コード例 #1
0
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
コード例 #2
0
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
コード例 #3
0
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
コード例 #4
0
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
コード例 #5
0
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
コード例 #6
0
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
コード例 #7
0
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
コード例 #8
0
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
コード例 #9
0
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