← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/services/features/scopes.py

  • Committer: Michael-Doyle Hudson
  • Date: 2011-09-21 21:12:02 UTC
  • mto: This revision was merged to the branch mainline in revision 14068.
  • Revision ID: michael.hudson@linaro.org-20110921211202-xk3mjmjqrufx10f5
revert the reversion of the xmlrpc feature flag endpoint

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/services/features/scopes.py
9
9
"""
10
10
 
11
11
__all__ = [
 
12
    'DefaultScope',
 
13
    'default_scopes',
 
14
    'FixedScope',
12
15
    'HANDLERS',
 
16
    'MultiScopeHandler',
13
17
    'ScopesForScript',
14
18
    'ScopesFromRequest',
 
19
    'TeamScope',
15
20
    'undocumented_scopes',
16
21
    ]
17
22
 
19
24
 
20
25
import re
21
26
 
22
 
from zope.component import getUtility
23
 
 
24
 
from canonical.launchpad.webapp.interfaces import ILaunchBag
 
27
from lp.registry.interfaces.person import IPerson
25
28
from lp.services.propertycache import cachedproperty
26
29
import canonical.config
27
30
 
60
63
        return True
61
64
 
62
65
 
63
 
class BaseWebRequestScope(BaseScope):
64
 
    """Base class for scopes that key off web request attributes."""
65
 
 
66
 
    def __init__(self, request):
67
 
        self.request = request
68
 
 
69
 
 
70
 
class PageScope(BaseWebRequestScope):
 
66
class PageScope(BaseScope):
71
67
    """The current page ID.
72
68
 
73
69
    Pageid scopes are written as 'pageid:' + the pageid to match.  Pageids
81
77
 
82
78
    pattern = r'pageid:'
83
79
 
 
80
    def __init__(self, pageid):
 
81
        self._pageid = pageid
 
82
 
84
83
    def lookup(self, scope_name):
85
84
        """Is the given scope match the current pageid?"""
86
85
        pageid_scope = scope_name[len('pageid:'):]
104
103
 
105
104
    @cachedproperty
106
105
    def _request_pageid_namespace(self):
107
 
        return tuple(self._pageid_to_namespace(
108
 
            self.request._orig_env.get('launchpad.pageid', '')))
 
106
        return tuple(self._pageid_to_namespace(self._pageid))
109
107
 
110
108
 
111
109
class TeamScope(BaseScope):
112
 
    """The current user's team memberships.
 
110
    """A user's team memberships.
113
111
 
114
112
    Team ID scopes are written as 'team:' + the team name to match.
115
113
 
119
117
 
120
118
    pattern = r'team:'
121
119
 
 
120
    def __init__(self, person):
 
121
        self.person = person
 
122
 
122
123
    def lookup(self, scope_name):
123
124
        """Is the given scope a team membership?
124
125
 
127
128
        fixed to reduce this to one query).
128
129
        """
129
130
        team_name = scope_name[len('team:'):]
130
 
        person = getUtility(ILaunchBag).user
131
 
        if person is None:
132
 
            return False
133
 
        return person.inTeam(team_name)
 
131
        return self.person.inTeam(team_name)
134
132
 
135
133
 
136
134
class ServerScope(BaseScope):
169
167
        return scope_name == self.script_scope
170
168
 
171
169
 
 
170
class FixedScope(BaseScope):
 
171
    """A scope that matches an exact value.
 
172
 
 
173
    Functionally `ScriptScope` and `DefaultScope` are equivalent to instances
 
174
    of this class, but their docstings are used on the +feature-info page.
 
175
    """
 
176
 
 
177
    def __init__(self, scope):
 
178
        self.pattern = re.escape(scope) + '$'
 
179
 
 
180
    def lookup(self, scope_name):
 
181
        return True
 
182
 
 
183
 
172
184
# These are the handlers for all of the allowable scopes, listed here so that
173
185
# we can for example show all of them in an admin page.  Any new scope will
174
186
# need a scope handler and that scope handler has to be added to this list.
213
225
            undocumented_scopes.add(scope_name)
214
226
 
215
227
 
 
228
default_scopes = (DefaultScope(),)
 
229
 
 
230
 
216
231
class ScopesFromRequest(MultiScopeHandler):
217
232
    """Identify feature scopes based on request state."""
218
233
 
219
234
    def __init__(self, request):
220
 
        super(ScopesFromRequest, self).__init__([
221
 
            DefaultScope(),
222
 
            PageScope(request),
223
 
            TeamScope(),
224
 
            ServerScope()])
 
235
        scopes = list(default_scopes)
 
236
        scopes.extend([
 
237
            PageScope(request._orig_env.get('launchpad.pageid', '')),
 
238
            ServerScope(),
 
239
            ])
 
240
        person = IPerson(request.principal, None)
 
241
        if person is not None:
 
242
            scopes.append(TeamScope(person))
 
243
        super(ScopesFromRequest, self).__init__(scopes)
225
244
 
226
245
 
227
246
class ScopesForScript(MultiScopeHandler):
228
247
    """Identify feature scopes for a given script."""
229
248
 
230
249
    def __init__(self, script_name):
231
 
        super(ScopesForScript, self).__init__([
232
 
            DefaultScope(),
233
 
            ScriptScope(script_name)])
 
250
        scopes = list(default_scopes)
 
251
        scopes.append(ScriptScope(script_name))
 
252
        super(ScopesForScript, self).__init__(scopes)