﻿import React, { Fragment, memo, useEffect, useState } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faSave, faTrash, faPlus } from '@fortawesome/free-solid-svg-icons';
import HijosInt from './HijosInt.jsx';
import ModalBusquedaEmp from '../../components/UI/modalBusqueda/modalBusquedaFiltro.jsx';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import { muestraArbolEmpleados, farmatearFechaEstandar, datosArbol } from '../../components/Util/Util.jsx';
//Invocaciones datos
import { Hijos_Listar_Request, Hijos_Guardar_Request, Empleados_Lista_Request, Empleados_Listar_Busqueda_Request } from "../../request/MantenimientosRequest.jsx";
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
//utilitarios
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import Swal from 'sweetalert2';
import { textFilter } from 'react-bootstrap-table2-filter';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';

//Seguridad
import Session from '../../components/Util/session/index.jsx';
import Config from '../../components/Util/constantes.js';
import { Obtener_MenuOpciones_Lista_Request, Obtener_MenuNombre_Request } from "../../request/MenuRequest.jsx"
import ModalSeguridad from "../Seguridad/ModalSeguridad.jsx";
import optSeg from '../../components/Util/seg-menu-opciones.js';

function hijos(props) {

    let historyMenu = useHistory();
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [empresaNombre, setEmpresaNombre] = useSessionStorage('empresaNombre');
    const [codigo, setCodigo] = useState('');
    const [categoria, setCategoria] = useState([]);
    const [id, setId] = useState('');
    const [fileSelector, setFileSelector] = useState(undefined);
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    const botones = [

        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnGuardar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => ingresarDatos(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        }
    ]
    const botonesLista = [

        {
            name: "btnInglista",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => ingresarDetalle(),
            leyenda: "",
            iclase: faPlus,
            tooltip: "Ingresar"
        },
        {
            name: "btnElimlista",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => eliminarDetalle(),
            leyenda: "",
            iclase: faTrash,
            tooltip: "Eliminar"
        }
    ]

    const listaCampos = {
        Empleado: { value: '', attributes: { readOnly: false, focus: false, label: 'Empleado', hidden: 'unset', maxLength: "6", Editando: false } },
        EmpleadoNombre: { value: '', attributes: { readOnly: true, focus: false, label: 'Nombre', hidden: 'unset', maxLength: "255", Editando: false } },
        NombreHijo: { value: '', attributes: { readOnly: false, focus: false, label: 'Nombre', hidden: 'unset', maxLength: "255", Editando: false } },
        fechaNacimiento: { value: new Date(), attributes: { readOnly: false, focus: false, label: 'Fecha Nacimiento', hidden: 'unset', maxLength: "100", Editando: false } },
        BotonesAE: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
    }

    const DatosM = {
        "Empresa": 0,
        "Empleado": 0,
        "Linea": 0,
        "Nombre": "",
        "Fec_Nacimiento": "",
        "Usuario": "",
        "Usuario_Modifica": "",
        "Usuario_Fecha_Actualiza": "",
        "MsgError": ""
    }




    const columnasHijo = [
        { dataField: 'Empresa', text: 'Empresa', hidden: true, sort: true, editable: false },
        { dataField: 'Linea', text: 'Empresa', hidden: true, sort: true, editable: false },
        { dataField: 'Nombre', text: 'Nombre', hidden: false, sort: true, editable: false },
        //{ dataField: 'Fec_Nacimiento', text: 'Nacimiento', hidden: false, sort: true, filter: textFilter({}), editable: false },
        { dataField: 'Fec_Nacimiento', text: 'Nacimiento', hidden: false, sort: true, formatter: (row, cell) => { return farmatearFechaEstandar(cell.Fec_Nacimiento) }, editable: false },
    ]

    const [datos, setDatos] = useState(listaCampos);
    const [listaHijos, setListaHijos] = useState([]);
    const [listaHijosTempBorrar, setListaHijosTempBorrar] = useState([]);
    const cellEditDet = { mode: 'click', blurToSave: true, autoSelectText: true };
    const selectRowDet = { mode: 'checkbox', clickToSelect: false, onSelect: (row, isSelected) => onRowSelectDet(row, isSelected), onSelectAll: (isSelect, rows) => handleOnSelectAllDet(isSelect, rows), hideSelectColumn: false, bgColor: '#10a599' };
    //modal
    const [selectModalEmp, setSelectModalEmp] = useState(undefined);
    const [listaEmpleados, setListaEmpleados] = useState([]);
    const [selectedEmpleado, setSelectedEmpleado] = useState(undefined);
    const columnasEmp = [{ dataField: 'Empleado', text: 'Número', csvText: 'Número', sort: true }, { dataField: 'NombreCompleto', text: 'Nombre', sort: true }];
    const selectRowEmp = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row) => onRowSelectEmp(row), bgColor: '#10a599' };

    //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 spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3)
        const response = await Empleados_Listar_Busqueda_Request(token, empresa, -1, -1, -1, -1, -1, `'${Config.ee_activo}','${Config.ee_Contratado}','${Config.ee_Suspendido}','${Config.ee_Permiso}'`);
        if (response.Exitoso) {
            const _datos = response.Datos;//.filter(item => item.estado == 'A');
            setListaEmpleados(_datos);
        }
        else {
            const _login = manageError(response, props, '');
            spinnerModalMostrar(false, '', 3);
            if (!_login) { volverAtras(); }
            return false;
        }

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.Hijos.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);
    }
    const cargaListaHijos = async (pEmpleado) => {
        let spinnerLabel = 'Cargando datos de hijos...';
        spinnerModalMostrar(true, spinnerLabel, 3);
        const response = await Hijos_Listar_Request(token, empresa, pEmpleado);
        if (response.Exitoso) {
            let _datos = response.Datos;
            if (_datos.length > 1) {
                let _indice = 1;
                _datos.map(function (item) {
                    item.Linea = _indice++;
                });
                setListaHijos(_datos);
            } else {
                if (_datos[0].Empresa > 0) {
                    setListaHijos(_datos);
                } else {
                    setListaHijos([]);
                }
            }
        }
        else {
            const _login = manageError(response, props, '');
            spinnerModalMostrar(false, '', 3);
            if (!_login) { volverAtras(); }
            return false;
        }
        spinnerModalMostrar(false, '', 3);
    }

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => {
            await cargarDatos()
        }
        carga()
    }, [])


    //procesar datos

    //procesar datos

    const ingresarDatos = async () => {
        const _id = id;
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Guardar.value;// (_id > 0) ? optSegopt.Editar.value : optSegopt.Guardar.value;
        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await ingresarDatosSel();
        }
    }

    const ingresarDatosSel = async () => {
        const _data = listaHijos;
        let resultado = '';
        let spinnerLabel = 'Ingresando datos';

        if (datos.Empleado.value === '') {
            Notificacion.warning('Debe seleccionar un Empleado');
            return;
        }

        spinnerModalMostrar(true, spinnerLabel, 3)
        resultado = await Hijos_Guardar_Request(token, empresa, datos.Empleado.value, JSON.stringify(_data));
        spinnerModalMostrar(false, '', 3)
        if (resultado.Exitoso == true) {
            Notificacion.success('Se actualizó la información con éxito');
        }
        else {
            if (isNaN(resultado.Mensaje.trim())) {
                Notificacion.error(`Error: ${resultado.Mensaje}`);
                const _login = manageError(resultado, props, 'Error: ');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };
            }
            else {
                Notificacion.success('Se almacenó la información con éxito');
            }
        }
        //Notificacion.success('Se almacenó la información con éxito');
        volverAtras();
    }
    const rowEventsDet = {
        onClick: (e, row, rowIndex) => {
        }
    }



    const rowStyleSal = (row, rowIndex) => {
        const style = {};
        //if (row.CorteRealizado === true) {
        //    style.color = '#21aba0';
        //} else {
        //    style.color = '#b0b0b0';
        // }
        return style;
    }
    const onRowSelectDet = (row, isSelect) => {
        let _listaHijosTempBorrar = listaHijosTempBorrar;
        if (isSelect) {
            _listaHijosTempBorrar.push(row);
        } else {
            _listaHijosTempBorrar = _listaHijosTempBorrar.filter(r => r.Linea != row.Linea);
        }
        setListaHijosTempBorrar(_listaHijosTempBorrar);
        return true;

    }


    const handleOnSelectAllDet = (isSelect, rows) => {
        let _listaHijosTempBorrar = [];
        let _listaHijos = listaHijos;
        if (isSelect) {
            let lista = _listaHijos.map(r => r.Linea);
            _listaHijosTempBorrar = _listaHijos;
            setListaHijosTempBorrar(_listaHijosTempBorrar);
            return lista;
        }
        setListaHijosTempBorrar(_listaHijosTempBorrar);
    }

    const eliminarDetalle = () => {
        const _listaHijosTempBorrar2 = listaHijosTempBorrar;
        if (_listaHijosTempBorrar2.length > 0) {
            const optSegopt = optSeg.TOpciones_Menu;
            let validar = validarMenuOpcion(optSegopt.Eliminar.value);
            if (!validar) {
                eliminarDetalleSel();
            }
        } else {
            Notificacion.warning('Debe seleccionar al menos un línea');
        }
    }


    const eliminarDetalleSel = () => {

        const _listaHijosTempBorrar = listaHijosTempBorrar;
        let eliminar = false;
        let _titulo = '';
        if (_listaHijosTempBorrar.length > 0) {
            if (_listaHijosTempBorrar.length == 1) {
                _titulo = 'Desea Eliminar el hijo seleccionado?';
            } else {
                _titulo = 'Desea Eliminar los hijos seleccionados?';;
            }
            eliminar = handleButtonDel(_titulo);
        } else {
            Notificacion.warning('Debe seleccionar al menos un línea');
            eliminar = false;
        }
        if (eliminar == true) {
            BorraDetalle();
        }
    }
    const BorraDetalle = () => {
        let _listaHijos = listaHijos;
        let _listaHijosTempBorrar = listaHijosTempBorrar;
        _listaHijosTempBorrar.forEach(function (Ing) {
            _listaHijos = _listaHijos.filter(item => item.Linea != Ing.Linea);
        })
        let _indice = 1;
        _listaHijos.map(function (item) {
            item.Linea = _indice++;
        });

        setListaHijos(_listaHijos);
    }

    const ingresarDetalle = async () => {
        if (validarDatosDet()) {
            const _id = id;
            const optSegopt = optSeg.TOpciones_Menu;
            const _value = optSegopt.Nuevo.value;// (_id > 0) ? optSegopt.Editar.value : optSegopt.Nuevo.value;
            let validar = validarMenuOpcion(_value);
            if (!validar) {
                await ingresarDetalleSel();
            }
        }

    }

    const ingresarDetalleSel = (event) => {
        if (validarDatosDet()) {
            setListaHijos([...listaHijos, {
                Empresa: empresa,
                Empleado: datos.Empleado.value,
                Linea: (listaHijos.length + 1),
                Nombre: datos.NombreHijo.value,
                //Fec_Nacimiento: farmatearFechaEstandar(datos.fechaNacimiento.value),
                Fec_Nacimiento: datos.fechaNacimiento.value,
                Usuario: usuario,
                Usuario_Modifica: usuario,
                Usuario_Fecha_Actualiza: "",
                MsgError: ""
            }]);

            let _Campos = datos;
            _Campos.NombreHijo.value = '';
            _Campos.fechaNacimiento.value = new Date();
            setDatos(_Campos);
        }
    }
    const validarDatosDet = () => {
        if (datos.NombreHijo.value.trim().length == 0) {
            Notificacion.error('Debe ingresar un nombre');
            return false;
        }
        let _Fecha = new Date();
        if (datos.fechaNacimiento.value > _Fecha) {
            Notificacion.error('La fecha de nacimiento debe ser menor a la de fecha de hoy');
            return false;
        }
        return true;
    }
    const handleButtonDel = (pTitulo) => {
        let resultado = false;

        Swal.fire({
            title: pTitulo,
            //text: '',
            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>',
            //backdrop:"linear-gradient(yellow, orange)",
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                resultado = true;
                BorraDetalle();
                // 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;
    }

    //eventos
    const onChangeInput = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        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);
    }


    const onKeyPressEmp = async (e) => {
        const _empleado = e.target.value.toString().trim();
        if (e.charCode == 13) {
            if (_empleado.length > 0) {
                const listEmpleado = listaEmpleados;
                const Empleado = listEmpleado.filter(item => item.Empleado == _empleado);
                let Datos = datos;
                if (Empleado.length > 0) {
                    Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
                    Datos.Empleado.value = Empleado[0].Empleado;
                    //const listaHijos =  await cargaListaHijos(Empleado[0].Empleado);
                    await cargaListaHijos(Empleado[0].Empleado);
                    setDatos(Datos);
                    //setListaHijos([]);
                } else {
                    Datos.Empleado.value = '';
                    setDatos(Datos);
                    Notificacion.warning('Empleado no existe');
                }
            }
        }
    }
    const onBlurEmpl = async () => {
        let Datos = datos;
        if (Datos.Empleado.value.toString().trim().length > 0) {
            const _listEmpleado = listaEmpleados;
            const Empleado = _listEmpleado.filter(item => item.Empleado == Datos.Empleado.value);
            Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
            Datos.Empleado.value = Empleado[0].Empleado;
            if (Empleado.length > 0) {
                Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
                Datos.Empleado.value = Empleado[0].Empleado;
                //const listaHijos =  await cargaListaHijos(Empleado[0].Empleado);
                await cargaListaHijos(Empleado[0].Empleado);
                setDatos(Datos);
                //setListaHijos(listaHijos);
            } else {
                Datos.Empleado.value = '';
                setDatos(Datos);
                Notificacion.warning('Empleado no existe');
            }
        }
    }


    const onChangeInputEmp = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        let newAttributes = datos[name].attributes;
        // newAttributes.focus = true; //Se asigna foco al componente 
        let Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
        Datos.EmpleadoNombre.value = '';
        Datos.NombreHijo.value = '';
        Datos.fechaNacimiento.value = new Date();
        setDatos(Datos);
        setListaHijosTempBorrar([]);
        setListaHijos([]);
    }
    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);
    }
    //*********MODAL**************************************/

    const seleccionModalEmp = async () => {
        let _selectedEmpleado = selectedEmpleado;

        if (!!_selectedEmpleado) {
            let Datos = datos;
            Datos.EmpleadoNombre.value = _selectedEmpleado.NombreCompleto;
            Datos.Empleado.value = _selectedEmpleado.Empleado;
            //const listaHijos = await cargaListaHijos(_selectedEmpleado.Empleado);
            await cargaListaHijos(_selectedEmpleado.Empleado);
            setSelectModalEmp(undefined)
            setSelectedEmpleado(undefined);
            setDatos(Datos);
            //setListaHijos(listaHijos);
        }
        else {
            Notificacion.warning('Debe seleccionar un empleado');
            Progress.done();
        }
    }

    const handleModalEmp = () => {
        setSelectModalEmp(true);
    }
    const cerrarModalEmp = () => {
        setSelectModalEmp(undefined);
        setSelectedEmpleado(undefined);
    }

    const onRowSelectEmp = (row) => {
        setSelectedEmpleado(row);
    }
    const onDoubleClickEmp = async (e, row, rowIndex) => {
        const listEmpleado = listaEmpleados;
        const Empleado = listEmpleado.filter(item => item.Empleado == row.Empleado);
        let Datos = datos;
        Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
        Datos.Empleado.value = Empleado[0].Empleado;
        //const listaHijos = await cargaListaHijos( Empleado[0].Empleado);
        await cargaListaHijos(Empleado[0].Empleado);
        setSelectModalEmp(undefined);
        setSelectedEmpleado(undefined);
        setDatos(Datos);
        //setListaHijos(listaHijos);    
    }

    //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);
        // console.log(`validarMenuOpcion: resultado= ${JSON.stringify(resultado)}, pOpcion= ${pOpcion} , _menuOpciones= ${JSON.stringify(_menuOpciones)}`)
        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.Eliminar.value:
                    eliminarDetalleSel();
                    break;
                case _optSegopt.Guardar.value:
                    ingresarDatosSel();
                    break;
                case _optSegopt.Nuevo.value:
                    ingresarDetalleSel();
                    break;
                default:
                    break;
            }
        }
    }

    return (
        <Fragment>
            <HijosInt
                botones={botones}
                botonesLista={botonesLista}
                Titulo={'Hijos de Empleado'}
                Datos={datos}
                onChangeInput={onChangeInput}
                listaHijos={listaHijos}
                columnasHijo={columnasHijo}
                cellEditDet={cellEditDet}
                rowEventsDet={rowEventsDet}
                selectRowDet={selectRowDet}
                rowStyleSal={rowStyleSal}
                onBlurEmpl={onBlurEmpl}
                onKeyPressEmp={onKeyPressEmp}
                onChangeInputEmp={onChangeInputEmp}
                handleModalEmp={handleModalEmp}
                onhandleChangeDate={onhandleChangeDate}
            />
            <ModalBusquedaEmp
                selectedModal={selectModalEmp}
                contentLabel={'selectedBusquedasEmp'}
                datos={listaEmpleados}
                id={'Empleado'}
                columnas={columnasEmp}
                striped={false}
                hover={true}
                condensed={false}
                selectRow={selectRowEmp}
                onDoubleClick={onDoubleClickEmp}
                label={'Lista de Empleados'}
                cerrarModal={cerrarModalEmp}
                seleccionModal={seleccionModalEmp}
                verLHOC={false}
                nombreCSV={'BusquedaEmpleados'}
            />
            <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(hijos));