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)
