← 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-08-13 06:57:51 UTC
  • mto: (1294.2.124 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: coles.david@gmail.com-20090813065751-pulonzqrb2pj9ta9
Ported Submit to object publisher framework

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
def generate_publisher(view_plugins, root):
53
54
    """
54
55
    Build a Mapper object for doing URL matching using 'routes', based on the
55
56
    given plugin registry.
56
57
    """
57
 
    m = routes.Mapper(explicit=True)
 
58
    r = Publisher(root=root)
 
59
 
 
60
    r.add_set_switch('api', 'api')
 
61
 
58
62
    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
 
63
        if hasattr(plugin, 'forward_routes'):
 
64
            for fr in plugin.forward_routes:
 
65
                # An annotated function can also be passed in directly.
 
66
                if hasattr(fr, '_forward_route_meta'):
 
67
                    r.add_forward_func(fr)
 
68
                else:
 
69
                    r.add_forward(*fr)
 
70
 
 
71
        if hasattr(plugin, 'reverse_routes'):
 
72
            for rr in plugin.reverse_routes:
 
73
                # An annotated function can also be passed in directly.
 
74
                if hasattr(rr, '_reverse_route_src'):
 
75
                    r.add_reverse_func(rr)
 
76
                else:
 
77
                    r.add_reverse(*rr)
 
78
 
 
79
        if hasattr(plugin, 'views'):
 
80
            for v in plugin.views:
 
81
                r.add_view(*v)
 
82
 
 
83
    return r
67
84
 
68
85
def handler(apachereq):
69
86
    """Handles an HTTP request.
85
102
            req.user = user
86
103
 
87
104
    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')
92
 
 
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']
 
105
        raise NotImplementedError("no public mode with obtrav yet!")
 
106
 
 
107
    req.publisher = generate_publisher(config.plugin_index[ViewPlugin],
 
108
                                 ApplicationRoot(req.config, req.store))
 
109
 
 
110
    try:
 
111
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
100
112
        try:
 
113
            # We 404 if we have a subpath but the view forbids it.
 
114
            if not viewcls.subpath_allowed and subpath:
 
115
                raise NotFound()
 
116
 
101
117
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, **kwargs)
 
118
            view = viewcls(req, obj, subpath)
103
119
 
104
120
            # Check that the request (mainly the user) is permitted to access
105
121
            # the view.
118
134
                errviewcls = XHTMLView.get_error_view(e)
119
135
 
120
136
            if errviewcls:
121
 
                errview = errviewcls(req, e)
 
137
                errview = errviewcls(req, e, obj)
122
138
                errview.render(req)
123
139
                return req.OK
124
140
            elif e.message:
138
154
        else:
139
155
            req.store.commit()
140
156
            return req.OK
141
 
    else:
 
157
    except PublishingError, e:
142
158
        req.status = 404
143
 
        XHTMLErrorView(req, NotFound()).render(req)
 
159
 
 
160
        if req.user.admin:
 
161
            XHTMLErrorView(req, NotFound('Not found: ' +
 
162
                                         str(e.args)), e[0]).render(req)
 
163
        else:
 
164
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
 
165
 
144
166
        return req.OK
145
167
 
146
168
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):