1

"""

     2

    Handling user preferences

     3

"""

     4

     5

import functools

     6

import Cookie

     7

     8

from qmsk.web import urltree

     9

    10

class Preference (urltree.URLType) :

    11

    """

    12

        A specific preference

    13

    """

    14

    15

    # the name to use

    16

    name = None

    17

    18

    # the default value

    19

    default = None

    20

    21

    def process (self, preferences, value) :

    22

        """

    23

            Post-process this preference value. This can access the values of other preferences or the request via

    24

            the given RequestPreferences. Note that the other items will not be post-processed here.

    25

    26

            Defaults to just return value.

    27

        """

    28

    29

        return value

    30

    31

class RequestPreferences (object) :

    32

    """

    33

        Represents the specific preferences for some request

    34

    """

    35

    36

    def __init__ (self, preferences, request, value_map=None) :

    37

        """

    38

            Initialize with the given Preferences object, http Request, and list of mapping of raw preference values

    39

        """

    40

    41

        # store

    42

        self.preferences = preferences

    43

        self.request = request

    44

    45

        # initialize

    46

        self.values = {}

    47

        self.set_cookies = {}

    48

    49

        # load preferences

    50

        for pref in preferences.pref_list :

    51

            # got a value for it?

    52

            if value_map and pref.name in value_map :

    53

                # get value

    54

                value = value_map[pref.name]

    55

    56

                # parse it

    57

                value = pref.parse(value)

    58

    59

            else :

    60

                # use default value

    61

                value = pref.default

    62

    63

            # add

    64

            self.values[pref.name] = value

    65

    66

        # then post-process using the Preferences

    67

        self.values = dict(

    68

            (name, self.preferences.pref_map[name].process(self, value)) for name, value in self.values.iteritems()

    69

        )

    70

    71

    def get (self, pref) :

    72

        """

    73

            Return the value for the given Preference, or preference name

    74

        """

    75

    76

        # Preference -> name

    77

        if isinstance(pref, Preference) :

    78

            pref = pref.name

    79

    80

        # look up

    81

        return self.values[pref]

    82

    83

    # support dict-access

    84

    __getitem__ = get

    85

    86

    def set (self, name, value_obj) :

    87

        """

    88

            Set a new value for the given preference

    89

        """

    90

    91

        # sanity-check to make sure we're not setting it twice...

    92

        assert name not in self.set_cookies

    93

    94

        # encode using the Preference object

    95

        value_str = self.preferences.pref_map[name].build(value_obj)

    96

    97

        # update in our dict

    98

        self.values[name] = value_obj

    99

   100

        # add to set_cookies

   101

        self.set_cookies[name] = value_str

   102

   103

class Preferences (object) :

   104

    """

   105

        Handle user preferences using cookies

   106

    """

   107

   108

    def __init__ (self, pref_list) :

   109

        """

   110

            Use the given list of Preference objects

   111

        """

   112

   113

        # store

   114

        self.pref_list = pref_list

   115

   116

        # translate to mapping as well

   117

        self.pref_map = dict((pref.name, pref) for pref in pref_list)

   118

   119

    def load (self, request, ) :

   120

        """

   121

            Load the set of preferences for the given request, and return as a { name -> value } dict

   122

        """

   123

   124

        # the dict of values

   125

        values = {}

   126

   127

        # load the cookies

   128

        cookie_data = request.env.get('HTTP_COOKIE')

   129

   130

        # got any?

   131

        if cookie_data :

   132

            # parse into a SimpleCookie

   133

            cookies = Cookie.SimpleCookie(cookie_data)

   134

   135

            # update the the values

   136

            values.update((morsel.key, morsel.value) for morsel in cookies.itervalues())

   137

   138

        else :

   139

            cookies = None

   140

   141

        # apply any query parameters

   142

        for pref in self.pref_list :

   143

            # look for a query param

   144

            value = request.get_arg(pref.name)

   145

   146

            if value :

   147

                # override

   148

                values[pref.name] = value

   149

   150

        # build the RequestPreferences object

   151

        return cookies, RequestPreferences(self, request, values)

   152

   153

    def handler (self, *pref_list) :

   154

        """

   155

            Intended to be used as a decorator for a request handler, this will load the give Preferences and pass

   156

            them to the wrapped handler as keyword arguments, in addition to any others given.

   157

        """

   158

   159

        def _decorator (func) :

   160

            @functools.wraps(func)

   161

            def _handler (request, **args) :

   162

                # load preferences

   163

                cookies, prefs = self.load(request)

   164

   165

                # bind to request.prefs

   166

                # XXX: better way to do this? :/

   167

                request.prefs = prefs

   168

   169

                # update args with new ones

   170

                args.update(((pref.name, prefs.get(pref)) for pref in pref_list))

   171

   172

                # handle to get response

   173

                response = func(request, **args)

   174

   175

                # set cookies?

   176

                if prefs.set_cookies :

   177

                    if not cookies :

   178

                        cookies = Cookie.SimpleCookie('')

   179

   180

                    # update cookies

   181

                    for key, value in prefs.set_cookies.iteritems() :

   182

                        cookies[key] = value

   183

   184

                    # add headers

   185

                    for morsel in cookies.itervalues() :

   186

                        response.add_header('Set-cookie', morsel.OutputString())

   187

   188

                return response

   189

   190

            # return wrapped handler

   191

            return _handler

   192

   193

        # return decorator...

   194

        return _decorator

   195

   196

