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

   199

class TimeFormat (urltree.URLStringType, Preference) :

   200

    """

   201

        Time format

   202

    """

   203

   204

    # set name

   205

    name = 'time_format'

   206

   207

    # default value

   208

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

   209

   210

class DateFormat (urltree.URLStringType, Preference) :

   211

    """

   212

        Date format

   213

    """

   214

   215

    # set name

   216

    name = 'date_format'

   217

   218

    # default value

   219

    default = "%Y-%m-%d"

   220

   221

class Timezone (Preference) :

   222

    """

   223

        Timezone

   224

    """

   225

   226

    # set name

   227

    name = 'timezone'

   228

   229

    # default value is UTC...

   230

    default = pytz.utc

   231

   232

    def parse (self, name) :

   233

        """

   234

            tz_name -> pytz.timezone

   235

        """

   236

   237

        return pytz.timezone(name)

   238

   239

    def build (self, tz) :

   240

        """

   241

            pytz.timezone -> tz_name

   242

        """

   243

   244

        return tz.zone

   245

   246

class Formatter (Preference) :

   247

    """

   248

        LogFormatter to use

   249

    """

   250

   251

    # set name

   252

    name = 'formatter'

   253

   254

    def __init__ (self, formatters, default) :

   255

        """

   256

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

   257

        """

   258

   259

        self.formatters = formatters

   260

        self.default = default

   261

   262

    def parse (self, fmt_name) :

   263

        """

   264

            fmt_name -> class LogFormatter

   265

        """

   266

   267

        return self.formatters[fmt_name]

   268

   269

    def build (self, fmt_cls) :

   270

        """

   271

            class LogFormatter -> fmt_name

   272

        """

   273

   274

        return fmt_cls.name

   275

   276

    def process (self, prefs, fmt_cls) :

   277

        """

   278

            class LogFormatter -> LogFormatter(tz, time_fmt)

   279

        """

   280

   281

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

   282

   283

# and then build the Preferences object

   284

import log_formatter

   285

   286

time_format = TimeFormat()

   287

date_format = DateFormat()

   288

timezone    = Timezone()

   289

formatter   = Formatter(log_formatter.FORMATTERS, log_formatter.IrssiFormatter)

   290

   291

preferences = Preferences([

   292

    time_format,

   293

    date_format,

   294

    timezone,

   295

    formatter,

   296

])

   297