﻿import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faCheck, faTimes, faSync, faCheckDouble, faSearch, faListAlt } from '@fortawesome/free-solid-svg-icons';

import { SiteRutas } from '../../request/RutasConfig.jsx';

import Config from '../../components/Util/constantes.js';
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import BotonArriba from '../../components/UI/botonArriba/botonArriba.jsx';

import { farmatearMontos, muestraArbolEmpleados, validarDecimal, Round, farmatearFechaEstandar, fechaUltimoDia } from '../../components/Util/Util.jsx';
//Invocaciones datos
import {
    Empleados_Consulta_Request, TipoPlanilla_Listar_Request, Oficina_lista_Request,
    Seccion_Lista_Request, Departamentos_Lista_Request, Areas_ListaEmpresa_Request,
} from "../../request/MantenimientosRequest.jsx";
import {
    Autogestion_ConsultarPorEstadoYPeriodo_Request, Autogestion_Rechazar_Request,
    Autogestion_Aprobar_Request
} from '../../request/AccionesRequest.jsx';
import { ParametrosPlanilla_Consulta_Request, Monedas_Consulta_Request } from '../../request/ServicioRequest.jsx';
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import Swal from 'sweetalert2';
import { Button } from 'react-bootstrap';

import AutogestionInt from './autogestionInt.jsx';

import moment from 'moment';

//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 optSeg from '../../components/Util/seg-menu-opciones.js';

