def polizasReliquidadas(periodo, complementoCliente):
mesAnterior = formatearFechaMesAnterior(periodo)
fechaIncioMes = primerDiaMes(periodo)
polizasParaReliquidar = buscarPolizasReliquidar(mesAnterior)
polizasAprobadaReliquidar = dict()
for poliza in polizasParaReliquidar.values():
numeroPoliza = poliza['POLIZA']
if not complementoCliente.get(numeroPoliza):
mensaje = 'PolizaReliquidacion;No existe la POLIZA en el COMPLEMENTO_CLIENTE;{0}'.format(numeroPoliza)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_COMPLEMENTO_CLIENTE': mensaje})
continue
numeroPolizaCertificado = poliza['NUMERO_POLIZA_CERTIFICADO']
nombreCampana = poliza['NOMBRE_CAMPANA']
fechaCierre = poliza['FECHA_CIERRE']
idEmpleado = poliza['CODIGO_EMPLEADO']
campanaId = poliza['CAMPAÑA_ID']
numeroPolizaCliente = complementoCliente[numeroPoliza]['NRO_CERT']
fecUltimoPago = complementoCliente[numeroPoliza]['FEC_ULT_PAG']
pk = '{0}_{1}_{2}'.format(campanaId, idEmpleado, numeroPoliza)
cobranzaRelPro = 0
pacpatRelPro = 0
if poliza['COBRANZA_RL_PRO'] > 0:
cobranzaRelPro = aprobarCobranza(numeroPolizaCertificado, fechaCierre, numeroPolizaCliente, fecUltimoPago)
if cobranzaRelPro == 0:
mensaje = 'PolizaReliquidacion;No cumple condicion de retencion COBRANZA para Reliquidacion;%s' % (numeroPoliza)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'PROCESO_COBRANZA_RELIQUIDACION': mensaje})
if poliza['PACPAT_RL_PRO'] > 0:
estadoMandato = complementoCliente[numeroPoliza]['ESTADO_MANDATO']
fecMandato = complementoCliente[numeroPoliza]['FECHA_MANDATO']
if estadoMandato is not None:
pacpatRelPro = aprobarActivacion(str(estadoMandato).upper(), fecMandato, fechaCierre)
mensajeValidacion = 'MANDATOS'
else:
pacpatRelPro = aprobarCobranza(numeroPolizaCertificado, fechaCierre, numeroPolizaCliente, fecUltimoPago)
mensajeValidacion = 'MANDATOS/COBRANZA'
if pacpatRelPro == 0:
mensaje = 'PolizaReliquidacion;No cumple condicion de retencion {0} para Reliquidacion;{1}'.format(mensajeValidacion, numeroPoliza)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'PROCESO_ACTIVACION_RELIQUIDACION': mensaje})
if cobranzaRelPro > 0 or pacpatRelPro > 0:
polizasAprobadaReliquidar[pk] = {'COBRANZA_REL_PRO': cobranzaRelPro, 'PACPAT_REL_PRO': pacpatRelPro, 'CODIGO_EMPLEADO': idEmpleado, 'CAMPAÑA_ID': campanaId, 'NOMBRE_CAMAPANA': nombreCampana, 'POLIZA': numeroPoliza}
if len(polizasAprobadaReliquidar) > 0:
actualizarPolizasReliquidadas(polizasAprobadaReliquidar, fechaIncioMes, mesAnterior)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZAS_RELIQUIDADS': 'PolizasReliquidadas;Existen {0} polizas para reliquidar del mes {1}'.format(len(polizasAprobadaReliquidar), mesAnterior)})
else:
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZAS_RELIQUIDADS': 'PolizasReliquidadas;No Existen polizas para reliquidar del periodo: {0}'.format(mesAnterior)})
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZAS_RELIQUIDADS': '-----------------------------------------------------' })
return polizasAprobadaReliquidar
def leerArchivoAsistencia(archivo, periodo):
try:
LOG_PROCESO_ASISTENCIA.setdefault(
'INICIO_LECTURA_ASISTENCIA', {
len(LOG_PROCESO_ASISTENCIA) + 1:
'Iniciando proceso de lectura del Archivo: %s' % archivo
})
encabezadoXls = ASISTENCIA_CONFIG_XLSX['ENCABEZADO_XLSX']
encabezadoTxt = ASISTENCIA_CONFIG_XLSX['ENCABEZADO_TXT']
columna = ASISTENCIA_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
coordenadaEcabezado = ASISTENCIA_CONFIG_XLSX['COORDENADA_ENCABEZADO']
columnasAdicionales = ASISTENCIA_CONFIG_XLSX['COLUMNAS_ADICIONALES']
xls = load_workbook(archivo, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
correlativo = 1
LOG_PROCESO_ASISTENCIA.setdefault(
len(LOG_PROCESO_ASISTENCIA) + 1, {
'ENCABEZADO_ASISTENCIA':
'Encabezado del Archivo: %s OK' % archivo
})
filaSalidaXls = dict()
empleadosLista = dict()
primerDia = primerDiaMes(periodo)
totalColumnas = calcularDiasHablies(
hoja.iter_rows(min_row=1, min_col=2, max_row=1))
totalFilas = len(tuple(hoja.iter_rows(min_row=3, min_col=1)))
LOG_PROCESO_ASISTENCIA.setdefault(
len(LOG_PROCESO_ASISTENCIA) + 1, {
'INICIO_CELDAS_ASISTENCIA':
'Iniciando lectura de Celdas del Archivo: %s' % archivo
})
updateEjecutivoFechaDesv(periodo)
for fila in tqdm(iterable=hoja.iter_rows(min_row=3, min_col=1),
total=totalFilas,
desc='Leyendo AsistenciaCRO',
unit=' Fila'):
# for fila in hoja.iter_rows(min_row=3, min_col=1):
diasVacaciones = 0
ausentismoMes = 1
if fila[columna['ID_EMPLEADO']].value is not None and fila[
columna['PLATAFORMA']].value is not None:
idEmpleado = fila[columna['ID_EMPLEADO']].value
plataforma = str(fila[columna['PLATAFORMA']].value).upper()
if not empleadosLista.get(idEmpleado):
empleadosLista[idEmpleado] = {
'ID_EMPLEADO': idEmpleado,
'PLATAFORMA': plataforma,
'ID_EMPLEADO2': idEmpleado,
'PLATAFORMA2': plataforma,
'PRIMER_DIA': primerDia
}
if not filaSalidaXls.get(idEmpleado):
conteoVhcAplica = 0
vhcAplica = 0
filaSalidaXls[idEmpleado] = {'CRR': correlativo}
for celda in range(2, totalColumnas + columnasAdicionales):
if str(fila[celda].value).upper() == 'V' or str(
fila[celda].value).upper() == 'VAC':
diasVacaciones += 1
conteoVhcAplica += 1
else:
conteoVhcAplica = 0
if conteoVhcAplica == 5:
vhcAplica = 1
conteoVhcAplica = 0
if type(fila[celda].value
) is int and fila[celda].value == 1:
ausentismoMes = 0
filaSalidaXls[idEmpleado].setdefault(
'VHC_MES', diasVacaciones)
filaSalidaXls[idEmpleado].setdefault(
'DIAS_HABILES_MES', totalColumnas)
filaSalidaXls[idEmpleado].setdefault('CARGA', vhcAplica)
filaSalidaXls[idEmpleado].setdefault(
'AUSENTISMO_MES', ausentismoMes)
filaSalidaXls[idEmpleado].setdefault(
'ID_EMPLEADO', idEmpleado)
correlativo += 1
else:
errorRut = '%s - Ejecutivo duplicado: %s' % (setearCelda2(
fila[columna['ID_EMPLEADO']], 0), idEmpleado)
LOG_PROCESO_ASISTENCIA.setdefault(
len(LOG_PROCESO_ASISTENCIA) + 1, {
'EJECUTIVO_DUPLICADO_%s' % str(
len(LOG_PROCESO_ASISTENCIA) + 1):
errorRut
})
LOG_PROCESO_ASISTENCIA.setdefault(
'FIN_CELDAS_ASISTENCIA', {
len(LOG_PROCESO_ASISTENCIA) + 1:
'Lectura de Celdas del Archivo: %s Finalizada - %s filas' %
(archivo, len(tuple(hoja.rows)))
})
LOG_PROCESO_ASISTENCIA.setdefault(
'PROCESO_ASISTENCIA', {
len(LOG_PROCESO_ASISTENCIA) + 1:
'Proceso del Archivo: %s Finalizado' % archivo
})
if len(empleadosLista) > 0:
listaEmpleadosFormateada = convertirALista(empleadosLista)
insertarEjecutivo(listaEmpleadosFormateada)
return filaSalidaXls, encabezadoTxt
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivo, e)
LOG_PROCESO_ASISTENCIA.setdefault(
'LECTURA_ARCHIVO', {len(LOG_PROCESO_ASISTENCIA) + 1: errorMsg})
LOG_PROCESO_ASISTENCIA.setdefault(
'PROCESO_ASISTENCIA', {
len(LOG_PROCESO_ASISTENCIA) + 1:
'Error al procesar Archivo: %s' % archivo
})
return False, False
def leerArchivoCalidad(archivo, periodo):
try:
LOG_PROCESO_CALIDAD.setdefault(
'INICIO_LECTURA', {
len(LOG_PROCESO_CALIDAD) + 1:
'Iniciando proceso de lectura del Archivo: %s' % archivo
})
encabezadoXls = CALIDAD_CONFIG_XLSX['ENCABEZADO_XLSX']
encabezadoTxt = CALIDAD_CONFIG_XLSX['ENCABEZADO_TXT']
celda = CALIDAD_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
coordenadaEcabezado = CALIDAD_CONFIG_XLSX['COORDENADA_ENCABEZADO']
xls = load_workbook(archivo, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1,
{'ENCABEZADO_ARCHIVO': 'Encabezado del Archivo: %s OK' % archivo})
i = 0
correlativo = 1
filaSalidaXls = dict()
ejecutivosExistentesDb = buscarRutEjecutivosDb(ultimoDiaMes(periodo),
primerDiaMes(periodo))
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo Calidad',
unit=' Fila'):
if i >= 2 and fila[celda['ID_EMPLEADO']].value is not None:
idEmpleado = str(fila[celda['ID_EMPLEADO']].value)
if ejecutivosExistentesDb.get(idEmpleado):
calidad = int(float(fila[celda['CALIDAD']].value) * 100)
filaSalidaXls[idEmpleado] = {
'CRR': correlativo,
'CALIDAD': calidad,
'ID_EMPLEADO': idEmpleado
}
correlativo += 1
else:
errorRut = '%s;No existe Ejecutivo;%s' % (setearCelda2(
fila[celda['ID_EMPLEADO']], 0), idEmpleado)
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1,
{'EJECUTIVO_NO_EXISTE_%s' % i: errorRut})
i += 1
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1, {
'FIN_LECTURA_ARCHIVO':
'Lectura de Celdas del Archivo: %s Finalizada - %s filas' %
(archivo, len(tuple(hoja.rows)))
})
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1,
{'FIN_PROCESO': 'Proceso del Archivo: %s Finalizado' % archivo})
return filaSalidaXls, encabezadoTxt
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivo, e)
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1, {'LECTURA_ARCHIVO_ERROR': errorMsg})
LOG_PROCESO_CALIDAD.setdefault(
len(LOG_PROCESO_CALIDAD) + 1,
{'PROCESO_ARCHIVO': 'Error al procesar Archivo: %s' % archivo})
return False, False
def extraerPropietariosCro(archivoPropietariosXls, periodo):
archivo = archivoPropietariosXls
LOG_PROCESO_GESTION.setdefault(
'INICIO_LECTURA_PROPIETARIOS', {
len(LOG_PROCESO_GESTION) + 1:
'Iniciando proceso de lectura del Archivo: %s' % archivo
})
try:
encabezadoXls = GESTION_CONFIG_XLSX['ENCABEZADO_PROPIETARIOS_XLSX']
celda = GESTION_CONFIG_XLSX['COLUMNAS_PROPIETARIOS_XLSX']
coordenadaEcabezado = GESTION_CONFIG_XLSX[
'COORDENADA_ENCABEZADO_PROPIETARIO']
xls = load_workbook(archivo, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
propietariosCro = dict()
validarArchivo = validarEncabezadoXlsx(hoja[coordenadaEcabezado],
encabezadoXls, archivo)
ejecutivosExistentesDb = buscarRutEjecutivosDb(ultimoDiaMes(periodo),
primerDiaMes(periodo))
i = 0
if type(validarArchivo) is not dict:
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo PropietariosCRO',
unit=' Fila'):
if i >= 1:
campahnaId = str(fila[celda['CAMPAÑA_ID']].value)
idEmpleado = str(fila[celda['ID_EMPLEADO']].value)
fecha = None
if fila[celda['FECHA']].value is not None:
fecha = setearFechaCelda(fila[celda['FECHA']])
if fila[celda['ID_EMPLEADO']].value is None:
celdaCoordenada = setearCelda2(
fila[0:celda['ID_EMPLEADO'] + 1],
len(fila[0:celda['ID_EMPLEADO']]) - 1, i)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'EMPLEADO_PROPIETARIO_NULL':
'{0};El ID_EMPLEADO es NULL;{1}'.format(
celdaCoordenada, idEmpleado)
})
continue
if not propietariosCro.get(campahnaId):
propietariosCro[campahnaId] = {
'ID_EMPLEADO': idEmpleado,
'FECHA': fecha
}
else:
if fecha is not None:
if propietariosCro[campahnaId]['FECHA'] is None:
propietariosCro[campahnaId][
'ID_EMPLEADO'] = idEmpleado
propietariosCro[campahnaId]['FECHA'] = fecha
else:
if fecha > propietariosCro[campahnaId]['FECHA']:
propietariosCro[campahnaId][
'ID_EMPLEADO'] = idEmpleado
propietariosCro[campahnaId][
'FECHA'] = fecha
i += 1
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'ENCABEZADO_PROPIETARIOSCRO':
'Encabezado del Archivo: %s OK' % archivo
})
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'LECTURA_PROPIETARIOS':
'Lectura del Archivo: %s Finalizado' % archivo
})
return propietariosCro
else:
LOG_PROCESO_GESTION.setdefault('ENCABEZADO_PROPIETARIOSCRO',
validarArchivo)
raise
except Exception as e:
errorMsg = 'Error al leer archivo: %s | %s' % (archivo, e)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'LECTURA_PROPIETARIOSCRO': errorMsg})
raise
def leerArchivoGestion(archivoEntrada, periodo, fechaInicioEntrada,
fechaFinEntrada, archivoPropietariosXls):
try:
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'INICIO_LECTURA_GESTION':
'Iniciando proceso de lectura del Archivo: %s' % archivoEntrada
})
encabezadoXls = GESTION_CONFIG_XLSX['ENCABEZADO_XLSX']
encabezadoTxt = GESTION_CONFIG_XLSX['ENCABEZADO_TXT']
columna = GESTION_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
coordenadaEcabezado = GESTION_CONFIG_XLSX['COORDENADA_ENCABEZADO']
xls = load_workbook(archivoEntrada, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'ENCABEZADO_GESTION':
'Encabezado del Archivo: %s OK' % archivoEntrada
})
filaSalidaXls = dict()
campanasNuevas = []
propietarioCro = extraerPropietariosCro(archivoPropietariosXls,
periodo)
campahnasExistentesDb = buscarCamphnasDb()
ejecutivosExistentesDb = buscarRutEjecutivosDb(ultimoDiaMes(periodo),
primerDiaMes(periodo))
listaEstadoUt = listaEstadoUtCro()
fechaInicioPeriodo = setearFechaInput(fechaInicioEntrada)
fechaFinPeriodo = setearFechaInput(fechaFinEntrada)
fechaIncioMes = primerDiaMes(periodo)
fechaFinMes = ultimoDiaMes(periodo)
i = 0
correlativo = 1
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'INICIO_CELDAS_GESTION':
'Iniciando lectura de Celdas del Archivo: %s' % archivoEntrada
})
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo GestionCRO',
unit=' Fila'):
if i >= 1:
fechaCreacion = setearFechaCelda(
fila[columna['FECHA_DE_CREACION']])
fechaCierre = setearFechaCelda(
fila[columna['FECHA_DE_CIERRE']])
estado = getEstado(fila[columna['ESTADO']])
nombreCampana = str(fila[columna['NOMBRE_DE_CAMPAÑA']].value)
campanhaId = str(fila[columna['CAMPAÑA_ID']].value)
estadoUt = getEstadoUt(fila[columna['ESTADO_UT']],
listaEstadoUt)
idEmpleado = str(fila[columna['ID_EMPLEADO']].value)
if type(fechaCreacion) is not datetime.date:
valorErroneo = str(
fila[columna['FECHA_DE_CREACION']].value)
celdaCoordenada = setearCelda2(
fila[0:columna['FECHA_DE_CREACION'] + 1],
len(fila[0:columna['FECHA_DE_CREACION']]) - 1, i)
mensaje = '%s;FECHA_DE_CREACION no es una fecha valida;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'FECHA_DE_CREACION': mensaje})
continue
if type(estado) is not int:
valorErroneo = str(fila[columna['ESTADO']].value)
celdaCoordenada = setearCelda2(
fila[0:columna['ESTADO'] + 1],
len(fila[0:columna['ESTADO']]) - 1, i)
mensaje = '%s;ESTADO no existe;%s' % (celdaCoordenada,
valorErroneo)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'ERROR_ESTADO': mensaje})
continue
if type(estadoUt) is not int and estado != 0:
valorErroneo = str(fila[columna['ESTADO_UT']].value)
celdaCoordenada = setearCelda2(
fila[0:columna['ESTADO_UT'] + 1],
len(fila[0:columna['ESTADO_UT']]) - 1, i)
mensaje = '%s;ESTADO_UT no existe;%s' % (celdaCoordenada,
valorErroneo)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'ERROR_ESTADOUT': estadoUt})
raise Exception('Error en la columna ESTADO_UT')
elif type(estadoUt) is not int:
estadoUt = 0
if nombreCampana == 'Inbound CRO':
if estado != 0:
fechaUltimaModificacion = fechaCierre
if type(fechaUltimaModificacion) is not datetime.date:
errorCampana = 'Celda%s;FECHA_CIERRE No es valida;%s' % (
setearCelda(fila[columna['CAMPAÑA_ID']]),
fechaUltimaModificacion)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'FECHA_CIERRE_ERROR': errorCampana})
continue
if fechaUltimaModificacion >= fechaIncioMes and fechaUltimaModificacion <= fechaFinMes:
if propietarioCro.get(campanhaId):
ejecutivoCorrecto = propietarioCro[campanhaId][
'ID_EMPLEADO']
else:
ejecutivoCorrecto = idEmpleado
else:
continue
else:
continue
else:
if fechaCreacion < fechaInicioPeriodo or fechaCreacion > fechaFinPeriodo:
continue
if propietarioCro.get(campanhaId):
ejecutivoCorrecto = propietarioCro[campanhaId][
'ID_EMPLEADO']
else:
ejecutivoCorrecto = idEmpleado
if not campahnasExistentesDb.get(nombreCampana):
campahnasExistentesDb[nombreCampana] = {
'NOMBRE_CAMPANA': nombreCampana
}
campanasNuevas.append([nombreCampana])
if ejecutivosExistentesDb.get(ejecutivoCorrecto):
filaSalidaXls[correlativo] = {
'CRR': correlativo,
'ESTADO': estado,
'ESTADO_UT': estadoUt,
'ID_CAMPANHA': campanhaId,
'CAMPANA': nombreCampana[0:30],
'ID_EMPLEADO': ejecutivoCorrecto
}
correlativo += 1
else:
errorRut = 'Celda%s;No existe Ejecutivo;%s' % (setearCelda(
fila[columna['CAMPAÑA_ID']]), ejecutivoCorrecto)
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1,
{'EJECUTIVO_NO_EXISTE': errorRut})
i += 1
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'FIN_CELDAS_GESTION':
'Lectura de Celdas del Archivo: %s Finalizada - %s filas' %
(archivoEntrada, len(tuple(hoja.rows)))
})
LOG_PROCESO_GESTION.setdefault(
len(LOG_PROCESO_GESTION) + 1, {
'PROCESO_GESTION':
'Proceso del Archivo: %s Finalizado' % archivoEntrada
})
if len(campanasNuevas) > 0:
insertarCamphnaCro(campanasNuevas)
return filaSalidaXls, encabezadoTxt
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivoEntrada, e)
LOG_PROCESO_GESTION.setdefault(
'LECTURA_ARCHIVO', {len(LOG_PROCESO_GESTION) + 1: errorMsg})
LOG_PROCESO_GESTION.setdefault(
'PROCESO_GESTION', {
len(LOG_PROCESO_GESTION) + 1:
'Error al procesar Archivo: %s' % archivoEntrada
})
return False, False
def leerArchivoFuga(archivo, periodo):
try:
LOG_PROCESO_FUGA.setdefault(
'INICIO_LECTURA_FUGA', {
len(LOG_PROCESO_FUGA) + 1:
'Iniciando proceso de lectura del Archivo: %s' % archivo
})
encabezadoXls = FUGA_CONFIG_XLSX['ENCABEZADO_XLSX']
encabezadoFugaTxt = FUGA_CONFIG_XLSX['ENCABEZADO_FUGA_TXT']
columna = FUGA_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
coordenadaEcabezado = FUGA_CONFIG_XLSX['COORDENADA_ENCABEZADO']
xls = load_workbook(archivo, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
LOG_PROCESO_FUGA.setdefault(
len(LOG_PROCESO_FUGA) + 1,
{'ENCABEZADO_FUGA': 'Encabezado del Archivo: %s OK' % archivo})
i = 0
correlativo = 1
filaSalidaFugaXls = dict()
filaSalidaStockXls = dict()
ejecutivosExistentesDb = buscarRutEjecutivosDb(ultimoDiaMes(periodo),
primerDiaMes(periodo))
LOG_PROCESO_FUGA.setdefault(
len(LOG_PROCESO_FUGA) + 1, {
'INICIO_CELDAS_FUGA':
'Iniciando lectura de Celdas del Archivo: %s' % archivo
})
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo FugaCRO',
unit=' Fila'):
if i >= 1:
fechaLpattrs = validaFechaCelda(
fila[columna['LPATTR_PER_RES']])
if type(fechaLpattrs) is str:
LOG_PROCESO_FUGA.setdefault(
len(LOG_PROCESO_FUGA) + 1,
{'FECHA_CREACION': fechaLpattrs})
continue
if periodo == str(fechaLpattrs.value) and fila[
columna['ID_EMPLEADO']].value is not None:
idEmpleado = str(fila[columna['ID_EMPLEADO']].value)
tipo = str(fila[columna['TIPO']].value).upper()
considerarFuga = str(
fila[columna['CONSIDERAR_FUGA']].value).upper()
lpattrCodStat = str(
fila[columna['LPATTR_COD_STAT']].value).upper()
if ejecutivosExistentesDb.get(idEmpleado):
unidad = ejecutivosExistentesDb[idEmpleado][
'PLATAFORMA']
if filaSalidaFugaXls.get(idEmpleado):
filaSalidaFugaXls[idEmpleado] = existeRut(
tipo, lpattrCodStat, considerarFuga,
filaSalidaFugaXls[idEmpleado])
else:
filaSalidaFugaXls[idEmpleado] = validarFugaStock(
correlativo, tipo, lpattrCodStat,
considerarFuga, idEmpleado, unidad)
correlativo += 1
else:
errorRut = 'Celda%s - No existe Ejecutivo: %s' % (
setearCelda(
fila[columna['ID_EMPLEADO']]), idEmpleado)
LOG_PROCESO_FUGA.setdefault(
'EJECUTIVO_NO_EXISTE_%s' % i,
{len(LOG_PROCESO_FUGA) + 1: errorRut})
i += 1
LOG_PROCESO_FUGA.setdefault(
'FIN_CELDAS_FUGA', {
len(LOG_PROCESO_FUGA) + 1:
'Lectura de Celdas del Archivo: %s Finalizada - %s filas' %
(archivo, len(tuple(hoja.rows)))
})
LOG_PROCESO_FUGA.setdefault(
'PROCESO_FUGA', {
len(LOG_PROCESO_FUGA) + 1:
'Proceso del Archivo: %s Finalizado' % archivo
})
return filaSalidaFugaXls, encabezadoFugaTxt
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivo, e)
LOG_PROCESO_FUGA.setdefault('LECTURA_ARCHIVO',
{len(LOG_PROCESO_FUGA) + 1: errorMsg})
LOG_PROCESO_FUGA.setdefault('PROCESO_FUGA', {
len(LOG_PROCESO_FUGA) + 1:
'Error al procesar Archivo: %s' % archivo
})
return False, False
def leerArchivoReactiva(archivoEntrada, periodo, fechaInicioEntrada,
fechaFinEntrada, archivoCertificacionXls,
archivoComplmentoCliente):
try:
archivoSalida = REACTIVA_CONFIG_XLSX['SALIDA_TXT']
encabezadoXls = REACTIVA_CONFIG_XLSX['ENCABEZADO_XLSX']
coordenadaEncabezado = REACTIVA_CONFIG_XLSX['COORDENADA_ENCABEZADO']
columna = REACTIVA_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
xls = load_workbook(archivoEntrada, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
fechaInicioPeriodo = setearFechaInput(fechaInicioEntrada)
fechaFinPeriodo = setearFechaInput(fechaFinEntrada)
fechaIncioMes = primerDiaMes(periodo)
fechaFinMes = ultimoDiaMes(periodo)
complementoCliente = extraerComplementoCliente(
len(LOG_PROCESO_REACTIVA), archivoComplmentoCliente)
LOG_PROCESO_REACTIVA.update(LOG_COMPLEMENTO_CLIENTE)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'DIVISOR_PROCESO':
'-----------------------------------------------------'
})
baseCertificacion = extraerBaseCertificacion(archivoCertificacionXls,
fechaInicioPeriodo,
fechaFinMes)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'DIVISOR_PROCESO':
'-----------------------------------------------------'
})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'INICIO_LECTURA_REACTIVA':
'Iniciando proceso de lectura del Archivo: %s' % archivoEntrada
})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'ENCABEZADO_REACTIVA':
'Encabezado del Archivo: %s OK' % archivoEntrada
})
campanaDescripcion = {inbound: 'Inbound', outbound: 'Outbound'}
campanaIdDuplicado = dict()
gestionReactTxt = dict()
polizaExitoRepetido = dict()
polizaReactTxt = dict()
certificacionReactTxt = dict()
dataCartolaDb = dict()
ejecutivosExistentesDb = buscarRutEjecutivosDb(fechaFinMes,
fechaIncioMes)
listaEstadoRetencionTexto = estadoRetencionReacDesc()
listaEstadoContactado = listaEstadoUtContacto()
i = 0
cantidadCampanasValidas = 0
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'INICIO_CELDAS_REACTIVA':
'Iniciando lectura de Celdas del Archivo: %s' % archivoEntrada
})
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo Reactiva',
unit=' Fila'):
i += 1
if i >= 2:
salienteEntrada = fila[columna['LLAMADA_SALIENTE']].value
estado = str(fila[columna['ESTADO']].value)
estadoUt = fila[columna['ESTADO_ULTIMA_TAREA']].value
estadoRetencion = fila[columna['ESTADO_RETENCION']].value
numeroPoliza, numeroPolizaCertificado = formatearNumeroPoliza(
fila[columna['NRO_POLIZA']].value)
idEmpleado = str(fila[columna['ID_EMPLEADO']].value)
campanaId = str(fila[columna['CAMAPAÑA_ID']].value)
fechaCreacionUnida = fechaUnida(
fila[columna['FECHA_CREACION']])
saliente = formatearSaliente(salienteEntrada)
pk = '{0}_{1}_{2}_{3}'.format(fechaCreacionUnida, numeroPoliza,
saliente, idEmpleado)
fechaCreacion = setearFechaCelda(
fila[columna['FECHA_CREACION']])
fechaCierre = setearFechaCelda(fila[columna['FECHA_CIERRE']])
if salienteEntrada is None:
celdaCoordenada = setearCelda2(
fila[0:columna['LLAMADA_SALIENTE'] + 1],
len(fila[0:columna['LLAMADA_SALIENTE']]) - 1, i)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'LLAMADA_SALIENTE':
'%s;Campaña InBound/OutBound NULL;%s' %
(celdaCoordenada, numeroPoliza)
})
continue
if fila[columna['NRO_POLIZA']].value is None:
celdaCoordenada = setearCelda2(
fila[0:columna['NRO_POLIZA'] + 1],
len(fila[0:columna['NRO_POLIZA']]) - 1, i)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'POLIZA_NULO':
'%s;Numero de poliza NULL;%s' %
(celdaCoordenada, numeroPoliza)
})
continue
if type(fechaCreacion) is not datetime.date:
valorErroneo = fila[columna['FECHA_CREACION']].value
celdaCoordenada = setearCelda2(
fila[0:columna['FECHA_CREACION'] + 1],
len(fila[0:columna['FECHA_CREACION']]) - 1, i)
mensaje = '%s;FECHA_CREACION no es una fecha valida;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'FECHA_CREACION': mensaje})
continue
if type(fechaCierre) is not datetime.date:
fechaCierre = None
if not ejecutivosExistentesDb.get(idEmpleado):
valorErroneo = fila[columna['ID_EMPLEADO']].value
celdaCoordenada = setearCelda2(
fila[0:columna['ID_EMPLEADO'] + 1],
len(fila[0:columna['ID_EMPLEADO']]) - 1, i)
mensaje = '%s;ID_EMPLEADO no existe en la DB;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'ID_EMPLEADO': mensaje})
continue
nombreCampana = campanaDescripcion.get(saliente)
exitoDuplicadoPoliza = 0
if saliente == inbound and fechaCreacion >= fechaIncioMes and fechaCreacion <= fechaFinMes or saliente == outbound and fechaCreacion >= fechaInicioPeriodo and fechaCreacion <= fechaFinPeriodo:
estadoValidoReact = validarEstadoReact(
estadoRetencion, estado)
contactoReact = validarContactoReact(
saliente, estadoRetencion, estado, estadoUt,
listaEstadoContactado)
if type(contactoReact) is not int:
valorErroneo = str(
fila[columna['ESTADO_ULTIMA_TAREA']].value)
celdaCoordenada = setearCelda2(
fila[0:columna['ESTADO_ULTIMA_TAREA'] + 1],
len(fila[0:columna['ESTADO_ULTIMA_TAREA']]) - 1, i)
mensaje = '%s;No existe EstadoUT;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'ERROR_ESTADO_UT': mensaje})
continue
if not gestionReactTxt.get(pk):
gestionReactTxt[pk] = {
'ESTADO_VALIDO_REACT': estadoValidoReact,
'CONTACTO_REACT': contactoReact,
'EXITO_REPETIDO_REACT': 0,
'ID_EMPLEADO': idEmpleado,
'ID_CAMPANA': campanaId,
'CAMPANA': nombreCampana,
'POLIZA': numeroPoliza,
'REPETICIONES': 1,
'FECHA_CREACION': fechaCreacion,
'FECHA_CIERRE': fechaCierre
}
cantidadCampanasValidas += 1
else:
controlCambioPk, indiceCambio = aprobarActualizarRegistro(
estado, estadoValidoReact, contactoReact,
gestionReactTxt[pk]['ESTADO_VALIDO_REACT'],
gestionReactTxt[pk]['CONTACTO_REACT'])
celdaCoordenada = setearCelda2(
fila[0:columna['ID_EMPLEADO'] + 1],
len(fila[0:columna['ID_EMPLEADO']]) - 1, i)
if controlCambioPk:
datosActualizados = {
'ESTADO_VALIDO_REACT':
estadoValidoReact,
'CONTACTO_REACT':
contactoReact,
'EXITO_REPETIDO_REACT':
0,
'ID_EMPLEADO':
idEmpleado,
'ID_CAMPANA':
campanaId,
'CAMPANA':
nombreCampana,
'POLIZA':
numeroPoliza,
'REPETICIONES':
gestionReactTxt[pk]['REPETICIONES'] + 1,
'FECHA_CREACION':
fechaCreacion,
'FECHA_CIERRE':
fechaCierre
}
gestionReactTxt[pk].update(datosActualizados)
mensaje = '{0};POLIZA_DUPLICADA;ESTADO_ANTERIOR:({1},{2}):NUEVO_VALOR:({3},{4},{5})_{6}'.format(
celdaCoordenada,
listaEstadoRetencionTexto.get(
gestionReactTxt[pk]
['ESTADO_VALIDO_REACT']),
gestionReactTxt[pk]['CONTACTO_REACT'],
listaEstadoRetencionTexto.get(
estadoValidoReact), contactoReact,
estadoRetencion, indiceCambio)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'REGISTRO_DUPLICADA': mensaje})
else:
mensaje = '{0};POLIZA_DUPLICADA;ELIMINADO:({1},{2},{3}):PERMANECE:({4},{5})'.format(
celdaCoordenada,
listaEstadoRetencionTexto.get(
estadoValidoReact), contactoReact,
estadoRetencion,
listaEstadoRetencionTexto.get(
gestionReactTxt[pk]
['ESTADO_VALIDO_REACT']),
gestionReactTxt[pk]['CONTACTO_REACT'])
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'REGISTRO_DUPLICADA': mensaje})
gestionReactTxt[pk]['REPETICIONES'] += 1
continue
ValidacionCertificacion = 0
grabCertificadaReact = 0
if estadoValidoReact == 1:
ValidacionCertificacion = 2
if complementoCliente.get(
int(numeroPoliza)) and complementoCliente[
int(numeroPoliza
)]['ESTADO_POLIZA'] == 'Vigente':
polizaReactTxt[numeroPoliza] = {
'ESTADO_POLIZA_REACT': 1,
'NUMERO_POLIZA': numeroPoliza
}
pkBaseCertificacion = '{0}_{1}'.format(
str(numeroPoliza), idEmpleado)
if baseCertificacion.get(pkBaseCertificacion):
ejecutivoBaseCertificacion = baseCertificacion[
pkBaseCertificacion]['ID_EMPLEADO']
if not ejecutivosExistentesDb.get(
ejecutivoBaseCertificacion):
valorErroneo = baseCertificacion[
pkBaseCertificacion]['ID_EMPLEADO']
celdaCoordenada = setearCelda2(
fila[0:columna['ID_EMPLEADO'] + 1],
len(fila[0:columna['ID_EMPLEADO']]) - 1, i)
mensaje = '%s;EJECUTIVO_BASE_CERIFICACION no existe en la DB;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'EJECUTIVO_BASE_CERTIFICADO': mensaje})
continue
fechaLlamado = baseCertificacion[
pkBaseCertificacion]['FECHA_LLAMADO']
if saliente == inbound and idEmpleado == ejecutivoBaseCertificacion:
if fechaLlamado >= fechaIncioMes and fechaLlamado <= fechaFinMes:
grabCertificadaReact = 1
gestionReactTxt[pk][
'EXITO_REPETIDO_REACT'] = 1
elif saliente == outbound and idEmpleado == ejecutivoBaseCertificacion:
if fechaLlamado >= fechaInicioPeriodo and fechaLlamado <= fechaFinMes:
grabCertificadaReact = 1
gestionReactTxt[pk][
'EXITO_REPETIDO_REACT'] = 1
certificacionReactTxt[numeroPoliza] = {
'GRAB_CERTIFICADA_REACT': grabCertificadaReact,
'ID_EMPLEADO': idEmpleado,
'CANPANA': nombreCampana,
'POLIZA': numeroPoliza
}
if grabCertificadaReact == 1:
ValidacionCertificacion = 1
if polizaExitoRepetido.get(numeroPoliza):
pkDataGestion = exitoRepetidoPk(
numeroPoliza, polizaExitoRepetido,
gestionReactTxt)
if pkDataGestion == 0:
continue
exitoDuplicadoPoliza = 1
if saliente == inbound:
if fechaCreacion >= gestionReactTxt[
pkDataGestion]['FECHA_CREACION']:
gestionReactTxt[pkDataGestion][
'EXITO_REPETIDO_REACT'] = 0
elif saliente == outbound:
if type(fechaCierre) is datetime.date and type(
gestionReactTxt[pkDataGestion]
['FECHA_CIERRE']) is datetime.date:
if fechaCierre >= gestionReactTxt[
pkDataGestion]['FECHA_CIERRE']:
gestionReactTxt[pkDataGestion][
'EXITO_REPETIDO_REACT'] = 0
else:
valorErroneo = '%s-VS-%s' % (
fechaCierre,
gestionReactTxt[pkDataGestion]
['FECHA_CIERRE'])
celdaCoordenada = setearCelda2(
fila[0:columna['FECHA_CIERRE'] + 1],
len(fila[0:columna['FECHA_CIERRE']]) -
1, i)
mensaje = '%s;FECHA_CIERRE no es una fecha valida;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'FECHA_CIERRE': mensaje})
if not polizaExitoRepetido[numeroPoliza].get(pk):
polizaExitoRepetido[numeroPoliza].setdefault(
pk, pk)
else:
polizaExitoRepetido[numeroPoliza] = {pk: pk}
estadoPoliza = complementoCliente[int(
numeroPoliza)]['ESTADO_POLIZA']
estadoFinalDb = 0
if grabCertificadaReact == 1 and polizaReactTxt.get(
numeroPoliza):
estadoFinalDb = 1
valoresPoliza = {
'ID_EMPLEADO': idEmpleado,
'NUMERO_POLIZA': numeroPoliza,
'ESTADO_RETENCION': estadoRetencion,
'ESTAD0_UT': estadoUt,
'IN_OUT': nombreCampana,
'VALIDACION_CERTIFICACION': ValidacionCertificacion,
'EXITO_REPETIDO': exitoDuplicadoPoliza,
'ESTADO_POLIZA': estadoPoliza,
'ESTADO_FINAL': estadoFinalDb
}
agregarCampanasPorEjecutivo(idEmpleado, pk, valoresPoliza)
if insertarPeriodoCampanaEjecutivos(campanasPorEjecutivos,
fechaIncioMes):
if insertarCampanaEjecutivos(campanasPorEjecutivos, fechaIncioMes):
mensaje = 'InsertarCampanaEjecutivos;Se insertaron correctamente: %s Campaña(s)' % (
cantidadCampanasValidas)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'INSERTAR_CAMPANAS_EJECUTIVOS': mensaje})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'INSERTAR_CAMPANAS_EJECUTIVOS':
'-----------------------------------------------------'
})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'FIN_CELDAS_REACTIVA':
'Lectura de Celdas del Archivo: %s Finalizada - %s filas' %
(archivoEntrada, len(tuple(hoja.rows)))
})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'PROCESO_REACTIVA':
'Proceso del Archivo: %s Finalizado' % archivoEntrada
})
salidaGestionReactTxt = convertirDataReact(gestionReactTxt)
dataSalida = [{
'NOMBRE_ARCHIVO':
archivoSalida['GESTION']['NOMBRE_SALIDA'],
'DATA':
salidaGestionReactTxt,
'ENCABEZADO':
archivoSalida['GESTION']['ENCABEZADO']
}, {
'NOMBRE_ARCHIVO':
archivoSalida['POLIZA']['NOMBRE_SALIDA'],
'DATA':
polizaReactTxt,
'ENCABEZADO':
archivoSalida['POLIZA']['ENCABEZADO']
}, {
'NOMBRE_ARCHIVO':
archivoSalida['CERTIFICACION']['NOMBRE_SALIDA'],
'DATA':
certificacionReactTxt,
'ENCABEZADO':
archivoSalida['CERTIFICACION']['ENCABEZADO']
}]
return dataSalida
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivoEntrada, e)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {'LECTURA_ARCHIVO': errorMsg})
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'PROCESO_REACTIVA':
'Error al procesar Archivo: %s' % archivoEntrada
})
return False
def leerArchivoDotacion(periodo):
try:
LOG_PROCESO_DOTACION.setdefault(
'INICIO_LECTURA_DOTACION', {
len(LOG_PROCESO_DOTACION) + 1:
'Iniciando proceso de escritura del Archivo de DOTACION'
})
encabezadoTxt = DOTACION_CONFIG_XLSX['ENCABEZADO_TXT']
filaSalidaXls = dict()
ejecutivosDB = buscarRutEjecutivosDb(ultimoDiaMes(periodo),
primerDiaMes(periodo))
for idEjecutivo, valor in tqdm(iterable=ejecutivosDB.items(),
total=len(ejecutivosDB),
desc='Leyendo DotacionCRO',
unit=' Fila'):
filaSalidaXls[idEjecutivo] = {
'ID_EMPLEADO':
ejecutivosDB[idEjecutivo]['ID_EMPLEADO'],
'NOMBRES':
'A',
'APELLIDO_PARTERNO':
'B',
'APELLIDO_MATERNO':
'C',
'DIRECCION':
'',
'COMUNA':
'',
'TELEFONO':
'',
'CELULAR':
'',
'FECHA_INGRESO':
ejecutivosDB[idEjecutivo]['FECHA_INGRESO'],
'FECHA_NACIMIENTO':
'',
'FECHA_DESVINCULACION':
ejecutivosDB[idEjecutivo]['FECHA_DESVINCULACION'],
'CORREO_ELECTRONICO':
'',
'RUT_JEFE':
'',
'EMPRESA':
'METLIFE',
'SUCURSAL':
'',
'CARGO':
ejecutivosDB[idEjecutivo]['PLATAFORMA'],
'NIVEL_CARGO':
'1',
'CANAL_NEGOCIO':
'MTLFCC',
'ROL_PAGO':
formatearPlataformaCRO(ejecutivosDB[idEjecutivo]['PLATAFORMA'])
}
LOG_PROCESO_DOTACION.setdefault(
'PROCESO_DOTACION', {
len(LOG_PROCESO_DOTACION) + 1:
'Proceso del Archivo: DOTACION Finalizado - %s filas escritas'
% len(ejecutivosDB)
})
return filaSalidaXls, encabezadoTxt
except Exception as e:
errorMsg = 'Error: Al escribir Archivo de DOTACION | %s' % (str(e))
LOG_PROCESO_DOTACION.setdefault(
'LECTURA_ARCHIVO_DOTACION',
{len(LOG_PROCESO_DOTACION) + 1: errorMsg})
return False, False
def leerArchivoProactiva(archivoEntrada, periodo, archivoComplementoCliente):
try:
encabezadoXls = PROACTIVA_CONFIG_XLSX['ENCABEZADO_XLSX']
encabezadoTxt = PROACTIVA_CONFIG_XLSX['ENCABEZADO_TXT']
encabezadoReliquidacionesTxt = PROACTIVA_CONFIG_XLSX['ENCABEZADO_RELIQUIDACIONES']
columna = PROACTIVA_CONFIG_XLSX['COLUMNAS_PROCESO_XLSX']
coordenadaEcabezado = PROACTIVA_CONFIG_XLSX['COORDENADA_ENCABEZADO']
xls = load_workbook(archivoEntrada, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
archivo_correcto = validarEncabezadoXlsx(hoja[coordenadaEcabezado], encabezadoXls, archivoEntrada)
if type(archivo_correcto) is not dict:
filaSalidaXls = dict()
fechaIncioMes = primerDiaMes(periodo)
fechaFinMes = ultimoDiaMes(periodo)
fechaFinMesSiguiente = mesSiguienteUltimoDia(periodo)
listaConsiderarRetencion = {'Mantiene su producto': mantieneSuProducto, 'Realiza pago en línea': realizaPagoEnLinea, 'Realiza Activación PAC/PAT': realizaActivacion}
i = 0
polizasNoAprobadas = 0
cantidadCampanasValidas = 0
complementoCliente = extraerComplementoCliente(len(LOG_PROCESO_PROACTIVA), archivoComplementoCliente)
LOG_PROCESO_PROACTIVA.update(LOG_COMPLEMENTO_CLIENTE)
ejecutivosExistentesDb = buscarRutEjecutivosDb(fechaFinMes, fechaIncioMes)
listaEstadoContactado = listaEstadoUtContacto()
listaEstadoRetencionTexto = estadoRetencionProDesc()
listaEstadoUtTexto = listaEstadoUtDesc()
listaEstadoUt = listaEstadoUtAll()
LOG_PROCESO_PROACTIVA.setdefault('INICIO_LECTURA_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: '-----------------------------------------------------' })
LOG_PROCESO_PROACTIVA.setdefault('ENCABEZADO_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: 'Encabezado del Archivo: %s OK' % archivoEntrada})
LOG_PROCESO_PROACTIVA.setdefault('INICIO_CELDAS_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: 'Iniciando lectura de Celdas del Archivo: %s' % archivoEntrada})
for fila in tqdm(iterable=hoja.rows, total = len(tuple(hoja.rows)), desc='Leyendo Proactiva' , unit=' Fila'):
i += 1
if i >= 2:
nombreCampana = str(fila[columna['NOMBRE_DE_CAMPAÑA']].value)
codigoEjecutivo = str(fila[columna['ID_EMPLEADO']].value)
estado = str(fila[columna['ESTADO']].value)
estadoRetencion = fila[columna['ESTADO_RETENCION']].value
campanaId = str(fila[columna['CAMAPAÑA_ID']].value)
estadoUltimaTarea = fila[columna['ESTADO_ULTIMA_TAREA']].value
numeroPoliza, numeroPolizaCertificado = formatearNumeroPoliza(fila[columna['NRO_POLIZA']].value)
pk = '{0}_{1}_{2}'.format(campanaId, codigoEjecutivo, numeroPoliza)
if numeroPoliza is None:
celdaCoordenada = setearCelda2(fila[0:columna['NRO_POLIZA']+1], len(fila[0:columna['NRO_POLIZA']])-1, i)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_NULO': '%s;Numero de poliza NULL;%s' % (celdaCoordenada, numeroPoliza)})
continue
fechaCreacion = setearFechaCelda(fila[columna['FECHA_CREACION']])
fechaCierre = None
fechaExpiracionCoret = None
if fila[columna['EXPIRACION_CORET']].value is not None:
fechaExpiracionCoret = setearFechaCelda(fila[columna['EXPIRACION_CORET']])
if fila[columna['FECHA_CIERRE']].value is not None:
fechaCierre = setearFechaCelda(fila[columna['FECHA_CIERRE']])
estadoValido = getEstado(fila[columna['ESTADO']])
estadoUtValido = getEstadoUt(fila[columna['ESTADO_ULTIMA_TAREA']], listaEstadoUt)
if type(fechaCreacion) is not datetime.date:
valorErroneo = str(fila[columna['FECHA_CREACION']].value)
celdaCoordenada = setearCelda2(fila[0:columna['FECHA_CREACION']+1], len(fila[0:columna['FECHA_CREACION']])-1, i)
mensaje = '%s;FECHA_CREACION no es una fecha valida;%s' % (celdaCoordenada, valorErroneo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'FECHA_CREACION': mensaje})
continue
if estado != 'Sin Gestion' and type(fechaCierre) is not datetime.date:
valorErroneo = str(fila[columna['FECHA_CIERRE']].value)
celdaCoordenada = setearCelda2(fila[0:columna['FECHA_CIERRE']+1], len(fila[0:columna['FECHA_CIERRE']])-1, i)
mensaje = '%s;FECHA_CIERRE no es una fecha valida;%s' % (celdaCoordenada,valorErroneo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'FECHA_CIERRE': mensaje})
continue
if estado == 'Sin Gestion' and type(fechaExpiracionCoret) is not datetime.date:
valorErroneo = str(fila[columna['EXPIRACION_CORET']].value)
celdaCoordenada = setearCelda2(fila[0:columna['EXPIRACION_CORET']+1], len(fila[0:columna['EXPIRACION_CORET']])-1, i)
mensaje = '%s;FECHA_EXPIRACION_CORET no es una fecha valida;%s' % (celdaCoordenada, valorErroneo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'FECHA_EXPIRACION': mensaje})
continue
if type(estadoValido) is not int:
valorErroneo = str(fila[columna['ESTADO']].value)
celdaCoordenada = setearCelda2(fila[0:columna['ESTADO']+1], len(fila[0:columna['ESTADO']])-1, i)
mensaje = '%s;No existe Estado;%s' % (celdaCoordenada, valorErroneo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'ERROR_ESTADO': mensaje})
continue
if type(estadoUtValido) is not int:
valorErroneo = str(fila[columna['ESTADO_ULTIMA_TAREA']].value)
celdaCoordenada = setearCelda2(fila[0:columna['ESTADO_ULTIMA_TAREA']+1], len(fila[0:columna['ESTADO_ULTIMA_TAREA']])-1, i)
mensaje = '%s;No existe EstadoUltimaTarea;%s' % (celdaCoordenada, valorErroneo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'ERROR_ESTADOUT': mensaje})
continue
if estado != 'Sin Gestion' and fechaCierre >= fechaIncioMes and fechaCierre <= fechaFinMes or estado == 'Sin Gestion' and fechaExpiracionCoret >= fechaIncioMes and fechaExpiracionCoret <= fechaFinMesSiguiente:
if ejecutivosExistentesDb.get(codigoEjecutivo):
idEmpleado = ejecutivosExistentesDb[codigoEjecutivo]['ID_EMPLEADO']
else:
celdaCoordenada = setearCelda2(fila[0:columna['ID_EMPLEADO']+1], len(fila[0:columna['ID_EMPLEADO']])-1, i)
mensaje = '%s;Ejecutivo no existe en la DB;%s' % (celdaCoordenada, codigoEjecutivo)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'RUT_NO_EXISTE': mensaje})
continue
repeticionPorCampana = 1
if filaSalidaXls.get(pk):
celdaCoordenada = setearCelda2(fila[0:columna['NRO_POLIZA']+1], len(fila[0:columna['NRO_POLIZA']])-1, i)
if estado == 'Terminado con Exito':
if filaSalidaXls[pk]['ESTADO_PRO'] != 2:
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': '{0};CAMBIO_POLIZA;ESTADO_ANTERIOR: {1}:NUEVO_VALOR:{2}'.format(celdaCoordenada, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), estado)})
repeticionPorCampana = filaSalidaXls[pk]['REPETICIONES'] + 1
filaSalidaXls.pop(pk)
elif listaConsiderarRetencion.get(estadoRetencion):
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': '{0};CAMBIO_POLIZA(RetencionDoble);ESTADO_ANTERIOR:({1},{2}):NUEVO_VALOR:({3},{4})'.format(celdaCoordenada, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), listaEstadoRetencionTexto.get(filaSalidaXls[pk]['ESTADO_RETENCION_PRO']), estado, estadoRetencion)})
repeticionPorCampana = filaSalidaXls[pk]['REPETICIONES'] + 1
filaSalidaXls.pop(pk)
if campanasPorEjecutivos[idEmpleado].get(pk):
if campanasPorEjecutivos[idEmpleado][pk]['RETENCION_ACTIVACION'] == 1 or campanasPorEjecutivos[idEmpleado][pk]['RETENCION_RL_COBRANZA'] == 1:
polizasNoAprobadas -= 1
campanasPorEjecutivos[idEmpleado].pop(pk)
cantidadCampanasValidas -= 1
else:
mensaje = '{0};POLIZA_DUPLICADA;ELIMINADO({1},{2})_vs_PERMANECE({3},{4})'.format(celdaCoordenada, estado, estadoRetencion, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), listaEstadoRetencionTexto.get(filaSalidaXls[pk]['ESTADO_RETENCION_PRO']))
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': mensaje})
filaSalidaXls[pk]['REPETICIONES'] += 1
continue
elif estado == 'Pendiente' or estado == 'Terminado sin Exito':
if filaSalidaXls[pk]['ESTADO_PRO'] != 2 and listaEstadoContactado.get(estadoUltimaTarea):
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': '{0};CAMBIO_POLIZA;ESTADO_ANTERIOR:({1},{2}):NUEVO_VALOR:({3},{4})'.format(celdaCoordenada, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), listaEstadoUtTexto.get(filaSalidaXls[pk]['ESTADO_UT_PRO']), estado, estadoUltimaTarea)})
repeticionPorCampana = filaSalidaXls[pk]['REPETICIONES'] + 1
filaSalidaXls.pop(pk)
elif filaSalidaXls[pk]['ESTADO_PRO'] == 0:
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': '{0};CAMBIO_POLIZA;ESTADO_ANTERIOR:({1},{2}):NUEVO_VALOR:({3},{4})'.format(celdaCoordenada, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), listaEstadoUtTexto.get(filaSalidaXls[pk]['ESTADO_UT_PRO']), estado, estadoUltimaTarea)})
repeticionPorCampana = filaSalidaXls[pk]['REPETICIONES'] + 1
filaSalidaXls.pop(pk)
else:
mensaje = '{0};POLIZA_DUPLICADA;ELIMINADO({1},{2})_vs_PERMANECE({3},{4})'.format(celdaCoordenada, estado, estadoUltimaTarea, getInversaEstado(filaSalidaXls[pk]['ESTADO_PRO']), listaEstadoUtTexto.get(filaSalidaXls[pk]['ESTADO_UT_PRO']))
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZA_DUPLICADA': mensaje})
filaSalidaXls[pk]['REPETICIONES'] += 1
continue
cobranzaPro = 0
pacpatPro = 0
listaConsiderarRetencion = {'Mantiene su producto': mantieneSuProducto, 'Realiza pago en línea': realizaPagoEnLinea, 'Realiza Activación PAC/PAT': realizaActivacion}
estadoRetencionValido = listaConsiderarRetencion.get(estadoRetencion)
if estado == 'Terminado con Exito':
if complementoCliente.get(numeroPoliza):
if estadoRetencionValido is None:
if nombreCampana == 'CO RET - Cobranza':
estadoRetencionValido = mantieneSuProducto
elif nombreCampana == 'CO RET - Fallo en Instalacion de Mandato':
estadoRetencionValido = realizaActivacion
valoresEntrada = {'ESTADO_RETENCION': estadoRetencionValido, 'NOMBRE_CAMPAÑA': nombreCampana, 'NUMERO_POLIZA': numeroPoliza, 'FECHA_CIERRE': fechaCierre, 'ID_EMPLEADO': idEmpleado, 'NUMERO_POLIZA_CERTIFICADO': numeroPolizaCertificado, 'CAMPAÑA_ID': campanaId, 'ESTADO_VALIDO': estadoValido, 'ESTADO_VALIDOUT': estadoUtValido, 'CELDA_NROPOLIZA': fila[columna['NRO_POLIZA']]}
cobranzaPro, pacpatPro, noAprobada = validarRetencionesPolizas(valoresEntrada, complementoCliente)
polizasNoAprobadas += noAprobada
cantidadCampanasValidas += 1
else:
if estadoRetencionValido is not None:
celdaCoordenada = setearCelda2(fila[0:columna['ESTADO']+1], len(fila[0:columna['ESTADO']])-1, i)
mensaje = '{0};ESTADO no corresponde con la RETENCION;{1}/{2}'.format(celdaCoordenada, estado, estadoRetencion)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'ESTADO_RETENCION_NO_VALIDO': mensaje})
if estadoRetencion is not None:
estadoRetencionValido = listaEstadoRetencion.get(estadoRetencion)
else:
estadoRetencionValido = validarEstadoRetencion(estado)
filaSalidaXls[pk] = {'COBRANZA_PRO': cobranzaPro, 'PACPAT_PRO': pacpatPro, 'ESTADO_PRO': estadoValido, 'ESTADO_UT_PRO': estadoUtValido, 'REPETICIONES': repeticionPorCampana, 'ESTADO_RETENCION_PRO': estadoRetencionValido, 'ID_EMPLEADO': idEmpleado, 'CAMPAÑA_ID': campanaId, 'CAMPANA': nombreCampana[0:30].rstrip(), 'POLIZA': numeroPoliza}
if insertarPeriodoCampanaEjecutivos(campanasPorEjecutivos, fechaIncioMes):
if insertarCampanaEjecutivos(campanasPorEjecutivos, fechaIncioMes):
mensaje = 'InsertarCampanaEjecutivos;Se insertaron correctamente: %s Campaña(s)' % (cantidadCampanasValidas)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'INSERTAR_CAMPANAS_EJECUTIVOS': mensaje})
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'INSERTAR_CAMPANAS_EJECUTIVOS': '-----------------------------------------------------' })
if polizasNoAprobadas > 0:
mensaje = 'InsertPolizasReliquidar;Se insertaron correctamente: %s Poliza(s)' % (polizasNoAprobadas)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'POLIZAS_RELIQUIDAR': mensaje})
polizasReliquidadaTxt = polizasReliquidadas(periodo, complementoCliente)
LOG_PROCESO_PROACTIVA.setdefault('FIN_CELDAS_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: 'Lectura de Celdas del Archivo: %s Finalizada - %s filas' % (archivoEntrada, len(tuple(hoja.rows)))})
LOG_PROCESO_PROACTIVA.setdefault('PROCESO_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: 'Proceso del Archivo: %s Finalizado' % archivoEntrada})
return filaSalidaXls, encabezadoTxt, polizasReliquidadaTxt, encabezadoReliquidacionesTxt
else:
LOG_PROCESO_PROACTIVA.setdefault('ENCABEZADO_PROACTIVA', archivo_correcto)
raise
except Exception as e:
errorMsg = 'Error: %s | %s' % (archivoEntrada, e)
LOG_PROCESO_PROACTIVA.setdefault('LECTURA_ARCHIVO', {len(LOG_PROCESO_PROACTIVA)+1: errorMsg})
LOG_PROCESO_PROACTIVA.setdefault('PROCESO_PROACTIVA', {len(LOG_PROCESO_PROACTIVA)+1: 'Error al procesar Archivo: %s' % archivoEntrada})
return False, False, False, False