def update_prov(id_Provider):
# recibir info del request
prov = Provider.query.get(id_Provider)
proper = Provider_Details.query.get(id_Provider)
print("Hola")
if prov is None:
raise APIException('Provider not found', status_code=404)
if proper is None:
raise APIException('Provider_Details not found', status_code=404)
request_body = request.get_json()
if "name_Provider" in request_body:
prov.name_Provider = request_body["name_Provider"]
if "email_Provider_Details" in request_body:
proper.email_Provider_Details = request_body["email_Provider_Details"]
if "phone_Provider_Details" in request_body:
proper.phone_Provider_Details = request_body["phone_Provider_Details"]
if "address_Provider_Details" in request_body:
proper.address_Provider_Details = request_body[
"address_Provider_Details"]
if "payment_Type_Provider_Details" in request_body:
proper.payment_Type_Provider_Details = request_body[
"payment_Type_Provider_Details"]
db.session.commit()
return jsonify("All good"), 200
def tutorias_contract(id_us):
get_tutorias_user = User.query.filter_by(id_u=id_us).first()
if get_tutorias_user is None:
raise APIException('El usuario que buscas no existe', status_code=401)
if request.method == 'GET':
get_tutorias_c_user = Tutoria_Contratada.query.filter_by(
user_id_fk=id_us).all()
if get_tutorias_c_user is None:
raise APIException(
'El usuario que busca no tiene tutorias contratadas',
status_code=402)
user_contract = list(
map(lambda x: x.serialize_tutoria_contratada(),
get_tutorias_c_user))
return jsonify(user_contract), 200
elif request.method == 'POST':
get_tutorias_c_user = User.query.filter_by(id_u=id_us).first()
if get_tutorias_c_user is None:
raise APIException('El usuario que buscas no existe',
status_code=401)
request_body = request.get_json()
for i in request_body:
insert_contract = Tutoria_Contratada(
tutoria_id_fk=i["tutoria_id_fk"],
user_id_fk=i["user_id_fk"],
fecha_contrato=i["fecha_contrato"],
is_active=i["is_active"],
fecha_cierre=i["fecha_cierre"])
db.session.add(insert_contract)
db.session.commit()
return jsonify({"Todo ok": request_body}), 200
def register():
email = request.json.get("email", None)
username = request.json.get("username", None)
password = request.json.get("password", None)
security_question = request.json.get("security_question", None)
security_answer = request.json.get("security_answer", None)
is_active = request.json.get("is_active", None)
# validar que contengan informacion
if email is None or username is None or password is None or security_question is None or security_answer is None:
raise APIException('Correo, nombre de usuario, contraseña, pregunta secreta o respuesta secreta no encontrados', status_code=406)
# valida que el email, username y password no estn en vacios
if email == "" or username == "" or password == "" or security_question == "" or security_answer == "":
raise APIException('Correo, nombre de usuario, contraseña, pregunta secreta o respuesta secreta estan vacios', status_code=407)
# valida si el email ya existe
emailrepetido = User.query.filter_by(email=email).first()
# emailrepetido = list(map(lambda x: x.serialize(), emailrepetido))
if emailrepetido is not None:
raise APIException('El correo ya existe', status_code=409)
# valida si el usuario ya existe
userrepetido = User.query.filter_by(username=username).first()
# userrepetido = list(map(lambda x: x.serialize(), userrepetido))
if userrepetido is not None:
raise APIException('El usuario ya se encuentra registrado', status_code=410)
# registro del nuevo usuario
# se usa la funcion generate_password_hash para encriptar el password y la respuesta a la pregunta de seguridad que el usuario registro
newUser = User(username=username, email=email,
password=generate_password_hash(password, "sha256"), is_active=is_active, security_question = security_question, security_answer = generate_password_hash(security_answer, "sha256"))
db.session.add(newUser)
db.session.commit()
return jsonify('Se registro el usuario correctamente'), 200
def add_favorite():
# Agregar validación para que no hayan repetidos en el mismo usuario.
user_id = get_jwt_identity() #THIS CAN BE THE EMAIL
print("Hola", user_id)
user = User.query.filter_by(id=user_id).first()
if request.method == 'POST':
req = request.get_json()
if req is None:
raise APIException("Resquest is need as a json object", status_code=400)
if 'cocktail_id' not in req:
raise APIException("Cocktail ID must be typed ", status_code=400)
if 'cocktail_name' not in req:
raise APIException("Cocktail name must be typed", status_code=400)
fav = Favorite(cocktail_id=req["cocktail_id"],cocktail_name= req["cocktail_name"], user_id=user.id)
db.session.add(fav)
db.session.commit()
getFavUser = Favorite.query.filter_by(user_id = user.id)
mapping = list(map(lambda f: f.serialize(), getFavUser))
return jsonify(mapping), 200 #It is OK
if request.method == 'GET':
myfavs = Favorite.query.all()
myfavs = list(map(lambda f: f.serialize(), favs))
return jsonify(myfavs), 200
return "Error, invalid method", 404
def login():
body = request.get_json()
email = body["email"]
password = body["password"]
user = User.get_with_email(email)
if user is None:
raise APIException("Datos incorrectos")
if check_password_hash(user.password, password):
access_token = create_access_token(identity=user.id)
return jsonify({"access_token": access_token})
else:
raise APIException("Datos incorrectos")
def ratePost(id):
# Obtener el ID del usuario registrado get_jwt_identity
current_user_id = get_jwt_identity()
user = User.query.get(current_user_id)
if user is None:
raise APIException('Usuario no registrado', status_code=420)
# Verificar si el request obtiene un campo valido
puntuacion = request.json.get("puntuacion", None)
if puntuacion is None:
raise APIException('Request invalido', status_code=421)
# Obtener el post seleccionado
selectedPost = Post.query.get(id)
if selectedPost is None:
raise APIException('No se encontro el Post', status_code=422)
# Guardar puntuacion
createdDate = datetime.datetime.now()
createdDate = createdDate.strftime("%d/%m/%Y %H:%M:%S")
updatedDate = datetime.datetime.now()
updatedDate = updatedDate.strftime("%d/%m/%Y %H:%M:%S")
newPostLike = Post_like(created = createdDate, updated = updatedDate, puntuacion = puntuacion, idpost = id,\
iduser = user.id)
db.session.add(newPostLike)
db.session.commit()
# Actualizar rate
# Obtener todos los votos del post
votesPost = Post_like.query.filter_by(idpost=id)
# Se mapean los resultados
all_votes = list(map(lambda x: x.serialize(), votesPost))
average = 0
for votes in all_votes:
average = average + votes["puntuacion"]
average = int(average/len(all_votes))
print("Average")
print(average)
selectedPost.total_like = average
db.session.commit()
return jsonify('Se actualizo la puntuacion'), 200
def indexPersonVaccine(id):
person_vaccine = PersonVaccine.query.get(id)
if person_vaccine is None:
raise APIException('El detalle de las vacunas de la persona con el id especificado, no fue encontrado.',status_code=403)
return jsonify(PersonVaccine.serialize(person_vaccine)), 200
def update_user(id_Document_User):
userUpdate = User.query.get(id_Document_User)
print("Hola")
if userUpdate is None:
raise APIException('User not found', status_code=404)
request_body = request.get_json()
if "name_User" in request_body:
userUpdate.name_User = request_body["name_User"]
if "email_User_Details" in request_body:
userUpdate.user.email_User_Details = request_body["email_User_Details"]
if "password_User_Details" in request_body:
userUpdate.user.password_User_Details = request_body[
"password_User_Details"]
if "cargo_User_Details" in request_body:
userUpdate.user.cargo_User_Details = request_body["cargo_User_Details"]
if "phone_User_Details" in request_body:
userUpdate.user.phone_User_Details = request_body["phone_User_Details"]
if "address_Details" in request_body:
userUpdate.user.address_Details = request_body["address_Details"]
db.session.commit()
return jsonify("All good"), 200
def create():
many = False
if isinstance(request.json["data"], type([])):
many = True
schema = UserSchema(many=many)
result = schema.load(request.json["data"])
if not result.errors:
if many:
for user in result.data:
user.save()
else:
result.data.save()
return jsonify(schema.dump(result.data).data), 201
else:
current_app.logger.error("Error creating new User",
extra={"errors": result.errors})
raise APIException("Error processing your request",
status_code=400,
payload=result.errors)
def handle_upload():
if 'image' not in request.files:
raise APIException("No image to upload")
my_image = UserImage()
result = cloudinary.uploader.upload(
request.files['image'],
public_id=f'sample_folder/profile/my-image-name',
crop='limit',
width=450,
height=450,
eager=[
{
'width': 200,
'height': 200,
'crop': 'thumb',
'gravity': 'face',
'radius': 100
},
],
tags=['profile_picture'])
my_image.url = result['secure_url']
my_image.save()
return jsonify(my_image.serialize()), 200
def deleteSitio(id):
sitio = Sitio.query.get(id)
if sitio is None:
raise APIException('Site not found', status_code=404)
db.session.delete(sitio)
db.session.commit()
return jsonify(sitio), 200
def get_cancha(id):
cancha = Cancha.query.get(id)
if cancha is None:
raise APIException('Cancha not found', status_code=404)
return jsonify(cancha.serialize()), 200
def deleteUsers(id):
user = Usuario.query.get(id)
if user is None:
raise APIException('User not found', status_code=404)
db.session.delete(user)
db.session.commit()
return jsonify(user), 200
def indexUser(id):
user = User.query.get(id)
if user is None:
raise APIException('El usuario con el id especificado, no fue encontrado.',status_code=403)
return jsonify(User.serialize(user)), 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.user_image = data_request["user_image"]
# user.user_image = data_request["user_image"]
#user.password = data_request["password"]
profile = Profile.query.get(id)
profile.personal_description = data_request["personal_description"]
profile.occupation = data_request["occupation"]
profile.location = data_request["location"]
profile.hobbies = data_request["hobbies"]
try:
db.session.commit()
return jsonify(User.serialize(user)), 200
except AssertionError as exception_message:
return jsonify(msg='Error: {}. '.format(exception_message)), 400
def get_user(user_id):
user = User.query.get(user_id)
if user is None:
raise APIException('este usuario no existe en la base de datos',
status_code=404)
userjson = user.serialize()
return jsonify(userjson), 200
def get_user(id):
user = User.query.get(id)
if user is None:
raise APIException('User not found', status_code=404)
return jsonify(user.serialize()), 200
def addNewPost():
# Obtener el ID del usuario registrado get_jwt_identity
current_user_id = get_jwt_identity()
user = User.query.get(current_user_id)
# Se reporta un error si no esta registrado
if user is None:
raise APIException('No se ha iniciado sesión', status_code=400)
#Obtener el request body
request_body = request.get_json()
# Validate the data
if (request_body["title"] is None or request_body["comment"] is None or request_body["url"] is None or request_body["provincia"] is None \
or request_body["dificultad"] is None or request_body["duracion"] is None):
raise APIException('Request Body inválido. Uno o más parámetros están vacíos', status_code=400)
#Crear Nuevo Post
createdDate = datetime.datetime.now()
createdDate = createdDate.strftime("%d/%m/%Y %H:%M:%S")
updatedDate = datetime.datetime.now()
updatedDate = updatedDate.strftime("%d/%m/%Y %H:%M:%S")
total_comment = 35
total_like = 35
newPost = Post(created = createdDate, updated = updatedDate, title = request_body["title"], comment = request_body["comment"],\
url = request_body["url"], provincia = request_body["provincia"], dificultad = request_body["dificultad"], duracion = request_body["duracion"],\
total_comment = total_comment, total_like = total_like, iduser = user.id)
db.session.add(newPost)
db.session.commit()
tmpObj = newPost.serialize()
#Obtener Post Guardado
# Guardar puntuacion inicial
createdDate = datetime.datetime.now()
createdDate = createdDate.strftime("%d/%m/%Y %H:%M:%S")
updatedDate = datetime.datetime.now()
updatedDate = updatedDate.strftime("%d/%m/%Y %H:%M:%S")
newPostLike = Post_like(created = createdDate, updated = updatedDate, puntuacion = 35, idpost = tmpObj["id"],\
iduser = user.id)
db.session.add(newPostLike)
db.session.commit()
return jsonify('Nuevo Post publicado'), 200
def deleteclasscreate(id):
clase = Actividades.query.get(id)
if clase is None:
raise APIException('User not found', status_code=404)
db.session.delete(clase)
db.session.commit()
return jsonify("ok"), 200
def delete_adopt(id):
#current_user = get_jwt_identity()
adopt1 = Adopt.query.get(id)
if adopt1 is None:
raise APIException("adopt is not found", status_code=404)
db.session.delete(adopt1)
db.session.commit()
return jsonify({"Succesfully delete by": "hi"}), 200
def borrar_mi_pasaporte(user_id, id_pyme):
favorito = Mi_pasaporte.query.filter_by(user_id=user_id,
id_pyme=id_pyme).first()
if favorito is None:
raise APIException('favorito no encontrado', status_code=404)
db.session.delete(favorito)
db.session.commit()
return jsonify({"msg": "el favorito se elimino con exito"}), 200
def tutorias_contract_del(id_c_tc):
gt_tutorias_contract_del = Tutoria_Contratada.query.filter_by(
id_tc=id_c_tc).first()
if gt_tutorias_contract_del is None:
raise APIException('La tutoria contratada no existe', status_code=403)
db.session.delete(gt_tutorias_contract_del)
db.session.commit()
return jsonify({"Fue eliminada la tutoria ID: ": id_c_tc}), 201
def del_user_by_ID(user_id):
user = User.query.filter_by(id=user_id).first_or_404()
if user is None:
raise APIException("Usuario no encontrado", status_code=404)
else:
db.session.delete(user)
db.session.commit()
return jsonify(user.serialize()), 204 #indicates that the server has successfully fulfilled the request and that there is no content to send in the response payload body
def delete_usuario():
current_user_id = get_jwt_identity()
user = User.query.filter_by(id=current_user_id).first()
if user is None:
raise APIException("usuario no existe!", status_code=404)
db.session.delete(user)
db.session.commit()
return jsonify({"Usuario eliminado": "ok"}), 200
def propiedades():
body = request.get_json()
user_id = get_jwt_identity()
try:
propiedad_id = Propiedad.create_propiedad(
user_id, body["titulo"], body["calle"], body["numero"],
body["codigo_postal"], body["dormitorios"], body["huespedes"],
body["camas"], body["bathrooms"], body["precio"],
body["descripcion"])
propiedad = Propiedad.get(propiedad_id)
if (Provincias.get(body["provincia"]) != None):
existing_provincia = Provincias.get(body["provincia"])
existing_provincia.propiedades.append(propiedad)
db.session.add(existing_provincia)
db.session.commit()
else:
propiedad = Propiedad.query.filter(
Propiedad.id == propiedad_id).delete()
db.session.commit()
raise APIException("Provincia no existente")
if (Localidades.get(body["ciudad"])):
existing_localidad = Localidades.get(body["ciudad"])
existing_localidad.propiedades.append(propiedad)
db.session.add(existing_localidad)
db.session.commit()
else:
propiedad = Propiedad.query.filter(
Propiedad.id == propiedad_id).delete()
db.session.commit()
raise APIException("Localidad no existente")
for amenidad in body["amenidades"]:
if (Amenidades.get(amenidad) != None):
existing_amenity = Amenidades.get(amenidad)
propiedad.amenidades.append(existing_amenity)
db.session.add(existing_amenity)
db.session.commit()
else:
raise APIException("Amenidad no existente")
except Exception as e:
print(e)
raise APIException("Todos los campos son obligatorios")
return jsonify("se subio la informacion"), 200
def signup():
body = request.get_json()
password = body["password"]
hashed = generate_password_hash(password, "sha256")
if User.get_with_email(body["email"]):
raise APIException("Esta cuenta ya existe")
User.create_user(body["name"], body["lastname"], body["email"], hashed)
return jsonify({}), 200
def delete_fav_by_id(fav_id):
fav = Favorite.query.filter_by(id=fav_id).first_or_404()
print(fav)
if fav is None:
raise APIException('Favorito no encontrado', status_code=404)
else:
db.session.delete(fav)
db.session.commit()
return jsonify(fav.serialize()), 200 #indicates that the server has successfully fulfilled the request and that there is no content to send in the response payload body
def getPostById(id):
post = Post.query.get(id)
if post is None:
raise APIException('Post no encontrado', status_code=420)
postReq = post.serialize()
return jsonify(postReq), 200
def del_medicamentos(id):
del_med = Medicamentos.query.get(id)
if del_med is None:
raise APIException('Medicamento no encontrado', status_code=404)
db.session.delete(del_med)
db.session.commit()
return jsonify("delete successful"), 200
def deleteProduct(id):
current_id = get_jwt_identity()
delproduct = Product.query.get(id)
if delproduct is None:
raise APIException("There is not product to delete", status_code=404)
db.session.delete(delproduct)
db.session.commit()
return jsonify({"msg": "The product has being successfully deleted."}), 200