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()