← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/dispatch/__init__.py

  • Committer: David Coles
  • Date: 2009-12-02 00:31:40 UTC
  • mfrom: (1326.1.4 svn-fixes)
  • Revision ID: coles.david@gmail.com-20091202003140-n0k6rmv86hu6mj2p
https://launchpad.net/bugs/456922
Allow updating files to past revisions through 'Subversion Log' page.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
37
37
import time
38
38
 
39
39
import mod_python
 
40
import routes
40
41
 
41
42
from ivle import util
42
43
import ivle.config
45
46
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
46
47
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
47
48
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
48
 
from ivle.webapp.publisher import Publisher, PublishingError
49
 
from ivle.webapp import ApplicationRoot
50
49
 
51
50
config = ivle.config.Config()
52
51
 
53
 
class ObjectPermissionCheckingPublisher(Publisher):
54
 
    """A specialised publisher that checks object permissions.
55
 
 
56
 
    This publisher verifies that the user holds any permission at all
57
 
    on the model objects through which the resolution path passes. If
58
 
    no permission is held, resolution is aborted with an Unauthorized
59
 
    exception.
60
 
 
61
 
    IMPORTANT: This does NOT check view permissions. It only checks
62
 
    the objects in between the root and the view, exclusive!
63
 
    """
64
 
 
65
 
    def traversed_to_object(self, obj):
66
 
        """Check that the user has any permission at all over the object."""
67
 
        if (hasattr(obj, 'get_permissions') and
68
 
            len(obj.get_permissions(self.root.user)) == 0):
69
 
            # Indicate the forbidden object if this is an admin.
70
 
            if self.root.user and self.root.user.admin:
71
 
                raise Unauthorized('Unauthorized: %s' % obj)
72
 
            else:
73
 
                raise Unauthorized()
74
 
 
75
 
 
76
 
def generate_publisher(view_plugins, root, publicmode=False):
 
52
def generate_router(view_plugins, attr):
77
53
    """
78
54
    Build a Mapper object for doing URL matching using 'routes', based on the
79
55
    given plugin registry.
80
56
    """
81
 
    r = ObjectPermissionCheckingPublisher(root=root)
82
 
 
83
 
    r.add_set_switch('api', 'api')
84
 
 
85
 
    if publicmode:
86
 
        view_attr = 'public_views'
87
 
        forward_route_attr = 'public_forward_routes'
88
 
        reverse_route_attr = 'public_reverse_routes'
89
 
    else:
90
 
        view_attr = 'views'
91
 
        forward_route_attr = 'forward_routes'
92
 
        reverse_route_attr = 'reverse_routes'
93
 
 
94
 
 
 
57
    m = routes.Mapper(explicit=True)
95
58
    for plugin in view_plugins:
96
 
        if hasattr(plugin, forward_route_attr):
97
 
            for fr in getattr(plugin, forward_route_attr):
98
 
                # An annotated function can also be passed in directly.
99
 
                if hasattr(fr, '_forward_route_meta'):
100
 
                    r.add_forward_func(fr)
101
 
                else:
102
 
                    r.add_forward(*fr)
103
 
 
104
 
        if hasattr(plugin, reverse_route_attr):
105
 
            for rr in getattr(plugin, reverse_route_attr):
106
 
                # An annotated function can also be passed in directly.
107
 
                if hasattr(rr, '_reverse_route_src'):
108
 
                    r.add_reverse_func(rr)
109
 
                else:
110
 
                    r.add_reverse(*rr)
111
 
 
112
 
        if hasattr(plugin, view_attr):
113
 
            for v in getattr(plugin, view_attr):
114
 
                r.add_view(*v)
115
 
 
116
 
    return r
 
59
        # Establish a URL pattern for each element of plugin.urls
 
60
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
 
61
        for url in getattr(plugin, attr):
 
62
            routex = url[0]
 
63
            view_class = url[1]
 
64
            kwargs_dict = url[2] if len(url) >= 3 else {}
 
65
            m.connect(routex, view=view_class, **kwargs_dict)
 
66
    return m
117
67
 
118
68
def handler(apachereq):
119
69
    """Handles an HTTP request.
134
84
        if user and user.valid:
135
85
            req.user = user
136
86
 
137
 
    req.publisher = generate_publisher(
138
 
        config.plugin_index[ViewPlugin],
139
 
        ApplicationRoot(req.config, req.store, req.user),
140
 
        publicmode=req.publicmode)
 
87
    if req.publicmode:
 
88
        req.mapper = generate_router(config.plugin_index[PublicViewPlugin],
 
89
                                    'public_urls')
 
90
    else:
 
91
        req.mapper = generate_router(config.plugin_index[ViewPlugin], 'urls')
141
92
 
142
 
    try:
143
 
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
 
93
    matchdict = req.mapper.match(req.uri)
 
94
    if matchdict is not None:
 
95
        viewcls = matchdict['view']
 
96
        # Get the remaining arguments, less 'view', 'action' and 'controller'
 
97
        # (The latter two seem to be built-in, and we don't want them).
 
98
        kwargs = matchdict.copy()
 
99
        del kwargs['view']
144
100
        try:
145
 
            # We 404 if we have a subpath but the view forbids it.
146
 
            if not viewcls.subpath_allowed and subpath:
147
 
                raise NotFound()
148
 
 
149
101
            # Instantiate the view, which should be a BaseView class
150
 
            view = viewcls(req, obj, subpath)
 
102
            view = viewcls(req, **kwargs)
151
103
 
152
104
            # Check that the request (mainly the user) is permitted to access
153
105
            # the view.
154
106
            if not view.authorize(req):
155
 
                # Indicate the forbidden object if this is an admin.
156
 
                if req.user and req.user.admin:
157
 
                    raise Unauthorized('Unauthorized: %s' % view)
158
 
                else:
159
 
                    raise Unauthorized()
 
107
                raise Unauthorized()
160
108
            # Render the output
161
109
            view.render(req)
162
110
        except HTTPError, e:
170
118
                errviewcls = XHTMLView.get_error_view(e)
171
119
 
172
120
            if errviewcls:
173
 
                errview = errviewcls(req, e, obj)
 
121
                errview = errviewcls(req, e)
174
122
                errview.render(req)
175
123
                return req.OK
176
124
            elif e.message:
190
138
        else:
191
139
            req.store.commit()
192
140
            return req.OK
193
 
    except Unauthorized, e:
194
 
        # Resolution failed due to a permission check. Display a pretty
195
 
        # error, or maybe a login page.
196
 
        XHTMLView.get_error_view(e)(req, e, req.publisher.root).render(req)
197
 
        return req.OK
198
 
    except PublishingError, e:
 
141
    else:
199
142
        req.status = 404
200
 
 
201
 
        if req.user and req.user.admin:
202
 
            XHTMLErrorView(req, NotFound('Not found: ' +
203
 
                                         str(e.args)), e[0]).render(req)
204
 
        else:
205
 
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
206
 
 
 
143
        XHTMLErrorView(req, NotFound()).render(req)
207
144
        return req.OK
208
145
 
209
146
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):