﻿import React, { Fragment, memo, useEffect, useState, useRef } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faSync, faTimes, faSave, faArrowUp, faPrint, faFile } from '@fortawesome/free-solid-svg-icons';
import AccionesPersonalInt from './accionesPersonalInt.jsx';
import { config } from '@fortawesome/fontawesome-svg-core';
import Config from '../../components/Util/constantes.js';
import { SiteRutas, baseUrl } from '../../request/RutasConfig.jsx';
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import { muestraArbolEmpleados, farmatearFechaEstandar, addDays } from '../../components/Util/Util.jsx';
import { Consulta_AccionesPersonalPorEstado_Request, AccionPersonal_Anular_Request, AccionPersonal_Lista_Anular_Request, Traslado_Consulta_Request, AccionPeriodicoDetalle_Lista_Request } from '../../request/AccionesRequest.jsx';
import {
    EmpleadosDistribucion_ListaPorc_Request, EmpleadosDistribucion_GuardaElimina_Request,
    EmpleadosDistribucion_ListaASociado_Request, EmpleadosDistribucion_Guardar_Request
} from '../../request/MantenimientosRequest.jsx';
import {
    Get_Description_Report_Request,
    SetParametrosReporte_Request,
} from "../../request/ReportesRequest.jsx";
import { Empresa_Consulta_Request } from "../../request/SeguridadRequest.jsx";
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import { useLocalStorage } from '../../components/Util/Hooks/useLocalStorage.jsx';
import ModalDistSalarial from './modalDistSalarial.jsx';
import BotonArriba from '../../components/UI/botonArriba/botonArriba.jsx';
import Swal from 'sweetalert2';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.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';
import { consultaDocumento } from '../DocumentoEmpleado/Lista/consultaDocumento.jsx';


