class ModeloServiciosAfiliados(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloServiciosAfiliados, self).__init__() self.__esquemaServiciosAfiliados = { 'id': { 'type': 'integer', 'maxlength': 8 }, 'legajo_afiliado': { 'type': 'integer', 'maxlength': 8 }, 'fecha': { 'type': 'date' }, 'cantidad': { 'type': 'integer', 'maxlength': 20 }, 'detalle': { 'type': 'string', 'maxlength': 80 }, }
class ModeloDescuentos(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloDescuentos, self).__init__() self.__esquemaDescuentos = { 'id': { 'type': 'integer', 'maxlength': 32 }, 'mes_descuento': { 'type': 'date' }, 'proveedor_id': { 'type': 'integer', 'maxlength': 16 }, 'cuota_actual': { 'type': 'integer', 'maxlength': 2 }, 'total_cuotas': { 'type': 'integer', 'maxlength': 2 }, 'fecha_carga_actual': { 'type': 'date' }, }
class ModeloUsuario(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloUsuario, self).__init__() self.__esquemaUsuario = { 'id': { 'type': 'integer', 'maxlength': 8 }, 'apellido': { 'type': 'string', 'maxlength': 50 }, 'nombre': { 'type': 'string', 'maxlength': 50 }, 'legajo': { 'type': 'integer', 'maxlength': 8 }, 'secretaria': { 'type': 'string', 'maxlength': 50 }, }
class ModeloServicios(QtCore.QAbstractListModel): __querier = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloServicios, self).__init__() self.__esquemaServicios = { 'id': { 'type': 'integer', 'maxlength': 16 }, 'nombre': { 'type': 'string', 'maxlength': 50 }, } self.__listaServicios = [] def getId(self, nombre): resultado = self.__querier.traerElementos(campos=['id'], tabla='servicios', condiciones=[ ('nombre', '=', "'{}'".format(nombre)) ]) print(resultado) return resultado[0][0] def guardarServicio(self, servicio): self.__querier.insertarElemento('servicios', servicio) self.verListaServicios() def verListaServicios(self): self.__listaServicios = self.__querier.traerElementos( tabla='servicios', campos=['nombre', 'id'], orden=('nombre', 'ASC')) if self.__listaServicios: self.layoutChanged.emit() print(self.__listaServicios) def rowCount(self, parent): return len(self.__listaServicios) def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__listaServicios[row][ column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla
class ModeloServicios(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades = None, parent = None): super(ModeloServicios, self).__init__() self.__esquemaServicios = { 'id' : {'type' : 'integer', 'maxlength' : 16 }, 'nombre' : { 'type' : 'string', 'maxlength' : 50 }, }
class ModeloFamiliares(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades = None, parent = None): super(ModeloFamiliares, self).__init__() self.__esquemaFamiliares = { 'dni' : {'type' : 'integer', 'maxlength' : 8 }, 'relacion' : { 'type' : 'string', 'maxlength' : 40 }, 'nombre' : { 'type' : 'string', 'maxlength' : 50 }, 'apellido' : { 'type' : 'string', 'maxlength' : 50 }, 'fecha_nacimiento' : { 'type': 'date'}, 'edad' : { 'type': 'integer', 'maxlength' : 3 }, 'nivel_estudios' : { 'type': 'string', 'maxlength' : 40 } 'legajo_afiliado' : {'type' : 'integer', 'maxlength' : 8 }, }
class ModeloDebitos(QtCore.QAbstractTableModel): q = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloDebitos, self).__init__() self.__esquemaDebitos = { 'legajo_afiliado': { 'type': 'integer', 'maxlength': 8 }, 'id_banco': { 'type': 'integer', 'maxlength': 8 }, 'cbu': { 'type': 'integer', 'maxlength': 22 }, }
class ModeloProcesador(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() # La idea ahora es separar el esquema de validación de los datos y campos que se van a usar, nosotros no vamos a usar # todos los campos en la tabla, habíamos definido los que se encuentran en el archivo 'cosas para hacer.md' # | Mes | Proveedor | Importe | Cuota N° | Total Cuotas def __init__(self, propiedades=None, parent=None): super(ModeloProcesador, self).__init__() if parent: self.__parent = parent self.__propiedades = [ "Estado", "Fecha", "Legajo", "Banco", "CBU", "Importe", "CUIT", "Orden de movimiento", "Codigo de rechazo", "Motivo de rechazo", "Empresa" ] if propiedades: self.__propiedades = self.validarPropiedades(propiedades) self.__debitosBet = [ ] # Los valores de prueba los saco del archivo fuente self.__debitosDatabase = [ ] # Los valores de acá salen de la base de datos self.__debitosNoProcesados = [] self.__debitosRechazados = [] self.__debitosProcesados = [] self.__codigosDeRechazo = {} self.verListaCodigosDeRechazo() # self.setConfig(banco = "P", cuit = "30561600194", empresa = "SIND T MUN MERLO") def verListaCodigosDeRechazo(self): self.__codigosDeRechazo = self.__querier.traerElementos( campos=["codigo", "descripcion"], tabla="codigos_rechazo") codigosDeRechazo = dict( (codigo, descripcion) for codigo, descripcion in self.__codigosDeRechazo) self.__codigosDeRechazo = codigosDeRechazo self.__codigosDeRechazo[None] = "" self.__codigosDeRechazo[' '] = "" # CodigosDeRechazo ahora contiene una lista de tuplas, cada tupla es un registro de la base de datos. def verListaDebitosAProcesar(self, lista): self.__debitosBet = lista self.verListaDebitosDatabase() self.__debitosProcesados = [] self.__debitosProcesadosDB = [] self.__debitosRechazados = [] # self.procesables = [] for index, debito in enumerate(self.__debitosBet): codigo = debito[8] if codigo != " ": self.__debitosBet[index][9] = self.__codigosDeRechazo[codigo] self.obtenerDebitoProcesable(debito) # if self.procesables: print("DEBUG - Debitos a procesar: ", self.__debitosBet) print("DEBUG - Procesados: ", self.__debitosProcesados) print("DEBUG - Rechazados, para clonar: ", self.__debitosRechazados) print("DEBUG - No Procesados, para clonar: ", self.__debitosNoProcesados) # self.__debitosBet = self.procesables self.layoutChanged.emit() return True # return False def verListaDebitosDatabase(self): self.__debitosDatabase = self.__querier.traerElementos( campos=[ "id", "id_temporal", "legajo_afiliado", "cbu", "fecha_descuento", "importe_actual", "fecha_carga_inicial", "proveedor_id", "cuota_actual", "total_cuotas", "importe_total", "n_orden", "estado", "motivo" ], tabla="debitos", uniones=[("afiliados", "afiliados.legajo = debitos.legajo_afiliado")], condiciones=[("id_temporal", "IS NOT", "NULL")], orden=("id_temporal", "ASC")) print(self.__debitosDatabase) def apllicarCambios(self): self.guardarXls() for debito in self.__debitosProcesados: print("Estado a actualizar: " + debito[0]) print("Motivo a actualizar: " + debito[8]) print("DEBITO PROCESADO a actulizar: ", debito) self.__querier.actualizarElemento(tabla="debitos", elemento={ "id_temporal": None, "estado": debito[0], "motivo": debito[8] }, condiciones=[("id_temporal", "=", int(debito[7])), ("legajo_afiliado", "=", debito[2])]) for debito in self.__debitosRechazados: self.__querier.insertarElemento( tabla="debitos", elemento={ "id_temporal": None, "legajo_afiliado": debito[2], "fecha_descuento": debito[4] + relativedelta(months=1), # Nueva fecha para proximo mes "importe_actual": debito[5], "fecha_carga_inicial": debito[6], "proveedor_id": debito[7], "cuota_actual": debito[8], "total_cuotas": debito[9], "importe_total": debito[10], "n_orden": debito[11], "estado": None, "motivo": None }) self.__querier.actualizarElemento(tabla="debitos", elemento={ "id_temporal": None, "estado": "Rechazado", "motivo": debito[13] }, condiciones=[("id", "=", debito[0])]) self.verListaDebitosDatabase() self.limpiarTabla() def actualizarDebito(self, debito, condiciones): self.__querier.actualizarElemento(tabla="debitos", elemento=debito, condiciones=condiciones) def obtenerDebitoProcesable(self, debito): # Voy a comparar los elementos de self.__debitosBet con los de # self.__debitosDatabase. El segundo lo puedo traer ordenado para hacer de las búsquedas un proceso mas rápido, # el primero no hace falta ordenarlo ya que vamos a iterar sobre el registro por registro. # noProcesados = [] # ignorados = [] match = [] f_idTemporal, f_legajoAfiliado, f_cbu, f_fecha, f_importe, f_estado, f_codigo_error = 7, 2, 4, 1, 5, 0, 8 db_idTemporal, db_legajoAfiliado, db_cbu, db_fecha, db_importe, db_estado, db_motivo = 1, 2, 3, 4, 5, 12, 13 for index, possMatch in enumerate(self.__debitosDatabase): if possMatch[db_idTemporal] == int( debito[f_idTemporal] ) and possMatch[db_legajoAfiliado] == debito[f_legajoAfiliado]: match = self.__debitosDatabase[index] print("\nDEBUG - El item file contiene: ") print("Legajo de Afiliado: ", debito[f_legajoAfiliado]) print("Id Temporal: ", debito[f_idTemporal]) print("Estado: ", debito[f_estado]) print("Codigo de error: ", debito[f_codigo_error]) print("\nDEBUG - El item en db contiene: ") print("Legajo de Afiliado: ", match[db_legajoAfiliado]) print("Id Temporal", match[db_idTemporal]) print("") if debito[f_cbu] != match[db_cbu]: # CBU print("Los CBU no coinciden en ", match[db_legajoAfiliado]) print(debito[f_cbu]) print(match[db_cbu]) if debito[f_fecha] != match[db_fecha]: # Fecha print("Las fechas no coinciden en ", match[db_legajoAfiliado]) print(debito[f_fecha]) print(match[db_fecha].strftime('%d/%m/%Y')) if debito[f_importe] != match[db_importe]: # Importe print("Los importes no coinciden en ", match[db_legajoAfiliado]) print(debito[f_importe]) print(match[db_importe]) if debito[f_estado] != "Procesado" or debito[ f_codigo_error] != " ": match = list(match) match[db_estado] = debito[f_estado] match[db_motivo] = debito[f_codigo_error] self.__debitosRechazados.append(match) else: self.__debitosProcesadosDB.append(list(match)) self.__debitosProcesados.append(list(debito)) return True return False def guardarXls(self): wb = openpyxl.Workbook() ws = wb.worksheets[0] registrosProcesados = len(self.__debitosProcesados) registrosRechazados = len(self.__debitosRechazados) # registrosModificados = registrosProcesados + registrosRechazados debitosXls = self.__querier.traerElementos( tabla="debitos", campos=[ "CONCAT(afiliados.nombre, ' ', afiliados. apellido)", "importe_actual", "cuota_actual", "total_cuotas", "motivo", "proveedores.nombre", "id_temporal", "legajo_afiliado" ], uniones=[('afiliados', 'afiliados.legajo = debitos.legajo_afiliado'), ('proveedores', 'proveedores.id = debitos.proveedor_id')], condiciones=[('id_temporal', 'IS NOT', ' NULL')], # limite = registrosModificados, orden=("debitos.id", "DESC")) ws['A1'] = 'Afiliado' ws['B1'] = 'Importe' ws['C1'] = 'Cuota' ws['D1'] = 'Cantidad de cuotas' ws['E1'] = 'Rechazado' ws['F1'] = 'Empresa' print("DBG - COSAS Proc: ", self.__debitosProcesados) print("DBG - COSAS Rech: ", self.__debitosRechazados) print("DBG - registros procesados: ", registrosProcesados) db_id_temporal, db_legajo = 6, 7 fp_id_temporal, fp_legajo = 7, 2 fr_id_temporal, fr_legajo = 1, 2 index = 2 for possMatch in self.__debitosProcesados: for debito in debitosXls: print(possMatch[fp_legajo], debito[db_legajo]) print(possMatch[fp_id_temporal], debito[db_id_temporal]) if possMatch[fp_legajo] == debito[db_legajo] and int( possMatch[fp_id_temporal]) == debito[db_id_temporal]: a = 'A{}'.format(index) b = 'B{}'.format(index) c = 'C{}'.format(index) d = 'D{}'.format(index) e = 'E{}'.format(index) f = 'F{}'.format(index) ws[a] = debito[0] ws[b] = debito[1] ws[c] = debito[2] ws[d] = debito[3] ws[f] = debito[5] print(debito, index) index += 1 index = 3 for possMatch in self.__debitosRechazados: for debito in debitosXls: if int(possMatch[fr_id_temporal] ) == debito[db_id_temporal] and possMatch[ fr_legajo] == debito[db_legajo]: a = 'A{}'.format(index + registrosProcesados) b = 'B{}'.format(index + registrosProcesados) c = 'C{}'.format(index + registrosProcesados) d = 'D{}'.format(index + registrosProcesados) e = 'E{}'.format(index + registrosProcesados) f = 'F{}'.format(index + registrosProcesados) ws[a] = debito[0] ws[b] = debito[1] ws[c] = debito[2] ws[d] = debito[3] ws[e] = self.__codigosDeRechazo[possMatch[13]] ws[f] = debito[5] print(debito, index) index += 1 # ABRIR UN CUADRO DE DIALOGO INDICANDO DONDE GUARDAR self.handleSave(wb) wb.close() def handleSave(self, workbook): path = QFileDialog.getSaveFileName(None, 'Save File', '/comercios/', 'Excel(*.xlsx)') if not path[0]: return workbook.save(path[0]) def limpiarTabla(self): self.__debitosBet = [] self.layoutChanged.emit() def __setTotales(self, indexImporte): self.total_debitos = len(self.__debitosBet) self.importe_total = 0 if self.total_debitos > 0: for debito in self.__debitosBet: self.importe_total += debito[indexImporte] def __toString(self, index): for debito in self.__debitosBet: debito[index] = str(debito[index]) def validarPropiedades(self, propiedades): # ahora mi función se asegura que las propieades existan en la lista, debería encontrar si hay alguna forma mas elegante de hacer esto if propiedades: prop = [] for propiedad in propiedades: if propiedad in self.__propiedades: prop.append(propiedad) else: print("Propiedad '{}' es inválida, no se agregará".format( propiedad)) return prop # Estas son las funciones específicas de Qt para las tablas def rowCount(self, parent): return len(self.__debitosBet) def columnCount(self, parent): if self.__debitosBet: return len(self.__debitosBet[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__debitosBet[row][ column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla def setData(self, index, value, role=QtCore.Qt.EditRole): # Esta función no la estoy usando if role == QtCore.Qt.EditRole: row = index.row() column = index.column() value = self.articulos[row][column] return value def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: # Los objetos tipo diccionario no ordenan sus elementos, por eso usar dict.keys() me tira los nombres # de las columnas en cualquier orden. Acá debería usar la lista propiedades. # además de salir ordenado, se ajusta la cantidad de columnas correspondiente keys = list(self.__propiedades) return keys[section]
class ModeloDebito(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloDebito, self).__init__() self.__esquemaDebitos = { 'debitos.id': { 'type': 'integer', 'maxlength': 32 }, 'legajo_afiliado': { 'type': 'string', 'maxlength': 22 }, 'fecha_descuento': { 'type': 'date' }, 'fecha_carga_inicial': { 'type': 'date' }, 'nombre': { 'type': 'string' }, 'proveedor_id': { 'type': 'integer' }, 'cuota_actual': { 'type': 'integer' }, 'total_cuotas': { 'type': 'integer' }, 'importe_actual': { 'type': 'integer' }, 'importe_total': { 'type': 'integer' }, 'estado': { 'type': 'string' }, 'n_orden': { 'type': 'string' }, 'motivo': { 'type': 'string' } } self.__propiedades = [ 'debitos.id', 'legajo_afiliado', 'fecha_descuento', 'fecha_carga_inicial', 'nombre', 'proveedor_id', 'cuota_actual', 'total_cuotas', 'importe_actual', 'importe_total', 'n_orden', 'estado', 'motivo' ] self.__propiedades = self.validarPropiedades(propiedades) self.listaDebitos = [] def guardarDebito(self, debito): # print(debito['total_cuotas']) mes = debito['fecha_descuento'] for indexCuota in range(debito['total_cuotas'] ): # El 1 indica desde que numero arrancar debito['cuota_actual'] = indexCuota + 1 debito['fecha_descuento'] = mes + relativedelta(months=indexCuota) self.__querier.insertarElemento('debitos', debito) def actualizarDebito(self, debito): self.__querier.actualizarElemento(tabla='debitos', elemento=debito) def verTablaDebitos(self, condiciones, orden=None, fechas=None): self.__condicionesRefresco = condiciones self.__ordenRefresco = orden self.__fechasRefresco = fechas self.listaDebitos = self.__querier.traerElementos( campos=self.__propiedades, tabla='debitos', condiciones=condiciones, orden=orden, uniones=[("proveedores", "debitos.proveedor_id = proveedores.id")]) self.listaDebitos = self.__toList() for fecha in fechas: self._setDates(fecha) self.__toString(2) self.__toString(3) self.layoutChanged.emit() def refrescarTabla(self): self.verTablaDebitos(condiciones=self.__condicionesRefresco, orden=self.__ordenRefresco, fechas=self.__fechasRefresco) def borrarDebito(self, idDebito): self.__querier.borrarElemento('debitos', 'id', idDebito) def __incrementMonth(self, date): if date.month() < 12: incrementedDate = date(date.year(), date.month() + 1, date.day()) else: incrementedDate = date(date.year() + 1, 0, date.day()) print("DEBUG - Incremented Date : {}".format(incrementedDate)) return incrementedDate def __toList(self): listaDebitos = [] for index, debito in enumerate(self.listaDebitos): listaDebitos.append(list(debito)) return listaDebitos def __toString(self, index): for debito in self.listaDebitos: debito[index] = str(debito[index]) def _setDates(self, dateIndex): for debito in self.listaDebitos: debito[dateIndex] = QtCore.QDate(debito[dateIndex]) def validarPropiedades(self, propiedades): if propiedades: prop = [] for propiedad in propiedades: if propiedad in self.__propiedades: prop.append(propiedad) else: print("Propiedad '{}' es inválida, no se agregará".format( propiedad)) return prop def consultarUltimoNumeroDeOrden(self, proveedor, fecha): respuesta = self.__querier.traerElementos( tabla="debitos", campos=["n_orden"], condiciones=[('proveedor_id', '=', proveedor), ('fecha_carga_inicial', '=', "'{}'".format(fecha)), ('proveedor_id', '<>', 7)], orden=('id', 'DESC'), limite=1) if respuesta: print(respuesta) return respuesta[0][0][-2:] else: return 0 def rowCount(self, parent): return len(self.listaDebitos) def columnCount(self, parent): if self.listaDebitos: return len(self.listaDebitos[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.listaDebitos[row][column] return value def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: keys = list(self.__propiedades) return keys[section]
class ModeloLiquidador(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() # La idea ahora es separar el esquema de validación de los datos y campos que se van a usar, nosotros no vamos a usar # todos los campos en la tabla, habíamos definido los que se encuentran en el archivo 'cosas para hacer.md' # | Mes | Proveedor | Importe | Cuota N° | Total Cuotas def __init__(self, propiedades=None, parent=None): super(ModeloLiquidador, self).__init__() if parent: self.__parent = parent self.__propiedades = [ 'debitos.id', 'operacion', 'fecha_descuento', 'legajo_afiliado', 'banco', 'cbu', 'importe_actual', 'cuit', 'movimiento', 'empresa' ] if propiedades: self.__propiedades = self.validarPropiedades(propiedades) self.listaDebitos = [ ] # Los valores de prueba los saco del archivo fuente self.__afiliado = [] self.setConfig(banco="P", cuit="30561600194", empresa="SIND T MUN MERLO") def setConfig(self, banco, cuit, empresa): self.operacion = "71" self.banco = banco self.cuit = cuit self.empresa = empresa def setPrefijoOrden(self, prefijo): if self.jubilado: prefijo = "1400008" # CONSULTAR CON CLAUDIO! else: prefijo = "14" self.prefijoOrden = prefijo def setTipoAfiliado(self, tipo): if tipo == "ACTIVO": self.jubilado = False else: self.jubilado = True def restoreDebitos(self): consulta = "UPDATE debitos SET id_temporal = NULL, estado = NULL WHERE id_temporal IS NOT NULL" self.__querier.consultaManual(consulta) def verListaLiquidacionJub(self, fechasCobro, condiciones=None): self.listaDebitos = self.__querier.traerElementos( campos=[ 'debitos.id', 'legajo_afiliado', 'cbu', 'importe_actual', 'dni' ], tabla='debitos', uniones=[("afiliados", "legajo_afiliado = afiliados.legajo")], condiciones=condiciones) for index, fechaCobro in enumerate(fechasCobro): fechaCobro = fechaCobro.strftime("%d%m%Y") fechasCobro[index] = fechaCobro orden = 1 newListaDebitos = [] for index, debito in enumerate(self.listaDebitos): debito = list(debito) legajo = debito[1] cbu = debito[2] dni = debito.pop(4) if len(legajo) != 8: continue if len(cbu) != 22: continue if int(dni[-1]) == 0: fechaCobro = fechasCobro[0] elif int(dni[-1]) <= 3: fechaCobro = fechasCobro[1] elif int(dni[-1]) <= 6: fechaCobro = fechasCobro[2] elif int(dni[-1]) <= 9: fechaCobro = fechasCobro[3] debito.insert(1, self.operacion) debito.insert(2, fechaCobro) debito.insert(4, self.banco) debito.insert(7, self.cuit) debito.insert(8, orden) debito.insert(9, self.empresa) newListaDebitos.append(debito) orden += 1 self.listaDebitos = newListaDebitos self.__setTotales(6) self.__toString(2) self.__toString(6) if self.listaDebitos: self.layoutChanged.emit() return True return False def verListaLiquidacion(self, fechaCobro, condiciones=None): self.listaDebitos = self.__querier.traerElementos( campos=['debitos.id', 'legajo_afiliado', 'cbu', 'importe_actual'], tabla='debitos', uniones=[("afiliados", "legajo_afiliado = afiliados.legajo")], condiciones=condiciones) fechaCobro = fechaCobro.strftime("%d%m%Y") orden = 1 newListaDebitos = [] for index, debito in enumerate(self.listaDebitos): debito = list(debito) legajo = debito[1] cbu = debito[2] if len(cbu) != 22: continue debito.insert(1, self.operacion) debito.insert(2, fechaCobro) debito.insert(4, self.banco) debito.insert(7, self.cuit) debito.insert(8, orden) debito.insert(9, self.empresa) orden += 1 newListaDebitos.append(debito) self.listaDebitos = newListaDebitos self.__setTotales(6) self.__toString(2) self.__toString(6) if self.listaDebitos: self.layoutChanged.emit() return True return False def actualizarDebito(self, debito, condiciones): self.__querier.actualizarElemento(tabla="debitos", elemento=debito, condiciones=condiciones) def esProcesable(self): resultado = self.__querier.traerElementos(tabla='debitos', condiciones=[ ('id_temporal', 'IS NOT', 'NULL') ], limite=1) if resultado: return False return True def __setTotales(self, indexImporte): self.total_debitos = len(self.listaDebitos) self.importe_total = 0 if self.total_debitos > 0: for debito in self.listaDebitos: self.importe_total += debito[ indexImporte] + 7 # Este 7 es el gasto bancario def __toString(self, index): for debito in self.listaDebitos: debito[index] = str(debito[index]) def validarPropiedades(self, propiedades): # ahora mi función se asegura que las propieades existan en la lista, debería encontrar si hay alguna forma mas elegante de hacer esto if propiedades: prop = [] for propiedad in propiedades: if propiedad in self.__propiedades: prop.append(propiedad) else: print("Propiedad '{}' es inválida, no se agregará".format( propiedad)) return prop # Estas son las funciones específicas de Qt para las tablas def rowCount(self, parent): return len(self.listaDebitos) def columnCount(self, parent): if self.listaDebitos: return len(self.listaDebitos[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.listaDebitos[row][ column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla def setData(self, index, value, role=QtCore.Qt.EditRole): # Esta función no la estoy usando if role == QtCore.Qt.EditRole: row = index.row() column = index.column() value = self.articulos[row][column] return value def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: # Los objetos tipo diccionario no ordenan sus elementos, por eso usar dict.keys() me tira los nombres # de las columnas en cualquier orden. Acá debería usar la lista propiedades. # además de salir ordenado, se ajusta la cantidad de columnas correspondiente keys = list(self.__propiedades) return keys[section]
class ModeloServiciosAfiliados(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades = None, parent = None): super(ModeloServiciosAfiliados, self).__init__() self.__esquemaServiciosAfiliados = { 'id_servicio' : {'type' : 'integer', 'maxlength' : 8 }, 'legajo_afiliado' : {'type' : 'integer', 'maxlength' : 8 }, 'fecha' : { 'type': 'date'}, 'cantidad' : { 'type': 'integer', 'maxlength' : 20}, 'detalle' : { 'type': 'string', 'maxlength' : 80}, } self.__propiedades = ['fecha', 'nombre', 'cantidad', 'detalle' ] self.__tablaServicios = [] def asociarServicio(self, servicio): self.__querier.insertarElemento('servicios_afiliado', servicio) self.verTablaServicios(servicio['legajo_afiliado']) return True def verTablaServicios(self, legajo): if not legajo: legajo = "0" self.__tablaServicios = self.__querier.traerElementos( tabla = 'servicios_afiliado', campos = ['fecha', 'nombre', 'detalle', 'cantidad'], uniones = [('servicios', 'servicios.id = id_servicio')], condiciones = [('legajo_afiliado', '=', legajo)], orden = ("fecha", "DESC") ) self.__tablaServicios = self.__toList() self._setDates(0) if self.__tablaServicios: self.layoutChanged.emit() return True return False def _setDates(self, dateIndex): for servicio in self.__tablaServicios: servicio[dateIndex] = QtCore.QDate(servicio[dateIndex]) def __toList(self): listaServicios = [] for index, debito in enumerate(self.__tablaServicios): listaServicios.append(list(debito)) return listaServicios # Estas son las funciones específicas de Qt para las tablas def rowCount(self, parent): return len(self.__tablaServicios) def columnCount(self, parent): if self.__tablaServicios: return len(self.__tablaServicios[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__tablaServicios[row][column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: # Los objetos tipo diccionario no ordenan sus elementos, por eso usar dict.keys() me tira los nombres # de las columnas en cualquier orden. Acá debería usar la lista propiedades. # además de salir ordenado, se ajusta la cantidad de columnas correspondiente keys = list(self.__propiedades) return keys[section]
class ModeloProveedores(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloProveedores, self).__init__() self.__propiedades = [ 'id', 'nombre', 'servicios', 'calle', 'altura', 'localidad', 'telefono', 'celular', 'email', 'cuit', 'razon_social', 'cbu', 'banco', 'cuenta', 'comision', 'responsable', 'forma_pago', 'notas' ] self.__propiedades = self.validarPropiedades(propiedades) self.__proveedor = {} self.__listaProveedores = [] def verListaProveedores(self): self.__listaProveedores = self.__querier.traerElementos( campos=self.__propiedades, tabla='proveedores') if self.__listaProveedores: self.layoutChanged.emit() return True return False def verDetallesProveedor(self, proveedor=QtCore.QModelIndex()): proveedor = self.__listaProveedores[proveedor.row()] idProveedor = proveedor[0] respuesta = self.__querier.traerElementos(condiciones=[('id', '=', idProveedor)], tabla='proveedores', limite=1) proveedor = list(respuesta[0]) print(proveedor) self.__proveedor = proveedor return self.__proveedor def guardarProveedor(self, proveedor): respuesta = self.__querier.traerElementos(campos=['id'], condiciones=[ ('id', '=', proveedor['id']) ], tabla='proveedores', limite=1) print(respuesta) if respuesta: self.__querier.actualizarElemento('proveedores', proveedor, [('id', '=', proveedor['id'])]) else: self.__querier.insertarElemento('proveedores', proveedor) if not self.__v.validate(proveedor, esquemaProveedor): errors = self.__v.document_error_tree for propiedad in esquemaProveedor: try: print("Hay un error en el campo: " + errors[propiedad].errors[0].document_path[0]) except: pass return False return True def validarPropiedades(self, propiedades): if propiedades: prop = [] for propiedad in propiedades: if propiedad in self.__propiedades: prop.append(propiedad) else: print("Propiedad '{}' es inválida, no se agregará".format( propiedad)) return prop def rowCount(self, parent): return len(self.__listaProveedores) def columnCount(self, parent): if self.__listaProveedores: return len(self.__listaProveedores[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__listaProveedores[row][column] return value def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: keys = list(self.__propiedades) return keys[section]
class ModeloAfiliado(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() # La idea ahora es separar el esquema de validación de los datos y campos que se van a usar, nosotros no vamos a usar # todos los campos en la tabla, habíamos definido los que se encuentran en el archivo 'cosas para hacer.md' # | Legajo | Apellido | Nombre | DNI | Dirección | Teléfono | Ordenado alfabéticamente por apellido # Calle + Altura + Piso + Depto + (Localidad) def __init__(self, propiedades = None, parent = None): super(ModeloAfiliado, self).__init__() if parent: self.__parent = parent self.__propiedades = ['legajo','dni', 'tipo_afiliado','cuil', 'apellido','nombre', 'fecha_nacimiento', 'edad', 'estado_civil', 'nacionalidad', 'calle', 'altura', 'piso', 'depto','cod_postal', 'barrio', 'localidad', 'telefono_particular', 'telefono_laboral', 'celular','email', 'lugar_trabajo', 'jerarquia', 'fecha_ingreso', 'antiguedad', 'nivel_estudios' ] if propiedades: self.__propiedades = self.validarPropiedades(propiedades) self.__listaAfiliados = [] # Los valores de prueba los saco del archivo fuente self.__afiliado = [] # ============================================================================================= # Esta lista de listas es la que aparece en la tabla de afiliados apenas arranca # el programa # Tengo que hacer que el programa levante esta lista desde la base de datos. # En la base de datos tengo solamente un objeto que tiene todos los campos vacíos salvo el dni # El legajo hay que modificarlo porque tiene auto-incremento # Legajo : 1, dni : 37537040 es lo que tiene que aparecer cuando uso esta función def verListaAfiliados(self, condiciones = None, orden = None): # if condiciones: # condiciones.append(("activo", "=", "1")) # else: # condiciones = [("activo", "=", "1")] self.condicionesRefresco = condiciones self.ordenRefresco = orden self.__listaAfiliados = self.__querier.traerElementos( campos = self.__propiedades, tabla = 'afiliados', condiciones = condiciones, orden = orden) if self.__listaAfiliados: self.layoutChanged.emit() return True return False def refrescarLista(self): self.__listaAfiliados = self.__querier.traerElementos( campos = self.__propiedades, tabla = 'afiliados', condiciones = self.condicionesRefresco, orden = self.ordenRefresco) if self.__listaAfiliados: self.layoutChanged.emit() def verDetallesAfiliado(self, afiliado = QtCore.QModelIndex()): # Extraigo el legajo para buscarlo de esa forma en la base de datos # porque la tabla no me muestra todos los datos afiliado = self.__listaAfiliados[afiliado.row()] legajo = afiliado[0] respuesta = self.__querier.traerElementos( condiciones = [('legajo', '=', legajo)], tabla = 'afiliados', limite = 1 ) afiliado = list(respuesta[0]) print(afiliado) self.__afiliado = afiliado return self.__afiliado def guardarAfiliado(self, afiliado, legajo = None): respuesta = self.__querier.traerElementos( campos = ['legajo'], condiciones = [('legajo', '=', afiliado['legajo'])], tabla = 'afiliados', limite = 1) print (respuesta) if not (self.__v.validate(afiliado, esquemaAfiliado)): errors = self.__v.document_error_tree errores = [] # print(errors) for propiedad in esquemaAfiliado: try: print("Hay un error en el campo: " + errors[propiedad].errors[0].document_path[0]) errores.append("Hay un error en el campo: {}\n".format(errors[propiedad].errors[0].document_path[0])) except: pass return errores if respuesta and legajo: # Si este if evalua en verdadero significa que existe # un registro con este legajo, por lo que se usar actualizarElemento # en lugar de insertarElemento if respuesta[0][0] == legajo: self.__querier.actualizarElemento('afiliados', afiliado, [("legajo", "=", "'{}'".format(legajo))]) self.verListaAfiliados() else: print("Ya existe un afiliado con este legajo") return (["Ya existe un afiliado con este legajo"]) elif not respuesta and legajo: self.__querier.actualizarElemento('afiliados', afiliado, [("legajo", "=", "'{}'".format(legajo))]) self.verListaAfiliados() else: self.__querier.insertarElemento('afiliados', afiliado) self.verListaAfiliados() return None def bajaAfiliado(self, afiliado): tabla = "afiliados" self.__querier.actualizarElemento(tabla, afiliado, [("legajo", "=", afiliado['legajo'])]) self.verListaAfiliados() def validarPropiedades(self, propiedades): # ahora mi función se asegura que las propieades existan en la lista, debería encontrar si hay alguna forma mas elegante de hacer esto if propiedades: prop = [] for propiedad in propiedades: if propiedad in self.__propiedades: prop.append(propiedad) else: print("Propiedad '{}' es inválida, no se agregará".format(propiedad)) return prop # Estas son las funciones específicas de Qt para las tablas def rowCount(self, parent): return len(self.__listaAfiliados) def columnCount(self, parent): if self.__listaAfiliados: return len(self.__listaAfiliados[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__listaAfiliados[row][column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla def setData(self, index, value, role = QtCore.Qt.EditRole): # Esta función no la estoy usando if role == QtCore.Qt.EditRole: row = index.row() column = index.column() value = self.__listaAfiliados[row][column] return value def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: # Los objetos tipo diccionario no ordenan sus elementos, por eso usar dict.keys() me tira los nombres # de las columnas en cualquier orden. Acá debería usar la lista propiedades. # además de salir ordenado, se ajusta la cantidad de columnas correspondiente keys = list(self.__propiedades) return keys[section]
class ModeloFamiliares(QtCore.QAbstractTableModel): __querier = querier.Querier() __v = cerberus.Validator() def __init__(self, propiedades=None, parent=None): super(ModeloFamiliares, self).__init__() self.__propiedades = [ 'familiares.dni', 'familiares.relacion', 'familiares.nombre', 'familiares.apellido', 'familiares.fecha_nacimiento', 'familiares.edad', 'familiares.nivel_estudios' ] self.__listaFamiliares = [] def borrarFamiliar(self, idFamiliar): self.__querier.borrarElemento('familiares', 'dni', idFamiliar) def guardarFamiliar(self, familiar): self.__querier.insertarElemento('familiares', familiar) self.verListaFamiliares() return True def refrescarTabla(self): self.__listaFamiliares = self.__querier.traerElementos( campos=self.__propiedades, tabla='familiares', uniones=[("afiliados", "legajo_afiliado = afiliados.legajo")], condiciones=self.condicionesRefresco, orden=self.ordenRefresco) if self.__listaFamiliares: self.layoutChanged.emit() def verListaFamiliares(self, condiciones=None, orden=None): self.condicionesRefresco = condiciones self.ordenRefresco = orden self.__listaFamiliares = self.__querier.traerElementos( campos=self.__propiedades, tabla='familiares', uniones=[("afiliados", "legajo_afiliado = afiliados.legajo")], condiciones=condiciones, orden=orden) self.__listaFamiliares = self.__toList() self._setDates(4) if self.__listaFamiliares: self.layoutChanged.emit() return True return False def _setDates(self, dateIndex): for familiar in self.__listaFamiliares: familiar[dateIndex] = QtCore.QDate(familiar[dateIndex]) def __toList(self): listaFamiliares = [] for index, familiar in enumerate(self.__listaFamiliares): listaFamiliares.append(list(familiar)) return listaFamiliares # Estas son las funciones específicas de Qt para las tablas def rowCount(self, parent): return len(self.__listaFamiliares) def columnCount(self, parent): if self.__listaFamiliares: return len(self.__listaFamiliares[0]) else: return 0 def flags(self, index): return QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled def data(self, index, role): # Acá es donde definí de dónde (De qué lista) voy a levantar los datos if role == QtCore.Qt.DisplayRole: row = index.row() column = index.column() value = self.__listaFamiliares[row][ column] # value contiene la lista de listas que contiene los afiliados return value # el valor que retorno es el que aparecería en la tabla def headerData(self, section, orientation, role): if role == QtCore.Qt.DisplayRole: if orientation == QtCore.Qt.Horizontal: # Los objetos tipo diccionario no ordenan sus elementos, por eso usar dict.keys() me tira los nombres # de las columnas en cualquier orden. Acá debería usar la lista propiedades. # además de salir ordenado, se ajusta la cantidad de columnas correspondiente keys = list(self.__propiedades) return keys[section]