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) :

    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)

    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)

    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)

    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

    65

def index (request) :

    66

    """

    67

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

    68

    """

    69

    70

    return templates.render_to_response("index",

    71

        req             = request,

    72

    )

    73

    74

# XXX: fix this namespace crap

    75

@preferences.handler()

    76

def preferences_ (request) :

    77

    """

    78

        Preferences editor

    79

    """

    80

    81

    # POST?

    82

    if request.is_post() :

    83

        # update any modified preferences

    84

        for pref in preferences.pref_list :

    85

            # get+parse new POST'd value

    86

            # XXX: this doesn't postprocess

    87

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

    88

    89

            # update if changed

    90

            if new_value != request.prefs[pref] :

    91

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

    92

    93

    # render

    94

    return templates.render_to_response("preferences",

    95

        req             = request,

    96

        prefs           = request.prefs,

    97

        preferences     = prefs,

    98

        timezones       = pytz.common_timezones,

    99

    )

   100

   101

def channel_select (request, channel) :

   102

    """

   103

        Redirect to the appropriate channel_view

   104

    """

   105

   106

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

   107

   108

@preferences.handler(prefs.formatter)

   109

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

   110

    """

   111

        The main channel view page, displaying the most recent lines

   112

    """

   113

   114

    # get latest events

   115

    lines = channel.source.get_latest(count)

   116

   117

    # type?

   118

    if type :

   119

        # other format

   120

        return _render_type(request, channel, lines, type)

   121

   122

    else :

   123

        # format HTML

   124

        lines = formatter.format_html(lines)

   125

   126

        # render page

   127

        return templates.render_to_response("channel_last",

   128

            req             = request,

   129

            prefs           = request.prefs,

   130

            channel         = channel,

   131

            count           = count,

   132

            lines           = lines,

   133

        )

   134

   135

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

   136

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

   137

    """

   138

        Display channel_date for specific UTC timestamp

   139

    """

   140

   141

    # convert timestamp to user's timezone

   142

    timestamp = timestamp.astimezone(timezone)

   143

   144

    # get correct day's correct page of lines

   145

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

   146

   147

    # type?

   148

    if type :

   149

        # special type

   150

        return _render_type(request, channel, lines, type)

   151

   152

    else :

   153

        # format HTML

   154

        lines = formatter.format_html(lines)

   155

   156

        # render

   157

        return templates.render_to_response("channel_date",

   158

            req             = request,

   159

            prefs           = request.prefs,

   160

            channel         = channel,

   161

            date            = timestamp,

   162

            page            = page,

   163

            count           = count,

   164

            max             = max,

   165

            lines           = lines,

   166

        )

   167

   168

@preferences.handler(prefs.timezone)

   169

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

   170

    """

   171

        Display a list of avilable logs for some month

   172

    """

   173

   174

    # current date as default

   175

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

   176

   177

    # target year/month

   178

    target = timezone.localize(datetime.datetime(

   179

        year    = year if year else now.year,

   180

        month   = month if month else now.month,

   181

        day     = 1

   182

    ))

   183

   184

    # get set of days available

   185

    days = set(channel.source.get_month_days(target))

   186

   187

    # display calendar

   188

    return templates.render_to_response("channel_calendar",

   189

        req             = request,

   190

        prefs           = request.prefs,

   191

        channel         = channel,

   192

        calendar        = calendar.Calendar(),

   193

        month           = target.date(),

   194

        days            = days,

   195

    )

   196

   197

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

   198

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

   199

    """

   200

        Display all log data for the given date

   201

    """

   202

   203

    # fix date timezone

   205

   206

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

   207

    if page :

   208

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

   209

   210

    else :

   211

        lines = channel.source.get_date(date)

   212

        max = None

   213

   214

    # type?

   215

    if type :

   216

        # special type

   217

        return _render_type(request, channel, lines, type)

   218

   219

    else :

   220

        # lines

   221

        lines = formatter.format_html(lines)

   222

   223

        # render page

   224

        return templates.render_to_response("channel_date",

   225

            req             = request,

   226

            prefs           = request.prefs,

   227

            channel         = channel,

   228

            date            = date,

   229

            page            = page,

   230

            count           = count,

   231

            max             = max,

   232

            lines           = lines,

   237

        )

   238

   239

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

   240

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

   241

    """

   242

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

   243

    """

   244

   245

    # calculate skip offset from page/count

   246

    skip = (page - 1) * count

   247

   248

    # got a search query?

   249

    if q :

   250

        try :

   251

            # do search

   252

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

   253

   254

            # update max?

   255

            if max and page > max :

   256

                max = page

   257

   258

        except log_search.NoResultsFound :

   259

            # no results

   260

            lines = None

   261

   262

    else :

   263

        # just display the search form

   264

        lines = None

   265

   266

    # type?

   267

    if type and lines :

   268

        # special type

   269

        return _render_type(request, channel, lines, type)

   270

   271

    else :

   272

        # format lines to HTML if any

   273

        if lines :

   274

            # format

   275

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

   276

   277

        # render page

   278

        return templates.render_to_response("channel_search",

   279

            req             = request,

   280

            prefs           = request.prefs,

   281

            channel         = channel,

   282

            search_query    = q,

   283

            count           = count,

   284

            page            = page,

   285

            skip            = skip,

   286

            max             = max,

   287

            lines           = lines,

   288

        )

   289