function autogestion(props) {

    const pDatos = {
        Tipo: { value: "", attributes: { readOnly: false, focus: false, label: "Tipo", hidden: "unset" } },
        Desde: { value: moment().add(-30, 'days').toDate(), attributes: { readOnly: false, focus: false, label: "Desde", hidden: "unset", } },
        Hasta: { value: moment().toDate(), attributes: { readOnly: false, focus: false, label: "Hasta", hidden: "unset", } },
        MostrarPendientes: { value: false, attributes: { readOnly: false, focus: false, label: "Mostrar solicitudes pendientes de aprobar", hidden: "unset", } },
        Comentario: { value: '', attributes: { readOnly: false, focus: false, label: "Comentario Anulación", hidden: "unset", } },
        BotonesAE: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'left', hidden: 'unset' } },
    };
    const [SpinnerModal, setSpinnerModal] = useState(false);
    const [SpinnerLabel, setSpinnerLabel] = useState('');
    const [SpinnerTipo, setSpinnerTipo] = useState(0);
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [usuarioNombre, setUsuarioNombre] = useSessionStorage('usuarioNombre', '');
    const [Pais, setPais] = useSessionStorage('pais');
    const [Datos, setDatos] = useState(pDatos);
    const [borrando, setBorrando] = useState(false);
    let historyMenu = useHistory();
    const [listaDatos, setListaDatos] = useState([]);
    const [listaTipo, setListaTipo] = useState([{ value: 'TOD', label: 'Todas' }, { value: 'VA', label: 'Vacaciones' }, { value: 'PE', label: 'Permisos' }, { value: 'CO', label: 'Constancias' }, { value: 'HO', label: 'Horas extras' }]);
    const [selectedOptionTipo, setSelectedOptionTipo] = useState(listaTipo[0]);
    const [filasSeleccionadas, setFilasSeleccionadas] = useState([]);
    const [listaDesglocePlanillas, setListaDesglocePlanillas] = useState([]);
    const [Parametros, setParametros] = useState(null);
    const [listaPlanillas, setListaPlanillas] = useState([]);
    const [EstadoGestion, setEstadoGestion] = useState('AP');
    const [show, setShow] = useState(false);
    const [listaArea, setListaArea] = useState([]);
    const [listaDepto, setListaDepto] = useState([]);
    const [listaSeccion, setListaSeccion] = useState([]);
    const [listaOficina, setListaOficina] = useState([]);
    const [detalle, setDetalle] = useState(null);
    const [linea, setLinea] = useState(undefined);
    const label = 'Detalle de Autogestión';
    const cerrarModal = () => { setShow(false); }
    const tipoHorasExtras = 'HO';
    const tipoConstancia = 'CO';

    const derecha = { textAlign: 'right', width: '10%' };
    const centro = { textAlign: 'center', width: '90%' };
    const ancho = { width: '100%' };

    //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 botones = [
        { name: "btnHome", clase: "btn btn-sm pull-right flipInX animated", evento: () => volverAtras(), leyenda: "", iclase: faReply, tooltip: "Volver" },
        { name: "btnAprobar", clase: "btn btn-sm pull-right flipInX animated", evento: () => Aprobar(), leyenda: "", iclase: faCheck, tooltip: "Aprobar" },
        { name: "btnRechazar", clase: "btn btn-sm pull-right flipInX animated", evento: () => handleAnular(), leyenda: "", iclase: faTimes, tooltip: "Rechazar" },
        //        { name: "btnRefrescar", clase: "btn btn-sm pull-right flipInX animated", evento: () => cargarDatos(), leyenda: "", iclase: faSync, tooltip: "Refrescar" },
        {
            name: "btnVerDetalle",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => detalleDatos(),
            leyenda: "",
            iclase: faListAlt,//"fa fa-pencil",
            tooltip: "Detalle del empleado"
        }
    ];
    const botonesLista = [

        {
            name: "btnRefescarCDD",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cargarDatos(),
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        },
    ]

    const columnas = [{
        dataField: 'Gestion_id', text: 'Solicitud', sort: true, align: 'center', headerAlign: 'center',
        // formatter: (row, cell) => {
        //     return (
        //         <table style={ancho}>
        //             <tbody>
        //                 <tr style={ancho}>
        //                     <td id={cell.Gestion_id} style={centro} > {cell.Gestion_id} </td>
        //                     <td style={derecha} >
        //                         <a type="button" onClick={() => { onVerDetalleClick(cell) }} >
        //                             <FontAwesomeIcon icon={faSearch} />
        //                         </a>
        //                     </td>
        //                 </tr>
        //             </tbody>
        //         </table>
        //     );
        // }
    },
    { dataField: 'Gestion_TipoNombre', text: 'Tipo', sort: true, align: 'center', headerAlign: 'center' },
    { dataField: 'Gestion_FechaDesde', text: 'Desde', sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Gestion_FechaDesde) }, headerAlign: 'center', align: 'center' },
    { dataField: 'Gestion_FechaHasta', text: 'Hasta', sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Gestion_FechaHasta) }, headerAlign: 'center', align: 'center' },
    { dataField: 'EmpleadoNombre', text: 'Nombre', sort: true, align: 'left', headerAlign: 'left' },
    { dataField: 'EmpleadoPuesto', text: 'Puesto', sort: true, align: 'left', headerAlign: 'center' }, {
        dataField: 'Gestion_Estado', text: 'Estado', sort: true, formatter: (row, cell) => {
            if (cell.Gestion_Estado === 'PE') return 'Pendiente'
            else if (cell.Gestion_Estado === 'EP') return 'En Proceso'
            else if (cell.Gestion_Estado === 'AP') return 'Aprobada'
            else if (cell.Gestion_Estado === 'PR') return 'Procesada'
            else return ''
        }, headerAlign: 'center', align: 'center'
    }, { dataField: 'email', text: 'Email', sort: true, headerAlign: 'center', align: 'left' },];

    const estadosNoEn = "'FI','RE','EL'";

    const onVerDetalleClick = (row) => {

        setDetalle(row);
        setShow(true);

    }

    const obtenerAreaDesc = (Area) => {

        let Descripcion = '';
        const filtro = listaArea.filter(x => x.Id === Area);

        if (filtro.length > 0) {
            Descripcion = filtro[0].Descripcion;
        }

        return Descripcion;

    }

    const obtenerDeptoDesc = (Depto) => {

        let Descripcion = '';
        const filtro = listaDepto.filter(x => x.Id === Depto);

        if (filtro.length > 0) {
            Descripcion = filtro[0].Descripcion;
        }

        return Descripcion;

    }

    const obtenerSeccionDesc = (Seccion) => {

        let Descripcion = '';
        const filtro = listaSeccion.filter(x => x.id === Seccion);

        if (filtro.length > 0) {
            Descripcion = filtro[0].Descripcion;
        }

        return Descripcion;

    }

    const obtenerOficinaDesc = (Oficina) => {

        let Descripcion = '';
        const filtro = listaOficina.filter(x => x.id === Oficina);

        if (filtro.length > 0) {
            Descripcion = filtro[0].Descripcion;
        }

        return Descripcion;

    }

    const obtenerEstadoDesc = (Estado) => {

        if (Estado === 'PE') return 'Pendiente'
        else if (Estado === 'AP') return 'Aprobada'
        else if (Estado === 'PR') return 'Procesada'
        else return ''

    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {

        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);

    }

    const handleCheckedChange = (e) => {
        const name = e.target.name;
        const value = e.target.checked;

        let newAttributes = Datos[name].attributes;

        const _Datos = Object.assign({}, Datos, {
            [name]: {
                value: value,
                attributes: newAttributes,
                id: name,
                name: name,
            },
        });

        if (value)
            setEstadoGestion('');
        else
            setEstadoGestion('AP');

        setDatos(_Datos);

    }

    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 onRowSelect = (row, isSelect) => {

        let filas = [...filasSeleccionadas];

        if (isSelect) {
            filas.push(row.Gestion_id);
            setLinea(row);
        } else {
            filas = filasSeleccionadas.filter(r => r !== row.Gestion_id);
            setLinea(undefined);
        }

        setFilasSeleccionadas(filas);

    };

    const onRowSelectAll = (isSelect, rows) => {

        if (isSelect) {
            setFilasSeleccionadas(listaDatos.map(r => r.Gestion_id));
            return listaDatos.map(r => r.Gestion_id);
        } else {
            setFilasSeleccionadas([]);
        }

    }

    const onChangeInputEmp = (e) => {

        const name = e.target.name;
        const value = e.target.value;

        let newAttributes = Datos[name].attributes;
        let _Datos = Object.assign({}, Datos, {
            [name]: { value: value, attributes: newAttributes },
        });

        setDatos(_Datos);

    }


    const ObtenerFechaPlanillaDesde = (pDesdeAccionP, pDesdePlanActual, pHastaPlanActual, pPeriodicidad, datos) => {

        let pFecha = new Date(), pDesde = new Date(), pHasta = new Date();

        pFecha = pDesdePlanActual;
        pDesde = pDesdePlanActual;
        pHasta = pHastaPlanActual;

        if ((pDesdeAccionP >= pDesdePlanActual) && (pDesdeAccionP <= pHastaPlanActual)) {
            datos.pDesdeN = pDesdePlanActual;
            datos.pHastaN = pHastaPlanActual;
        }
        else {

            switch (pPeriodicidad) {
                case Config.pr_Mensual:
                case Config.pr_Mensual_Adelanto:
                    pDesde = moment(pDesde).add(1, 'M').toDate();
                    pHasta = fechaUltimoDia(pDesde);// moment(pDesde).endOf('month').toDate();
                    break;
                case Config.pr_Quincenal:
                    if (parseInt(moment(pDesde).format('DD')) === 1) {
                        pDesde = moment(moment(pDesde).format('YYYY') + '/' + moment(pDesde).format('MM') + '/16').toDate();
                        pHasta = moment(moment(pDesde).format('YYYY') + '/' + moment(pDesde).format('MM') + '/' + moment(pDesde).endOf('month').format('DD')).toDate();
                    }
                    else {
                        pDesde = moment(pDesde).add(1, 'M').toDate();
                        pDesde = moment(moment(pDesde).format('YYYY') + '/' + moment(pDesde).format('MM') + '/01').toDate();
                        pHasta = moment(pDesde).add(14, 'days').toDate();
                    };
                    break;
                case Config.pr_Semanal:
                    pDesde = moment(pHasta).add(1, 'days').toDate();
                    pHasta = moment(pHasta).add(7, 'days').toDate();
                    break;
                case Config.pr_Bisemanal:
                    pDesde = moment(pHasta).add(1, 'days').toDate();
                    pHasta = moment(pHasta).add(14, 'days').toDate();
                    break;
                default:
                    break;
            }

            if ((pDesdeAccionP >= pDesde) && (pDesdeAccionP <= pHasta)) {
                datos.pDesdeN = pDesde;
                datos.pHastaN = pHasta;
            } else {
                ObtenerFechaPlanillaDesde(pDesdeAccionP, pDesde, pHasta, pPeriodicidad, datos);
            }

        }

    }

    const ObtenerSiguienteFechaPlanilla = (datos, pPeriodicidad) => {

        switch (pPeriodicidad) {
            case Config.pr_Mensual:
            case Config.pr_Mensual_Adelanto:
                datos.pDesde = moment(datos.pDesde).add(1, 'M').toDate();
                datos.pHasta = fechaUltimoDia(datos.pDesde); //moment(datos.pDesde).endOf('month').toDate();
                break;
            case Config.pr_Quincenal:
                if (parseInt(moment(datos.pDesde).format('DD')) === 1) {
                    datos.pDesde = moment(moment(datos.pDesde).format('YYYY') + '/' + moment(datos.pDesde).format('MM') + '/16').toDate();
                    datos.pHasta = moment(moment(datos.pDesde).format('YYYY') + '/' + moment(datos.pDesde).format('MM') + '/' + moment(datos.pDesde).endOf('month').format('DD')).toDate();
                }
                else {
                    datos.pDesde = moment(datos.pDesde).add(1, 'M').toDate();
                    datos.pDesde = moment(moment(datos.pDesde).format('YYYY') + '/' + moment(datos.pDesde).format('MM') + '/01').toDate();
                    datos.pHasta = moment(datos.pDesde).add(14, 'days').toDate();
                };
                break;
            case Config.pr_Semanal:
                datos.pDesde = moment(datos.pHasta).add(1, 'days').toDate();
                datos.pHasta = moment(datos.pHasta).add(7, 'days').toDate();
                break;
            case Config.pr_Bisemanal:
                datos.pDesde = moment(datos.pHasta).add(1, 'days').toDate();
                datos.pHasta = moment(datos.pHasta).add(14, 'days').toDate();
                break;
            default:
                break;
        }

    };

    const DiasDiferencia = (FechaIni, FechaFin) => {

        return moment(FechaFin).diff(FechaIni, 'days') + 1;

    };

    const GeneraDesglocePlanillas = (Autogestion, _TipoPlanilla) => {

        let _DiasDesc = 0;
        let _Residuo = 0;
        let _Desde = moment().toDate();
        let _Hasta = moment().toDate();
        let _Dias = 0;
        let Detalle = {};
        let lstDesglocePlanillas = [];

        _Residuo = 0;// Autogestion.DiasVac - Math.trunc(Autogestion.DiasVac);

        if (_Residuo < 0)
            _Residuo = 0;

        _Dias = Autogestion.Gestion_DiasSolicitado;

        // if (_Residuo > 0)
        //     _Dias = (Autogestion.DiasVac + (1 - _Residuo));

        _Desde = Autogestion.Gestion_FechaDesde;
        _Hasta = Autogestion.Gestion_FechaHasta;

        let datos = { pDesdeN: _Desde, pHastaN: _Hasta };

        if (Autogestion.Gestion_FechaDesde < _TipoPlanilla.Desde) {
            ObtenerFechaPlanillaDesde(_TipoPlanilla.Desde, _TipoPlanilla.Desde, _TipoPlanilla.Hasta, _TipoPlanilla.Periodicidad, datos);
        }
        else {
            ObtenerFechaPlanillaDesde(Autogestion.Gestion_FechaDesde, _TipoPlanilla.Desde, _TipoPlanilla.Hasta, _TipoPlanilla.Periodicidad, datos);
        }

        _Desde = datos.pDesdeN;
        _Hasta = datos.pHastaN;

        let fechaTemp = new Date();

        if (_Hasta > Autogestion.Gestion_FechaHasta) {
            fechaTemp = Autogestion.Gestion_FechaHasta;
        }
        else {
            fechaTemp = _Hasta;
        }

        _DiasDesc = DiasDiferencia(Autogestion.Gestion_FechaDesde, fechaTemp);

        if (_DiasDesc > _Dias)
            _DiasDesc = _Dias;

        Detalle.Id = Autogestion.Gestion_id;
        Detalle.Desde = _Desde;
        Detalle.Hasta = _Hasta;
        Detalle.Dias = _DiasDesc;
        Detalle.Activo = Config.ee_activo;
        Detalle.UltimaPlanilla = true;

        if ((_Dias - _DiasDesc) > 0) {
            Detalle.Dias = _DiasDesc;
            Detalle.UltimaPlanilla = false;
        }
        else {
            if (_Residuo > 0)
                Detalle.Dias = (_DiasDesc - (1 - _Residuo));
        }

        lstDesglocePlanillas.push(Detalle);

        _Dias = _Dias - _DiasDesc;

        while (_Dias > 0) {

            datos = { pDesde: _Desde, pHasta: _Hasta };
            ObtenerSiguienteFechaPlanilla(datos, _TipoPlanilla.Periodicidad);
            _Desde = datos.pDesde;
            _Hasta = datos.pHasta;

            if (_Hasta > Autogestion.Gestion_FechaHasta) {
                _DiasDesc = DiasDiferencia(_Desde, Autogestion.Gestion_FechaHasta);
            }
            else {
                _DiasDesc = DiasDiferencia(_Desde, _Hasta);
            }

            if (_DiasDesc > _Dias)
                _DiasDesc = _Dias;

            Detalle = {};

            Detalle.Id = Autogestion.Gestion_id;
            Detalle.Desde = _Desde;
            Detalle.Hasta = _Hasta;
            Detalle.Dias = _DiasDesc;
            Detalle.Activo = Config.ee_activo;
            Detalle.UltimaPlanilla = true;

            if ((_Dias - _DiasDesc) > 0) {
                Detalle.Dias = _DiasDesc;
                Detalle.UltimaPlanilla = false;
            } else {
                if (_Residuo > 0)
                    Detalle.Dias = _DiasDesc - (1 - _Residuo);
            }

            _Dias = _Dias - _DiasDesc;

            lstDesglocePlanillas.push(Detalle);

        }

        return lstDesglocePlanillas;
    }

    const cargarDatos = async () => {

        let response = null;
        let lstPlanillas = [];
        let lstDatos = [];
        let lstDesglocePlanillas = [];

        try {
            spinnerModalMostrar(true, 'Cargando datos', 3);

            response = await ParametrosPlanilla_Consulta_Request(token, empresa);

            if (response.Exitoso) {
                setParametros(response.Datos);
            } else {
                const _login = manageError(response, props, 'ParametrosPlanilla_Consulta_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            response = await TipoPlanilla_Listar_Request(token, empresa);

            if (response.Exitoso) {
                setListaPlanillas(response.Datos);
                lstPlanillas = response.Datos;
            } else {
                const _login = manageError(response, props, 'TipoPlanilla_Listar_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            response = await Autogestion_ConsultarPorEstadoYPeriodo_Request(token, empresa, EstadoGestion, selectedOptionTipo.value, Datos.Desde.value, Datos.Hasta.value, estadosNoEn);

            let TPlanilla = null;

            if (response.Exitoso) {

                if (response.Datos.length > 0 && response.Datos[0].Empleado > 0) {
                    for (let i = 0; i < response.Datos.length; i++) {

                        TPlanilla = lstPlanillas.filter(x => parseInt(x.TipoPlanilla) === parseInt(response.Datos[i].TipoPlanilla))[0];

                        if ((response.Datos[i].Gestion_Tipo !== tipoHorasExtras) && (response.Datos[i].Gestion_Tipo !== tipoConstancia)) {
                            if (moment(response.Datos[i].Gestion_FechaDesde).toDate() <= moment(TPlanilla.Hasta).toDate()) {
                                lstDatos.push(response.Datos[i]);

                                lstDesglocePlanillas = lstDesglocePlanillas.concat(GeneraDesglocePlanillas(response.Datos[i], TPlanilla));
                            }
                        } else {
                            lstDatos.push(response.Datos[i]);
                        }
                    }
                    setListaDesglocePlanillas(lstDesglocePlanillas);
                    setListaDatos(lstDatos);

                }

            }
            else {
                if (response.Datos.length === 1) {
                    setListaDatos([]);
                } else {
                    const _login = manageError(response, props, '');
                    spinnerModalMostrar(false, '', 3);
                    if (_login) { return false; };
                }
            }

            const responseA = await Areas_ListaEmpresa_Request(token, empresa);
            if (responseA.Exitoso) {
                setListaArea(responseA.Datos);
            } else {
                const _login = manageError(responseA, props, 'Areas_ListaEmpresa_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            const responseD = await Departamentos_Lista_Request(token, empresa, -1, -1);
            if (responseD.Exitoso) {
                setListaDepto(responseD.Datos);
            } else {
                const _login = manageError(responseD, props, 'Departamentos_Lista_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            const responseS = await Seccion_Lista_Request(token, empresa, -1, -1, -1);
            if (responseS.Exitoso) {
                setListaSeccion(responseS.Datos);
            } else {
                const _login = manageError(responseS, props, 'Seccion_Lista_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            const responseO = await Oficina_lista_Request(token, empresa, -1, -1, -1 - 1);
            if (responseO.Exitoso) {
                setListaOficina(responseO.Datos);
            } else {
                const _login = manageError(responseO, props, 'Oficina_lista_Request ');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.Autogestion.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)

        } catch (ex) {
            Notificacion.error('Error ' + ex.message);
        } finally {
            spinnerModalMostrar(false, '', 3);
        }

    }

    const handleSelectTipo = (selTipo) => {

        setSelectedOptionTipo(selTipo);

    }

    const handleAnular = () => {
        if (filasSeleccionadas.length === 0) {
            Notificacion.warning('Debe seleccionar al menos un registro');
        } else if (Datos.Comentario.value.length == 0) {
            Notificacion.warning('Debe especificar un comentario para la Anulación');
        } else {
            const optSegopt = optSeg.TOpciones_Menu;
            let validar = validarMenuOpcion(optSegopt.Rechazar.value);
            if (!validar) {
                handleAnularSel();
            }
        }
    }


    const handleAnularSel = () => {

        let resultado = false;
        if (filasSeleccionadas.length === 0) {
            Notificacion.warning('Debe seleccionar al menos un registro');
        } else if (Datos.Comentario.value.length == 0) {
            Notificacion.warning('Debe especificar un comentario para la Anulación');
        } else {

            Swal.fire({
                title: 'Anular',
                html: '<h4>¿Está seguro de anular las peticiones de Autogestión?',
                type: 'question',
                showCancelButton: true,
                confirmButtonColor: '#10a599',
                cancelButtonColor: '#d33',
                confirmButtonText: '<h5><i className="fa fa-check fa-fw"></i> Sí</h5>',
                cancelButtonText: '<h5><i className="fa fa-remove fa-fw"></i> No</h5>',
                reverseButtons: true,
                allowOutsideClick: false,
            }).then((result) => {
                if (result.value) {
                    resultado = true;
                    Anular();
                } else if (result.dismiss === Swal.DismissReason.cancel) {
                    resultado = false;
                }
            });

            setBorrando(false);

        }

    }




    const Anular = async () => {
        let lstDatos = [...listaDatos];
        if (filasSeleccionadas.length > 0) {
            spinnerModalMostrar(true, 'Anulando', 3);

            let _data = [];

            filasSeleccionadas.forEach(x => {

                let res = lstDatos.filter(y => y.Gestion_id === x);

                if (res.length > 0) {
                    res[0].Gestion_Comentario = Datos.Comentario.value;
                    res[0].Gestion_Estado = 'RE';
                    res[0].EmpleadoNombre = usuarioNombre;
                    _data.push(res[0]);
                }

            });

            const response = await Autogestion_Rechazar_Request(token, JSON.stringify(_data));
            spinnerModalMostrar(false, '', 3);

            if (response.Exitoso) {
                setBorrando(true);
                await cargarDatos();
                Notificacion.success('Proceso de Anulación exitoso');
            } else {
                const _login = manageError(response, props, 'Error: ');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };

            }
        } else {
            Notificacion.warning('Debe seleccionar un registro');
        }
    }



    const Aprobar = () => {
        if (filasSeleccionadas.length > 0) {
            const optSegopt = optSeg.TOpciones_Menu;
            let validar = validarMenuOpcion(optSegopt.Aprobar.value);
            if (!validar) {
                AprobarSel();
            }
        } else {
            Notificacion.warning('Debe seleccionar al menos un registro');
        }
    }

    const AprobarSel = async () => {

        if (filasSeleccionadas.length > 0) {


            let _datos = [];
            let _detalle = [];

            filasSeleccionadas.forEach(x => {
                _datos = _datos.concat(listaDatos.filter(y => y.Gestion_id === x));
                _detalle = _detalle.concat(listaDesglocePlanillas.filter(y => y.Id === x));
            });

            spinnerModalMostrar(true, 'Aprobando', 3);
            const response = await Autogestion_Aprobar_Request(token, JSON.stringify(_datos), JSON.stringify(_detalle), usuario, usuarioNombre);
            spinnerModalMostrar(false, '', 3);

            if (response.Exitoso) {
                setBorrando(true);
                await cargarDatos();
                Notificacion.success('Acción de personal generada exitosamente');
            } else {
                const _login = manageError(response, props, 'Error: ');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };

            }
        } else {
            Notificacion.warning('Debe seleccionar al menos un registro');
        }

    }

    const validaSeleccionado = () => {
        if (linea != undefined) {
            return true;
        }
        else {
            Notificacion.error('Debe seleccionar un registro');
            return false;
        }
    }


    const detalleDatos = () => {
        if (validaSeleccionado()) {
            onVerDetalleClick(linea)
        }
    }

    const onDoubleClick = async (e, row, rowIndex) => {
        onVerDetalleClick(row);
    }

    useEffect(() => {
        muestraArbolEmpleados(false);

        const carga = async () => {
            await cargarDatos()
        }
        carga()
    }, [])
    //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;
            //Notificacion.error('No existe opción en la seguridad');
        }
        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.Aprobar.value:
                    AprobarSel();
                    break;
                case _optSegopt.Rechazar.value:
                    handleAnularSel();
                    break;
                default:
                    break;
            }
        }
    }
    return (
        <Fragment>
            <AutogestionInt
                botones={botones}
                Titulo={"Solicitudes de Autogestión"}
                listaDatos={listaDatos}
                selectedOptionTipo={selectedOptionTipo}
                handleSelectTipo={handleSelectTipo}
                listaTipo={listaTipo}
                Datos={Datos}
                onRowSelect={onRowSelect}
                onRowSelectAll={onRowSelectAll}
                columnas={columnas}
                id={'Gestion_id'}
                borrando={borrando}
                handleCheckedChange={handleCheckedChange}
                onhandleChangeDate={onhandleChangeDate}
                onChangeInputEmp={onChangeInputEmp}
                label={label}
                show={show}
                cerrarModal={cerrarModal}
                obtenerAreaDesc={obtenerAreaDesc}
                obtenerDeptoDesc={obtenerDeptoDesc}
                obtenerSeccionDesc={obtenerSeccionDesc}
                obtenerOficinaDesc={obtenerOficinaDesc}
                obtenerEstadoDesc={obtenerEstadoDesc}
                detalle={detalle}
                onDoubleClick={onDoubleClick}
                botonesLista={botonesLista}
            />
            <BotonArriba Delay={10} Visible={100} />
            <ModalSpinner
                selectedModal={SpinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={SpinnerLabel}
                tipoSpinner={SpinnerTipo}
            />
            <ModalSeguridad
                //token={this.props.token}
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </Fragment>
    )

}
export default withRouter(memo(autogestion));