1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
from inspect import getargspec, ismethod
from core import abort, request
from decorators import expose
from routing import lookup_controller
from util import iscontroller
class RestController(object):
'''
A base class for ``REST`` based controllers. Inherit from this class
to implement a REST controller.
``RestController`` implements a set of routing functions which override
the default pecan routing with behavior consistent with RESTful routing.
This functionality covers navigation to the requested resource
controllers, and the appropriate handling of both the common (``GET``,
``POST``, ``PUT``, ``DELETE``) as well as custom-defined REST action
methods.
For more on developing **RESTful** web applications with Pecan, see
:ref:`rest`.
'''
_custom_actions = {}
@expose()
def _route(self, args):
'''
Routes a request to the appropriate controller and returns its result.
Performs a bit of validation - refuses to route delete and put actions
via a GET request).
'''
# convention uses "_method" to handle browser-unsupported methods
if request.environ.get('pecan.validation_redirected', False) is True:
#
# If the request has been internally redirected due to a validation
# exception, we want the request method to be enforced as GET, not
# the `_method` param which may have been passed for REST support.
#
method = request.method.lower()
else:
method = request.params.get('_method', request.method).lower()
# make sure DELETE/PUT requests don't use GET
if request.method == 'GET' and method in ('delete', 'put'):
abort(405)
# check for nested controllers
result = self._find_sub_controllers(args)
if result:
return result
# handle the request
handler = getattr(self, '_handle_%s' % method, self._handle_custom)
result = handler(method, args)
# return the result
return result
def _find_controller(self, *args):
'''
Returns the appropriate controller for routing a custom action.
'''
for name in args:
obj = getattr(self, name, None)
if obj and iscontroller(obj):
return obj
return None
def _find_sub_controllers(self, remainder):
'''
Identifies the correct controller to route to by analyzing the
request URI.
'''
# need either a get_one or get to parse args
method = None
for name in ('get_one', 'get'):
if hasattr(self, name):
method = name
break
if not method:
return
# get the args to figure out how much to chop off
args = getargspec(getattr(self, method))
fixed_args = len(args[0][1:]) - len(
request.pecan.get('routing_args', [])
)
var_args = args[1]
# attempt to locate a sub-controller
if var_args:
for i, item in enumerate(remainder):
controller = getattr(self, item, None)
if controller and not ismethod(controller):
self._set_routing_args(remainder[:i])
return lookup_controller(controller, remainder[i + 1:])
elif fixed_args < len(remainder) and hasattr(
self, remainder[fixed_args]
):
controller = getattr(self, remainder[fixed_args])
if not ismethod(controller):
self._set_routing_args(remainder[:fixed_args])
return lookup_controller(
controller,
remainder[fixed_args + 1:]
)
def _handle_custom(self, method, remainder):
'''
Routes ``_custom`` actions to the appropriate controller.
'''
# try finding a post_{custom} or {custom} method first
controller = self._find_controller('post_%s' % method, method)
if controller:
return controller, remainder
# if no controller exists, try routing to a sub-controller; note that
# since this isn't a safe GET verb, any local exposes are 405'd
if remainder:
if self._find_controller(remainder[0]):
abort(405)
sub_controller = getattr(self, remainder[0], None)
if sub_controller:
return lookup_controller(sub_controller, remainder[1:])
abort(404)
def _handle_get(self, method, remainder):
'''
Routes ``GET`` actions to the appropriate controller.
'''
# route to a get_all or get if no additional parts are available
if not remainder or remainder == ['']:
controller = self._find_controller('get_all', 'get')
if controller:
return controller, []
abort(404)
method_name = remainder[-1]
# check for new/edit/delete GET requests
if method_name in ('new', 'edit', 'delete'):
if method_name == 'delete':
method_name = 'get_delete'
controller = self._find_controller(method_name)
if controller:
return controller, remainder[:-1]
# check for custom GET requests
if method.upper() in self._custom_actions.get(method_name, []):
controller = self._find_controller(
'get_%s' % method_name,
method_name
)
if controller:
return controller, remainder[:-1]
controller = getattr(self, remainder[0], None)
if controller and not ismethod(controller):
return lookup_controller(controller, remainder[1:])
# finally, check for the regular get_one/get requests
controller = self._find_controller('get_one', 'get')
if controller:
return controller, remainder
abort(404)
def _handle_delete(self, method, remainder):
'''
Routes ``DELETE`` actions to the appropriate controller.
'''
if remainder:
controller = getattr(self, remainder[0], None)
if controller and not ismethod(controller):
return lookup_controller(controller, remainder[1:])
# check for post_delete/delete requests first
controller = self._find_controller('post_delete', 'delete')
if controller:
return controller, remainder
# if no controller exists, try routing to a sub-controller; note that
# since this is a DELETE verb, any local exposes are 405'd
if remainder:
if self._find_controller(remainder[0]):
abort(405)
sub_controller = getattr(self, remainder[0], None)
if sub_controller:
return lookup_controller(sub_controller, remainder[1:])
abort(404)
def _handle_post(self, method, remainder):
'''
Routes ``POST`` requests.
'''
# check for custom POST/PUT requests
if remainder:
method_name = remainder[-1]
if method.upper() in self._custom_actions.get(method_name, []):
controller = self._find_controller(
'%s_%s' % (method, method_name),
method_name
)
if controller:
return controller, remainder[:-1]
controller = getattr(self, remainder[0], None)
if controller and not ismethod(controller):
return lookup_controller(controller, remainder[1:])
# check for regular POST/PUT requests
controller = self._find_controller(method)
if controller:
return controller, remainder
abort(404)
def _handle_put(self, method, remainder):
return self._handle_post(method, remainder)
def _set_routing_args(self, args):
'''
Sets default routing arguments.
'''
request.pecan.setdefault('routing_args', []).extend(args)
|