def __init__(self):
self.dbx = DatabaseX()
self.colores = Colores()
self.medidas = Medidas()
self.user = ""
self.correo = ""
self.contra = ""
def enviarRegistro(self):
database = DatabaseX()
sql = (
"INSERT INTO `myfitapp`.`registrodiario`(`id_registro`,`id_usuario`,`cintura`,`cuello`,`pesoActual`,`fecha`)"
+ "VALUES(0,1," + str(self.cintura) + "," + str(self.cuello) +
"," + str(self.peso) + ",curdate());")
database.executeNonQueryBool(sql)
mensaje = print("El registro se guardó correctamente")
return mensaje
class Login:
def __init__(self):
self.idUser = 0
self.dbx = DatabaseX()
pass
def comprobacion(self, usuario, contra):
sqlCount = f"SELECT COUNT(*) FROM myfitapp.usuario WHERE user = '******'"
# Imprime para comprobar el sql que cuenta registros
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime para comprobar el diccionario que resulta de la consulta de sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime para comprobar el número contado
# print(rowsNum)
if rowsNum == 1:
sqlSelect = f"SELECT * FROM myfitapp.usuario WHERE user = '******'"
selectUserDic = self.dbx.executeQueryOneRow(sqlSelect)
# Imprime el diccionario que resulta de ejecutar sqlSelect
# print(selectUserDic)
contraBD = selectUserDic.get("contra")
# Imprime la contraseña de la BD
# print(contraBD)
if contraBD == contra:
idBD = selectUserDic.get("id_usuario")
self.idUser = idBD
return True
else:
print("Contraseña incorrecta")
return False
else:
print("El usuario que ha ingresado no existe")
def idUsuario(self):
return self.idUser
def __init__(self, idUser):
self.idUser = idUser
self.colores = Colores()
self.idAlimento = 0
self.dbx = DatabaseX()
class Alimentacion:
def __init__(self, idUser):
self.idUser = idUser
self.colores = Colores()
self.idAlimento = 0
self.dbx = DatabaseX()
def agregarAlimento(self):
while True:
while True:
try:
idAlimento = int(
input(
"Ingrese el ID de su alimento, si desconoce el ID ingrese 0 para ir al buscador: "
))
if idAlimento < 0 or idAlimento is None:
print("")
print(
colores.red(
"Ese valor de id Alimento no es válido"))
print("")
else:
self.idAlimento = idAlimento
break
except Exception:
print("")
print(
self.colores.red(
"El campo de id Alimento solo acepta valores numéricos"
))
print("")
if idAlimento == 0:
result = False
break
else:
sqlCount = f"SELECT COUNT(*) FROM myfitapp.producto WHERE id_producto = '{self.idAlimento:}' and (id_usuario = 0 or id_usuario = '{self.idUser:}'"
# Imprime para comprobar estructura del sqlCount
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime el diccionario resultante de ejecutar sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime el numero de filas con ese ID de alimento
# print(rowsNum)
if rowsNum == 1:
result = True
break
else:
print("")
print(
self.colores.red(
"El ID que ingresó no existe, por favor ingrese un ID válido"
))
print("")
if result:
while True:
try:
porcion = int(
input(
"Ingrese la cantidad de porciones del alimento que consumió: "
))
if porcion <= 0 or porcion is None:
print("")
print(
self.colores.red(
"Ese valor de porcion no es válido"))
print("")
else:
# meter a la BD
self.dbx.executeNonQueryBool(
"INSERT INTO `myfitapp`.`consumoalimento`(`id_consumoAlimento`,`id_producto`,`id_usuario`,`porcion`,`fecha`) "
+
f"VALUES(0,{self.idAlimento},{self.idUser},{porcion}, CURDATE());"
)
break
except Exception:
print("")
print(
self.colores.red(
"El campo de porcion solo acepta valores numéricos"
))
print("")
return result
else:
return result
def buscarAlimento(self):
print("")
# variables a ungresar
alimento = str(input("Ingrese el alimento que quiere buscar: "))
# meter a la BD
alimento1 = self.dbx.executeQueryRows(
f"SELECT * FROM myfitapp.producto WHERE nombre like '%{alimento}%' and id_usuario = 0 or id_usuario = {self.idUser};"
)
# imprimir info con prettytable
table = PrettyTable()
table.field_names = [
"ID",
"Nombre",
"Gramos por porción",
"Calorías",
"Grasas totales",
"Colesterol",
"Sodio",
"Azúcares",
]
for row in alimento1:
table.add_row([
row["id_producto"],
row["nombre"],
row["porcion"],
row["calorias"],
row["grasasTotales"],
row["colesterol"],
row["sodio"],
row["azucares"],
])
print(table)
print("")
def crearReceta(self):
print("")
# variables a ingresar
while True:
try:
nombre = str(input("Ingrese el nombre del nuevo alimento: "))
if nombre == "":
print("")
print(self.colores.red("Ese valor de nombre no es válido"))
print("")
else:
break
except Exception:
print("")
print(self.colores.red("El campo de nombre solo acepta texto"))
print("")
# nombre = str(input("Ingrese el nombre del nuevo alimento: "))
while True:
try:
porciones = float(
input(
"Ingrese la cantidad de gramos por porción de su alimento: "
))
if porciones < 0.0 or porciones is None:
print("")
print(
self.colores.red(
"Ese valor de porciones no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de porciones solo acepta valores numericos"))
print("")
# porciones = float(
# input("Ingrese la cantidad de gramos por porción de su alimento: "))
while True:
try:
calorias = float(input("Ingrese la cantidad de la calorias: "))
if calorias < 0.0 or calorias is None:
print("")
print(
self.colores.red("Ese valor de calorias no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de calorias solo acepta valores numericos"))
print("")
# calorias = float(input("Ingrese la cantidad de la caloria: "))
while True:
try:
grasaTotales = float(
input("Ingrese la cantidad de grasas totales: "))
if grasaTotales < 0.0 or grasaTotales is None:
print("")
print(
self.colores.red(
"Ese valor de grasa Totales no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de grasas totales solo acepta valores numericos"
))
print("")
# grasaTotales = float(input("Ingrese la cantidad de grasas totales: "))
while True:
try:
colesterol = float(
input("Ingrese la cantidad de colesterol: "))
if colesterol < 0.0 or colesterol is None:
print("")
print(
self.colores.red(
"Ese valor de colesterol no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de cantidad de colesteron solo acepta valores numericos"
))
print("")
# colesterol = float(input("Ingrese la cantidad de colesterol: "))
while True:
try:
sodio = float(input("Ingrese la cantidad de sodio: "))
if sodio < 0.0 or sodio is None:
print("")
print(self.colores.red("Ese valor de sodio no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de sodio solo acepta valores numericos"))
print("")
# sodio = float(input("Ingrese la cantidad de sodio: "))
while True:
try:
azucares = float(input("Ingrese la cantidad de azúcares: "))
if azucares < 0.0 or azucares is None:
print("")
print(
self.colores.red("Ese valor de azucares no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de azucares solo acepta valores numericos"))
print("")
# azucares = float(input("Ingrese la cantidad de azucares: "))
print("")
# ingresas a la BD
self.dbx.executeNonQueryBool(
"INSERT INTO `myfitapp`.`producto`(`id_producto`,`nombre`,`porcion`,`calorias`,`grasasTotales`,`colesterol`,`sodio`,`azucares`,`id_usuario`) "
+
f"VALUES(0,'{nombre}', {porciones}, {calorias}, {grasaTotales}, {colesterol}, {sodio},{azucares}, {self.idUser});"
)
def __init__(self):
self.idUser = 0
self.dbx = DatabaseX()
pass
def __init__(self):
self.colores = Colores()
self.database = DatabaseX()
self.peso = 0.00
self.cintura = 0.00
self.cuello = 0.00
class Medidas:
def __init__(self):
self.colores = Colores()
self.database = DatabaseX()
self.peso = 0.00
self.cintura = 0.00
self.cuello = 0.00
def ingresarPrimerPeso(self, peso, idUsuario):
sql = (
"INSERT INTO `myfitapp`.`registrodiario`(`id_registro`,`id_usuario`,`cintura`,`cuello`,`pesoActual`,`fecha`) "
+
f"VALUES(0,{idUsuario},{self.cintura},{self.cuello},{peso},curdate());"
)
self.database.executeNonQueryBool(sql)
def ingresarPeso(self, idUsuario):
peso = 0.00
while peso < 0.01 or peso > 400:
try:
peso = float(input("Ingrese su peso en kilogramos: "))
if peso < 0.01 or peso > 400:
print(self.colores.red("Ese valor de peso no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de peso solo acepta valores numéricos"))
self.peso = peso
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where fecha = curdate() and id_usuario = {idUsuario};"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 0:
sql = (
"INSERT INTO `myfitapp`.`registrodiario`(`id_registro`,`id_usuario`,`cintura`,`cuello`,`pesoActual`,`fecha`) "
+
f"VALUES(0,{idUsuario},{self.cintura},{self.cuello},{self.peso},curdate());"
)
self.database.executeNonQueryBool(sql)
else:
sql = (
"UPDATE `myfitapp`.`registrodiario` " +
f"SET `pesoActual` = {self.peso} where `fecha` = curDate() AND `id_usuario` = {idUsuario};"
)
self.database.executeNonQueryBool(sql)
print("")
print(self.colores.green("El registro se guardó correctamente"))
# Actualización del campo Peso Actual en la tabla Usuario
sql1 = (
"UPDATE `myfitapp`.`usuario` " +
f"SET `pesoActual` = {self.peso} where `id_usuario` = {idUsuario};"
)
self.database.executeNonQueryBool(sql1)
def ingresarCintura(self, idUsuario):
cintura = 0.00
while cintura < 0.01 or cintura > 300:
try:
cintura = float(
input("Ingrese su medida de cintura en centímetros: "))
if cintura < 0.01 or cintura > 300:
print(
self.colores.red("Ese valor de cintura no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de cintura solo acepta valores numéricos"))
self.cintura = cintura
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where fecha = curdate() and id_usuario = {idUsuario};"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 0:
sql = (
"INSERT INTO `myfitapp`.`registrodiario`(`id_registro`,`id_usuario`,`cintura`,`cuello`,`pesoActual`,`fecha`) "
+
f"VALUES(0,{idUsuario},{self.cintura},{self.cuello},{self.peso},curdate());"
)
self.database.executeNonQueryBool(sql)
else:
sql = (
"UPDATE `myfitapp`.`registrodiario` " +
f"SET `cintura` = {self.cintura} where `fecha` = curDate() AND `id_usuario` = {idUsuario};"
)
self.database.executeNonQueryBool(sql)
print("")
print(self.colores.green("El registro se guardó correctamente"))
def ingresarCuello(self, idUsuario):
cuello = 0.00
while cuello < 0.01 or cuello > 200:
try:
cuello = float(
input("Ingrese su medida de cuello en centímetros: "))
if cuello < 0.01 or cuello > 200:
print(self.colores.red("Ese valor de cuello no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de cuello solo acepta valores numéricos"))
self.cuello = cuello
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where fecha = curdate() and id_usuario = {idUsuario};"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 0:
sql = (
"INSERT INTO `myfitapp`.`registrodiario`(`id_registro`,`id_usuario`,`cintura`,`cuello`,`pesoActual`,`fecha`) "
+
f"VALUES(0,{idUsuario},{self.cintura},{self.cuello},{self.peso},curdate());"
)
self.database.executeNonQueryBool(sql)
else:
sql = (
"UPDATE `myfitapp`.`registrodiario` " +
f"SET `cuello` = {self.cuello} where `fecha` = curDate() AND `id_usuario` = {idUsuario};"
)
self.database.executeNonQueryBool(sql)
print("")
print(self.colores.green("El registro se guardó correctamente"))
class SignUp:
def __init__(self):
self.dbx = DatabaseX()
self.colores = Colores()
self.medidas = Medidas()
self.user = ""
self.correo = ""
self.contra = ""
def comprobacionUsuario(self, usuario):
while usuario == "":
print(self.colores.red("Debe llenar el campo de usuario"))
usuario = input("Ingrese un nombre de usuario: ")
sqlCount = f"SELECT COUNT(*) FROM myfitapp.usuario WHERE user = '******'"
# Imprime para comprobar estructura del sqlCount
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime el diccionario resultante de ejecutar sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime el numero de filas con ese nombre de usuario
# print(rowsNum)
if rowsNum == 0:
# print("ok")
self.user = usuario
return True
else:
# print("mal")
return False
def comprobacionCorreo(self, correo):
while correo == "":
print(self.colores.red("Debe llenar el campo de correo"))
correo = input("Ingrese su correo electronico: ")
sqlCount = f"SELECT COUNT(*) FROM myfitapp.usuario WHERE correo = '{correo:}'"
# Imprime para comprobar estructura del sqlCount
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime el diccionario resultante de ejecutar sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime el número de correos con correo
# print(rowsNum)
if rowsNum == 0:
# print("ok")
self.correo = correo
return True
else:
# print("mal")
return False
pass
def comprobacionContra(self, contra):
while (len(contra) > 12) or (len(contra) < 4):
print(self.colores.red("Contraseña no válida"))
contra = input(
"Ingrese una contraseña de mínimo 4 y máximo 12 caracteres: ")
self.contra = contra
return True
def guardaDatos(self):
nombre = input("Ingrese su nombre: ")
while nombre == "":
print(self.colores.red("Debe llenar el campo nombre"))
nombre = input("Ingrese su nombre: ")
apellido = input("Ingrese su apellido: ")
while apellido == "":
print(self.colores.red("Debe llenar el campo apellido"))
apellido = input("Ingrese su apellido: ")
genero = 0
while True:
try:
print("Ingrese su género: ")
print("(1) Masculino")
print("(2) Femenino")
genero = int(
input("Ingrese el número de la opción que desea: "))
except Exception:
print(self.colores.red("Valor no válido"))
if genero == 1 or genero == 2:
break
else:
print(
self.colores.red(
"Género no válido. Vuelva a ingresar su respuesta."))
altura = 0
while altura < 0.5 or altura > 3:
try:
altura = float(input("Ingrese su altura en metros: "))
if altura < 0.5 or altura > 3:
print(self.colores.red("Ese valor de altura no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de altura solo acepta valores numéricos"))
peso = 0.00
while peso < 10 or peso > 440:
try:
peso = float(input("Ingrese su peso en kilogramos: "))
if peso < 10 or peso > 440:
print(self.colores.red("Ese valor de peso no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de peso solo acepta valores numéricos"))
pesoDeseado = 0
while pesoDeseado < 10 or pesoDeseado > 440:
try:
pesoDeseado = float(
input("Ingrese su peso deseado en kilogramos: "))
if pesoDeseado < 10 or pesoDeseado > 440:
print(
self.colores.red(
"Ese valor de peso deseado no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de peso deseado solo acepta valores numéricos"
))
print("Ingrese su fecha de nacimiento con números")
anno = 0
while anno < 1000 or anno > 9999:
try:
anno = int(input("Ingrese su año de nacimiento: "))
if anno < 1000 or anno > 9999:
print(self.colores.red("Ese valor de año no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de año solo acepta valores numéricos"))
mes = 0
while mes < 1 or mes > 12:
try:
mes = int(input("Ingrese su mes de nacimiento: "))
if mes < 1 or mes > 12:
print(self.colores.red("Ese valor de mes no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de mes solo acepta valores numéricos"))
while True:
dia = 0
while True:
try:
dia = int(input("Ingrese su día de nacimiento: "))
break
except Exception:
print(
self.colores.red(
"El campo de día solo acepta valores numéricos"))
if (mes == 1 or mes == 3 or mes == 5 or mes == 7 or mes == 8
or mes == 10 or mes == 12):
if dia < 1 or dia > 31:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 4 or mes == 6 or mes == 9 or mes == 11:
if dia < 1 or dia > 30:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 2 and (anno % 4 == 0 and
(not (anno % 100 == 0) or anno % 400 == 0)):
if dia < 1 or dia > 29:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 2:
if dia < 1 or dia > 28:
print(self.colores.red("Valor de día no válido"))
else:
break
else:
print(self.colores.red("Ese valor de día no es válido"))
sql2 = (
"INSERT INTO myfitapp.usuario (id_usuario, nombre, apellido, correo, user, contra, id_genero, altura, pesoActual, pesoDeseado, nacimiento) "
+
f"VALUES (0, '{nombre}', '{apellido}', '{self.correo}', '{self.user}', '{self.contra}', {genero}, {altura}, {peso}, {pesoDeseado}, '{anno}-{mes}-{dia}');"
)
insert = self.dbx.executeNonQueryBool(sql2)
if insert:
print(self.colores.green("Usuario registrado correctamente"))
else:
print(
self.colores.red("No se ha podido registrar el nuevo usuario"))
# mandar peso actual como primer registro del usuario en la tabla registro diario
sqlCount = f"SELECT COUNT(id_usuario) from myfitapp.usuario where user = '******';"
countDic = self.dbx.executeQueryOneRow(sqlCount)
count = countDic.get("COUNT(id_usuario)")
if count == 1:
sqlId = (
f"SELECT id_usuario from myfitapp.usuario where user = '******';"
)
IdUsuarioDic = self.dbx.executeQueryOneRow(sqlId)
idUser = IdUsuarioDic.get("id_usuario")
self.medidas.ingresarPrimerPeso(peso, idUser)
else:
print(
self.colores.red(
"No se ingresó el peso actual a la tabla registros diarios"
))
def __init__(self, idUser):
self.idUser = idUser
self.colores = Colores()
self.idEjercicio = 0
self.dbx = DatabaseX()
class Ejercicio:
def __init__(self, idUser):
self.idUser = idUser
self.colores = Colores()
self.idEjercicio = 0
self.dbx = DatabaseX()
def agregarCardio(self):
while True:
while True:
try:
idEjercicio = int(
input(
"Ingrese el ID de su ejercicio, si desconoce el ID ingrese 0 para ir al buscador: "
)
)
if idEjercicio < 0 or idEjercicio is None:
print("")
print(colores.red("Ese valor de ID de ejercicio no es válido"))
print("")
else:
self.idEjercicio = idEjercicio
break
except Exception:
print("")
print(
self.colores.red(
"El campo de ID de ejercicio solo acepta valores numéricos"
)
)
print("")
if idEjercicio == 0:
result = False
break
else:
sqlCount = f"SELECT COUNT(*) FROM myfitapp.cardiovascular WHERE id_ejercicio = '{self.idEjercicio:}' and (id_usuario = 0 or id_usuario = '{self.idUser:}')"
# Imprime para comprobar estructura del sqlCount
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime el diccionario resultante de ejecutar sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime el numero de filas con ese ID de ejercicio
# print(rowsNum)
if rowsNum == 1:
result = True
break
else:
print("")
print(
self.colores.red(
"El ID que ingresó no existe, por favor ingrese un ID válido"
)
)
print("")
if result:
while True:
try:
tiempo = int(
input(
"Ingrese la cantidad de tiempo que se ejercitó en minutos: "
)
)
if tiempo <= 0 or tiempo is None:
print("")
print(self.colores.red("Ese valor de tiempo no es válido"))
print("")
else:
# meter a la BD
self.dbx.executeNonQueryBool(
"INSERT INTO `myfitapp`.`registrousuarioejerciciocardio`(`id_registroUsuarioCardio`,`id_usuario`,`id_ejercicio`,`tiempoTotalEmpleado`,`fecha`) "
+ f"VALUES(0,{self.idUser},{self.idEjercicio}, {tiempo}, CURDATE());"
)
break
except Exception:
print("")
print(
self.colores.red(
"El campo de tiempo solo acepta valores numéricos enteros"
)
)
print("")
return result
else:
return result
def buscarCardio(self):
print("")
# variables a ingresar
EjercicioCardio = str(
input("Ingrese el ejercicio de cardio que quiere buscar: ")
)
print("")
# meter a la BD
ejercicio1 = self.dbx.executeQueryRows(
f"SELECT * FROM myfitapp.cardiovascular where nombreEjercicio like '%{EjercicioCardio}%'and id_usuario = 0 or id_usuario = {self.idUser};"
)
# imprimir info con prettytable
table = PrettyTable()
table.field_names = [
"id_ejercicio",
"nombre Ejercicio",
"calorias quemadas por minuto",
]
for row in ejercicio1:
table.add_row(
[
row["id_ejercicio"],
row["nombreEjercicio"],
row["caloriasQuemadas"],
]
)
print(table)
print("")
def crearCardio(self):
print("")
# variables a ingresar
while True:
try:
nombre = str(input("Ingrese el nombre del nuevo ejercicio: "))
if nombre == "":
print("")
print(self.colores.red("Ese valor de nombre no es válido"))
print("")
else:
break
except Exception:
print("")
print(self.colores.red("El campo de nombre solo acepta texto"))
print("")
while True:
try:
caloriasQuemadas = float(
input("Ingrese la cantidad de calorias quemadas por minuto: ")
)
if caloriasQuemadas < 0.0 or caloriasQuemadas is None:
print("")
print(self.colores.red("Ese valor de porciones no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de calorias quemadas solo acepta valores numericos"
)
)
print("")
# ingresar a la BD
self.dbx.executeNonQueryBool(
f"INSERT INTO `myfitapp`.`cardiovascular`(`id_ejercicio`,`nombreEjercicio`,`caloriasQuemadas`,`id_usuario`) VALUES(0,'{nombre}', {caloriasQuemadas}, {self.idUser});"
)
def agregarPeso(self):
while True:
while True:
try:
idEjercicio = int(
input(
"Ingrese el ID de su ejercicio, si desconoce el ID ingrese 0 para ir al buscador: "
)
)
if idEjercicio < 0 or idEjercicio is None:
print("")
print(colores.red("Ese valor de ID de ejercicio no es válido"))
print("")
else:
self.idEjercicio = idEjercicio
break
except Exception:
print("")
print(
self.colores.red(
"El campo de ID de ejercicio solo acepta valores numéricos"
)
)
print("")
if idEjercicio == 0:
result = False
break
else:
sqlCount = f"SELECT COUNT(*) FROM myfitapp.fuerza WHERE id_ejercicio = '{self.idEjercicio:}' and (id_usuario = 0 or id_usuario = '{self.idUser:}'"
# Imprime para comprobar estructura del sqlCount
# print(sqlCount)
rowsNumDic = self.dbx.executeQueryOneRow(sqlCount)
# Imprime el diccionario resultante de ejecutar sqlCount
# print(rowsNumDic)
rowsNum = rowsNumDic.get("COUNT(*)")
# Imprime el numero de filas con ese ID de ejercicio
# print(rowsNum)
if rowsNum == 1:
result = True
break
else:
print("")
print(
self.colores.red(
"El ID que ingresó no existe, por favor ingrese un ID válido"
)
)
print("")
if result:
while True:
try:
repeticiones = int(
input("Ingrese la cantidad de repeticiones realizadas: ")
)
if repeticiones <= 0 or repeticiones is None:
print("")
print(
self.colores.red("Ese valor de repeticiones no es válido")
)
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de repeticiones solo acepta valores numéricos"
)
)
print("")
while True:
try:
series = int(input("Ingrese la cantidad de series realizadas: "))
if series < 0 or series is None:
print("")
print(self.colores.red("Ese valor de series no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de series solo acepta valores numericos"
)
)
print("")
while True:
try:
peso = int(
input(
"Ingrese la cantidad de libras aplicadas en su ejercicio: "
)
)
if peso < 0 or peso is None:
print("")
print(self.colores.red("Ese valor de peso no es válido"))
print("")
else:
break
except Exception:
print("")
print(
self.colores.red(
"El campo de peso solo acepta valores numericos"
)
)
print("")
# meter a la BD
self.dbx.executeNonQueryBool(
"INSERT INTO `myfitapp`.`registrousuarioejerciciofuerza`(`id_registroUsuarioFuerza`,`id_usuario`,`id_ejercicio`,`repeticiones`, series, pesoAplicado, `fecha`) "
+ f"VALUES(0,{self.idUser},{self.idEjercicio}, {repeticiones}, {series}, {peso}, CURDATE());"
)
return result
else:
return result
def buscarPeso(self):
print("")
# variables a ingresar
EjercicioPeso = str(input("Ingrese el ejercicio de peso que quiere buscar: "))
print("")
# meter a la BD
ejercicio1 = self.dbx.executeQueryRows(
f"SELECT * FROM myfitapp.fuerza where nombreEjercicio like '%{EjercicioPeso}%'and id_usuario = 0 or id_usuario = {self.idUser};"
)
# imprimir info con prettytable
table = PrettyTable()
table.field_names = [
"id_ejercicio",
"nombreEjercicio",
"parteDelCuerpo",
]
for row in ejercicio1:
table.add_row(
[
row["id_ejercicio"],
row["nombreEjercicio"],
row["parteDelCuerpo"],
]
)
print(table)
print("")
def crearPeso(self):
print("")
# variables a ingresar
while True:
try:
nombre = str(input("Ingrese el nombre del nuevo ejercicio: "))
if nombre == "":
print("")
print(self.colores.red("Ese valor de nombre no es válido"))
print("")
else:
break
except Exception:
print("")
print(self.colores.red("El campo de nombre solo acepta texto"))
print("")
while True:
try:
parteDelCuerpo = str(
input("Ingrese la parte del cuerpo que ejercita: ")
)
if parteDelCuerpo == "":
print("")
print(
self.colores.red("Ese valor de partes del cuerpo no es válido")
)
print("")
else:
break
except Exception:
print("")
print(
self.colores.red("El campo de parte del cuerpo solo acepta texto")
)
print("")
print("")
# ingresar a la BD
self.dbx.executeNonQueryBool(
f"INSERT INTO `myfitapp`.`fuerza`(`id_ejercicio`,`nombreEjercicio`,`parteDelCuerpo`,`id_usuario`) VALUES(0,'{nombre}', '{parteDelCuerpo}', {self.idUser});"
)
def __init__(self):
self.database = DatabaseX()
self.colores = Colores()
class Evolucion:
def __init__(self):
self.database = DatabaseX()
self.colores = Colores()
def evoPeso(self, idUsuario):
sql = f"select * from registrodiario where id_usuario = {idUsuario} order by fecha asc;"
datos = self.database.executeQueryRows(sql)
listaDato = []
listaFecha = []
for row in datos:
if row["pesoActual"] > 0:
fechaFixed = str(row["fecha"])
listaFecha.append(fechaFixed[:10])
listaDato.append(float(row["pesoActual"]))
Ejey = listaDato
Ejex = listaFecha
fig, ax = plt.subplots(figsize=(20, 10))
ax.plot(Ejex, Ejey, marker="o", color="#7581bf")
ax.set(title="Evolución de peso diario",
xlabel="Fecha",
ylabel="Peso\n(kg)")
plt.grid(True, color="#b4b5bf")
plt.show()
def evoCintura(self, idUsuario):
sql = f"select * from registrodiario where id_usuario = {idUsuario} order by fecha asc;"
datos = self.database.executeQueryRows(sql)
listaDato = []
listaFecha = []
for row in datos:
if row["cintura"] > 0:
fechaFixed = str(row["fecha"])
listaFecha.append(fechaFixed[:10])
listaDato.append(float(row["cintura"]))
Ejey = listaDato
Ejex = listaFecha
fig, ax = plt.subplots(figsize=(20, 10))
ax.plot(Ejex, Ejey, marker="o", color="#7581bf")
ax.set(title="Evolución de cintura",
xlabel="Fecha",
ylabel="Medida\n(cm)")
plt.grid(True, color="#b4b5bf")
plt.show()
def evoCuello(self, idUsuario):
sql = f"select * from registrodiario where id_usuario = {idUsuario} order by fecha asc;"
datos = self.database.executeQueryRows(sql)
listaDato = []
listaFecha = []
for row in datos:
if row["cuello"] > 0:
fechaFixed = str(row["fecha"])
listaFecha.append(fechaFixed[:10])
listaDato.append(float(row["cuello"]))
Ejey = listaDato
Ejex = listaFecha
fig, ax = plt.subplots(figsize=(20, 10))
ax.plot(Ejex, Ejey, marker="o", color="#7581bf")
ax.set(title="Evolución de Cuello",
xlabel="Fecha",
ylabel="Medida\n(cm)")
plt.grid(True, color="#b4b5bf")
plt.show()
def evoCalConsumidas(self, idUsuario):
sql = (
"SELECT consumoalimento.fecha,sum(consumoalimento.porcion*producto.calorias) as caloriasTotales "
+
"FROM consumoalimento inner join producto on consumoalimento.id_producto = producto.id_producto "
+
f"where consumoalimento.id_usuario = {idUsuario} group by consumoalimento.fecha order by fecha asc;"
)
datos = self.database.executeQueryRows(sql)
listaDato = []
listaFecha = []
for row in datos:
fechaFixed = str(row["fecha"])
listaFecha.append(fechaFixed[:10])
listaDato.append(float(row["caloriasTotales"]))
Ejey = listaDato
Ejex = listaFecha
fig, ax = plt.subplots(figsize=(20, 10))
ax.plot(Ejex, Ejey, marker="o", color="#7581bf")
ax.set(
title="Evolución de calorias consumidas",
xlabel="Fecha",
ylabel="Calorias\n(kcal)",
)
plt.grid(True, color="#b4b5bf")
plt.show()
def evoCalQuemadas(self, idUsuario):
print(self.colores.red("Fuera de servicio..."))
def evoEjPeso(self, idUsuario):
print(self.colores.red("Fuera de servicio..."))
def evoTiempo(self, idUsuario):
print(self.colores.red("Fuera de servicio..."))
class Resumen:
def __init__(self):
self.database = DatabaseX()
self.colores = Colores()
def imprimeResumenActual(self, idUsuario):
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where id_usuario = {idUsuario} and fecha = curdate();"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 1:
sql = f"select * from registrodiario where fecha = curdate() AND id_usuario = {idUsuario};"
resumen = self.database.executeQueryRows(sql)
table = PrettyTable()
table.field_names = [
"Fecha",
"Peso",
"Cintura",
"Cuello",
]
for row in resumen:
table.add_row([
row["fecha"],
row["pesoActual"],
row["cintura"],
row["cuello"],
])
print("")
print(table)
else:
print("")
print(
self.colores.red("No se encontró ningún registro de este día"))
def imprimeResumenOtroDia(self, idUsuario):
anno = 0
while anno < 1000 or anno > 9999:
try:
anno = int(input("Ingresa el año deseado (yyyy): "))
if anno < 1000 or anno > 9999:
print(self.colores.red("Ese valor de año no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de año solo acepta valores numéricos"))
mes = 0
while mes < 1 or mes > 12:
try:
mes = int(input("Ingresa el mes deseado (mm): "))
if mes < 1 or mes > 12:
print(self.colores.red("Ese valor de mes no es válido"))
else:
break
except Exception:
print(
self.colores.red(
"El campo de mes solo acepta valores numéricos"))
while True:
dia = 0
while True:
try:
dia = int(input("Ingresa el día deseado(dd): "))
break
except Exception:
print(
self.colores.red(
"El campo de día solo acepta valores numéricos"))
if (mes == 1 or mes == 3 or mes == 5 or mes == 7 or mes == 8
or mes == 10 or mes == 12):
if dia < 1 or dia > 31:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 4 or mes == 6 or mes == 9 or mes == 11:
if dia < 1 or dia > 30:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 2 and (anno % 4 == 0 and
(not (anno % 100 == 0) or anno % 400 == 0)):
if dia < 1 or dia > 29:
print(self.colores.red("Valor de día no válido"))
else:
break
elif mes == 2:
if dia < 1 or dia > 28:
print(self.colores.red("Valor de día no válido"))
else:
break
else:
print(self.colores.red("Ese valor de día no es válido"))
date = str(anno) + "-" + str(mes) + "-" + str(dia)
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where id_usuario = {idUsuario} and fecha = '{date}';"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 1:
sql = f"select * from registrodiario where id_usuario = {idUsuario} and fecha = '{date}';"
resumen = self.database.executeQueryRows(sql)
table = PrettyTable()
table.field_names = [
"Fecha",
"Peso",
"Cintura",
"Cuello",
]
for row in resumen:
table.add_row([
row["fecha"],
row["pesoActual"],
row["cintura"],
row["cuello"],
])
print("")
print(table)
else:
print("")
print(
self.colores.red(
"No se encontró ningún registro con la fecha proporcionada"
))
from databaseX import DatabaseX
from colores import Colores
from prettytable import PrettyTable
database = DatabaseX()
class Resumen:
def __init__(self):
self.database = DatabaseX()
self.colores = Colores()
def imprimeResumenActual(self, idUsuario):
sqlCount = f"SELECT COUNT(id_registro) from registrodiario where id_usuario = {idUsuario} and fecha = curdate();"
datos = self.database.executeQueryOneRow(sqlCount)
count = datos.get("COUNT(id_registro)")
if count == 1:
sql = f"select * from registrodiario where fecha = curdate() AND id_usuario = {idUsuario};"
resumen = self.database.executeQueryRows(sql)
table = PrettyTable()
table.field_names = [
"Fecha",
"Peso",
"Cintura",
"Cuello",
]
for row in resumen:
table.add_row([
row["fecha"],
row["pesoActual"],
row["cintura"],
def createDatabaseX(self):
database = DatabaseX()
return database