def ver_contactos():
"""Muestra un submenu que permite filtrar la forma en que
se muestran los contactos, por Nombre, Apellido o Edad"""
while True:
print(
c.VERDE, c.BOLD, """
Antes de ver los contactos puedes filtrarlos por Nombre,
Apellido o por Edad.
""", c.ENDC)
opcion = input(c.CYAN + "[DESEAS CONTINUAR?][SI/NO]: " + c.ENDC)
if opcion.lower() == 'si':
filtro = input(c.VERDE + "Filtro [Nombre(default)]: " + c.ENDC)
if filtro.title() in ("Nombre", "Apellido", "Edad"):
Agenda.listar_contactos(filtro.title())
elif filtro == '':
Agenda.listar_contactos("Nombre")
else:
c.error(
"Solo Nombre[default], Apellido o Edad son permitidos!")
elif opcion.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...", c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
def eliminar_contacto():
"""Activa la opcion de eliminar un contacto a traves de su indice."""
while True:
print("""
{}ADVERTENCIA!!, no es posible recuperar contactos borrados.{}
{}Para eliminar un contacto debes introducir su id, asegurate de
saberlo antes de proceder.{}
""".format(c.ROJO + c.BOLD, c.ENDC, c.VERDE + c.BOLD, c.ENDC))
opcion = input(c.CYAN + "[DESEAS CONTINUAR?][SI/NO]: " + c.ENDC)
if opcion.lower() == 'si':
indice = input(c.VERDE + "[ID]: " + c.ENDC)
Agenda.eliminar_registro(indice)
elif opcion.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...", c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
def __init__(self):
self.dbx = DatabaseX()
self.colores = Colores()
self.medidas = Medidas()
self.user = ""
self.correo = ""
self.contra = ""
def __init__(self, nombre, apellido, edad, telefono, email):
"""Inicializador de instancias.
Argumentos:
nombre {str}
apellido {str}
edad {int}
telefono {str}
email {str}
"""
self.nombre = nombre
self.apellido = apellido
try:
self.edad = int(edad)
except:
c.error("{}: No es una edad valida!!".format(edad))
self.edad = ''
# Verificar numero valido
if self.telefono_valido(telefono):
self.telefono = telefono
else:
c.error(
"{}: No es un numero de telefono valido!!".format(telefono))
self.telefono = ''
if self.email_valido(email):
self.email = email
else:
self.email = ''
def busqueda_personalizada():
"""Realiza una busqueda por parametros dentro de la agenda."""
while True:
print(
c.VERDE, c.BOLD, """
En este submenu puedes realizar una busqueda por Nombre,
Apellido o el numero de Telefono.
NOTA: Mayusculas y minusculas cuentan.
""", c.ENDC)
opcion = input(c.CYAN + "[DESEAS CONTINUAR?][SI/NO]: " + c.ENDC)
if opcion.lower() == 'si':
filtro = input(c.VERDE + "Filtrar por campo [Nombre(default)]: " +
c.ENDC)
busqueda = input(c.VERDE + "[A quien buscas?]: " + c.ENDC)
Agenda.buscar_registro("Nombre", busqueda) if filtro == '' else \
Agenda.buscar_registro(filtro, busqueda)
elif opcion.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...", c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
class Objetivos:
def __init__(self):
self.colores = Colores()
def mostrarObjetivos(self):
print(self.colores.red("Fuera de servicio..."))
def agregarObjetivos(self):
print(self.colores.red("Fuera de servicio..."))
def modificarObjetivos(self):
print(self.colores.red("Fuera de servicio..."))
def eliminarObjetivos(self):
print(self.colores.red("Fuera de servicio..."))
def email_valido(cls, email):
"""Verifica que las entradas de emails sean validas.
Argumento:
email {str}
Retorno:
str -- True si encuentra una coincidencia valida.
"""
coincidencias = []
for grupos in cls.regex_email.findall(email):
coincidencias.append(grupos[0])
if len(coincidencias) > 0:
return coincidencias[0]
else:
c.error("{}: No es un email valido!!".format(email))
return False
def modificar_contacto():
"""Activa la opcion de modificar un contacto en la agenda."""
while True:
print("""
{}Aqui puedes modificar un contacto atraves de su indice(id)
asegurate de saber el indice correcto antes de modificar.{}
{}NOTA: Los cambios no son reversibles.{}
""".format(c.VERDE + c.BOLD, c.ENDC, c.ROJO + c.BOLD, c.ENDC))
opcion = input(c.CYAN + "[DESEAS CONTINUAR?][SI/NO]: " + c.ENDC)
if opcion.lower() == 'si':
indice = input(c.VERDE + "[ID]: " + c.ENDC)
nombre = input(c.VERDE + "[NOMBRE]: " + c.ENDC)
apellido = input(c.VERDE + "[APELLIDO]: " + c.ENDC)
edad = input(c.VERDE + "[EDAD]: " + c.ENDC)
telefono = input(c.VERDE + "[TELEFONO]: " + c.ENDC)
email = input(c.VERDE + "[CORREO]: " + c.ENDC)
if indice != '' and nombre != '' and apellido != '' and \
edad != '' and telefono != '' and email != '':
modificado = Contacto(nombre, apellido, edad, telefono, email)
if modificado.es_valido():
Agenda.modificar_registro(indice,
*modificado.obtener_datos())
c.success(
"El contacto con el ID {} se ha modificado!".format(
indice))
else:
c.error("Verifica los datos, algo anda mal.")
else:
c.error("Faltan datos, el contacto no se ha modificado!!")
elif opcion.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...", c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
def solicitar_contacto():
"""Esta funcion estara en ejecucion hasta que el usuario
no quiera seguir ingresando contactos a la agenda"""
while True:
print(
c.VERDE, c.BOLD, """
A continuacion debes proporcionar informacion sobre el contacto,
asegurate de ingresar la info correcta, ejemplo: 8090000000 no es
un numero valido en esta agenda el formato debe ser 809-000-0000
y para correos [email protected]
""", c.ENDC)
opcion = input(c.CYAN + "[DESEAS CONTINUAR?][SI/NO]: " + c.ENDC)
if opcion.lower() == 'si':
nombre = input(c.VERDE + "[NOMBRE]: " + c.ENDC)
apellido = input(c.VERDE + "[APELLIDO]: " + c.ENDC)
edad = input(c.VERDE + "[EDAD]: " + c.ENDC)
telefono = input(c.VERDE + "[TELEFONO]: " + c.ENDC)
email = input(c.VERDE + "[CORREO]: " + c.ENDC)
contacto = Contacto(nombre, apellido, edad, telefono, email)
if contacto.es_valido():
Agenda(contacto).agregar_registro()
opcion2 = input(c.CYAN + "\n" + "[AGREGAR OTRO?][SI/NO]: " +
c.ENDC)
if opcion2.lower() == 'si':
continue
elif opcion2.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...",
c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
else:
c.error("Contacto no valido, por favor intenta de nuevo!!")
elif opcion.lower() == 'no':
print(c.AMARILLO, "\n[!] Regresando al menu anterior...", c.ENDC)
sleep(1.5)
break
else:
c.error("Solo puedes responder Si o No.")
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 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"
))
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});"
)
from login import Login
from signUp import SignUp
from resumenDiario import Resumen
from medidas import Medidas
from objetivos import Objetivos
from alimentacion import Alimentacion
from ejercicio import Ejercicio
from evolucion import Evolucion
from colores import Colores
eleccion = 0
idUsuario = 0
colores = Colores()
while True:
print("")
print(
colores.cyan(
"-------------------------------------------------------"))
print(colores.blue("APLICACIÓN FIT"))
print(
colores.cyan(
"-------------------------------------------------------"))
print("(1) Iniciar sesión")
print("(2) Crear una cuenta")
print("(0) Salir")
print(
colores.cyan(
"-------------------------------------------------------"))
print("")
while True:
def __init__(self):
self.colores = Colores()
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});"
)
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..."))
def __init__(self):
self.database = DatabaseX()
self.colores = Colores()
def __init__(self, idUser):
self.idUser = idUser
self.colores = Colores()
self.idAlimento = 0
self.dbx = DatabaseX()
def menu_principal():
"""Menu principal de la agenda donde puede interactuarse
con las opciones principales del programa."""
while True:
portada()
print("""
------------------- MENU PRINCIPAL ---------------------
1 - {uno}
2 - {dos}
3 - {tres}
4 - {cuatro}
5 - {cinco}
6 - {seis}
7 - {siete}
8 - Salir
""".format(
uno=c.VERDE + "[+] Generar el archivo de la agenda." + c.ENDC,
dos=c.ROJO + "[x] Borrar todo el contenido de la agenda." + c.ENDC,
tres=c.VERDE + "[+] Agregar un nuevo contacto" + c.ENDC,
cuatro=c.CYAN + "[-] Ver lista de contactos." + c.ENDC,
cinco=c.AMARILLO + "[!] Realizar una busqueda personalizada." +
c.ENDC,
seis=c.ROJO + "[x] Eliminar un contacto." + c.ENDC,
siete=c.AZUL + "[!=] Modificar un contacto." + c.ENDC))
# capturar la opcion elegida en el menu principal
opcion = input(c.CYAN + "[ESCOGE UNA OPCION]: " + c.ENDC)
if opcion.isdecimal():
if opcion == '1':
Agenda.crear_agenda()
elif opcion == '2':
Agenda.borrar_agenda()
elif opcion == '3':
solicitar_contacto()
elif opcion == '4':
ver_contactos()
elif opcion == '5':
busqueda_personalizada()
elif opcion == '6':
eliminar_contacto()
elif opcion == '7':
modificar_contacto()
elif opcion == '8':
c.success("Cerrando la agenda...")
break
else:
c.error("Opcion desconocida!!")
else:
c.error("Caracteres alfabeticos no son bienvenidos aqui!!")