class UsuarioModel(bd.Model):
__tablename__ = "t_usuario"
# https://docs.sqlalchemy.org/en/13/core/metadata.html#sqlalchemy.schema.Column
# https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/
# https://docs.sqlalchemy.org/en/13/core/type_basics.html
id = bd.Column("usu_id", bd.Integer, primary_key=True)
nombre = bd.Column("usu_nom", bd.String(45))
apellido = bd.Column("usu_ape", bd.String(45))
tipo = bd.Column("usu_tipo", bd.Integer)
hashe = bd.Column("usu_hash", bd.Text, nullable=True)
salt = bd.Column("usu_salt", bd.Text, nullable=True)
direccion = bd.Column("usu_dir", bd.Text)
correo = bd.Column("usu_email", bd.String(45))
telefono = bd.Column("usu_fono", bd.String(25))
# RELACIONES
registro = bd.relationship('RegistroModel', lazy="dynamic")
turno = bd.relationship('TurnoModel', lazy="dynamic")
# usuario.horario
# select * from usuario inner join horario on usuario.usu_id=horario.usu_id
def __init__(self,
nombre,
apellido,
tipo,
direccion,
correo,
telefono,
password=None):
self.nombre = nombre
self.apellido = apellido
self.tipo = tipo
self.direccion = direccion
self.correo = correo
self.telefono = telefono
if password:
# encriptacion de mi contraseña
password_convertida = bytes(password, 'utf-8')
salt = bcrypt.gensalt()
hashed = bcrypt.hashpw(password_convertida, salt)
salt = salt.decode('utf-8')
hashed = hashed.decode('utf-8')
self.hashe = hashed
self.salt = salt
# metodo para sobreescribir la forma en que se devuelve un objeto, es exclusivo de las clases y la POO, es un metodo magico
def __str__(self):
return '{}, {}, {}'.format(self.nombre, self.apellido, self.correo)
def retornar_usuario(self):
return {
'nombre_completo': self.nombre + ' ' + self.apellido,
'correo': self.correo,
'telefono': self.telefono
}
def guardar_bd(self):
# cada vez que nosotros creamos una instancia para crear un nuevo usuario, lo mejor es mandar toda la instacion a almacenar a la base de datos para no tener problemas con referencias a ese objeto
# cuando creo mi sesion estoy insertando mi nuevo usuario, pero no lo estoy guardando, si hay algo mal o algo incorrecto, no lo guardara en la base de datos hasta hacer commit, caso contrario si no hay error pero no lo queremos guardar en la bd podemos hacer un rollback para 'retroceder en el tiempo' y asi no guardar ese registro, a esto se le llama TRANSACTION o TRANSACT-SQL
bd.session.add(self)
bd.session.commit()
class UsuarioModel(bd.Model):
__tablename__ = 't_usuario'
usu_id = bd.Column(bd.Integer, primary_key=True)
usu_nom = bd.Column(bd.String(45))
usu_ape = bd.Column(bd.String(45))
usu_titulos = bd.Column(bd.Text)
# relationship => no crean relaciones en la bd, pero sirven para devolver las relaciones de una manera mas facil sin la necesidad de usar filtros y tambien las relaciones inversas
contactos = bd.relationship('ContactoModel', backref='usuarioContacto')
redes_sociales = bd.relationship('RedSocialModel',
backref='usuarioRedSocial')
proyectos = bd.relationship('ProyectoModel', backref='usuarioProyecto')
class CabeceraDocumentoModel(bd.Model):
__tablename__="t_cabecera_doc"
id = bd.Column("cd_id", bd.Integer, primary_key=True)
fecha = bd.Column("cd_fech", bd.Date)
numeracion = bd.Column("cd_numeracion", bd.String(25))
total = bd.Column("cd_total", bd.DECIMAL(5,2))
# RELACION
usu_id = bd.Column(bd.Integer, bd.ForeignKey("t_usuario.usu_id"), nullable=False)
detalles = bd.relationship("DetalleDocumentoModel")
def __init__(self, fecha, numeracion, total, id_usu):
self.fecha = fecha
self.numeracion = numeracion
self.total = total
self.usu_id = id_usu
def retornar_cabecera(self):
return {
'nro': self.numeracion,
'fecha': self.fecha,
'total' : self.total
}
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
class PrecioModel(bd.Model):
__tablename__="t_precio"
id = bd.Column("precio_id",bd.Integer, primary_key=True)
descripcion = bd.Column("precio_desc", bd.String(45))
precio = bd.Column("precio_precio", bd.DECIMAL(5,2))
# RELACIONES
atenciones = bd.relationship("AtencionModel")
def __init__(self, descripcion, precio):
self.descripcion = descripcion
self.precio = precio
def guardar_bd(self):
bd.session.add(self)
bd.session.commit()
def retornar_precio(self):
return {
'descripcion':self.descripcion,
'precio':self.precio
}
def actualizar_precio(self, descripcion, precio):
self.descripcion= descripcion
self.precio = precio
bd.session.commit()
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 UsuarioModel(bd.Model):
__tablename__ = 't_usuario'
usu_id = bd.Column(bd.Integer, primary_key=True)
usu_nom = bd.Column(bd.String(45))
usu_ape = bd.Column(bd.String(45))
usu_titulos = bd.Column(bd.Text)
# relationship => no crean relaciones en la BD, pero sirven para devolver las relaciones de una manera mas facil,
# sin la necesidad de usar filtros y tambien las relaciones inversas
contactos = bd.relationship('ContactoModel', backref='usuarioContacto')
redes_sociales = bd.relationship('RedSocialModel',
backref='usuarioRedSocial')
proyectos = bd.relationship('ProyectoModel', backref='usuarioProyecto')
def __init__(self, nombre, apellido, titulos):
self.usu_nom = nombre
self.usu_ape = apellido
self.usu_titulos = titulos
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 OpcionesModel(bd.Model):
__tablename__ = "t_opcionesLocal"
id = bd.Column("ol_id", bd.Integer, primary_key=True)
descripcion = bd.Column("ol_desc", bd.String(45))
# relacion
# localtipo = bd.Column("loc_id",bd.Integer,bd.ForeignKey('t_local.loc_id'),nullable=False)
# local = bd.relationship("LocalModel")
def __init__(self, descripcion):
self.descripcion = descripcion
# self.localtipo = localtipo
def retornar_yisun(self):
return {'id': self.id, 'descripcion': self.descripcion}
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class CategoriaModel (bd.Model):
# si no le cambio el nombre de la tabla, automaticamente pondra de nombre el nombre de la clase
# https://docs.sqlalchemy.org/en/13/orm/tutorial.html
__tablename__="t_categoria"
# https://docs.sqlalchemy.org/en/13/core/type_basics.html#generic-types
id = bd.Column("cat_id", bd.Integer, primary_key=True)
nombre = bd.Column("cat_nom", bd.String(45))
# RELACIONES
productos = bd.relationship('ProductoModel', lazy='dynamic')
def __init__(self, nombre):
self.nombre = nombre
def devolver_json(self):
return {
'id':self.id,
'nombre': self.nombre
}
def guardar_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 TipoModel(bd.Model):
__tablename__ = "t_tipo"
id = bd.Column("tipo_id", bd.Integer, primary_key=True)
descripcion = bd.Column("tipo_desc", bd.String(45), nullable=True)
canchitas = bd.relationship('CanchitaModel', lazy=True, backref="tipos")
# backref=> es una manera simple de declarar una nueva propiedad en la clase CanchitasModel para poder ingresar a sus valores solamente necesitaria canchita.tipo
def __init__(self, descripcion):
self.descripcion = descripcion
def retornar_json(self):
return {'id': self.id, 'descripcion': self.descripcion}
def retornar_json_con_nombre_local(self):
locales = []
for canchita in self.canchitas:
locales.append(canchita.locales.retornar_yisun())
return {'descripcion': self.descripcion, 'nombres': locales}
def guarda_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()