← 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-07-07 04:42:48 UTC
  • mto: (1294.4.2 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: grantw@unimelb.edu.au-20090707044248-sj79vbkwfgrzn059
Add some comments to the breadcrumb styles.

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