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(config.LOG_CHANNELS, config.SEARCH_INDEX_PATH, '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, type=None) :

    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

    # we can render in various modes...

    80

    if not type :

    81

        # normal HTML

    82

        lines = formatter.format_html(lines)

    83

    84

        return templates.render_to_response("channel_last",

    85

            req             = request,

    86

            prefs           = request.prefs,

    87

            channel         = channel,

    88

            count           = count,

    89

            lines           = lines,

    90

        )

    91

    92

    elif type == 'txt' :

    93

        # plaintext

    94

        lines = formatter.format_txt(lines)

    95

    96

        # build data

    97

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

    98

    99

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

   100

   101

    elif type == 'png' :

   102

        # PNG image

   103

        png_data = formatter.format_png(lines)

   104

   105

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

   106

   107

    elif type == 'rss' :

   108

        # RSS feed

   109

        rss_data = formatter.format_rss(lines)

   110

   111

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

   112

   113

    else :

   114

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

   115

   116

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

   117

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

   118

    """

   119

        Display channel_date for specific UTC timestamp

   120

    """

   121

   122

    # convert timestamp to user's timezone

   123

    timestamp = timestamp.astimezone(timezone)

   124

   125

    # get correct day's correct page of lines

   126

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

   127

   128

    # lines

   129

    lines = formatter.format_html(lines)

   130

   131

    # render

   132

    return templates.render_to_response("channel_date",

   133

        req             = request,

   134

        prefs           = request.prefs,

   135

        channel         = channel,

   136

        date            = timestamp,

   137

        page            = page,

   138

        count           = count,

   139

        max             = max,

   140

        lines           = lines,

   141

    )

   142

   143

@preferences.handler(prefs.timezone)

   144

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

   145

    """

   146

        Display a list of avilable logs for some month

   147

    """

   148

   149

    # current date as default

   150

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

   151

   152

    # target year/month

   153

    target = timezone.localize(datetime.datetime(

   154

        year    = year if year else now.year,

   155

        month   = month if month else now.month,

   156

        day     = 1

   157

    ))

   158

   159

    # get set of days available

   160

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

   161

   162

    # display calendar

   163

    return templates.render_to_response("channel_calendar",

   164

        req             = request,

   165

        prefs           = request.prefs,

   166

        channel         = channel,

   167

        calendar        = calendar.Calendar(),

   168

        month           = target.date(),

   169

        days            = days,

   170

    )

   171

   172

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

   173

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

   174

    """

   175

        Display all log data for the given date

   176

    """

   177

   178

    # fix date timezone

   179

    date = date.replace(tzinfo=timezone)

   180

   181

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

   182

    if page :

   183

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

   184

   185

    else :

   186

        lines = channel.source.get_date(date)

   187

        max = None

   188

   189

    # lines

   190

    lines = formatter.format_html(lines)

   191

   192

    # render

   193

    return templates.render_to_response("channel_date",

   194

        req             = request,

   195

        prefs           = request.prefs,

   196

        channel         = channel,

   197

        date            = date,

   198

        page            = page,

   199

        count           = count,

   200

        max             = max,

   201

        lines           = lines,

   202

    )

   203

   204

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

   205

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

   206

    """

   207

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

   208

    """

   209

   210

    # calculate skip offset from page/count

   211

    skip = (page - 1) * count

   212

   213

    # got a search query?

   214

    if q :

   215

        try :

   216

            # do search

   217

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

   218

   219

            # update max?

   220

            if max and page > max :

   221

                max = page

   222

   223

        except log_search.NoResultsFound :

   224

            # no lines

   225

            lines = None

   226

   227

        else :

   228

            # format

   229

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

   230

   231

    else :

   232

        lines = None

   233

   234

    # render

   235

    return templates.render_to_response("channel_search",

   236

        req             = request,

   237

        prefs           = request.prefs,

   238

        channel         = channel,

   239

        search_query    = q,

   240

        count           = count,

   241

        page            = page,

   242

        skip            = skip,

   243

        max             = max,

   244

        lines           = lines,

   245

    )

   246