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]