1

"""

     2

    Our URL action handlers

     3

"""

     4

     5

import datetime, calendar, pytz

     6

     7

from qmsk.web import http, template

     8

     9

import urls, channels, helpers

    10

import preferences as prefs

    11

from preferences import preferences

    12

import config, log_search

    13

    14

# load templates from here

    15

templates = template.TemplateLoader("templates",

    16

    _helper_class   = helpers.Helpers,

    17

    urls            = urls,

    18

    channel_list    = config.LOG_CHANNELS,

    19

    config          = config,

    20

)

    21

    22

# return a http.Response for the given text in the given format

    23

def _render_type (request, channel, lines, type, full_timestamps=False) :

    24

    """

    25

        Render the given LogLines as a http.Response in the given format, which is one of:

    26

            html    - XXX: not supported

    27

            txt     - Plaintext

    28

            png     - PNG image

    29

            rss     - RSS feed

    30

    """

    31

    32

    # load related preferences

    33

    formatter = request.prefs['formatter']

    34

    35

    # we can render in various modes...

    36

    if type in ('html', None) :

    37

        xxx

    38

    39

    elif type == 'txt' :

    40

        # plaintext

    41

        lines = formatter.format_txt(lines, full_timestamps)

    42

    43

        # build data

    44

        data = '\n'.join(data for line, data in lines)

    45

    46

        return http.Response(data, 'text/plain')

    47

    48

    elif type == 'png' :

    49

        # PNG image

    50

        png_data = formatter.format_png(lines, full_timestamps)

    51

    52

        return http.Response(png_data, 'image/png', charset=None)

    53

    54

    elif type == 'rss' :

    55

        # RSS feed

    56

        rss_data = formatter.format_rss(lines, full_timestamps)

    57

    58

        # XXX: fix to render as unicode?

    59

        return http.Response(rss_data, 'application/rss+xml', charset=None)

    60

    61

    else :

    62

        raise http.ResponseError("Unrecognized type: %r" % (type, ))

    63

    64

def _render_date (request, channel, date, lines, type, count, page, max) :

    65

    """

    66

        Render the given LogLines as a http.Response for channel_date

    67

    """

    68

    69

    # type?

    70

    if type :

    71

        # special type

    72

        return _render_type(request, channel, lines, type)

    73

    74

    else :

    75

        # format HTML

    76

        lines = request.prefs['formatter'].format_html(lines)

    77

    78

        # render

    79

        return templates.render_to_response("channel_date",

    80

            req             = request,

    81

            prefs           = request.prefs,

    82

            channel         = channel,

    83

            date            = date,

    84

            count           = count,

    85

            page            = page,

    86

            max             = max,

    87

            lines           = lines,

    88

    89

            # for prev/next date

    90

            date_next       = channel.source.get_next_date(date),

    91

            date_prev       = channel.source.get_prev_date(date),

    92

        )

    93

    94

def index (request) :

    95

    """

    96

        The topmost index page, display a list of available channels, perhaps some general stats

    97

    """

    98

    99

    return templates.render_to_response("index",

   100

        req             = request,

   101

    )

   102

   103

# XXX: fix this namespace crap

   104

@preferences.handler()

   105

def preferences_ (request) :

   106

    """

   107

        Preferences editor

   108

    """

   109

   110

    # POST?

   111

    if request.is_post() :

   112

        # update any modified preferences

   113

        for pref in preferences.pref_list :

   114

            # get+parse new POST'd value

   115

            # XXX: this doesn't postprocess

   116

            new_value = pref.parse(request.get_post(pref.name))

   117

   118

            # update if changed

   119

            if new_value != request.prefs[pref] :

   120

                request.prefs.set(pref.name, new_value)

   121

   122

    # render

   123

    return templates.render_to_response("preferences",

   124

        req             = request,

   125

        prefs           = request.prefs,

   126

        preferences     = prefs,

   127

        timezones       = pytz.common_timezones,

   128

    )

   129

   130

def channel_select (request, channel) :

   131

    """

   132

        Redirect to the appropriate channel_view

   133

    """

   134

   135

    return http.Redirect(urls.channel.build(request, channel=channel))

   136

   137

@preferences.handler(prefs.formatter)

   138

