﻿import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { faReply, faDownload, faSave, faTimes, faFileExcel } from '@fortawesome/free-solid-svg-icons';
import { SiteRutas, ImagenesRutas } from '../../../request/RutasConfig.jsx';
import { Notificacion } from '../../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../../components/Util/ManageError.js';
import { muestraArbolEmpleados } from '../../../components/Util/Util.jsx';
//Invocaciones datos
import { ProveedorCupon_Listar_Request, CuponEncabezado_Guardar_Request, CuponDetalle_GuardarLista_Request, CuponDetalle_ListarEn_Request, CuponDepartamento_GuardarLista, CuponEncabezado_Eliminar_Request } from "../../../request/MantenimientosRequest.jsx"
import { useSessionStorage } from '../../../components/Util/Hooks/useSessionStorage.jsx';
import ModalSpinner from '../../../components/UI/modalSpinner/modalSpinner.jsx';
import ModalErrores from '../../../components/UI/modalErrores/modalErrores.jsx';
import { Organigrama_lista_Request, Organigrama_ListarAreaDepto_Request } from '../../../request/SeguridadRequest.jsx';

//Seguridad
import Session from '../../../components/Util/session/index.jsx';
import Config from '../../../components/Util/constantes.js';
import { Obtener_MenuOpciones_Lista_Request, Obtener_MenuNombre_Request } from "../../../request/MenuRequest.jsx"
import ModalSeguridad from "../../Seguridad/ModalSeguridad.jsx";
import ModalDescripcionCarga from '../../../components/UI/modalDescripcionCarga/modalDescripcionCarga.jsx';
import optSeg from '../../../components/Util/seg-menu-opciones.js';
import CargaCuponesInt from './CargaCuponesInt.jsx';

import moment from 'moment';
import * as XLSX from "xlsx";

