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

    13

# load templates from here

    14

templates = template.TemplateLoader("templates",

    15

    _helper_class   = helpers.Helpers,

    16

    urls            = urls,

    17

    channel_list    = channels.channel_list,

    18

)

    19

    20

# our LogSearch thing

    21

# XXX: move elsewhere

    22

import log_search

    23

search_index = log_search.LogSearchIndex("logs/index", 'r')

    24

    25

def index (request) :

    26

    """

    27

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

    28

    """

    29

    30

    return templates.render_to_response("index",

    31

        req             = request,

    32

    )

    33

    34

# XXX: fix this namespace crap

    35

@preferences.handler()

    36

def preferences_ (request) :

    37

    """

    38

        Preferences editor

    39

    """

    40

    41

    # POST?

    42

    if request.is_post() :

    43

        # update any modified preferences

    44

        for pref in preferences.pref_list :

    45

            # get+parse new POST'd value

    46

            # XXX: this doesn't postprocess

    47

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

    48

    49

            # update if changed

    50

            if new_value != request.prefs[pref] :

    51

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

    52

    53

    # render

    54

    return templates.render_to_response("preferences",

    55

        req             = request,

    56

        prefs           = request.prefs,

    57

        preferences     = prefs,

    58

        timezones       = pytz.common_timezones,

    59

    )

    60

    61

def channel_select (request, channel) :

    62

    """

    63

        Redirect to the appropriate channel_view

    64

    """

    65

    66

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

    67

    68

@preferences.handler(prefs.formatter)

    69

def channel_last (request, channel, count, formatter) :

    70

    """

    71

        The main channel view page, displaying the most recent lines

    72

    """

    73

    74

    # get latest events

    75

    lines = channel.source.get_latest(count)

    76

    77

    # lines

    78

    lines = formatter.format_html(lines)

    79

    80

    return templates.render_to_response("channel_last",

    81

        req             = request,

    82

        prefs           = request.prefs,

    83

        channel         = channel,

    84

        count           = count,

    85

        lines           = lines,

    86

    )

    87

    88

@preferences.handler(prefs.timezone)

    89

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

    90

    """

    91

        Display a list of avilable logs for some month

    92

    """

    93

    94

    # current date as default

    95

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

    96

    97

    # target year/month

    98

    target = timezone.localize(datetime.datetime(

    99

        year    = year if year else now.year,

   100

        month   = month if month else now.month,

   101

        day     = 1

   102

    ))

   103

   104

    # get set of days available

   105

    days = channel.source.get_month_days(target)

   106

   107

    # display calendar

   108

    return templates.render_to_response("channel_calendar",

   109

        req             = request,

   110

        prefs           = request.prefs,

   111

        channel         = channel,

   112

        calendar        = calendar.Calendar(),

   113

        month           = target.date(),

   114

        days            = days,

   115

    )

   116

   117

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

   118

def channel_date (request, channel, date, formatter, timezone) :

   119

    """

   120

        Display all log data for the given date

   121

    """

   122

   123

    # fix date timezone

   124

    date = date.replace(tzinfo=timezone)

   125

   126

    # get latest events

   127

    lines = channel.source.get_date(date)

   128

   129

    # lines

   130

    lines = formatter.format_html(lines)

   131

   132

    # render

   133

    return templates.render_to_response("channel_date",

   134

        req             = request,

   135

        prefs           = request.prefs,

   136

        channel         = channel,

   137

        date            = date,

   138

        lines           = lines,

   139

    )

   140

   141

@preferences.handler(prefs.formatter)

   142

def channel_search (request, channel, formatter, q=None, count=None, skip=None) :

   143

    """

   144

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

   145

    """

   146

   147

    # got a search query?

   148

    if q :

   149

        # do search

   150

        lines = search_index.search_simple(channel, q, count, skip)

   151

   152

        # format

   153

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

   154

   155

    else :

   156

        lines = None

   157

   158

    # render

   159

    return templates.render_to_response("channel_search",

   160

        req             = request,

   161

        prefs           = request.prefs,

   162

        channel         = channel,

   163

        search_query    = q,

   164

        lines           = lines,

   165

    )

   166

   167

   168