def channel_last (request, channel, count, formatter, type=None) :

   139

    """

   140

        The main channel view page, displaying the most recent lines

   141

    """

   142

   143

    # get latest events

   144

    lines = channel.source.get_latest(count)

   145

   146

    # type?

   147

    if type :

   148

        # other format

   149

        return _render_type(request, channel, lines, type)

   150

   151

    else :

   152

        # format HTML

   153

        lines = formatter.format_html(lines)

   154

   155

        # render page

   156

        return templates.render_to_response("channel_last",

   157

            req             = request,

   158

            prefs           = request.prefs,

   159

            channel         = channel,

   160

            count           = count,

   161

            lines           = lines,

   162

        )

   163

   164

@preferences.handler(prefs.formatter, prefs.timezone, prefs.count)

   165

def channel_link (request, channel, timestamp, formatter, timezone, count, type=None) :

   166

    """

   167

        Display channel_date for specific UTC timestamp

   168

    """

   169

   170

    # convert timestamp to user's timezone

   171

    timestamp = timestamp.astimezone(timezone)

   172

   173

    # get correct day's correct page of lines

   174

    page, max, lines = channel.source.get_date_paged(timestamp, count)

   175

   176

    # render channel_date

   177

    return _render_date (request, channel, timestamp, lines, type, count, page, max)

   178

   179

@preferences.handler(prefs.timezone)

   180

def channel_calendar (request, channel, year, month, timezone) :

   181

    """

   182

        Display a list of avilable logs for some month

   183

    """

   184

   185

    # current date as default

   186

    now = timezone.localize(datetime.datetime.now())

   187

   188

    # target year/month

   189

    target = timezone.localize(datetime.datetime(

   190

        year    = year if year else now.year,

   191

        month   = month if month else now.month,

   192

        day     = 1

   193

    ))

   194

   195

    # display calendar

   196

    return templates.render_to_response("channel_calendar",

   197

        req             = request,

   198

        prefs           = request.prefs,

   199

        channel         = channel,

   200

        month           = target,

   201

    )

   202

   203

@preferences.handler(prefs.count, prefs.timezone)

   204

def channel_date (request, channel, date, count, timezone, page=1, type=None) :

   205

    """

   206

        Display all log data for the given date

   207

    """

   208

   209

    # convert date to user's timezone

   210

    date = timezone.localize(date)

   211

   212

#    print

   213

#    print "channel_date: date=%s" % date

   214

   215

    # get that day's events, either paged or not

   216

    if page :

   217

        page, max, lines = channel.source.get_date_paged(date, count, page)

   218

   219

    else :

   220

        lines = channel.source.get_date(date)

   221

        max = None

   222

   223

    # render channel_date

   224

    return _render_date (request, channel, date, lines, type, count, page, max)

   225

   226

@preferences.handler(prefs.formatter, prefs.count)

   227

def channel_search (request, channel, formatter, count, q=None, page=1, max=1, type=None, t=None) :

   228

    """

   229

        Display the search form for the channel for GET, or do the search for POST.

   230

    """

   231

   232

    # calculate skip offset from page/count

   233

    skip = (page - 1) * count

   234

   235

    # got a search query?

   236

    if q :

   237

        # attribute targets

   238

        targets = dict(('search_%s' % target, True) for target in t if target in ('msg', 'nick')) if t else {}

   239

   240

        try :

   241

            # do search

   242

            lines = log_search.get_index().search_simple(channel, q, count, skip, **targets)

   243

   244

            # update max?

   245

            if max and page > max :

   246

                max = page

   247

   248

        except log_search.NoResultsFound :

   249

            # no results

   250

            lines = None

   251

   252

    else :

   253

        # just display the search form

   254

        lines = None

   255

   256

    # type?

   257

    if type and lines :

   258

        # special type

   259

        return _render_type(request, channel, lines, type, full_timestamps=True)

   260

   261

    else :

   262

        # format lines to HTML if any

   263

        if lines :

   264

            # format

   265

            lines = formatter.format_html(lines, full_timestamps=True)

   266

   267

        # render page

   268

        return templates.render_to_response("channel_search",

   269

            req             = request,

   270

            prefs           = request.prefs,

   271

            channel         = channel,

   272

            search_query    = q,

   273

            search_targets  = t,

   274

            count           = count,

   275

            page            = page,

   276

            skip            = skip,

   277

            max             = max,

   278

            lines           = lines,

   279

        )

   280