import React, { memo, useState, useEffect, useCallback } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import Swal from 'sweetalert2';
import { faReply, faCheck, faSync, } from '@fortawesome/free-solid-svg-icons'
import moment from 'moment';

import { SiteRutas } from '../../request/RutasConfig.jsx';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import optSeg from '../../components/Util/seg-menu-opciones.js'
import Config from '../../components/Util/constantes.js'
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import ModalSeguridad from "../Seguridad/ModalSeguridad.jsx";
import { farmatearFechaEstandar, muestraArbolEmpleados, farmatearCantidad, validarDecimal, farmatearMontos } from '../../components/Util/Util.jsx';

import RebajoPorTardiasInt from './rebajoPorTardiasInt.jsx';
import { GetRebajoTardias, GetRebajoTardiasDetalle, RebajoTardiasAprobarRegistros } from '../../request/RebajasRequest.jsx';
import { Obtener_MenuNombre_Request, Obtener_MenuOpciones_Lista_Request } from '../../request/MenuRequest.jsx';

import ModaldetalleTardiaJustificaciones from './modaldetalleTardiaJustificaciones.jsx';
import { BotonCeldaGrid } from '../../components/UI/botonera/headerBotones.js';

export const rebajoPorTardias = (props) => {

    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioS');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    const [selectModal, setSelectModal] = useState(false);
    const tablest = { width: '100%' };
    const cuentacenter = { textAlign: 'center', width: '80%' };
    const cuentaright = { textAlign: 'right', width: '20%' };

    const [lstRebajosTardias, setLstRebajosTardias] = useState([]);
    const [lstRebajosTardiasDetalle, setLstRebajosTardiasDetalle] = useState([]);
    const [id, setID] = useState(0);
    const [justificacionId, setJustificacionId] = useState(0);
    const [empleadoId, setEmpleadoId] = useState(0);
    const [fila, setFila] = useState([]);

    const [listaAccionesSel, setListaAccionesSel] = useState([]);
    const [selectAP, setSelectAP] = useState([]);
    const [cellDetalle, setCellDetalle] = useState([]);

    const [force, updateState] = useState();
    const forceUpdate = useCallback(() => updateState({}), []);

    let historyMenu = useHistory();
    const empresa = JSON.parse(sessionStorage.getItem('empresa'));

    const columnas = [
        { dataField: 'Id', text: 'Id', hidden: true, csvExport: false, },
        { dataField: 'Empresa', text: 'Empresa', hidden: true, csvExport: false, },
        {
            dataField: 'HorasParametrizadas', text: 'Rebajo Estimado', sort: false, align: 'right', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '7%', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearCantidad(cell.HorasParametrizadas) }
        },
        {
            dataField: 'HorasRebajar', text: 'Rebajo Solicitado', sort: false, align: 'right', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '7%', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearCantidad(cell.HorasRebajar) }
        },
        {
            dataField: 'HorasRebajoAplicado', text: 'Rebajo Aplicado', sort: false, align: 'right', editable: true,
            validator: (newValue, row, column) => {
                const valido = validaCantidad(newValue, row);
                return valido;
            },
            headerStyle: (colum, colIndex) => { return { width: '7%', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearCantidad(cell.HorasRebajoAplicado) }
        },
        {
            dataField: 'FechaSolicitud', text: 'Fecha', sort: false, align: 'center', hidden: false,
            headerStyle: (colum, colIndex) => { return { width: '7%', textAlign: 'center' }; },
            formatter: (row, cell) => { return moment(cell.FechaSolicitud).format('DD-MM-YYYY'); }
        },
        {
            dataField: 'NombreCompleto', text: 'Coladorador', sort: false, align: 'left', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '20%', textAlign: 'center' }; }
        },
        {
            dataField: 'Puesto', text: 'Puesto', sort: false, align: 'left', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '20%', textAlign: 'center' }; }
        },
        {
            dataField: 'NombreCompletoJefe', text: 'Jefatura', sort: false, align: 'left', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '20%', textAlign: 'center' }; }
        },
        {
            dataField: 'JustificacionComentarios', text: 'Justificación', csvText: 'Justificacion', sort: false, align: 'center', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '7%', textAlign: 'center' }; },
            formatter: (e, column, columnIndex, row, rowIndex) => {
                const _llaveCta = column.Id;
                const campo =
                    <table style={tablest}>
                        <tbody>
                            <tr style={tablest}>
                                <td id={_llaveCta} style={cuentacenter}>{column.JustificacionComentarios}</td>
                                <td style={cuentaright} >
                                    {column.JustificacionComentarios !== "No" ?
                                        <BotonCeldaGrid
                                            indice={column.Id}
                                            clase={'hoverBtn'}
                                            tooltip={"Detalle"}
                                            evento={(event) => { onValidarDetalle(column, columnIndex, row, rowIndex, event) }}
                                            iclase={"fa fa-list-alt"}
                                        //iclase={"fa fa-spinner fa-spin"}
                                        />
                                        : null
                                    }
                                </td>
                            </tr>
                        </tbody>
                    </table>
                return campo;
            },
        },
        {
            dataField: 'Estado', text: 'Estado', sort: false, align: 'center', editable: false,
            headerStyle: (colum, colIndex) => { return { width: '5%', textAlign: 'center' }; }
        },
        { dataField: 'IdEmpleado', text: 'Empleado Id', sort: true, hidden: true, csvExport: false, },
        { dataField: 'JustificacionID', text: 'Justificacion ID', sort: true, width: 350, align: 'center', hidden: true, csvExport: false, },
        { dataField: 'Tipo', text: 'Tipo', sort: true, align: 'center', hidden: true, csvExport: false, },
        { dataField: 'IdJefe', text: 'Id Jefe', sort: true, align: 'center', hidden: true, csvExport: false, },
        { dataField: 'UsuarioAplica', text: 'Usuario Aplica', sort: true, align: 'center', hidden: true, csvExport: false, },
        { dataField: 'FechaAplica', text: 'Fecha Aplica', sort: true, align: 'center', hidden: true, csvExport: false, },
    ];

    const columasDetalle = [
        {
            dataField: 'Dia', text: 'Día', csvText: 'Dia', hidden: false, sort: false, align: 'left',
            headerStyle: (colum, colIndex) => { return { width: '70px', textAlign: 'center' }; },
        },
        {
            dataField: 'FechaMarca', text: 'Fecha', hidden: false, align: 'left',
            headerStyle: (colum, colIndex) => { return { width: '80px', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearFechaEstandar(cell.FechaMarca) }
        },
        {
            dataField: 'AplicaRebajoTardias', text: 'Rebajo de Tardías', csvText: 'Rebajo de Tardias', hidden: false, align: 'center',
            headerStyle: (colum, colIndex) => { return { width: '90px', textAlign: 'center' }; },
        },
        {
            dataField: 'HorasParametrizadas', text: 'Rebajo Estimado', hidden: false, align: 'right',
            headerStyle: (colum, colIndex) => { return { width: '90px', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearCantidad(cell.HorasParametrizadas) }
        },
        {
            dataField: 'HorasRebajar', text: 'Rebajo Solicitado', hidden: false, align: 'right',
            headerStyle: (colum, colIndex) => { return { width: '90px', textAlign: 'center' }; },
            formatter: (row, cell) => { return farmatearCantidad(cell.HorasRebajar) }
        },
        {
            dataField: 'Justificacion', text: 'Justificación', csvText: 'Justificacion', hidden: false, align: 'left',
            headerStyle: (colum, colIndex) => { return { width: '300px', textAlign: 'center' }; },
        },
    ]

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnAprobar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => {
                const apruebe = async () => { await onValidaAprobar(); }
                apruebe();
            },
            leyenda: "",
            iclase: faCheck,
            tooltip: "Aprobar"
        },
    ]

    const botonesFiltro = [
        {
            name: "btnRefrescar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => {
                const carga = async () => { await cargarDatos(); }
                carga();
            },
            leyenda: "",
            iclase: faSync,
            tooltip: "Refrescar"
        },
    ]

    const botonesMod = [
        {
            name: "btnCerrarModal",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cerraModalEdicionNuevo(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
    ]

    const _Filtros = {
        SolicitudPendienteAprobar: { value: true, attributes: { readOnly: false, focus: false, label: 'Mostrar Solicitudes Pendientes de Aprobar', labelEx: '', } },
        Desde: {
            value: moment().subtract(15, 'days').toDate(),
            attributes: {
                readOnly: true,
                focus: false,
                label: "Desde",
                hidden: "unset",
                // minDate: moment(moment().subtract(15, 'days').toDate()).toDate(),
                // maxDate: moment(moment().subtract(1, 'days').toDate()).toDate(),
            }
        },
        Hasta: {
            value: moment().toDate(),
            attributes: {
                readOnly: true,
                focus: false,
                label: 'Hasta',
                hidden: "unset",
                // minDate: moment(moment().subtract(14, 'days').toDate()).toDate(),
                // maxDate: moment().toDate(),
            },
        },
        Estado: { value: 'PE', attributes: { readOnly: false, focus: false, label: 'Estado', hidden: "unset", } },
        BotonesAE: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
    };

    const [filtros, setFiltros] = useState(_Filtros);

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => {
            await cargarDatos()
        }
        carga()
    }, [])

    const handleCuentaModal = async (cell) => {
        setID(cell.Id);
        setJustificacionId(cell.JustificacionID);
        setEmpleadoId(cell.IdEmpleado);
        setFila(cell);
        await cargaDetalle(cell.IdEmpleado, cell.JustificacionID);
        setSelectModal(true);
    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const cellEdit = { mode: 'click', autoSelectText: true, blurToSave: true };

    const selectRowAP = {
        mode: 'checkbox',
        bgColor: '#10a599',
        clickToSelect: true,
        selected: selectAP,
        onSelect: (row, isSelect, rowIndex, e) => onRowSelectDet(row, isSelect, rowIndex, e),
        onSelectAll: (isSelect, rows) => handleOnSelectAllDet(isSelect, rows),
        hideSelectColumn: false,
        clickToEdit: true,
    };

    const validaCantidad = (newValue, row) => {
        if (isNaN(newValue)) {
            return {
                valid: false,
                message: '1-Debe ingresar un dato válido'
            };
        }
        if (newValue.toString().trim().length == 0) {
            return {
                valid: false,
                message: '2-Debe ingresar un dato válido'
            };

        }
        let isValid = true;
        isValid = validarDecimal(newValue);
        if (!isValid) {
            return {
                valid: false,
                message: '3-Debe ingresar un dato válido'
            };
        }

        let lista = [...lstRebajosTardias];
        let _filtrado = lista.filter((x) => x.Id === row.Id);

        if (_filtrado && _filtrado.length > 0) {
            let HR = _filtrado[0].HorasRebajar;

            if ((Number(newValue) > HR) || (Number(newValue) < 0)) {
                return {
                    valid: false,
                    message: `El mínimo permitido para el Rebajo Aplicado es 0 y el máximo es ${HR}`
                };
            }
        }

        return { valid: true, mensaje: '' };

    }

    const onRowSelectDet = (row, isSelect, rowIndex, e) => {
        if (isSelect) {
            if (row.Estado !== "PE") {
                return false;
            }
        }
        let lista = [...listaAccionesSel];
        let _listaAP = [...selectAP];
        if (isSelect) {
            lista.push(row.Id);
            _listaAP.push(row.Id);
        } else {
            lista = lista.filter(x => x !== row.Id);
            _listaAP = _listaAP.filter(x => x !== row.Id);
        }

        setID(row.Id);
        setFila(row);

        setListaAccionesSel(lista);
        setSelectAP(_listaAP);

        return true;
    }

    const handleOnSelectAllDet = (isSelect, rows) => {

        if (lstRebajosTardias.length === 0) {
            Notificacion.warning("No hay registros para marcar.");
            return false;
        }

        if (isSelect) {
            let _elegibles = rows.filter((x) => x.Estado === 'PE');
            setListaAccionesSel(_elegibles.map(x => x.Id));
            setSelectAP(_elegibles.map(r => r.Id));
            return _elegibles.map(x => x.Id);
        } else {
            setListaAccionesSel([]);
            setSelectAP([])
            return [];
        }

    }

    const rowEventsDist = {
        onClick: (e, row) => {
        }
    };

    const cargarDatos = async () => {

        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3);

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.rebajoPorTardias.value);

        let _menuId = 0;

        if (_MenuNomb.ID != undefined) {
            _menuId = _MenuNomb.ID;
        }
        const _UsuarioS = usuarioS;
        let _menuOpciones = null;

        if (_menuId > 0) {
            _menuOpciones = await cargarMenuOpciones(Config.Modulo, _UsuarioS, _menuId);
        }

        setMenuId(_menuId);
        setMenuOpciones(_menuOpciones);

        const response = await GetRebajoTardias(token, empresa, filtros.SolicitudPendienteAprobar.value, filtros.Desde.value, filtros.Hasta.value, filtros.Estado.value);
        if (response.Exitoso) {
            if (response.Datos.length >= 0) {
                if (response.Datos.length === 1) {
                    if (response.Datos[0].MsgError === "No hay datos por mostrar") {
                        setLstRebajosTardias([]);
                    }
                    else {
                        setLstRebajosTardias(response.Datos);
                    }
                }
                else {
                    if (response.Datos.length === 0) {
                        setLstRebajosTardias([]);
                    }
                    else {
                        setLstRebajosTardias(response.Datos);
                    }
                }
            }
            else {
                setLstRebajosTardias([]);
            }
        }
        else {
            const _login = manageError(response, props, '');
            if (_login) {
                spinnerModalMostrar(false, '', 3);
                return;
            };
        }
        spinnerModalMostrar(false, '', 3);

    }

    const cargaDetalle = async (pEmpleadoId, pJustificacionId) => {
        const response = await GetRebajoTardiasDetalle(token, empresa, pEmpleadoId, pJustificacionId);

        if (response.Exitoso) {
            if (response.Datos.length >= 0) {
                if (response.Datos.length === 1) {
                    if (response.Datos[0].MsgError === "No hay datos por mostrar") {
                        setLstRebajosTardiasDetalle([]);
                    }
                    else {
                        setLstRebajosTardiasDetalle(response.Datos);
                    }
                }
                else {
                    if (response.Datos.length === 0) {
                        setLstRebajosTardiasDetalle([]);
                    }
                    else {
                        setLstRebajosTardiasDetalle(response.Datos);
                    }
                }
            }
            else {
                setLstRebajosTardiasDetalle([]);
            }
        }
    }

    const onValidaAprobar = async () => {

        if (lstRebajosTardias.length === 0) {
            Notificacion.warning("No hay registros para marcar.");
            return false;
        }

        if (selectAP.length === 0) {
            Notificacion.warning("Debe marcar uno o más registros.");
            return false;
        }

        const optSegopt = optSeg.TOpciones_Menu;
        let _value = "";
        _value = optSegopt.Aprobar.value;
        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await onAprobar();
        }
    }

    const onValidarDetalle = async (cell, columnIndex, row, rowIndex, event) => {
        event.preventDefault();
        event.stopPropagation();
        setCellDetalle(cell);
        const optSegopt = optSeg.TOpciones_Menu;
        let _value = "";
        _value = optSegopt.VerDetalle.value;
        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await handleCuentaModal(cell);
        }
    }

    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 onActionResultModal = async (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false);
            setOpcionValidar(0);
            setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.VerDetalle.value:
                    await handleCuentaModal(cellDetalle);
                    break;
                case _optSegopt.Aprobar.value:
                    await onAprobar();
                    break;
                default:
                    break;
            }
        }
    }

    const handleCerrarModal = () => setShowModalSeguridad(false);

    const handleCheckedChange = async (e) => {
        const name = e.target.name;
        const value = e.target.checked;

        let newAttributes = filtros[name].attributes;
        filtros.Desde.attributes.readOnly = value;
        filtros.Hasta.attributes.readOnly = value;
        filtros.Estado.value = value ? 'PE' : '';

        const _Datos = Object.assign({}, filtros, {
            [name]: {
                value: value,
                attributes: newAttributes,
                id: name,
                name: name,
            },
        });
        setFiltros((x) => x = _Datos);
    }

    const onhandleChangeDate = async (date, id) => {
        const name = id;
        const value = date;
        let newAttributes = filtros[name].attributes;

        let _Datos = {};

        if (name === 'Desde') {
            _Datos = Object.assign({}, filtros, { [name]: { value: value, attributes: newAttributes } });
            _Datos.Hasta.value = moment(value).add(15, 'days').toDate();
        } else {
            _Datos = Object.assign({}, filtros, { [name]: { value: value, attributes: newAttributes } });
        }

        setFiltros((x) => x = _Datos);
        forceUpdate();
    }

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    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 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 cerraModalEdicionNuevo = () => { setSelectModal(false); }

    const onAprobar = async () => {

        let resultado = false;
        let _lstRebajosTardias = [...lstRebajosTardias];

        if (lstRebajosTardias.length === 0) {
            Notificacion.warning("No hay registros para marcar.");
            return false;
        }

        if (selectAP.length === 0) {
            Notificacion.warning("Debe marcar uno o más registros.");
            return false;
        }

        Swal.fire({
            title: 'Solicitudes Rebajo de Tardías',
            html: '<h4>¿Confirma la aplicación de el o los registros seleccionados?</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;
                aprobarRegistros();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        })

        const aprobarRegistros = async () => {

            let Modelo = {
                Empresa: empresa,
                Id: 0,
                EmpleadoId: 0,
                JustificacionID: 0,
                HorasRebajoAplicado: 0,
                Estado: 'AP',
                NombreCompleto: '',
                Motivo: 'REBAJO HRS NO LABORADAS MARCAS',
                UsuarioAplica: usuario,
                Fecha: new Date(),
            }

            const _filtrados = _lstRebajosTardias.filter(x => selectAP.includes(x.Id));

            let _lista = _filtrados.map((item) => {
                let _result = Modelo;
                _result.Id = item.Id;
                _result.EmpleadoId = item.IdEmpleado;
                _result.JustificacionID = item.JustificacionID;
                _result.HorasRebajoAplicado = Number(item.HorasRebajoAplicado);
                _result.NombreCompleto = item.NombreCompleto;
                _result.Fecha = new Date(item.FechaSolicitud);
                return { ..._result };
            });

            spinnerModalMostrar(true, 'Aprobando Registros', 3);
            let resultado = await RebajoTardiasAprobarRegistros(token, _lista);
            if (resultado.Exitoso) {
                Notificacion.success(`Se aprobó con éxito.`);
                setListaAccionesSel([]);
                setSelectAP([]);
                setID(0);
                setFila([]);
                await cargarDatos();
            }
            else {
                const _login = manageError(resultado, props, 'Error: ');
                if (_login) {
                    spinnerModalMostrar(false, '', 3);
                    return;
                };
            }

            spinnerModalMostrar(false, '', 3);
        }

    }

    return (
        <>
            <RebajoPorTardiasInt
                Titulo={"Solicitudes Rebajo de Tardías"}
                botones={botones}
                datos={lstRebajosTardias}
                rowEventsDist={rowEventsDist}
                columnas={columnas}
                selectRow={selectRowAP}
                nombreCSV={"RebajoPorTardias"}
                filtros={filtros}
                handleCheckedChange={handleCheckedChange}
                onhandleChangeDate={onhandleChangeDate}
                botonesFiltro={botonesFiltro}
                cellEdit={cellEdit}
            />
            <ModaldetalleTardiaJustificaciones
                Titulo={fila.NombreCompleto}
                show={selectModal}
                cerrarModal={cerraModalEdicionNuevo}
                datos={lstRebajosTardiasDetalle}
                linea={fila}
                botones={botonesMod}
                columnas={columasDetalle}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </>
    )
}

export default withRouter(memo(rebajoPorTardias))

