← 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: 2010-02-15 03:45:04 UTC
  • Revision ID: grantw@unimelb.edu.au-20100215034504-hwpkwo6m1184jkni
Document publication of documentation to the website.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
45
45
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
46
46
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
47
47
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
48
 
from ivle.webapp.routing import Router, RoutingError
 
48
from ivle.webapp.publisher import Publisher, PublishingError
49
49
from ivle.webapp import ApplicationRoot
50
50
 
51
51
config = ivle.config.Config()
52
52
 
53
 
def generate_router(view_plugins, root):
 
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, config)) == 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):
54
77
    """
55
78
    Build a Mapper object for doing URL matching using 'routes', based on the
56
79
    given plugin registry.
57
80
    """
58
 
    r = Router(root=root)
 
81
    r = ObjectPermissionCheckingPublisher(root=root)
59
82
 
60
83
    r.add_set_switch('api', 'api')
61
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
 
62
95
    for plugin in view_plugins:
63
 
        if hasattr(plugin, 'forward_routes'):
64
 
            for fr in plugin.forward_routes:
 
96
        if hasattr(plugin, forward_route_attr):
 
97
            for fr in getattr(plugin, forward_route_attr):
65
98
                # An annotated function can also be passed in directly.
66
99
                if hasattr(fr, '_forward_route_meta'):
67
100
                    r.add_forward_func(fr)
68
101
                else:
69
102
                    r.add_forward(*fr)
70
103
 
71
 
        if hasattr(plugin, 'reverse_routes'):
72
 
            for rr in plugin.reverse_routes:
 
104
        if hasattr(plugin, reverse_route_attr):
 
105
            for rr in getattr(plugin, reverse_route_attr):
73
106
                # An annotated function can also be passed in directly.
74
107
                if hasattr(rr, '_reverse_route_src'):
75
108
                    r.add_reverse_func(rr)
76
109
                else:
77
110
                    r.add_reverse(*rr)
78
111
 
79
 
        if hasattr(plugin, 'views'):
80
 
            for v in plugin.views:
 
112
        if hasattr(plugin, view_attr):
 
113
            for v in getattr(plugin, view_attr):
81
114
                r.add_view(*v)
82
115
 
83
116
    return r
101
134
        if user and user.valid:
102
135
            req.user = user
103
136
 
104
 
    if req.publicmode:
105
 
        raise NotImplementedError("no public mode with obtrav yet!")
106
 
 
107
 
    req.router = generate_router(config.plugin_index[ViewPlugin],
108
 
                                 ApplicationRoot(req.config, req.store))
 
137
    req.publisher = generate_publisher(
 
138
        config.plugin_index[ViewPlugin],
 
139
        ApplicationRoot(req.config, req.store, req.user),
 
140
        publicmode=req.publicmode)
109
141
 
110
142
    try:
111
 
        obj, viewcls, subpath = req.router.resolve(req.uri.decode('utf-8'))
 
143
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
112
144
        try:
113
145
            # We 404 if we have a subpath but the view forbids it.
114
146
            if not viewcls.subpath_allowed and subpath:
120
152
            # Check that the request (mainly the user) is permitted to access
121
153
            # the view.
122
154
            if not view.authorize(req):
123
 
                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()
124
160
            # Render the output
125
161
            view.render(req)
126
162
        except HTTPError, e:
134
170
                errviewcls = XHTMLView.get_error_view(e)
135
171
 
136
172
            if errviewcls:
137
 
                errview = errviewcls(req, e)
 
173
                errview = errviewcls(req, e, obj)
138
174
                errview.render(req)
139
175
                return req.OK
140
176
            elif e.message:
154
190
        else:
155
191
            req.store.commit()
156
192
            return req.OK
157
 
    except RoutingError, e:
158
 
        if req.user.admin:
 
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:
 
199
        req.status = 404
 
200
 
 
201
        if req.user and req.user.admin:
159
202
            XHTMLErrorView(req, NotFound('Not found: ' +
160
 
                                         str(e.args))).render(req)
 
203
                                         str(e.args)), e[0]).render(req)
161
204
        else:
162
 
            XHTMLErrorView(req, NotFound()).render(req)
 
205
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
163
206
 
164
207
        return req.OK
165
208