class TriajeModel(bd.Model):
__tablename__ = "t_triaje"
id = bd.Column("triaje_id", bd.Integer, primary_key=True)
peso = bd.Column("triaje_peso", bd.DECIMAL(5, 2))
temperatura = bd.Column("triaje_temp", bd.DECIMAL(5, 2))
# RELACIONES
atencion_id = bd.Column(bd.Integer,
bd.ForeignKey("t_atencion.atencion_id"))
# esto sirve para crear nuestra relacion de uno a uno
atencion = bd.relationship("AtencionModel", uselist=False)
def __init__(self, peso, temperatura, atencion):
self.peso = peso
self.temperatura = temperatura
self.atencion_id = atencion
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
def devolver_triaje(self):
return {
'peso': self.peso,
'temperatura': self.temperatura,
'atencion': self.atencion_id
}
def actualizar_triaje(self, peso, temperatura):
self.peso = peso
self.temperatura = temperatura
bd.session.commit()
class RegistroModel(bd.Model):
# si no definimos el __tablename__, el nombre será el nombre de la clase
__tablename__ = "t_registro"
id = bd.Column("registro_id", bd.Integer, primary_key=True)
registro_ingreso = bd.Column("registro_ingreso", bd.DateTime)
registro_salida = bd.Column("registro_salida", bd.DateTime)
# RELACIONES
usu_id = bd.Column(bd.Integer,
bd.ForeignKey('t_usuario.usu_id'),
nullable=False)
def __init__(self, registro_de_ingreso, registro_de_salida, id_usuario):
self.registro_ingreso = registro_de_ingreso
self.registro_salida = registro_de_salida
self.usu_id = id_usuario
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
def horario_marcado(self):
return {
'entrada': format(self.registro_ingreso),
'salida': format(self.registro_salida)
}
class AtencionModel(bd.Model):
__tablename__="t_atencion"
id = bd.Column("atencion_id", bd.Integer, primary_key=True)
fecha = bd.Column("atencion_fech", bd.Date, nullable=False)
motivo = bd.Column("atencion_motivo", bd.Text, nullable=False)
diagnostico = bd.Column("atencion_diagnostico", bd.Text)
medicacion = bd.Column("atencion_medicacion", bd.Text)
siguiente_atencion = bd.Column("atencion_proxima_fecha", bd.Date)
observaciones = bd.Column("atencion_obs",bd.Text)
# RELACIONES
id_mascota = bd.Column("mascota_id", bd.Integer, bd.ForeignKey("t_mascota.mascota_id"), nullable=False)
id_precio = bd.Column("precio_id", bd.Integer, bd.ForeignKey("t_precio.precio_id"), nullable=False)
detalles = bd.relationship("DetalleDocumentoModel")
def __init__(self, fecha, motivo, diagnostico, medicacion, proxima_atencion, observaciones, mascota, precio):
self.fecha = fecha
self.motivo = motivo
self.diagnostico = diagnostico
self.medicacion = medicacion
self.siguiente_atencion = proxima_atencion
self.observaciones = observaciones
self.id_mascota = mascota
self.id_precio = precio
def traer_atencion(self):
return {
'fecha': format(self.fecha),
'motivo': self.motivo,
'diagnostico': self.diagnostico,
'medicacion': self.medicacion,
'proxima atencion':format(self.siguiente_atencion),
'observaciones': self.observaciones
}
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
def eliminar_bd(self):
bd.session.delete(self)
bd.session.commit()
class ReservaModel(bd.Model):
__tablename__ = "t_reserva"
id = bd.Column("res_id",bd.Integer,primary_key=True)
fechainit = bd.Column("res_fechin",bd.DATETIME)
fechaend = bd.Column("res_fechfin",bd.DATETIME)
monto = bd.Column("res_monto",bd.DECIMAL(5,2))
adelanto = bd.Column("res_adelanto",bd.DECIMAL(5,2))
user = bd.Column("usu_id",bd.Integer,bd.ForeignKey('t_usuario.usu_id'), nullable=False)
cancha = bd.Column("pc_id",bd.Integer,bd.ForeignKey('t_precioCancha.pc_id'),nullable=False)
usuarios = bd.relationship('UsuarioModel', lazy=True)
precio = bd.relationship('PrecioCanchaModel')
valoraciones = bd.relationship('ValoracionesModel',lazy=True,backref="valoracion")
def __init__(self,fechainit,fechaend,monto,adelanto,user,cancha):
self.fechainit = fechainit
self.fechaend = fechaend
self.monto = monto
self.adelanto = adelanto
self.user = user
self.cancha = cancha
def retornar_json(self):
return{
'id': self.id,
'descripcion':{
'fechainit': self.fechainit,
'fechaend': self.fechaend,
# 'monto': self.monto,
# 'adelanto': self.adelanto,
# 'user': self.user,
# 'cancha': self.cancha
}
}
def guarda_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class CanchitaModel(bd.Model):
__tablename__ = "t_canchita"
id = bd.Column("can_id", bd.Integer, primary_key=True)
tamanio = bd.Column("can_tamanio", bd.String(45))
foto = bd.Column("can_foto", bd.Text)
# relaciones
local = bd.Column("loc_id",
bd.Integer,
bd.ForeignKey('t_local.loc_id'),
nullable=False)
tipo = bd.Column("tipo_id",
bd.Integer,
bd.ForeignKey('t_tipo.tipo_id'),
nullable=False)
locales = bd.relationship("LocalModel", lazy=True)
tiposi = bd.relationship("TipoModel", lazy=True)
precio = bd.relationship("PrecioCanchaModel", lazy=True, backref="precio")
def __init__(self, tamanio, foto, local, tipo):
self.tamanio = tamanio
self.foto = foto
self.local = local
self.tipo = tipo
def retornar_json(self):
return {
'id': self.id,
'tipo': self.tiposi.descripcion,
'tamanio': self.tamanio,
'foto': self.foto,
'local': self.locales.retornar_yisun(),
}
def guarda_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class TurnoModel(bd.Model):
__tablename__ = "t_turno"
turno_id = bd.Column(bd.Integer, primary_key=True)
turno_hora_ingreso = bd.Column(bd.DateTime())
turno_hora_salida = bd.Column(bd.DateTime())
# RELACIONES
usu_id = bd.Column(bd.Integer,
bd.ForeignKey('t_usuario.usu_id'),
nullable=False)
# formas de acceder a mi tabla padre sin la necesidad de llamarla, ESTO NO CREA LA RELACION
usuario = bd.relationship('UsuarioModel')
def __init__(self, hora_ingreso, hora_salida, id_usuario):
self.turno_hora_ingreso = hora_ingreso
self.turno_hora_salida = hora_salida
self.usu_id = id_usuario
class LocalModel(bd.Model):
__tablename__ = "t_local"
id = bd.Column("loc_id", bd.Integer, primary_key=True)
nombre = bd.Column("loc_nombre", bd.String(45))
latitud = bd.Column("loc_lat", bd.DECIMAL(10, 8))
longitud = bd.Column("loc_lng", bd.DECIMAL(10, 8))
direccion = bd.Column("loc_direccion", bd.String(45))
fono = bd.Column("loc_fono", bd.String(15))
usuario = bd.Column("usu_id",
bd.Integer,
bd.ForeignKey('t_usuario.usu_id'),
nullable=False)
# ----------------
canchitas = bd.relationship('CanchitaModel', lazy=True, backref="cancha")
# opcion = bd.relationship('OpcionesModel',lazy=True,backref="opciones")
def __init__(self, nombre, latitud, longitud, direccion, fono, usu_id):
self.nombre = nombre
self.latitud = latitud
self.longitud = longitud
self.direccion = direccion
self.fono = fono
self.usuario = usu_id
def retornar_yisun(self):
return {
'id': self.id,
'nombre': self.nombre,
'latitud': str(self.latitud),
'longitud': str(self.longitud),
'direccion': self.direccion,
'fono': self.fono,
}
def guardar_na_bd(self):
bd.session.add(self)
bd.session.commit()
# parametros para el lazy puede ser
# 'select'/True => que va a cargar la data de su hijo
# 'joined'/False => es como usar un inner join cuando vamos a hacer un select
# 'subquery'' => es igual que joined pero x detras usa una subquery para jalar los datos del hijo
# 'dynamic' => retorna los objetos del join de la consulta
class ContactoModel(bd.Model):
__tablename__ = 't_contacto'
contact_id = bd.Column(bd.Integer, primary_key=True)
contact_nomb = bd.Column(bd.String(45))
contact_email = bd.Column(bd.String(25))
contact_mensaje = bd.Column(bd.Text)
usu_id = bd.Column(bd.Integer, bd.ForeignKey('t_usuario.usu_id'))
def __init__(self, nombre, correo, mensaje, id_usuario):
self.contact_nomb = nombre
self.contact_email = correo
self.contact_mensaje = mensaje
self.usu_id = id_usuario
def save(self):
bd.session.add(self)
bd.session.commit()
class ProyectoModel(bd.Model):
__tablename__ = 't_proyecto'
proy_id = bd.Column(bd.Integer, primary_key=True)
proy_desc = bd.Column(bd.String(45))
proy_duracion = bd.Column(bd.String(5))
proy_img = bd.Column(bd.Text)
usu_id = bd.Column(bd.Integer, bd.ForeignKey('t_usuario.usu_id'))
def __init__(self, descripcion, duracion, imagen, usuario):
self.proy_desc = descripcion
self.proy_duracion = duracion
self.proy_img = imagen
self.usu_id = usuario
def save(self):
bd.session.add(self)
bd.session.commit()
class ProductoModel(bd.Model):
__tablename__ = "t_producto"
id = bd.Column("prod_id", bd.Integer, primary_key=True)
nombre = bd.Column("prod_nom", bd.String(45))
precio = bd.Column("prod_precio", bd.Float(precision=2))
# RELACIONES
# nullable es para estipular si puede aceptar valores nulos o no, por default viene con el valor de True
cat_id = bd.Column(bd.Integer,
bd.ForeignKey('t_categoria.cat_id'),
nullable=False)
# https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/#one-to-many-relationships
categoria = bd.relationship('CategoriaModel')
def __init__(self, nombre, precio, id_cat):
self.nombre = nombre
self.precio = precio
self.cat_id = id_cat
class ValoracionesModel(bd.Model):
__tablename__ = "t_valoraciones"
id= bd.Column("val_id",bd.Integer,primary_key=True)
comentario = bd.Column("val_comentario",bd.Text)
estrellita = bd.Column("val_estrellas",bd.Integer)
reserva = bd.Column("res_id",bd.Integer,bd.ForeignKey('t_reserva.res_id'),nullable=False)
reservas = bd.relationship('ReservaModel')
def __init__(self,comentario,estrellita,id):
self.comentario = comentario
self.estrellita = estrellita
self.id = id
def retornar_yisun_con_local(self):
return {
'comentario': self.comentario,
'estrella': self.estrellita
}
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class PrecioCanchaModel(bd.Model):
__tablename__ = "t_precioCancha"
id = bd.Column("pc_id", bd.Integer, primary_key=True)
descripcion = bd.Column("pc_desc", bd.String(45))
monto = bd.Column("pc_monto", bd.DECIMAL(5, 2))
disponible = bd.Column("pc_disponibilidad", bd.Boolean)
canchita = bd.Column("can_id",
bd.Integer,
bd.ForeignKey('t_canchita.can_id'),
nullable=False)
cancha = bd.relationship("CanchitaModel", lazy=True)
reservas = bd.relationship("ReservaModel", lazy=True, backref="reserva")
def __init__(self, descripcion, monto, disponibilidad, canchita):
self.descripcion = descripcion
self.monto = monto
self.disponible = disponibilidad
self.canchita = canchita
def retornar_yisus(self):
return {
'id': self.id,
'descripcion': self.descripcion,
'monto': str(self.monto),
# 'disponible': self.disponible,
}
def guarda_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
def actualizar_estado(self, nuevo_estado):
self.disponible = nuevo_estado
bd.session.commit()
class RedSocialModel(bd.Model):
__tablename__ = 't_redsocial'
rs_id = bd.Column(bd.Integer, primary_key=True)
rs_nomb = bd.Column(bd.String(25))
rs_link = bd.Column(bd.Text)
usu_id = bd.Column(bd.Integer, bd.ForeignKey('t_usuario.usu_id'))
class MascotaModel(bd.Model):
__tablename__ = "t_mascota"
mascota_id = bd.Column(bd.Integer, primary_key=True)
# nullable indica si el campo puede admitir valores nulos
mascota_nombre = bd.Column(bd.String(45), nullable=False)
mascota_fechnac = bd.Column(bd.Date)
mascota_tipo = bd.Column(bd.String(45))
mascota_raza = bd.Column(bd.String(45))
mascota_sexo = bd.Column(bd.String(45))
mascota_obs = bd.Column(bd.Text)
# RELACIONES
usu_id = bd.Column(bd.Integer,
bd.ForeignKey('t_usuario.usu_id'),
nullable=False)
atenciones = bd.relationship('AtencionModel', lazy=True)
# valores que puede albergar el parametro lazy
# 'select'/true => nos va a cargar toda la data del hijo
# 'joined'/false => es muy parecido al select pero hace una sentencia de join inplicitamente para traer la data del hijo
# 'subquery' => hace la sentencia similar al joined pero lo que en realidad usa es un select anidado (un select dentro de otro select)
# 'dynamic' => retorna los objetos del join de la consulta
def __init__(self,
nombre,
fecha_nacimiento,
tipo,
raza,
sexo,
id_usu,
observaciones=None):
self.mascota_nombre = nombre
self.mascota_fechnac = fecha_nacimiento
self.mascota_tipo = tipo
self.mascota_raza = raza
self.mascota_sexo = sexo
self.usu_id = id_usu
if observaciones:
self.mascota_obs = observaciones
def retornar_mascota(self):
return {
'nombre': self.mascota_nombre,
'fecha de nacimiento': str(self.mascota_fechnac),
'tipo': self.mascota_tipo,
'raza': self.mascota_raza,
'sexo': self.mascota_sexo,
'observaciones': self.mascota_obs
}
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
def actualizar_mascota(self,
nombre=None,
tipo=None,
raza=None,
sexo=None,
observaciones=None):
if nombre:
self.mascota_nombre = nombre
if tipo:
self.mascota_tipo = tipo
if raza:
self.mascota_raza = raza
if sexo:
self.mascota_sexo = sexo
if observaciones:
self.mascota_obs = observaciones
bd.session.commit()
