def indexPersonMedicineByPerson():
person_id = request.json.get("person_id", None)
if person_id is None:
return jsonify({"message":
"El código de la persona es requerido."}), 400
results = PersonMedicine.query.filter_by(person_id=person_id)
if results is None:
raise APIException(
'No existen medicamentos para la persona con el id especificado.',
status_code=403)
return jsonify(list(map(lambda x: x.serialize(), results))), 200
if results is None:
# No se toma como error, simplemente no hay medicamentos para la persona
return jsonify([]), 200
else:
return jsonify(PersonMedicine.serialize(results)), 200
def list(args):
page, per_page = args.pop("page"), args.pop("per_page")
paginator = User.objects.filter(**args,
active=True).paginate(page=page,
per_page=per_page)
schema = UserSchema(many=True)
result = schema.dump(paginator.items)
if not result.errors:
payload = {"result": result.data}
args = clean_keys(args, remove_text="__iexact")
return paginated_response(paginator, "user.list", payload, args)
else:
current_app.logger.error("Error while serializing User Model",
extra={"errors": result.errors})
raise APIException(
"Internal server error while processing your requests",
status_code=500)
def delete(id):
person_medicine = PersonMedicine.query.get(id)
if person_medicine is None:
raise APIException(
'El detalle de los medicamentos de la persona con el id especificado, no fue encontrado.',
status_code=403)
try:
db.session.delete(person_medicine)
db.session.commit()
return jsonify(
'El detalle de los medicamentos fue eliminado satisfactoriamente.'
), 200
except AssertionError as exception_message:
return jsonify(msg='Error: {}. '.format(exception_message)), 400
# FIN - Definición de EndPoints para el Modelo [PersonMedicine] - FIN
def updateUsuario(id):
body = request.get_json()
usuario = Usuario.query.get(id)
if usuario is None:
raise APIException('Usuario not found', status_code=404)
if "nombre" in body:
usuario.nombre = body["nombre"]
if "email" in body:
usuario.email = body["email"]
if "password" in body:
usuario.password = body["password"]
if "edad" in body:
usuario.edad = body["edad"]
if "roles" in body:
for rol in body["roles"]:
rolAdd = Rol.query.get(rol["id"])
usuario.roles.append(rolAdd)
if "categorias" in body:
for cat in body["categorias"]:
catAdd = Categoria.query.get(cat["id"])
usuario.roles.append(rolAdd)
if "sitios_favoritos" in body:
for fav in body["sitios_favoritos"]:
favAdd = Rol.query.get(rol["fav"])
usuario.sitios_favoritos.append(favAdd)
if "comentarios" in body:
for comentarios in body["comentarios"]:
comentariosAdd = Rol.query.get(comentarios["id"])
usuario.comentarios.append(comentariosAdd)
db.session.commit()
return jsonify(Usuario.serialize(usuario)), 200
def update(id):
person_medicine = PersonMedicine.query.get(id)
if person_medicine is None:
raise APIException(
'El detalle de los medicamentos de la persona con el id especificado, no fue encontrado.',
status_code=403)
data_request = request.get_json()
person_medicine.description = data_request["description"]
person_medicine.frequency = data_request["frequency"]
person_medicine.observation = data_request["observation"]
person_medicine.update_date = datetime.datetime.now()
try:
db.session.commit()
return jsonify(PersonMedicine.serialize(person_medicine)), 200
except AssertionError as exception_message:
return jsonify(msg='Error: {}. '.format(exception_message)), 400
def indexInfoPersonQr(id):
person = Person.query.get(id)
if person is None:
raise APIException('La persona con el id especificado, no fue encontrada.',status_code=403)
person = Person.serialize(person)
personInfoQr = {
"full_name": person["full_name"],
"known_as": person["known_as"],
"emergency_contact": person["emergency_contact"],
"emergency_phone": person["emergency_phone"],
"user_image": person["user_image"],
"vaccine1_date": person["vaccine1_date"],
"vaccine2_date": person["vaccine2_date"]
}
resultsMedicine = PersonMedicine.query.filter_by(person_id=id)
personMedicine = list(map(lambda x: x.serialize(), resultsMedicine))
return jsonify({"results": personInfoQr, "medicine": personMedicine}), 200
def update(id):
user = User.query.get(id)
if user is None:
raise APIException('El usuario con el id especificado, no fue encontrado.',status_code=403)
data_request = request.get_json()
user.name = data_request["name"]
user.first_surname = data_request["first_surname"]
user.second_surname = data_request["second_surname"]
user.birth_date = data_request["birth_date"]
user.telephone_number = data_request["telephone_number"]
user.user_image = data_request["user_image"]
user.password = data_request["password"]
user.update_date = datetime.datetime.now()
try:
db.session.commit()
return jsonify(User.serialize(user)), 200
except AssertionError as exception_message:
return jsonify(msg='Error: {}. '.format(exception_message)), 400
def handle_contact():
"""
Create contact
"""
# POST request
if request.method == 'POST':
body = request.get_json()
if body is None:
raise APIException(
"You need to specify the request body as a json object",
status_code=400)
contact = Contact(name=body['name'],
email=body['email'],
phone=body['phone'],
address=body['address'])
db.session.add(contact)
db.session.commit()
return "ok", 200
# GET request
if request.method == 'GET':
contact = Contact.query.all()
contact = list(map(lambda x: x.serialize(), contact))
return jsonify(contact), 200
return "Invalid Method", 404
def get_code(email):
usuario = User.query.filter_by(email=email).first()
if usuario is None:
raise APIException('Usuario not found', status_code=404)
return jsonify(usuario.serializeCode()), 200
def get_type_canino():
pet = Pet.query.filter_by(type_pet='Canino')
if pet is None:
raise APIException("msg: pet not found", status_code=404)
request = list(map(lambda x: x.serialize(), pet))
return jsonify(request), 200
def get_pymes_id(pymes_id):
pymes = Pymes.query.get(pymes_id)
if pymes is None:
raise APIException('El pymes no existe', status_code=404)
pymesjson = pymes.serialize()
return jsonify(pymesjson), 200
def user_pva_ind(id_us):
gt_get_user_pva_ind = User.query.filter_by(id_u=id_us).first()
if gt_get_user_pva_ind is None:
raise APIException('El usuario que buscas no existe', status_code=404)
user_pva = gt_get_user_pva_ind.serialize_user()
return jsonify(user_pva), 200
def tutorias_pva_ind(id_tt):
gt_get_tutorias_pva_ind = Tutorias.query.filter_by(id_tt=id_tt).first()
if gt_get_tutorias_pva_ind is None:
raise APIException('El usuario que buscas no existe', status_code=401)
tutorias_pva = gt_get_tutorias_pva_ind.serialize_tutorias()
return jsonify(tutorias_pva), 200