def create_cases(request):
try:
body = request.body.decode(request.charset)
except UnicodeDecodeError:
return JsonResponse(
{"error": f"Couldn't decode body as {request.charset}."},
status=400)
with io.StringIO(body, newline='') as csvfile:
reader = csv.DictReader(csvfile)
ids = []
for row in reader:
data = {key: [value] for key, value in row.items()}
try:
ids.append(CaseApi.create_case(data))
except RequestException:
return JsonResponse(
{
"error": "Error while using external Zaaksysteem API.",
"result": ids
},
status=500,
)
return JsonResponse({"result": ids})
def destroy(self, request, key=None):
"""
:return: :py:class:`restae.response.JsonResponse`
"""
self.pre_delete(key)
key.delete()
return JsonResponse()
def path_cat(a, b):
r = {'a': a}
if b is not None:
r['b'] = b
return JsonResponse(r)
def post(self):
data_dict = request.get_json()
report = Report(**data_dict)
report.position = [float(s) for s in data_dict["position"]]
report.save()
url = url_for(".report_detail", id=str(report.id))
response = {"report": report.as_dict(), "url": url}
return JsonResponse(response, status=200)
def partial_update(self, request, key=None):
try:
obj = key.get()
obj.update(self.get_body())
obj.put()
self.post_save(obj, created=False)
return JsonResponse(data=self.get_serializer()(obj).data)
except Exception as err:
raise BadRequest(str(err))
def create(self, request):
"""
:return: :py:class:`restae.response.JsonResponse`
"""
_model = get_model_class_from_query(self.get_queryset())
obj = _model(**self.get_serializer()(data=self.get_body()).data)
obj.put()
self.post_save(obj, created=True)
return JsonResponse(data=self.get_serializer()(obj).data)
def apply_dispatch(self):
"""
Does the hole mechanism of dispatch.
Loops over all middlewares before and after the dispatch method call
.. code-block:: python
for middleware in self.middlewares:
middleware.process_request(self.request)
self.route_args = self.get_route_args()
response = self.do_dispatch()
for middleware in self.middlewares:
middleware.process_response(self.request, response)
:return: :py:class:`webob.Response`
"""
try:
self.query_params = dict(self.request.GET)
self.env = self.request.GET.env
for middleware in self.middlewares:
if middleware.activate_on_method(self.request.method.upper()):
middleware.process_request(self.request)
self.route_args = self.get_route_args()
response = self.do_dispatch()
for middleware in self.middlewares:
if middleware.activate_on_method(self.request.method.upper()):
middleware.process_response(self.request, response)
return response
except NotFound as nf:
return JsonResponse(status=404, data=str(nf) or 'Not found')
except NotAuthorized as na:
return JsonResponse(status=403, data=str(na) or 'Not authorized')
except Forbidden as fo:
return JsonResponse(status=401, data=str(fo) or 'Forbidden')
except MissingParameter as mp:
return JsonResponse(status=400,
data=str(mp) or 'Missing parameter')
except BadRequest as br:
return JsonResponse(status=400, data=str(br) or 'Bad request')
except MissingBody as mb:
return JsonResponse(status=400,
data=str(mb) or 'Request is missing a body')
except ValueError as ve:
return JsonResponse(status=400, data=str(ve) or 'Value error')
except DispatchError:
return Response(status=404)
except Exception as err:
logging.error('%s: %s', err.__class__.__name__, str(err))
logging.error(traceback.format_exc())
return self.handle_exception(err, self.app.debug)
def retrieve(self, request, key=None):
"""
:return: :py:class:`restae.response.JsonResponse`
"""
try:
obj = key.get()
if obj is None:
raise NotFound
except Exception:
raise NotFound
return JsonResponse(data=self.get_serializer()(obj).data)
def do_dispatch(self):
"""
Dispatches the request.
This will first check if there's a handler_method defined in the
matched route, and if not it'll use the method correspondent to the
request method (``get()``, ``post()`` etc).
"""
if self.request.method.upper() == 'OPTIONS':
return CorsResponse()
route_args = self.get_route_args()
route_kwargs = {}
matched_url = None
for url in getattr(self, 'urls', []):
if re.match(url.regex, self.request.path_info):
matched_url = url
break
if matched_url is None:
raise NotFound('URL not found on this server')
if matched_url.route.detail is True:
try:
route_kwargs['key'] = self.get_object(
urlsafe=route_args['urlsafe'])
except Exception:
return JsonResponse(status=400,
data='Given urlsafe is invalid')
if self.request.method.lower() not in matched_url.route.mapping.keys():
raise DispatchError('Invalid method {}'.format(
self.request.method))
self.action = matched_url.route.mapping[self.request.method.lower()]
method = getattr(self, self.action, None)
# The handler only receives *args if no named variables are set.
args, kwargs = route_args, route_kwargs
if kwargs:
args = ()
if self.check_action_permissions() is False:
raise NotAuthorized()
return method(self, *args, **kwargs)
def _send_500(connection, message):
response = JsonResponse()
response.status = 500
response.content = {'message': message}
http_response = response.get_http()
connection.send(http_response)
def qs_cat(querystring):
return JsonResponse(querystring)
def form_cat(form):
return JsonResponse(form)
def json_cat(json):
return JsonResponse(json)
def get(self, id):
report = Report.objects.get_or_404(id=id)
response = {"report": report.as_dict()}
return JsonResponse(response, status=200)
def get(self):
fields = "address", "position", "severity", "noise_type"
reports = Report.objects.only(*fields).all()
response = {"reports": [r.as_dict() for r in reports]}
return JsonResponse(response, status=200)
def _send_404(connection):
response = JsonResponse()
response.status = 404
response.content = {'message': '404 Not Found'}
http_response = response.get_http()
connection.send(http_response)
def get(self):
reports = Report.objects.all()
response = {"reports": [r.as_dict() for r in reports]}
return JsonResponse(response, status=200)