class estado(db.Model):
__tablename__ = 'estado'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(45), nullable=False)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return query
@classmethod
def insert(cls, dataJson):
query = (
nombre = dataJson["nombre"],
)
estado.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if "nombre" in dataJson:
query.nombre = dataJson["nombre"]
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class Producto(db.Model):
__tablename__ = 'producto'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(128), nullable=False)
id_tipo_producto = db.Column(db.Integer, nullable=False)
precio = db.Column(db.Integer, nullable=False)
id_cliente = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
descripcion = db.Column(db.String(256), nullable=False)
sku = db.Column(db.String(256), nullable=False)
id_iva = db.Column(db.Integer, nullable=False)
estado = db.Column(db.Integer, nullable=False)
barcode = db.Column(db.String(256), nullable=True)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.order_by(
Producto.id_tipo_producto.asc()).filter_by(estado=1).all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Producto(
nombre=dataJson['nombre'],
id_tipo_producto=dataJson['id_tipo_producto'],
id_cliente=dataJson['id_cliente'],
precio=dataJson['precio'],
created_at=func.NOW(),
updated_at=func.NOW(),
descripcion=dataJson['descripcion'],
sku=dataJson['sku'],
id_iva=dataJson['id_iva'],
barcode=dataJson['barcode'],
estado=dataJson['estado'],
)
Producto.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'nombre' in dataJson:
query.nombre = dataJson['nombre']
if 'id_tipo_producto' in dataJson:
query.id_tipo_producto = dataJson['id_tipo_producto']
if 'id_cliente' in dataJson:
query.id_cliente = dataJson['id_cliente']
if 'precio' in dataJson:
query.precio = dataJson['precio']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'descripcion' in dataJson:
query.descripcion = dataJson['descripcion']
if 'sku' in dataJson:
query.sku = dataJson['sku']
if 'id_iva' in dataJson:
query.id_iva = dataJson['id_iva']
if 'barcode' in dataJson:
query.barcode = dataJson['barcode']
if 'estado' in dataJson:
query.estado = dataJson['estado']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_data_cliente(cls, _id):
query = cls.query.filter_by(id_cliente=_id, estado=1).all()
return query
@classmethod
def get_data_producto(cls, _id):
query = cls.query.filter_by(id_tipo_producto=_id, estado=1).all()
return query
@classmethod
def get_data_producto_name(cls, _id):
search = "%{}%".format(_id)
query = cls.query.filter(Producto.nombre.like(search), estado=1).all()
return query
@classmethod
def get_data_sku(cls, sku):
query = cls.query.filter_by(sku=sku).first()
return Utilidades.obtener_datos(query)
@classmethod
def get_data_barcode(cls, barcode):
query = cls.query.filter_by(barcode=barcode).first()
return Utilidades.obtener_datos(query)
class Pago(db.Model):
__tablename__ = 'pago'
id = db.Column(db.Integer, primary_key=True)
monto = db.Column(db.Integer, nullable=True)
hash = db.Column(db.String(128), nullable=False)
estado = db.Column(db.Integer, nullable=True)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(hash=_id, estado=0).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Pago(
monto=dataJson['monto'],
estado=0,
hash=None,
created_at=func.NOW(),
updated_at=func.NOW(),
)
Pago.guardar(query)
if query.id:
_hash = Pago.gethash(query.id)
return _hash
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'nombre' in dataJson:
query.nombre = dataJson['nombre']
if 'hash' in dataJson:
query.hash = dataJson['hash']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'estado' in dataJson:
query.estado = dataJson['estado']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def gethash(cls, _id):
sql = "SELECT md5(" + str(_id) + ") as cod from dual"
query = db.session.execute(sql)
_hash = ''
if query:
for x in query:
json = {"hash": x.cod}
_hash = x.cod
pagou = Pago.update_data(_id, json)
if pagou:
return _hash
return False
class ProductoStock(db.Model):
__tablename__ = 'producto_stock'
id = db.Column(db.Integer, primary_key=True)
id_producto = db.Column(db.Integer, nullable=False)
id_sucursal = db.Column(db.Integer, nullable=False)
cantidad = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = ProductoStock(
id_producto=dataJson['id_producto'],
id_sucursal=dataJson['id_sucursal'],
cantidad=dataJson['cantidad'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
ProductoStock.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_producto' in dataJson:
query.id_producto = dataJson['id_producto']
if 'id_sucursal' in dataJson:
query.id_sucursal = dataJson['id_sucursal']
if 'cantidad' in dataJson:
query.cantidad = dataJson['cantidad']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
@classmethod
def prodSucursalStock(cls, id_producto, id_sucursal):
query = cls.query.filter_by(id_producto=id_producto,
id_sucursal=id_sucursal).first()
return Utilidades.obtener_datos(query)
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def filtroStock(cls, sku=None, id_sucursal=None, producto=None):
filt_sku = ''
filt_suc = ''
filt_pro = ""
if sku:
filt_sku = " AND p.sku = " + str(sku) + " "
if id_sucursal:
filt_suc = " AND ps.id_sucursal = " + str(id_sucursal)
if producto:
filt_pro = " AND p.nombre LIKE '%" + str(producto) + "%'"
sql = "SELECT \
p.sku, p.nombre, ps.cantidad, s.nombre as sucursal \
FROM producto_stock ps \
JOIN producto p ON p.id = ps.id_producto" + str(filt_sku) + " \
JOIN sucursal s ON s.id = ps.id_sucursal \
WHERE 1 = 1 " + filt_suc + filt_pro
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"nombre": x.nombre,
"sku": x.sku,
"cantidad": x.cantidad,
"sucursal": x.sucursal
}
result.append(temp)
return result
class Orden(db.Model):
__tablename__ = 'orden'
id = db.Column(db.Integer, primary_key=True)
id_persona = db.Column(db.String(128), nullable=False)
kilometros = db.Column(db.String(128), nullable=True)
id_tipo_entrega = db.Column(db.Integer, nullable=False)
id_sucursal = db.Column(db.Integer, nullable=False)
estado = db.Column(db.Integer, nullable=False)
id_creador = db.Column(db.Integer, nullable=False)
hora_recepcion = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
hora_salida = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
id_direccion = db.Column(db.Integer, nullable=True)
delivery = db.Column(db.Integer, nullable=True)
informada = db.Column(db.Integer, nullable=True)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Orden(id_persona=dataJson['id_persona'],
id_tipo_entrega=dataJson['id_tipo_entrega'],
id_sucursal=dataJson['id_sucursal'],
id_creador=dataJson['id_creador'],
id_direccion=dataJson['id_direccion'],
hora_recepcion=func.NOW(),
hora_salida=dataJson['hora_salida'],
created_at=func.NOW(),
updated_at=func.NOW(),
estado=1,
delivery=dataJson['delivery'],
kilometros=dataJson['kilometros'],
informada=0)
Orden.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_persona' in dataJson:
query.id_persona = dataJson['id_persona']
if 'id_tipo_entrega' in dataJson:
query.id_tipo_entrega = dataJson['id_tipo_entrega']
if 'id_sucursal' in dataJson:
query.id_sucursal = dataJson['id_sucursal']
if 'id_creador' in dataJson:
query.id_creador = dataJson['id_creador']
if 'id_direccion' in dataJson:
query.id_direccion = dataJson['id_direccion']
if 'hora_salida' in dataJson:
query.hora_salida = dataJson['hora_salida']
if 'hora_recepcion' in dataJson:
query.hora_recepcion = dataJson['hora_recepcion']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'delivery' in dataJson:
query.delivery = dataJson['delivery']
if 'informada' in dataJson:
query.informada = dataJson['informada']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def ordenFullInfo(cls, _id):
sql = 'SELECT \
p.id, o.kilometros,o.delivery, p.nombre, p.apellido_paterno, t.numero as telefono,c.nombre as comuna, d.direccion_escrita, td.nombre as tipo, d.numero, d.departamento \
FROM orden o \
JOIN persona p ON p.id = o.id_persona \
JOIN telefono t ON t.id_persona = p.id \
LEFT JOIN direccion d ON d.id = o.id_direccion \
LEFT JOIN comuna c ON c.id = d.id_comuna \
LEFT JOIN tipo_direccion td ON td.id = d.id_tipo_direccion where o.id = ' + str(
_id) + ' '
query = db.session.execute(sql)
res = []
if query:
apellido = ''
depto = ''
direccion = ''
for x in query:
if x.departamento is not None:
depto = x.departamento
if x.direccion_escrita is not None:
direccion = str(x.direccion_escrita + ", " + x.tipo + " " +
depto).upper()
pago = OrdenPago.get_data_orden(_id)
idtp = pago[0]["id_tipo_pago"]
tipo_pago = TipoPago.get_data(idtp)
pago[0]["tipo_pago"] = tipo_pago[0]["nombre"]
correo = Correo.get_data_by_persona(x.id)
mail = correo[0]["direccion"]
if x.apellido_paterno is not None:
apellido = x.apellido_paterno
temp = {
"nombre": x.nombre + " " + str(apellido),
"correo": mail,
"telefono": x.telefono,
"direccion": direccion,
"delivery": x.delivery,
"kilometros": x.kilometros,
"detalle": OrdenDetalle.DetalleByOrden(_id),
"pago": pago
}
res.append(temp)
return res
@classmethod
def ordenFullInfoData(cls, _sucursal, _fecha, estado):
sql = "SELECT \
CASE WHEN o.estado = 1 then 'Pendiente' WHEN o.estado = 2 then 'En Curso' WHEN o.estado = 3 then 'Despachada' WHEN o.estado = 4 then 'Entregada' END as estado, \
date_format(o.created_at, '%d-%m-%Y') as fecha, \
date_format(o.created_at, '%H:%I:%S') as hora, o.id, \
concat(p.nombre,' ', p.apellido_paterno) as nombre, te.nombre as tipo_entrega, \
concat(d.direccion_escrita, ' ', d.numero, ' ',d.departamento ) as direccion, \
t.numero, c.direccion as correo, op.id_tipo_pago, op.estado as pagado \
FROM orden o \
JOIN persona p on p.id = o.id_persona \
LEFT JOIN direccion d ON d.id = o.id_direccion \
JOIN tipo_entrega te ON te.id = o.id_tipo_entrega \
JOIN telefono t ON t.id_persona = o.id_persona \
JOIN correo c ON c.id_persona = o.id_persona \
JOIN orden_pago op ON op.id_orden = o.id \
WHERE o.id_sucursal = " + str(
_sucursal) + " and o.estado = " + str(
estado
) + " and date_format(o.created_at, '%d-%m-%Y') = '" + str(
_fecha) + "' \
ORDER BY o.id ASC"
query = db.session.execute(sql)
res = []
if query:
for x in query:
temp = {
"id": x.id,
"estado": x.estado,
"fecha": x.fecha,
"hora": x.hora,
"nombre": x.nombre,
"direccion": x.direccion,
"tipo_entrega": x.tipo_entrega,
"numero": x.numero,
"correo": x.correo,
"tipo_pago": x.id_tipo_pago,
"pagado": x.pagado,
"detalle": OrdenDetalle.DetalleByOrden(x.id)
}
res.append(temp)
return res
@classmethod
def ordenToNotify(cls):
sql = "SELECT o.id FROM orden o JOIN orden_pago op on o.id = op.id_orden and op.estado in(1,3) WHERE o.informada = 0"
query = db.session.execute(sql)
res = []
if query:
for x in query:
temp = {
"id": x.id,
}
res.append(temp)
return res
class ProductoIngrediente(db.Model):
__tablename__ = 'producto_ingrediente'
id = db.Column(db.Integer, primary_key=True)
id_producto = db.Column(db.Integer, nullable=False)
id_ingrediente = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = ProductoIngrediente(
id_producto = dataJson['id_producto'],
id_ingrediente = dataJson['id_ingrediente'],
created_at = func.NOW(),
updated_at = func.NOW(),
)
ProductoIngrediente.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_producto' in dataJson:
query.id_producto = dataJson['id_producto']
if 'id_ingrediente' in dataJson:
query.id_ingrediente = dataJson['id_ingrediente']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
# @classmethod
# def IngredienteByProducto(cls, id_producto):
# sql = "SELECT \
# i.id, \
# i.nombre, \
# ti.nombre as tipo \
# FROM producto p \
# JOIN producto_ingrediente pi ON pi.id_producto = p.id \
# JOIN ingrediente i ON i.id = pi.id_ingrediente \
# JOIN tipo_ingrediente ti ON ti.id = i.id_tipo_ingrediente \
# WHERE p.id = " + str(id_producto) + " "
# query = db.session.execute(sql)
# result = []
# if query:
# for x in query:
# temp = {
# "id": x.id,
# "nombre": x.nombre,
# "tipo" : x.tipo
# }
# result.append(temp)
# return result
@classmethod
def IngredienteByProducto(cls, id_producto):
sql = "SELECT \
i.id, i.nombre \
FROM producto_ingrediente pi \
JOIN ingrediente i ON i.id = pi.id_ingrediente and i.estado = 1 \
JOIN tipo_ingrediente ti ON ti.id = i.id_tipo_ingrediente \
WHERE pi.id_producto = "+ str(id_producto) + " group by ti.id, i.id, i.nombre, ti.nombre"
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"id": x.id,
"nombre": x.nombre,
# "tipo" : x.tipo,
# "ingrediente" : ProductoIngrediente.ingredienteByTipoAndProducto(id_producto, x.tipo)
}
result.append(temp)
return result
@classmethod
def ingredienteByTipoAndProducto(cls, id_producto, id_tipo_ingrediente):
sql = "SELECT \
i.id, i.nombre \
FROM producto_ingrediente pi \
JOIN ingrediente i ON i.id = pi.id_ingrediente \
JOIN tipo_ingrediente ti ON ti.id = i.id_tipo_ingrediente \
WHERE pi.id_producto = "+ str(id_producto) +" and ti.id = "+ str(id_tipo_ingrediente) +" group by ti.id, i.id, i.nombre, ti.nombre"
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"nombre": x.nombre,
"tipo" : x.id
}
result.append(temp)
return result
class OrdenDetalle(db.Model):
__tablename__ = 'orden_detalle'
id = db.Column(db.Integer, primary_key=True)
id_producto = db.Column(db.Integer, nullable=False)
id_orden = db.Column(db.Integer, nullable=False)
cantidad = db.Column(db.Integer, nullable=False)
detalle = db.Column(db.String(128), nullable=False)
eleccion = db.Column(db.String(128), nullable=False)
precio_unitario = db.Column(db.Integer, nullable=False)
precio_extendido = db.Column(db.Integer, nullable=False)
precio_iva = db.Column(db.Integer, nullable=False)
precio_total = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = OrdenDetalle(
id_producto=dataJson['id_producto'],
id_orden=dataJson['id_orden'],
cantidad=dataJson['cantidad'],
detalle=dataJson['detalle'],
eleccion=dataJson['eleccion'],
precio_unitario=dataJson['precio_unitario'],
precio_extendido=dataJson['precio_extendido'],
precio_iva=dataJson['precio_iva'],
precio_total=dataJson['precio_total'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
OrdenDetalle.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_producto' in dataJson:
query.id_producto = dataJson['id_producto']
if 'id_orden' in dataJson:
query.id_orden = dataJson['id_orden']
if 'cantidad' in dataJson:
query.cantidad = dataJson['cantidad']
if 'detalle' in dataJson:
query.detalle = dataJson['detalle']
if 'eleccion' in dataJson:
query.eleccion = dataJson['eleccion']
if 'precio_unitario' in dataJson:
query.precio_unitario = dataJson['precio_unitario']
if 'precio_extendido' in dataJson:
query.precio_extendido = dataJson['precio_extendido']
if 'precio_iva' in dataJson:
query.precio_iva = dataJson['precio_iva']
if 'precio_total' in dataJson:
query.precio_total = dataJson['precio_total']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def DetalleByOrden(cls, id_orden):
sql = "SELECT * FROM orden o JOIN orden_detalle od ON od.id_orden = o.id WHERE o.id = " + str(
id_orden) + " "
query = db.session.execute(sql)
result = []
if query:
for x in query:
choose = ''
detalle = ''
if x.eleccion is not None:
choose = "- (" + str(x.eleccion) + ")"
if x.detalle is not None:
detalle = "- " + str(x.detalle)
temp = {
"id": x.id,
"id_producto": x.id_producto,
"id_orden": x.id_orden,
"cantidad": x.cantidad,
"detalle": detalle,
"eleccion": choose,
"precio_unitario": x.precio_unitario,
"precio_extendido": x.precio_extendido,
"precio_iva": x.precio_iva,
"precio_total": x.precio_total,
"data_producto": Producto.get_data(x.id_producto)
}
result.append(temp)
return result
class RangoDelivery(db.Model):
__tablename__ = 'rango_delivery'
id = db.Column(db.Integer, primary_key=True)
desde = db.Column(db.String(128), nullable=False)
hasta = db.Column(db.Integer, nullable=False)
monto = db.Column(db.Integer, nullable=False)
id_cliente = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = RangoDelivery(
desde=dataJson['desde'],
hasta=dataJson['hasta'],
monto=dataJson['monto'],
id_cliente=dataJson['hasta'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
RangoDelivery.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'desde' in dataJson:
query.desde = dataJson['desde']
if 'hasta' in dataJson:
query.hasta = dataJson['hasta']
if 'monto' in dataJson:
query.monto = dataJson['monto']
if 'id_cliente' in dataJson:
query.id_cliente = dataJson['id_cliente']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class Documento(db.Model):
__tablename__ = 'documento'
id = db.Column(db.Integer, primary_key=True)
id_tipo_documento = db.Column(db.Integer, nullable=False)
id_orden = db.Column(db.Integer, nullable=False)
folio = db.Column(db.Integer, nullable=False)
fecha_emision = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
estado = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Documento(
id_tipo_documento=dataJson['id_tipo_documento'],
id_orden=dataJson['id_orden'],
folio=dataJson['folio'],
fecha_emision=dataJson['fecha_emision'],
estado=dataJson['estado'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
Documento.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_tipo_documento' in dataJson:
query.id_tipo_documento = dataJson['id_tipo_documento']
if 'id_orden' in dataJson:
query.id_orden = dataJson['id_orden']
if 'folio' in dataJson:
query.folio = dataJson['folio']
if 'fecha_emision' in dataJson:
query.fecha_emision = dataJson['fecha_emision']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class PersonaDireccion(db.Model):
__tablename__ = 'persona_direccion'
id = db.Column(db.Integer, primary_key=True)
id_persona = db.Column(db.Integer, nullable=False)
id_direccion = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = PersonaDireccion(
id_persona=dataJson['id_persona'],
id_direccion=dataJson['id_direccion'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
PersonaDireccion.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_persona' in dataJson:
query.id_persona = dataJson['id_persona']
if 'id_direccion' in dataJson:
query.id_direccion = dataJson['id_direccion']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def DireccionByPersona(cls, id_persona):
sql = "SELECT \
d.* \
FROM persona p \
JOIN persona_direccion pd ON pd.id_persona = p.id \
JOIN direccion d ON d.id = pd.id_direccion \
JOIN tipo_direccion td ON td.id = d.id_tipo_direccion \
where p.id = " + str(id_persona) + " "
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"id": x.id,
"id_comuna": x.id_comuna,
"direccion_escrita": x.direccion_escrita,
"numero": x.numero,
"departamento": x.departamento,
"id_tipo_direccion": x.id_tipo_direccion,
}
result.append(temp)
return result
@classmethod
def get_data_persona(cls, _id):
query = cls.query.filter_by(id_persona=_id).all()
return Utilidades.obtener_datos(query)
@classmethod
def dirByUser(cls, id_persona):
sql = "SELECT \
d.id AS direccion_id, d.direccion_escrita, d.numero,td.nombre as tipo, d.departamento, c.id AS comuna_id, c.nombre as comuna, p.nombre as provincia \
FROM persona_direccion pd \
JOIN direccion d ON d.id = pd.id_direccion \
LEFT JOIN comuna c ON c.id = d.id_comuna \
LEFT JOIN tipo_direccion td ON td.id = d.id_tipo_direccion \
LEFT JOIN provincia p ON p.id = c.id_provincia \
WHERE pd.id_persona =" + str(id_persona)
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"id": x.direccion_id,
"id_comuna": x.comuna_id,
"comuna": x.comuna,
"provincia": x.provincia,
"direccion_escrita": x.direccion_escrita,
"numero": x.numero,
"departamento": x.departamento,
"tipo_direccion": x.tipo,
}
result.append(temp)
return result
class UsuarioSucusrsal(db.Model):
__tablename__ = 'usuario_sucursal'
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, nullable=False)
id_sucursal = db.Column(db.Integer, nullable=False)
estado = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id_usuario=_id).all()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = UsuarioSucusrsal(
id_usuario=dataJson['id_usuario'],
id_sucursal=dataJson['id_sucursal'],
estado=dataJson['estado'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
UsuarioSucusrsal.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_usuario' in dataJson:
query.id_usuario = dataJson['id_usuario']
if 'id_sucursal' in dataJson:
query.id_sucursal = dataJson['id_sucursal']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_data_user(cls, _id):
sql = "SELECT \
s.* \
FROM usuario_sucursal us \
JOIN sucursal s ON s.id = us.id_sucursal \
WHERE us.id_usuario = " + str(_id) + " and us.estado = 1"
query = db.session.execute(sql)
response = []
if query:
for x in query:
temp = {"id": x.id, "nombre": x.nombre}
response.append(temp)
return response
class Movimiento(db.Model):
__tablename__ = 'movimiento'
id = db.Column(db.Integer, primary_key=True)
concepto = db.Column(db.String(128), nullable=False)
id_tipo_movimiento = db.Column(db.Integer, nullable=False)
monto = db.Column(db.Integer, nullable=False)
id_centro_costo = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
fecha = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Movimiento(
concepto=dataJson['concepto'],
id_tipo_movimiento=dataJson['id_tipo_movimiento'],
monto=dataJson['monto'],
id_centro_costo=dataJson['id_centro_costo'],
fecha=dataJson['fecha'],
created_at=func.NOW(),
updated_at=func.NOW(),
)
Movimiento.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'concepto' in dataJson:
query.concepto = dataJson['concepto']
if 'id_tipo_movimiento' in dataJson:
query.id_tipo_movimiento = dataJson['id_tipo_movimiento']
if 'monto' in dataJson:
query.monto = dataJson['monto']
if 'id_centro_costo' in dataJson:
query.id_centro_costo = dataJson['id_centro_costo']
if 'fecha' in dataJson:
query.fecha = dataJson['fecha']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_data_fecha(cls, fecha_ini, fecha_fin=None, tipo_movimiento=None):
filtro = ' '
if fecha_fin is None:
filtro += "AND m.fecha = '" + str(fecha_ini) + "' "
else:
filtro += "AND m.fecha >= '" + str(
fecha_ini) + "' AND m.fecha <= '" + str(fecha_fin) + "' "
if tipo_movimiento is not None:
filtro += "AND m.id_tipo_movimiento = " + str(tipo_movimiento)
sql = "SELECT \
m.fecha, \
if(tm.id = 1, m.monto, m.monto*-1 ) as monto_bruto, \
(m.monto * cc.comision) as comision, \
m.concepto, \
cc.descripcion \
FROM movimiento m \
JOIN tipo_movimiento tm ON tm.id = m.id_tipo_movimiento \
JOIN centro_costo cc ON cc.id = m.id_centro_costo \
WHERE 1 = 1 " + str(filtro)
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"fecha": str(x.fecha),
"monto_bruto": x.monto_bruto,
"comision": str(x.comision),
"concepto": x.concepto,
"descripcion": x.descripcion
}
result.append(temp)
return result
class Menu(db.Model):
__tablename__ = 'menu'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(90), nullable=False)
icon = db.Column(db.String(45), nullable=False)
url = db.Column(db.String(255), nullable=False)
submenu = db.Column(db.JSON)
activo = db.Column(db.Integer, server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return query
@classmethod
def insert(cls, dataJson):
query = Menu(
name=dataJson["name"],
icon=dataJson["icon"],
url=dataJson["url"],
submenu=dataJson["submenu"],
activo=dataJson["activo"],
)
AgendaAtencionBloque.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if "name" in dataJson:
query.name = dataJson["name"]
if "icon" in dataJson:
query.icon = dataJson["icon"]
if "url" in dataJson:
query.url = dataJson["url"]
if "submenu" in dataJson:
query.submenu = dataJson["submenu"]
if "activo" in dataJson:
query.activo = dataJson["activo"]
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class ClienteCuenta(db.Model):
__tablename__ = 'cliente_cuenta'
id = db.Column(db.Integer, primary_key=True)
id_tipo_cuenta = db.Column(db.Integer, nullable=False)
id_cliente = db.Column(db.Integer, nullable=False)
nombre = db.Column(db.String(128), nullable=False)
id_banco = db.Column(db.Integer, nullable=False)
identificacion = db.Column(db.String(128), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
numero = db.Column(db.String(256), nullable=False)
correo = db.Column(db.String(256), nullable=False)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = ClienteCuenta(nombre=dataJson['nombre'],
id_tipo_cuenta=dataJson['id_tipo_cuenta'],
id_cliente=dataJson['id_cliente'],
id_banco=dataJson['id_cliente'],
identificacion=dataJson['identificacion'],
created_at=func.NOW(),
updated_at=func.NOW(),
numero=dataJson['numero'],
correo=dataJson["correo"])
ClienteCuenta.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'nombre' in dataJson:
query.nombre = dataJson['nombre']
if 'id_tipo_cuenta' in dataJson:
query.id_tipo_cuenta = dataJson['id_tipo_cuenta']
if 'id_cliente' in dataJson:
query.id_cliente = dataJson['id_cliente']
if 'id_banco' in dataJson:
query.id_banco = dataJson['id_banco']
if 'identificacion' in dataJson:
query.identificacion = dataJson['identificacion']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'numero' in dataJson:
query.numero = dataJson['numero']
if 'correo' in dataJson:
query.correo = dataJson['correo']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def infoCuenta(cls, id_cliente):
sql = 'SELECT \
cc.nombre, cc.identificacion, b.nombre as banco, tc.nombre as tipo_cuenta, cc.numero, cc.correo \
FROM cliente_cuenta cc \
JOIN cliente c ON c.id = cc.id_cliente \
JOIN banco b ON b.id = cc.id_banco \
JOIN tipo_cuenta tc ON tc.id = cc.id_tipo_cuenta \
WHERE cc.id_cliente =' + str(id_cliente)
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"nombre": x.nombre,
"identificacion": x.identificacion,
"banco": x.banco,
"tipo_cuenta": x.tipo_cuenta,
"numero": x.numero,
"correo": x.correo
}
result.append(temp)
return result
class Usuario(db.Model):
__tablename__ = 'usuario'
id = db.Column(db.Integer, primary_key=True)
correo = db.Column(db.String(128), nullable=False)
telefono = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(128), nullable=False)
id_persona = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = Usuario(
correo = dataJson['correo'],
telefono = dataJson['telefono'],
password = Usuario.get_user_hash(dataJson['password']),
id_persona = dataJson['id_persona'],
created_at = func.NOW(),
updated_at = func.NOW(),
)
Usuario.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'correo' in dataJson:
query.correo = dataJson['correo']
if 'telefono' in dataJson:
query.telefono = dataJson['telefono']
if 'password' in dataJson:
query.nombre = dataJson['password']
if 'id_persona' in dataJson:
query.id_persona = dataJson['id_persona']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_user_hash(cls, password):
sql = 'select md5('+ str(password) +') as password from dual'
query = db.session.execute(sql)
if query:
for x in query:
return x.password
return None
@classmethod
def get_user_login(cls,user, password):
sql = "select * from usuario where correo = '"+ str(user) +"' or telefono ='"+ str(user) +"' and password = md5("+ str(password) +")"
query = db.session.execute(sql)
if query:
for x in query:
return Persona.personaFullInfo(x.id_persona)
return None
class Persona(db.Model):
__tablename__ = 'persona'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(128), nullable=False)
apellido_paterno = db.Column(db.String(128))
apellido_materno = db.Column(db.String(128))
genero = db.Column(db.String(1))
tipo_persona = db.Column(db.Integer, nullable=False)
identificacion = db.Column(db.String(128), nullable=True)
fecha_nacimiento = db.Column(db.Date)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
estado = db.Column(db.Integer)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
identificacion = None
if "identificacion" in dataJson:
identificacion = dataJson['identificacion']
query = Persona(nombre=dataJson['nombre'],
apellido_paterno=dataJson['apellido_paterno'],
apellido_materno=dataJson['apellido_materno'],
genero=dataJson['genero'],
tipo_persona=dataJson['tipo_persona'],
identificacion=identificacion,
fecha_nacimiento=dataJson['fecha_nacimiento'],
created_at=func.NOW(),
updated_at=func.NOW(),
estado=dataJson['estado'])
Persona.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'nombre' in dataJson:
query.nombre = dataJson['nombre']
if 'apellido_paterno' in dataJson:
query.apellido_paterno = dataJson['apellido_paterno']
if 'apellido_materno' in dataJson:
query.apellido_materno = dataJson['apellido_materno']
if 'genero' in dataJson:
query.genero = dataJson['genero']
if 'tipo_persona' in dataJson:
query.tipo_persona = dataJson['tipo_persona']
if 'identificacion' in dataJson:
query.identificacion = dataJson['identificacion']
if 'fecha_nacimiento' in dataJson:
query.fecha_nacimiento = dataJson['fecha_nacimiento']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'estado' in dataJson:
query.estado = dataJson['estado']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def personaFullInfo(cls,
_id=None,
correo=None,
telefono=None,
identificacion=None):
filtro = ''
if _id is not None:
filtro = str(filtro) + ' AND p.id = ' + str(_id)
if correo is not None:
filtro = str(filtro) + ' AND c.direccion = ' + str(correo)
if telefono is not None:
filtro = str(filtro) + ' AND f.numero = ' + str(telefono)
if identificacion is not None:
filtro = str(filtro) + " AND p.identificacion = '" + str(
identificacion) + "' "
sql = 'SELECT \
cl.nombre as razon, cl.giro, p.identificacion, p.id, p.nombre, p.apellido_paterno, f.numero, c.direccion, u.correo, u.telefono, u.id as user_id \
FROM persona p \
JOIN telefono f ON f.id_persona = p.id \
JOIN correo c ON c.id_persona = p.id \
LEFT JOIN usuario u ON u.id_persona = p.id \
LEFT JOIN cliente cl ON cl.id_persona = p.id \
WHERE 1 = 1 ' + str(filtro) + ' '
query = db.session.execute(sql)
res = []
if query:
for x in query:
temp = {
"identificacion": x.identificacion,
"giro": x.giro,
"razon": x.razon,
"id": x.id,
"nombre": x.nombre,
"apellido_paterno": x.apellido_paterno,
"telefono": x.numero,
"correo": x.correo,
"id_usuario": x.user_id,
"direcciones": PersonaDireccion.dirByUser(x.id),
"sucursales": UsuarioSucusrsal.get_data_user(x.user_id)
}
res.append(temp)
return res
class OrdenPago(db.Model):
__tablename__ = 'orden_pago'
id = db.Column(db.Integer, primary_key=True)
id_tipo_pago = db.Column(db.Integer, nullable=False)
id_orden = db.Column(db.Integer, nullable=False)
monto = db.Column(db.Integer, nullable=False)
voucher = db.Column(db.String(128), nullable=False)
comprobante = db.Column(db.LargeBinary)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
vuelto = db.Column(db.Integer, nullable=False)
estado = db.Column(db.Integer, nullable=False)
url_redirect = db.Column(db.String(128), nullable=True)
tb_token = db.Column(db.String(128), nullable=True)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def get_data_orden(cls, _id):
query = cls.query.filter_by(id_orden=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = OrdenPago(
id_tipo_pago=dataJson['id_tipo_pago'],
id_orden=dataJson['id_orden'],
monto=dataJson['monto'],
voucher=dataJson['voucher'],
comprobante=dataJson['comprobante'],
created_at=func.NOW(),
updated_at=func.NOW(),
vuelto=dataJson['vuelto'],
estado=dataJson['estado'],
url_redirect=None,
tb_token=None,
)
OrdenPago.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'id_tipo_pago' in dataJson:
query.id_tipo_pago = dataJson['id_tipo_pago']
if 'id_orden' in dataJson:
query.id_orden = dataJson['id_orden']
if 'monto' in dataJson:
query.monto = dataJson['monto']
if 'voucher' in dataJson:
query.vouvher = dataJson['voucher']
if 'comprobante' in dataJson:
query.comprobante = dataJson['comprobante']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'vuelto' in dataJson:
query.vuelto = dataJson['vuelto']
if 'url_redirect' in dataJson:
query.url_redirect = dataJson['url_redirect']
if 'tb_token' in dataJson:
query.tb_token = dataJson['tb_token']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
@classmethod
def update_data_by_orden(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id_orden=_id).first()
if query:
if 'id_tipo_pago' in dataJson:
query.id_tipo_pago = dataJson['id_tipo_pago']
if 'id_orden' in dataJson:
query.id_orden = dataJson['id_orden']
if 'monto' in dataJson:
query.monto = dataJson['monto']
if 'voucher' in dataJson:
query.vouvher = dataJson['voucher']
if 'comprobante' in dataJson:
query.comprobante = dataJson['comprobante']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'estado' in dataJson:
query.estado = dataJson['estado']
if 'vuelto' in dataJson:
query.vuelto = dataJson['vuelto']
if 'url_redirect' in dataJson:
query.url_redirect = dataJson['url_redirect']
if 'tb_token' in dataJson:
query.tb_token = dataJson['tb_token']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def RepartidorByOrden(cls, id_orden):
sql = "SELECT \
or1.*, r.* \
FROM orden o \
JOIN orden_repartidor or1 ON or1.id_orden = o.id \
JOIN repartidor r ON r.id = or1.id_tipo_pago \
WHERE o.id = " + str(id_orden) + " "
query = db.session.execute(sql)
result = []
if query:
for x in query:
temp = {
"id": x.id,
"id_tipo_pago": x.id_tipo_pago,
"id_orden": x.id_orden,
"data_repartidor": Persona.get_data(x.id_persona)
}
result.append(temp)
return result
@classmethod
def update_data_pago(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id_orden=_id).first()
if query:
if 'estado' in dataJson:
query.estado = dataJson['estado']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
class TipoCuenta(db.Model):
__tablename__ = 'tipo_cuenta'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(90), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
query = TipoCuenta(nombre=dataJson["nombre"],
created_at=func.NOW(),
updated_at=func.NOW())
TipoCuenta.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if "nombre" in dataJson:
query.nombre = dataJson["nombre"]
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: ' + str(
exc_obj) + ' File: ' + fname + ' linea: ' + str(
exc_tb.tb_lineno)
return {'mensaje': str(msj)}, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class paciente(db.Model):
__tablename__ = 'paciente'
id = db.Column(db.Integer, primary_key=True)
identificacion = db.Column(db.String(20), nullable=False)
nombre = db.Column(db.String(45), nullable=False)
apellido = db.Column(db.String(45), nullable=False)
fecNacimiento = db.Column(db.DateTime, nullable=False)
idHistoriaClinica = db.Column(db.Integer, nullable=False)
sexo = db.Column(db.String(1), nullable=False)
direccion = db.Column(db.String(45), nullable=False)
telefono = db.Column(db.String(45), nullable=False)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return query
@classmethod
def insert(cls, dataJson):
query = (
identificacion = dataJson["identificacion"],
nombre = dataJson["nombre"],
apellido = dataJson["apellido"],
fecNacimiento = dataJson["fecNacimiento"],
idHistoriaClinica = dataJson["idHistoriaClinica"],
sexo = dataJson["sexo"],
direccion = dataJson["direccion"],
telefono = dataJson["telefono"],
)
paciente.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if "identificacion" in dataJson:
query.identificacion = dataJson["identificacion"]
if "nombre" in dataJson:
query.nombre = dataJson["nombre"]
if "apellido" in dataJson:
query.apellido = dataJson["apellido"]
if "fecNacimiento" in dataJson:
query.fecNacimiento = dataJson["fecNacimiento"]
if "idHistoriaClinica" in dataJson:
query.idHistoriaClinica = dataJson["idHistoriaClinica"]
if "sexo" in dataJson:
query.sexo = dataJson["sexo"]
if "direccion" in dataJson:
query.direccion = dataJson["direccion"]
if "telefono" in dataJson:
query.telefono = dataJson["telefono"]
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
@classmethod
def Listar_Pacientes_Mayor_Riesgo(cls)
class pjoven(db.Model):
__tablename__ = 'pjoven'
id = db.Column(db.Integer, primary_key=True)
fumador = db.Column(db.Integer, nullable=False)
idHistoriaClinica = db.Column(db.Integer, nullable=False)
edadFumador = db.Column(db.Integer, nullable=False)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return query
@classmethod
def getFumadorPorHistoria(cls, _id):
query = cls.query.filter_by(idHistoriaClinica=_id).first()
return query
@classmethod
def insert(cls, dataJson):
query = (
fumador = dataJson["fumador"],
idHistoriaClinica = dataJson["idHistoriaClinica"],
edadFumador = dataJson["edadFumador"],
)
pjoven.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if "fumador" in dataJson:
query.fumador = dataJson["fumador"]
if "idHistoriaClinica" in dataJson:
query.idHistoriaClinica = dataJson["idHistoriaClinica"]
if "edadFumador" in dataJson:
query.edadFumador = dataJson["edadFumador"]
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
class Direccion(db.Model):
__tablename__ = 'direccion'
id = db.Column(db.Integer, primary_key=True)
direccion_escrita = db.Column(db.String(128), nullable=False)
numero = db.Column(db.String(128), nullable=False)
departamento = db.Column(db.String(128), nullable=False)
id_comuna = db.Column(db.Integer, nullable=False)
id_tipo_direccion = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
updated_at = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue())
id_place = db.Column(db.String(128), nullable=False)
#CRUD
@classmethod
def getAll(cls):
query = cls.query.all()
return query
@classmethod
def get_data(cls, _id):
query = cls.query.filter_by(id=_id).first()
return Utilidades.obtener_datos(query)
@classmethod
def insert(cls, dataJson):
numero = None
id_comuna = None
if "numero" in dataJson:
numero = dataJson['numero']
if "id_comuna" in dataJson:
id_comuna = dataJson['id_comuna']
query = Direccion(
direccion_escrita = dataJson['direccion_escrita'],
numero = numero,
departamento = dataJson['departamento'],
id_comuna = id_comuna,
id_tipo_direccion = dataJson['id_tipo_direccion'],
created_at = func.NOW(),
updated_at = func.NOW(),
id_place = dataJson['id_place'],
)
Direccion.guardar(query)
if query.id:
return query.id
return False
@classmethod
def update_data(cls, _id, dataJson):
try:
db.session.rollback()
query = cls.query.filter_by(id=_id).first()
if query:
if 'direccion_escrita' in dataJson:
query.direccion_escrita = dataJson['direccion_escrita']
if 'numero' in dataJson:
query.numero = dataJson['numero']
if 'departamento' in dataJson:
query.departamento = dataJson['departamento']
if 'id_comuna' in dataJson:
query.id_comuna = dataJson['id_comuna']
if 'id_tipo_direccion' in dataJson:
query.id_tipo_direccion = dataJson['id_tipo_direccion']
if 'created_at' in dataJson:
query.created_at = dataJson['created_at']
if 'id_place' in dataJson:
query.id_place = dataJson['id_place']
query.updated_at = func.NOW()
db.session.commit()
if query.id:
return query.id
return None
except Exception as e:
print("=======================E")
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
msj = 'Error: '+ str(exc_obj) + ' File: ' + fname +' linea: '+ str(exc_tb.tb_lineno)
return {'mensaje': str(msj) }, 500
def guardar(self):
db.session.add(self)
db.session.commit()
def eliminar(self):
db.session.delete(self)
db.session.commit()
@classmethod
def getPlaces(cls,_id):
sql = "SELECT \
id_place as dir \
FROM direccion d \
LEFT JOIN comuna c on c.id = d.id_comuna \
WHERE d.id = " + str(_id)
query = db.session.execute(sql)
if query:
for x in query:
return str(x.dir)
return None
@classmethod
def getMonto(cls, distance):
sql = "select * from rango_delivery WHERE "+ str(distance) +" between desde and hasta;"
query = db.session.execute(sql)
if query:
for x in query:
return str(x.monto)
return None
