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_view.build(request, channel=channel))

    67

    68

@preferences.handler(prefs.formatter)

    69

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

    70

    """

    71

        The main channel view page, display the most important info, and all requisite links

    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_view",

    81

        req             = request,

    82

        prefs           = request.prefs,

    83

        channel         = channel,

    84

        count           = count,

    85

        lines           = lines,

    86

    )

    87

    88

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

    89

    """

    90

        Display the last x lines of channel messages in various formats

    91

    """

    92

    93

    if format == 'txt' :

    94

        # XXX: formatting

    95

#        return http.Response('\n'.join(str(channel.source.get_latest(count))), 'text/plain')

    96

         pass

    97

    98

    elif format == 'html' :

    99

        pass

   100

   101

    else :

   102

        raise http.ResponseError("Unknown filetype %r" % format)

   103

   104

@preferences.handler(prefs.timezone)

   105

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

   106

    """

   107

        Display a list of avilable logs for some month

   108

    """

   109

   110

    # current date as default

   111

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

   112

   113

    # target year/month

   114

    target = timezone.localize(datetime.datetime(

   115

        year    = year if year else now.year,

   116

        month   = month if month else now.month,

   117

        day     = 1

   118

    ))

   119

   120

    # get set of days available

   121

    days = channel.source.get_month_days(target)

   122

   123

    # display calendar

   124

    return templates.render_to_response("channel_calendar",

   125

        req             = request,

   126

        prefs           = request.prefs,

   127

        channel         = channel,

   128

        calendar        = calendar.Calendar(),

   129

        month           = target.date(),

   130

        days            = days,

   131

    )

   132

   133

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

   134

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

   135

    """

   136

        Display all log data for the given date

   137

    """

   138

   139

    # fix date timezone

   140

    date = date.replace(tzinfo=timezone)

   141

   142

    # get latest events

   143

    lines = channel.source.get_date(date)

   144

   145

    # lines

   146

    lines = formatter.format_html(lines)

   147

   148

    # render

   149

    return templates.render_to_response("channel_date",

   150

        req             = request,

   151

        prefs           = request.prefs,

   152

        channel         = channel,

   153

        date            = date,

   154

        lines           = lines,

   155

    )

   156

   157

@preferences.handler(prefs.formatter)

   159

    """

   160

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

   161

    """

   162

   163

    # got a search query?

   164

    if q :

   165

        # do search

   167

   168

        # format

   169

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

   170

   171

    else :

   172

        lines = None

   173

   174

    # render

   175

    return templates.render_to_response("channel_search",

   176

        req             = request,

   177

        prefs           = request.prefs,

   178

        channel         = channel,

   179

        search_query    = q,

   180

        lines           = lines,

   181

    )

   182

   183

   184