class Domicilio(db.Model):
"""
Este modelo representará a las Domicilio.
Contará con los siquientes campos:
domicilio_id --> clave primaria
calle --> numero o nombre de la calle
numero --> numero/altura de la direccion
departamento --> departamento(string)
piso --> numero en el caso de departamento
aclaracion --> aclaracion del domicilio
localidad_id --> clave forania refenciando a la tabla localidad
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'domicilio'
# Atributos
domicilio_id = db.Column(db.Integer, primary_key=True)
calle = db.Column(db.String(50), nullable=False)
numero = db.Column(db.Integer)
departamento = db.Column(db.String(50))
piso = db.Column(db.Integer)
aclaracion = db.Column(db.String(80), nullable=False)
localidad_id = db.Column(db.Integer,
db.ForeignKey('localidad.localidad_id'),
nullable=False)
persona_id = db.Column(db.Integer,
db.ForeignKey('persona.persona_id'),
nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, calle, numero, aclaracion, localidad_id):
"""
Constructor de la clase domicilio
"""
self.calle = calle
self.numero = numero
self.aclaracion = aclaracion
self.localidad_id = localidad_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
loc = Localidad.query.filter_by(localidad_id=self.localidad_id)
return 'Calle {} {}, localidad de'.format(self.calle, self.numero, loc)
def getDireccion(self):
return "calle " + self.calle + " numero " + self.numero
def getLocalidad(self):
loca = Localidad.query.filter_by(localidad_id=self.localidad_id)
prov = Provincia.query.filter_by(provincia_id=loca.provincia_id)
return "Localidad {} de la provincia de {}".format(loca, prov)
# metodo qe devuelva calle/nº
# localidad/pcia
class Producto(db.Model):
"""
Este modelo representará a las producto.
Contará con los siquientes campos:
producto_id --> clave primaria
descripcion --> nombre del producto
precio_id --> clave forania refenciando a la tabla precio
estado_producto_id --> clave forania refenciando a la tabla estado de producto
tipo_producto_id --> clave forania refenciando a la tabla tipo de producto
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'producto'
# Atributos
producto_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
precio_id = db.Column(db.Integer,
db.ForeignKey('precio.precio_id'),
nullable=False)
estado_producto_id = db.Column(
db.Integer,
db.ForeignKey('estado_producto.estado_producto_id'),
nullable=False)
tipo_producto_id = db.Column(
db.Integer,
db.ForeignKey('tipo_producto.tipo_producto_id'),
nullable=False)
detalle_pedido = db.relationship('DetallePedido',
uselist=False,
backref='detalle_pedido',
lazy=True)
detalle_stock = db.relationship('DetalleStock',
backref='detalle_stock',
lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion, precio_id, tipo_producto_id):
"""
Constructor de la clase producto
"""
self.descripcion = descripcion
self.precio_id = precio_id
self.tipo_producto_id = tipo_producto_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Producto: {}'.format(self.descripcion)
def getProducto(self):
return self.descripcion
def getPrecioProdcuto(self):
precio = Precio.query.filter_by(provincia_id=self.precio_id)
return "Producto " + self.descripcion + " precio: " + precio.valor
class Pedido(db.Model):
"""
Este modelo representará a pedido.
Contará con los siquientes campos:
pedido_id --> clave primaria
detalle_id --> clave forania refenciando a la tabla detalle
usuario_id --> clave forania refenciando a la tabla usuario
estado_id --> clave forania refenciando a la tabla estado
tipo_pedido_id --> clave forania refenciando a la tabla tipo de pedido
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'pedido'
# Atributos
pedido_id = db.Column(db.Integer, primary_key=True)
detalle = db.relationship('DetallePedido',
uselist=False,
backref='detalles_pedidos',
lazy=True)
usuario_id = db.Column(db.Integer,
db.ForeignKey('usuario.id'),
nullable=False)
estado_pedido_id = db.Column(
db.Integer,
db.ForeignKey('estado_pedido.estado_pedido_id'),
nullable=False)
tipo_pedido_id = db.Column(db.Integer,
db.ForeignKey('tipo_pedido.tipo_pedido_id'),
nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, detalle_id, usuario_id, estado_id, tipo_pedido_id):
"""
Constructor de la clase pedido
"""
self.detalle_id = detalle_id
self.estado_pedido_id = estado_id
self.usuario_id = usuario_id
self.tipo_pedido_id = tipo_pedido_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'pedido {}'.format(self.detalle_id, self.usuario_id,
self.estado_pedido_id, self.tipo_pedido_id)
class Localidad(db.Model):
"""
Este modelo representará a las localidades.
Contará con los siquientes campos:
localidad_id --> clave primaria
descripcion --> nombre de la localidad
provincia_id --> clave forania refenciando a la tabla provincia
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'localidad'
# Atributos
localidad_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
provincia_id = db.Column(db.Integer,
db.ForeignKey('provincia.provincia_id'),
nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion, provincia_id):
"""
Constructor de la clase localidad
"""
self.descripcion = descripcion
self.provincia_id = provincia_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'localidad de {}'.format(self.descripcion, self.provincia_id)
class CuentaCorriente(db.Model):
"""
Este modelo representará el Cuenta corriente.
Contará con los siquientes campos:
cuenta_corriente_id --> clave primaria
persona_id --> clave forania refenciando a la tabla persona
tipo_movimiento_id --> clave forania refenciando a la tabla tipo de movimiento
usuario_id --> clave forania refenciando a la tabla usuario
saldo --> represanta el saldo de la cuenta corriente
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'cuenta_corriente'
# Atributos
cuenta_corriente_id = db.Column(db.Integer, primary_key=True)
persona_id = db.Column(db.Integer, db.ForeignKey('persona.persona_id'),nullable=False)
movimientos = db.relationship('MovimientoCtaCorriente', backref='movimiento_ctacorriente', lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, persona_id):
"""
Constructor de la clase Cuenta_corriente
"""
self.persona_id = persona_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'cuenta corriente: {}'.format(self.persona_id)
class DetalleStock(db.Model):
"""
Este modelo representará a stock.
Contará con los siquientes campos:
stock_id --> clave primaria
descripcion --> nombre del stock
cantidad --> represanta la cantidad "real" del producto
tipo_movimiento_id --> clave forania refenciando a la tabla tipo de movimientos
usuario_id --> clave forania refenciando a la tabla usuario
tipo_producto_id --> clave forania refenciando a la tabla tipo de producto
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'detalle_stock'
# Atributos
stock_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
cantidad = db.Column(db.String(80), nullable=False)
tipo_movimiento_stock_id = db.Column(db.Integer, db.ForeignKey(\
'tipo_movimiento_stock.tipo_movimiento_stock_id'), \
nullable=False)
usuario_id = db.Column(db.Integer, db.ForeignKey('usuario.id'), nullable=False)
producto_id = db.Column(db.Integer, db.ForeignKey('producto.producto_id'), nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion, cantidad, tipo_movimiento_id, usuario_id, tipo_producto_id):
"""
Constructor de la clase stock
"""
self.descripcion = descripcion
self.cantidad = cantidad
self.tipo_movimiento_id = tipo_movimiento_id
self.usuario_id = usuario_id
self.tipo_producto_id = tipo_producto_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'stock {}'.format(self.descripcion, self.cantidad, self.tipo_movimiento_id, self.usuario_id, self.tipo_producto_id)
class MovimientoCtaCorriente(db.Model):
"""
Representa a la asociación de usuario que realiza la carga,
la cta corriente a la cual pertenece el movimiento,
el tipo de movimiento que se deberá registrar y el saldo
asociado.
"""
# Nombre de la tabla
__tablename__ = 'movimiento_cta_corriente'
# Atributos
movimiento_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
# Relacionamos el movimiento con la cuenta corriente
cta_corriente = db.Column(db.Integer, db.ForeignKey('cuenta_corriente.cuenta_corriente_id'),nullable=False)
# Relacionamos el tipo de movimiento con la cuenta corriente
tipo_movimiento_cta_corriente = db.Column(db.Integer, db.ForeignKey(\
'tipo_movimiento_cta_corriente.tipo_movimiento_cta_corriente_id'), \
nullable=False)
# Relacionamos el usuario que realiza el movimiento en la cta corriente
usuario = db.Column(db.Integer, db.ForeignKey('usuario.id'),nullable=False)
saldo = db.Column(db.Float(), nullable=False)
def __init__(self, descripcion, usuario, tipo_movimiento_cta_corriente, cta_corriente, saldo):
"""
A la hora de agregar un movimiento a la cta corriente necesitamos tener registro
del usuario que realiza la carga del movimiento, el tipo de movimiento a realizar,
la cuenta corriente y el saldo.
"""
self.descripcion = descripcion
self.usuario = usuario
self.tipo_movimiento_cta_corriente = tipo_movimiento_cta_corriente
self.cta_corriente = cta_corriente
self.saldo = saldo
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'tipo de movimiento: {}'.format(self.descripcion)
class DetallePedido(db.Model):
"""
Este modelo representará el Detalle.
Contará con los siquientes campos:
detalle_id --> clave primaria
producto_id --> clave forania refenciando a la tabla producto
cantidad --> represanta la cantidad del producto
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'detalle_pedido'
# Atributos
detalle_id = db.Column(db.Integer, primary_key=True)
producto_id = db.Column(db.Integer,
db.ForeignKey('producto.producto_id'),
nullable=False)
pedido_id = db.Column(db.Integer,
db.ForeignKey('pedido.pedido_id'),
nullable=False)
cantidad = db.Column(db.String(80), nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, producto_id, cantidad):
"""
Constructor de la clase Detalle
"""
self.producto_id = producto_id
self.cantidad = cantidad
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'detalle: {}'.format(self.producto_id, self.cantidad)
class Precio(db.Model):
"""
Este modelo representará a los precios.
Contará con los siquientes campos:
precio_id --> clave primaria
descripcion --> descripcion del precio
valor --> describe el valor numerico del precio
lista_precio_id --> clave forania refenciando a la tabla lista de precios
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'precio'
# Atributos
precio_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
valor = db.Column(db.Float(), nullable=False)
lista_precio_id = db.Column(db.Integer,
db.ForeignKey('lista_precio.lista_precio_id'),
nullable=False)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion, valor, lista_precio_id):
"""
Constructor de la clase precio
"""
self.descripcion = descripcion
self.valor = valor
self.lista_precio_id = lista_precio_id
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'precio de {}'.format(self.descripcion)
class Usuario(db.Model, UserMixin):
"""
Este modelo representará a la tabla usuarios.
Contará con los siquientes campos:
id --> clave primaria
username --> nombre de usuario
password --> passwd del usuario
descripcion --> descripcion del usuario
persona_id -- > persona_id foreing key referenciando a la entidad persona
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'usuario'
# Atributos
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password_hash = db.Column(db.String(50), nullable=False)
descripcion = db.Column(db.String(50))
persona_id = db.Column(db.Integer,
db.ForeignKey('persona.persona_id'),
nullable=False)
usuario_rol = db.relationship('Rol', secondary=usuario_rol)
movientos = db.relationship('MovimientoCtaCorriente',
uselist=False,
backref='movimientos',
lazy=True)
detalle_stock = db.relationship('DetalleStock',
uselist=False,
backref='detalles_stocks_usuarios',
lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, username, password, persona_id):
"""
Constructor de la clase usuario
"""
self.username = username
self.password_hash = password
self.persona_id = persona_id
def get_username(self):
"""
Devuelve el username.
"""
return self.username
def get_email(self):
print('persona id {}'.format(self.persona_id), flush=True)
def get_role(self):
"""
Devuelve el o los roles que tiene asociado el usuario.
"""
lista_roles = [str(r) for r in self.usuario_rol]
return lista_roles[0]
def get_mis_datos(self):
"""
Nos devuelve un diccionario con los siguientes campos:
- username
- email
- telefono principal
- telefono secundario
"""
datos = {}
datos['username'] = self.username
persona = Persona.query.filter_by(persona_id=self.persona_id).first()
datos['email'] = persona.get_email()
datos['tel_principal'] = persona.get_tel_principal()
datos['tel_secundario'] = persona.get_tel_secundario()
return datos
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f"UserName: {self.username}"
def has_role(self, role):
"""
Verificamos si el usuario tiene el rol pasado
por parametro
"""
lista_roles = [str(r) for r in self.usuario_rol]
if role in lista_roles:
return True
else:
return False
from distribuidora import db, login_manager
from sqlalchemy import event
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from distribuidora.models.persona import Persona
from distribuidora.models.stock import DetalleStock
# Establecemos las tablas pivot.
# Relacionamos un usuario con uno o mas roles.
usuario_rol = db.Table(
'usuario_rol',
db.Column('id', db.Integer, db.ForeignKey('usuario.id'), primary_key=True),
db.Column('rol_id',
db.Integer,
db.ForeignKey('rol.rol_id'),
primary_key=True))
# Relacionamos los roles con los permisos
rol_permiso = db.Table(
'rol_permiso',
db.Column('permiso_id',
db.Integer,
db.ForeignKey('permiso.permiso_id'),
primary_key=True),
db.Column('rol_id',
db.Integer,
db.ForeignKey('rol.rol_id'),
primary_key=True))
class Persona(db.Model):
"""
Este modelo representará a la entidad Persona.
Contará con los siquientes campos:
persona_id --> clave primaria
apellido --> apellido de la persona
nombre --> nombre de la persona
fecha_nacimiento --> fecha de nacimiento de la persona
email --> email de la persona
razon_social --> Nombre en caso de ser un empresa
telefono_ppal --> telefono principal de la persona
telefono_sec --> telefono secundario de la persona
tipo_dni_id --> tipo dni foreing key contra la entidad tipo_dni
num_dni --> numero de dni de la persona
domicilio_id --> domicilio_id foreing jey referenciando a la entidad domicilio
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'persona'
# Atributos
persona_id = db.Column(db.Integer, primary_key=True)
apellido = db.Column(db.String(50))
nombre = db.Column(db.String(50))
num_dni = db.Column(db.String(10))
fecha_nacimiento = db.Column(db.DateTime, nullable=True)
email = db.Column(db.String(50), nullable=False, unique=True)
razon_social = db.Column(db.String(50))
telefono_ppal = db.Column(db.String(50), nullable=False)
telefono_sec = db.Column(db.String(50))
tipo_dni_id = db.Column(db.Integer,
db.ForeignKey('tipo_dni.tipo_dni_id'),
nullable=True)
cuenta_corriente = db.relationship('CuentaCorriente',
backref='cuenta_corriente',
lazy=True,
uselist=False)
usuario = db.relationship('Usuario',
backref='persona',
lazy=True,
uselist=False)
domicilio = db.relationship('Domicilio',
backref='persona',
lazy=True,
uselist=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, apellido, nombre, email, telefono_ppal):
"""
Constructor de la clase persona
"""
self.apellido = apellido
self.nombre = nombre
self.email = email
self.telefono_ppal = telefono_ppal
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Persona: {}'.format(self.apellido, self.nombre)
def name_completo(self):
return self.apellido + " " + self.nombre
def get_email(self):
return self.email
def get_tel_principal(self):
return self.telefono_ppal
def get_tel_secundario(self):
return self.telefono_sec