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

def index (request) :

    23

    """

    24

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

    25

    """

    26

    27

    return templates.render_to_response("index",

    28

        req             = request,

    29

    )

    30

    31

# XXX: fix this namespace crap

    32

@preferences.handler()

    33

def preferences_ (request) :

    34

    """

    35

        Preferences editor

    36

    """

    37

    38

    # POST?

    39

    if request.is_post() :

    40

        # update any modified preferences

    41

        for pref in preferences.pref_list :

    42

            # get+parse new POST'd value

    43

            # XXX: this doesn't postprocess

    44

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

    45

    46

            # update if changed

    47

            if new_value != request.prefs[pref] :

    48

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

    49

    50

    # render

    51

    return templates.render_to_response("preferences",

    52

        req             = request,

    53

        prefs           = request.prefs,

    54

        preferences     = prefs,

    55

        timezones       = pytz.common_timezones,

    56

    )

    57

    58

def channel_select (request, channel) :

    59

    """

    60

        Redirect to the appropriate channel_view

    61

    """

    62

    63

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

    64

    65

@preferences.handler(prefs.formatter)

    66

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

    67

    """

    68

        The main channel view page, displaying the most recent lines

    69

    """

    70

    71

    # get latest events

    72

    lines = channel.source.get_latest(count)

    73

    74

    # we can render in various modes...

    75

    if not type :

    76

        # normal HTML

    77

        lines = formatter.format_html(lines)

    78

    79

        return templates.render_to_response("channel_last",

    80

            req             = request,

    81

            prefs           = request.prefs,

    82

            channel         = channel,

    83

            count           = count,

    84

            lines           = lines,

    85

        )

    86

    87

    elif type == 'txt' :

    88

        # plaintext

    89

        lines = formatter.format_txt(lines)

    90

    91

        # build data

    92

        data = '\n'.join(data for line, data in lines)

    93

    94

        return http.Response(data, 'text/plain')

    95

    96

    elif type == 'png' :

    97

        # PNG image

    98

        png_data = formatter.format_png(lines)

    99

   100

        return http.Response(png_data, 'image/png', charset=None)

   101

   102

    elif type == 'rss' :

   103

        # RSS feed

   104

        rss_data = formatter.format_rss(lines)

   105

   106

        return http.Response(rss_data, 'application/rss+xml')

   107

   108

    else :

   109

        raise http.ResponseError("Unrecognized type: %r" % (type, ))

   110

   111

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

   112

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

   113

    """

   114

        Display channel_date for specific UTC timestamp

   115

    """

   116

   117

    # convert timestamp to user's timezone

   118

    timestamp = timestamp.astimezone(timezone)

   119

   120

    # get correct day's correct page of lines

   121

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

   122

   123

    # lines

   124

    lines = formatter.format_html(lines)

   125

   126

    # render

   127

    return templates.render_to_response("channel_date",

   128

        req             = request,

   129

        prefs           = request.prefs,

   130

        channel         = channel,

   131

        date            = timestamp,

   132

        page            = page,

   133

        count           = count,

   134

        max             = max,

   135

        lines           = lines,

   136

    )

   137

   138

@preferences.handler(prefs.timezone)

   139

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

   140

    """

   141

        Display a list of avilable logs for some month

   142

    """

   143

   144

    # current date as default

   145

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

   146

   147

    # target year/month

   148

    target = timezone.localize(datetime.datetime(

   149

        year    = year if year else now.year,

   150

        month   = month if month else now.month,

   151

        day     = 1

   152

    ))

   153

   154

    # get set of days available

   155

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

   156

   157

    # display calendar

   158

    return templates.render_to_response("channel_calendar",

   159

        req             = request,

   160

        prefs           = request.prefs,

   161

        channel         = channel,

   162

        calendar        = calendar.Calendar(),

   163

        month           = target.date(),

   164

        days            = days,

   165

    )

   166

   167

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

   168

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

   169

    """

   170

        Display all log data for the given date

   171

    """

   172

   173

    # fix date timezone

   174

    date = date.replace(tzinfo=timezone)

   175

   176

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

   177

    if page :

   178

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

   179

   180

    else :

   181

        lines = channel.source.get_date(date)

   182

        max = None

   183

   184

    # lines

   185

    lines = formatter.format_html(lines)

   186

   187

    # render

   188

    return templates.render_to_response("channel_date",

   189

        req             = request,

   190

        prefs           = request.prefs,

   191

        channel         = channel,

   192

        date            = date,

   193

        page            = page,

   194

        count           = count,

   195

        max             = max,

   196

        lines           = lines,

   197

    )

   198

   199

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

   200

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

   201

    """

   202

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

   203

    """

   204

   205

    # calculate skip offset from page/count

   206

    skip = (page - 1) * count

   207

   208

    # got a search query?

   209

    if q :

   210

        try :

   211

            # do search

   212

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

   213

   214

            # update max?

   215

            if max and page > max :

   216

                max = page

   217

   218

        except log_search.NoResultsFound :

   219

            # no lines

   220

            lines = None

   221

   222

        else :

   223

            # format

   224

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

   225

   226

    else :

   227

        lines = None

   228

   229

    # render

   230

    return templates.render_to_response("channel_search",

   231

        req             = request,

   232

        prefs           = request.prefs,

   233

        channel         = channel,

   234

        search_query    = q,

   235

        count           = count,

   236

        page            = page,

   237

        skip            = skip,

   238

        max             = max,

   239

        lines           = lines,

   240

    )

   241