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

        )

    71

    def get (self, pref) :

    72

        """

    73

            Return the value for the given Preference

    74

        """

    75

    76

        return self.values[pref.name]

    81

    def set (self, name, value_obj) :

    82

        """

    83

            Set a new value for the given preference

    84

        """

    85

    86

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

    87

        assert name not in self.set_cookies

    88

    89

        # encode using the Preference object

    90

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

    91

    92

        # update in our dict

    93

        self.values[name] = value_obj

    94

    95

        # add to set_cookies

    96

        self.set_cookies[name] = value_str

    97

    98

class Preferences (object) :

    99

    """

   100

        Handle user preferences using cookies

   101

    """

   102

   103

    def __init__ (self, pref_list) :

   104

        """

   105

            Use the given list of Preference objects

   106

        """

   107

   108

        # store

   109

        self.pref_list = pref_list

   110

   111

        # translate to mapping as well

   112

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

   113

   114

    def load (self, request, ) :

   115

        """

   116

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

   117

        """

   118

   119

        # the dict of values

   120

        values = {}

   121

   122

        # load the cookies

   123

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

   124

   125

        # got any?

   126

        if cookie_data :

   127

            # parse into a SimpleCookie

   128

            cookies = Cookie.SimpleCookie(cookie_data)

   129

   130

            # update the the values

   131

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

   132

   133

        else :

   134

            cookies = None

   135

   136

        # apply any query parameters

   137

        for pref in self.pref_list :

   138

            # look for a query param

   139

            value = request.get_arg(pref.name)

   140

   141

            if value :

   142

                # override

   143

                values[pref.name] = value

   144

   145

        # build the RequestPreferences object

   146

        return cookies, RequestPreferences(self, request, values)

   147

   148

    def handler (self, *pref_list) :

   149

        """

   150

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

   151

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

   152

        """

   153

   154

        def _decorator (func) :

   155

            @functools.wraps(func)

   156

            def _handler (request, **args) :

   157

                # load preferences

   158

                cookies, prefs = self.load(request)

   159

   164

                # update args with new ones

   165

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

   166

   167

                # handle to get response

   168

                response = func(request, **args)

   169

   170

                # set cookies?

   171

                if prefs.set_cookies :

   175

                    # update cookies

   176

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

   177

                        cookies[key] = value

   178

   179

                    # add headers

   180

                    for morsel in cookies.itervalues() :

   181

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

   182

   183

                return response

   184

   185

            # return wrapped handler

   186

            return _handler

   187

   188

        # return decorator...

   189

        return _decorator

   190

   191

# now for our defined preferences....

   192

import pytz

   193

   194

class TimeFormat (urltree.URLStringType, Preference) :

   195

    """

   196

        Time format

   197

    """

   198

   199

    # set name

   200

    name = 'time_format'

   201

   202

    # default value

   203

    default = "%H:%M:%S"

   204

   205

class DateFormat (urltree.URLStringType, Preference) :

   206

    """

   207

        Date format

   208

    """

   209

   210

    # set name

   211

    name = 'date_format'

   212

   213

    # default value

   215

   216

class Timezone (Preference) :

   217

    """

   218

        Timezone

   219

    """

   220

   221

    # set name

   222

    name = 'timezone'

   223

   224

    # default value is UTC...

   225

    default = pytz.utc

   226

   227

    def parse (self, name) :

   228

        """

   229

            tz_name -> pytz.timezone

   230

        """

   231

   232

        return pytz.timezone(name)

   233

   234

    def build (self, tz) :

   235

        """

   236

            pytz.timezone -> tz_name

   237

        """

   238

   239

        return tz.zone

   240

   241

class Formatter (Preference) :

   242

    """

   243

        LogFormatter to use

   244

    """

   245

   246

    # set name

   247

    name = 'formatter'

   248

   249

    def __init__ (self, formatters, default) :

   250

        """

   251

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

   252

        """

   253

   254

        self.formatters = formatters

   255

        self.default = default

   256

   257

    def parse (self, fmt_name) :

   258

        """

   259

            fmt_name -> class LogFormatter

   260

        """

   261

   262

        return self.formatters[fmt_name]

   263

   264

    def build (self, fmt_cls) :

   265

        """

   266

            class LogFormatter -> fmt_name

   267

        """

   268

   270

   271

    def process (self, prefs, fmt_cls) :

   272

        """

   273

            class LogFormatter -> LogFormatter(tz, time_fmt)

   274

        """

   275

   277

   278

# and then build the Preferences object

   279

import log_formatter

   280

   286

preferences = Preferences([

   291

])

   292