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

    74

        """

    75

    76

        return self.values[pref.name]

    77

    78

    def set (self, name, value_obj) :

    79

        """

    80

            Set a new value for the given preference

    81

        """

    82

    83

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

    84

        assert name not in self.set_cookies

    85

    86

        # encode using the Preference object

    87

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

    88

    89

        # update in our dict

    90

        self.values[name] = value_obj

    91

    92

        # add to set_cookies

    93

        self.set_cookies[name] = value_str

    94

    95

class Preferences (object) :

    96

    """

    97

        Handle user preferences using cookies

    98

    """

    99

   100

    def __init__ (self, pref_list) :

   101

        """

   102

            Use the given list of Preference objects

   103

        """

   104

   105

        # store

   106

        self.pref_list = pref_list

   107

   108

        # translate to mapping as well

   109

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

   110

   111

    def load (self, request, ) :

   112

        """

   113

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

   114

        """

   115

   116

        # the dict of values

   117

        values = {}

   118

   119

        # load the cookies

   120

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

   121

   122

        # got any?

   123

        if cookie_data :

   124

            # parse into a SimpleCookie

   125

            cookies = Cookie.SimpleCookie(cookie_data)

   126

   127

            # update the the values

   128

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

   129

   130

        else :

   131

            cookies = None

   132

   133

        # apply any query parameters

   134

        for pref in self.pref_list :

   135

            # look for a query param

   136

            value = request.get_arg(pref.name)

   137

   138

            if value :

   139

                # override

   140

                values[pref.name] = value

   141

   142

        # build the RequestPreferences object

   143

        return cookies, RequestPreferences(self, request, values)

   144

   145

    def handler (self, *pref_list) :

   146

        """

   147

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

   148

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

   149

        """

   150

   151

        def _decorator (func) :

   152

            @functools.wraps(func)

   153

            def _handler (request, **args) :

   154

                # load preferences

   155

                cookies, prefs = self.load(request)

   156

   157

                # update args with new ones

   158

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

   159

   160

                # handle to get response

   161

                response = func(request, **args)

   162

   163

                # set cookies?

   164

                if prefs.set_cookies :

   165

                    # update cookies

   166

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

   167

                        cookies[key] = value

   168

   169

                    # add headers

   170

                    for morsel in cookies.itervalues() :

   171

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

   172

   173

                return response

   174

   175

            # return wrapped handler

   176

            return _handler

   177

   178

        # return decorator...

   179

        return _decorator

   180

   181

# now for our defined preferences....

   182

import pytz

   183

   184

class TimeFormat (urltree.URLStringType, Preference) :

   185

    """

   186

        Time format

   187

    """

   188

   189

    # set name

   190

    name = 'time_format'

   191

   192

    # default value

   193

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

   194

   195

class DateFormat (urltree.URLStringType, Preference) :

   196

    """

   197

        Date format

   198

    """

   199

   200

    # set name

   201

    name = 'date_format'

   202

   203

    # default value

   204

    default = "%Y-%m%d"

   205

   206

class Timezone (Preference) :

   207

    """

   208

        Timezone

   209

    """

   210

   211

    # set name

   212

    name = 'timezone'

   213

   214

    # default value is UTC...

   215

    default = pytz.utc

   216

   217

    def parse (self, name) :

   218

        """

   219

            tz_name -> pytz.timezone

   220

        """

   221

   222

        return pytz.timezone(name)

   223

   224

    def build (self, tz) :

   225

        """

   226

            pytz.timezone -> tz_name

   227

        """

   228

   229

        return tz.zone

   230

   231

class Formatter (Preference) :

   232

    """

   233

        LogFormatter to use

   234

    """

   235

   236

    # set name

   237

    name = 'formatter'

   238

   239

    def __init__ (self, formatters, default) :

   240

        """

   241

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

   242

        """

   243

   244

        self.formatters = formatters

   245

        self.default = default

   246

   247

    def parse (self, fmt_name) :

   248

        """

   249

            fmt_name -> class LogFormatter

   250

        """

   251

   252

        return self.formatters[fmt_name]

   253

   254

    def build (self, fmt_cls) :

   255

        """

   256

            class LogFormatter -> fmt_name

   257

        """

   258

   259

        return fmt.name

   260

   261

    def process (self, prefs, fmt_cls) :

   262

        """

   263

            class LogFormatter -> LogFormatter(tz, time_fmt)

   264

        """

   265

   266

        return fmt_cls(prefs.get(Timezone), prefs.get(TimeFormat))

   267

   268

# and then build the Preferences object

   269

import log_formatter

   270

   271

preferences = Preferences([

   272

    TimeFormat(),

   273

    DateFormat(),

   274

    Timezone(),

   275

    Formatter(log_formatter.FORMATTERS, log_formatter.IrssiFormatter),

   276

])

   277