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;
    }
}

//////////////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 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;
    }
}

////////////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;
    }
}

//////////////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) => {
   try {
       const data = { pCodigo, pUsuario }
       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) => {
    try {
        const data = { pCodigo, pUsuario, pMotivo }
        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_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;
    }
}