async def handler(self, request):
"""Main handler function"""
resp = self.resp
request.record("finish")
self.debug(request, resp)
if not IResponse.providedBy(resp) or not resp.prepared:
resp = await apply_rendering(View(None, request), request, resp)
resp = await apply_cors(request, resp)
return resp
async def __call__(self):
"""Apply CORS on the OPTIONS view."""
headers = await self.preflight()
resp = await self.render()
if IResponse.providedBy(resp):
headers.update(resp.headers)
resp.headers = headers
return resp
return Response(content=resp, headers=headers)
async def handler(self, request):
"""Main handler function"""
request._view_error = False
await notify(BeforeRenderViewEvent(request, self.view))
request.record("viewrender")
try:
# We try to avoid collisions on the same instance of
# guillotina
view_result = await self.view()
if app_settings["check_writable_request"](request):
await commit(warn=False)
else:
await abort()
except (ConflictError, TIDConflictError):
await abort()
# bubble this error up
raise
except response.Response as exc:
await abort()
view_result = exc
request._view_error = True
except Exception:
await abort()
raise
request.record("viewrendered")
resp = view_result
if resp is None:
resp = Response(status=200)
if not IResponse.providedBy(resp) or not resp.prepared:
resp = await apply_rendering(self.view, self.request, resp)
request.record("renderer")
resp = await apply_cors(request, resp)
if not request._view_error:
task = request.execute_futures()
else:
task = request.execute_futures("failure")
if task is not None:
await self.wait(request, resp, task)
self.debug(request, resp)
request.record("finish")
del self.view
del self.resource
request.clear_futures()
return resp
async def __call__(self, value) -> Response:
"""
Value can be:
- Guillotina response object
- serializable value
"""
if IResponse.providedBy(value):
resp = cast(Response, value)
if resp.content is not None:
resp.set_body(self.get_body(resp.content), self.content_type)
return resp
return Response(body=self.get_body(value) or b"",
status=200,
content_type=self.content_type)
async def __call__(self, value) -> aioResponse:
"""
Value can be:
- Guillotina response object
- serializable value
"""
status = 200
headers: Dict[str, str] = {}
if IResponse.providedBy(value):
headers = value.headers
status = value.status_code or 200
value = value.content
headers.update({"Content-Type": self.content_type})
return aioResponse(body=self.get_body(value), status=status, headers=headers)
async def __call__(self, value) -> aioResponse:
'''
Value can be:
- Guillotina response object
- serializable value
'''
status = 200
headers: Dict[str, str] = {}
if IResponse.providedBy(value):
headers = value.headers
status = value.status_code or 200
value = value.content
headers.update({
'Content-Type': self.content_type
})
return aioResponse(
body=self.get_body(value), status=status, headers=headers)
async def handle_ws_request(self, ws, message):
method = app_settings["http_methods"]["GET"]
try:
frame_id = message["id"]
except KeyError:
frame_id = "0"
parsed = parse.urlparse(message.get("path", message.get("value")))
path = tuple(p for p in parsed.path.split("/") if p)
from guillotina.traversal import traverse
obj, tail = await traverse(self.request, task_vars.container.get(),
path)
if tail and len(tail) > 0:
# convert match lookups
view_name = routes.path_to_view_name(tail)
elif not tail:
view_name = ""
else:
raise
permission = get_utility(IPermission, name="guillotina.AccessContent")
security = get_security_policy()
allowed = security.check_permission(permission.id, obj)
if not allowed:
return await ws.send_bytes(orjson.dumps({"error": "Not allowed"}))
try:
view = query_multi_adapter((obj, self.request),
method,
name=view_name)
except AttributeError:
view = None
try:
view.__route__.matches(self.request, tail or [])
except (KeyError, IndexError):
view = None
if view is None:
return await ws.send_bytes(
orjson.dumps({
"error": "Not found",
"id": frame_id
}))
ViewClass = view.__class__
view_permission = get_view_permission(ViewClass)
if not security.check_permission(view_permission, view):
return await ws.send_bytes(
orjson.dumps({
"error": "No view access",
"id": frame_id
}))
if hasattr(view, "prepare"):
view = (await view.prepare()) or view
view_result = await view()
if IResponse.providedBy(view_result):
raise Exception("Do not accept raw ASGI exceptions in ws")
else:
from guillotina.traversal import apply_rendering
resp = await apply_rendering(view, self.request, view_result)
# Return the value, body is always encoded
response_object = orjson.dumps({
"data": resp.body.decode("utf-8"),
"id": frame_id
})
await ws.send_bytes(response_object)
# Wait for possible value
self.request.execute_futures()
