class AgenciaModel(bd.Model):
__tablename__="t_agencia"
agen_id = bd.Column(bd.Integer, primary_key=True)
agen_nomb = bd.Column(bd.String(45))
agen_hor = bd.Column(bd.String(45))
agen_lat=bd.Column(bd.DECIMAL)
agen_lng=bd.Column(bd.DECIMAL)
usu_id= bd.Column(bd.Integer,bd.ForeignKey('t_usuario.usu_id'))
usuario = bd.relationship('UsuarioModel',lazy=True)
def __init__(self,nombre,horario,latitud,longitud,usuario):
self.agen_nomb=nombre
self.agen_hor=horario
self.agen_lat=latitud
self.agen_lng=longitud
self.usu_id=usuario
def retornar_json(self):
return {
"id":self.agen_id,
"nombre":self.agen_nomb,
"horario":self.agen_hor,
"latitud":str(self.agen_lat),
"longitud":str(self.agen_lng),
"telefono":self.usuario.usu_fono,
"tipo usuario":self.usuario.usu_tipo,
"direccion":self.usuario.usu_direccion
}
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class MovimientoModel(bd.Model):
__tablename__ = "t_movimiento"
mov_id = bd.Column(bd.Integer, primary_key=True)
mov_tipo = bd.Column(bd.String(45))
mov_monto = bd.Column(bd.DECIMAL)
mov_fecha = bd.Column(bd.DATETIME)
nro_cue_destino = bd.Column(bd.String(45))
cue_id = bd.Column(bd.Integer, bd.ForeignKey('t_cuenta.cue_id'))
cuentacliente = bd.relationship('CuentaModel', lazy=True)
def __init__(self, tipo, monto, fecha, destinatario, cuenta):
self.mov_tipo = tipo
self.mov_monto = monto
self.mov_fecha = fecha
self.nro_cue_destino = destinatario
self.cue_id = cuenta
def retornar_json(self):
return {
'tipo': self.mov_tipo,
'monto': str(self.mov_monto),
'fecha': str(self.mov_fecha),
'cuenta_destino': self.nro_cue_destino,
'cuenta': self.cue_id
}
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class UsuarioModel(bd.Model):
__tablename__ = "t_usuario"
usu_id = bd.Column("usu_id", bd.Integer, primary_key=True)
usu_mail = bd.Column("usu_mail", bd.String(50))
usu_salt = bd.Column("usu_salt", bd.Text)
usu_hash = bd.Column("usu_hash", bd.Text)
usu_nom = bd.Column("usu_nom", bd.String(45))
usu_ape = bd.Column("usu_ape", bd.String(50))
usu_fono = bd.Column("usu_fono", bd.String(20))
tipousu_id = bd.Column(bd.Integer,
bd.ForeignKey('t_tipo_usuario.tipousu_id'),
nullable=False)
def __init__(self, correo, password, nombre, apellido, fono, tipousu_id):
self.usu_mail = correo
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.usu_salt = salt
self.usu_hash = hashed
self.usu_nom = nombre
self.usu_ape = apellido
self.usu_fono = fono
self.tipousu_id = tipousu_id
class UsuarioModel(bd.Model):
__tablename__ = "t_usuario"
usu_id = bd.Column(bd.Integer, primary_key=True)
usu_hash = bd.Column(bd.Text)
usu_salt = bd.Column(bd.Text)
usu_mail = bd.Column(bd.Text)
usu_tipo = bd.Column(bd.Integer)
usu_fono = bd.Column(bd.String(10))
usu_direccion = bd.Column(bd.String(50))
cliente = bd.relationship('ClienteModel', lazy=True)
def __init__(self, password, email, tipo_usuario, telefono, direccion):
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.usu_salt = salt
self.usu_hash = hashed
self.usu_mail = email
self.usu_tipo = tipo_usuario
self.usu_fono = telefono
self.usu_direccion = direccion
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class EmpresaModel(bd.Model):
# Yo al heredar la clase Model todo lo que defina como atributos van a ser columnas de una tabla y la clase va a ser una tabla de la bd
# si no especifico el nombre de la tabla, el nombre por defecto sera el nombre de la clase, si yo no quiero ese nombre y quiero uno diferente, uso el atributo __tablename__
__tablename__ = "t_empresa"
# https://docs.sqlalchemy.org/en/13/core/type_basics.html?highlight=datatypes
id = bd.Column('emp_id', bd.Integer, primary_key=True)
nombre = bd.Column('emp_nom', bd.String(45))
latitud = bd.Column('emp_lat', bd.DECIMAL(10, 8))
longitud = bd.Column('emp_lng', bd.DECIMAL(10, 8))
foto = bd.Column('emp_foto', bd.Text)
fono = bd.Column('emp_fono', bd.String(15))
direccion = bd.Column('emp_dir', bd.String(50))
# RELACIONES
distrito = bd.Column('distrito_id',
bd.Integer,
bd.ForeignKey('t_distrito.distrito_id'),
nullable=False)
def __init__(self, nombre, latitud, longitud, foto, fono, dir, dist_id):
self.nombre = nombre
self.latitud = latitud
self.longitud = longitud
self.foto = foto
self.fono = fono
self.direccion = dir
self.distrito = dist_id
class ProductoModel(bd.Model):
__tablename__ = "t_producto"
prod_id = bd.Column("prod_id", bd.Integer, primary_key=True)
prod_nom = bd.Column("prod_nom", bd.String(40))
prod_desc = bd.Column("prod_desc", bd.String(40))
cat_id = bd.Column(bd.Integer,
bd.ForeignKey('t_categoria.cat_id'),
nullable=False)
def __init__(self, nombre, descripcion, cat_id):
self.prod_nom = nombre
self.prod_desc = descripcion
self.cat_id = cat_id
class ProveedorModel(bd.Model):
__tablename__ = "t_proveedor"
prov_id = bd.Column("prov_id", bd.Integer, primary_key=True)
prov_nom = bd.Column("prov_nom", bd.String(45))
prov_ape = bd.Column("prov_ape", bd.String(50))
prov_fono = bd.Column("prov_fono", bd.String(20))
prov_dir = bd.Column("prov_dir", bd.String(200))
def __init__(self, nombre, apellido, fono, direccion):
self.prov_nom = nombre
self.prov_ape = apellido
self.prov_fono = fono
self.prov_dir = direccion
class ClienteModel(bd.Model):
__tablename__="t_cliente"
id_cliente = bd.Column("cli_id", bd.Integer, primary_key = True, autoincrement = True, nullable = False)
dni_cliente = bd.Column("cli_dni", bd.String(8), nullable = False) # unique=True
nombre_cliente = bd.Column("cli_nomb", bd.String(45), nullable = False)
apellido_cliente = bd.Column("cli_ape", bd.String(45), nullable = False)
estado = bd.Column(bd.Boolean, default=True, nullable=False)
# Sirve para hacer la relacion inversa
prestamosCliente = bd.relationship('PrestamoModel', backref='clientePrestamo')
def __init__(self, dni, nombre, apellido):
self.dni_cliente = dni
self.nombre_cliente = nombre
self.apellido_cliente = apellido
def devolverJson(self):
return {
'id': self.id_cliente,
'dni': self.dni_cliente,
'nombre': self.nombre_cliente,
'apellido': self.apellido_cliente,
'estado': self.estado
}
def devolverClientePrestamo(self):
# modo intermedio-avanzado
resultado = self.devolverJson()
# print(self.prestamosCliente)
prestamos = []
for prestamo in self.prestamosCliente:
prestamos.append(prestamo.devolverJson())
resultado['prestamos']=prestamos
return resultado
# modo intermedio
# prestamos = []
# for prestamo in self.prestamosCliente:
# prestamos.append(prestamo.devolverJson())
# return {
# 'id': self.id_cliente,
# 'dni': self.dni_cliente,
# 'nombre': self.nombre_cliente,
# 'apellido': self.apellido_cliente,
# 'estado': self.estado,
# 'prestamos': prestamos
# }
def save(self):
bd.session.add(self)
bd.session.commit()
class EstadoModel(bd.Model):
__tablename__ = "t_estado"
est_id = bd.Column("est_id", bd.Integer, primary_key=True)
est_nom = bd.Column("est_nom", bd.String(50))
def __init__(self, nombre):
self.est_nom = nombre
class DistritoModel(bd.Model):
__tablename__="t_distrito"
id = bd.Column('distrito_id',bd.Integer,primary_key=True)
descripcion = bd.Column('distrito_desc', bd.String(45), nullable=False)
# RELACIONES
departamento = bd.Column('dep_id', bd.Integer, bd.ForeignKey('t_departamento.dep_id'),nullable=False)
# RELACION INVERSA
empresas = bd.relationship('EmpresaModel',backref='empresa')
def __init__(self, desc, dep_id):
self.descripcion = desc
self.departamento = dep_id
def guardar(self):
bd.session.add(self)
bd.session.commit()
def retornarJson(self):
return {
'id': self.id,
'nombre':self.descripcion,
}
def retornarJsonConDepartamento(self):
dep = DepartamentoModel.query.filter_by(id=self.departamento).first()
return {
'id': self.id,
'nombre':self.descripcion,
'departamento':{
'id':dep.id,
'nombre': dep.descripcion
}
}
class CategoriaModel(bd.Model):
__tablename__ = "t_categoria"
cat_id = bd.Column("cat_id", bd.Integer, primary_key=True)
cat_nom = bd.Column("cat_nom", bd.String(50))
def __init__(self, nombre):
self.cat_nom = nombre
class TipoTransporteModel(bd.Model):
__tablename__ = "t_tipo_transporte"
tipotran_id = bd.Column("tipotran_id", bd.Integer, primary_key=True)
tipotran_nom = bd.Column("tipotran_nom", bd.String(50))
def __init__(self, nombre, img):
self.tipotran_nom = nombre
class TipoUsuarioModel(bd.Model):
__tablename__ = "t_tipo_usuario"
tipousu_id = bd.Column("tipousu_id", bd.Integer, primary_key=True)
tipousu_nom = bd.Column("tipousu_nom", bd.String(50))
def __init__(self, nombre, img):
self.tipousu_nom = nombre
class TipoMonedaModel(bd.Model):
__tablename__="t_tipomoneda"
tipomon_id = bd.Column(bd.Integer, primary_key=True)
tipomon_desc = bd.Column(bd.String(45))
def __init__(self,descripcion):
self.tipomon_desc=descripcion
class CuentaModel(bd.Model):
__tablename__ = "t_cuenta"
cue_id = bd.Column(bd.Integer, primary_key=True)
cue_nro = bd.Column(bd.String(20))
cue_tipo = bd.Column(bd.String(45))
cue_saldo = bd.Column(bd.DECIMAL)
cue_estado = bd.Column(bd.Boolean)
tipomoneda_id = bd.Column(bd.Integer,
bd.ForeignKey('t_tipomoneda.tipomon_id'))
cliente_id = bd.Column(bd.Integer, bd.ForeignKey('t_cliente.cli_id'))
agencia_id = bd.Column(bd.Integer, bd.ForeignKey('t_agencia.agen_id'))
cliente = bd.relationship('ClienteModel', lazy=True)
movimiento = bd.relationship('MovimientoModel', lazy=True)
def __init__(self, nro, tipo, saldo, estado, moneda, cliente, agencia):
self.cue_nro = nro
self.cue_tipo = tipo
self.cue_saldo = saldo
self.cue_estado = estado
self.tipomoneda_id = moneda
self.cliente_id = cliente
self.agencia_id = agencia
def retornar_jsoncliente(self):
return {
"nro de cuenta": self.cue_nro,
"tipo": self.cue_tipo,
"saldo": str(self.cue_saldo),
"estado": self.cue_estado,
"moneda": self.tipomoneda_id,
"id cliente": self.cliente_id,
}
def retornar_jsonagencia(self):
return {
"nro de cuenta": self.cue_nro,
"tipo": self.cue_tipo,
"saldo": str(self.cue_saldo),
"estado": self.cue_estado,
"moneda": self.tipomoneda_id,
"id agencia": self.agencia_id
}
def actualizar_estado(self, nuevo_saldo):
self.cue_saldo = nuevo_saldo
bd.session.commit()
class TransporteModel(bd.Model):
__tablename__ = "t_transporte"
tran_id = bd.Column("tran_id", bd.Integer, primary_key=True)
tran_nom = bd.Column("tran_nom", bd.String(45))
tran_ape = bd.Column("tran_ape", bd.String(50))
tran_fono = bd.Column("tran_fono", bd.String(20))
tran_placa = bd.Column("tran_placa", bd.String(200))
tipotran_id = bd.Column(bd.Integer,
bd.ForeignKey('t_tipo_transporte.tipotran_id'),
nullable=False)
def __init__(self, nombre, apellido, fono, placa, tipotran_id):
self.tran_nom = nombre
self.tran_ape = apellido
self.tran_fono = fono
self.tran_placa = placa
self.tran_id = tipotran_id
class ClienteModel(bd.Model):
__tablename__ = "t_cliente"
cli_id = bd.Column(bd.Integer, primary_key=True)
cli_nomb = bd.Column(bd.String(45))
cli_ape = bd.Column(bd.String(45))
cli_fechanac = bd.Column(bd.DATETIME)
usu_id = bd.Column(bd.Integer, bd.ForeignKey('t_usuario.usu_id'))
cuentacliente = bd.relationship('CuentaModel', lazy=True)
def __init__(self, nombre, apellido, fecha_nacimiento, usuario):
self.cli_nomb = nombre
self.cli_ape = apellido
self.cli_fechanac = fecha_nacimiento
self.usu_id = usuario
def guardar_en_la_bd(self):
bd.session.add(self)
bd.session.commit()
class UbicacionModel(bd.Model):
__tablename__ = "t_ubicacion"
ubi_id = bd.Column("ubi_id", bd.Integer, primary_key=True)
ubi_ciud = bd.Column("ubi_ciud", bd.String(45))
ubi_dir = bd.Column("ubi_dir", bd.String(200))
ubi_lat = bd.Column("ubi_lat", bd.DECIMAL(10, 8))
ubi_lng = bd.Column("ubi_lng", bd.DECIMAL(10, 8))
ubi_refer = bd.Column("ubi_refer", bd.TEXT)
usu_id = bd.Column(bd.Integer,
bd.ForeignKey('t_usuario.usu_id'),
nullable=False)
def __init__(self, ciudad, direccion, latitud, longitud, referencia,
usu_id):
self.ubi_ciud = ciudad
self.ubi_dir = direccion
self.ubi_lat = latitud
self.ubi_lng = longitud
self.ubi_refer = referencia
self.usu_id = usu_id
class DetallePedidoModel(bd.Model):
__tablename__ = "t_detalle_pedido"
dped_id = bd.Column("dped_id", bd.Integer, primary_key=True)
dped_desc = bd.Column("dped_desc", bd.String(100))
dped_subtotal = bd.Column("dped_subtotal", bd.DECIMAL(10, 2))
dped_total = bd.Column("dped_total", bd.DECIMAL(10, 2))
dped_nro = bd.Column("dped_nro", bd.String(10))
ped_id = bd.Column(bd.Integer,
bd.ForeignKey('t_pedido.ped_id'),
nullable=False)
pre_id = bd.Column(bd.Integer,
bd.ForeignKey('t_precio.pre_id'),
nullable=False)
def __init__(self, descripcion, subtotal, nro, total, ped_id, pre_id):
self.dped_desc = descripcion
self.dped_subtotal = subtotal
self.dped_total = total
self.dped_nro = nro
self.ped_id = ped_id
self.pre_id = pre_id
class AlmacenModel(bd.Model):
__tablename__ = "t_almacen"
alm_id = bd.Column("alm_id", bd.Integer, primary_key=True)
alm_cap = bd.Column("alm_cap", bd.String(200))
alm_est = bd.Column("alm_est", bd.BOOLEAN)
alm_lat = bd.Column("alm_lat", bd.DECIMAL(10, 2))
alm_lng = bd.Column("alm_lng", bd.DECIMAL(10, 2))
provpro_id = bd.Column(bd.Integer,
bd.ForeignKey('t_proveedor_producto.provpro_id'),
nullable=False)
def __init__(self, capacidad, estado, lat, lng, provpro_id):
self.alm_cap = capacidad
self.alm_est = estado
self.alm_lat = lat
self.alm_lng = lng
self.provpro_id = provpro_id
class PresentacionModel(bd.Model):
__tablename__ = "t_presentacion"
pres_id = bd.Column("pres_id", bd.Integer, primary_key=True)
pres_est = bd.Column("pres_est", bd.BOOLEAN)
pres_can = bd.Column("pres_can", bd.DECIMAL(10, 2))
pres_uni = bd.Column("pres_uni", bd.String(30))
pre_id = bd.Column(bd.Integer,
bd.ForeignKey('t_precio.pre_id'),
nullable=False)
provpro_id = bd.Column(bd.Integer,
bd.ForeignKey('t_proveedor_producto.provpro_id'),
nullable=False)
def __init__(self, estado, cantidad, unidad, pre_id, provpro_id):
self.pres_est = estado
self.pres_can = cantidad
self.pres_uni = unidad
self.pre_id = pre_id
self.provpro_id = provpro_id
class DepartamentoModel(bd.Model):
__tablename__ = "t_departamento"
id = bd.Column('dep_id', bd.Integer, primary_key=True)
descripcion = bd.Column('dep_desc', bd.String(45), unique=True)
# ESTO NO CREA UNA RELACION
# REVERSE RELATIONS
distritos = bd.relationship('DistritoModel', backref='distrito')
# https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/#one-to-many-relationships
# el parametro lazy puede admitir distintos valores
# 'select'/True => valor x defecto. para cargar la data de su hijo
# 'joined'/False => es como usar un inner join cuando vamos a hacer el select
# 'subquery' => es muy parecido al joined pero x detras usar una subquery para jalar los datos de su hijo
# 'dynamic' => returna los objetos del join de la consulta
def __init__(self, desc):
self.descripcion = desc
def __str__(self):
return 'id:{} nombre:{}'.format(self.id, self.descripcion)
def retornarJson(self):
listDistritos = []
for distrito in self.distritos:
listDistritos.append(distrito.retornarJson())
return {
'id': self.id,
'nombre': self.descripcion,
'distritos': listDistritos
}
def guardar(self):
bd.session.add(self)
bd.session.commit()
def actualizar_departamento(self, nueva_desc):
self.descripcion = nueva_desc
bd.session.commit()
class LibroModel(bd.Model):
__tablename__ = "t_libro"
id_libro = bd.Column('lib_id',
bd.Integer,
primary_key=True,
autoincrement=True)
nombre_libro = bd.Column('lib_nom', bd.String(45), nullable=False)
edicion_libro = bd.Column('lib_edicion', bd.Date(), nullable=False)
autor_libro = bd.Column('lib_autor', bd.Text(), nullable=False)
cantidad_libro = bd.Column('lib_cant', bd.Integer, nullable=False)
estado = bd.Column(bd.Boolean, default=True, nullable=False)
# Sirve para hacer la relacion inversa
# solo se crea en las tablas que se hace la relacion
# backref sirve para uso interno de sqlalchemist
prestamosLibro = bd.relationship('PrestamoModel', backref='libroPrestamo')
def __init__(self, nombre, edicion, cantidad, autor):
self.nombre_libro = nombre
self.edicion_libro = edicion
self.cantidad_libro = cantidad
self.autor_libro = autor
def save(self):
# crea la instanciacion en la base de datos (ingresa todos los datos, pero aun no se guardan)
bd.session.add(self)
# hace que los cambios ingresados sean permanentes (aca ya se guarda en la base de datos)
bd.session.commit()
def __str__(self):
# este metodo magico permite sobreescribir la forma en la cual se lee el objeto en consola
return self.nombre_libro
def devolverJson(self):
return {
'id': self.id_libro,
'nombre': self.nombre_libro,
'edicion': str(self.edicion_libro),
'autor': self.autor_libro,
'cantidad': self.cantidad_libro,
'estado': self.estado
}
def devolverLibroPrestamo(self):
resultado = self.devolverJson()
print(self.prestamosLibro)
prestamos = []
for prestamo in self.prestamosLibro:
prestamos.append(prestamo.devolverJson())
# agregamos una nueva llave llamada prestamos
resultado['prestamos'] = prestamos
return resultado
def devolverPrestamosLibroPorId(self):
resultado = self.devolverJson()
prestamos = []
for prestamo in self.prestamosLibro:
prestamos.append(prestamo.devolverJsonPorLibroId())
resultado['prestamos'] = prestamos
return resultado
def update(self, **kwargs): #parametro=valor, parametro2=valor2
# el metodo get se usa para los diccionarios y se encarga de que de auerdo a la llave que le pasemos (parametro 1)
# va a devolver su valor, y opcionalmente como segundo parametro que le puede indicar que valor va a retornar, si es que la llave indicada no existe
nombre = kwargs.get('nombre') if kwargs.get(
'nombre') else self.nombre_libro # usando operador ternario
autor = kwargs.get('autor') if kwargs.get(
'autor') else self.autor_libro
edicion = kwargs.get('edicion') if kwargs.get(
'edicion') else self.edicion_libro
cantidad = kwargs.get('cantidad') if kwargs.get(
'cantidad') else self.cantidad_libro
estado = kwargs.get('estado') if kwargs.get('estado') else self.estado
self.nombre_libro = nombre
self.autor_libro = autor
self.edicion_libro = edicion
self.cantidad_libro = cantidad
self.estado = estado
self.save()
def delete(self, **kwargs):
bd.session.delete(self)
bd.session.commit()
def inhabilitarLibro(self):
self.estado = False
self.save()
class ClienteModel(bd.Model):
__tablename__ = "t_cliente"
id_cliente = bd.Column('cli_id',
bd.Integer,
primary_key=True,
autoincrement=True)
dni_cliente = bd.Column('cli_dni', bd.String(8), nullable=False)
nombre_cliente = bd.Column('cli_nomb', bd.String(45), nullable=False)
apellido_cliente = bd.Column('cli_ape', bd.String(45), nullable=False)
estado = bd.Column(bd.Boolean, default=True, nullable=False)
prestamosCliente = bd.relationship('PrestamoModel',
backref='clientePrestamo')
def __init__(self, dni, nombre, apellido):
self.dni_cliente = dni
self.nombre_cliente = nombre
self.apellido_cliente = apellido
def save(self):
bd.session.add(self)
bd.session.commit()
def __str__(self):
return self.nombre_cliente
def devolverJson(self):
return {
'id': self.id_cliente,
'dni': str(self.dni_cliente),
'nombre': self.nombre_cliente,
'apellido': self.apellido_cliente,
'estado': self.estado
}
def devolverClientePrestamo(self):
resultado = self.devolverJson()
print(self.prestamosCliente)
prestamos = []
for prestamo in self.prestamosCliente:
prestamos.append(prestamo.devolverJson())
# agregamos una nueva llave llamada prestamos
resultado['prestamos'] = prestamos
return resultado
def devolverPrestamosClientePorId(self):
resultado = self.devolverJson()
prestamos = []
for prestamo in self.prestamosCliente:
prestamos.append(prestamo.devolverJsonPorClienteId())
resultado['prestamos'] = prestamos
return resultado
def update(self, **kwargs):
dni = kwargs.get('dni') if kwargs.get('dni') else self.dni_cliente
nombre = kwargs.get('nombre') if kwargs.get(
'nombre') else self.nombre_cliente
apellido = kwargs.get('apellido') if kwargs.get(
'apellido') else self.apellido_cliente
estado = kwargs.get('estado') if kwargs.get('estado') else self.estado
self.dni_cliente = dni
self.nombre_cliente = nombre
self.apellido_cliente = apellido
self.estado = estado
self.save()
def inhabilitarCliente(self):
self.estado = False
self.save()