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 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 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 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 extraerBaseCertificacion(archivoCertificacionXls, fechaInicioPeriodo,
fechaFinMes):
archivo = archivoCertificacionXls
archivoBaseCertificacion = REACTIVA_CONFIG_XLSX[
'ARCHIVO_BASE_CERTIFICACION']
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'INICIO_BASE_CERTIFICACION':
'Iniciando proceso de lectura del Archivo: %s' % archivo
})
try:
encabezadoXls = archivoBaseCertificacion['ENCABEZADO']
celda = archivoBaseCertificacion['COLUMNAS']
xls = load_workbook(archivo, read_only=True, data_only=True)
nombre_hoja = xls.sheetnames
hoja = xls[nombre_hoja[0]]
baseCertificado = dict()
i = 0
validarArchivo = validarEncabezadoXlsx(hoja['A1:X1'], encabezadoXls,
archivo)
if type(validarArchivo) is not dict:
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'ENCABEZADO_BASE_CERTIFICACION':
'Encabezado del Archivo: %s OK' % archivo
})
for fila in tqdm(iterable=hoja.rows,
total=len(tuple(hoja.rows)),
desc='Leyendo BaseCertificacion',
unit=' Fila'):
i += 1
if i >= 2:
numeroPoliza = fila[celda['NRO_POLIZA']].value
idEmpleado = fila[celda['ID_EMPLEADO']].value
canal = str(fila[celda['CANAL']].value)
tipoCertificacion = str(
fila[celda['TIPO_CERTIFICACION']].value)
fechaLlamado = setearFechaCelda(
fila[celda['FECHA_LLAMADO']])
if numeroPoliza is None:
celdaCoordenada = setearCelda2(
fila[celda['NRO_POLIZA']], 0)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'POLIZA_NULO':
'%s;Numero de poliza NULL BaseCertificado;%s' %
(celdaCoordenada, numeroPoliza)
})
continue
if tipoCertificacion.upper() != 'GRABACIÓN CERTIFICADA':
continue
if type(fechaLlamado) is not datetime.date:
valorErroneo = fila[celda['FECHA_LLAMADO']].value
celdaCoordenada = setearCelda2(
fila[0:celda['FECHA_LLAMADO'] + 1],
len(fila[0:celda['FECHA_LLAMADO']]) - 1, i)
mensaje = '%s;FECHA_LLAMADO no es una fecha valida;%s' % (
celdaCoordenada, valorErroneo)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'FECHA_LLAMADO': mensaje})
continue
if fechaLlamado < fechaInicioPeriodo or fechaLlamado > fechaFinMes:
continue
pk = '{0}_{1}'.format(str(numeroPoliza), str(idEmpleado))
if baseCertificado.get(pk):
if baseCertificado[pk]['FECHA_LLAMADO'] >= fechaLlamado:
continue
baseCertificado[pk] = {
'NRO_POLIZA': int(numeroPoliza),
'FECHA_LLAMADO': fechaLlamado,
'ID_EMPLEADO': str(idEmpleado),
'CANAL': canal,
'TIPO_CERTIFICACION': tipoCertificacion
}
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1, {
'LECTURA_BASE_CERTIFICACION':
'Lectura del Archivo: %s Finalizado - %s Filas' %
(archivo, len(tuple(hoja.rows)))
})
return baseCertificado
else:
LOG_PROCESO_REACTIVA.setdefault('ENCABEZADO_BASE_CERTIFICACION',
validarArchivo)
raise
except Exception as e:
errorMsg = 'Error al leer archivo;%s | %s' % (archivo, e)
LOG_PROCESO_REACTIVA.setdefault(
len(LOG_PROCESO_REACTIVA) + 1,
{'LECTURA_BASE_CERTIFICACION': errorMsg})
raise
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 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
def validarRetencionesPolizas(valoresEntrada: dict, complementoCliente: dict):
estadoRetencion = valoresEntrada['ESTADO_RETENCION']
nombreCampana = valoresEntrada['NOMBRE_CAMPAÑA']
numeroPoliza = valoresEntrada['NUMERO_POLIZA']
idEmpleado = valoresEntrada['ID_EMPLEADO']
numeroPolizaCertificado = valoresEntrada['NUMERO_POLIZA_CERTIFICADO']
fechaCierre = valoresEntrada['FECHA_CIERRE']
campanaId = valoresEntrada['CAMPAÑA_ID']
estadoValido = valoresEntrada['ESTADO_VALIDO']
estadoUtValido = valoresEntrada['ESTADO_VALIDOUT']
celdaNroPoliza = valoresEntrada['CELDA_NROPOLIZA']
cobranzaPro = 0
pacpatPro = 0
seReliquida = 0
polizaNoAprobada = 0
controPolizaNoAprobada = False
if nombreCampana == 'CO RET - Cobranza' and estadoRetencion == realizaActivacion:
cobranzaPro = 1
pacpatPro = 1
elif nombreCampana == 'CO RET - Fallo en Instalacion de Mandato' and estadoRetencion == mantieneSuProducto:
cobranzaPro = 1
pacpatPro = 1
elif nombreCampana == 'CO RET - Cobranza' and estadoRetencion == mantieneSuProducto or nombreCampana == 'CO RET - Cobranza' and estadoRetencion == realizaPagoEnLinea:
cobranzaPro = 1
elif nombreCampana == 'CO RET - Fallo en Instalacion de Mandato' and estadoRetencion == realizaPagoEnLinea:
cobranzaPro = 1
elif nombreCampana == 'CO RET - Fallo en Instalacion de Mandato' and estadoRetencion == realizaActivacion:
pacpatPro = 1
fecUltimoPago = complementoCliente[numeroPoliza]['FEC_ULT_PAG']
numeroPolizaCliente = complementoCliente[numeroPoliza]['NRO_CERT']
pk2 = '{0}_{1}_{2}'.format(campanaId, idEmpleado, numeroPoliza)
valoresPoliza = {'ID_EMPLEADO': idEmpleado, 'NUMERO_POLIZA': numeroPoliza, 'CAMPAÑA_ID': campanaId, 'NOMBRE_CAMPAÑA': nombreCampana, 'ESTADO_RETENCION': estadoRetencion, 'RETENCION_COBRANZA': 0, 'RETENCION_ACTIVACION': 0, 'RETENCION_RL_COBRANZA': 0, 'RETENCION_RL_ACTIVACION': 0, 'ESTADO_VALIDO': estadoValido, 'ESTADO_VALIDOUT': estadoUtValido, 'FECHA_CIERRE': fechaCierre, 'RELIQUIDACION': seReliquida, 'NUMERO_POLIZA_CERTIFICADO': numeroPolizaCertificado}
agregarCampanasPorEjecutivo(idEmpleado, pk2, valoresPoliza)
if cobranzaPro > 0:
cobranzaPro = aprobarCobranza(numeroPolizaCertificado, fechaCierre, numeroPolizaCliente, fecUltimoPago)
if cobranzaPro == 0:
if campanasPorEjecutivos[idEmpleado].get(pk2):
campanasPorEjecutivos[idEmpleado][pk2]['RETENCION_RL_COBRANZA'] = 1
campanasPorEjecutivos[idEmpleado][pk2]['RELIQUIDACION'] = 1
controPolizaNoAprobada = True
celdaCoordenada = setearCelda2(celdaNroPoliza, 0)
mensaje = '%s;Poliza no cumple condicion de retencion COBRANZA;%s' % (celdaCoordenada, numeroPoliza)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'PROCESO_COBRANZA': mensaje})
else:
campanasPorEjecutivos[idEmpleado][pk2]['RETENCION_COBRANZA'] = cobranzaPro
if pacpatPro > 0:
estadoMandato = complementoCliente[numeroPoliza]['ESTADO_MANDATO']
fecMandato = complementoCliente[numeroPoliza]['FECHA_MANDATO']
if estadoMandato is not None:
pacpatPro = aprobarActivacion(str(estadoMandato).upper(), fecMandato, fechaCierre)
mensajeValidacion = 'MANDATOS'
else:
pacpatPro = aprobarCobranza(numeroPolizaCertificado, fechaCierre, numeroPolizaCliente, fecUltimoPago)
mensajeValidacion = 'MANDATOS/COBRANZA'
if pacpatPro == 0:
if campanasPorEjecutivos[idEmpleado].get(pk2):
campanasPorEjecutivos[idEmpleado][pk2]['RETENCION_RL_ACTIVACION'] = 1
campanasPorEjecutivos[idEmpleado][pk2]['RELIQUIDACION'] = 1
controPolizaNoAprobada = True
celdaCoordenada = setearCelda2(celdaNroPoliza, 0)
mensaje = '{0};Poliza no cumple condicion de retencion {1};{2}'.format(celdaCoordenada, mensajeValidacion, numeroPoliza)
LOG_PROCESO_PROACTIVA.setdefault(len(LOG_PROCESO_PROACTIVA)+1, {'PROCESO_COBRANZA': mensaje})
else:
campanasPorEjecutivos[idEmpleado][pk2]['RETENCION_ACTIVACION'] = pacpatPro
if controPolizaNoAprobada:
polizaNoAprobada = 1
return cobranzaPro, pacpatPro, polizaNoAprobada