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

def index (request) :

    21

    """

    22

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

    23

    """

    24

    25

    return templates.render_to_response("index",

    26

        req             = request,

    27

    )

    28

    29

# XXX: fix this namespace crap

    30

@preferences.handler()

    31

def preferences_ (request) :

    32

    """

    33

        Preferences editor

    34

    """

    35

    36

    # POST?

    37

    if request.is_post() :

    38

        # update any modified preferences

    39

        for pref in preferences.pref_list :

    40

            # get+parse new POST'd value

    41

            # XXX: this doesn't postprocess

    42

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

    43

    44

            # update if changed

    45

            if new_value != request.prefs[pref] :

    46

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

    47

    48

    # render

    49

    return templates.render_to_response("preferences",

    50

        req             = request,

    51

        prefs           = request.prefs,

    52

        preferences     = prefs,

    53

        timezones       = pytz.common_timezones,

    54

    )

    55

    56

def channel_select (request, channel) :

    57

    """

    58

        Redirect to the appropriate channel_view

    59

    """

    60

    61

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

    62

    63

@preferences.handler(prefs.formatter)

    64

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

    65

    """

    66

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

    67

    """

    68

    69

    # get latest events

    70

    lines = channel.source.get_latest(count)

    71

    72

    # lines

    73

    lines = formatter.format_html(lines)

    74

    75

    return templates.render_to_response("channel_view",

    76

        req             = request,

    77

        prefs           = request.prefs,

    78

        channel         = channel,

    79

        count           = count,

    80

        lines           = lines,

    81

    )

    82

    83

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

    84

    """

    85

        Display the last x lines of channel messages in various formats

    86

    """

    87

    88

    if format == 'txt' :

    89

        # XXX: formatting

    90

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

    91

         pass

    92

    93

    elif format == 'html' :

    94

        pass

    95

    96

    else :

    97

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

    98

    99

@preferences.handler(prefs.timezone)

   100

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

   101

    """

   102

        Display a list of avilable logs for some month

   103

    """

   104

   105

    # current date as default

   106

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

   107

   108

    # target year/month

   109

    target = timezone.localize(datetime.datetime(

   110

        year    = year if year else now.year,

   111

        month   = month if month else now.month,

   112

        day     = 1

   113

    ))

   114

   115

    # get set of days available

   116

    days = channel.source.get_month_days(target)

   117

   118

    # display calendar

   119

    return templates.render_to_response("channel_calendar",

   120

        req             = request,

   121

        prefs           = request.prefs,

   122

        channel         = channel,

   123

        calendar        = calendar.Calendar(),

   124

        month           = target.date(),

   125

        days            = days,

   126

    )

   127

   128

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

   129

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

   130

    """

   131

        Display all log data for the given date

   132

    """

   133

   134

    # fix date timezone

   135

    date = date.replace(tzinfo=timezone)

   136

   137

    # get latest events

   138

    lines = channel.source.get_date(date)

   139

   140

    # lines

   141

    lines = formatter.format_html(lines)

   142

   144

    return templates.render_to_response("channel_date",

   145

        req             = request,

   146

        prefs           = request.prefs,

   147

        channel         = channel,

   148

        date            = date,

   149

        lines           = lines,

   150

    )

   151

   154

    """

   155

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

   156

    """

   157

   162