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 EstadoPedido(db.Model):
"""
Este modelo representará los estados de pedidos.
Contará con los siquientes campos:
estado_pedido_id --> clave primaria
descripcion --> describe el estado del pedido
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'estado_pedido'
# Atributos
estado_pedido_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False, unique=True)
pedidos = db.relationship('Pedido',
uselist=False,
backref='pedido',
lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion):
"""
Constructor de la clase Estado_pedido
"""
self.descripcion = descripcion
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Estado de Pedido: {}'.format(self.descripcion)
class TipoProducto(db.Model):
"""
Este modelo representará el tipo de Producto
Contará con los siquientes campos:
tipo_producto_id --> clave primaria
descripcion --> describe el tipo de producto
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'tipo_producto'
# Atributos
tipo_producto_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())
productos = db.relationship('Producto', backref='tipo_producto', lazy=True)
def __init__(self, descripcion):
"""
Constructor de la clase tipo_producto
"""
self.descripcion = descripcion
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Tipo de Producto: {}'.format(self.descripcion)
class TipoMovimientoStock(db.Model):
"""
Este modelo representará el movimiento del stock.
Contará con los siquientes campos:
movimiento_stock_id --> clave primaria
descripcion --> describe el tipo de dni
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'tipo_movimiento_stock'
# Atributos
tipo_movimiento_stock_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
detalle_stock = db.relationship('DetalleStock', backref='detalles_stocks', lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion):
"""
Constructor de la clase movimiento_stock
"""
self.descripcion = descripcion
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'movimiento de stock: {}'.format(self.descripcion)
class Permiso(db.Model):
"""
Este modelo representará a los permisos
Contará con los siquientes campos:
permisos_id --> clave primaria
nombre --> nombre del permiso
descripcion --> descipcion
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'permiso'
# Atributos
permiso_id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), nullable=False, unique=True)
descripcion = db.Column(db.String(80), nullable=False)
rol_permiso = db.relationship('Rol', secondary=rol_permiso)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, nombre, descripcion):
"""
Constructor de la clase permiso
"""
self.descripcion = descripcion
self.nombre = nombre
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Permiso: {}'.format(self.nombre, self.descripcion)
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 ListaPrecio(db.Model):
"""
Este modelo representará el lista de precios
Contará con los siquientes campos:
lista_precio_id --> clave primaria
descripcion --> describe lista de precios
fecha --> describe la fecha en que se realizado la carga
ts_created --> momento en que el registro fue creado
"""
# Nombre de la tabla
__tablename__ = 'lista_precio'
# Atributos
lista_precio_id = db.Column(db.Integer, primary_key=True)
descripcion = db.Column(db.String(80), nullable=False)
precios = db.relationship('Precio', backref='precio', lazy=True)
ts_created = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, descripcion, fecha):
"""
Constructor de la clase lista de precios
"""
self.descripcion = descripcion
self.fecha = fecha
def __repr__(self):
"""
Nos devolverá una representación del Modelo
"""
return 'Lista de precios: {}'.format(self.descripcion, self.fecha)
class TipoMovimientoCtaCorriente(db.Model):
__tablename__ = 'tipo_movimiento_cta_corriente'
tipo_movimiento_cta_corriente_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())
movimientos = db.relationship('MovimientoCtaCorriente', backref='movimiento_cta_corriente', lazy=True)
def __init__(self, descripcion):
self.descripcion = descripcion
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 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
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