def post(self, **kwargs):
if 'pk' in kwargs:
raise NotFound("Did you mean to use PUT?")
self._resource.validate_request()
obj = self._resource.create_object()
ret = self._resource.serialize(obj, params=request.args)
return ret
def post(self):
json_data = request.get_json(force=True)
print(json_data)
sn = ""
pw = ""
try:
sn = int(json_data['serviceDetailsId'])
if (sn < 1000): raise NotFound("No transaction found ")
except:
abort("Invalid transaction id")
cust = Customer()
print(cust)
return ([
{
"serviceDetailsId": sn,
"customer": {
'firstName': 'john',
'lastName': 'shrill'
}
},
])
print("got " + un)
return []
def match(self,
path_info=None,
method=None,
return_rule=False,
query_args=None,
request=None):
self.map.update()
if path_info is None:
path_info = self.path_info
else:
path_info = to_unicode(path_info, self.map.charset)
if query_args is None:
query_args = self.query_args
method = (method or self.default_method).upper()
path = u'%s|%s' % (self.map.host_matching and self.server_name
or self.subdomain, path_info
and '/%s' % path_info.lstrip('/'))
have_match_for = set()
for rule in self.map._rules:
try:
rv = rule.match(path, request)
except RequestSlash:
raise RequestRedirect(
self.make_redirect_url(
url_quote(path_info, self.map.charset, safe='/:|+') +
'/', query_args))
except RequestAliasRedirect as e:
raise RequestRedirect(
self.make_alias_redirect_url(path, rule.endpoint,
e.matched_values, method,
query_args))
if rv is None:
continue
if rule.methods is not None and method not in rule.methods:
have_match_for.update(rule.methods)
continue
if self.map.redirect_defaults:
redirect_url = self.get_default_redirect(
rule, method, rv, query_args)
if redirect_url is not None:
raise RequestRedirect(redirect_url)
if return_rule:
return rule, rv
else:
return rule.endpoint, rv
if have_match_for:
raise MethodNotAllowed(valid_methods=list(have_match_for))
raise NotFound()
def dispatch_request(self, *args, **kwargs):
authorized = True if len(self.authentication_methods) == 0 else False
for authentication_method in self.authentication_methods:
if authentication_method().authorized():
authorized = True
if not authorized:
raise Unauthorized
try:
self._resource = self.resource()
return super(ResourceView, self).dispatch_request(*args, **kwargs)
except mongoengine.queryset.DoesNotExist:
raise NotFound()
except ValidationError, e:
return e.message, '400 Bad Request'
def post(self, **kwargs):
if 'pk' in kwargs:
raise NotFound("Did you mean to use PUT?")
self._resource.validate_request()
obj = self._resource.create_object()
# Check if we have permission to create this object
if not self.has_add_permission(request, obj):
raise Unauthorized
ret = self._resource.serialize(obj, params=request.args)
if isinstance(obj, mongoengine.Document) and self._resource.uri_prefix:
return ret, "201 Created", {
"Location": self._resource._url(str(obj.id))
}
else:
return ret
def to_python(self, value):
"""
`value` has slashs in it, that's why we inherit from `PathConverter`.
E.g.: `commune/13200@latest/`, `departement/13@1860-07-01/` or
`region/76@2016-01-01/Auvergne-Rhone-Alpes/`.
Note that the slug is not significative but cannot be omitted.
"""
if '/' not in value:
return NotFound()
level, code = value.split('/')[:2] # Ignore optional slug
geoid = GeoZone.SEPARATOR.join([level, code])
zone = GeoZone.objects.resolve(geoid)
if not zone and GeoZone.SEPARATOR not in level:
# Try implicit default prefix
level = GeoZone.SEPARATOR.join([self.DEFAULT_PREFIX, level])
geoid = GeoZone.SEPARATOR.join([level, code])
zone = GeoZone.objects.resolve(geoid)
return zone or NotFound()
def to_python(self, value):
try:
return self.model.objects.get_or_404(id=value)
except NotFound:
pass
try:
quoted = self.quote(value)
query = db.Q(slug=value) | db.Q(slug=quoted)
obj = self.model.objects(query).get()
except (InvalidQueryError, self.model.DoesNotExist):
# If the model doesn't have a slug or matching slug doesn't exist.
if self.has_redirected_slug:
latest = self.model.slug.latest(value)
if latest:
return LazyRedirect(latest)
return NotFound()
else:
if obj.slug != value:
return LazyRedirect(quoted)
return obj
def test_dispatch():
"""URL routing dispatch helper"""
env = create_environ('/')
map = Map([Rule('/', endpoint='root'), Rule('/foo/', endpoint='foo')])
adapter = map.bind_to_environ(env)
raise_this = None
def view_func(endpoint, values):
if raise_this is not None:
raise raise_this
return Response(repr((endpoint, values)))
dispatch = lambda p, q=False: Response.force_type(
adapter.dispatch(view_func, p, catch_http_exceptions=q), env)
assert dispatch('/').data == "('root', {})"
assert dispatch('/foo').status_code == 301
raise_this = NotFound()
assert_raises(NotFound, lambda: dispatch('/bar'))
assert dispatch('/bar', True).status_code == 404
def dispatch(request):
urls = _url_map.bind_to_environ(request.environ)
try:
endpoint, args = urls.match()
except HTTPException as e:
return e
args['request'] = request
_logger.debug('Incoming endpoint %s', endpoint)
try:
rep = dric.bus.publish(endpoint, **args)
except HTTPException as e:
return e
except Exception as e:
_logger.warn('Exception raised for endpoint %s: %s', endpoint, e)
if dric.env == 'dev':
traceback.print_stack()
else:
try:
return rep[0]
except TypeError:
_logger.warn('No response for endpoint "%s"', endpoint)
return NotFound()
def dispatch_request(self):
req = _request_ctx_stack.top.request
if req.routing_exception is not None:
self.raise_routing_exception(req)
if req.url_rule.bound_to is not None:
rule = req.url_rule.bound_to
else:
rule = req.url_rule
rvars = rule.resource_vars
req.resource_adapters = {}
for varname, value in req.view_args.items():
if varname in rvars:
req.resource_adapters[varname] = \
self.resource_adapter_class(req,
self,
req.view_args[varname],
req.url_rule.context,
req.url_rule.pool,
req.url_rule.selectors)
if req.url_rule.bound_to\
and varname == req.url_rule.bound_to.primary_resource:
req.resource_adapters['resource'] \
= req.resource_adapters[varname]
for varname in req.resource_adapters:
resource = req.resource_adapters[varname].resource
if resource is None and req.method is not 'PUT':
raise NotFound('Resource %s' % req.view_args[varname])
req.view_args[varname] = resource
if 'If-Match' in req.headers:
if req.headers['If-Match'] != aggregated_etag(req):
req.routing_exception = PreconditionFailed('Resource changed')
self.raise_routing_exception(req)
return super(LDP, self).dispatch_request()
def to_python(self, value):
try:
return value if isinstance(value, UUID) else UUID(value.strip())
except ValueError:
return NotFound()
def _find_handler(cls, return_rule=False):
path = request.httprequest.path.split('/')
if path[1] in [lg.code for lg in cls._get_languages()]:
raise NotFound()
return super(IrHttp, cls)._find_handler(return_rule=return_rule)