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
예제 #2
0
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
예제 #4
0
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
예제 #7
0
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
예제 #9
0
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
예제 #10
0
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
예제 #11
0
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
예제 #12
0
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
예제 #13
0
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