import { Fragment, memo, useState, useEffect, useRef } from 'react';
import React from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { faReply, faPlus, faSave, faSync, faTimes, faFileExcel } from '@fortawesome/free-solid-svg-icons';
import { SiteRutas, ImagenesRutas } from '../../../request/RutasConfig.jsx';
import { Notificacion } from '../../../components/Util/Notificacion/Notificacion.jsx';
//Invocaciones datos
import { Presupuesto_Listar_Request, Presupuesto_GuardarLista_Request, Presupuesto_EliminarLista_Request } from "../../../request/MantenimientosRequest.jsx"
import PresupuestoInt from './presupuestoInt.jsx';

import { useSessionStorage } from '../../../components/Util/Hooks/useSessionStorage.jsx';
import ModalSpinner from '../../../components/UI/modalSpinner/modalSpinner.jsx';
import Swal from 'sweetalert2';
import { validarDecimal, validaCuenta, datosArbol, farmatearMontos } from '../../../components/Util/Util.jsx';

//Seguridad
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 optSeg from '../../../components/Util/seg-menu-opciones.js';
import { Empresa_Consulta_Request } from "../../../request/SeguridadRequest.jsx";
import { Catalogo_Lista_Request, CentroCostos_CentroDefault_Request, CentroCosto_Lista_CCC_Request, CentroCosto_Lista_CXCCEmpresa_Request, CentroCosto_Lista_CXCC_Request } from '../../../request/ServicioRequest.jsx';
import ModalBusqueda from '../../../components/UI/modalBusqueda/modalBusqueda.jsx';
import ModalBusquedaTree from '../../../components/UI/modalBusqueda/modalBusquedaTree.jsx';
import ModalPresupuesto from '../../../components/UI/modalPresupuesto/modalPresupuesto.jsx';

import * as XLSX from "xlsx";
import moment from 'moment/moment.js';

import ModalDescripcionCarga from '../../../components/UI/modalDescripcionCarga/modalDescripcionCarga.jsx';

