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()