# now for our defined preferences....

   197

import pytz

   198

import config

   199

   200

class TimeFormat (urltree.URLStringType, Preference) :

   201

    """

   202

        Time format

   203

    """

   204

   205

    # set name

   206

    name = 'time_format'

   207

   208

    # default value

   209

    default = config.PREF_TIME_FMT_DEFAULT

   210

   211

class DateFormat (urltree.URLStringType, Preference) :

   212

    """

   213

        Date format

   214

    """

   215

   216

    # set name

   217

    name = 'date_format'

   218

   219

    # default value

   220

    default = config.PREF_DATE_FMT_DEFAULT

   221

   222

class Timezone (Preference) :

   223

    """

   224

        Timezone

   225

    """

   226

   227

    # set name

   228

    name = 'timezone'

   229

   230

    # default value is UTC...

   231

    default = config.PREF_TIMEZONE_DEFAULT

   232

   233

    def parse (self, name) :

   234

        """

   235

            tz_name -> pytz.timezone

   236

        """

   237

   238

        return pytz.timezone(name)

   239

   240

    def build (self, tz) :

   241

        """

   242

            pytz.timezone -> tz_name

   243

        """

   244

   245

        return tz.zone

   246

   247

class ImageFont (Preference) :

   248

    """

   249

        Font for ImageFormatter

   250

    """

   251

   252

    # set name

   253

    name = 'image_font'

   254

   255

    def __init__ (self, font_dict, default_name) :

   256

        """

   257

            Use the given { name: (path, title) } dict and default the given name

   258

        """

   259

   260

        self.font_dict = font_dict

   261

        self.default = self.parse(default_name)

   262

   263

    def parse (self, name) :

   264

        """

   265

            name -> (name, path, title)

   266

        """

   267

   268

        path, title = self.font_dict[name]

   269

   270

        return name, path, title

   271

   272

    def build (self, font_info) :

   273

        """

   274

            (name, path, title) -> name

   275

        """

   276

   277

        name, path, title = font_info

   278

   279

        return name

   280

   281

class ImageFontSize (urltree.URLIntegerType, Preference) :

   282

    # set name, default

   283

    name = 'image_font_size'

   284

    default = config.PREF_IMAGE_FONT_SIZE_DEFAULT

   285

   286

    # XXX: params

   287

   288

class Formatter (Preference) :

   289

    """

   290

        LogFormatter to use

   291

    """

   292

   293

    # set name

   294

    name = 'formatter'

   295

   296

    def __init__ (self, formatters, default) :

   297

        """

   298

            Use the given { name -> class LogFormatter } dict and default (a LogFormatter class)

   299

        """

   300

   301

        self.formatters = formatters

   302

        self.default = default

   303

   304

    def parse (self, fmt_name) :

   305

        """

   306

            fmt_name -> class LogFormatter

   307

        """

   308

   309

        return self.formatters[fmt_name]

   310

   311

    def build (self, fmt_cls) :

   312

        """

   313

            class LogFormatter -> fmt_name

   314

        """

   315

   316

        return fmt_cls.name

   317

   318

    def process (self, prefs, fmt_cls) :

   319

        """

   320

            class LogFormatter -> LogFormatter(tz, time_fmt, image_font.path)

   321

        """

   322

   323

        font_name, font_path, font_title = prefs[image_font]

   324

        font_size = prefs[image_font_size]

   325

   326

        return fmt_cls(prefs[timezone], prefs[time_format], font_path, font_size)

   327

   328

class Count (urltree.URLIntegerType, Preference) :

   329

    """

   330

        Number of lines of log data to display per page

   331

    """

   332

   333

    # set name

   334

    name = "count"

   335

   336

    # default

   337

    default = config.PREF_COUNT_DEFAULT

   338

   339

    def __init__ (self) :

   340

        super(Count, self).__init__(allow_negative=False, allow_zero=False, max=config.PREF_COUNT_MAX)

   341

   342

# and then build the Preferences object

   343

time_format     = TimeFormat()

   344

date_format     = DateFormat()

   345

timezone        = Timezone()

   346

image_font      = ImageFont(config.FORMATTER_IMAGE_FONTS, config.PREF_IMAGE_FONT_DEFAULT)

   347

image_font_size = ImageFontSize()

   348

formatter       = Formatter(config.LOG_FORMATTERS, config.PREF_FORMATTER_DEFAULT)

   349

count           = Count()

   350

   351

preferences = Preferences([

   352

    time_format,

   353

    date_format,

   354

    timezone,

   355

    image_font,

   356

    image_font_size,

   357

    formatter,

   358

    count,

   359

])

   360