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