const CargaCupones = (props) => {
    const [listaDatos, setlistaDatos] = useState([]);
    const [listaDatosErrores, setlistaDatosErrores] = useState([]);
    const [borrando, setBorrando] = useState(false);
    const [selectedModalErrores, setselectedModalErrores] = useState(false);
    const [selectedModalDesc, setselectedModalDesc] = useState(false);
    const [id, setID] = useState(0);
    const [token, setToken] = useSessionStorage('token', '');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);

    const [checked, setchecked] = useState([]);
    const [expanded, setexpanded] = useState([]);

    const [selected, setSelected] = useState([]);
    let historyMenu = useHistory();

    const [filtro, setFiltro] = useState('');
    const [displayOrg, setDisplayOrg] = useState('unset');
    const [nodosAbiertos, setNodosAbiertos] = useState(["1"]);
    const [listaOrganigrama, setListaOrganigrama] = useState([{ id: '', name: '', isOpen: true, valor: '' }]);
    const [listaOrganigramaTree, setListaOrganigramaTree] = useState([{ id: '', value: '', label: '' }]);

    const [listaDepartamentos, setListaDepartamentos] = useState([]);

    const hiddenFileInput = React.useRef(null);

    const [Datos, setDatos] = useState({
        Nombre: { value: "", attributes: { readOnly: false, ID: '', focus: false, label: 'Nombre:', hidden: 'unset', Editando: false, maxLength: "50" } },
        fecMesAno: { value: moment().toDate(), attributes: { readOnly: false, focus: false, label: "Fecha de validez", hidden: "unset", minDate: moment("1900/01/01").toDate() } },
        Descripcion: { value: "", attributes: { readOnly: false, focus: false, label: 'Descripción', hidden: "unset", maxLength: 200 } },
        Proveedor: { value: "", attributes: { readOnly: false, focus: false, label: 'Proveedor', hidden: "unset", } },
    });
    const [listaProveedores, setlistaProveedores] = useState([]);
    const [selectedProveedor, setselectedProveedor] = useState(null);

    const columnasErrores = [
        {
            dataField: 'Cupon_Id',
            text: 'Número de Cupón',
            csvText: 'Número Cupón',
            sort: true,
            headerAlign: 'center',
            align: 'center',
            hidden: false
        },
        {
            dataField: 'MsgError',
            text: 'Errores',
            csvText: 'Errores',
            sort: true,
            headerAlign: 'center',
            align: 'center',
            hidden: false
        }
    ];

    const columnas = [
        {
            dataField: 'Cupon_Id',
            text: 'Número de Cupón',
            csvText: 'Numero Cupón',
            sort: true,
            headerAlign: 'center',
            align: 'center',
            hidden: false
        }
    ];

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnCargarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: (e) => abrirModalDesc(),
            leyenda: "",
            iclase: faFileExcel,
            tooltip: "Cargar Cupones"
        },
        {
            name: "btnGuardarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleGuardarCupones(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar Cupones"
        },
    ];

    const handleCerrarModalErr = () => {
        setselectedModalErrores(false);
    };

    const abrirModalDesc = () => {
        setselectedModalDesc(true);
    };

    const handleClick = (e) => {

        setselectedModalDesc(false);

        e.preventDefault();
        hiddenFileInput.current && hiddenFileInput.current.click();
    };

    const compararFechas = (pFecha) => {
        let resultado = false;
        let Hoy = new Date();

        const AnyoFecha = pFecha.getFullYear();
        const MesFecha = pFecha.getMonth();
        const DiaFecha = pFecha.getDate();

        const AnyoHoy = Hoy.getFullYear();
        const MesHoy = Hoy.getMonth();
        const DiaHoy = Hoy.getDate();

        if (AnyoFecha < AnyoHoy) {
            resultado = false;
        }
        else {
            if (AnyoFecha == AnyoHoy && MesFecha < MesHoy) {
                resultado = false;
            }
            else {
                if (AnyoFecha == AnyoHoy && MesFecha == MesHoy && DiaFecha < DiaHoy) {
                    resultado = false;
                }
                else {
                    resultado = true;
                }
            }
        }
        return resultado;
    };

    const handleGuardarCupones = async () => {

        let lista = listaDatos;
        let datos = Datos;

        if (lista.length > 0) {

            let revisaErrores = listaDatos.filter(item => item.MsgError !== "");

            if (revisaErrores.length > 0) {
                Notificacion.error("Existen líneas con errores.");
                return;
            }

            if (datos.Nombre.value.toString().trim() === "") {
                Notificacion.error("No se puede continuar con el proceso, ya que se necesita un nombre.");
                return;
            };

            if (datos.Descripcion.value.toString().trim() === "") {
                Notificacion.error("No se puede continuar con el proceso, ya que se necesita una descripción.");
                return;
            };

            if (!compararFechas(datos.fecMesAno.value)) {
                Notificacion.error("La fecha de validez del cupón no puede ser menor a la fecha actual.");
                return;
            };

            if (checked.length === 0) {
                Notificacion.error("Debe seleccionar al menos un departamento.");
                return;
            }

            const optSegopt = optSeg.TOpciones_Menu;
            const _value = optSegopt.Cargar.value;

            let validar = validarMenuOpcion(_value);
            if (!validar) {
                await procesoGuardarDatos();
            };

        } else {
            Notificacion.error("Debe seleccionar un archivo válido para poder cargar los cupones.");
        };

    };

    //Seguridad
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioS');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    const selectRow = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row, isSelected) => onRowSelect(row, isSelected), bgColor: '#10a599' };
    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.CargaCupones);
    }

    const onRowSelect = (row, isSelected) => {
        setID(row.Id);
    }

    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3)

        const response = await ProveedorCupon_Listar_Request(token, empresa);
        let lista = [];
        if (response.Exitoso) {

            if ((response.Datos).length > 1) {
                response.Datos.map(x => (lista.push({ value: x.Id, label: x.Nombre })));
            } else {

                if ((response.Datos).length === 1) {
                    if (response.Datos[0].Id !== 0 && response.Datos[0].Empresa !== 0) {
                        response.Datos.map(x => (lista.push({ value: x.Id, label: x.Nombre })));
                    } else {
                        Notificacion.error("Lo sentimos, no existen proveedores de cupones asociados a esta empresa.");
                        volverAtras();
                    }
                } else {
                    Notificacion.error("Lo sentimos, no existen proveedores de cupones asociados a esta empresa.");
                    volverAtras();
                }

            }

            setlistaProveedores(lista);
            setselectedProveedor(lista[0]);
        }
        else {
            const _login = manageError(response, props, '');
            spinnerModalMostrar(false, '', 3);
            setlistaProveedores([]);
            if (_login) { return false; };
        }

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.ProveedorCupon.value);
        let _menuId = 0;

        if (_MenuNomb.ID != undefined) {
            _menuId = _MenuNomb.ID;
        }
        const _UsuarioS = usuarioS;
        let _menuOpciones = null;
        if (_menuId > 0) {
            _menuOpciones = await cargarMenuOpciones(Config.Modulo, _UsuarioS, _menuId);
        }
        setMenuId(_menuId), setMenuOpciones(_menuOpciones);

        const responseOrR = await cargaArbolR();

        let _ArrayDatos = [];
        cargaNodeAbiertos(responseOrR, _ArrayDatos);
        setListaOrganigramaTree(responseOrR);
        setListaOrganigrama(responseOrR);
        setNodosAbiertos(_ArrayDatos);

        spinnerModalMostrar(false, '', 3)
    };

    const cargaNodeAbiertos = (pDatos, pArray) => {
        let arrayAbierto = pArray;
        for (let j = 0, len = pDatos.length; j < len; j++) {
            pArray.push(`${pDatos[j].id.toString()}`);
            let _arrayD = cargaNodeAbiertos(pDatos[j].children, pArray);
        }
        return pArray;
    };

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => {
            await cargarDatos(false)
        }
        carga()
    }, []);

    const cargaArbolR = async () => {
        //try {

        let responseOr = await Organigrama_ListarAreaDepto_Request(token, empresa);// await organigrama_lista(pEmpresa); 

        if (responseOr.Exitoso) {
            //Notificacion.success("", "Se ha iniciado sesión en empresa lista organigrama.");
        }
        else {
            const _login = manageError(responseOr, props, '');
            if (!_login) { history.push(SiteRutas.Login); }
            return false;

        }
        let _Menu = responseOr.Datos;//.data;
        let _arbolPadre = _Menu.filter(item => item.PadreID === 0);
        let subMenu = [];

        // siempre va tener el home
        let arrayAbierto = [];
        for (let j = 0, len = _arbolPadre.length; j < len; j++) {
            arrayAbierto.push(`${_arbolPadre[j].ID.toString()}`);
            //arrayAbierto.push(`${_arbolPadre[j].ID.toString()}`);
            let _arbolHijo = _Menu.filter(item => item.PadreID === _arbolPadre[j].ID);
            //arma el menu principal
            let _hijo = [];
            //arma los menues hijos
            if (_arbolHijo.length > 0) {
                _hijo = cargaSubArbolR(_arbolHijo, _Menu, _arbolPadre[j].ID, arrayAbierto, _arbolPadre[j].ID.toString());
            }

            subMenu.push({ id: _arbolPadre[j].Composicion, label: _arbolPadre[j].Nombre, isOpen: true, children: _hijo, value: _arbolPadre[j].Composicion });
        };

        //setNodosAbiertos(arrayAbierto);
        return subMenu;
        //  }
        //  catch (err) {

        //  }
    };

    const cargaSubArbolR = (lstSubArbol, lstArbol, pRaiz, pAbierto, pRuta) => {
        let _submenu = [];
        let _hijo = [];

        for (let j = 0, len = lstSubArbol.length; j < len; j++) {
            let _Ruta = `${lstSubArbol[j].ID.toString()}`
            pAbierto.push(_Ruta);
            let _arbolHijo = lstArbol.filter(item => item.PadreID === lstSubArbol[j].ID);
            _submenu = cargaSubArbolR(_arbolHijo, lstArbol, lstSubArbol[j].ID, pAbierto, _Ruta);
            _hijo.push({ id: lstSubArbol[j].Composicion, label: lstSubArbol[j].Nombre, isOpen: true, children: _submenu, value: lstSubArbol[j].Composicion });
        }

        return _hijo;
    }

    const handleselectProveedor = (selProveedor) => {
        //console.log("__");
        setselectedProveedor(selProveedor);
    };

    //Seguridad
    const cargarMenuOpciones = async (pModuloId, pUsuarioId, pMenuId) => {
        try {

            let listMO = await Obtener_MenuOpciones_Lista_Request(token, pModuloId, pUsuarioId, pMenuId);
            if (listMO.Exitoso === false) {
                manageError(listMO, props);
                return null;
            }
            return listMO.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuOpciones`);
        }
    }

    const cargarMenuNombre = async (pModulo, pMenuNombre) => {
        try {
            let listMON = await Obtener_MenuNombre_Request(token, pModulo, pMenuNombre);
            if (listMON.Exitoso == false) {
                manageError(listMON, props);
                return null;
            }
            return listMON.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuNombre`);
        }
    }

    const validarMenuOpcion = (pOpcion) => {
        let validar = false;
        let _menuOpciones = menuOpciones;
        const optSegopt = optSeg.TOpciones_Menu;
        let resultado = _menuOpciones.filter((item) => item.Opcion_Nombre == pOpcion);
        if (resultado.length > 0) {
            if (resultado[0].Opcion_Validar) {
                setShowModalSeguridad(true); setOpcionValidar(resultado[0].Opcion_Id); setOpcionValidarNombre(pOpcion);
                validar = true;
            }
        } else {
            setShowModalSeguridad(true); setOpcionValidar(resultado[0].Opcion_Id); setOpcionValidarNombre(pOpcion);
            validar = true;
        }
        return validar;
    };

    const handleCerrarModal = () => setShowModalSeguridad(false);

    const onActionResultModal = (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.Cargar.value:
                    procesoGuardarDatos();
                    break;
                default:
                    break;
            }
        }
    };

    const procesoGuardarDatos = async () => {

        let spinnerLabel = "Guardando Datos...";
        spinnerModalMostrar(true, spinnerLabel, 3);

        let listaVerifica = listaDatos, arrayRevisa = [];

        for (let i in listaVerifica) {
            arrayRevisa.push(listaVerifica[i].Cupon_Id);
        }

        arrayRevisa = JSON.stringify(arrayRevisa).replace("[", "").replace("]", "").replace(/"/g, "'");

        const proveedorId = selectedProveedor.value;

        let revisaCuponesRepetidos = await CuponDetalle_ListarEn_Request(token, empresa, proveedorId, arrayRevisa);

        if (revisaCuponesRepetidos.Exitoso) {
            let errores = 0, arrayErrores = [];
            for (let i in listaVerifica) {

                if (listaVerifica[i] !== undefined) {
                    const repetidos = (revisaCuponesRepetidos.Datos).filter(item => (item.Cupon_Id).toLowerCase() === (listaVerifica[i].Cupon_Id).toLowerCase());

                    if (repetidos.length > 0) {
                        listaVerifica[i].MsgError = "Este Cupón ya fue cargado anteriormente por el mismo proveedor.";
                        arrayErrores.push(listaVerifica[i])
                        errores++;
                    }
                }
            }

            if (errores > 0) {
                setlistaDatos([]);
                setlistaDatosErrores(arrayErrores);
                spinnerModalMostrar(false, "", 3);
                setselectedModalErrores(true);
                return;
            }

        } else {
            Notificacion.error("Sucedió un error al analizar los cupones. Inténtelo nuevamente.");
            volverAtras();
        }

        let resGuardarEnc = await guardarEncabezado(proveedorId);

        if (resGuardarEnc[0].Exitoso) {

            let detalle = await guardarDetalle(resGuardarEnc[0].Carga_Id, proveedorId);

            if (detalle) {
                //Continuar con el proceso
                let deptos = await guardarDepartamentos(resGuardarEnc[0].Carga_Id);

                if (deptos) {
                    Notificacion.success("Se guardó la información de los cupones correctamente");
                    volverAtras();
                } else {
                    //borrar encabezado y cupones
                    Notificacion.error("Sucedió un error al agregar los departamentos.");
                    volverAtras();
                }

            } else {
                //Borrar encabezado
                await CuponEncabezado_Eliminar_Request(token, empresa, resGuardarEnc[0].Carga_Id, proveedorId);
                Notificacion.error("Sucedió un error al guardar los detalles de los cupones.");
                volverAtras();
            }

        } else {
            Notificacion.error(`Sucedió un error al guardar los datos del encabezado. Error: ${resGuardarEnc[0].Mensaje}`);
        };

        spinnerModalMostrar(false, "", 3);

    };

    const guardarEncabezado = async (pProveedorId) => {

        const NombreCupon = Datos.Nombre.value;
        const Descripcion = Datos.Descripcion.value;
        const FechaValidez = Datos.fecMesAno.value;
        let Carga_Id = 0, resExitoso = false;

        let resultado = await CuponEncabezado_Guardar_Request(token, empresa, pProveedorId, NombreCupon, Descripcion, FechaValidez, usuario);

        if (resultado.Exitoso === true) {
            Carga_Id = resultado.Mensaje.toString().trim();
        }
        else {
            if (isNaN(resultado.Mensaje.trim())) {
                const _login = manageError(resultado, props, 'Error: ');
                if (_login) {
                    resExitoso = false;
                }
            }
            else {
                Carga_Id = resultado.Mensaje.toString().trim();
                resExitoso = true;
            }
        }

        let respuesta = [{ "Exitoso": resExitoso, "Carga_Id": Carga_Id, "Mensaje": resultado.Mensaje }];
        return respuesta
    };

    const guardarDetalle = async (pCarga_Id, pProveedorId) => {

        let listaCupones = listaDatos;
        let listaDinamica = [];

        for (let i in listaCupones) {

            let fila = generarItemDetalle();

            fila.Carga_Id = pCarga_Id;
            fila.Empresa = empresa;
            fila.Proveedor_Id = pProveedorId;
            fila.Cupon_Id = listaCupones[i].Cupon_Id;

            listaDinamica.push(fila);

        }

        let resultado = await CuponDetalle_GuardarLista_Request(token, listaDinamica);

        if (resultado.Exitoso) {
            return true;
        } else {
            return false;
        }

    };

    const guardarDepartamentos = async (pCarga_Id) => {

        let listaDeptos = checked;
        let listaDinamica = [];

        for (let i in listaDeptos) {

            let item = elementoNodo();
            let arrayString = (listaDeptos[i].split("D"))

            item.Empresa = empresa;
            item.Carga_Id = pCarga_Id;
            item.Usuario_Modifica = usuario;
            item.Area = arrayString[0].replace("A", "");
            item.Departamento = arrayString[1];

            listaDinamica.push(item);
        }

        let resultado = await CuponDepartamento_GuardarLista(token, listaDinamica);

        if (resultado.Exitoso) {
            return true;
        } else {
            return false;
        }

    };

    const elementoNodo = () => {
        return {
            Empresa: 0,
            Usuario_Modifica: "",
            Carga_Id: 0,
            Area: 0,
            Departamento: 0
        };
    };

    const guardarDepartamentos_bak = async (pCarga_Id) => {

        let listaDeptos = checked;
        let listaDinamica = [];

        for (let i in listaDeptos) {
            listaDeptos[i].Empresa = empresa;
            listaDeptos[i].Usuario_Modifica = usuario;
            listaDeptos[i].Carga_Id = pCarga_Id;

            listaDinamica.push(listaDeptos[i]);
        }

        let resultado = await CuponDepartamento_GuardarLista(token, listaDinamica);

        if (resultado.Exitoso) {
            return true;
        } else {
            return false;
        }

    };

    const cargaArchivoExcel = (e) => {
        e.preventDefault();

        if (e.target.files != undefined) {

            let files = e.target.files, f = files[0];
            let reader = new FileReader();
            let self = this;
            const exts = { '.xls': 1, '.xlsx': 1 };
            let re = /\..+$/;
            let ext = f.name.match(re);
            if (exts[ext]) {
                reader.onload = function (e) {
                    var data = e.target.result;
                    let readedData = XLSX.read(data, { type: 'binary' });
                    const wsname = readedData.SheetNames[0];
                    const ws = readedData.Sheets[wsname];

                    const dataParse = XLSX.utils.sheet_to_json(ws, { header: 1 });

                    leerArchivoExcel(dataParse)

                };
            } else {
                //setListaDatosDetalle([]);
                Notificacion.warning('Dede seleccionar un archivo del tipo xls o xlsx');
                e.value = '';
            }
            reader.readAsBinaryString(f);
        }
        e.target.value = '';
    };

    const generarItem = () => {

        return {
            Cupon_Id: "",
            MsgError: ""
        };
    };

    const generarItemDetalle = () => {

        return {
            Empresa: "",
            Carga_Id: "",
            Proveedor_Id: "",
            Cupon_Id: "",
        };
    };

    const leerArchivoExcel = (dataParse) => {
        const _Datos = { ...listaDatos };
        let errores = 0;

        try {

            let _listaDatos = [], arrayErrores = [];

            for (let i = 1; i < dataParse.length; i++) {

                if (dataParse[i][0] !== undefined) {

                    let fila = generarItem();
                    let error = "";
                    let cuentaErrorCiclo = 0;

                    fila.Cupon_Id = dataParse[i][0].toString().trim();

                    const repetidos = _listaDatos.filter(item => (item.Cupon_Id).toLowerCase() === (fila.Cupon_Id).toLowerCase());

                    if (repetidos.length > 0) {
                        errores++;
                        cuentaErrorCiclo++;
                        fila.MsgError = "El número de cupón está repetido.";
                    }

                    if (fila.Cupon_Id.length > 30) {
                        errores++;
                        cuentaErrorCiclo++;
                        fila.MsgError = `${fila.MsgError} El número del cupón excede el largo establecido.`
                    }

                    if (cuentaErrorCiclo > 0) {

                        let revisaArrayErrores = arrayErrores.filter(item => (item.Cupon_Id).toLowerCase() === (fila.Cupon_Id).toLowerCase());

                        if (revisaArrayErrores.length === 0) {
                            arrayErrores.push(fila);
                        } else {

                            if (cuentaErrorCiclo > 1) {
                                if (!(revisaArrayErrores[0].MsgError.includes(fila.MsgError))) {
                                    for (let i in arrayErrores) {
                                        if (arrayErrores[i].Cupon_Id === fila.Cupon_Id) {
                                            arrayErrores[i].MsgError = fila.MsgError;
                                        }
                                    }
                                }
                            } else {
                                if (!(revisaArrayErrores[0].MsgError.includes(fila.MsgError))) {
                                    for (let i in arrayErrores) {
                                        if ((arrayErrores[i].Cupon_Id).toLowerCase() === (fila.Cupon_Id).toLowerCase()) {
                                            arrayErrores[i].MsgError = `${arrayErrores[i].MsgError} ${fila.MsgError}`;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _listaDatos.push(fila)
                }

            }

            if (errores === 0) {
                setlistaDatos([]);
                setlistaDatos(_listaDatos);
            } else {
                setlistaDatos([]);
                setlistaDatosErrores(arrayErrores);
                setselectedModalErrores(true);
            }

        } catch (ex) {
            // console.log(ex);
            Notificacion.error(`Ocurrió un error procesando el archivo`);
        }
    };

    const cellEdit = { mode: "click", autoSelectText: true, blurToSave: true };

    const onChangeInput = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        let newAttributes = Datos[name].attributes;

        const newDatos = Object.assign({}, Datos, { [name]: { value: value, attributes: newAttributes } })
        setDatos(newDatos);
    };

    const onhandleChangeDate = async (date, id) => {
        const name = id;
        const value = date;
        let newAttributes = Datos[name].attributes;

        const _Datos = Object.assign({}, Datos, { [name]: { value: value, attributes: newAttributes } });

        setDatos(_Datos);

    };

    const pruebaCheck = (pCheck, targetNode) => {
        setListaDepartamentos(pCheck);
        setchecked(pCheck);
    }

    const pruebaExp = (pCheck) => {
        setexpanded(pCheck);
    }

    return (
        <Fragment>
            <CargaCuponesInt
                titulo={'Carga de Cupones'}
                id={"Cupon_Id"}
                listaDatos={listaDatos}
                Datos={Datos}
                columnas={columnas}
                selectRow={selectRow}
                borrando={borrando}
                botones={botones}
                verLHOC={false}
                nombreCSV={"ProveedorCupon"}
                cellEdit={cellEdit}
                hiddenFileInput={hiddenFileInput}
                cargaArchivoExcel={cargaArchivoExcel}
                onChangeInput={onChangeInput}
                onhandleChangeDate={onhandleChangeDate}
                listaProveedores={listaProveedores}
                selectedProveedor={selectedProveedor}
                handleselectProveedor={handleselectProveedor}

                lstOrganigrama={listaOrganigrama}
                filtro={filtro}
                displayOrg={displayOrg}
                nodosAbiertos={nodosAbiertos}
                selected={selected}
                listaOrganigramaTree={listaOrganigramaTree}
                checked={checked}
                expanded={expanded}
                pruebaCheck={pruebaCheck}
                pruebaExp={pruebaExp}
            />

            <ModalErrores
                selectedModal={selectedModalErrores}
                datos={listaDatosErrores}
                columnas={columnasErrores}
                id={"Cupon_Id"}
                label={"Errores en la carga"}
                selectRow={selectRow}
                cellEdit={cellEdit}
                botones={[]}
                cerrarModal={handleCerrarModalErr}
            />

            <ModalDescripcionCarga
                selectedModal={selectedModalDesc}
                contentLabel={'spinnerModalProgress'}
                label={"Descripción del archivo xls:"}
                imgDescripcion={ImagenesRutas.AyudaExcelCargaCup}
                cerrarModal={handleClick}
            />

            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'selectedDescripcionCarga'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </Fragment>
    );
};
export default withRouter(memo(CargaCupones))