export function ListaPresupuesto() {

    const [id, setID] = useState('');
    const [datos, setDatos] = useState([]);
    const [datosEmpresa, setDatosEmpresa] = useState([]);
    const hiddenFileInput = React.useRef(null);
    const [listCXCC, setListCXCC] = useState([]);
    const [listaDatos, setListaDatos] = useState([]);
    const [listCCosto, setListCCosto] = useState([]);
    const [listCuentas, setListCuentas] = useState([]);
    const [listaDatosExcel, setListaDatosExcel] = useState([]);
    const [listCentroCosto, setListCentroCosto] = useState([]);
    const [listCuentasCont, setListCuentasCont] = useState([]);
    const [listaAccionesSel, setListaAccionesSel] = useState([]);
    const [listCentroCostoFiltro, setListCentroCostoFiltro] = useState([]);

    const mounted = useRef();
    let historyMenu = useHistory();
    const tablest = { width: '100%' };
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const cuentaright = { textAlign: 'right', width: '20%' };
    const cuentacenter = { textAlign: 'center', width: '80%' };
    const [token, setToken] = useSessionStorage('tokenCON', '');
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [usuario, setUsuario] = useSessionStorage('usuarioCON');
    const [empresa, setEmpresa] = useSessionStorage('empresaCON', 0);
    const [empresaNombre, setEmpresaNombre] = useSessionStorage('empresaNombreCON');

    const [indexC, setIndexC] = useState(undefined);
    const [pColumn, setPColumn] = useState(undefined);
    const [indexCost, setIndexCost] = useState(undefined);
    const [rowsSelected, setRowSelected] = useState(undefined);
    const [selectModalTree, setSelectModalTree] = useState(false);
    const [selectedCuenta, setSelectedCuenta] = useState(undefined);
    const [selectModalBusqueda, setSelectModalBusqueda] = useState(false);
    const [selectedCentroCosto, setSelectedCentroCosto] = useState(undefined);

    const Header = [
        { title: 'Centro Costo', field: 'CentroCosto' },
        { title: 'Nombre', field: 'Nombre' },
        { title: 'id', field: 'ID', hidden: true },
    ]

    const columnas = [
        {
            dataField: 'Nombre', text: 'Nombre', csvText: 'Nombre', sort: true, footer: '',
            editable: true, validator: (newValue, row, column) => {
                const valido = validaCuentaTabla(newValue, row, column);
                return valido;
            },
            formatter: (e, column, columnIndex, row, rowIndex) => {
                const _llaveCta = column.llave;
                const campo =
                    <table style={tablest}>
                        <tbody>
                            <tr style={tablest}>
                                <td id={_llaveCta} style={cuentacenter}>{column.Nombre}</td>
                                <td style={cuentaright} > <a type="button" className='hoverBtn' onClick={() => { handleCuentaModal(column, columnIndex, row, rowIndex) }} ><i className="fa fa-search"></i></a></td>
                            </tr>
                        </tbody>
                    </table>
                return campo;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '130px' };
            },
        },
        {
            dataField: 'Nombre_Centro_Costo', text: 'Centro Costo', csvExport: false, sort: true, editable: true, footer: '',
            validator: (newValue, row, column) => {
                return onValidarCCosto(newValue, row, column);
            },
            formatter: (e, column, columnIndex, row, rowIndex) => {
                const _llave = column.llave + 'B';
                const campo =
                    <table style={tablest}>
                        <tbody>
                            <tr style={tablest}>
                                <td className='text-right' id={_llave} > {column.Nombre_Centro_Costo} </td>
                                <td className='text-right' > <a className='hoverBtn' type="button" onClick={() => { handleModal(column, columnIndex) }} ><i className="fa fa-search"></i></a></td>
                            </tr>
                        </tbody>
                    </table>
                return campo;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '130px' };
            },

        },
        {
            dataField: 'Saldo_01',
            text: 'Enero',
            csvText: 'Enero',
            classes: "ColumnText",
            sort: true,
            align: "right",
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column, row, column);
                return valido;
            },
        },
        {
            dataField: 'Saldo_02',
            text: 'Febrero',
            csvText: 'Febrero',
            classes: "ColumnText",
            sort: true,
            align: "right",
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
        },
        {
            dataField: 'Saldo_03',
            text: 'Marzo',
            csvText: 'Marzo',
            classes: "ColumnText",
            sort: true,
            align: "right",
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
        },
        {
            dataField: 'Saldo_04',
            text: 'Abril',
            csvText: 'Abril',
            classes: "ColumnText",
            sort: true,
            align: "right",
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
        },
        {
            dataField: 'Saldo_05',
            text: 'Mayo',
            csvText: 'Mayo',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_06',
            text: 'Junio',
            csvText: 'Junio',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_07',
            text: 'Julio',
            csvText: 'Julio',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_08',
            text: 'Agosto',
            csvText: 'Agosto',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_09',
            text: 'Setiembre',
            csvText: 'Setiembre',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_10',
            text: 'Octubre',
            csvText: 'Octubre',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_11',
            text: 'Noviembre',
            csvText: 'Noviembre',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        },
        {
            dataField: 'Saldo_12',
            text: 'Diciembre',
            csvText: 'Diciembre',
            classes: "ColumnText",
            sort: true,
            align: "right",
            validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row, column);
                return valido;
            },
            headerStyle: (colum, colIndex) => {
                return { width: '170px' };
            },
        }];

    const columnasExcel = [

        {
            dataField: 'Nombre',
            text: 'Cuenta',
            csvText: 'Cuenta',
            sort: true,
        },
        {
            dataField: 'Centro_Costo_Excel',
            text: 'Centro Costo',
            csvText: 'Centro_Costo',
            sort: true,
        },
        {
            dataField: 'NombreCuenta',
            text: 'Nombre',
            csvText: 'Nombre',
            sort: true,
        },
        {
            dataField: 'Error',
            text: 'Error',
            csvText: 'Error',
            sort: true,
        }
    ];

    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) => validarCargarNuevoPresupuesto(e),
            leyenda: "",
            iclase: faFileExcel,
            tooltip: "Cargar"
        },
        {
            name: "btnGuardarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => validarGuardarDatos(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        },
        {
            name: "btnRefrescarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => validarRefrescar(),
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        },
    ]

    const botonesExcel = [
        {
            name: "btnSalirC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleCerrarModalExcel(),
            leyenda: "",
            iclase: faTimes,
            tooltip: "Salir"
        },
        {
            name: "btnGuardarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => validarGuardarDatosExcel(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        },
    ]

    const onFormato = (valor) => {
        return farmatearMontos(valor);
    }

    const handleCuentaModal = (cell, columnIndex, row, rowIndex) => {

        const indexC = datos.findIndex((element) => element.ID === cell.ID);

        setIndexC(indexC);
        setSelectModalTree(true);
        setPColumn(cell);
    }

    //Seguridad
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioSCON');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [showModalExcel, setShowModalExcel] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');
    const [selectedModalDesc, setselectedModalDesc] = useState(false);

    const selectRow = {
        mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row, isSelect, rowIndex, e) => {
            onRowSelectList(row);
        }, clickToEdit: true, bgColor: '#d73220', style: { color: '#ffffff' }
    };

    const selectRowExcel = {
        mode: 'checkbox', clickToSelect: true, hideSelectColumn: false,
        onSelect: (row, isSelect) => onRowSelect(row, isSelect), clickToEdit: true,
        onSelectAll: (isSelect, rows) => handleOnSelectAllDet(isSelect, rows), bgColor: '#d73220', style: { color: '#ffffff' }
    };

    const cellEdit = { mode: "click", autoSelectText: true, blurToSave: true };

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const cargarNuevoPresupuesto = (e) => {
        e.preventDefault();
        hiddenFileInput.current && hiddenFileInput.current.click();
    }

    const guardarDatos = async (pDatos) => {

        let spinnerLabel = 'Actualizando datos'
        spinnerModalMostrar(true, spinnerLabel, 3);

        const response = await Presupuesto_Listar_Request(token, datosEmpresa.Id, 0, 0);

        let cuentaCC = 0;
        let arrayDatos = pDatos;

        for (let i in arrayDatos) {
            let fecha = (moment().format("yyyy-MM-DD hh:mm:ss.SSS"));

            arrayDatos[i].Fecha_Actualizacion = fecha.toString();

            if (arrayDatos[i].Nombre_Centro_Costo === "") {
                cuentaCC++;
            }

            for (let j in arrayDatos[i]) {
                if (j.toString().startsWith("Saldo_")) {
                    arrayDatos[i][j] = arrayDatos[i][j].toString().replace(/,/g, "");
                }
            }
        }

        if (cuentaCC > 0) {
            Notificacion.error("No puede existir registro alguno sin Centro de Costo.")
        } else {
            let resultadoEliminar = await Presupuesto_EliminarLista_Request(token, response.Datos);

            if (resultadoEliminar.Exitoso) {

                let resultado = await Presupuesto_GuardarLista_Request(token, arrayDatos);

                if (resultado.Exitoso) {

                    await formatoSaldos(arrayDatos);
                    Notificacion.success("El proceso ha finalizado exitosamente.");

                } else {
                    await Presupuesto_GuardarLista_Request(token, response.Datos);
                    Notificacion.error("Ha ocurrido un problema al guardar los datos, consulte al proveedor del sistema.")
                }

            } else {
                Notificacion.error("Ha ocurrido un problema al guardar los datos, consulte al proveedor del sistema.")
            }

        }

        spinnerModalMostrar(false, '', 3);

    }

    const guardarDatosExcel = async (pDatos) => {

        let spinnerLabel = 'Actualizando datos'
        spinnerModalMostrar(true, spinnerLabel, 3);

        let arrayDatos = pDatos;

        for (let i in arrayDatos) {
            for (let j in arrayDatos[i]) {
                if (j.toString().startsWith("Saldo_")) {
                    arrayDatos[i][j] = arrayDatos[i][j].toString().replace(/,/g, "");;
                }
            }
        }

        let resultado = await Presupuesto_GuardarLista_Request(token, arrayDatos);

        if (resultado.Exitoso) {

            setShowModalExcel(false);
            Notificacion.success("El proceso de importación ha finalizado exitosamente.");

        } else {
            Notificacion.error("Ha ocurrido un problema la guardar los datos, consulte al proveedor del sistema.")
        }

        await formatoSaldos(arrayDatos);
        spinnerModalMostrar(false, '', 3);

    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Asientos);
    }

    const onRowSelectList = (row) => {
        setID(`${row.Centro_Costo}/${row.Cuenta}/${row.Empresa}`);
    }

    const onRowSelect = (row, isSelect) => {
        let _listaGralAPBorrar = {};
        let lista = [...listaAccionesSel];
        let _docMant = undefined;
        if (isSelect) {
            _listaGralAPBorrar = row;
            lista.push(row.ID);
            _docMant = row;

        } else {
            _listaGralAPBorrar = {};
            lista = lista.filter(x => x !== row.ID);
            _docMant = undefined;
        }

        setListaAccionesSel(lista);

        return true;

    }

    const handleOnSelectAllDet = (isSelect, rows) => {
        if (isSelect) {
            setListaAccionesSel(rows.map(x => x.ID));
            return rows.map(x => x.ID);
        } else {
            setListaAccionesSel([]);
            return [];
        }
    }

    const formatoSaldos = async (pPresupuestos) => {

        for (let i in pPresupuestos) {
            pPresupuestos[i].ID = pPresupuestos[i].Nombre + "/" + pPresupuestos[i].Nombre_Centro_Costo;

            for (let j in pPresupuestos[i]) {
                if (j.toString().startsWith("Saldo_")) {
                    pPresupuestos[i][j] = pPresupuestos[i][j].toString().replace(/,/g, "");
                    let numeroFormato = onFormato(pPresupuestos[i][j]);
                    pPresupuestos[i][j] = numeroFormato;
                }
            }
        }

        setDatos(pPresupuestos);
    }

    //
    //Inicio de componente
    //
    useEffect(() => {
        if (!mounted.current) {
            const carga = async () => {
                await cargarDatos()
            }
            carga();
            mounted.current = true;
        }
    }, [])

    const cargarDatos = async (pBorrando) => {
        if (!pBorrando) {
            let spinnerLabel = 'Cargando datos...';
            spinnerModalMostrar(true, spinnerLabel, 3)
        }

        await listarPresupuestos();
        await cargarCentrosDeCosto();
        await cargarSeguridad();

        const _listCuentasContTemp = await carga_ListTree();
        setListCuentasCont(_listCuentasContTemp);

        ingresarDetalleLista();

        spinnerModalMostrar(false, '', 3)
    }

    const carga_ListTree = async () => {

        const response = await Catalogo_Lista_Request(token, empresa, 0);
        let _lista = [];
        if (response.Exitoso) {
            const _listCuentas = response.Datos;
            const _listCuentasCont = llenadoListaArbol(_listCuentas);
            setListCuentas(_listCuentas);
            _lista = datosArbol(_listCuentasCont);
        }
        else {
            Notificacion.error(response.Mensaje);
            await volverAtras();
        }

        return _lista;

    }

    const listarPresupuestos = async () => {
        const _datosEmpresa = await cargarEmpresa();

        setDatosEmpresa(_datosEmpresa);

        const response = await Presupuesto_Listar_Request(token, _datosEmpresa.Id, 0, 0);

        if (response.Exitoso) {

            await formatoSaldos(response.Datos);

        } else {
            Notificacion.error("Sucedió un error al consultar los presupuestos.");
            spinnerModalMostrar(false, '', 3);
            volverAtras();
            return;
        }
    }

    const llenadoListaArbol = (pLista) => {
        let _Datos = [];
        const _Lista = pLista;
        _Datos.push({ "title": empresaNombre, "subtitle": "", "padre": -1, "value": 0 });

        _Lista.map(function (item, index) {
            _Datos.push({ "title": item.Cuenta + " " + item.Nombre, "subtitle": "", "padre": (item.Padres.length > 0 ? parseInt(item.Padres.substring(item.Padres.length - 6, item.Padres.length)) : 0), "value": item.ID });
        });

        return _Datos;
    }

    const ingresarDetalleLista = (limpiar = false) => {

        let _listaDatos = limpiar ? [] : [].concat(listaDatos);

        let item = {
            Cargado: false,
            Centro_Costo: 0,
            Cuenta: 0,
            Empresa: 0,
            Fecha_Actualizacion: new Date("1900-01-01"),
            ID: 0,
            Nombre: "",
            Nombre_Centro_Costo: "",
            Saldo_01: "",
            Saldo_02: "",
            Saldo_03: "",
            Saldo_04: "",
            Saldo_05: "",
            Saldo_06: "",
            Saldo_07: "",
            Saldo_08: "",
            Saldo_09: "",
            Saldo_10: "",
            Saldo_11: "",
            Saldo_12: "",
        };

        _listaDatos.push(item);

        setListaDatos(_listaDatos);
    }

    const cargarCentrosDeCosto = async () => {

        let response = await CentroCosto_Lista_CCC_Request(token, empresa);

        if (response.Exitoso) {
            if (Array.isArray(response.Datos)) {
                setListCCosto(response.Datos);
            } else {
                Notificacion.error('No hay datos para: Centros de Costo.');
                volverAtras();
            }
        }
        else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }

        response = await CentroCosto_Lista_CXCCEmpresa_Request(token, empresa);

        if (response.Exitoso) {
            if (Array.isArray(response.Datos)) {
                setListCXCC(response.Datos);
            } else {
                Notificacion.error('No hay datos para: Centros de Costo.');
                volverAtras();
            }
        }
        else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }

    }

    //
    //Seguridad
    //
    const cargarSeguridad = async () => {
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.Presupuesto.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 cargarMenuOpciones = async (pModuloId, pUsuarioId, pMenuId) => {
        try {
            let listMO = await Obtener_MenuOpciones_Lista_Request(token, pModuloId, pUsuarioId, pMenuId);
            if (listMO.Exitoso === false) {
                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) {
                return null;
            }
            return listMON.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuNombre.`);
        }
    }

    const cargarEmpresa = async () => {
        let response = await Empresa_Consulta_Request(token, empresa);

        if (response.Exitoso) {
            return (response.Datos);
        } else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }
        return null;
    };


    //
    //Validaciones
    //

    const validarMenuOpcion = (pOpcion) => {
        let validar = false;
        let _menuOpciones = menuOpciones;
        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 validaMonto = (newValue, row, column) => {

        if (column.dataField.startsWith("Saldo_")) {
            newValue = newValue.toString().replace(/,/g, "");
        }

        if (newValue.toString().trim().length == 0) {
            return {
                valid: false,
                message: "Debe ingresar un dato válido",
            };
        }
        if (isNaN(newValue)) {
            return {
                valid: false,
                message: "Debe ingresar un dato válido",
            };
        }
        let isValid = true;
        isValid = validarDecimalFunc(newValue);
        if (!isValid) {
            return {
                valid: false,
                message: "Debe ingresar un dato válido",
            };
        }
        return { valid: true, mensaje: "" };
    };

    const validarDecimalFunc = (pValor) => {
        let isValid = true;
        if (pValor.toString().length > 0) {
            let strporc = pValor;
            isValid = strporc.match(/^((999999999(\.0{1,2})?)|(\d{1,19}(\.\d{0,2})?))$/) == null ? false : true;
        }
        return isValid;
    }

    const validaCuentaTabla = (newValue, row, column) => {

        if (row.Nombre !== newValue) {

            if (column.dataField == 'Nombre') {
                const validacion = validaCuenta(listCuentas, newValue)

                if (validacion.length > 0) {
                    return {
                        valid: false,
                        message: validacion,
                    };
                } else {

                    const _listaCuenta = listCuentas.filter(item => item.Cuenta == newValue || item.CuentaStr == newValue);

                    row.Nombre = _listaCuenta[0].Cuenta;
                    row.Cuenta = _listaCuenta[0].ID;
                    row.Nombre_Centro_Costo = "";
                    //row.Centro_Costo = 0;

                    return { valid: true, mensaje: "" };
                }
            }
        } else {
            return { valid: true, mensaje: "" };
        }
    };

    const validarGuardarDatos = async () => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Guardar.value;

        let validar = validarMenuOpcion(_value);

        if (!validar) {
            await confirmGuardarDatos();
        }
    }

    const validarGuardarDatosExcel = async () => {

        if (listaAccionesSel.length > 0) {

            //Lista de seleccionados
            let arrayModal = listaAccionesSel, arrayExcel = listaDatosExcel, filtradoColumnas = [], presupFiltro;
            let cuenta = 0;

            for (let i in arrayModal) {

                presupFiltro = [];
                presupFiltro = arrayExcel.filter(item => item.ID == arrayModal[i]);

                if (presupFiltro[0].Error !== "") {
                    cuenta++;
                } else {
                    filtradoColumnas.push(presupFiltro[0]);
                }

            }

            if (cuenta > 0) {
                Notificacion.error(`Debe seleccionar filas que no contengan errores.`);
            } else {
                await guardarDatosExcel(filtradoColumnas);
                let spinnerLabel = 'Actualizando datos'
                spinnerModalMostrar(true, spinnerLabel, 3);
                await listarPresupuestos();
                spinnerModalMostrar(false, "", 3);
                setListaAccionesSel([]);
            }

        } else {
            Notificacion.warning("Debe seleccionar al menos un registro.");
        }

    }

    const validarCargarNuevoPresupuesto = async (e) => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Cargar.value;

        let validar = validarMenuOpcion(_value);

        if (!validar) {
            confirmCargarNuevoPresupuesto(e);
        }
    }

    const validarRefrescar = async () => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Refrescar.value;

        let validar = validarMenuOpcion(_value);

        if (!validar) {
            await handleRefrescar();
        }
    }

    const validarCuentaExcel = (Cuenta, Linea) => {

        const validacion = validaCuenta(listCuentas, Cuenta)

        if (validacion.length > 0) {
            //Notificacion.error(`Error: ${validacion}, Línea: ${Linea}`);
            return validacion;

        } else {

            const _listaCuenta = listCuentas.filter(item => item.Cuenta == Cuenta || item.CuentaStr == Cuenta);

            if (_listaCuenta.length > 0) {
                return "";
            }
            else {
                //Notificacion.error(`No se encontró la cuenta`);
                return "No se encontró la cuenta.";
            }
        }

    }

    const validarCCostoExcel = (Cuenta, CCosto) => {
        if (Cuenta !== "") {
            const validacion = validaCCosto(listCCosto, Cuenta, CCosto, listCXCC);
            if (validacion.length > 0) {
                return validacion;
            } else {
                const listaCCosto = listCCosto.filter(item => item.Centro_Costo === CCosto);
                return "";
            }
        } else {
            return "No se encontró el centro de costo";
        };
    }

    const validaCCosto = (plista, pcuenta, pCCosto, pListaCXCC) => {
        let cCosto = new RegExp('^' + pCCosto + '-', 'i');
        let idCC = -1;
        const listCentroCosto = plista.filter(item => item.CentroCosto === pCCosto.toString());
        if (listCentroCosto.length == 0) {
            return 'El centro de costo no existe'
        }
        else {
            const listaCCosto = plista.filter(item => item.CentroCosto.match(cCosto));
            if (listaCCosto.length > 0) {
                return 'El centro de costo es de mayor'
            }
        }
        idCC = listCentroCosto[0].ID;
        // let filtro = { ID: [pcuenta], CentroCosto: [idCC] };
        // const listaCCCosto = multiFilter(pListaCXCC, filtro)


        // if (listaCCCosto.length == 0) {
        //     return 'No existe relacion entre la cuenta y el centro de costo'
        // }

        return '';
    }

    const onValidarCCosto = (newValue, row, column) => {

        if (row.Nombre_Centro_Costo !== newValue) {
            if (column.dataField == 'Nombre_Centro_Costo') {
                if (!!row.Cuenta) {
                    if (row.Cuenta != -1) {
                        const validacion = validaCCosto(listCCosto, row.Cuenta, newValue, listCXCC)
                        if (validacion.length > 0) {
                            return {
                                valid: false,
                                message: validacion
                            };
                        } else {
                            const listaCCosto = listCCosto.filter(item => item.CentroCosto == newValue);
                            const validaRepetido = datos.filter(item => item.Nombre_Centro_Costo === newValue && item.Nombre === row.Nombre);

                            if (validaRepetido.length > 0) {
                                return {
                                    valid: false,
                                    message: "El centro de costo y la cuenta están repetidos"
                                };
                            } else {
                                row.Centro_Costo = listaCCosto[0].ID;
                                row.Nombre_Centro_Costo = listaCCosto[0].CentroCosto;
                                return true;
                            }

                        }
                    } else {
                        return {
                            valid: false,
                            message: 'Debe seleccionar una cuenta contable'
                        };
                    }
                } else {
                    return {
                        valid: false,
                        message: 'Debe seleccionar una cuenta contable'
                    };
                }
            }
        } else {
            return true;
        }
    }

    //
    ////Confirmaciones
    //
    const confirmCargarNuevoPresupuesto = (e) => {
        let resultado = false;
        Swal.fire({
            title: 'Atención',
            html: '<h4>¿Desea cargar un nuevo presupuesto?</h4>',
            showCancelButton: true,
            confirmButtonColor: '#10a599',
            cancelButtonColor: '#d33',
            confirmButtonText: '<h5><i class="fa fa-check fa-fw"></i> Sí</h5>',
            cancelButtonText: '<h5><i class="fa fa-remove fa-fw"></i> No</h5>',
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                resultado = true;
                mostrarModalDesc();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        });
    }

    const mostrarModalDesc = () => {
        setselectedModalDesc(true);
    }


    const confirmGuardarDatos = () => {
        let resultado = false;
        Swal.fire({
            title: 'Atención',
            html: '<h4>¿Está seguro que desea guardar los datos?</h4>',
            showCancelButton: true,
            confirmButtonColor: '#10a599',
            cancelButtonColor: '#d33',
            confirmButtonText: '<h5><i class="fa fa-check fa-fw"></i> Sí</h5>',
            cancelButtonText: '<h5><i class="fa fa-remove fa-fw"></i> No</h5>',
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                resultado = true;
                guardarDatos(datos);
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        });
    }

    const handleRefrescar = async () => {

        Swal.fire({
            title: 'Atención',
            html: '<h4>¿Está seguro que desea volver a cargar los datos y perder las modificaciones que ha realizado?</h4>',
            showCancelButton: true,
            confirmButtonColor: '#10a599',
            cancelButtonColor: '#d33',
            confirmButtonText: '<h5><i class="fa fa-check fa-fw"></i> Sí</h5>',
            cancelButtonText: '<h5><i class="fa fa-remove fa-fw"></i> No</h5>',
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                cargarDatos();
            } else if (result.dismiss === Swal.DismissReason.cancel) {

            }
        });

    }


    //
    ////Modals
    //
    const cerrarModalTree = () => {
        setIndexC(-1);
        setSelectModalTree(false);
    }

    const cerrarModalBusqueda = () => {
        setSelectModalBusqueda(false);
        setSelectedCentroCosto(undefined);
        setIndexCost(indexCost);
        setRowSelected(undefined);
    }

    const onRowSelectBusqueda = (row) => {
        setSelectedCentroCosto(row);
    }

    const seleccionModalTree = async () => {
        if (!!selectedCuenta) {
            if (!selectedCuenta.node.children) {

                const listCCont = listCuentas.filter(item => item.ID == selectedCuenta.node.value);
                let _pColumn = { ...pColumn };

                //listCuentasLista ///// de todas las cuentas existentes
                //listCCont ///// Lista de la lista filtrada
                //pColumn ////// Es la celda que se manda por parámetro al abrir el modal

                _pColumn.Cuenta = listCCont[0].ID;
                _pColumn.CuentaStr = listCCont[0].Cuenta;
                _pColumn.NombreCuenta = listCCont[0].Nombre;

                spinnerModalMostrar(true, 'Cargando datos', 3);
                const response = await CentroCostos_CentroDefault_Request(token, empresa, _pColumn.Cuenta);
                spinnerModalMostrar(false, '', 3);

                let _listaDatos = [].concat(datos);
                _listaDatos[indexC].Cuenta = _pColumn.Cuenta;
                _listaDatos[indexC].Nombre = _pColumn.CuentaStr;


                if (response.Exitoso) {
                    _listaDatos[indexC].Centro_Costo = response.Datos.ID;
                    _listaDatos[indexC].Nombre_Centro_Costo = response.Datos.CentroCosto;
                    _listaDatos[indexC].Centro_CostoNom = response.Datos.Nombre;
                }
                else {
                    Notificacion.error(response.Mensaje);
                }

                setListaDatos(_listaDatos);
                setSelectedCuenta(undefined);
                setSelectModalTree(false);
                setIndexC(-1);
                setPColumn(_pColumn);

            }
            else {
                Notificacion.error('La cuenta selccionada es padre.');
                setSelectModalTree(false);
                setSelectedCuenta(undefined);
            }
        }
        else {
            Notificacion.warning('Debe seleccionar un registro.');
        }
    }

    const handleCerrarModal = () => setShowModalSeguridad(false);

    const handleCerrarModalExcel = () => {
        setShowModalExcel(false)
        Notificacion.info("Se ha cancelado el proceso de importación del presupuesto.");
    };

    const onActionResultModal = (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.Refrescar.value:
                    handleRefrescar();
                    break;
                case _optSegopt.Guardar.value:
                    //Guardar datos 
                    confirmGuardarDatos();
                    break;
                case _optSegopt.Cargar.value:
                    //Cargar nuevo presupuesto
                    confirmCargarNuevoPresupuesto();
                    break;
                default:
                    break;
            }
        }
    }

    const onRowSelectBusquedaTree = (row) => {
        setSelectedCuenta(row);
    }

    const handleChangeSearch = (event) => {

        let _listCentroCostoFiltro = listCentroCosto;
        _listCentroCostoFiltro = _listCentroCostoFiltro.filter(function (item) {
            return item.CentroCosto.toLowerCase().search(
                event.target.value.toLowerCase()) !== -1;
        });

        if (_listCentroCostoFiltro.length == 0) {
            _listCentroCostoFiltro = listCentroCosto;

            _listCentroCostoFiltro = _listCentroCostoFiltro.filter(function (item) {
                return item.Nombre.toLowerCase().search(
                    event.target.value.toLowerCase()) !== -1;
            });
        }

        setListCentroCostoFiltro(_listCentroCostoFiltro);

    }

    const handleModal = async (cell, row) => {

        const modal = true;
        const _indexCost = row;

        if (!!cell.Cuenta) {
            if (cell.Cuenta != -1) {
                spinnerModalMostrar(true, 'Cargando datos');
                const response = await CentroCosto_Lista_CXCC_Request(token, empresa, cell.Cuenta);
                spinnerModalMostrar(false, '');

                let _listCentroCostoFiltro = [];

                if (response.Exitoso) {
                    _listCentroCostoFiltro = response.Datos;
                } else {
                    Notificacion.error(response.Mensaje);
                    await volverAtras();
                    return;
                }

                //const _idCCObj = cell.llave.toString() + 'B';
                setSelectModalBusqueda(modal), setListCentroCosto(_listCentroCostoFiltro), setListCentroCostoFiltro(_listCentroCostoFiltro);
                setIndexCost(_indexCost); //setIdCCObj(_idCCObj);

            } else {
                Notificacion.warning('Debe seleccionar una cuenta contable.');
            }
        } else {
            Notificacion.warning('Debe seleccionar una cuenta contable.');
        }

    }

    const seleccionModal = () => {
        if (!!selectedCentroCosto) {

            const listCCost = listCCosto.filter(item => item.ID == selectedCentroCosto.ID);

            let _listaDatos = [].concat(datos);

            _listaDatos[indexCost].Centro_Costo = listCCost[0].ID;
            _listaDatos[indexCost].Nombre_Centro_Costo = listCCost[0].CentroCosto;

            setListaDatos(_listaDatos);
            setSelectedCentroCosto(undefined);
            setSelectModalBusqueda(false);
            setIndexCost(indexCost);

        }
        else {
            Notificacion.warning('Debe seleccionar un registro.');
        }
    }

    //
    ////Excel
    //
    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 });

                    revisarArchivoExcel(dataParse);
                };
            } else {
                Notificacion.warning('Dede seleccionar un archivo del tipo xls o xlsx.');
                e.value = '';
            }
            reader.readAsBinaryString(f);
        }
        e.target.value = '';
    }

    const revisarArchivoExcel = (dataParse) => {

        let arrayExcelModal = [];
        let fila = {};

        for (let i = 1; i < dataParse.length; i++) {

            fila = generarItemExcel();

            if (dataParse[i][0] !== undefined) {

                if (dataParse[i][1] !== undefined) {

                    fila.Cargado = true;
                    fila.Nombre = dataParse[i][0];
                    fila.Empresa = empresa;
                    fila.ID = dataParse[i][0] + "/" + dataParse[i][1];
                    fila.Fecha_Actualizacion = (moment().format("yyyy-MM-DD hh:mm:ss.SSS")).toString();

                    if (dataParse[i][2] !== undefined) {
                        if (!isNaN(dataParse[i][2])) {
                            fila.Saldo_01 = parseFloat(dataParse[i][2]);
                        } else {
                            fila.Error += "El Monto de Enero no es númerico ";
                        }
                    } else {
                        fila.Saldo_01 = 0.00;
                    }

                    if (dataParse[i][3] !== undefined) {
                        if (!isNaN(dataParse[i][3])) {
                            fila.Saldo_02 = parseFloat(dataParse[i][3]);
                        } else {
                            fila.Error += "El Monto de Febrero no es númerico ";
                        }
                    } else {
                        fila.Saldo_02 = 0.00;
                    }

                    if (dataParse[i][4] !== undefined) {
                        if (!isNaN(dataParse[i][4])) {
                            fila.Saldo_03 = parseFloat(dataParse[i][4]);
                        } else {
                            fila.Error += "El Monto de Marzo no es númerico ";
                        }
                    } else {
                        fila.Saldo_03 = 0.00;
                    }

                    if (dataParse[i][5] !== undefined) {
                        if (!isNaN(dataParse[i][5])) {
                            fila.Saldo_04 = parseFloat(dataParse[i][5]);
                        } else {
                            fila.Error += "El Monto de Abril no es númerico ";
                        }
                    } else {
                        fila.Saldo_04 = 0.00;
                    }

                    if (dataParse[i][6] !== undefined) {
                        if (!isNaN(dataParse[i][6])) {
                            fila.Saldo_05 = parseFloat(dataParse[i][6]);
                        } else {
                            fila.Error += "El Monto de Mayo no es númerico ";
                        }
                    } else {
                        fila.Saldo_05 = 0.00;
                    }

                    if (dataParse[i][7] !== undefined) {
                        if (!isNaN(dataParse[i][7])) {
                            fila.Saldo_06 = parseFloat(dataParse[i][7]);
                        } else {
                            fila.Error += "El Monto de Junio no es númerico ";
                        }
                    } else {
                        fila.Saldo_06 = 0.00;
                    }

                    if (dataParse[i][8] !== undefined) {
                        if (!isNaN(dataParse[i][8])) {
                            fila.Saldo_07 = parseFloat(dataParse[i][8]);
                        } else {
                            fila.Error += "El Monto de Julio no es númerico ";
                        }
                    } else {
                        fila.Saldo_07 = 0.00;
                    }

                    if (dataParse[i][9] !== undefined) {
                        if (!isNaN(dataParse[i][9])) {
                            fila.Saldo_08 = parseFloat(dataParse[i][9]);
                        } else {
                            fila.Error += "El Monto de Agosto no es númerico ";
                        }
                    } else {
                        fila.Saldo_08 = 0.00;
                    }

                    if (dataParse[i][10] !== undefined) {
                        if (!isNaN(dataParse[i][10])) {
                            fila.Saldo_09 = parseFloat(dataParse[i][10]);
                        } else {
                            fila.Error += "El Monto de Setiembre no es númerico ";
                        }
                    } else {
                        fila.Saldo_09 = 0.00;
                    }

                    if (dataParse[i][11] !== undefined) {
                        if (!isNaN(dataParse[i][11])) {
                            fila.Saldo_10 = parseFloat(dataParse[i][11]);
                        } else {
                            fila.Error += "El Monto de Octubre no es númerico ";
                        }
                    } else {
                        fila.Saldo_10 = 0.00;
                    }

                    if (dataParse[i][12] !== undefined) {
                        if (!isNaN(dataParse[i][12])) {
                            fila.Saldo_11 = parseFloat(dataParse[i][12]);
                        } else {
                            fila.Error += "El Monto de Noviembre no es númerico ";
                        }
                    } else {
                        fila.Saldo_11 = 0.00;
                    }

                    if (dataParse[i][13] !== undefined) {
                        if (!isNaN(dataParse[i][13])) {
                            if (validarDecimalFunc((dataParse[i][13]).toString())) {
                                fila.Saldo_12 = parseFloat(dataParse[i][13]);
                            } else {
                                fila.Error += "El Monto de Diciembre no es válido. ";
                            }
                        } else {
                            fila.Error += "El Monto de Diciembre no es númerico ";
                        }
                    } else {
                        fila.Saldo_12 = 0.00;
                    }


                    let responseValidaCuenta = validarCuentaExcel(fila.Nombre, i);

                    if (responseValidaCuenta === "") {

                        fila.Centro_Costo_Excel = dataParse[i][1];

                        const filtroCuenta = listCuentas.filter(item => item.Cuenta === fila.Nombre.trim());

                        if (filtroCuenta.length > 0) {
                            //fila.CuentaID = filtroCuenta[0].ID;
                            fila.Cuenta = filtroCuenta[0].ID;
                        }

                        let responseValidaCCosto = validarCCostoExcel(fila.Cuenta, fila.Centro_Costo_Excel);

                        if (responseValidaCCosto === "") {

                            const filtroCCosto = listCCosto.filter(item => item.CentroCosto == fila.Centro_Costo_Excel);

                            if (filtroCCosto.length > 0) {
                                fila.Centro_Costo = filtroCCosto[0].ID;
                                fila.NombreCuenta = filtroCuenta[0].Nombre
                            }

                        } else {
                            fila.NombreCuenta = responseValidaCCosto;
                            if (fila.Error === "") {
                                fila.Error = "***";
                            }
                        }

                    } else {
                        fila.NombreCuenta = responseValidaCuenta;
                        if (fila.Error === "") {
                            fila.Error = "***";
                        }
                    }

                    let validacion = arrayExcelModal.filter(item => item.Nombre === (fila.Nombre.toString()).trim() && item.Centro_Costo_Excel === fila.Centro_Costo_Excel);

                    if (validacion.length > 0) {
                        fila.Error = `La fila está duplicada. ${fila.Error}`
                        //fila.ID = `${dataParse[i][0]}/${dataParse[i][1]}/2 `; 

                        for (let i in arrayExcelModal) {
                            if (arrayExcelModal[i].Nombre === fila.Nombre.trim() && arrayExcelModal[i].Centro_Costo_Excel === fila.Centro_Costo_Excel && !(arrayExcelModal[i].Error.includes("La fila está duplicada"))) {
                                arrayExcelModal[i].Error = `La fila está duplicada. ${arrayExcelModal[i].Error}`;
                            }
                        }

                    }

                } else {
                    fila.Nombre = dataParse[i][0];
                    fila.ID = dataParse[i][0] + "/" + i;
                    fila.Error = "No se digitó Centro de Costo";
                }

            } else {
                fila.ID = -2 - i;
                fila.Error = "No se digitó la Cuenta.";
            }

            arrayExcelModal.push(fila);

        }

        setListaDatosExcel(arrayExcelModal);
        setShowModalExcel(true);
    }

    const generarItemExcel = () => {

        return {
            Centro_Costo: "",
            Cargado: false,
            Centro_Costo_Excel: "",
            Cuenta: 0,
            Empresa: 0,
            Error: "",
            Fecha_Actualizacion: new Date("1900-01-01"),
            Nombre: "",
            NombreCuenta: "",
            Saldo_01: "",
            Saldo_02: "",
            Saldo_03: "",
            Saldo_04: "",
            Saldo_05: "",
            Saldo_06: "",
            Saldo_07: "",
            Saldo_08: "",
            Saldo_09: "",
            Saldo_10: "",
            Saldo_11: "",
            Saldo_12: "",
        };

    }

    const handleClick = (e) => {

        setselectedModalDesc(false);

        e.preventDefault();
        hiddenFileInput.current && hiddenFileInput.current.click();
    };

    return (
        <Fragment>

            <PresupuestoInt
                titulo={"Presupuesto del Periodo Actual"}
                listaPresupuestos={datos}
                columnas={columnas}
                cellEdit={cellEdit}
                selectRow={selectRow}
                botonDet={botones}
                hiddenFileInput={hiddenFileInput}
                cargaArchivoExcel={cargaArchivoExcel}
            />

            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />

            <ModalBusquedaTree
                selectedModal={selectModalTree}
                contentLabel={'selectedBusquedasTree'}
                label={'Catálogo'}
                onSelectedRow={onRowSelectBusquedaTree}
                cerrarModal={cerrarModalTree}
                seleccionModal={seleccionModalTree}
                maxDepth={5}
                carga_ListTree={() => { }}
                listatree={listCuentasCont}
            />

            <ModalBusqueda
                selectedModal={selectModalBusqueda}
                contentLabel={'selectedBusquedas'}
                listaFiltro={listCentroCostoFiltro}
                columnas={Header}
                keyRow={'ID'}
                label={'Lista de Centros de Costos Asociados'}
                onSelectedRow={onRowSelectBusqueda}
                handleChangeSearch={handleChangeSearch}
                cerrarModal={cerrarModalBusqueda}
                seleccionModal={seleccionModal}
                rowsSelected={rowsSelected}
            />

            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
            />

            <ModalPresupuesto
                selectedModal={showModalExcel}
                contentLabel={'selectedCargaIngDedDet'}
                datos={listaDatosExcel}
                id={'ID'}
                columnas={columnasExcel}
                striped={false}
                hover={true}
                condensed={false}
                selectRow={selectRowExcel}
                label={'Carga de Presupuestos por Excel'}
                cellEdit={{}}
                cerrarModal={handleCerrarModalExcel}
                seleccionModal={() => { }}
                datosFiltro={listaDatosExcel}
                verLHOC={false}
                botones={botonesExcel}
            />

            <ModalDescripcionCarga
                selectedModal={selectedModalDesc}
                contentLabel={'spinnerModalProgress'}
                label={"Descripción del archivo xls:"}
                imgDescripcion={ImagenesRutas.DescExcel_Presupuesto}
                cerrarModal={handleClick}
            />

        </Fragment>
    );
};
export default withRouter(memo(ListaPresupuesto))