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