def get_by_id(cls, id, noClose=False):
"""
Busca un tipo de dodcumento en la BD segun su id.
"""
try:
cls.abrir_conexion()
sql = ("SELECT tiposDocumento.idTipoDoc, \
tiposDocumento.nombre, \
tiposDocumento.estado \
from tiposDocumento where tiposDocumento.idTipoDoc = {}"
).format(id)
cls.cursor.execute(sql)
tipoDoc = cls.cursor.fetchall()[0]
if len(tipoDoc) > 0:
return TipoDocumento(tipoDoc[0], tipoDoc[1], tipoDoc[2])
else:
raise custom_exceptions.ErrorDeConexion(
origen="data_tipo_documento.get_by_id()",
msj_adicional="Tipo de documento inexistente")
except custom_exceptions.ErrorDeConexion as e:
raise e
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_tipo_documento.get_by_id()",
msj=str(e),
msj_adicional="Error buscando tipo de documento en la BD.")
def get_all(cls, noClose=False):
"""
Busca todos los tipos de dodcumento en la BD.
"""
try:
cls.abrir_conexion()
sql = ("SELECT tiposDocumento.idTipoDoc, \
tiposDocumento.nombre, \
tiposDocumento.estado \
from tiposDocumento")
cls.cursor.execute(sql)
tipoDocs_ = cls.cursor.fetchall()
tipoDocs = []
if len(tipoDocs_) > 0:
for td in tipoDocs_:
tipoDocs.append(TipoDocumento(td[0], td[1], td[2]))
return tipoDocs
else:
raise custom_exceptions.ErrorDeConexion(
origen="data_tipo_documento.get_all()",
msj_adicional="No hay Tipos de Documento cargados en la BD."
)
except custom_exceptions.ErrorDeConexion as e:
raise e
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_tipo_documento.get_all()",
msj=str(e),
msj_adicional=
"Error buscando todos los tipos de documento en la BD.")
def get_by_id(cls, id, noClose=False):
"""Obtiene un material de la BD en base a un ID.
"""
try:
cls.abrir_conexion()
sql = ("SELECT idMaterial, \
nombre, \
unidadMedida, \
costoRecoleccion, \
stock, \
color, \
estado, \
descripcion \
FROM materiales WHERE idMaterial = {};").format(id)
cls.cursor.execute(sql)
m = cls.cursor.fetchone()
if m == None:
return False
else:
material = Material(m[0], m[1], m[2], m[3], m[4], m[5], m[6],
m[7])
return material
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_material.get_by_id()",
msj=str(e),
msj_adicional=
"Error obteniendo un material en base al id recibido como parámetro."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def add(cls, id, fecha, cant, kind):
"""
Da de alta una nueva producción en el sistema.
"""
try:
cls.abrir_conexion()
sql = ""
if kind == "art":
sql = (
"INSERT INTO prodTipArt (idTipoArticulo, fecha, cantidad,estado) \
VALUES ({},\"{}\",{},'disponible');".format(
id, fecha, cant))
elif kind == "ins":
sql = (
"INSERT INTO prodInsumos (idInsumo, fecha, cantidad,estado) \
VALUES ({},\"{}\",{},'disponible');".format(
id, fecha, cant))
cls.cursor.execute(sql)
cls.db.commit()
return cls.cursor.lastrowid
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_produccion.add()",
msj=str(e),
msj_adicional="Error dando de alta una produccion en la BD.")
finally:
cls.cerrar_conexion()
def get_by_id(cls, id):
"""
Obtiene un Punto de Depósito de la BD segun su ID.
"""
try:
cls.abrir_conexion()
sql = (
"select * from puntosDeposito where estadoEliminacion = 'disponible' AND idPunto={} order by nombre ASC"
).format(id)
cls.cursor.execute(sql)
punto = cls.cursor.fetchall()[0]
#Se instancia sin los horarios ya que no se muestran, para no generar tráfico de datos innecesario.
direccion = DatosDireccion.get_one_id(punto[4])
materiales_ = DatosMaterial.get_all_byIdPuntoDep(punto[0], True)
materiales = []
for mat in materiales_:
materiales.append(mat.id)
pd = PuntoDeposito(punto[0], direccion, punto[1], punto[2],
materiales, None)
return pd
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.get_by_id()",
msj=str(e),
msj_adicional=
"Error obteniendo un Punto de Depósito desde la BD.")
finally:
cls.cerrar_conexion()
def baja_materialPD(cls, materiales, idPunto, noClose=False):
"""
Hace un borrado lógico de los materiales aceptados por un Punto de Depósito a la BD.
"""
try:
cls.abrir_conexion()
if len(materiales) > 0:
for material in materiales:
print(str(material))
sql = (
"UPDATE puntosDep_mat SET estado = %s where idPunto = %s and idMaterial = %s"
)
values = ("eliminado", idPunto, str(material))
cls.cursor.execute(sql, values)
cls.db.commit()
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.baja_materialPD()",
msj=str(e),
msj_adicional=
"Error eliminando los materiales aceptados por un Punto de Depósito a la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def alta_pd(cls, puntoDep, idDireccion, noClose=False):
"""
Añade un Punto de Depósito a la BD.
"""
try:
cls.abrir_conexion()
#Obtengo el ID que se le va a asignar para poder guardarlo en el Horario.
sql = (
"SELECT `AUTO_INCREMENT` FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'puntosDeposito'"
)
cls.cursor.execute(sql)
id_asignado = cls.cursor.fetchone()[0]
#Hago el alta del PD en la BD.
sql = (
"INSERT into puntosDeposito (estado,nombre,estadoEliminacion,idDireccion) values (%s, %s, %s, %s)"
)
values = (puntoDep.estado, puntoDep.nombre, 'disponible',
idDireccion)
cls.cursor.execute(sql, values)
cls.db.commit()
return id_asignado
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.alta_pd()",
msj=str(e),
msj_adicional="Error añadiendo un Punto de Depósito a la BD.")
finally:
if not (noClose):
cls.cerrar_conexion()
def get_from_TAid(cls, id, noClose=False):
"""
Obtiene los insumos que componen un tipo articulo de la BD
"""
try:
cls.abrir_conexion()
sql = ("SELECT tiposArt_ins.cantidad,tiposArt_ins.idInsumo \
FROM tiposArt_ins \
INNER JOIN tiposArticulo \
USING(idTipoArticulo) \
WHERE idTipoArticulo = {};").format(id)
cls.cursor.execute(sql)
cantins_ = cls.cursor.fetchall()
cantins = []
for i in cantins_:
cantIns = CantInsumo(i[0], i[1])
cantins.append(cantIns)
return cantins
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_cant_insumo.get_from_TAid()",
msj=str(e),
msj_adicional="Error obtieniendo los insumos desde la BD.")
finally:
if not (noClose):
cls.cerrar_conexion()
def get_all_documentos(cls, uid):
"""
Obtiene todos los documentos registrados distintos al del usuario.
"""
try:
cls.abrir_conexion()
if uid != False:
sql = (
"select nroDoc from usuarios where idUsuario != {} and estado = \"habilitado\""
).format(uid)
else:
sql = ("select nroDoc from usuarios where nroDoc is not NULL")
cls.cursor.execute(sql)
docs_ = cls.cursor.fetchall()
docs = []
for doc in docs_:
docs.append(doc[0])
return docs
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_usuario.get_all_documentos()",
msj=str(e),
msj_adicional=
"Error obteniendo todos los documentos registrados distintos al del usuario de la BD."
)
finally:
cls.cerrar_conexion()
def verificar_codigo(cls, cod, uid):
"""
Verifica que el codigo corresponda a un deposito y le asigna el deposito al usuario correspondiente
Devuelve la cantidad de EPS acreditados
"""
try:
cls.abrir_conexion()
sql = (
"UPDATE depositos SET idUsuario = {}, fechaReg=\"{}\", estado = \"acreditado\" WHERE codigo=\"{}\""
.format(uid, datetime.now(), cod))
cls.cursor.execute(sql)
cls.db.commit()
rwcount = int(cls.cursor.rowcount)
if rwcount > 0:
sql = (
"SELECT cantidad FROM depositos join ecoPuntos using (idEcoPuntos) where codigo = %s"
)
values = (cod, )
cls.cursor.execute(sql, values)
cantEP = cls.cursor.fetchall()[0][0]
return cantEP
else:
dep = cls.get_by_codigo(cod)
if dep == False:
return 0
else:
return -1
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_pedido.verificar_codigo()",
msj=str(e),
msj_adicional=
"Error verificando un código de depósito en la BD.")
finally:
cls.cerrar_conexion()
def get_from_TAid(cls, id, noClose=False):
"""
Obtiene el valor de un tipo articulo de la BD
"""
try:
cls.abrir_conexion()
sql = ("SELECT idValor, fecha, valor \
FROM valoresTipArt \
WHERE idTipoArticulo = {};").format(id)
cls.cursor.execute(sql)
valores = cls.cursor.fetchall()
max_date = valores[0]
for v in valores:
if v[1] > max_date[1]:
max_date = v
return max_date
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_valor.get_from_TAid()",
msj=str(e),
msj_adicional="Error obtieniendo lso valores desde la BD.")
finally:
if not (noClose):
cls.cerrar_conexion()
def get_salidas_by_entidad(cls, id, noClose=False):
try:
cls.abrir_conexion()
sql = ("SELECT idSalida, \
idTipoArticulo, \
fecha, \
cantidadSalida, \
valorTotal, \
concepto \
FROM salidasStock WHERE idEntidad = {};".format(id))
cls.cursor.execute(sql)
salidas = cls.cursor.fetchall()
salidasStock = []
for s in salidas:
articulos = CantArticulo(s[3], s[1])
salida = SalidaStock(s[0], articulos, s[2], s[4], s[5])
salidasStock.append(salida)
return salidasStock
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.get_salidas()",
msj=str(e),
msj_adicional="Error obtieniendo las \
salidas de stock desde la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def get_all(cls, noClose=False):
"""Obtiene todas las salidas de la BD.
"""
try:
cls.abrir_conexion()
sql = ("SELECT idSalida, \
idTipoArticulo, \
idEntidad, \
fecha, \
cantidadSalida, \
valorTotal, \
concepto \
from salidasStock")
cls.cursor.execute(sql)
salidasStock = []
salidasStock_ = cls.cursor.fetchall()
if len(salidasStock_) > 0:
for salida in salidasStock_:
cant_art = CantArticulo(
salida[4], salida[1],
float(salida[5]) / float(salida[4]))
salidasStock.append(
SalidaStock(salida[0], cant_art,
salida[3].strftime("%d/%m/%Y"),
float(salida[4]), salida[6]))
return salidasStock
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_salida_stock_get_all()",
msj=str(e),
msj_adicional="Error obteniendo todas las salidas de la BD.")
def get_all(cls, noClose=False):
"""Obtiene todas las entradas externas de la BD.
"""
try:
cls.abrir_conexion()
sql = ("SELECT idEntradaMat, \
idMaterial, \
cant, \
fecha, \
concepto \
FROM entradasMat")
cls.cursor.execute(sql)
entradas_ = cls.cursor.fetchall()
entradas = []
for ent in entradas_:
cantMat = CantMaterial(float(ent[2]), ent[1])
entradas.append(
EntradaStock(ent[0], cantMat, ent[3].strftime("%d/%m/%Y"),
ent[4]))
return entradas
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_entrada_externa.get_all()",
msj=str(e),
msj_adicional=
"Error obteniendo todas las entradas externas de la BD.")
def verificacion(cls, code):
"""
Realiza la verificación del codigo del usuario.
"""
try:
cls.abrir_conexion()
#Verifico si existe un usuario con este codigo
sql = (
"SELECT idUsuario,email,password,estado from usuarios where codigo_registro = %s"
)
values = (code, )
cls.cursor.execute(sql, values)
user = cls.cursor.fetchone()
print(user)
if len(user) > 0 and user[3] == "no-verificado":
#Una vez verificado, actualizo su estado
sql = ("UPDATE usuarios set estado = %s where idUsuario = %s")
values = ("no-activo", user[0])
cls.cursor.execute(sql, values)
cls.db.commit()
return {"email": user[1], "password": user[2]}
else:
#Si no existe ningun usuario con ese codigo, o su estado no es "no-verificado", devuelvo False
return False
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_usuario.update_nivel()",
msj=str(e),
msj_adicional=
"Error actualizando un nivel de un usuario en la BD.")
finally:
cls.cerrar_conexion()
def get_by_codigo(cls, cod, noClose=False):
"""
Obtiene los depósitos correspondientes a un código.
"""
try:
cls.abrir_conexion()
sql = (
"Select idDeposito, codigo, fechaReg, fechaDep, idMaterial, idUsuario, idPunto, idEcoPuntos, cant, estado from depositos where codigo = %s"
)
values = (cod, )
cls.cursor.execute(sql, values)
dep = cls.cursor.fetchone()
if dep == None:
return False
else:
mat = CantMaterial(dep[8], dep[4])
ep = DatosEcoPuntos.get_by_id(dep[7])
ep.cantidad = int(ep.cantidad)
try:
fecha_reg = dep[2].strftime("%d/%m/%Y")
except:
fecha_reg = None
return Deposito(dep[0], dep[1], mat, dep[6],
dep[3].strftime("%d/%m/%Y"), ep, fecha_reg,
dep[9])
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_pedido.get_by_codigo()",
msj=str(e),
msj_adicional=
"Obtiene los depósitos correspondientes a un código.")
finally:
if not (noClose):
cls.cerrar_conexion()
def get_all_emails(cls, uid=None):
"""
Obtiene todos los emails registrados distintos al del usuario.
"""
try:
cls.abrir_conexion()
if uid == None:
sql = ("select email from usuarios")
else:
sql = ("select email from usuarios where idUsuario != {}"
).format(uid)
cls.cursor.execute(sql)
emails_ = cls.cursor.fetchall()
emails = []
for email in emails_:
emails.append(email[0])
return emails
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_usuario.get_all_emails()",
msj=str(e),
msj_adicional=
"Error obteniendo todos los emails registrados distintos al del usuario de la BD."
)
finally:
cls.cerrar_conexion()
def get_by_id(cls, id):
"""
Obtiene el depósito correspondiente a un ID.
"""
try:
cls.abrir_conexion()
sql = (
"Select idDeposito, codigo, fechaReg, fechaDep, idMaterial, idUsuario, idPunto, idEcoPuntos, cant, estado from depositos where idDeposito = {}"
).format(id)
cls.cursor.execute(sql, )
dep = cls.cursor.fetchone()
if dep == None:
return False
else:
mat = CantMaterial(dep[8], dep[4])
ep = DatosEcoPuntos.get_by_id(dep[7])
ep.cantidad = int(ep.cantidad)
try:
fecha_reg = dep[2].strftime("%d/%m/%Y")
except:
fecha_reg = None
return Deposito(dep[0], dep[1], mat, dep[6],
dep[3].strftime("%d/%m/%Y"), ep, fecha_reg,
dep[9])
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_deposito.get_by_id()",
msj=str(e),
msj_adicional=
"Error obteniendo el depósito correspondiente a un ID.")
finally:
cls.cerrar_conexion()
def update_nombre_apellido_tu(cls, nombre, apellido, tu, uid):
"""
Actualiza el nombre, el apellido y el tipo de usuario de un usuario en la BD.
"""
try:
cls.abrir_conexion()
sql = (
"UPDATE usuarios set nombre = %s, apellido = %s, idTipoUsuario = %s where idUsuario = %s"
)
values = (nombre, apellido, tu, uid)
cls.cursor.execute(sql, values)
cls.db.commit()
return True
except custom_exceptions.ErrorDeConexion as e:
raise e
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_usuario.update_nombre_apellido_tu()",
msj=str(e),
msj_adicional=
"Error actualizando el nombre, el apellido y el tipo de usuario de un usuario en la BD.."
)
finally:
cls.cerrar_conexion()
def add_one(cls,
idArt,
cant,
concepto,
fecha,
costoTotal,
costoObtAlt,
noClose=False):
"""Registra una salida de stock al municipio en la BD en base a los parámetros recibidos.
"""
try:
cls.abrir_conexion()
sql = (
"INSERT into salidasMun (idTipoArticulo, cantSalida, fecha, concepto,costo,costoObtencionAlt) values (%s,%s,%s,%s,%s,%s)"
)
values = (idArt, cant, fecha, concepto, costoTotal, costoObtAlt)
cls.cursor.execute(sql, values)
cls.db.commit()
return True
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_salidas_mun.add_one()",
msj=str(e),
msj_adicional=
"Error registrando una salida de stock al municipio en la BD.")
def get_all_names(cls, noClose=False):
"""
Obtiene todos los nombres de los Puntos de Depósito de la BD.
"""
try:
cls.abrir_conexion()
sql = (
"select nombre from puntosDeposito where estadoEliminacion = 'disponible'"
)
cls.cursor.execute(sql)
puntosDeposito = cls.cursor.fetchall()
puntosDeposito_ = []
for punto in puntosDeposito:
puntosDeposito_.append(punto[0])
return puntosDeposito_
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.get_all_names()",
msj=str(e),
msj_adicional=
"Error obtieniendo todos los nombres de los Puntos de Depósito de la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def get_all(cls, noClose=False):
"""Obtiene todas las salidas de la municipalidad de la BD.
"""
try:
cls.abrir_conexion()
sql = ("SELECT idSalidaMun, \
idTipoArticulo, \
cantSalida, \
fecha \
from salidasMun")
cls.cursor.execute(sql)
salidasMun = []
salidasMun_ = cls.cursor.fetchall()
if len(salidasMun_) > 0:
for salida in salidasMun_:
cant_articulo = CantArticulo(salida[2], salida[1])
salidasMun.append(
SalidaStockMunicipalidad(
salida[0], cant_articulo,
salida[3].strftime("%d/%m/%Y")))
return salidasMun
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_material.get_by_id()",
msj=str(e),
msj_adicional=
"Error obteniendo todas las salidas de la municipalidad de la BD."
)
def alta_materialPD(cls, materiales, idPunto, noClose=False):
"""
Añade un los materiales aceptados por un Punto de Depósito a la BD.
"""
try:
cls.abrir_conexion()
if len(materiales) > 0:
for material in materiales:
print(str(material))
sql = (
"INSERT into puntosDep_mat (idMaterial, idPunto, estado) values (%s,%s,%s)"
)
values = (str(material), idPunto, "disponible")
cls.cursor.execute(sql, values)
cls.db.commit()
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.alta_materialPD()",
msj=str(e),
msj_adicional=
"Error añadiendo los materiales aceptados por un Punto de Depósito a la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def get_from_Pid(cls, id, noClose=False):
"""
Obtiene los articulos de un pedido de la BD
"""
try:
cls.abrir_conexion()
sql = ("SELECT \
cantidad, \
idTipoArticulo \
FROM tiposArt_pedidos \
WHERE idPedido = {};").format(id)
cls.cursor.execute(sql)
cantarts_ = cls.cursor.fetchall()
cantarts = []
for a in cantarts_:
#TODO: agregar precio venta
cantart = CantArticulo(a[0],a[1])
cantarts.append(cantart)
return cantarts
except Exception as e:
raise custom_exceptions.ErrorDeConexion(origen="data_cant_articulo.get_from_Pid()",
msj=str(e),
msj_adicional="Error obtieniendo los articulos de un pedido desde la BD.")
finally:
if not(noClose):
cls.cerrar_conexion()
def get_all_sin_filtro(cls, noClose=False):
"""
Obtiene todos los Puntos de Depósito de la BD.
"""
try:
cls.abrir_conexion()
sql = ("select * from puntosDeposito order by nombre ASC")
cls.cursor.execute(sql)
puntosDeposito = cls.cursor.fetchall()
puntosDeposito_ = []
for punto in puntosDeposito:
#Se instancia sin los horarios ya que no se muestran, para no generar tráfico de datos innecesario.
if punto[3] == 'eliminado':
direccion = None
else:
direccion = DatosDireccion.get_one_id(punto[4])
materiales_ = DatosMaterial.get_all_byIdPuntoDep(
punto[0], True)
materiales = []
for mat in materiales_:
materiales.append(mat.id)
puntosDeposito_.append(
PuntoDeposito(punto[0], direccion, punto[1], punto[2],
materiales, None))
return puntosDeposito_
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.get_all()",
msj=str(e),
msj_adicional="Error otodos los Puntos de Depósito desde la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
def alta_direccion(cls, direccion, noClose=False):
"""
Añade una direccion a la BD.
"""
try:
cls.abrir_conexion()
#Obtengo el ID que se le va a asignar para poder guardarlo en el Punto de Depósito.
sql = (
"SELECT `AUTO_INCREMENT` FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'direcciones'"
)
cls.cursor.execute(sql)
id_asignado = cls.cursor.fetchone()[0]
#Hago el alta.
sql = (
"INSERT into direcciones (calle, altura, ciudad, provincia, pais) values (%s, %s, %s, %s, %s)"
)
values = (direccion.calle, direccion.altura, direccion.ciudad,
direccion.provincia, direccion.pais)
cls.cursor.execute(sql, values)
cls.db.commit()
return id_asignado
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_direccion.alta_direccion()",
msj=str(e),
msj_adicional="Error añadiendo una direccion en la BD.")
finally:
if not (noClose):
cls.cerrar_conexion()
def get_all_insumos(cls):
"""
Obtiene todas las producciones de insumos de la BD.
"""
try:
cls.abrir_conexion()
sql = ("SELECT \
idProdInsumo, \
idInsumo, \
fecha, \
cantidad \
FROM prodInsumos WHERE estado != \"eliminado\" order by fecha DESC;"
)
cls.cursor.execute(sql)
prods_ = cls.cursor.fetchall()
producciones = []
for p in prods_:
ins = CantInsumo(p[3], p[1])
receta = cls.get_receta_ins(p[0])
prod = ProduccionInsumo(p[0], ins, p[2].strftime("%d/%m/%Y"),
receta)
producciones.append(prod)
return producciones
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_produccion.get_all_insumos()",
msj=str(e),
msj_adicional="Error obtieniendo las producciones desde la BD."
)
finally:
cls.cerrar_conexion()
def get_by_id(cls,id):
"""
Obtiene un punto de retiro de la BD a partir de su id.
"""
try:
cls.abrir_conexion()
sql = ("SELECT idPunto, \
estadoEliminacion, \
demoraFija, \
nombre, \
idDireccion, \
estado \
FROM puntosRetiro WHERE idPunto = {} AND estadoEliminacion != \"eliminado\";".format(id))
cls.cursor.execute(sql)
pr = cls.cursor.fetchall()[0]
direccion = DatosDireccion.get_one_id(pr[4])
horarios = DatosHorario.get_horariosPR_id(pr[0])
puntoRetiro = PuntoRetiro(pr[0],direccion,pr[3],pr[1],horarios,pr[2],bool(pr[5]))
return puntoRetiro
except Exception as e:
raise custom_exceptions.ErrorDeConexion(origen="data_punto_retiro.get_by_id()",
msj=str(e),
msj_adicional="Error obtieniendo un punto de retiro desde la BD.")
finally:
cls.cerrar_conexion()
def cant_vendidos_mes_actual(cls, aid):
"""
Obtiene la cantidad de unidades vendidas de un artículo en base a su ID.
"""
try:
cls.abrir_conexion()
d = datetime.datetime.now()
current_month = int(d.strftime("%m"))
sql = (
"select sum(cantidad) from pedidos right join tiposArt_pedidos using (idPedido) where month(fechaEnc) = %s and idTipoArticulo = %s and pedidos.estado != 'cancelado' and pedidos.estado != 'devuelto'"
)
values = (current_month, aid)
cls.cursor.execute(sql, values)
result = cls.cursor.fetchone()[0]
if result == None:
result = 0
return result
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data_articulo.cant_vendidos_mes_actual()",
msj=str(e),
msj_adicional=
"Error obteniendo la cantidad de unidades vendidas de un artículo."
)
finally:
cls.cerrar_conexion()
def alta_horario_PR(cls, horario, idPuntoRetiro, noClose=False):
"""
Añade un horario de un Punto de Retiro a la BD.
"""
try:
cls.abrir_conexion()
sql = (
"INSERT into horariosPR (idPunto, horaDesde, horaHasta, dia) values (%s,%s,%s,%s)"
)
values = (idPuntoRetiro, horario.horaDesde, horario.horaHasta,
horario.dia)
print(values)
cls.cursor.execute(sql, values)
cls.db.commit()
except Exception as e:
raise custom_exceptions.ErrorDeConexion(
origen="data.alta_horario_PR()",
msj=str(e),
msj_adicional=
"Error añadiendo un horario de un Punto de DepóRetirosito a la BD."
)
finally:
if not (noClose):
cls.cerrar_conexion()
