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

    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

# our LogSearch thing

    23

# XXX: move elsewhere

    24

import log_search

    25

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

    26

    27

def index (request) :

    28

    """

    29

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

    30

    """

    31

    32

    return templates.render_to_response("index",

    33

        req             = request,

    34

    )

    35

    36

# XXX: fix this namespace crap

    37

@preferences.handler()

    38

def preferences_ (request) :

    39

    """

    40

        Preferences editor

    41

    """

    42

    43

    # POST?

    44

    if request.is_post() :

    45

        # update any modified preferences

    46

        for pref in preferences.pref_list :

    47

            # get+parse new POST'd value

    48

            # XXX: this doesn't postprocess

    49

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

    50

    51

            # update if changed

    52

            if new_value != request.prefs[pref] :

    53

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

    54

    55

    # render

    56

    return templates.render_to_response("preferences",

    57

        req             = request,

    58

        prefs           = request.prefs,

    59

        preferences     = prefs,

    60

        timezones       = pytz.common_timezones,

    61

    )

    62

    63

def channel_select (request, channel) :

    64

    """

    65

        Redirect to the appropriate channel_view

    66

    """

    67

    68

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

    69

    70

@preferences.handler(prefs.formatter)

    71

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

    72

    """

    73

        The main channel view page, displaying the most recent lines

    74

    """

    75

    76

    # get latest events

    77

    lines = channel.source.get_latest(count)

    78

    79

    # lines

    80

    lines = formatter.format_html(lines)

    81

    82

    return templates.render_to_response("channel_last",

    83

        req             = request,

    84

        prefs           = request.prefs,

    85

        channel         = channel,

    86

        count           = count,

    87

        lines           = lines,

    88

    )

    89

    90

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

    91

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

    92

    """

    93

        Display channel_date for specific UTC timestamp

    94

    """

    95

    96

    # convert timestamp to user's timezone

    97

    timestamp = timestamp.astimezone(timezone)

    98

    99

    # get latest events

   100

    lines = channel.source.get_date(timestamp)

   101

   102

    # lines

   103

    lines = formatter.format_html(lines)

   104

   105

    # render

   106

    return templates.render_to_response("channel_date",

   107

        req             = request,

   108

        prefs           = request.prefs,

   109

        channel         = channel,

   110

        date            = timestamp,

   111

        lines           = lines,

   112

    )

   113

   114

@preferences.handler(prefs.timezone)

   115

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

   116

    """

   117

        Display a list of avilable logs for some month

   118

    """

   119

   120

    # current date as default

   121

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

   122

   123

    # target year/month

   124

    target = timezone.localize(datetime.datetime(

   125

        year    = year if year else now.year,

   126

        month   = month if month else now.month,

   127

        day     = 1

   128

    ))

   129

   130

    # get set of days available

   131

    days = channel.source.get_month_days(target)

   132

   133

    # display calendar

   134

    return templates.render_to_response("channel_calendar",

   135

        req             = request,

   136

        prefs           = request.prefs,

   137

        channel         = channel,

   138

        calendar        = calendar.Calendar(),

   139

        month           = target.date(),

   140

        days            = days,

   141

    )

   142

   143

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

   144

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

   145

    """

   146

        Display all log data for the given date

   147

    """

   148

   149

    # fix date timezone

   150

    date = date.replace(tzinfo=timezone)

   151

   152

    # get latest events

   153

    lines = channel.source.get_date(date)

   154

   155

    # lines

   156

    lines = formatter.format_html(lines)

   157

   158

    # render

   159

    return templates.render_to_response("channel_date",

   160

        req             = request,

   161

        prefs           = request.prefs,

   162

        channel         = channel,

   163

        date            = date,

   164

        lines           = lines,

   165

    )

   166

   167

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

   169

    """

   171

    """

   172

   176

    # got a search query?

   177

    if q :

   178

        try :

   179

            # do search

   180

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

   185

   186

        except log_search.NoResultsFound :

   187

            # no lines

   188

            lines = None

   189

   190

        else :

   191

            # format

   192

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

   193

   194

    else :

   195

        lines = None

   196

   197

    # render

   198

    return templates.render_to_response("channel_search",

   199

        req             = request,

   200

        prefs           = request.prefs,

   201

        channel         = channel,

   202

        search_query    = q,

   203

        count           = count,

   205

        skip            = skip,

   206

        max             = max,

   207

        lines           = lines,

   208

    )

   209