def __get_item(self, req: Request, resp: Response, obj_id):
resp.content_type = MEDIA_JSON
try:
nid = int(obj_id)
except (TypeError, ValueError):
resp.status = HTTP_BAD_REQUEST
resp.body = '{"message": "Invalid id"}'
return
schema_class = self.__get_schema_class('get')
with scoped_session() as session:
query = self._apply_permissions(req, {'method': 'get'},
self.get_base_query(session))
qf = [
self.model_class.id == nid,
]
if issubclass(self.model_class, SoftDelete):
qf.append(self.model_class.deleted == false())
q = query.filter(*qf)
q = self._apply_permissions(req, {'method': 'get'}, q)
instance = q.first()
if instance is None:
resp.status = HTTP_NOT_FOUND
return
item, _ = schema_class().dump(instance)
resp.status = HTTP_OK
resp.body = json.dumps(item)
def on_post(self, req: Request, resp: Response):
try:
params = json.loads(req.stream.read(req.content_length or 0))
except (TypeError, ValueError):
resp.status = HTTP_BAD_REQUEST
return
schema_class = self.get_list_schema_class()
with scoped_session() as session:
query = self._apply_permissions(req, {'method': 'list'},
self.get_base_query(session))
count = query.count()
if issubclass(self.model_class, SoftDelete):
query = query.filter(self.model_class.deleted == false())
try:
query = self.__apply_selector(query, params)
except InvalidSelectorException as e:
resp.status = HTTP_BAD_REQUEST
resp.body = json.dumps({'error': e.message})
return
query = self._apply_sort(query, params)
query = self._apply_limit(query, params)
query = self._apply_offset(query, params)
from sqlalchemy.dialects import postgresql
print(str(query.statement.compile(dialect=postgresql.dialect())))
items = schema_class().dump(query, many=True)
resp.body = json.dumps({'count': count, 'results': items.data})
def on_post(self, req: falcon.Request, res: falcon.Response) -> None:
payload = json.loads(req.stream.read())
if 'img' not in payload:
res.status = falcon.HTTP_400
res.body = json.dumps({"title": "Missing parameter", "description": "The \"img\" parameter is required."})
return
img = payload['img']
try:
mediatype, imgbytes = parse(img)
except ValueError as e:
res.status = falcon.HTTP_400
res.body = json.dumps({"title": "Invalid \"img\" parameter", "description": str(e)})
return
started = time.time()
result = self.infer_fn(imgbytes)
elapsed = time.time() - started
body = {
'result': result,
'infer_secs': elapsed
}
res.status = falcon.HTTP_200
res.body = json.dumps(body, ensure_ascii=False)
def on_post(self, req: Request, res: Response):
username = req.media.get("username")
password = req.media.get("password")
print(username, password)
if username == None or password == None:
res.status = HTTP_401
res.body = json.dumps({
"error":
True,
"message":
"One or more required params were not provided!"
})
return
username_is_available = self.__username_is_available(username)
print(username_is_available)
if username_is_available == False:
res.status = HTTP_409
res.body = json.dumps({
"error": True,
"message": "Username already in use!"
})
return
self.__insert_user(username, password)
res.status = HTTP_201
res.body = json.dumps({"success": True})
def on_get(self, req: falcon.Request, resp: falcon.Response) -> None:
"""
---
summary: Get all payments owned by the authenticated user from the DB or all if admin
tags:
- Payment
parameters:
- in: query
schema: CoreListSchema
produces:
- application/json
responses:
200:
description: All Payments
schema:
type: array
items: Payment
401:
description: Unauthorized
"""
user = req.context['user']
user.export()
if 'Admin' not in user.role.name:
rv = self._service.find(owner_id=str(user.id))
resp.body = self._json_or_404(rv)
else:
rv = self._service.all()
resp.body = self._json_or_404(rv)
def on_post(self, req: Request, resp: Response) -> None:
"""Post /v1/user register new user by only simple uuid"""
try:
data = json.loads(req.bounded_stream.read())
user = self.session.query(User).filter(
User.uuid == data["uuid"]).first()
if user:
resp.status = falcon.HTTP_200 # This is the default status
resp.body = user.json()
else:
new_user = User()
new_user.uuid = data["uuid"]
self.session.add(new_user)
self.session.commit()
resp.status = falcon.HTTP_200 # This is the default status
resp.body = new_user.json()
except Exception as err:
print(err)
self.session.rollback()
self.session.close()
resp.status = falcon.HTTP_400
def process_response(self, req: falcon.Request, resp: falcon.Response,
resource: Resource) -> None:
try:
payload = resp.payload
except AttributeError:
pass
else:
method = req.method.lower()
schema = self._get_schema(resource, method, "response")
if not schema and bool(payload):
resp.body = json.dumps(payload)
if not schema:
return
try:
data = schema.dumps(payload, many=utils.is_collection(payload))
except ValidationError as err:
raise falcon.HTTPInternalServerError(
title="Could not serialize response",
description=json.dumps(err.messages),
)
resp.body = data
def on_post_change(self, req: Request, resp: Response):
try:
input_data = json.loads(req.stream.read(req.content_length or 0))
except (ValueError, KeyError):
resp.status = HTTP_BAD_REQUEST
return
changes, errors = UpwardChangeSchema().load(input_data, many=True)
if errors is not None:
errors_num = len(errors)
if errors_num > 0:
resp.status = HTTP_BAD_REQUEST
resp.body = json.dumps({'errors': errors})
return
results = []
for change in changes:
try:
res, conflict = self.__process_upward_change(change)
except (exc.FixedModel, exc.InvalidSyncEntry,
exc.InvalidSyncEntryType, exc.InvalidSyncModel,
exc.ModelNotFound):
resp.status = HTTP_BAD_REQUEST
resp.body = json.dumps({'errors': errors})
return
results.append(res)
if conflict:
resp.status = HTTP_CONFLICT
resp.body = json.dumps(results)
resp.status = HTTP_OK
resp.body = json.dumps(results)
def on_put(self, req: falcon.Request, resp: falcon.Response, user_id: str,
note_id: str):
user: User = req.user
if user_id != str(user.uuid):
resp.status = falcon.HTTP_BAD_REQUEST
resp.body = 'Attempting to update another user\'s data'
return
try:
payload = json_util.loads(req.bounded_stream.read())
note_filter = {'_id': ObjectId(note_id), 'user': ObjectId(user_id)}
data = {
'$set': {
'text': payload.get('text', ''),
'dateModified': datetime.now()
}
}
except json.JSONDecodeError:
resp.status = falcon.HTTP_BAD_REQUEST
resp.body = 'Invalid payload provided'
return
try:
self._notes.update_one(note_filter, data)
except WriteError:
resp.status = falcon.HTTP_BAD_REQUEST
resp.body = 'The provided payload failed to pass validation'
return
def on_get_doc(self, resp: Response, obj_id=None):
if obj_id is None:
resp.status = HTTP_METHOD_NOT_ALLOWED
return
try:
cid = int(obj_id)
except (TypeError, ValueError):
resp.status = HTTP_BAD_REQUEST
resp.body = '{"message": "Invalid id"}'
return
with scoped_session() as session:
change = session.query(Change).filter(Change.id == cid).first()
if change is None:
resp.status = HTTP_NOT_FOUND
return
obj = self.__get_object_dump_by_change(session, change)
if obj is None:
resp.status = HTTP_NOT_FOUND
return
resp.status = HTTP_OK
resp.body = json.dumps(obj)
def on_get(self, req: falcon.Request, resp: falcon.Response) -> None:
"""
For an admin user, this endpoint returns all applications, for a user it
returns all of the applications they own.
---
summary: Get all Applications from the DB
tags:
- Application
parameters:
- in: query
schema: CoreListSchema
produces:
- application/json
responses:
200:
description: All Applications
schema:
type: array
items: Application
401:
description: Unauthorized
"""
user = req.context['user']
user.export()
if not user.is_admin:
rv = self._service.find(owner_id=str(user.id))
resp.body = self._json_or_404(rv)
else:
rv = self._service.all()
resp.body = self._json_or_404(rv)
def on_get_changes(self, req: Request, resp: Response):
since = req.get_param_as_int('since', required=False, default=0)
batch_size = req.get_param_as_int('batch_size',
required=False,
default=50)
i = 0
end = False
items = []
with scoped_session() as session:
while i < batch_size and not end:
obj = session.query(Change).filter(Change.id > since).first()
if obj is None:
end = True
break
item, errors = ChangeSchema().dump(obj)
if errors is not None:
errors_num = len(errors)
if errors_num > 0:
resp.status = HTTP_BAD_REQUEST
resp.body = json.dumps({'errors': errors})
return
if self.__can_read_change(req, item):
items.append(item)
since = since + 1
i = i + 1
resp.status = HTTP_OK
resp.body = json.dumps(items)
def on_put(self, req: Request, resp: Response, run_id: str) -> None:
# Start a run
if self.workflow.in_progress():
error = f"Can only run one instance of a workflow at a time, {run_id} rejected."
log.error(error)
raise falcon.HTTPError(falcon.HTTP_403, 'Concurrency Error', error)
log.info("Starting calculations for RUN_ID: " + run_id)
try:
if not db.is_valid_run_id(run_id):
result = {'status': "invalid job id: " + run_id}
resp.status = falcon.HTTP_401
resp.body = json.dumps(result)
return
thr = threading.Thread(target=self.workflow.run_calculations, args=(run_id,))
thr.start()
log.info(f"started job: {run_id}")
result = {'status': "started job: " + run_id}
resp.body = json.dumps(result)
except ValueError:
raise falcon.HTTPError(falcon.HTTP_400, 'Invalid JSON',
'Could not decode the request body. The JSON was invalid.')
def on_post(self, req: Request, resp: Response, subreddit: Text):
log.info('Attempting to create monitored sub %s', subreddit)
try:
self.reddit.subreddit(subreddit).mod.accept_invite()
except APIException as e:
if e.error_type == 'NO_INVITE_FOUND':
log.error('No open invite to %s', subreddit)
raise HTTPInternalServerError(
f'No available invite for {subreddit}',
f'We were unable to find a '
f'pending mod invote for r/{subreddit}')
else:
log.exception('Problem accepting invite', exc_info=True)
raise HTTPInternalServerError(
f'Unknown error accepting mod invite for r/{subreddit}',
f'Unknown error accepting mod invite for r/{subreddit}. Please contact us'
)
except Exception as e:
log.exception('Failed to accept invite', exc_info=True)
raise HTTPInternalServerError(
f'Unknown error accepting mod invite for r/{subreddit}',
f'Unknown error accepting mod invite for r/{subreddit}. Please contact us'
)
with self.uowm.start() as uow:
existing = uow.monitored_sub.get_by_sub(subreddit)
if existing:
resp.body = json.dumps(existing.to_dict())
return
monitored_sub = create_monitored_sub_in_db(subreddit, uow)
resp.body = json.dumps(monitored_sub.to_dict())
def on_get(self, req: Request, resp: Response, subreddit: Text):
with self.uowm.start() as uow:
sub = uow.monitored_sub.get_by_sub(subreddit)
if not sub:
resp.body = json.dumps({})
return
resp.body = json.dumps(sub.to_dict())
def on_get(self, _: Request, resp: Response, dataset_id: UUID):
result = self._dataset_manager.get_dataset(dataset_id)
if isinstance(result, Dataset):
resp.body = result.json()
resp.status = falcon.HTTP_202
else:
resp.body = json.dumps(dict(error=result))
resp.status = falcon.HTTP_404
def on_post(self, req: Request, resp: Response):
result = self._model_manager.import_model(req)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = result.json()
resp.status = falcon.HTTP_201
def on_get(self, req: Request, resp: Response):
result = self._method_manager.count_methods()
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = json.dumps(dict(count=result))
resp.status = falcon.HTTP_201
def on_get(self, _: Request, resp: Response, model_id: UUID):
result = self._model_manager.update_model(model_id)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = json.dumps(dict(result), cls=DataclassJSONEncoder)
resp.status = falcon.HTTP_201
def on_post(self, req: Request, resp: Response, snap_id: UUID):
result = self._resource_manager.create_monitor(req.media['id'])
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = result.json()
resp.status = falcon.HTTP_201
def on_delete(self, _: Request, resp: Response, snap_id: UUID):
result = self._resource_manager.remove_monitor(snap_id)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_404
else:
resp.body = result.json()
resp.status = falcon.HTTP_202
def on_get(self, req: Request, resp: Response):
monitors = self._resource_manager.monitors()
if isinstance(monitors, Exception):
resp.body = json.dumps(dict(error=str(monitors)))
resp.status = falcon.HTTP_500
else:
resp.body = json.dumps(monitors)
resp.status = falcon.HTTP_201
def on_delete(self, _: Request, resp: Response, model_id: UUID):
result = self._model_manager.delete_model(model_id)
if isinstance(result, Model):
resp.body = result.json()
resp.status = falcon.HTTP_202
else:
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_404
def on_get(self, _: Request, resp: Response, model_id: UUID):
result = self._model_manager.model_version_count(model_id)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = json.dumps(dict(count=result))
resp.status = falcon.HTTP_200
def on_get(req: falcon.Request, resp: falcon.Response):
database = connect(constants.DB_URL)
current_analyses_table = database[constants.CURRENT_ANALYSES_TABLE]
if req.get_param(constants.TWEET_TOPIC_TABLE_KEY_NAME):
if current_analyses_table.find_one(
analysis_topic_id=req.get_param_as_int(
constants.TWEET_TOPIC_TABLE_KEY_NAME)):
resp.status = falcon.HTTP_OK
resp.body = dumps({'currently_analysing': True})
else:
resp.status = falcon.HTTP_OK
resp.body = dumps({'currently_analysing': False})
elif req.get_param(constants.TWEET_USER_TABLE_KEY_NAME):
if current_analyses_table.find_one(
analysis_user_id=req.get_param_as_int(
constants.TWEET_USER_TABLE_KEY_NAME)):
resp.status = falcon.HTTP_OK
resp.body = dumps({'currently_analysing': True})
else:
resp.status = falcon.HTTP_OK
resp.body = dumps({'currently_analysing': False})
elif req.get_param('all'):
data = {'current_analyses': []}
current_analyses = current_analyses_table.all()
for current_analysis in current_analyses:
if current_analysis[constants.TWEET_TOPIC_TABLE_KEY_NAME]:
if current_analysis['is_hashtag']:
data['current_analyses'].append({
'type':
'hashtag',
'analysis_topic_id':
current_analysis[
constants.TWEET_TOPIC_TABLE_KEY_NAME]
})
else:
data['current_analyses'].append({
'type':
'topic',
'analysis_topic_id':
current_analysis[
constants.TWEET_TOPIC_TABLE_KEY_NAME]
})
elif current_analysis[constants.TWEET_USER_TABLE_KEY_NAME]:
data['current_analyses'].append({
'type':
'user',
'analysis_user_id':
current_analysis[constants.TWEET_USER_TABLE_KEY_NAME]
})
resp.status = falcon.HTTP_OK
resp.body = dumps(data)
else:
resp.status = falcon.HTTP_NOT_FOUND
def on_post(self, req: Request, resp: Response):
snap = ModelSnapshot.from_json(req.media['ModelSnapshot'])
result = self._snapshot_manager.create_snapshot(snap)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = result.json()
resp.status = falcon.HTTP_201
def on_delete(self, _: Request, resp: Response, dataset_id: UUID,
version_id: UUID):
result = self._dataset_manager.delete_version(dataset_id, version_id)
if isinstance(result, DatasetVersion):
resp.body = result.json()
resp.status = falcon.HTTP_200
else:
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_404
def on_get(self, req: Request, resp: Response):
query = get_params_to_query(req, SORT_ATTRIBUTES, 'created', 'desc')
methods = self._method_manager.list_methods(query=query)
if isinstance(methods, Exception):
resp.body = json.dumps(dict(error=str(methods)))
resp.status = falcon.HTTP_500
else:
resp.body = f"[{','.join(map(lambda x: x.json(), methods))}]"
resp.status = falcon.HTTP_201
def on_post(self, req: Request, resp: Response):
result = Result.from_json(req.media['Result'])
result = self._result_manager.replace(result)
if isinstance(result, Exception):
resp.body = json.dumps(dict(error=str(result)))
resp.status = falcon.HTTP_500
else:
resp.body = json.dumps(asdict(result), cls=DataclassJSONEncoder)
resp.status = falcon.HTTP_201
def on_get(self, req: falcon.Request, resp: falcon.Response, user_id: str,
note_id: str):
user: User = req.user
if user_id != str(user.uuid):
resp.status = falcon.HTTP_BAD_REQUEST
resp.body = 'Attempting to access another user\'s data'
return
user_notes = self._notes.find({'_id': ObjectId(note_id)})
resp.body = json_util.dumps(user_notes)
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 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 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 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 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, 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, 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)
