import { MantenimientosRutas, GetHeaderRequest, GetResponseBody, GetResponseBodyError, GetHeaderRequestFormData } from './RutasConfig.jsx';
import axios from 'axios';


//////////////Areas ///////////////

export const AreaEmpresa_Guardar_Request = async (pToken, pAreaEmpresa) => {
    try {
        const data = { pAreaEmpresa }
        const result = await axios.post(MantenimientosRutas.AreaEmpresa_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Areas_Consulta_Request = async (pToken, pArea) => {
    try {
        const data = { pArea }
        const result = await axios.post(MantenimientosRutas.Areas_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Areas_lista_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Areas_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Areas_ListaEmpresa_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.Areas_ListaEmpresa, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Areas_ListaEmpresaPorArea_Request = async (pToken, pArea) => {
    try {
        const data = { pArea }
        const result = await axios.post(MantenimientosRutas.Areas_ListaEmpresaPorArea, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Areas_Guardar_Request = async (pToken, pArea) => {
    try {
        const data = { pArea }
        const result = await axios.post(MantenimientosRutas.Areas_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Areas_Modificar_Request = async (pToken, pArea) => {
    try {
        const data = { pArea }
        const result = await axios.post(MantenimientosRutas.Areas_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Areas_Eliminar_Request = async (pToken, pArea) => {
    try {
        const data = { pArea }
        const result = await axios.post(MantenimientosRutas.Areas_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////BANCO DE PREGUNTAS///////////////

export const BancoPreguntas_Consulta_Request = async (pToken, pId, pEmpresa) => {
    try {
        const data = { pId, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntas_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntas_Lista_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntas_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasActivas_Lista_Request = async (pToken, pIdTipoAviso, pEmpresa) => {
    try {
        const data = { pIdTipoAviso, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasActivas_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntas_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntas_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntas_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntas_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntas_Eliminar_Request = async (pToken, pId, pEmpresa) => {
    try {
        const data = { pId, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntas_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasUltimoConsecutivo_Consulta_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasUltimoConsecutivo_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////BANCO DE PREGUNTAS AVISOS///////////////
export const BancoPreguntasAvisos_ListaAmbos_Request = async (pToken, pIdPregunta, pIdAviso, pActivo, pEmpresa) => {
    try {
        const data = { pIdPregunta, pIdAviso, pActivo, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_ListaAmbos, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisos_Lista_Request = async (pToken, pIdPregunta, pIdAviso, pEmpresa) => {
    try {
        const data = { pIdPregunta, pIdAviso, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisos_Consulta_Request = async (pToken, pIdPregunta, pEmpresa) => {
    try {
        const data = { pIdPregunta, pEmpresa }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisosLista_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisosLista_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisosLista_Eliminar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisosLista_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisosLista_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisosLista_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisos_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisos_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const BancoPreguntasAvisos_Eliminar_Request = async (pToken, pId) => {
    try {
        const data = { pId }
        const result = await axios.post(MantenimientosRutas.BancoPreguntasAvisos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////CATEGORIAS//////////////////
export const Categoria_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.Categoria_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Categoria_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Categoria_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Categoria_Guardar_Request = async (pToken, pCategoria) => {
    try {
        const data = { pCategoria }
        const result = await axios.post(MantenimientosRutas.Categoria_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Categoria_Modificar_Request = async (pToken, pCategoria) => {
    try {
        const data = { pCategoria }
        const result = await axios.post(MantenimientosRutas.Categoria_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Categoria_Eliminar_Request = async (pToken, pCodigo, pUsuario) => {
    try {
        const data = { pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.Categoria_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const RevaluacionCategoria_Request = async (pToken, pEmpresa, pCategoria, pIndMontoPorc, pValor, pChkMin, pChkMax, pMSG, pUsuario_id) => {
    try {
        const data = { pEmpresa, pCategoria, pIndMontoPorc, pValor, pChkMin, pChkMax, pMSG, pUsuario_id }
        const result = await axios.post(MantenimientosRutas.RevaluacionCategoria, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
//////////////DATOS GENERALES/////////////
export const DatosGral_Consulta_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.DatosGral_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////DEPARTAMENTOS///////////////

export const Departamentos_Consulta_Request = async (pToken, pEmpresa, pArea, pDepto) => {
    try {
        const data = { pEmpresa, pArea, pDepto }
        const result = await axios.post(MantenimientosRutas.Departamentos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Departamentos_Lista_Request = async (pToken, pEmpresa, pArea) => {
    try {
        const data = { pEmpresa, pArea }
        const result = await axios.post(MantenimientosRutas.Departamentos_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Departamentos_Guardar_Request = async (pToken, pDepto) => {
    try {
        const data = { pDepto }
        const result = await axios.post(MantenimientosRutas.Departamentos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Departamentos_Modificar_Request = async (pToken, pDepto) => {
    try {
        const data = { pDepto }
        const result = await axios.post(MantenimientosRutas.Departamentos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Departamentos_Eliminar_Request = async (pToken, pEmpresa, pArea, pDepto) => {
    try {
        const data = { pEmpresa, pArea, pDepto }
        const result = await axios.post(MantenimientosRutas.Departamentos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////DOCUMENTO ACCION PERSONAL X EMPLEADO ///////////////

export const DocumentosAccionPersonalxEmpleado_Listar_Request = async (pToken, pEmpresa, pEmpleado, pNumeroAccionPersonal) => {
    try {
        const data = { pEmpresa, pEmpleado, pNumeroAccionPersonal }
        const result = await axios.post(MantenimientosRutas.DocumentosAccionPersonalxEmpleado_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const DocumentosAccionPersonalxEmpleado_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pDocumento_Nombre, pNumeroAccionPersonal) => {
    try {
        const data = { pEmpresa, pEmpleado, pDocumento_Nombre, pNumeroAccionPersonal }
        const result = await axios.post(MantenimientosRutas.DocumentosAccionPersonalxEmpleado_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const DocumentosAccionPersonalxEmpleado_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.DocumentosAccionPersonalxEmpleado_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const DocumentosAccionPersonalxEmpleado_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.DocumentosAccionPersonalxEmpleado_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const DocumentosAccionPersonalxEmpleado_VerDocumento_Request = async (pToken, pEmpresa, pEmpleado, pDocumento_Nombre, pNumeroAccionPersonal, pArchivo) => {
    try {
        const data = { pEmpresa, pEmpleado, pDocumento_Nombre, pNumeroAccionPersonal, pArchivo }
        const result = await axios.post(MantenimientosRutas.DocumentosAccionPersonalxEmpleado_VerDocumento, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////DOCUMENTO X EMPLEADO///////////////

export const DocumentosxEmpleado_Listar_Request = async (pToken, pEmpresa, pEmpleado, pEmpleadoAct, pTipoDoc, pEstadoDoc) => {
    try {
        const data = { pEmpresa, pEmpleado, pEmpleadoAct, pTipoDoc, pEstadoDoc }
        const result = await axios.post(MantenimientosRutas.DocumentosxEmpleado_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const DocumentosxEmpleado_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pId, pDoc) => {
    try {
        const data = { pEmpresa, pEmpleado, pId, pDoc }
        const result = await axios.post(MantenimientosRutas.DocumentosxEmpleado_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const DocumentosxEmpleado_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.DocumentosxEmpleado_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const DocumentosxEmpleado_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.DocumentosxEmpleado_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const DocumentosxEmpleado_VerDocumento_Request = async (pToken, pEmpresa, pEmpleado, pId, pArchivo) => {
    try {
        const data = { pEmpresa, pEmpleado, pId, pArchivo }
        const result = await axios.post(MantenimientosRutas.DocumentosxEmpleado_VerDocumento, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

////////////// Embargos y Pensiones ///////////////

export const EmbargosPensiones_Lista_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.EmbargosPensiones_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmbargosPensionesXTipo_Lista_Request = async (pToken, pEmpresa, pEmpleado, pTipo) => {
    try {
        const data = { pEmpresa, pEmpleado, pTipo }
        const result = await axios.post(MantenimientosRutas.EmbargosPensiones_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Empleado ///////////////
export const Empleados_Lista_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pSalBruto) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pSalBruto }
        const result = await axios.post(MantenimientosRutas.Empleados_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Empleados_Listar_Busqueda_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pEstado) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pEstado }
        const result = await axios.post(MantenimientosRutas.Empleados_Listar_Busqueda, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleado_Foto_Request = async (pToken, pEmpleado) => {
    try {
        const data = { pEmpleado }
        const result = await axios.post(MantenimientosRutas.Empleado_Foto, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadoImagen_DescargarImagen_Request = async (pToken, pEmpresa, pEmpleado, pNombreArchivo) => {
    try {
        const data = { pEmpresa, pEmpleado, pNombreArchivo }
        const result = await axios.post(MantenimientosRutas.EmpleadoImagen_DescargarImagen, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_ListarEnvioCorreo_Request = async (pToken, pFiltro) => {
    try {
        const data = { pFiltro }
        const result = await axios.post(MantenimientosRutas.Empleados_ListarEnvioCorreo, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_ValidaJornadaDec_Request = async (pToken, pEmpresa, pDesde, pHasta) => {
    try {
        const data = { pEmpresa, pDesde, pHasta }
        const result = await axios.post(MantenimientosRutas.Empleados_ValidaJornadaDec, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_ConsultaEmpleadoEmail_Request = async (pToken, pEmpresa, pEmpleado, pEmail) => {
    try {
        const data = { pEmpresa, pEmpleado, pEmail }
        const result = await axios.post(MantenimientosRutas.Empleados_ConsultaEmpleadoEmail, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_Consulta_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.Empleados_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_Guardar_Request = async (pToken, pEmpleado) => {
    try {
        const data = { pEmpleado }
        const result = await axios.post(MantenimientosRutas.Empleados_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_Consulta_Pago_Request = async (pToken, pEmpresa, pTipoPlanilla, pTipoBanco, pTipoArchivo, pAno) => {
    try {
        const data = { pEmpresa, pTipoPlanilla, pTipoBanco, pTipoArchivo, pAno }
        const result = await axios.post(MantenimientosRutas.Empleados_Consulta_Pago, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_ModificarEstado = async (pToken, Empresa, Empleado, estado) => {
    try {
        const data = { Empresa, Empleado, estado }
        const result = await axios.post(MantenimientosRutas.Empleados_ModificarEstado, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_ModificarSalario = async (pToken, pEmpleado) => {
    try {
        const data = { pEmpleado };
        const result = await axios.post(MantenimientosRutas.Empleados_ModificarSalario, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const ConsultarSalarioPorDia = async (pToken, pEmpresa, pEmpleado, pTipoPlanilla) => {
    try {
        const data = { pEmpresa, pEmpleado, pTipoPlanilla }
        const result = await axios.post(MantenimientosRutas.ConsultarSalarioPorDia, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const ObtenerPromedio50Semanas_Request = async (pToken, pEmpresa, pEmpleado, pCantidadDias, pFechaHasta, pResultado, pMonedaExtranjera, pTipoCambio) => {
    try {
        const data = { pEmpresa, pEmpleado, pCantidadDias, pFechaHasta, pResultado, pMonedaExtranjera, pTipoCambio }
        const result = await axios.post(MantenimientosRutas.ObtenerPromedio50Semanas, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const Empleados_TieneEmpleadosACargo_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.Empleados_TieneEmpleadosACargo, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Empleados_TieneEmpleadosUbicacionBorrar_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pSalBruto) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina, pEmpleado, pSalBruto }
        const result = await axios.post(MantenimientosRutas.Empleados_TieneEmpleadosUbicacionBorrar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Empleado Ditribucion Ubicacion///////////////

export const EmpleadoDistUbi_Guardar_Request = async (pToken, pEmpleado, pEmpleadoD, pEmpleadoU) => {
    try {
        const data = { pEmpleado, pEmpleadoD, pEmpleadoU }
        const result = await axios.post(MantenimientosRutas.EmpleadoDistUbi_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoDistUbiSal_Guardar_Request = async (pToken, pEmpleado, pEmpleadoD, pEmpleadoU, pEmpleadoS) => {
    try {
        const data = { pEmpleado, pEmpleadoD, pEmpleadoU, pEmpleadoS }
        const result = await axios.post(MantenimientosRutas.EmpleadoDistUbiSal_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Empleados_CalcularSalario_Request = async (pToken, pEmpresa, pEmpleado, pFechaHasta) => {
    try {
        const data = { pEmpresa, pEmpleado, pFechaHasta }
        const result = await axios.post(MantenimientosRutas.Empleados_CalcularSalario, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoDistUbi_Modificar_Request = async (pToken, pEmpleado, pEmpleadoD, pEmpleadoU) => {
    try {
        const data = { pEmpleado, pEmpleadoD, pEmpleadoU }
        const result = await axios.post(MantenimientosRutas.EmpleadoDistUbi_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoDistUbiSal_Modificar_Request = async (pToken, pEmpleado, pEmpleadoD, pEmpleadoU, pEmpleadoS) => {
    try {
        const data = { pEmpleado, pEmpleadoD, pEmpleadoU, pEmpleadoS }
        const result = await axios.post(MantenimientosRutas.EmpleadoDistUbiSal_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosDistribucion_Lista_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosDistribucion_ListaPorc_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina, pPorcentaje) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina, pPorcentaje }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_ListaPorc, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosDistribucion_ListaASociado_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_ListaASociado, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosDistribucion_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosDistribucion_Guardar_Request = async (pToken, pEmpleadoUb) => {
    try {
        const data = { pEmpleadoUb }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosDistribucion_GuardaElimina_Request = async (pToken, pEmpresa, pEmpleado, pUsuarioM, pEmpleadoDist) => {
    try {
        const data = { pEmpresa, pEmpleado, pUsuarioM, pEmpleadoDist }
        const result = await axios.post(MantenimientosRutas.EmpleadosDistribucion_GuardaElimina, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Empleado Imagen //////////////////


export const EmpleadoImagen_Consulta_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.EmpleadoImagen_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoImagen_SubirImagen_Request = async (pToken, pDatos, pFile) => {
    try {
        const data = { pDatos, pFile }
        let form = new FormData();
        form.append('pDatos', pDatos);
        form.append('pFile', pFile);
        const result = await axios.post(MantenimientosRutas.EmpleadoImagen_SubirImagen, form, { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Aniversarios_SubirImagen_Request = async (pToken, pParametros) => {
    const properties = Object.keys(pParametros);
    let form = new FormData();
    properties.forEach(property => {
        form.append(property, pParametros[property]);
    });
    const result = await axios.post(MantenimientosRutas.SubirImagenAniversarios, form, {
        headers: GetHeaderRequestFormData(pToken),
        //body: form
    });
    return await GetResponseBody(result);
};

export const tablaFontSize_NumeroAniversario = async (pToken) => {
    try {
        //const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.TablaFontSize_NumeroAniversario, JSON.stringify(), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}



export const Obtener_lstHtml = async (pToken, pNombreCarpeta) => {
    try {
        const data = { pNombreCarpeta }
        const result = await axios.post(MantenimientosRutas.Obtener_lstHtml, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const TablaRango_GuardarLista = async (pToken, pUsuario, pTabla) => {
    try {
        const data = { pUsuario, pTabla }
        const result = await axios.post(MantenimientosRutas.TablaRango_GuardarLista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Actualizar_TamnoFuente = async (pToken, pRangoDesde, pRangoHasta, pNuevoValor) => {
    try {
        const data = { pRangoDesde, pRangoHasta, pNuevoValor }
        const result = await axios.post(MantenimientosRutas.Actualizar_TamnoFuente, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const Eliminar_TamanoFuente = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Eliminar_TamanoFuente, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const Registrar_Datos = async (pToken, pUsuario, pTextoCorreo, pFormatoHtml, pNombre1, pNombre2, pNombre3) => {
    try {
        const data = { pUsuario, pTextoCorreo, pFormatoHtml, pNombre1, pNombre2, pNombre3 }
        const result = await axios.post(MantenimientosRutas.Registrar_Datos, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const Registrar_DatosNotificacion = async (pToken, pUsuario, pTextoCorreo, pFormatoHtml, pNombre1, pNombre2, pNombre3) => {
    try {
        const data = { pUsuario, pTextoCorreo, pFormatoHtml, pNombre1, pNombre2, pNombre3 }
        const result = await axios.post(MantenimientosRutas.Registrar_DatosNotificacion, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};


export const Obtener_ParamGenerales = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Obtener_ParamGeneralesAniversarios, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
//////////////Empleado SALUD CONTACOS //////////

export const EmpleadosSaludContactos_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pContactoNombre) => {
    try {
        const data = { pEmpresa, pEmpleado, pContactoNombre }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludContactos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludContactos_Listar_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludContactos_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludContactos_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludContactos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludContactos_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludContactos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosSaludContactos_Eliminar_Request = async (pToken, pEmpresa, pEmpleado, pContactoNombre) => {
    try {
        const data = { pEmpresa, pEmpleado, pContactoNombre }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludContactos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Empleado SALUD DATOS CLINICOS //////////

export const EmpleadosSaludDatosClinicos_Consulta_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludDatosClinicos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludDatosClinicos_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludDatosClinicos_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludDatosClinicos_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludDatosClinicos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosSaludDatosClinicos_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludDatosClinicos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosSaludDatosClinicos_Eliminar_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.EmpleadosSaludDatosClinicos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Empleado Ubicacion ///////////////

export const EmpleadosUbicacion_Lista_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosUbicacion_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosUbicacion_ListaASociado_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosUbicacion_ListaASociado, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosUbicacion_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pEmpleado, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.EmpleadosUbicacion_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const EmpleadosUbicacion_Modificar_Request = async (pToken, pEmpleadoUb) => {
    try {
        const data = { pEmpleadoUb }
        const result = await axios.post(MantenimientosRutas.EmpleadosUbicacion_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadosUbicacion_GuardaElimina_Request = async (pToken, pEmpresa, pEmpleado, pUsuarioM, pEmpleadoUbi) => {
    try {
        const data = { pEmpresa, pEmpleado, pUsuarioM, pEmpleadoUbi }
        const result = await axios.post(MantenimientosRutas.EmpleadosUbicacion_GuardaElimina, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

////////////// EMPLEADO CAMISA ///////////////

export const EmpleadoCamisa_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.EmpleadoCamisa_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoCamisa_Consulta_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoCamisa_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoCamisa_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoCamisa_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoCamisa_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoCamisa_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoCamisa_Eliminar_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoCamisa_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


////////////// EMPLEADO PANTALON ///////////////

export const EmpleadoPantalon_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.EmpleadoPantalon_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoPantalon_Consulta_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoPantalon_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoPantalon_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoPantalon_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoPantalon_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoPantalon_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoPantalon_Eliminar_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoPantalon_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

////////////// EMPLEADO ZAPATO ///////////////

export const EmpleadoZapato_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.EmpleadoZapato_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoZapato_Consulta_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoZapato_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const EmpleadoZapato_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoZapato_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoZapato_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.EmpleadoZapato_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const EmpleadoZapato_Eliminar_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.EmpleadoZapato_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}





////////////FORMATOS/////////////////////////////
export const Cantidad_DecimalesPocentaje_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Cantidad_DecimalesPocentaje, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Cantidad_DecimalesMoneda_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Cantidad_DecimalesMoneda, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Cantidad_DecimalesCantidad_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Cantidad_DecimalesCantidad, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

///////////CUPON DEPARTAMENTO  ///
export const CuponDepartamento_GuardarLista = async (pToken, pListaCupones) => {
    try {
        const data = { pListaCupones }
        const result = await axios.post(MantenimientosRutas.CuponDepartamento_GuardarLista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const CuponDepartamento_Listar_Request = async (pToken, pEmpresa, pCargaId) => {
    try {
        const data = { pEmpresa, pCargaId }
        const result = await axios.post(MantenimientosRutas.CuponDepartamento_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const CuponDepartamento_Eliminar_Request = async (pToken, pEmpresa, pCargaId) => {
    try {
        const data = { pEmpresa, pCargaId }
        const result = await axios.post(MantenimientosRutas.CuponDepartamento_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

////////////CUP�N ENCABEZADO  ///

export const CuponEncabezado_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.CuponEncabezado_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const CuponEncabezado_Eliminar_Request = async (pToken, pEmpresa, pCargaId, pProveedorId) => {
    try {
        const data = { pEmpresa, pCargaId, pProveedorId }
        const result = await axios.post(MantenimientosRutas.CuponEncabezado_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

///////////CUPON DETALLE  ///

export const CuponDetalle_Listar_Request = async (pToken, pEmpresa, pCarga_Id) => {
    try {
        const data = { pEmpresa, pCarga_Id }
        const result = await axios.post(MantenimientosRutas.CuponDetalle_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const CuponDetalle_ListarEn_Request = async (pToken, pEmpresa, pProveedor_Id, pListaCupones) => {
    try {
        const data = { pEmpresa, pProveedor_Id, pListaCupones }
        const result = await axios.post(MantenimientosRutas.CuponDetalle_ListarEn, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};


export const CuponDetalle_GuardarLista_Request = async (pToken, pListaCupones) => {
    try {
        const data = { pListaCupones }
        const result = await axios.post(MantenimientosRutas.CuponDetalle_GuardarLista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};

export const CuponEncabezado_Guardar_Request = async (pToken, Empresa, Proveedor_Id, Nombre, Descripcion, Fecha_Validez, Usuario_Carga) => {
    try {
        const data = { Empresa, Proveedor_Id, Nombre, Descripcion, Fecha_Validez, Usuario_Carga }
        const result = await axios.post(MantenimientosRutas.CuponEncabezado_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
};


////////////PROVEEDOR CUPONES ///

export const ProveedorCupon_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.ProveedorCupon_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const ProveedorCupon_Consulta_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.ProveedorCupon_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const ProveedorCupon_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.ProveedorCupon_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const ProveedorCupon_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.ProveedorCupon_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const ProveedorCupon_Eliminar_Request = async (pToken, pEmpresa, pId) => {
    try {
        const data = { pEmpresa, pId }
        const result = await axios.post(MantenimientosRutas.ProveedorCupon_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


////////////GRADOS///

export const Grados_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.Grados_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Grados_Consulta_Request = async (pToken, pEmpresa, pGrado) => {
    try {
        const data = { pEmpresa, pGrado }
        const result = await axios.post(MantenimientosRutas.Grados_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Grados_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.Grados_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Grados_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.Grados_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Grados_Eliminar_Request = async (pToken, pEmpresa, pGrado) => {
    try {
        const data = { pEmpresa, pGrado }
        const result = await axios.post(MantenimientosRutas.Grados_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

////////////HIJOS///

export const Hijos_Listar_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.Hijos_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Hijos_Guardar_Request = async (pToken, pEmpresa, pEmpleado, pHijos) => {
    try {
        const data = { pEmpresa, pEmpleado, pHijos }
        const result = await axios.post(MantenimientosRutas.Hijos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

////////////INGRESOS Y DEDUCCIONES ///

export const IngresoDeduccion_Consulta_Request = async (pToken, Empresa, Id, Tipo) => {
    try {
        const data = { Empresa, Id, Tipo }
        const result = await axios.post(MantenimientosRutas.IngresoDeduccion_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const IngresosDeduccionesSalario_Consultar_Request = async (pToken, pEmpresa, pEmpleado, pTipoPlanilla) => {
    try {
        const data = { pEmpresa, pEmpleado, pTipoPlanilla }
        const result = await axios.post(MantenimientosRutas.IngresosDeduccionesSalario_Consultar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


////////////INGRESOS Y DEDUCCIONES TEMPORALES///

export const IngresoDeduccionTemp_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pIngresoDeduccion, pTipo, pClase) => {
    try {
        const data = { pEmpresa, pEmpleado, pIngresoDeduccion, pTipo, pClase }
        const result = await axios.post(MantenimientosRutas.IngresoDeduccionTemp_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const IngDedTemporales_ListGuardar_Request = async (pToken, pIngDedTemporales, pEmpresa, pId, pTipo, pPorEmpleado) => {
    try {
        const data = { pIngDedTemporales, pEmpresa, pId, pTipo, pPorEmpleado }
        const result = await axios.post(MantenimientosRutas.IngDedTemporales_ListGuardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const IngresoDeduccionTemp_ListEliminar_Request = async (pToken, pIngDedTemporales) => {
    try {
        const data = { pIngDedTemporales }
        const result = await axios.post(MantenimientosRutas.IngresoDeduccionTemp_ListEliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////LIBRO DE SALARIOS//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

export const LibroSalarios_Consulta_Request = async (pToken, pEmpresa, pEmpleado, pAno, pMes) => {
    try {
        const data = { pEmpresa, pEmpleado, pAno, pMes }
        const result = await axios.post(MantenimientosRutas.libroSalarios_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Consulta_LibroSalarios_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.Consulta_LibroSalarios, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const LibroSalariosMensual_Consulta_Request = async (pToken, pEmpresa, pAno, pMes) => {
    try {
        const data = { pEmpresa, pAno, pMes }
        const result = await axios.post(MantenimientosRutas.LibroSalariosMensual_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const LibroSalarios_ListarEmpleado_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.LibroSalarios_ListarEmpleado, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const LibroSalario_Modificar_Request = async (pToken, pLibroSalarios) => {
    try {
        const data = { pLibroSalarios }
        const result = await axios.post(MantenimientosRutas.LibroSalarios_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const LibroSalario_Guardar_Request = async (pToken, pLibroSalarios) => {
    try {
        const data = { pLibroSalarios }
        const result = await axios.post(MantenimientosRutas.LibroSalarios_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const LibroSalario_Eliminar_Request = async (pToken, pLibroSalarios) => {
    try {
        const data = { pLibroSalarios }
        const result = await axios.post(MantenimientosRutas.LibroSalarios_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Marca Justificacion Opciones///////////////

//export const PLMarcaJustificacionOpciones_Consulta_Request = async (pToken, pJustificacionID) => {
//    try {
//        const data = { pJustificacionID }
//        const result = await axios.post(MantenimientosRutas.PLMarcaJustificacionOpciones_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
//        return await GetResponseBody(result);
//    } catch (error) {
//        let pResult = {};
//        pResult.status = 401;
//        let _result = GetResponseBodyError(pResult);
//        return _result;
//    }
//}

export const PLMarcaJustificacionOpciones_Lista_Request = async (pToken, pEmpresa, pActivo) => {
    try {
        const data = { pEmpresa, pActivo }
        const result = await axios.post(MantenimientosRutas.PLMarcaJustificacionOpciones_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//export const PLMarcaJustificacionOpciones_Guardar_Request = async (pToken, pDatos) => {
//    try {
//        const data = { pDatos }
//        const result = await axios.post(MantenimientosRutas.PLMarcaJustificacionOpciones_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
//        return await GetResponseBody(result);
//    } catch (error) {
//        let pResult = {};
//        pResult.status = 401;
//        let _result = GetResponseBodyError(pResult);
//        return _result;
//    }
//}

//export const PLMarcaJustificacionOpciones_Modificar_Request = async (pToken, pDatos) => {
//    try {
//        const data = { pDatos }
//        const result = await axios.post(MantenimientosRutas.PLMarcaJustificacionOpciones_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
//        return await GetResponseBody(result);
//    } catch (error) {
//        let pResult = {};
//        pResult.status = 401;
//        let _result = GetResponseBodyError(pResult);
//        return _result;
//    }
//}

//export const PLMarcaJustificacionOpciones_Eliminar_Request = async (pToken, pJustificacionID) => {
//    try {
//        const data = { pJustificacionID }
//        const result = await axios.post(MantenimientosRutas.PLMarcaJustificacionOpciones_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
//        return await GetResponseBody(result);
//    } catch (error) {
//        let pResult = {};
//        pResult.status = 401;
//        let _result = GetResponseBodyError(pResult);
//        return _result;
//    }
//}

//////////////NIVEL 1///////////////

export const Nivel1_Consulta_Request = async (pToken, pNivel1) => {
    try {
        const data = { pNivel1 }
        const result = await axios.post(MantenimientosRutas.Nivel1_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Nivel1_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Nivel1_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel1_Guardar_Request = async (pToken, pNivel1) => {
    try {
        const data = { pNivel1 }
        const result = await axios.post(MantenimientosRutas.Nivel1_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel1_Modificar_Request = async (pToken, pNivel1) => {
    try {
        const data = { pNivel1 }
        const result = await axios.post(MantenimientosRutas.Nivel1_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel1_Eliminar_Request = async (pToken, pNivel1) => {
    try {
        const data = { pNivel1 }
        const result = await axios.post(MantenimientosRutas.Nivel1_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////NIVEL 2///////////////

export const Nivel2_Consulta_Request = async (pToken, pNivel1, pNivel2) => {
    try {
        const data = { pNivel1, pNivel2 }
        const result = await axios.post(MantenimientosRutas.Nivel2_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Nivel2_Listar_Request = async (pToken, pNivel1) => {
    try {
        const data = { pNivel1 }
        const result = await axios.post(MantenimientosRutas.Nivel2_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel2_Guardar_Request = async (pToken, pNivel2) => {
    try {
        const data = { pNivel2 }
        const result = await axios.post(MantenimientosRutas.Nivel2_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel2_Modificar_Request = async (pToken, pNivel2) => {
    try {
        const data = { pNivel2 }
        const result = await axios.post(MantenimientosRutas.Nivel2_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel2_Eliminar_Request = async (pToken, pNivel1, pNivel2) => {
    try {
        const data = { pNivel1, pNivel2 }
        const result = await axios.post(MantenimientosRutas.Nivel2_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////NIVEL 3///////////////

export const Nivel3_Consulta_Request = async (pToken, pNivel1, pNivel2, pNivel3) => {
    try {
        const data = { pNivel1, pNivel2, pNivel3 }
        const result = await axios.post(MantenimientosRutas.Nivel3_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Nivel3_Listar_Request = async (pToken, pNivel1, pNivel2) => {
    try {
        const data = { pNivel1, pNivel2 }
        const result = await axios.post(MantenimientosRutas.Nivel3_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel3_Guardar_Request = async (pToken, pNivel3) => {
    try {
        const data = { pNivel3 }
        const result = await axios.post(MantenimientosRutas.Nivel3_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel3_Modificar_Request = async (pToken, pNivel3) => {
    try {
        const data = { pNivel3 }
        const result = await axios.post(MantenimientosRutas.Nivel3_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Nivel3_Eliminar_Request = async (pToken, pNivel1, pNivel2, pNivel3) => {
    try {
        const data = { pNivel1, pNivel2, pNivel3 }
        const result = await axios.post(MantenimientosRutas.Nivel3_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////OFICINAS///////////////

export const Oficina_Consulta_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.Oficina_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Oficinas_PlzasDisponibles_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.Oficinas_PlzasDisponibles, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Oficina_lista_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion }
        const result = await axios.post(MantenimientosRutas.Oficina_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Oficinas_Guardar_Request = async (pToken, pOficina) => {
    try {
        const data = { pOficina }
        const result = await axios.post(MantenimientosRutas.Oficinas_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Oficinas_Modificar_Request = async (pToken, pOficina) => {
    try {
        const data = { pOficina }
        const result = await axios.post(MantenimientosRutas.Oficinas_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Oficinas_Eliminar_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion, pOficina) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion, pOficina }
        const result = await axios.post(MantenimientosRutas.Oficinas_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
//////////////PAIS///////////////

export const Pais_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.Pais_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Pais_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Pais_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Pais_Guardar_Request = async (pToken, pPais) => {
    try {
        const data = { pPais }
        const result = await axios.post(MantenimientosRutas.Pais_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Pais_Modificar_Request = async (pToken, pPais) => {
    try {
        const data = { pPais }
        const result = await axios.post(MantenimientosRutas.Pais_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Pais_Eliminar_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.Pais_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////PARAMETROS AUTOGESTION///////////////

export const Parametro_Autogestion_Consulta_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.Parametro_Autogestion_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Parametro_Autogestion_GuardarED_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.Parametro_Autogestion_GuardarED, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Parametro_Autogestion_ModificarED_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.Parametro_Autogestion_ModificarED, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////PARAMETROS GENERALES///////////////

export const ParametrosGenerales_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const ParametrosGenerales_Listar_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const ParametrosGenerales_Guardar_Request = async (pToken, pParametrosGral) => {
    try {
        const data = { pParametrosGral }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const ParametrosGenerales_GuardarAct_Request = async (pToken, pParametrosGral) => {
    try {
        const data = { pParametrosGral }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_GuardarActualizar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const ParametrosGenerales_Modificar_Request = async (pToken, pParametrosGral) => {
    try {
        const data = { pParametrosGral }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const ParametrosGenerales_Eliminar_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.ParametrosGenerales_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////Planilla///////////////

export const Planilla_ObtenerSalarioPromedioPorTipoMovimiento = async (pToken, Empresa, Empleado, TipoPlanilla, TipoMovimiento, CantidadMeses) => {
    try {
        const data = { Empresa, Empleado, TipoPlanilla, TipoMovimiento, CantidadMeses }
        const result = await axios.post(MantenimientosRutas.Planilla_ObtenerSalarioPromedioPorTipoMovimiento, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////POLIZAS///////////////

export const Polizas_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.Polizas_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Polizas_Consulta_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.Polizas_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Polizas_Guardar_Request = async (pToken, pPoliza) => {
    try {
        const data = { pPoliza }
        const result = await axios.post(MantenimientosRutas.Polizas_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Polizas_Modificar_Request = async (pToken, pPoliza) => {
    try {
        const data = { pPoliza }
        const result = await axios.post(MantenimientosRutas.Polizas_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Polizas_Eliminar_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.Polizas_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////PUESTOS///////////////

export const Puestos_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.Puestos_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Puestos_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.Puestos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Puestos_Guardar_Request = async (pToken, pPuesto) => {
    try {
        const data = { pPuesto }
        const result = await axios.post(MantenimientosRutas.Puestos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Puestos_Modificar_Request = async (pToken, pPuesto) => {
    try {
        const data = { pPuesto }
        const result = await axios.post(MantenimientosRutas.Puestos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Puestos_Eliminar_Request = async (pToken, pCodigo, pUsuario) => {
    try {
        const data = { pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.Puestos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////RANGOS RENTA //////

export const RangosRenta_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.RangosRenta_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////RANGOS VACACIONES ACUMULADAS //////
export const RangosVacAcum_CantidadAcumula_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.RangosVacAcum_CantidadAcumula, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const RangosVacAcum_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.RangosVacAcum_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const RangosVacAcum_Guardar_Request = async (pToken, pVacacionesAcum) => {
    try {
        const data = { pVacacionesAcum }
        const result = await axios.post(MantenimientosRutas.RangosVacAcum_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////RESTRICCIÓN DE DOMINIOS//////////////////
export const RestriccionDominios_Consulta_Request = async (pToken, pResDom_Codigo) => {
    try {
        const data = { pResDom_Codigo }
        const result = await axios.post(MantenimientosRutas.RestriccionDominios_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const RestriccionDominiosNombre_Consulta_Request = async (pToken, pEmailDominio) => {
    try {
        const data = { pEmailDominio }
        const result = await axios.post(MantenimientosRutas.RestriccionDominiosNombre_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const RestriccionDominios_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.RestriccionDominios_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const RestriccionDominios_Guardar_Request = async (pToken, pRestriccionDominios) => {
    try {
        const data = { pRestriccionDominios }
        const result = await axios.post(MantenimientosRutas.RestriccionDominios_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const RestriccionDominios_Modificar_Request = async (pToken, pRestriccionDominios) => {
    try {
        const data = { pRestriccionDominios }
        const result = await axios.post(MantenimientosRutas.RestriccionDominios_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
export const RestriccionDominios_Eliminar_Request = async (pToken, pResDom_Codigo, pUsuario) => {
    try {
        const data = { pResDom_Codigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.RestriccionDominios_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////SALARIO ACTUAL///////////////

export const SalarioActual_EliminarEmpleado_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.SalarioActual_EliminarEmpleado, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////SECCIONES///////////////

export const Seccion_Consulta_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion }
        const result = await axios.post(MantenimientosRutas.Seccion_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Seccion_Lista_Request = async (pToken, pEmpresa, pArea, pDepto) => {
    try {
        const data = { pEmpresa, pArea, pDepto }
        const result = await axios.post(MantenimientosRutas.Seccion_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Secciones_Guardar_Request = async (pToken, pSeccion) => {
    try {
        const data = { pSeccion }
        const result = await axios.post(MantenimientosRutas.Secciones_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Secciones_Modificar_Request = async (pToken, pSeccion) => {
    try {
        const data = { pSeccion }
        const result = await axios.post(MantenimientosRutas.Secciones_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const Secciones_Eliminar_Request = async (pToken, pEmpresa, pArea, pDepto, pSeccion) => {
    try {
        const data = { pEmpresa, pArea, pDepto, pSeccion }
        const result = await axios.post(MantenimientosRutas.Secciones_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////TIPO ACCION INFORMATIVA///////////////

export const TipoAccionInformativa_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.TipoAccionInformativa_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoAccionInformativa_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoAccionInformativa_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoAccionInformativa_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoAccionInformativa_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoAccionInformativa_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoAccionInformativa_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoAccionInformativa_Eliminar_Request = async (pToken, pCodigo, pUsuario) => {
    try {
        const data = { pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.TipoAccionInformativa_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////TIPO CXC///////////////

export const TipoCxC_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.TipoCxC_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoCxC_Consulta_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoCxC_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoCxC_Guardar_Request = async (pToken, pTipoCxC) => {
    try {
        const data = { pTipoCxC }
        const result = await axios.post(MantenimientosRutas.TipoCxC_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoCxC_Modificar_Request = async (pToken, pTipoCxC) => {
    try {
        const data = { pTipoCxC }
        const result = await axios.post(MantenimientosRutas.TipoCxC_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoCxC_Eliminar_Request = async (pToken, pEmpresa, pCodigo, pUsuario) => {
    try {
        const data = { pEmpresa, pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.TipoCxC_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////TIPO DOCUMENTO///////////////

export const TipoDocumentos_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.TipoDocumentos_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoDocumentos_Consulta_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoDocumentos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoDocumentos_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoDocumentos_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoDocumentos_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoDocumentos_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoDocumentos_Eliminar_Request = async (pToken, pEmpresa, pCodigo, pUsuario) => {
    try {
        const data = { pEmpresa, pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.TipoDocumentos_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////TIPO INCAPACIDAD///////////////

export const TipoIncapacidad_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.TipoIncapacidad_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoIncapacidad_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoIncapacidad_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
        //        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoIncapacidad_Guardar_Request = async (pToken, pPuesto) => {
    try {
        const data = { pPuesto }
        const result = await axios.post(MantenimientosRutas.TipoIncapacidad_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoIncapacidad_Modificar_Request = async (pToken, pPuesto) => {
    try {
        const data = { pPuesto }
        const result = await axios.post(MantenimientosRutas.TipoIncapacidad_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoIncapacidad_Eliminar_Request = async (pToken, pCodigo, pUsuario) => {
    try {
        const data = { pCodigo, pUsuario }
        const result = await axios.post(MantenimientosRutas.TipoIncapacidad_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////TIPO JORNADA///////////////

export const TipoJornada_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.TipoJornada_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoJornada_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoJornada_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoJornada_Guardar_Request = async (pToken, pTipoJornada) => {
    try {
        const data = { pTipoJornada }
        const result = await axios.post(MantenimientosRutas.TipoJornada_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoJornada_Modificar_Request = async (pToken, pTipoJornada) => {
    try {
        const data = { pTipoJornada }
        const result = await axios.post(MantenimientosRutas.TipoJornada_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoJornada_Eliminar_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoJornada_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////TIPO LICENCIA///////////////


export const TipoLicencia_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.TipoLicencia_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoLicencia_Consulta_Request = async (pToken, pEmpresa, pTipoLic_Codigo) => {
    try {
        const data = { pEmpresa, pTipoLic_Codigo }
        const result = await axios.post(MantenimientosRutas.TipoLicencia_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoLicencia_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoLicencia_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoLicencia_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TipoLicencia_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoLicencia_Eliminar_Request = async (pToken, pEmpresa, pTipoLic_Codigo) => {
    try {
        const data = { pEmpresa, pTipoLic_Codigo }
        const result = await axios.post(MantenimientosRutas.TipoLicencia_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}




//////////////TIPO PLANILLA///////////////

export const TipoPlanilla_Listar_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoPlanilla_Periodo_Listar_Request = async (pToken, pEmpresa, pTipoPlanilla, pEmpleado, pTipoColilla) => {
    try {
        const data = { pEmpresa, pTipoPlanilla, pEmpleado, pTipoColilla }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Periodo_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoPlanilla_Consulta_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoPlanilla_Guardar_Request = async (pToken, pTipoPlanilla) => {
    try {
        const data = { pTipoPlanilla }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoPlanilla_Modificar_Request = async (pToken, pTipoPlanilla) => {
    try {
        const data = { pTipoPlanilla }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoPlanilla_Eliminar_Request = async (pToken, pEmpresa, pCodigo) => {
    try {
        const data = { pEmpresa, pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoPlanilla_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////TIPO SANGRE///////////////

export const TipoSangre_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.TipoSangre_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


//////////////TIPO SEGURO///////////////

export const TipoSeguro_Listar_Request = async (pToken) => {
    try {
        const data = {}
        const result = await axios.post(MantenimientosRutas.TipoSeguro_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoSeguro_Consulta_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoSeguro_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TipoSeguro_Guardar_Request = async (pToken, pTipoJornada) => {
    try {
        const data = { pTipoJornada }
        const result = await axios.post(MantenimientosRutas.TipoSeguro_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoSeguro_Modificar_Request = async (pToken, pTipoJornada) => {
    try {
        const data = { pTipoJornada }
        const result = await axios.post(MantenimientosRutas.TipoSeguro_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}


export const TipoSeguro_Eliminar_Request = async (pToken, pCodigo) => {
    try {
        const data = { pCodigo }
        const result = await axios.post(MantenimientosRutas.TipoSeguro_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////LIQUIDACION///////////////

export const Liquidacion_Listar_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.Liquidacion_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////CONSTANCIA SALARIAL FORMATO 6///////////////
export const ConstanciaSalarialFormato6_Listar_Request = async (pToken, pEmpresa, pEmpleado) => {
    try {
        const data = { pEmpresa, pEmpleado }
        const result = await axios.post(MantenimientosRutas.ConstanciaSalarialFormato6_Listar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////TiposAviso///////////////

export const TiposAviso_Consulta_Request = async (pToken, pTipoAviso_Codigo) => {
    try {
        const data = { pTipoAviso_Codigo }
        const result = await axios.post(MantenimientosRutas.TiposAviso_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TiposAviso_Lista_Request = async (pToken, pEmpresa) => {
    try {
        const data = { pEmpresa }
        const result = await axios.post(MantenimientosRutas.TiposAviso_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TiposAviso_Guardar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TiposAviso_Guardar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TiposAviso_Modificar_Request = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.TiposAviso_Modificar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const TiposAviso_Eliminar_Request = async (pToken, pTipoAviso_Codigo) => {
    try {
        const data = { pTipoAviso_Codigo }
        const result = await axios.post(MantenimientosRutas.TiposAviso_Eliminar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

//////////////MonitorAvisos///////////////

export const MonitorAvisos_Consulta_Request = async (pToken, pMonitor_Codigo) => {
    try {
        const data = { pMonitor_Codigo }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_Lista_Request = async (pToken, pEmpresa, pTipoAviso, pFechaInicial, pFechaFinal, pEstado, pEstadoDiferenteDe) => {
    try {
        const data = { pEmpresa, pTipoAviso, pFechaInicial, pFechaFinal, pEstado, pEstadoDiferenteDe }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_Lista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_Aceptar_Request = async (pToken, pCodigo, pUsuario, pTipoAviso) => {
    try {
        const data = { pCodigo, pUsuario, pTipoAviso }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_Aceptar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_Rechazar_Request = async (pToken, pCodigo, pUsuario, pMotivo, pTipoAviso) => {
    try {
        const data = { pCodigo, pUsuario, pMotivo, pTipoAviso }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_Rechazar, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_AceptarLista_Request = async (pToken, pDatos, pUsuario) => {
    try {
        const data = { pDatos, pUsuario }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_AceptarLista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_RechazarLista_Request = async (pToken, pDatos, pUsuario, pMotivo) => {
    try {
        const data = { pDatos, pUsuario, pMotivo }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_RechazarLista, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const MonitorAvisos_Descargar_Request = async (pToken, pMonitor_Codigo) => {
    try {
        const data = { pMonitor_Codigo }
        const result = await axios.post(MantenimientosRutas.MonitorAvisos_DescargarArchivo, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const JefeOrigen_Request = async (pToken, pEmpresa, pOrigen) => {
    try {
        const data = { pEmpresa, pOrigen }
        const result = await axios.post(MantenimientosRutas.JefeDirecto_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const JefeAprobadorGestiones_Request = async (pToken, pEmpresa, pOrigen) => {
    try {
        const data = { pEmpresa, pOrigen }
        const result = await axios.post(MantenimientosRutas.JefeAprobadorGestiones_Request, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const CambioJefatura_Empleados_Consulta_Request = async (pToken, pEmpresa, pIdArea, pIdDepartamento, pReportarA, pReportaAJefe, pJefe_Directo_2, pAprobador_Gest_Jef_2) => {
    try {
        const data = { pEmpresa, pIdArea, pIdDepartamento, pReportarA, pReportaAJefe, pJefe_Directo_2, pAprobador_Gest_Jef_2 }
        const result = await axios.post(MantenimientosRutas.CambioJefatura_Empleados_Consulta, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}

export const Actualizacion_Empleado_Cambio_Masivo_Jefatura = async (pToken, pDatos) => {
    try {
        const data = { pDatos }
        const result = await axios.post(MantenimientosRutas.Actualizacion_Empleado_Cambio_Masivo_Jefatura, JSON.stringify(data), { headers: GetHeaderRequest(pToken) });
        return await GetResponseBody(result);
    } catch (error) {
        let pResult = {};
        pResult.status = 401;
        let _result = GetResponseBodyError(pResult);
        return _result;
    }
}
