﻿import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faPlus, faPencilAlt, faTrash, faSync, faCheck, faTimes, faDownload } from '@fortawesome/free-solid-svg-icons';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import Lista from '../../components/UI/controlLista/controlLista.jsx';
import Config from '../../components/Util/constantes.js';
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import { farmatearFechaEstandar, farmatearFechaEstandarHora, muestraArbolEmpleados } from '../../components/Util/Util.jsx';

//Invocaciones datos
import { MonitorAvisos_Lista_Request, TiposAviso_Lista_Request, MonitorAvisos_AceptarLista_Request, 
    MonitorAvisos_RechazarLista_Request, MonitorAvisos_Descargar_Request } from '../../request/MantenimientosRequest.jsx'

import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import { useLocalStorage } from '../../components/Util/Hooks/useLocalStorage.jsx';
import { addDays } from '../../components/Util/Util.jsx';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import Swal from 'sweetalert2';

//Seguridad
import Session from '../../components/Util/session/index.jsx';
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 { MonitorAvisosInt } from './MonitorAvisosInt.jsx';

function MonitorAvisos(props) {

    const [borrando, setBorrando] = useState(false);
    const [datos, setDatos] = useState([]);
    const [datosH, setDatosH] = useState([]);
    const [id, setID] = useState(0);
    const [idH, setIDH] = useState(0);
    const [listaSeleccionados, setListaSeleccionados] = useState([]);
    const [descargaSel, setDescargaSel] = useState(0);
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [ubicacion, setUbicacion] = useLocalStorage('Ubicacion', null);
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    let historyMenu = useHistory();

    const selectRow = { mode: 'checkbox', clickToSelect: true, hideSelectColumn: false, onSelect: (row, isSelected) => onRowSelect(row, isSelected), bgColor: '#10a599' ,hideSelectAll: true};
    const selectRowH = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row, isSelected) => onRowSelectH(row, isSelected), 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 [listaTiposAviso, setListaTiposAviso] = useState([]);
    const [listaTiposAvisoH, setListaTiposAvisoH] = useState([]);
    const [selectedOptionTipoAviso, setSelectedOptionTipoAviso] = useState([]);
    const [selectedOptionTipoAvisoH, setSelectedOptionTipoAvisoH] = useState([]);

    const listaCampos = {
        TipoAviso: { value: 0, attributes: { readOnly: false, focus: false, label: 'Tipo de Aviso', 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' } },
        Boton: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
        Comentario: { value: '', attributes: { readOnly: false, focus: false, label: "Motivo de Rechazo", hidden: "unset", maxLength: "250" } },
    }

    const listaCamposH = {
        TipoAvisoH: { value: 0, attributes: { readOnly: false, focus: false, label: 'Tipo de Aviso', hidden: 'unset' } },
        fecDesdeH: { value: addDays(new Date(), -30), attributes: { readOnly: false, focus: false, label: 'Desde', hidden: 'unset' } },
        fecHastaH: { value: addDays(new Date(), 1), attributes: { readOnly: false, focus: false, label: 'Hasta', hidden: 'unset' } },
        BotonH: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
    }

    const [datosAvisos, setdatosAvisos] = useState(listaCampos);
    const [datosAvisosH, setdatosAvisosH] = useState(listaCamposH);

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const onRowSelect = (row, isSelected) => {
        let _Lista = [...listaSeleccionados];
        if (isSelected){
            setID(row.Monitor_Codigo);
            _Lista.push(row);
        }
        else{
            setID(0);
            _Lista = _Lista.filter(x => x.Monitor_Codigo !== row.Monitor_Codigo);
        }
        
        setListaSeleccionados(_Lista);
        return true;
    }    

    const onRowSelectH = (row, isSelected) => {
        setIDH(row.Monitor_Codigo);
    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const columnas = [{
        dataField: 'Monitor_Codigo',
        text: 'Número',
        csvText: 'Número',
        sort: true
    }, {
        dataField: 'TipoAvisoDescripcion',
        text: 'Tipo de Aviso',
        csvText: 'TipoAviso',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'NombreJefe',
        text: 'Jefatura',
        csvText: 'Jefatura',
        sort: true
    }, {
        dataField: 'NombreEmpleado',
        text: 'Empleado',
        csvText: 'Empleado',
        sort: true
    }, {
        dataField: 'Monitor_FechaInicio',
        text: 'Fecha Inicio',
        csvText: 'FechaInicio',
        sort: true,
        editable: false,
        formatter: (row, cell) => { return farmatearFechaEstandar(cell.Monitor_FechaInicio) }
    }, {
        dataField: 'Monitor_FechaFin',
        text: 'Fecha Final',
        csvText: 'FechaFin',
        sort: true,
        editable: false,
        formatter: (row, cell) => { return cell.Monitor_FechaFin !== '' ? farmatearFechaEstandar(cell.Monitor_FechaFin) : '' }
    }, {
        dataField: 'Monitor_FechaRegistro',
        text: 'Fecha Registro',
        csvText: 'FechaRegistro',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        formatter: (row, cell) => { return farmatearFechaEstandarHora(cell.Monitor_FechaRegistro) },
        footer: ''
    }, {
        dataField: 'TextoEstado',
        text: 'Estado',
        csvText: 'Estado',
        sort: true
    }, {
        dataField: 'Monitor_NombreDepartamento',
        text: 'Departamento',
        csvText: 'Departamento',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'Monitor_Descripcion',
        text: 'Descripción',
        csvText: 'Descripción',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'TieneArchivo',
        text: 'Tiene Archivo',
        csvText: 'TieneArchivo',
        sort: true
    }]

    const columnasH = [{
        dataField: 'Monitor_Codigo',
        text: 'Número',
        csvText: 'Número',
        sort: true
    }, {
        dataField: 'TipoAvisoDescripcion',
        text: 'Tipo de Aviso',
        csvText: 'TipoAviso',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'NombreJefe',
        text: 'Jefatura',
        csvText: 'Jefatura',
        sort: true
    }, {
        dataField: 'NombreEmpleado',
        text: 'Empleado',
        csvText: 'Empleado',
        sort: true
    }, {
        dataField: 'Monitor_FechaInicio',
        text: 'Fecha Inicio',
        csvText: 'FechaInicio',
        sort: true,
        editable: false,
        formatter: (row, cell) => { return farmatearFechaEstandar(cell.Monitor_FechaInicio) }
    }, {
        dataField: 'Monitor_FechaFin',
        text: 'Fecha Final',
        csvText: 'FechaFin',
        sort: true,
        editable: false,
        formatter: (row, cell) => { return cell.Monitor_FechaFin !== '' ? farmatearFechaEstandar(cell.Monitor_FechaFin) : '' }
    }, {
        dataField: 'Monitor_FechaRegistro',
        text: 'Fecha Registro',
        csvText: 'FechaRegistro',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        formatter: (row, cell) => { return farmatearFechaEstandarHora(cell.Monitor_FechaRegistro) },
        footer: ''
    }, {
        dataField: 'TextoEstado',
        text: 'Estado',
        csvText: 'Estado',
        sort: true
    }, {
        dataField: 'Monitor_NombreDepartamento',
        text: 'Departamento',
        csvText: 'Departamento',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'Monitor_Descripcion',
        text: 'Descripción',
        csvText: 'Descripción',
        sort: true,
        classes: 'ColumnText',
        editable: false,
        footer: ''
    }, {
        dataField: 'TieneArchivo',
        text: 'Tiene Archivo',
        csvText: 'TieneArchivo',
        sort: true
    }]

    const botones = [
        {
            name: "btnAceptar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleAceptar(),
            leyenda: "",
            iclase: faCheck,
            tooltip: "Aceptar Solicitud"
        },
        {
            name: "btnRechazar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleRechazar(),
            leyenda: "",
            iclase: faTimes,
            tooltip: "Rechazar Solicitud"
        },
        {
            name: "btnDescargar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleDescargar(false),
            leyenda: "",
            iclase: faDownload,
            tooltip: "Descargar Archivo"
        }
    ]

    const botonesP = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        }
    ]

    const botonesH = [
        {
            name: "btnDescargarH",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleDescargar(true),
            leyenda: "",
            iclase: faDownload,
            tooltip: "Descargar Archivo"
        }
    ]

    const botonRefrescar = [
        {
            name: "btnRefescarCDD",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cargarDatos(false),
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        }
    ]

    const botonRefrescarH = [
        {
            name: "btnRefescarCDDH",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cargarDatosH(false),
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        }
    ]

    const TiposAviso_Listar = async () => {
        let datos = [];
        const response = await TiposAviso_Lista_Request(token, empresa);
        if (response.Exitoso) {
            datos = response.Datos;
        } else {
            const _login = manageError(response, props, 'TiposAviso_Lista_Request ');
            spinnerModalMostrar(false, '', 3);
            if (!_login) { volverAtras(); }
            return false;
        }

        return datos;
    }

    const cargaTiposAviso = async () => {
        const _listaTiposAvisoOrig = await TiposAviso_Listar();
        let _listaTiposAviso = [];
        _listaTiposAviso.push({ value: 0, label: "----" });
        _listaTiposAvisoOrig.map(function (item) {
            _listaTiposAviso.push({ value: item.TipoAviso_Codigo, label: item.TipoAviso_Descripcion });
        });
        setSelectedOptionTipoAviso(_listaTiposAviso[0]);
        setListaTiposAviso(_listaTiposAviso);
    }

    const cargaTiposAvisoH = async () => {
        const _listaTiposAvisoOrigH = await TiposAviso_Listar();
        let _listaTiposAvisoH = [];
        _listaTiposAvisoH.push({ value: 0, label: "----" });
        _listaTiposAvisoOrigH.map(function (item) {
            _listaTiposAvisoH.push({ value: item.TipoAviso_Codigo, label: item.TipoAviso_Descripcion });
        });
        setSelectedOptionTipoAvisoH(_listaTiposAvisoH[0]);
        setListaTiposAvisoH(_listaTiposAvisoH);
    }

    const cargarDatos = async (pBorrando) => {
        if (!pBorrando) {
            let spinnerLabel = 'Cargando datos...';
            spinnerModalMostrar(true, spinnerLabel, 3)
        }

        const _datosAvisos = datosAvisos;

        const response = await MonitorAvisos_Lista_Request(token, empresa, _datosAvisos.TipoAviso.value, _datosAvisos.fecDesde.value, _datosAvisos.fecHasta.value, "REP", "");
        if (response.Exitoso) {

            // for(let i in response.Datos) {
            //     response.Datos[i].Monitor_FechaInicio = farmatearFechaEstandar(response.Datos[i].Monitor_FechaInicio);
            //     response.Datos[i].Monitor_FechaRegistro = farmatearFechaEstandarHora(response.Datos[i].Monitor_FechaRegistro);
            // }

            let _datos = response.Datos;
            _datos.forEach(function (elemento) {
                var fechaFin = new Date(elemento.Monitor_FechaFin);
                var fechaLimite = new Date('1900-12-31');
                elemento.Monitor_FechaFin = (fechaFin <= fechaLimite) ? '' : fechaFin;
            });

            setDatos(_datos);
        }
        else {
            const _login = manageError(response, props, '');
            spinnerModalMostrar(false, '', 3);
            if (_login) { return false; };
        }
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.MonitorAvisos.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)

        if (!pBorrando) {
            spinnerModalMostrar(false, '', 3)
        }
    }

    const cargarDatosH = async (pBorrando) => {
        if (!pBorrando) {
            let spinnerLabel = 'Cargando datos...';
            spinnerModalMostrar(true, spinnerLabel, 3)
        }

        const _datosAvisos = datosAvisosH;

        const response = await MonitorAvisos_Lista_Request(token, empresa, _datosAvisos.TipoAvisoH.value, _datosAvisos.fecDesdeH.value, _datosAvisos.fecHastaH.value, "TO", "REP");
        if (response.Exitoso) {

            // for(let i in response.Datos) {
            //     response.Datos[i].Monitor_FechaInicio = farmatearFechaEstandar(response.Datos[i].Monitor_FechaInicio);
            //     response.Datos[i].Monitor_FechaRegistro = farmatearFechaEstandarHora(response.Datos[i].Monitor_FechaRegistro);
            //  }            

            let _datos = response.Datos;
            _datos.forEach(function (elemento) {
                var fechaFin = new Date(elemento.Monitor_FechaFin);
                var fechaLimite = new Date('1900-12-31');
                elemento.Monitor_FechaFin = (fechaFin <= fechaLimite) ? '' : fechaFin;
            });

            setDatosH(_datos);
        }
        else {
            const _login = manageError(response, props, '');
            spinnerModalMostrar(false, '', 3);
            if (_login) { return false; };
        }
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.MonitorAvisos.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)

        if (!pBorrando) {
            spinnerModalMostrar(false, '', 3)
        }
    }

    const validaSeleccionado = (pHistorico) => {
        let _id;

        if (pHistorico) {
            _id = idH;
        }
        else {
            if(listaSeleccionados.length > 1){
                Notificacion.error('Debe seleccionar sólo un registro');    
                return false;
            }
            if(listaSeleccionados.length == 0){
                Notificacion.error('Debe seleccionar un registro');    
                return false;
            }
            _id = listaSeleccionados[0].Monitor_Codigo;
            setID(_id);
        }

        if (_id != '') {
            return true;
        }
        else {
            Notificacion.error('Debe seleccionar un registro');
            return false;
        }
    } 

    const validaSeleccionadoLista=()=>{

        if(listaSeleccionados.length == 0){
            Notificacion.error('Debe seleccionar un registro');
            return false;                        
        }
        return true;
    }
    
    const handleAceptar = () => {
        if (validaSeleccionadoLista()) {
            const optSegopt = optSeg.TOpciones_Menu;
            let validar = validarMenuOpcion(optSegopt.Eliminar.value);
            if (!validar) {
                handleAceptarSel();
            }
        }
    }

    const handleRechazar = () => {
        if (validaSeleccionadoLista()) {
            let _datosAvisos = datosAvisos;

            if (_datosAvisos.Comentario.value.trim().length == 0) {
                Notificacion.error('Debe indicar un motivo para el rechazo.');
            }
            else {
                const optSegopt = optSeg.TOpciones_Menu;
                let validar = validarMenuOpcion(optSegopt.Editar.value);
                if (!validar) {
                    handleRechazarSel();
                }
            }
        }
    }

    const handleDescargar = (pHistorico) => {
        setDescargaSel(pHistorico);
        if (validaSeleccionado(pHistorico)) {
            const optSegopt = optSeg.TOpciones_Menu;
            let validar = validarMenuOpcion(optSegopt.Nuevo.value);
            if (!validar) {
                handleDescargarSel(pHistorico);
            }
        }
    }

    const handleAceptarSel = () => {
        let resultado = false;
        let _Pregunta = '';
        if (validaSeleccionadoLista()) {
            _Pregunta =  (listaSeleccionados.length > 1 ? '<h4>¿Está seguro que desea aceptar las solicitudes seleccionadas?</h4>': '<h4>¿Está seguro que desea aceptar la solicitud seleccionada?</h4>' )
            Swal.fire({
                title: 'Aceptar Solicitud',
                html: _Pregunta,
                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;
                    aceptarSolicitud();
                } else if (result.dismiss === Swal.DismissReason.cancel) {
                    resultado = false;
                }
            })
            setBorrando(false);
        }

        const aceptarSolicitud = async () => {
            let _id = id;
            let _usuario = usuario;
            let resultado = '';
            spinnerModalMostrar(true, 'Aceptando Solicitud', 3);

            resultado = await MonitorAvisos_AceptarLista_Request(token, JSON.stringify(listaSeleccionados), _usuario);
            if (resultado.Exitoso) {
                Notificacion.success(`Proceso de aceptación finalizado con éxito.`);
                await cargarDatos(true);
                setID('');
                setListaSeleccionados([]);
            }
            else {
                Notificacion.error(resultado.Mensaje);
            }

            spinnerModalMostrar(false, '', 3);

        }

        return resultado;
    }

    const handleRechazarSel = () => {
        let resultado = false;
        let _Pregunta = '';
        if (validaSeleccionadoLista()) {
            _Pregunta =  (listaSeleccionados.length > 1 ? '<h4>¿Está seguro que desea rechazar las solicitudes seleccionadas?</h4>': '<h4>¿Está seguro que desea rechazar la solicitud seleccionada?</h4>');
            Swal.fire({
                title: 'Rechazar Solicitud',
                html: _Pregunta,
                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;
                    rechazarSolicitud();
                } else if (result.dismiss === Swal.DismissReason.cancel) {
                    resultado = false;
                }
            })
            setBorrando(false);
        }

        const rechazarSolicitud = async () => {
            let _id = id;
            let _usuario = usuario;
            let resultado = '';
            let _datosAvisos = datosAvisos;
            spinnerModalMostrar(true, 'Rechazando Solicitud', 3);
            resultado = await MonitorAvisos_RechazarLista_Request(token, JSON.stringify(listaSeleccionados), _usuario, _datosAvisos.Comentario.value.trim());
            if (resultado.Exitoso) {
                Notificacion.success(`Proceso de rechazo finalizado con éxito.`);
                await cargarDatos(true);
                setID('');
                _datosAvisos.Comentario.value = "";
                setListaSeleccionados([]);
            }
            else {
                Notificacion.error(resultado.Mensaje);
            }

            spinnerModalMostrar(false, '', 3);

        }

        return resultado;
    }

    const handleDescargarSel = (pHistorico) => {
        let resultado = false;

        if (validaSeleccionado(pHistorico)) {
            Swal.fire({
                title: 'Aceptar Solicitud',
                html: '<h4>¿Está seguro que desea descargar el archivo de la solicitud seleccionada?</h4>',
                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;
                    descargarArchivo(pHistorico);
                } else if (result.dismiss === Swal.DismissReason.cancel) {
                    resultado = false;
                }
            })
            setBorrando(false);
        }

        const descargarArchivo = async (pHistorico) => {
            let _id;
            let resultado = '';

            if (pHistorico) {
                _id = idH;
            }
            else {
                _id = listaSeleccionados[0].Monitor_Codigo;// id;
            }

            spinnerModalMostrar(true, 'Descargando Archivo', 3);

            resultado = await MonitorAvisos_Descargar_Request(token, _id);
            if (resultado.Exitoso) {
                if (resultado.Datos.MsgError === "") {
                    const a = document.createElement('a');
                    a.download = resultado.Datos.Monitor_Archivo;
                    // a.href = 'data:image/png;base64,' + resultado.Datos.DatosArchivo;
                    a.href = 'data:application/octet-stream;base64,' + resultado.Datos.DatosArchivo;
                    a.click();
                }
                else {
                    Notificacion.error(resultado.Datos.MsgError);
                }
            }
            else {
                const _login = manageError(resultado, props, 'Imposible descargar el archivo.');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };
            }

            spinnerModalMostrar(false, '', 3);

        }

        return resultado;
    }

    useEffect(() => {
        muestraArbolEmpleados(false);
        cargaTiposAviso();
        cargaTiposAvisoH();

        const carga = async () => {
            await cargarDatos(false);
            await cargarDatosH(false);
        }
        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;
        }
        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:
                    handleAceptarSel(false);
                    break;
                case _optSegopt.Editar.value:
                    handleRechazarSel(false);
                    break;
                case _optSegopt.Nuevo.value:
                    handleDescargarSel(descargaSel);
                    break;
                default:
                    break;
            }
        }
    }

    const onhandleSelectedOptionTipoAviso = (pTipoAviso) => {
        let _datos = { ...datosAvisos };
        setSelectedOptionTipoAviso(pTipoAviso);
        _datos.TipoAviso.value = pTipoAviso.value;
        setdatosAvisos(_datos);
    }

    const onhandleSelectedOptionTipoAvisoH = (pTipoAviso) => {
        let _datos = { ...datosAvisosH };
        setSelectedOptionTipoAvisoH(pTipoAviso);
        _datos.TipoAvisoH.value = pTipoAviso.value;
        setdatosAvisosH(_datos);
    }

    const onhandleChangeDate = (date, id) => {
        const name = id;
        const value = date;
        let _Datos = datosAvisos;
        let _DatosOrig = datosAvisos;
        let newAttributes = _DatosOrig[name].attributes;
        _DatosOrig = Object.assign({}, _DatosOrig, { [name]: { value: value, attributes: newAttributes } })
        _Datos.fecDesde.value = _DatosOrig.fecDesde.value;
        _Datos.fecHasta.value = _DatosOrig.fecHasta.value;
        setdatosAvisos(_DatosOrig);
    }

    const onhandleChangeDateH = (date, id) => {
        const name = id;
        const value = date;
        let _Datos = datosAvisosH;
        let _DatosOrig = datosAvisosH;
        let newAttributes = _DatosOrig[name].attributes;
        _DatosOrig = Object.assign({}, _DatosOrig, { [name]: { value: value, attributes: newAttributes } })
        _Datos.fecDesdeH.value = _DatosOrig.fecDesdeH.value;
        _Datos.fecHastaH.value = _DatosOrig.fecHastaH.value;
        setdatosAvisosH(_DatosOrig);
    }

    const onChangeInputEmp = (e) => {

        const name = e.target.name;
        const value = e.target.value;

        let newAttributes = datosAvisos[name].attributes;
        let _Datos = Object.assign({}, datosAvisos, {
            [name]: { value: value, attributes: newAttributes },
        });

        setdatosAvisos(_Datos);

    }

    return (
        <Fragment>
            <MonitorAvisosInt
                titulo={'Monitor de Solicitudes'}
                botonesP={botonesP}

                botones={botones}
                datosAvisos={datosAvisos}
                onhandleSelectedOptionTipoAviso={onhandleSelectedOptionTipoAviso}
                selectedOptionTipoAviso={selectedOptionTipoAviso}
                onhandleChangeDate={onhandleChangeDate}
                botonRefrescar={botonRefrescar}
                listaTiposAviso={listaTiposAviso}
                columnas={columnas}
                datos={datos}
                selectRow={selectRow}
                onChangeInputEmp={onChangeInputEmp}

                botonesH={botonesH}
                datosAvisosH={datosAvisosH}
                onhandleSelectedOptionTipoAvisoH={onhandleSelectedOptionTipoAvisoH}
                selectedOptionTipoAvisoH={selectedOptionTipoAvisoH}
                onhandleChangeDateH={onhandleChangeDateH}
                botonRefrescarH={botonRefrescarH}
                listaTiposAvisoH={listaTiposAvisoH}
                columnasH={columnasH}
                datosH={datosH}
                selectRowH={selectRowH}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </Fragment>
    );

};
export default withRouter(memo(MonitorAvisos))