export function accionesPersonal(props) {
    const mounted = useRef();
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [ubicacion, setUbicacion] = useLocalStorage('Ubicacion', null);
    const [Pais, setPais] = useSessionStorage('pais');
    const listEst = [{ value: "A", label: "Pendientes" }, { value: "P", label: "Procesados" }, { value: "N", label: "Nulas" }];
    const listEstEmp = [{ value: "A", label: "Activos" }, { value: "I", label: "Inactivos" }];
    const listAP = Config.listaAccionesPersonal;
    const datosConst = {
        Estado: { value: '', attributes: { readOnly: false, focus: false, label: 'Estado', hidden: 'unset' } },
        EstadoEmp: { value: '', attributes: { readOnly: false, focus: false, label: 'Empleado', hidden: 'unset' } },
        AccionPers: { value: '', attributes: { readOnly: false, focus: false, label: 'Acción personal', hidden: 'unset' } },
        fecDesde: { value: addDays(new Date(), -30), attributes: { readOnly: false, focus: false, label: 'Desde', hidden: 'unset' } },
        fecHasta: { value: addDays(new Date(), 1), attributes: { readOnly: false, focus: false, label: 'Hasta', hidden: 'unset' } },
        BotonesAE: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
        //Desde: { value: , attributes: { readOnly: false, focus: false, label: 'Desde' } },
    }
    const [listaEstado, setListaEstado] = useState(listEst);
    const [listaEstadoEmp, setListaEstadoEmp] = useState(listEstEmp);
    const [listaAccionPers, setListaAccionPers] = useState(listAP);
    const [selectedOptionEstado, setSelectedOptionEstado] = useState({ value: 'A', label: "Pendientes" });
    const [selectedOptionEstadoEmp, setSelectedOptionEstadoEmp] = useState({ value: "A", label: "Activos" });
    const [selectedOptionAccionPers, setSelectedOptionAccionPers] = useState({ value: 'TOD', label: 'TOD - Todas' });
    const [datos, setDatos] = useState(datosConst);
    const [listaGralAP, setListaGralAP] = useState([]);
    const [listaGralAPBorrar, setListaGralAPBorrar] = useState({});
    const [listaDetalleAP, setListaDetalleAP] = useState([]);
    const [listaAccionesSel, setListaAccionesSel] = useState([]);
    const cellEditAP = { mode: 'click', blurToSave: true, autoSelectText: true };
    const selectRowAP = { mode: 'checkbox', bgColor: '#10a599', clickToSelect: true, selected: selectAP, onSelect: (row, isSelect) => onRowSelectDet(row, isSelect), onSelectAll: (isSelect, rows) => handleOnSelectAllDet(isSelect, rows), hideSelectColumn: false };
    const columnasAP = [
        { dataField: 'Numero', text: 'N° Acción', csvText: 'No Accion', hidden: false, sort: true, editable: false },
        { dataField: 'Empleado_id', text: 'N° Empleado', csvText: 'No Empleado', hidden: false, sort: true, editable: false },
        { dataField: 'NomCompleto', text: 'Nombre', hidden: false, sort: true, editable: false },
        { dataField: 'Tipo', text: 'Tipo', hidden: false, sort: false, editable: false },
        { dataField: 'Fecha', text: 'Fecha Aplic', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Fecha) }, editable: false },
        { dataField: 'Desde', text: 'Fecha Inicial', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Desde) }, editable: false },
        { dataField: 'Hasta', text: 'Fecha Final', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Hasta) }, editable: false },
        { dataField: 'llave', text: 'llave', hidden: true, sort: true, editable: false, csvExport: false },
    ]
    const [listaEmpDist, setListaEmpDist] = useState([]);
    const [selectModalEmp, setSelectModalEmp] = useState(false);
    const [detalleVisible, setDetalleVisible] = useState('none');
    const columnasDAP = [
        { dataField: 'Numero', text: 'N° Acción', csvText: 'No Accion', hidden: false, sort: true, editable: false },
        { dataField: 'Desde', text: 'Fecha Inicial', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Desde) }, editable: false },
        { dataField: 'Hasta', text: 'Fecha Final', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Hasta) }, editable: false },
        { dataField: 'DiasAAplicar', text: 'Días', csvText: 'Dias', hidden: false, sort: true, editable: false },
        { dataField: 'UltimoRegStr', text: 'Último', csvText: 'Ultimo', hidden: false, sort: true, editable: false },
        { dataField: 'Estado', text: 'Activo', hidden: false, sort: false, editable: false },
        { dataField: 'IdDetalle', text: 'llave', hidden: true, sort: true, editable: false, csvExport: false, csvExport: false },
    ]

    const [selectAP, setSelectAP] = useState([]);
    const [verLHOCAP, setVerLHOCAP] = useState(false);
    const [verLHOCAPD, setVerLHOCAPD] = useState(false);
    const selectRowDAP = { hideSelectColumn: true };
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    const reporteId = 48;
    let historyMenu = useHistory();

    //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('');

    //documentos 
    const [docMant, setDocMant] = useState(undefined);

    const botones = [

        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnAnularCDD",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => anularDatos(),
            leyenda: "",
            iclase: faTimes,
            tooltip: "Anular"
        },
        {
            name: "btnDocumentosMant",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleDocumentos(),
            leyenda: "",
            iclase: faFile,
            tooltip: "Documentos"
        },
        {
            name: "btnImprimir",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleImprimir(),
            leyenda: "",
            iclase: faPrint,
            tooltip: "Imprimir"
        }
    ]
    const botonesMod = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cerrarModalDetEmp(false),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        }
    ]

    const botonesLista = [

        {
            name: "btnRefescarCDD",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cargarDatos(),
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        },
    ]
    useEffect(() => {

        if (!mounted.current) {
            muestraArbolEmpleados(false);
            const carga = async () => {
                await cargarDatos()
            }
            carga();
            mounted.current = true;
        }

    }, [])

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }
    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3);
        const _SelectedOptionAccionPers = selectedOptionAccionPers;
        const _SelectedOptionEstadoEmp = selectedOptionEstadoEmp;
        const _SelectedOptionEstado = selectedOptionEstado;
        const _Datos = datos;
        const pEmpresa = empresa;
        setVerLHOCAP(false);
        setSelectAP([]);
        await cargaListaGralAp(pEmpresa, _SelectedOptionEstado.value, _SelectedOptionEstadoEmp.value, _Datos.fecDesde.value, _Datos.fecHasta.value, _SelectedOptionAccionPers.value);

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.GeneraldeAcciones.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)

        spinnerModalMostrar(false, '', 3);
        //setVerLHOCAP(false);
    }

    const cargaListaGralAp = async (pEmpresa, pAccionPersEst, pEstadoEmp, pFecDesde, pFecHasta, pTipoAccion) => {
        const _FecDesde = moment.utc().year(pFecDesde.getFullYear()).month(pFecDesde.getMonth()).date(pFecDesde.getDate()).endOf('day').toISOString();
        const _FecHasta = moment.utc().year(pFecHasta.getFullYear()).month(pFecHasta.getMonth()).date(pFecHasta.getDate()).endOf('day').toISOString();
        setVerLHOCAP(false);
        const response = await Consulta_AccionesPersonalPorEstado_Request(token, pEmpresa, pAccionPersEst, pEstadoEmp, _FecDesde, _FecHasta, pTipoAccion);
        setListaAccionesSel([]);
        let _datos = response.Datos;
        if (response.Exitoso) {
            if (_datos.length > 1) {
                setListaGralAP(_datos);
            } else {
                if (_datos[0].Empresa > 0) {
                    setListaGralAP(_datos);
                } else {
                    setListaGralAP([]);
                    setVerLHOCAP(false);
                }
            }
        }
        else {
            setVerLHOCAP(false);
            setListaGralAP([]);
            if (response.Mensaje.trim().length > 0) {
                const _login = manageError(response, props, '');
                if (_login) { spinnerModalMostrar(false, '', 3); return false; };

            }
        }
    }

    const cargaListaDetalleAp = async (pEmpleado, pNumero, pAccionPersEst) => {
        const response = await AccionPeriodicoDetalle_Lista_Request(token, empresa, pEmpleado, pNumero, pAccionPersEst);
        if (response.Exitoso) {
            let _datos = response.Datos;
            if (_datos.length > 1) {
                setListaDetalleAP(_datos);
            } else {
                if (_datos[0].Empresa > 0) {
                    setListaDetalleAP(_datos);
                } else {
                    setListaDetalleAP([]);
                }
            }
        }
        else {
            setListaDetalleAP([]);
            const _login = manageError(response, props, '');
            if (_login) { spinnerModalMostrar(false, '', 3); return false; };
        }
    }
    const AnularDetalle = () => {
        let _listaGralAP = listaGralAP;
        let _listaGralAPBorrar = listaGralAPTempBorrar;
        _listaGralAPBorrar.forEach(function (Ing) {
            _listaGralAP = _listaGralAP.filter(item => item.Linea != Ing.Linea);
        })
        let _indice = 1;
        _listaGralAP.map(function (item) {
            item.Linea = _indice++;
        });

        setListaGralAP(_listaGralAP);
    }

    const ListaDeAccionP = () => {
        let _listaAPA = [];
        selectAP.forEach(x => {
            for (let i = 0, len = listaGralAP.length; i < len; i++) {
                if (listaGralAP[i].llave == x) {
                    listaGralAP[i].Usuario_Modifica = usuario;
                    _listaAPA.push(listaGralAP[i]);
                }
            }
        });
        return _listaAPA;
    }


    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }


    const anularDatos = () => {
        //console.log(`Datos de llaves selecionado en la tabla: ${JSON.stringify(selectAP)}`);


        const _selectedOptionEstado2 = selectedOptionEstado;
        if (_selectedOptionEstado2.value == 'A') {
            const _listaGralAPBorrar2 = listaGralAPBorrar;
            let eliminar = false;
            let _titulo = '';
            if (_listaGralAPBorrar2.Empleado_id != undefined) {
                const optSegopt = optSeg.TOpciones_Menu;
                let validar = validarMenuOpcion(optSegopt.Anular.value);
                if (!validar) {
                    anularDatosSel();
                }
            } else {
                Notificacion.warning('Debe seleccionar al menos un línea');
                eliminar = false;
            }
            if (eliminar == true) {
                //await cargarDatos();
            }
        } else {
            Notificacion.warning('El estado de la acción debe ser pendiente');
        }
    }

    const anularDatosSel = async () => {
        const _selectedOptionEstado = selectedOptionEstado;
        if (_selectedOptionEstado.value == 'A') {
            const _listaGralAPBorrar = listaGralAPBorrar;
            let eliminar = false;
            let _titulo = '';
            if (selectAP.length > 0) {
                _titulo = 'Desea Anular las Acciones de Personal SELECCIONADAS?';

                eliminar = handleButtonDel(_titulo);
            } else {
                Notificacion.warning('Debe seleccionar al menos un línea');
                eliminar = false;
            }
            if (eliminar == true) {
                //await cargarDatos();
            }
        } else {
            Notificacion.warning('El estado de la acción debe ser pendiente');
        }
    }

    const anulacionDatos = async () => {
        let _data = [];//listaGralAPBorrar;
        let resultado = '';
        let resultadoAn = '';
        let resultadoGE = '';
        let resultadoTras = '';
        let spinnerLabel = 'Ingresando datos';
        //props.spinnerModalMostrar(true, spinnerLabel, 3)
        //_data.Usuario_Modifica = usuario;
        const _listaData = ListaDeAccionP();

        resultado = await AccionPersonal_Lista_Anular_Request(token, JSON.stringify(_listaData));
        spinnerModalMostrar(false, '', 3)
        if (resultado.Exitoso == true) {
            for (let i = 0, len = _listaData.length; i < len; i++) {
                _data = _listaData[i];
                if ((_data.Tipo.trim().toUpperCase() == 'TRA') && (_data.Version.trim().toUpperCase() == "V")) {
                    //debe guardar distribucion
                    resultadoTras = await Traslado_Consulta_Request(token, empresa, _data.Empleado_id, _data.Numero);
                    if (resultadoTras.Exitoso == true) {
                        resultadoAn = await EmpleadosDistribucion_ListaPorc_Request(token, empresa, _data.Empleado_id, resultadoTras.Datos.AreaDestino, resultadoTras.Datos.DeptoDestino,
                            resultadoTras.Datos.SeccionDestino, resultadoTras.Datos.OficinaDestino, 0);
                        if (resultadoAn.Exitoso == true) {
                            if (resultadoAn.Datos[0].Empresa > 0) {

                                let _datosDist = resultadoAn.Datos;
                                _datosDist[0].Area = resultadoTras.Datos.AreaOrigen;
                                _datosDist[0].Depto = resultadoTras.Datos.DeptoOrigen;
                                _datosDist[0].Seccion = resultadoTras.Datos.SeccionOrigen;
                                _datosDist[0].Oficina = resultadoTras.Datos.OficinaOrigen;
                                _datosDist[0].Porcentaje = 100;
                                _datosDist[0].UsuarioModifica = usuario;
                                resultadoGE = await EmpleadosDistribucion_GuardaElimina_Request(token, empresa, _data.Empleado_id, usuario, JSON.stringify(_datosDist));
                                if (resultadoGE.Exitoso == false) {
                                    Notificacion.error(`Error distribucióon : ${resultadoGE.Mensaje}`);
                                }

                            } /*else {
                                //llama el modal para ubicacion
                                setSelectModalEmp(true);
                                let _Area = -1;
                                let _Depto = -1;
                                let _Seccion = -1;
                                let _Oficina = -1;
                                let _Ubicacion = ubicacion;
                                _Area = parseInt(_Ubicacion.substring(_Ubicacion.search("A") + 1, _Ubicacion.search("D")));
                                _Depto = parseInt(_Ubicacion.substring(_Ubicacion.search("D") + 1, _Ubicacion.search("S")));
                                _Seccion = parseInt(_Ubicacion.substring(_Ubicacion.search("S") + 1, _Ubicacion.search("O")));
                                _Oficina = parseInt(_Ubicacion.substring(_Ubicacion.search("O") + 1, _Ubicacion.length));
                                let _listaEmpDist = await EmpleadosDistribucion_ListaASociado(token, empresa, _data.Empleado_id, _Area, _Depto, _Seccion, _Oficina);
                                // _listaEmpDist.map(function(dato){
                                //     if((dato.Area == _Area) && (dato.Depto == _Depto) && (dato.Seccion == _Seccion) && (dato.Oficina == _Oficina) ){
                                //       dato.Porcentaje = 100;
                                //     };

                                //});
                                setSelectModalEmp(true);
                                await cerrarModalDetEmp(true);
                                setListaEmpDist(_listaEmpDist);
                            }*/
                        }
                    }/* else {
                        const _login = manageError(resultadoTras, props, 'Error: ');
                        spinnerModalMostrar(false, '', 3);
                        if (_login) { return false; };
                    }*/

                } /*else {
                    Notificacion.success('Se anularon las acciones con éxito');
                    await cargarDatos();
                }*/
            }//for
            Notificacion.success('Se anularon las acciones con éxito');
            await cargarDatos(); 
        }
        else {
            //console.log(`resultado.Mensaje antes if: ${resultado.Mensaje}`)
            if (isNaN(resultado.Mensaje.trim())) {
                const _login = manageError(resultado, props, 'Error: ');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };
            }
            else {
                Notificacion.success('Se anularon las acciones con éxito');
                await cargarDatos();
            }
        }

    }


    const handleButtonDel = (pTitulo) => {
        let resultado = false;

        Swal.fire({
            title: pTitulo,
            //text: '',
            type: 'question',
            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>',
            //backdrop:"linear-gradient(yellow, orange)",
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                resultado = true;
                anulacionDatos();
                // For more information about handling dismissals please visit
                // https://sweetalert2.github.io/#handling-dismissals
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
                //    Swal.fire(
                //      'Cancelled',
                //      'Your imaginary file is safe :)',
                //      'error'
                //    )
            }
        })
        return resultado;
    }

    const onRowSelectDet = (row, isSelect) => {
        let _listaGralAPBorrar = {};
        let lista = [...listaAccionesSel];
        let _docMant = undefined;
        let _listaAP = [...selectAP];
        if (isSelect) {
            _listaGralAPBorrar = row;
            lista.push(row.Numero);
            _docMant = row;
            _listaAP.push(row.llave);

        } else {
            _listaGralAPBorrar = {};
            lista = lista.filter(x => x !== row.Numero);
            _docMant = undefined;
            _listaAP = _listaAP.filter(x => x !== row.llave);
        }

        setListaGralAPBorrar(_listaGralAPBorrar);
        setListaAccionesSel(lista);
        setDocMant(_docMant);
        setSelectAP(_listaAP)

        return true;

    }
    const rowEventsAP = {
        onClick: async (e, row, rowIndex) => {
            if (row.Version == 'N') {
                setDetalleVisible('unset');
                const _SelectedOptionEstado = selectedOptionEstado;

                await cargaListaDetalleAp(row.Empleado_id, row.Numero, _SelectedOptionEstado.value)
            } else {
                setDetalleVisible('none');
            }
        }
    }
    const rowStyleAP = (row, rowIndex) => {
        const style = {};
        //if (row.CorteRealizado === true) {
        //    style.color = '#21aba0';
        //} else {
        //    style.color = '#b0b0b0';
        // }
        return style;
    }

    const handleOnSelectAllDet = (isSelect, rows) => {
        //const _listaAP = rows.map(r => r.llave);
        if (isSelect) {
            setListaAccionesSel(rows.map(x => x.Numero));
            setSelectAP(rows.map(r => r.llave));
            return rows.map(x => x.llave);
        } else {
            setListaAccionesSel([]);
            setSelectAP([])
            return [];
        }

    }


    const onhandleChangeDate = (date, id) => {
        const name = id;
        const value = date;
        let newAttributes = datos[name].attributes;
        // newAttributes.focus = true; //Se asigna foco al componente 
        const _Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
        setDatos(_Datos);
        limpiaPantalla();
    }
    const onhandleSelectedOptionEstado = (pSelectedOptionEstado) => {
        setSelectedOptionEstado(pSelectedOptionEstado);
        limpiaPantalla();
    }
    const onhandleSelectedOptionEstadoEmp = (pSelectedOptionEstadoEmp) => {
        setSelectedOptionEstadoEmp(pSelectedOptionEstadoEmp);
        limpiaPantalla();
    }
    const onhandleSelectedOptionAp = (pSelectedOptionAccionPers) => {
        setSelectedOptionAccionPers(pSelectedOptionAccionPers);
        limpiaPantalla();
    }

    const EmpleadosDistribucion_ListaASociado = async (pToken, pEmpresa, pId, pArea, pDepto, pSec, pOfic) => {
        let datos = [];
        const response = await EmpleadosDistribucion_ListaASociado_Request(pToken, pEmpresa, pId, pArea, pDepto, pSec, pOfic);
        if (response.Exitoso) {
            datos = response.Datos;
        } else {
            const _login = manageError(response, props, 'EmpleadosDistribucion_ListaASociado_Request ');
            if (_login) { spinnerModalMostrar(false, '', 3); return false; };
        }
        return datos;
    }
    const rowEventsDist = {
        onClick: (e, row, rowIndex) => {
            //console.log(`clicked on row with index: ${rowIndex}`);
            //console.log({ row });
            //console.log({ e });
        }//,
        // onMouseEnter: (e, row, rowIndex) => {
        //   console.log(`enter on row with index: ${rowIndex}`);
        // }
    };
    const rowStyleSal = (row, rowIndex) => {
        const style = {};
        if (row.Porcentaje > 0) {
            style.color = '#21aba0';
        } else {
            style.color = '#b0b0b0';
        }

        return style;
    }
    //modal

    const validarDatos = () => {
        const pEmpleadoD = listaEmpDist;
        let porcTortal = 0;
        pEmpleadoD.map(function (item) {
            porcTortal += parseFloat(item.Porcentaje);
        });
        if (porcTortal != 100) {
            Notificacion.error(`La suma de porcenajes debe ser igual a 100`);
            return false;
        }
        return true;
    }

    const limpiaPantalla = () => {
        //console.log('limpiaPantalla');
        setListaDetalleAP([]);
        setListaGralAP([]);
        setListaGralAPBorrar({});
        setVerLHOCAP(false);
    }
    ///modal /////
    const cerrarModalDetEmp = async (pEstado) => {
        if (pEstado == false) {
            let _validacion = validarDatos();
            let resultado = '';
            const _data = listaGralAPBorrar;
            if (_validacion) {
                const pEmpleadoD = listaEmpDist.filter(item => item.Porcentaje != 0);
                spinnerModalMostrar(true, '', 3)
                resultado = await EmpleadosDistribucion_GuardaElimina_Request(token, empresa, _data.Empleado_id, usuario, JSON.stringify(pEmpleadoD));

                spinnerModalMostrar(false, '', 3)
                if (resultado.Exitoso == true) {
                    Notificacion.success('Se realizó la distribucióncon éxito');
                }
                else {
                    const _login = manageError(resultado, props, 'Error: ');
                    if (_login) { spinnerModalMostrar(false, '', 3); return false; };
                }
                setSelectModalEmp(pEstado);
            }
        }
    }

    //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.Anular.value:
                    anularDatosSel();
                    break;
                default:
                    break;
            }
        }
    }
    // impresion
    const handleImprimir = () => {
        let resultado = false;
        Swal.fire({
            title: '¿Desea imprimir las Acciones de Personal seleccionadas?',

            type: 'question',
            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;
                imprimirReporte();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        })
        return resultado;
    }

    const imprimirReporte = async () => {
        const Resumen = '';
        const IncluirResumen = false;
        let ReportNombre = '';
        let NombreEmpresa = '';
        let Numeros = '';
        const Reporte = reporteId;

        try {

            spinnerModalMostrar(true, 'Cargando', 3);

            if (listaAccionesSel.length == 0) {
                Notificacion.error('¡Debe seleccionar al menos un registro!');
                return;
            }

            Numeros = listaAccionesSel.toString();
            // console.log(Numeros);
            let result = await Get_Description_Report_Request(token, reporteId);

            if (result.Exitoso) {
                ReportNombre = result.Datos.ReportTitulo;
            } else {
                const _login = manageError(result, props, '');
                if (_login) { spinnerModalMostrar(false, '', 3); return false; };
            }

            result = await Empresa_Consulta_Request(token, empresa);

            if (result.Exitoso) {
                NombreEmpresa = result.Datos.Nombre;
            } else {
                const _login = manageError(result, props, '');
                if (_login) { spinnerModalMostrar(false, '', 3); return false; };
            }

            const params = {
                Empresa: empresa,
                IncluirResumen,
                Resumen,
                ReportNombre,
                NombreEmpresa,
                Reporte,
                Numeros
            }

            let data = await SetParametrosReporte_Request(token, params);

            if (data.hasOwnProperty("Error")) {
                Notificacion.error(`${data.Error}`);
            } else {
                const myWindow = window.open();
                setTimeout(() => {
                    myWindow.location.replace(
                        `${baseUrl}ReportesSSR/MuestraReporte.aspx?ReporteId=${reporteId}&Empresa=${empresa}&Pais=${Pais}`
                    );
                }, 1);
            }
        } catch (err) {
            console.log(err);
            Notificacion.error('Ocurrió un error');
        } finally {
            spinnerModalMostrar(false, '', 3);
        }

    }
    //documentos
    const handleDocumentos = () => {

        if (validaSeleccionado()) {

            const _AP = docMant.Numero;
            const _Empleado = docMant.Empleado_id;
            //            console.log(`handleDocumentos: _AP = ${_AP}, _Empleado = ${_Empleado}, docMant = ${JSON.stringify(docMant)}`);
            historyMenu.push(`${SiteRutas.ListaDocumentosAP}/${_Empleado}/${_AP}`);
        }

    }

    //Valida que se haya seleccionado un dato para los docuentos, utiliza el ultimo seleccionado
    const validaSeleccionado = () => {

        if (docMant != undefined) {
            return true;
        }
        else {
            Notificacion.error('Debe seleccionar un registro');
            return false;
        }
    }
    return (
        <Fragment>
            <AccionesPersonalInt
                Datos={datos}
                Titulo={"Lista de Acciones de Personal"}
                botones={botones}
                selectedOptionEstado={selectedOptionEstado}
                selectedOptionEstadoEmp={selectedOptionEstadoEmp}
                selectedOptionAccionPers={selectedOptionAccionPers}
                listaEstado={listaEstado}
                listaEstadoEmp={listaEstadoEmp}
                listaAccionPers={listaAccionPers}
                onhandleSelectedOptionEstado={onhandleSelectedOptionEstado}
                onhandleSelectedOptionEstadoEmp={onhandleSelectedOptionEstadoEmp}
                onhandleSelectedOptionAp={onhandleSelectedOptionAp}
                onhandleChangeDate={onhandleChangeDate}
                selectRowAP={selectRowAP}
                rowEventsAP={rowEventsAP}
                cellEditAP={cellEditAP}
                rowStyleAP={rowStyleAP}
                columnasAP={columnasAP}
                listaGralAP={listaGralAP}
                listaDetalleAP={listaDetalleAP}
                detalleVisible={detalleVisible}
                columnasDAP={columnasDAP}
                selectRowDAP={selectRowDAP}
                verLHOCAP={verLHOCAP}
                verLHOCAPD={verLHOCAPD}
                botonesLista={botonesLista}
            />
            <BotonArriba Delay={10} Visible={100} />

            <ModalDistSalarial
                show={selectModalEmp}
                //datos={Datos}
                cerrarModal={cerrarModalDetEmp}
                titulo={"Cambiar Distribución Salarial"}
                botones={botonesMod}
                listaEmpDist={listaEmpDist}
                rowEventsDist={rowEventsDist}
                rowStyleSal={rowStyleSal}
            />
            <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(accionesPersonal));