def getDetail(project_id):
# Load project from internal database
project = models.Project.query.filter_by(id=project_id).first()
# Check if project was found
if not project:
validation = ValidationResult(dict())
validation.addError("Project not in internal database")
return validation
# Init result cloud api
resultCloud = ResultCloud(config.RESULT_CLOUD_API)
# Try to load project
try:
response = resultCloud.get_project(project.ext_id)
except:
# Prepare validation and return result
validation = ValidationResult(models.serialize(project))
return validation
# Init result
result = models.serialize(project)
# If there was a response, get submissions
if response:
result["submissions"] = resultCloud.last_response['Result']['Submissions']
# Prepare validation and return result
validation = ValidationResult(result)
return validation
def put_response(model, field, match, not_implemented=[]):
model_to_update = model.query.filter(
getattr(model, field) == match).first()
if not model_to_update:
return not_found()
update_json = request.get_json()
if 'id' in update_json:
return bad_request('Cannot update id.')
for key in not_implemented:
if key in update_json:
return bad_request(
'Update of ' + key +
'not implemented. Use the endpoints respective to ' + key +
' to perform this operation.')
for key in update_json:
setattr(model_to_update, key, update_json[key])
db.session.add(model_to_update)
db.session.commit()
return jsonify({
'message': 'Updated.',
model.__name__.lower(): serialize(model_to_update)
})
def all_response(model, model_name):
models = model.query.paginate()
return jsonify({
'page': models.page,
'pages': models.pages,
'per_page': models.per_page,
'next': models.next_num,
'prev': models.prev_num,
model_name: [serialize(model) for model in models.items]
})
def getList():
# Init api handler
resultCloud = ResultCloud(config.RESULT_CLOUD_API)
# Try to load projects from result cloud
try:
response = resultCloud.get_git_projects()
except:
# Load internal projects
internalProjects = models.Project.query.all()
# Prepare validation and return result
validation = ValidationResult([models.serialize(project) for project in internalProjects])
return validation
# Check if the request was successful
if not response:
# Load failed
validationResult = ValidationResult(dict())
validationResult.addError("Failed to load projects from ResultCloud repository")
# Return result
return validationResult
else:
# Load was successful
externalProjects = resultCloud.last_response['Result']
# Merge new projects
for project in externalProjects:
if not models.Project.query.filter_by(ext_id=project["Id"]).first():
new_project = models.Project(project["Id"], project["Name"], project["GitRepository"])
ProjectService.save(new_project)
# Load internal projects
internalProjects = models.Project.query.all()
# Prepare validation and return result
validation = ValidationResult([models.serialize(project) for project in internalProjects])
return validation
def update(question_id):
question = Question.query.filter(Question.id == question_id).first()
if not question:
return not_found()
update_json = request.get_json()
# TODO: determine if it's better to use an exception flow here
try:
validate_json(update_json)
except (InvalidUpdateFieldError, IdUpdateError) as err:
return bad_request(err.args[0])
question.update(**update_json)
db.session.add(question)
db.session.commit()
return jsonify({'message': 'Updated.', 'question': serialize(question)})
def list(self):
page = request.GET.get('page', 1)
search = request.GET.get('search')
per_page = 20
query = User.query
if search is not None:
search = '%{}%'.format(search)
query = User.query.filter(
User.username.ilike(search) |
User.fb_id.ilike(search) |
User.name.ilike(search) |
User.gender.ilike(search))
query = query.order_by(User.name)
pagination = Pagination(query, page, per_page)
context = {
'pages': pagination.pages,
'prev': pagination.prev,
'next': pagination.next,
'current': page,
'objects': serialize(pagination.objects)
}
return context
def specific_response(model, field, match):
specific_model = model.query.filter(getattr(model, field) == match).first()
if not specific_model:
return not_found()
return jsonify(serialize(specific_model))
def getConsumptionHistory(prescription_id):
records = db.session.query(models.DrugInventory)\
.filter(models.DrugInventory.prescription_id==prescription_id)\
.order_by(models.DrugInventory.time_stamp.desc())
json_str = json.dumps({'ConsumptionHistory': [models.serialize(record) for record in records]}, default=models.custom_parser)
return Response(json_str, status=200, mimetype='application/json')
def getUserData(user_id):
user = models.User.query.get(user_id)
resp = Response(json.dumps({'User': models.serialize(user)}), status=200)
resp.mimetype = 'application/json'
return resp
def getPrescriptions(user_id):
prescriptions = db.session.query(Prescription).filter(Prescription.patient_id == user_id)
json_str = json.dumps({'Prescriptions': [models.serialize(prescription) for prescription in prescriptions]}, default=models.custom_parser)
resp = Response(json_str, status=200, mimetype='application/json')
return resp
