← 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: William Grant
  • Date: 2009-12-08 03:50:24 UTC
  • mfrom: (1294.2.143 ui-the-third)
  • Revision ID: grantw@unimelb.edu.au-20091208035024-wjx8zp54gth15ph8
Merge ui-the-third. This is another UI revamp.

The header is now thin! Thin! The yellow bar is gone. The tabs are gone.
Breadcrumbs are here. Routes is replaced (with an object publishing
mechanism). Views are less repetitive. etc.

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
41
40
 
42
41
from ivle import util
43
42
import ivle.config
46
45
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
46
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
47
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
 
48
from ivle.webapp.publisher import Publisher, PublishingError
 
49
from ivle.webapp import ApplicationRoot
49
50
 
50
51
config = ivle.config.Config()
51
52
 
52
 
def generate_router(view_plugins, attr):
 
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):
53
77
    """
54
78
    Build a Mapper object for doing URL matching using 'routes', based on the
55
79
    given plugin registry.
56
80
    """
57
 
    m = routes.Mapper(explicit=True)
 
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
 
58
95
    for plugin in view_plugins:
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
 
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
67
117
 
68
118
def handler(apachereq):
69
119
    """Handles an HTTP request.
84
134
        if user and user.valid:
85
135
            req.user = user
86
136
 
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')
 
137
    req.publisher = generate_publisher(
 
138
        config.plugin_index[ViewPlugin],
 
139
        ApplicationRoot(req.config, req.store, req.user),
 
140
        publicmode=req.publicmode)
92
141
 
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']
 
142
    try:
 
143
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
100
144
        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
 
101
149
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, **kwargs)
 
150
            view = viewcls(req, obj, subpath)
103
151
 
104
152
            # Check that the request (mainly the user) is permitted to access
105
153
            # the view.
106
154
            if not view.authorize(req):
107
 
                raise Unauthorized()
 
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()
108
160
            # Render the output
109
161
            view.render(req)
110
162
        except HTTPError, e:
118
170
                errviewcls = XHTMLView.get_error_view(e)
119
171
 
120
172
            if errviewcls:
121
 
                errview = errviewcls(req, e)
 
173
                errview = errviewcls(req, e, obj)
122
174
                errview.render(req)
123
175
                return req.OK
124
176
            elif e.message:
138
190
        else:
139
191
            req.store.commit()
140
192
            return req.OK
141
 
    else:
 
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:
142
199
        req.status = 404
143
 
        XHTMLErrorView(req, NotFound()).render(req)
 
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
 
144
207
        return req.OK
145
208
 
146
209
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):