def test_slots_response(self): resp = Response() try: resp.doesnt = 'exist' except AttributeError: pytest.fail('Unable to add additional variables dynamically')
def patch_response(resp: falcon.Response, headers, body, status): if body: resp.body = body resp.set_headers(headers) if isinstance(status, int): status = getattr(falcon, 'HTTP_{}'.format(status)) resp.status = status return resp
def test_default_response_context(self): resp = Response() resp.context.hello = 'World!' assert resp.context.hello == 'World!' assert resp.context['hello'] == 'World!' resp.context['note'] = 'Default Response.context_type used to be dict.' assert 'note' in resp.context assert hasattr(resp.context, 'note') assert resp.context.get('note') == resp.context['note']
def on_get(self, req: falcon.Request, resp: falcon.Response, dash_id): res = [] for event in get_data_cursor(dash_id): res.append({ 'date': event[0].isoformat(), 'value': float(event[2]) }) resp.body = json.dumps(res)
def json_response(self, filename='export.json'): serializer = Serializer() prepared_query = self.prepare_query() field_dict = {} for field in prepared_query._select: field_dict.setdefault(field.model_class, []) field_dict[field.model_class].append(field.name) def generate(): i = prepared_query.count() yield '[\n' for obj in prepared_query: i -= 1 yield json.dumps(serializer.serialize_object(obj, field_dict)) if i > 0: yield ',\n' yield '\n]' Response.append_header('Content-Type', 'application/javascript') Response.append_header('Content-Disposition', 'attachment; filename=%s' % filename) Response.body = generate();
def on_patch(self, req: falcon.Request, res: falcon.Response): # todo: use salted password if self.auth_error: raise self.auth_error nickname = req.get_param('nickname') if not nickname: raise falcon.HTTPMethodNotAllowed(ERROR_INVALID_REQUEST) if self.user and self.user['nickname'] == nickname: result = r.db(DB_NAME).table(DB_TABLE_USERS).update(self.data).run(conn) res.body = json.dumps(result) else: raise falcon.HTTPUnauthorized('Unauthorized Error', ERROR_INVALID_REQUEST)
def on_get(self, req: falcon.Request, res: falcon.Response): nickname = req.get_param('nickname') if nickname: user = r.db(DB_NAME).table(DB_TABLE_USERS).get(nickname).run(conn) if self.user and self.user['nickname'] == user['nickname']: response = user_schema_internal.dumps(user) else: response = user_schema_external.dumps(user) else: users = r.db(DB_NAME).table(DB_TABLE_USERS).run(conn) response = user_schema_external.loads(list(users), many=True) res.body = response.data
def authorize_request(self, request: falcon.Request, response: falcon.Response): uri, http_method, body, headers = extract_params(request) scope = request.params.get('scope') or '' scopes = scope.split() credentials = dict( client_id=request.params.get('client_id'), redirect_uri=request.params.get('redirect_uri', None), response_type=request.params.get('response_type', None), state=request.params.get('state', None) ) log.debug('Fetched credentials from request %r.', credentials) try: headers, body, status = self._auth_endpoint.create_authorization_response( uri, http_method, body, headers, scopes, credentials) log.debug('Authorization successful.') except FatalClientError as e: log.debug('Fatal client error %r', e) response.status = falcon.HTTP_SEE_OTHER response.set_header('Location', e.in_uri(self.error_url)) except OAuth2Error as e: log.debug('OAuth2Error: %r', e) response.status = falcon.HTTP_SEE_OTHER response.set_header('Location', e.in_uri(self.error_url)) else: patch_response(response, headers, body, status)
def on_get(self, req: falcon.Request, resp: falcon.Response): user_resp = req.get_param('g-recaptcha-response') resp.body = templates.get_template('register.html').render() resp.status = falcon.HTTP_200 resp.content_type = 'text/html' if user_resp and verify_recaptcha(user_resp, 'captcha_secret'): with db.transaction(): dash = Dash() dash.api_key = hashlib.sha1(os.urandom(2 ** 13)).hexdigest() dash.dash_id = hashlib.sha1(os.urandom(2 ** 13)).hexdigest() dash.save() resp.status = falcon.HTTP_201 resp.body = templates.get_template('register_after.html').render(api_key=dash.api_key, dash_id=dash.dash_id) elif user_resp: resp.status = falcon.HTTP_400 resp.body = templates.get_template('register.html').render()
def on_post(self, req: falcon.Request, resp: falcon.Response, dash_id): api_key, data = extract_payload(req) if not authenticate_request(req, api_key, dash_id): raise falcon.HTTPError(falcon.HTTP_401) dash = Dash.get(Dash.dash_id == dash_id) if dash.num_records > 10 ** 5: raise falcon.HTTPBadRequest schema = { "type": "object", "properties": { "key": { "type": "string", "maxLength": 32 }, "value": { "type": "number" } }, "required": ["key", "value"] } try: jsonschema.validate(data, schema) except: raise falcon.HTTPBadRequest with db.transaction(): event = Event() event.dash_id = dash event.key = data['key'] event.val = data['value'] event.save() dash.num_records += 1 dash.save() resp.status = falcon.HTTP_201
def on_get(self, req, resp: Response): resp.content_type = MEDIA_JS resp.content_type = MEDIA_HTML resp.context = {'framework': 'Falcon'}
def on_post(self, req: falcon.Request, resp: falcon.Response) -> None: """Send some data, get a prediction back.""" resp.media = {"predictions": self._predict_and_marshal(req.media)} resp.status = falcon.HTTP_OK
def on_post(self, req:falcon.Request, resp: falcon.Response): try: self._reputation_service.update(req.media) resp.status = falcon.HTTP_202 except exceptions.RidDuplicateError: raise falcon.HTTPError(falcon.HTTP_422, 'Rejected due to duplicate identifier')
def on_post(self, request: Request, response: Response): character_dto = CharacterDTO(**request.media) character: Character = self.__character_service.save( character_dto.to_model) response.body = json.dumps(character_to_dto(character).__dict__)
def on_put(self, req: falcon.Request, resp: falcon.Response, contact_id: str) -> None: data = self._controller.replace_item(req, contact_id) resp.body = self._make_response(data)
def on_get(self, req: Request, resp: Response) -> None: resp.json = self.resource.get_all_anime(limit=10) resp.status = falcon.HTTP_200
def on_get(self, req: falcon.Request, resp: falcon.Response): idx = random.randrange(0, len(self.questions)) question = self.questions[idx] resp.status = falcon.HTTP_200 resp.media = {'token': question.token, 'question': question.question}
def generate_response( res: Response, status_code: int, body_dict: dict, headers: Dict = {} ) -> NoReturn: res.status = get_http_status(status_code=status_code) res.media = body_dict res.set_headers(headers=headers)
def on_get(self, req: falcon.Request, resp: falcon.Response): if req.params and req.params['url']: process_image(req.params['url']) resp.status = falcon.HTTP_OK resp.content_type = falcon.MEDIA_HTML resp.body = '<center><img src="/images/emotionfull.png" /></center>'
def on_get_strategies(self, req: falcon.Request, resp: falcon.Response): resp.media = list(get_all_strategies().keys())
def on_get(self, _: Request, resp: Response): resp.body = json.dumps(dict(count=self._model_manager.model_count()))
def on_post(self, req: falcon.Request, resp: falcon.Response): param = SimulateRoutes.SimulateParam.from_dict(req.media) simulator = self._build_simulator(param) results = simulator.run() assert len(results) == 1 resp.media = SimulateRoutes.SimulateResponse(result=results[0]).as_dict()
def on_post(self, req: falcon.Request, resp: falcon.Response): object_id = self._controller.create_item(req) data = dict(_id=object_id) resp.body = self._make_response(data) resp.status = falcon.HTTP_201
def on_get(self, req: falcon.Request, resp: falcon.Response) -> None: data = self._controller.get_list(req) resp.body = self._make_response(data)
def on_post(self, req: Request, resp: Response): short_running_task(req.media) resp.status = falcon.HTTP_202
def on_get(self, req: Request, res: Response): res.media = {"pong": True}
def on_post_async(self, req: Request, resp: Response): long_running_task(req.media) resp.status = falcon.HTTP_202
def on_get(self, req: falcon.Request, resp: falcon.Response): resp.media = {"service": "healthy"}
def on_get(self, req: falcon.Request, resp: falcon.Response, dash_id): resp.content_type = 'text/html' resp.body = templates.get_template('dash.html').render(dash_id=dash_id)
def on_post(self, req: falcon.Request, resp: falcon.Response, rtype: str = None): """ Handles POST requests. """ # Check URL parameters if not rtype: raise falcon.HTTPBadRequest( title='Missing URL Parameters', description='Resource type identifier is required in the URL.') try: # Retrieve body parameters rname, rdata, ttl = req.media['rname'], req.media['rdata'], \ req.media.get('ttl', Config.get('default-record-ttl', 3600)) # Validate record RecordValidator.validate(rname, rtype, rdata) # Create record entity record = Record(rname=rname, rtype=rtype, ttl=ttl, rdata=rdata) # Add and commit database transaction req.context.dbconn.add(record) req.context.dbconn.commit() except KeyError as e: raise falcon.HTTPBadRequest( title='Missing Body Parameters', description=f'Missing \'{str(e)}\' in the request body.') except (InvalidDNSRecord, InvalidDNSRecordType) as e: raise falcon.HTTPConflict(title='Conflict', description=str(e)) except IntegrityError: # Rollback transaction req.context.dbconn.rollback() # Raise 409 conflict raise falcon.HTTPConflict(title='Conflict', description='Record already exists.') except SQLAlchemyError as e: # Rollback transaction req.context.dbconn.rollback() # Raise 500 internal server error raise falcon.HTTPInternalServerError( title='Internal Server Error', description=f'Message: {str(e)}') resp.status_code, resp.media = falcon.HTTP_201, { 'rname': record.rname, 'rtype': record.rtype, 'rdata': record.rdata, 'ttl': record.ttl, }
def on_get(self, req: Request, resp: Response, number: str): user: User = req.context.user fragment, has_photo = self._finder.find(parse_museum_number(number)) resp.media = create_response_dto(fragment, user, has_photo)
def curried(request: falcon.Request, response: falcon.Response, **kwargs: Any) -> None: media = method(request, response, **kwargs) if media: response.media = media
def on_put(self, req: falcon.Request, resp: falcon.Response, rtype: str = None, rname: str = None): """ Handles PUT requests. """ # Check URL parameters if not rtype: raise falcon.HTTPBadRequest( title='Missing URL Parameters', description='Resource type identifier is required in the URL.') if not rname: raise falcon.HTTPBadRequest( title='Missing URL Parameters', description='Resource name identifier is required in the URL.') # Save update statement where parameters where = {'rtype': rtype, 'rname': rname} try: # Retrieve body parameters values = { p: req.media.get(p) for p in ('rname', 'rdata', 'ttl') if req.media.get(p) } # Validate record RecordValidator.validate(values.get('rname', rname), rtype, values['rdata']) # Add and commit database transaction updated = req.context.dbconn.query(Record).filter_by( **where).update(values, synchronize_session=False) req.context.dbconn.commit() # If no rows were updated, insert if updated == 0: # Add and commit database transaction req.context.dbconn.add( Record(rname=values.get('rname', rname), rtype=rtype, rdata=values['rdata'], ttl=values.get('ttl'))) req.context.dbconn.commit() except KeyError as e: raise falcon.HTTPBadRequest( title='Missing Body Parameters', description=f'Missing \'{str(e)}\' in the request body.') except (InvalidDNSRecord, InvalidDNSRecordType) as e: raise falcon.HTTPConflict(title='Conflict', description=str(e)) except IntegrityError: # Rollback transaction req.context.dbconn.rollback() # Raise 409 conflict raise falcon.HTTPConflict(title='Conflict', description='Record already exists.') except SQLAlchemyError as e: # Rollback transaction req.context.dbconn.rollback() # Raise 500 internal server error raise falcon.HTTPInternalServerError( title='Internal Server Error', description=f'Message: {str(e)}') resp.status_code, resp.media = falcon.HTTP_200, { 'rname': values.get('rname', rname), 'rtype': rtype, 'rdata': values.get('rdata'), }
def hello_world(): resp = Response() impl.on_get(request, resp) return resp.body
def resp(): """Simple empty Response fixture.""" return Response()
def process_request(self, req: falcon.Request, resp: falcon.Response): resp.set_header('Access-Control-Allow-Origin', '*') resp.set_header('Access-Control-Allow-Headers', '*') if req.method == 'OPTIONS': raise HTTPStatus(falcon.HTTP_200)
def on_get(self, req: Request, resp: Response, field): resp.status = HTTP_200 resp.body = json.dumps({ "magic": 500, "message": "Lorem ipsum, eigh?" })
def hello_world(self, request): resp = Response() self.on_get(request, resp) return resp.body
def process_response( self, req: falcon.Request, resp: falcon.Response, resource: object, req_succeeded: bool, ): """ Intercepts outgoing responses and handles incoming CORS OPTIONS preflight requests. Args: req (falcon.Request): The Falcon `Request` object. resp (falcon.Response): The Falcon `Response` object. resource (object): Resource object to which the request was routed. May be None if no route was found for the request. req_succeeded (bool): True if no exceptions were raised while the framework processed and routed the request; otherwise False. """ # Set the `Access-Control-Allow-Origin` header. resp.set_header('Access-Control-Allow-Origin', '*') # Skip the request if it doesn't exhibit the characteristics of a CORS # OPTIONS preflight request. if not self.is_req_cors(req=req): return None msg_fmt = "Processing CORS preflight OPTIONS request." self.logger.info(msg_fmt) # Retrieve and remove the `Allow` header from the response. allow = resp.get_header('Allow') resp.delete_header('Allow') # Retrieve the `Access-Control-Request-Headers` header from the # request. allow_headers = req.get_header('Access-Control-Request-Headers', default='*') # Set the appropriate CORS headers in the response. resp.set_header(name="Access-Control-Allow-Methods", value=allow) resp.set_header( name="Access-Control-Allow-Headers", value=allow_headers, ) resp.set_header(name="Access-Control-Max-Age", value='86400')
def write_response(req: Request, res: Response) -> None: root = get_root_dir() res.content_type = 'application/cbor' res.set_header('Access-Control-Allow-Origin', '*') if req.path.endswith('/_entry-names'): path = root / req.path[1:-len('/_entry-names')] if path.is_file(): raise HTTPStatus(HTTP_404) res.data = cbor2.dumps( dict(type='plain-object', content=sorted([ re.sub(r'\.h5$', '', p.name) + ('/' if p.is_dir() else '') for p in path.glob('[!_]*') ]))) elif req.path.endswith('/_entries'): path = root / req.path[1:-len('/_entries')] if path.is_file(): raise HTTPStatus(HTTP_404) res.data = cbor2.dumps( dict(type='plain-object', content=list(_entries(path)))) elif req.path == '/_meta': res.data = cbor2.dumps( dict(type='plain-object', content=dict(spec=None, schema=get_schema()))) elif req.path.endswith('/_meta'): key = req.path[1:-len('/_meta')] if (root / key).with_suffix('.h5').is_file(): res.data = cbor2.dumps( dict(type='plain-object', content={'IS_ARRAY': True})) else: res.data = cbor2.dumps(_read_meta(root, key)) else: t_last = float(req.get_param('t_last') or 0) / 1000 entry = _read(root, req.path[1:], t_last) if entry['type'] == 'file': res.data = (root / cast(str, entry['content'])).read_bytes() else: res.data = cbor2.dumps(entry) res.status = HTTP_200
def http_422_handler(_req: falcon.Request, resp: falcon.Response, ex: Exception, _params: dict): resp.status = ex.status errors = [ex.title] if isinstance(ex.title, list) else ex.title resp.media = {'errors': errors}
def on_post(self, _req: falcon.Request, res: falcon.Response): # todo: use salted password self.data['created_on'] = int(time.time() * 1000) result = r.db(DB_NAME).table(DB_TABLE_USERS).insert(self.data).run(conn) res.body = json.dumps(result)