sigesp 0.10.0-20240129 → 1.0.1-20240419

package/esm2020/lib/sigesp.service.mjs

@@ -0,0 +1,2050 @@
+import { MPrefijo } from './core/models/CFG/MPrefijo.model';
+import { MEnterprise } from './core/models/CFG/Enterprise.model';
+import { MPersonalNomina } from './core/models/SNO/MPersonalNomina.model';
+import { MHojaTiempo } from './core/models/SNO/MHojaTiempo.model';
+import { Injectable } from '@angular/core';
+import { MUsuario } from './core/models/SSS/user.model';
+import { HttpHeaders } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { MProveedor } from './core/models/RPC/proveedores.model';
+import { map, catchError, retry } from 'rxjs/operators';
+import { MUsuarioPrefijo } from './core/models/CFG/userPrefix.model';
+import { CatalogoComponent } from './shared/components/catalogo/catalogo.component';
+import { MCuentaPresupuesto } from './core/models/SPG/cuentaPresupuesto.model';
+import { MCuentaInstitucional } from './core/models/SCG/cuentaInstitucional.model';
+import { MMoneda, MMonedaConfig } from './core/models/CFG/moneda.model';
+import { MUnidadTributaria } from './core/models/STB/unidadTributaria.model';
+import { ConfirmComponent } from './shared/components/confirm/confirm.component';
+import { MConfiguracionSCG } from './core/models/SCG/configuracionSCG.model';
+import { MPlanUnicoCuenta } from './core/models/SCG/planUnicoCuenta.model';
+import { TableSelectComponent } from './shared/components/table-select/table-select.component';
+import { MConfigurationSPG } from './core/models/SPG/configurationSPG.model';
+import { MEstructuraPresupuestariaOne, MEstructuraPresupuestariaTwo, MEstructuraPresupuestariaThree, MEstructuraPresupuestariaFour, MEstructuraPresupuestariaFiveComplete, MEstructuraPresupuestariaFive, MAllStructure } from './core/models/SPG/estructuraPresupuestaria.model';
+import { MCentroCosto, MUsuarioCentroCosto } from './core/models/SCG/centroCosto.model';
+import { MFuenteFinanciamiento } from './core/models/SPG/fuenteFinanciamiento.model';
+import { MCuentaEgresos } from './core/models/SPG/expensiveAccount.model';
+import { CatalogoEstructurasComponent } from './shared/components/catalogo-estructuras/catalogo-estructuras.component';
+import { CatalogoDobleInputComponent } from './shared/components/catalogo-doble-input/catalogo-doble-input.component';
+import { MSistema, MUsuarioSistema } from './core/models/SSS/sistema';
+import { MComprobantePresupuestarioEgresos, MComprobantePresupuestarioIngresos } from './core/models/SPG/comprobantePresupuestario.model';
+import { MCuentaIngresos } from './core/models/SCG/IncomeAccount';
+import { MIncomeStructureAccount } from './core/models/SPG/incomeStructureAccount.model';
+import { MOrganizationType } from './core/models/SPG/organizationType.model';
+import { MSpecialty } from './core/models/RPC/specialty.model';
+import { MDocument } from './core/models/RPC/document.model';
+import { MClasification } from './core/models/RPC/clasification.model';
+import { MCountry, MState, MMunicipality, MParish, MCity, MCommunity } from './core/models/CFG/locations.model';
+import { MProviderBeneficiary } from './core/models/RPC/providerBeneficiary.model';
+import { MSigecofBank, MBank, MBankAccountType, MAgenciaBanco, MCuentaBanco } from './core/models/SCB/bank.model';
+import { MConfigurationRPC } from './core/models/RPC/configuracionRPC.model';
+import { MConfigSOC } from './core/models/SOC/configuracionSOC.model';
+import { MDeductionType } from './core/models/STB/deductionType.model';
+import { MCargo } from './core/models/SOC/charge.model';
+import { MConceptoRetencion, MDeduction } from './core/models/STB/deduction.model';
+import { MConfigSSS } from './core/models/SSS/securityConfiguration.model';
+import { MAdministrativeUnit } from './core/models/SPG/administrativeUnit.model';
+import { MComponent } from './core/models/SSS/component.model';
+import { MServiceCharge } from './core/models/SOC/serviceCharge.model';
+import { MEmpresa } from './core/models/CFG/Empresa.model';
+import { MConceptosCXP } from './core/models/CXP/MConceptosCXP.model';
+import { MTipoDocumentoCXP } from './core/models/CXP/MTipoDocumentoCXP.model';
+import { MConfiguracionSNO } from './core/models/SNO/MConfiguracionSNO.model';
+import { MDefinicionNomina } from './core/models/SNO/MDefinicionNomina.model';
+import { MAsignacionCargo } from './core/models/SNO/MAsignacionCargo.model';
+import { MNominaSimple } from './core/models/SNO/MNominaSimple.model';
+import { MPersonal } from './core/models/SNO/MPersonal.model';
+import { MEntradaSuministros } from './core/models/SIV/MEntradaSuministro.model';
+import Swal from 'sweetalert2';
+import * as CryptoJS from 'crypto-js';
+import { MTipoDepositos } from './core/models/SIV/MTipoDepositos.model';
+import { MComunidad } from './core/models/CFG/comunidad.model';
+import { MExchangeRate } from './core/models/CFG/TasaCambio.model';
+import { MCargosAdicionales } from './core/models/STB/MCargosAdicionales';
+import { MClient } from './core/models/SFV/MClienteModel';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "ngx-toastr";
+export class SigespService {
+    // public URL: string = "http://192.168.1.67/sigesp_php";
+    // usuarioActivo: MUsuario = {
+    //   conexionDB: {
+    //     baseDeDatos: "db_sigesp_demov3",
+    //     gestor: "postgres",
+    //     login: "postgres",
+    //     nombre: "SIGESP C.A, servidor 85 (SE PUEDE USAR)",
+    //     password: "adminsigesp",
+    //     puerto: "5432",
+    //     servidor: "192.168.1.67",
+    //   },
+    //   empresa: {
+    //     id: 1,
+    //     periodoFiscal: "2019-01-01",
+    //     titulo: "SIGESP C.A."
+    //   },
+    //   nombre: "SIGESP",
+    //   token: "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzM4NCJ9.eyJwYXNzd29yZF91c3UiOiIxMjM0NTY3OCIsImlkX2VtcHJlc2EiOiIxIiwidGl0ZW1wIjoiU0lHRVNQIEMuQS4iLCJwZXJmaXNjYWwiOiIyMDE5LTAxLTAxIiwibF91c3VhcmlvIjoiU0lHRVNQIiwic2Vydmlkb3IiOiIxOTIuMTY4LjEuNjciLCJwdWVydG8iOiI1NDMyIiwiYmFzZWRlZGF0b3MiOiJkYl9zaWdlc3BfZGVtb3YzIiwibG9naW4iOiJwb3N0Z3JlcyIsInBhc3N3b3JkIjoiYWRtaW5zaWdlc3AifQ.PISBSfueRAdsWsJ1AaGcVCgW-2aJkgtvLdsW0Bgo5ltyYowD8oy_nqK5sjE2URGk"
+    // }
+    // procede: string = 'SCGCMP';
+    // codsis: string = 'SCG';
+    constructor(http, dialog, toast) {
+        this.http = http;
+        this.dialog = dialog;
+        this.toast = toast;
+        this.usuarioActivo = null;
+        this.currentComponent = null;
+        this.userMenu = null;
+        this.ip_adress = '127.0.0.1';
+    }
+    /**
+     * @description Valida que selo se escriban guiones y 9
+     * @param event
+     */
+    onlyGuionesAndNine(event) {
+        if (event.key === '-' || event.key === '9') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @description Actualiza el moncmp de sigesp_comprobante
+     */
+    updateComprobanteAmount(amount, idComprobante) {
+        return this.http.put(`${this.URL}/dao/sigesp/comprobante_dao.php?monto=true`, {
+            moncmp: amount,
+            id_comprobante: idComprobante
+        }, {
+            headers: this.getHttpHeaders()
+        });
+    }
+    /**
+     * @description Actualiza el comprobante prsupuestario de Egresos
+     * @param comprobante
+     */
+    updateComprobantePresupuestarioEgresos(comprobante) {
+        return this.http.put(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`, { ...comprobante, id: comprobante.id_dt_spgcmp }, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene el comprobante presupuestario de Egresos
+     */
+    getComprobantePresupuestarioEgresos() {
+        return this.http.get(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`, {
+            headers: this.getHttpHeaders()
+        }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(element => new MComprobantePresupuestarioEgresos(element))));
+    }
+    /**
+     * @description Actualiza el comprobante prsupuestario de Ingresos
+     * @param comprobante
+     */
+    updateComprobantePresupuestarioIngresos(comprobante) {
+        return this.http.put(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`, { ...comprobante, id: comprobante.id_dt_spicmp }, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene el comprobante presupuestario de Ingresos
+     */
+    getComprobantePresupuestarioIngresos() {
+        return this.http.get(`${this.URL}/dao/spi/comprobante_presupuestario_ingresos_dao.php`, {
+            headers: this.getHttpHeaders()
+        }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(element => new MComprobantePresupuestarioIngresos(element))));
+    }
+    /**
+     * @Actualiza la distribución de la cuenta de egreso
+     * @param distribution
+     */
+    updateDistributionExpenseAccount(distribution) {
+        return this.http.put(`${this.URL}/dao/spg/cuentas_egresos_dao.php`, distribution, { headers: this.getHttpHeaders() });
+    }
+    /**
+  * @Actualiza la distribución de la cuenta de egreso
+  * @param distribution
+  */
+    updateDistributionExpenseAccount2(distribution) {
+        return this.http.put(`${this.URL}/dao/spg/cuentas_egresos_dao.php`, distribution, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @Actualiza la distribución de la cuenta de Ingreso
+     * @param distribution
+     */
+    updateDistributionIncomeAccount(distribution) {
+        return this.http.put(`${this.URL}/dao/spi/cuentas_ingresos_dao.php`, distribution, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => {
+            if (res.success) {
+                res.data = new MCuentaIngresos(res.data);
+            }
+            return res;
+        }));
+    }
+    updateDistributionIncomeAccount2(distribution) {
+        return this.http.put(`${this.URL}/dao/spi/cuentas_ingresos_dao.php`, distribution, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => {
+            if (res.success) {
+                res.data = new MCuentaIngresos(res.data);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @Actualiza la distribución de la cuenta de Ingreso de Estructura
+     * @param distribution
+     */
+    updateDistributionIncomeStructureAccount(distribution, level) {
+        return this.http.put(`${this.URL}/dao/spi/cuenta_estructura_ingresos_dao.php`, distribution, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => {
+            if (res.success) {
+                res.data = new MIncomeStructureAccount(res.data, level);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene las cuentas por nivel de las cuenats de egresos
+     * @param level Número de niveles de la configuración
+     * @param id id del nivel 3 o 5 que se va a buscar
+     * @return Observable<MCuentaEgresos[]>
+     */
+    getExpenseAccountsForLevel(level, id) {
+        return this.http.get(`${this.URL}/dao/spg/cuentas_egresos_dao.php?level=${level}&id=${id}`, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => res.data.map(element => new MCuentaEgresos(element))));
+    }
+    /**
+     * @description Abre el catálogo de estructura presupuesaria
+     * @param data Data que se va a mostrar
+     * @param configuration Configuración de la estructura
+     * @return Promise<any>
+     * @author Miguel Ramírez
+     */
+    openCatalogoEstructuraPresupuestaria(data, configuration) {
+        const catalogo = this.dialog.open(CatalogoEstructurasComponent, {
+            data: {
+                data,
+                configuration
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return catalogo.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las cuentas de egresos
+     * @param onlyAvailable
+     * @return Observable<MCuentaEgresos[]>
+     */
+    getExpenseAccounts(onlyAvailable = false) {
+        return this.http.get(`${this.URL}/dao/spg/cuentas_egresos_dao.php${onlyAvailable ? '?available=true' : ''}`, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => res.data.map(element => new MCuentaEgresos(element))));
+    }
+    /**
+     * @description Obtiene todas las estructuras presupuetsarias de las 5 tablas
+     * @return Promise<MAllStructure>
+     * @author Miguel Ramírez
+     */
+    getAllBudgetStructure() {
+        return new Promise((resolve, reject) => {
+            this.getBudgetStructureOne().subscribe(structureOne => {
+                this.getBudgetStructureTwoAll().subscribe(structureTwo => {
+                    this.getBudgetStructureThree().subscribe(structureThree => {
+                        this.getBudgetStructureFour().subscribe(structureFour => {
+                            this.getBudgetStructureFiveByIdEp4().subscribe(structureFive => {
+                                resolve(new MAllStructure({
+                                    structureOne,
+                                    structureTwo,
+                                    structureThree,
+                                    structureFour,
+                                    structureFive
+                                }));
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    }
+    /**
+     * @description Obtiene la estructura completa dependiendo de la configuración
+     * @return Promise<any[]>
+     * @author Miguel Ramírez
+     * @type= {}
+     */
+    async getBudgetStructureComplete(nivel, tipo) {
+        return new Promise(async (resolve) => {
+            let data = [];
+            await this.getBudgetStructureFive(nivel, tipo).subscribe(result => {
+                data.push(...result);
+            });
+            // await this.getBudgetStructureThreeComplete(3).subscribe(result => {
+            //   data.push(...result)
+            // })
+            await resolve(data);
+        });
+    }
+    /**
+     * @description Elimina una o varias estructuras presupuestarias
+     * @param idStructures Id de las estructuras presupuestarias 5 que van a ser eliminadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    deleteBudgetStructureFive(idStructures) {
+        return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`, { body: idStructures, headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Actualiza una o varias estructuras 4
+     * @param structures Estructuras presupuestarias que van a ser actualizadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    updateBudgetStructureFive(structures) {
+        return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Agrega una o varias estructuras presupuestarias 4
+     * @param structures Las estructuras que van a ser registradas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    setBudgetStructureFive(structures) {
+        return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene toda la estructura presupuestaria 5
+     * @return Observable<MEstructuraPresupuestariaFive[]>
+     * @author Miguel Ramírez
+     * @params tipo:"sss"
+     */
+    getBudgetStructureFive(level = null, tipo = '') {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php?complete=true&tipo=${tipo}`, { headers: this.getHttpHeaders() }).pipe(map((resp) => resp.data.map(e => new MEstructuraPresupuestariaFiveComplete(e, level))));
+    }
+    /**
+     * @description Obtiene la estructura presupuestaria 5 por el Id de la estructura 4
+     * @param idEp4 id de la estructura presupuestaria 4
+     */
+    getBudgetStructureFiveByIdEp4(idEp4) {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php${idEp4 ? `?id_ep4=${idEp4}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MEstructuraPresupuestariaFive(element))));
+    }
+    /**
+     * @description Elimina una o varias estructuras presupuestarias
+     * @param idStructures Id de las estructuras presupuestarias 3 que vana  ser eliminadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    deleteBudgetStructureFour(idStructures) {
+        return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`, { body: idStructures, headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Actualiza una o varias estructuras 4
+     * @param structures Estructuras presupuestarias que van a ser actualizadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    updateBudgetStructureFour(structures) {
+        return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Agrega una o varias estructuras presupuestarias 4
+     * @param structures Las estructuras que van a ser registradas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    setBudgetStructureFour(structures) {
+        return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene las estructuras presupuestarias 4
+     * @param idEp3 Id de la estructura presupuestaria 3
+     * @return Observable<MEstructurapresupuestaria[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureFour(idEp3) {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria4_dao.php${idEp3 ? `?id_ep3=${idEp3}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MEstructuraPresupuestariaFour(element))));
+    }
+    /**
+     * @description Elimina una o varias estructuras presupuestarias
+     * @param idStructures Id de las estructuras presupuestarias 3 que vana  ser eliminadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    deleteBudgetStructureThree(idStructures) {
+        return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`, { body: idStructures, headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Actualiza una o varias estructuras 3
+     * @param structures Estructuras presupuestarias que van a ser actualizadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    updateBudgetStructureThree(structures) {
+        return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Agrega una o varias estructuras presupuestarias 3
+     * @param structures Las estructuras que van a ser registradas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    setBudgetStructureThree(structures) {
+        return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`, structures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Se trae la estructura presupuestaria completa hasta el nivel 3
+     * @return Observable<any[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureThreeComplete(level) {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php?complete=true`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MEstructuraPresupuestariaFiveComplete(element, level))));
+    }
+    /**
+     * @description Obtiene las estructuras presupuestarias 3
+     * @param idEp2 Id de la estructura presupuestaria 2
+     * @return Observable<MEstructurapresupuestaria[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureThree(idEp2) {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php${idEp2 ? `?id_ep2=${idEp2}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MEstructuraPresupuestariaThree(element))));
+    }
+    /**
+     * @description Elimina una o varias estructuras presupuestarias uno
+     * @param idStructures Id de la o las estructuras presupuestarias que van a ser eliminadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    deleteBudgetStructureTwo(idStructures) {
+        return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`, { body: idStructures, headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Actualiza una estructura presupuestaria dos
+     * @param structure Estructura presupuestaria uno que se va a actualizar
+     * @return Observable<any>
+     */
+    updateBudgetStructureTwo(structure) {
+        return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`, structure, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Registra las estructuras presupuestrias dos en la base de datos
+     * @param budgetStructures Array de estructuras presupuestaria que se van a registrar
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    setBudgetStructureTwo(budgetStructures) {
+        return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`, budgetStructures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene la estructura presupuestaria
+     * @return Observable<MEstructuraPresupuestaria[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureTwo(idEp1) {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php?id_ep1=${idEp1}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map(((resp) => resp.data.map(element => new MEstructuraPresupuestariaTwo(element)))));
+    }
+    /**
+     * @description Obtiene la estructura presupuestaria
+     * @return Observable<MEstructuraPresupuestaria[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureTwoAll() {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map(((resp) => resp.data.map(element => new MEstructuraPresupuestariaTwo(element)))));
+    }
+    /**
+     * @description Elimina una o varias estructuras presupuestarias uno
+     * @param idStructures Id de la o las estructuras presupuestarias que van a ser eliminadas
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    deleteBudgetStructureOne(idStructures) {
+        return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`, { body: idStructures, headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Actualiza una estructura presupuestaria uno
+     * @param structure Estructura presupuestaria uno que se va a actualizar
+     * @return Observable<any>
+     */
+    updateBudgetStructureOne(structure) {
+        return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`, structure, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Registra las estructuras presupuestrias en la base de datos
+     * @param budgetStructures Array de estructuras presupuestaria que s evan a registrar
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    setBudgetStructureOne(budgetStructures) {
+        return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`, budgetStructures, { headers: this.getHttpHeaders() });
+    }
+    /**
+     * @description Obtiene la estructura presupuestaria
+     * @return Observable<MEstructuraPresupuestaria[]>
+     * @author Miguel Ramírez
+     */
+    getBudgetStructureOne() {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map(((resp) => resp.data.map(element => new MEstructuraPresupuestariaOne(element)))));
+    }
+    /**
+     * @description Obtiene las configuraciones de la estructura presupuestaria
+     * @return Observable<MConfigurationSPG[]>
+     * @author Miguel Ramírez
+     */
+    getConfigurationSPG() {
+        return this.http.get(`${this.URL}/dao/spg/estructura_presupuestaria_config_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => new MConfigurationSPG(resp.data[0])));
+    }
+    /**
+     * @description Obtiene las configuraciones de los proveedores
+     * @return Observable<MConfigurationRPC[]>
+     * @author Carlos Albornoz
+     */
+    getConfigurationRPC() {
+        return this.http.get(`${this.URL}/dao/rpc/proveedor_config_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => {
+            if (resp.success) {
+                resp.data = new MConfigurationRPC(resp.data);
+            }
+            return resp;
+        }));
+    }
+    /**
+     * @description Obtiene las MConfiguracionSNO de la nomina
+     * @return Observable<MConfiguracionSNO[]>
+     * @date 27-07-2021
+     */
+    getConfigurationSNO() {
+        return this.http.get(`${this.URL}/dao/sno/configuracion_dao.php?tipo=${'configuracion'}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => {
+            if (resp.success) {
+                if (resp.data != null) {
+                    resp.data = resp.data.map(e => new MConfiguracionSNO(e));
+                }
+                else {
+                    resp.data = [];
+                }
+            }
+            return resp;
+        }));
+    }
+    dateToString(date) {
+        return `${date.getFullYear()}-${date.getMonth() + 1 >= 10 ? date.getMonth() + 1 : `0${date.getMonth() + 1}`}-${date.getDate() >= 10 ? date.getDate() : `0${date.getDate()}`}`;
+    }
+    /**
+     * @description Obtiene las configuraciones de Seguridad
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getConfigSSS() {
+        return this.http.get(`${this.URL}/dao/sss/seguridad_config_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => {
+            if (resp.success) {
+                resp.data = new MConfigSSS(resp.data);
+            }
+            return resp;
+        }));
+    }
+    getComponents(systemCode = null, permit) {
+        return this.http.get(`${this.URL}/dao/sss/componentes_dao.php?${systemCode ? `codsis=${systemCode}${permit ? `&permit=true` : ''}` : ''}`, { headers: this.getHttpHeaders() }).pipe(map(res => {
+            if (res.success) {
+                res.data = res.data.map(e => new MComponent(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene las fuentes de financiamiento
+     * @return Observable<MFuenteFinanciamiento[]>
+     * @author Miguel Ramírez
+     */
+    getFuenteFinanciamiento() {
+        return this.http.get(`${this.URL}/dao/spg/fuente_financiamiento_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MFuenteFinanciamiento(element))));
+    }
+    /**
+     * @description Obtiene los centros de costo
+     * @return Observable<MCentroCosto[]>
+     * @author Miguel Ramírez
+     * @param id:idusurio o id del ecntro de costo
+     * modificado 28-12-2022
+     */
+    getCentroCosto(tipo = null, id) {
+        return this.http.get(`${this.URL}/dao/scg/centro_costo_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MCentroCosto(element))));
+    }
+    /**
+     * @description Obtiene los centros de costo
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getCostCenters() {
+        return this.http.get(`${this.URL}/dao/scg/centro_costo_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(element => new MCentroCosto(element));
+            }
+            return res;
+        }));
+    }
+    getUserCostCenters(codigo) {
+        return this.http.get(`${this.URL}/dao/scg/centro_costo_usuario_dao.php?codigo=${codigo}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(element => new MUsuarioCentroCosto(element));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Abre el dialog de checkks
+     * @param columns Columnas que va a tener la tabla
+     * @param title Título de la modal
+     * @param dataSource Data que s eva a mostrar en la tabla
+     */
+    openDialogMultiSelect(
+    // columns: string[], 
+    // title: string, 
+    // dataSource: any[],
+    // columnNames?: string[]
+    columns, title, dataSource, columnNames = null, width = '450px', options = {
+        disableClose: false,
+        hasBackdrop: false,
+        //  disableMasterToggle: false
+    }) {
+        let dialogRef = this.dialog.open(TableSelectComponent, {
+            data: {
+                title: title,
+                columns: columns,
+                dataSource: dataSource,
+                columnNames,
+                // disableMasterToggle: options.disableMasterToggle
+            },
+            width: width,
+            maxHeight: '90vh',
+            hasBackdrop: options.hasBackdrop,
+            disableClose: options.disableClose
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Abre el dialog de las comunidades
+     * @return Promise<MPlanUnicoCuenta>
+     * @author Miguel Ramírez
+     */
+    async openDialogPlanUnicoCuentas() {
+        let planes = await this.getListadoPLanUnicoCuentas().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['cuenta', 'denominacion'],
+                columnNames: ['cuenta', 'denominación'],
+                title: 'Catálogo de Plan de Cuentas Géneral',
+                dataSource: planes
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene el listado del plan único de cuentas
+     * @return Observable<MplanUnicoCuenta[]>
+     * @author Miguel Ramírez
+     */
+    getListadoPLanUnicoCuentas() {
+        return this.http.get(`${this.URL}/dao/scg/plan_unico_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MPlanUnicoCuenta(element))));
+    }
+    /**
+     * @description Obtiene la configuración de SCG
+     * @return Observable<MConfiguracionSCG[]>
+     * @author Miguel Ramírez
+     * @modifit 25-07-2021
+     */
+    getConfigurationSCG() {
+        return this.http.get(`${this.URL}/dao/scg/configuracion_contabilidad_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MConfiguracionSCG(element))));
+    }
+    /**
+     * @description Abre un dialog de confirmación
+     * @param title Título de la modal de confirm
+     * @param message Mensaje (opcional) para el ususario
+     * @return Promise<boolean>
+     * @author Miguel Ramírez
+     */
+    openDialogConfirm(title, message) {
+        let dialogRef = this.dialog.open(ConfirmComponent, {
+            data: {
+                title: title,
+                message: (message) ? message : null
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Convierte el contenido de un AbstractControl en mayúscula (Usar en evento keyup)
+     * @param formGroup Formulario dónde se va a buscar el AbstractControl
+     * @param name Nombre del AbstractControl
+     * @return void
+     * @author Miguel Ramírez
+     */
+    changeToUpperCase(formGroup, name) {
+        this.getAbstractControl(formGroup, name).setValue(this.getAbstractControl(formGroup, name).value.toUpperCase());
+    }
+    /**
+     * @description Obtiene el AbstractControl de un formulario
+     * @param formGroup Formulario donde se va a buscar el AbstractControl
+     * @param name Nombre del AbstractControl
+     * @return AbstractControl
+     * @author Miguel Ramírez
+     */
+    getAbstractControl(formGroup, name) {
+        return formGroup.get(name);
+    }
+    /**
+     * @description Previene que se escriban letras en el input (Usar en keypress)
+     * @param event Evento del teclado
+     * @return boolean
+     * @author Miguel Ramírez
+     * @modificado como onlyNumero para corregir codigo, usar currency-input si quiere usar decimales
+     */
+    onlyDecimal(event) {
+        if (!isNaN(+event.key) && event.keyCode != 32) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @description Previene que se escriban letras en el input (Usar en keypress)
+     * @param event Evento del teclado
+     * @return boolean
+     * @author Miguel Ramírez
+     */
+    onlyNumbers(event) {
+        // console.log(event);
+        if (!isNaN(+event.key) && event.keyCode != 32) {
+            return true;
+        }
+        return false;
+    }
+    /**
+    * @description Acepta solo numero, delete y backspace
+    * @param event Evento del teclado
+    * @return boolean
+    * @author Dimaly Crespo
+    */
+    onlyNumbers2(event) {
+        if (!isNaN(+event.key) || event.keyCode == 8 || event.keyCode == 46) {
+            return true;
+        }
+        return false;
+    }
+    /**
+    * @description Acepta solo numero,guiones, parentesis,espacios
+    * @param event Evento del teclado
+    * @return boolean
+    * @author Dimaly Crespo
+    */
+    typeNumbersHyphen(event) {
+        if (!isNaN(+event.key) || event.keyCode == 8 || event.keyCode == 32 || event.keyCode == 46
+            || event.keyCode == 58 || event.keyCode == 57 || event.keyCode == 189) {
+            return true;
+        }
+        return false;
+    }
+    /**
+    * @description Permite (a-z A-Z á-ú ñÑ üÜ ',.) que se escriban numeros en el input (Usar en keypress)
+    * @param event Evento del teclado
+    * @return boolean
+    * @date 14-05-2022
+    *
+    */
+    typeName(event) {
+        if ((event.key >= 'a' && event.key <= 'z') || (event.key >= 'A' && event.key <= 'Z') || event.key == "ñ" || event.key == "Ñ"
+            || (event.key >= 'á' && event.key <= 'ú') || event.key >= 'ü' || event.key >= 'Ü' || event.key == "'" || event.keyCode == 32
+            || event.key == "." || event.key == "," || event.keyCode == 8 || event.keyCode == 32 || event.keyCode == 46) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @description Permite (0-9 a-z A-Z á-ú ñÑ üÜ ',.-_/:()%#º&$€£¥) que se escriban  en el input (Usar en keypress)
+     * @param event Evento del teclado
+     * @return boolean
+     * @date 14-05-2022
+     *
+     */
+    typeText(event) {
+        if ((event.key >= 'a' && event.key <= 'z') || (event.key >= 'A' && event.key <= 'Z') || event.key == "ñ" || event.key == "Ñ"
+            || (event.key >= 'á' && event.key <= 'ú') || event.key == 'ü' || event.key == 'Ü' || event.key == "'" || isNaN(+event.key)
+            || event.key == "." || event.key == "," || event.key == "&" || event.key == "_" || event.key == "-" || event.key == "#"
+            || event.key == "º" || event.key == "$" || event.key == "(" || event.key == ")" || event.key == "%" || event.key == ' '
+            || event.key == ':' || event.key == '/' || event.keyCode == 8364 || event.keyCode == 165 || event.keyCode == 163
+            || event.keyCode == 8 || event.keyCode == 32 || event.keyCode == 46) {
+            return true;
+        }
+        return false;
+    }
+    /**
+   * @description Permite (0-9 a-z A-Z ñÑ .-_) que se escriban  en el input (Usar en keypress)
+   * @param event Evento del teclado
+   * @return boolean
+   * @date 14-05-2022
+   */
+    typeCode(event) {
+        if ((event.key >= 'a' && event.key <= 'z') || (event.key >= 'A' && event.key <= 'Z') || event.key == "ñ" || event.key == "Ñ"
+            || isNaN(+event.key) || event.key == "." || event.key == "_" || event.key == "-" || event.keyCode == 8 || event.keyCode == 32 || event.keyCode == 46) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @description Abre el dialog de las comunidades
+     * @return Promise<MComunidad>
+     * @author Miguel Ramírez
+     */
+    async openDialogUnidadesTributarias() {
+        let udTributarias = await this.getUnidadesTributarias().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['año', 'nro_decreto', 'fecha_decreto', 'entrada_videncia', 'publicacion_gaceta', 'nro_gaceta', 'valorut'],
+                title: 'Catálogo de Unidades Tributarias',
+                dataSource: udTributarias
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las unidades tributarias
+     * @return Observable<any>
+     * @author Miguel Ramírez
+     */
+    getUnidadesTributarias() {
+        const request = {
+            operacion: 'obtenerData',
+            sigesp_conexion: {
+                servidor: this.URL,
+                usuario: this.usuarioActivo.getInterface()
+            }
+        };
+        return this.http.post(`${this.URL}/dao/cfg/undtributaria_dao.php`, request).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.map(element => new MUnidadTributaria(element))));
+    }
+    /**
+     * @description Abre una modal génerica
+     * @param columns Columnas que va a tener la tabla
+     * @param title Título del dialog
+     * @param dataSource Data que se va a mostrar en la tabla
+     * @return Promise<any>
+     * @author Miguel Ramírez
+     */
+    async openCatalogoGenerico(columns, title, dataSource, columnNames = null, width = '450px', options = { disableClose: false, hasBackdrop: false }) {
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns,
+                title,
+                dataSource,
+                columnNames
+            },
+            width: width,
+            maxHeight: '90vh',
+            hasBackdrop: options.hasBackdrop ? options.hasBackdrop : false,
+            disableClose: options.disableClose ? options.disableClose : false,
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Abre una modal génerica con 2 inputs
+     * @param columns Columnas que va a tener la tabla
+     * @param title Título del dialog
+     * @param dataSource Data que se va a mostrar en la tabla
+     * @return Promise<any>
+     * @author Carlos Albornoz
+     */
+    async openCatalogoDosInputs(columns, title, dataSource, filterData, columnNames = null, width = "450px") {
+        let dialogRef = this.dialog.open(CatalogoDobleInputComponent, {
+            data: {
+                columns,
+                title,
+                dataSource,
+                columnNames,
+                filterData
+            },
+            width: width,
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Abre el dialog de las comunidades
+     * @return Promise<MComunidad>
+     * @author Miguel Ramírez
+     */
+    async openDialogComunidad() {
+        let comunidades = await this.getComunidades().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['prefijo', 'pais', 'estado', 'municipio', 'parroquia', 'codigo', 'comunidad'],
+                title: 'Catálogo de Comunidades',
+                dataSource: comunidades
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las comunidades
+     * @return Observable<MComunidad[]>
+     * @author Miguel Ramírez
+     */
+    getComunidades() {
+        const request = {
+            operacion: 'obtenerData',
+            sigesp_conexion: {
+                servidor: this.URL,
+                usuario: this.usuarioActivo.getInterface()
+            }
+        };
+        return this.http.post(`${this.URL}/dao/cfg/comunidades_dao.php`, request).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.map(element => new MComunidad(element))));
+    }
+    /**
+     * @description Abre el dialog de las las monedas
+     * @return Promise<MMoneda>
+     * @author Miguel Ramírez
+     */
+    async openDialogMonedas() {
+        let coins = await this.getMonedas('todas').toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['codigo', 'denominacion', 'codigoIso', 'simbolo'],
+                title: 'Catálogo de Monedas',
+                columnNames: ['código', 'denominación', 'iso', 'simbolo'],
+                dataSource: coins
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las monedas
+     * @return Observable<MMoneda[]>
+     * @author Miguel Ramírez
+     * actualizado 4-12-2022
+     * @param tipo :string {'todas','uno','actual}
+     * @param id : number
+     * @returns
+     */
+    getMonedas(tipo, id) {
+        return this.http.get(`${this.URL}/dao/cfg/moneda_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MMoneda(element))));
+    }
+    /**
+     * @Description: Obtiene la tasa de cambio asociadas a uno o varias monedas
+     * @param tipo string
+     * @param id codigo moneda
+     * @returns array/null
+     * @tipo:all->todas, (moneda->una moneda id->id de moneda)
+     */
+    getCurrencyExchangeRate(tipo = null, id) {
+        return this.http.get(`${this.URL}/dao/cfg/tasa_cambio_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MExchangeRate(element))));
+    }
+    /**
+     * @description Abre el dialog de las las cuentas contables (Cuentas Institucionales)
+     * @return Promise<McuentaInstitucional>
+     * @author Miguel Ramírez
+     */
+    async openDialogCuentasInstitucionales() {
+        let accounts = await this.getCuentasInstitucionales().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['cuenta', 'denominacion'],
+                columnNames: ['cuenta', 'denominación'],
+                title: 'Catálogo de plan de cuenta institucional',
+                dataSource: accounts
+            },
+            width: '800px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las cuentas contables (Cuentas Institucionales)
+     * @return Observable<MCuentaInstitucional[]>
+     * @author Miguel Ramírez
+     */
+    getCuentasInstitucionales(inventory) {
+        return this.http.get(`${this.URL}/dao/scg/cuentas_dao.php${(inventory) ? '?inventory=true' : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((resp) => resp.data.map(element => new MCuentaInstitucional(element))));
+    }
+    /**
+     * @description Abre el dialog de las cuentas de presupuesto (Recursos y Egresos)
+     * @return Promise<MCuentaPresupuesto>
+     * @author Miguel Ramírez
+     */
+    async openDialogCuentasPresupuesto() {
+        let accounts = await this.getCuentasPresupuesto().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columnNames: ['cuenta', 'denominación'],
+                columns: ['cuenta', 'denominacion'],
+                title: 'Catálogo de Cuentas de Presupuesto',
+                dataSource: accounts
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene las cuentas de recursos y egresos
+     * @return Observable<MCuentaPresupuesto>
+     * @author Miguel Ramírez
+     */
+    getCuentasPresupuesto(filter) {
+        return this.http.get(`${this.URL}/dao/scg/plan_unico_cuentas_dao.php?filter=${filter}`, { headers: this.getHttpHeaders() }).pipe(map((res) => res.data.map(element => new MCuentaPresupuesto(element))));
+    }
+    /**
+     * @description Abre el cátalogo de cuentas de la tabla "scg_plan_unico_re"
+     * @returns Promise<MCuentaPresupuesto>
+     * @author Carlos Albornoz
+     * @params filtro: Indica bajo que parametros se va a filtrar el catalogo
+     */
+    async openCatalogoCuentasPresuspuesto(titulo, filtro = null, ancho = '750px') {
+        let cuentas = [];
+        await this.getCuentasPresupuesto().toPromise().then((res) => {
+            cuentas = res;
+            if (filtro) {
+                if (filtro.estado) {
+                    cuentas = cuentas.filter(c => {
+                        return c.status == filtro.estado;
+                    });
+                }
+                if (filtro.tipo) {
+                    cuentas = cuentas.filter(c => {
+                        return c.tipo == filtro.tipo;
+                    });
+                }
+            }
+            cuentas = cuentas.map(e => {
+                e['provStatus'] = e.status == "C" ? "Movimientos" : "Totalizadora";
+                e['provType'] = e.status == "R" ? "Recursos" : "Ingresos";
+                return e;
+            });
+        });
+        return this.openCatalogoGenerico(["cuenta", "denominacion", "provStatus", "provType"], titulo, cuentas, ["Cuenta", "Denominación", "Estado", "Tipo"], ancho);
+    }
+    /**
+     * @description Abre el cátalogo de cuentas de la tabla "spg_cuentas"
+     * @returns Promise<MCuentaEgresos>
+     * @author Carlos Albornoz
+     * @params presupuesto: Indica si se a trabajar con estructura de presupuesto o no
+     */
+    async openCatalogoCuentasEgreso(titulo, presupuesto = true, ancho = "750px") {
+        let cuentas = [];
+        await this.getExpenseAccounts().toPromise().then(res => {
+            cuentas = res;
+            cuentas = cuentas.filter(e => {
+                return e.status == "C";
+            }).map(e => {
+                e['provStatus'] = e.status == "C" ? "Movimientos" : "Totalizadora";
+                return e;
+            });
+        });
+        if (presupuesto) {
+            return this.openCatalogoDosInputs(["cuenta", "denominacion", "estructura", "provStatus"], titulo, cuentas, [{
+                    placeholder: "Cuenta",
+                    property: "cuenta"
+                }, {
+                    placeholder: "Estructura",
+                    property: "estructura"
+                }], ["Cuenta", "Denominación", "Estructura", "Estado"], ancho);
+        }
+        else {
+            let filteredAccounts = [];
+            cuentas.forEach(c => {
+                if (!filteredAccounts.find(e => e.cuenta == c.cuenta)) {
+                    filteredAccounts.push(c);
+                }
+            });
+            return this.openCatalogoGenerico(["cuenta", "denominacion", "provStatus"], titulo, filteredAccounts, ["Cuenta", "Denominación", "Estado"], ancho);
+        }
+    }
+    /**
+     * @description Abre el cátalogo de cuentas de la tabla "spi_cuentas"
+     * @returns Promise<MCuentaIngresos>
+     * @author Carlos Albornoz
+     * @params presupuesto: Indica si se a trabajar con estructura de presupuesto o no
+     */
+    async openCatalogoCuentasIngreso(titulo, presupuesto = true, ancho = "750px") {
+        let cuentas = [];
+        await this.getIncomeAccounts().toPromise().then((res) => {
+            cuentas = res.data;
+            cuentas = cuentas.filter(e => {
+                return e.estado == "C";
+            }).map(e => {
+                e['provStatus'] = e.estado == "C" ? "Movimientos" : "Totalizadora";
+                return e;
+            });
+        });
+        if (presupuesto) {
+            return this.openCatalogoDosInputs(["cuenta", "denominacion", "estructura", "provStatus"], titulo, cuentas, [{
+                    placeholder: "Cuenta",
+                    property: "cuenta"
+                }, {
+                    placeholder: "Estructura",
+                    property: "estructura"
+                }], ["Cuenta", "Denominación", "Estructura", "Estado"], ancho);
+        }
+        else {
+            let filteredAccounts = [];
+            cuentas.forEach(c => {
+                if (!filteredAccounts.find(e => e.cuenta == c.cuenta)) {
+                    filteredAccounts.push(c);
+                }
+            });
+            return this.openCatalogoGenerico(["cuenta", "denominacion", "provStatus"], titulo, filteredAccounts, ["Cuenta", "Denominación", "Estado"], ancho);
+        }
+    }
+    getUnidadAdministrativa(tipo) {
+        return this.http.get(`${this.URL}/dao/spg/unidad_administrativa_dao.php?tipo=${tipo}`, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MAdministrativeUnit(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los cargos de servicios
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getServiceCharges(serviceId = null) {
+        return this.http.get(`${this.URL}/dao/soc/servicio_cargo_dao.php${serviceId ? `?service_id=${serviceId}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MServiceCharge(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene los paises
+    * @return Observable<MCountry>
+    * @author Carlos Albornoz
+    * @modified 10-01-2022
+    * @param codigo: Codigo del pais
+
+    */
+    getCountries(codigo) {
+        return this.http.get(`${this.URL}/dao/cfg/paises_dao.php?codigo=${codigo}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MCountry(e))));
+    }
+    /**
+     * @description Obtiene los estados
+     * @return Observable<MState>
+     * @author Carlos Albornoz
+     * @modificado 4-12-2022
+     * @param codigo: Codigo del pais
+     */
+    getStates(codigo) {
+        return this.http.get(`${this.URL}/dao/cfg/estados_dao.php?codigo=${codigo}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MState(e))));
+    }
+    /**
+     * @description Obtiene los municipios
+     * @return Observable<MMunicipality>
+     * @author Carlos Albornoz
+     * @modificado 10-01-2022
+     * @param pais: Codigo del pais ,
+     * @param estado: Codigo del estado
+     * @actualizado 4-12-2022
+     */
+    getMunicipalities(pais, estado) {
+        return this.http.get(`${this.URL}/dao/cfg/municipios_dao.php?pais=${pais}&estado=${estado}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MMunicipality(e))));
+    }
+    /**
+     * @description Obtiene las parroquias
+     * @return Observable<MParish>
+     * @author Carlos Albornoz
+     * @modificado 10-01-2022
+     * @param pais: Codigo del pais
+     * @param estado: Codigo del estado
+     * @param municipio:codigo Municipio
+     * @actualizado 4-12-2022
+
+     */
+    getParishes(pais, estado, municipio) {
+        return this.http.get(`${this.URL}/dao/cfg/parroquias_dao.php?pais=${pais}&estado=${estado}&municipio=${municipio}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MParish(e))));
+    }
+    /**
+     * @description Obtiene las ciudades
+     * @return Observable<MParish>
+     * @author Carlos Albornoz
+     * @modificado 10-01-2022
+     * @param pais: Codigo del pais
+     * @param estado: Codigo del estado
+
+
+     */
+    getCity(pais, estado) {
+        return this.http.get(`${this.URL}/dao/cfg/ciudades_dao.php?pais=${pais}&estado=${estado}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MCity(e))));
+    }
+    /**
+* @description Obtiene las ciudades
+* @return Observable<MParish>
+* @author Dimaly Crespo
+* @modificado 10-01-2022
+* @param pais: Codigo del pais
+
+*/
+    getCommunities(pais, estado, municipio, parroquia) {
+        return this.http.get(`${this.URL}/dao/cfg/comunidades_dao.php?pais=${pais}&estado=${estado}&municipio=${municipio}&parroquia=${parroquia}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MCommunity(e))));
+    }
+    /**
+     * @description Obtiene los sistemas activas
+     * @return Observable<MSistema>
+     * @author Carlos Albornoz
+     */
+    getSistemas() {
+        return this.http.get(`${this.URL}/dao/sss/sistemas_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => res.data.map(e => new MSistema(e))));
+    }
+    /**
+     * @description Obtiene la moneda actual
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     * @actualizado: 4-12-20222
+     * @params id: id de la moneda,
+     * @params tipo: todas->obtiene todas las moneda, (uno-> obtiene una moneda + id)
+     * (mon:formato para inputCurrency + id )
+     */
+    getCurrentCurrency(tipo = null, id) {
+        return this.http.get(`${this.URL}/dao/cfg/moneda_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = new MMonedaConfig(res.data);
+            }
+            return res;
+        }));
+    }
+    /**
+ * @description Obtiene la linea empresa
+ * @return Observable<IResponse>
+ * @author Dimaly Crespo
+ * @actualizado: 5-12-20222
+ */
+    getEnterprise(tipo = null, id) {
+        return this.http.get(`${this.URL}/dao/cfg/enterprise_dao.php?tipo=${tipo}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MEnterprise(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los tipos de organizacion
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getOrganizationTypes() {
+        return this.http.get(`${this.URL}/dao/rpc/tipo_organizacion_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MOrganizationType(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los tipos de organizacion
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getSpecialties() {
+        return this.http.get(`${this.URL}/dao/rpc/especialidad_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MSpecialty(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los documentos
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getDocuments() {
+        return this.http.get(`${this.URL}/dao/rpc/documento_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MDocument(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene las clasificaciones
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getClasifications() {
+        return this.http.get(`${this.URL}/dao/rpc/clasificacion_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MClasification(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene el prefijo de los usuarios
+     * @param procede De que módulo procede
+     * @param codsis Código del sistema
+     * @return Observable<MUsuarioPrefijo[]>
+     * @author Carlos Albornoz
+     */
+    getUserPrefix(filter = null, code = null) {
+        return this.http.get(`${this.URL}/dao/cfg/control_numero_dao.php${filter ? `?filter=${filter}&code=${code}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MUsuarioPrefijo(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los pefijo
+     * @param procede De que módulo procede
+     * @param codsis Código del sistema
+     * @return Observable<MUsuarioPrefijo[]>
+     * @author DimalyCrespo 17-12-2022
+     */
+    getPrefix(filter = null, code = null) {
+        return this.http.get(`${this.URL}/dao/cfg/control_numero_dao.php${filter ? `?filter=${filter}&code=${code}` : ''}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MPrefijo(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Abre el dialog para buscar los proveedores
+     * @return Promise<MProveedor>
+     * @author Miguel Ramírez
+     */
+    async openDialogProveedores() {
+        let proveedores = await this.getProveedores().toPromise();
+        let dialogRef = this.dialog.open(CatalogoComponent, {
+            data: {
+                columns: ['tipo', 'rif', 'nombre'],
+                title: 'Catálogo de Proveedores y Beneficiarios',
+                dataSource: proveedores
+            },
+            width: '450px',
+            maxHeight: '90vh'
+        });
+        return dialogRef.afterClosed().toPromise();
+    }
+    /**
+     * @description Obtiene los proveedores
+     * @return Observable<MProveedor[]>
+     * @author Miguel Ramírez
+     */
+    getProveedores() {
+        let request = {
+            operacion: 'obtenerData',
+            sigesp_conexion: {
+                servidor: this.URL,
+                usuario: this.usuarioActivo.getInterface()
+            }
+        };
+        return this.http.post(`${this.URL}/dao/rpc/proveedor_beneficiario_dao.php`, request).pipe(retry(3), catchError(this.handlerError), map((res) => res.map(element => new MProveedor(element))));
+    }
+    /**
+     * @description Obtiene los proveedores y beneficiarios
+     * @Note Si quiere solo los datos basicos use los parametros ('S','P','N')
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     * @type ={'P','B','S'}
+     * @destination ={'P','B','C','A','N'}≈{Proveedor,Beneficiario,Contatista,Ambos,Ninguno}
+     * @account ={'S','N'} para traer las cuentas bancarias del proveedor por defecto esta en N
+     * @modificado 17-07-2023
+     */
+    getProvidersAndBeneficiaries(type = 'default', destination = null, account = 'N') {
+        return this.http.get(`${this.URL}/dao/rpc/proveedor_beneficiario_dao.php${type ? `?provider_type=${type}` : ''}&destination=${destination}&account=${account}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MProviderBeneficiary(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene un Usuario segun su ID
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getUserById(id) {
+        return this.http.get(`${this.URL}/dao/sss/usuario_dao.php?id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = new MUsuario(res.data);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los bancos
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getBanks(idEnterprise) {
+        return this.http.get(`${this.URL}/dao/scb/banco_dao.php?e=${idEnterprise}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MBank(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los tipos de cuenta bancarias
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getBankAccountTypes() {
+        return this.http.get(`${this.URL}/dao/scb/banco_tipo_cuenta_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MBankAccountType(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description obtiene las cuenta segun el id
+     * @param tipo {'banco', 'default'}
+     * @param id para la opcion banco usar id=idBanco, opcion defaulf id=idEnterprise
+     * @returns
+     */
+    getAllBankAccount(tipo, id) {
+        return this.http.get(`${this.URL}/dao/scb/cuenta_banco_dao.php?tipo=${tipo}&e=${id}`, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(element => new MCuentaBanco(element));
+            }
+            else {
+                res.data = [];
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los bancos sigecof
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getSigecofBanks() {
+        return this.http.get(`${this.URL}/dao/sigesp/banco_sigecof_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MSigecofBank(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene la configuracion de SOC
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getConfigSOC() {
+        return this.http.get(`${this.URL}/dao/soc/configuracion_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = new MConfigSOC(res.data);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los tipos de deduccion
+     * @return Observable<IResponse>
+     * @author Carlos Albornoz
+     */
+    getDeductionTypes() {
+        return this.http.get(`${this.URL}/dao/stb/tipo_deduccion_dao.php`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MDeductionType(e));
+            }
+            return res;
+        }));
+    }
+    getIncomeAccounts(onlyAvailable = false) {
+        return this.http.get(`${this.URL}/dao/spi/cuentas_ingresos_dao.php${onlyAvailable ? '?available=true' : ''}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MCuentaIngresos(e));
+            }
+            return res;
+        }));
+    }
+    getCharges() {
+        return this.http.get(`${this.URL}/dao/stb/cargos_dao.php`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MCargo(e));
+            }
+            return res;
+        }));
+    }
+    getDeductions() {
+        return this.http.get(`${this.URL}/dao/stb/deducciones_dao.php`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MDeduction(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene la los datos de Empresa
+     * @return Observable<IResponse>
+     * @author Dimaly Crespo
+     *
+     */
+    getCompany(tipo, id) {
+        return this.http.get(`${this.URL}/dao/cfg/empresas_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MEmpresa(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene los tipos de documentos registrados en CXP
+    * @return Observable<IResponse>
+    * @author Dimaly Crespo
+    * @date 20-07-2021
+    */
+    getTiposDocumetos() {
+        return this.http.get(`${this.URL}/dao/cxp/tipo_documento_dao.php?operacion=${'buscar'}&existen=${'existen'}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MTipoDocumentoCXP(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @param get toma los valores: [ idOrdenCompra ,'recepcion','existen','codigo', 'ordenesSOC', 'op', 'art' ]
+     * @param n codigo Documento Orden, se usa para obtener los detalles de la orden de compra, es obligatorio al combinar con la opcion get: idOrdenCompra
+     * @description 'recepcion': Obtine las ordenes de suministro,
+     * existe y codigo: Obtiene los codigos registrados,
+     * ordenesSOC: obtiene las ordenes de compra,
+     * op: obtiene las ordenes pendientes
+     * art: obtiene los articulos
+     * @return Observable<IResponse>
+     * @date 3-10-2021
+     * @returns
+     */
+    getEntradaSuministros(get, n) {
+        return this.http.get(`${this.URL}/dao/siv/entrada_suministro_dao.php?get=${get}&n=${n}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MEntradaSuministros(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los tipos de documentos registrados en CXP
+     * @return Observable<IResponse>
+     * @author Dimaly Crespo
+     * @date 20-07-2021
+     */
+    getConceptosCxP() {
+        return this.http.get(`${this.URL}/dao/cxp/concepto_dao.php?operacion=${'buscar'}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MConceptosCXP(e));
+            }
+            return res;
+        }));
+    }
+    /**
+  * @description Obtiene los los conceptos Retencion ISRL
+  * @return Observable<IResponse>
+  * @author Dimaly Crespo
+  * @date 26-07-2021
+  */
+    getConceptosRetencion() {
+        return this.http.get(`${this.URL}/dao/stb/deducciones_dao.php?code=${'conceptos'}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MConceptoRetencion(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene la configuración de RRHH y de SNO
+    * @return Observable<IResponse>
+    * @author Dimaly Crespo
+    */
+    obtenerConfiguracionSNO() {
+        return this.http.get(`${this.URL}/dao/sno/configuracion_dao.php?tipo=${'configuracion'}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                if (res.data.length > 0) {
+                    res.data = res.data.map(e => new MConfiguracionSNO(e));
+                }
+            }
+            return res;
+        }));
+    }
+    /**
+     *
+     * @param tipo ['default', 'uno', 'cargos'] dafault:Todas las nominas, uno: una nomina, 'cargos': nominas por cargos
+     * @param id :id de la nomina. Campo requerido para uno y cargos
+     * @returns array()
+     * @description Obtiene las nominas registradas
+     * @return Observable<IResponse>
+     * @date 20-10-21
+     *
+    */
+    getNomina(tipo, id) {
+        return this.http.get(`${this.URL}/dao/sno/definicion_nomina_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MDefinicionNomina(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los cargos de las nomina
+     * @param tipo ['codigo','default'] ->codigo: obtiene el proximo codigo. ->default: obtiene todos los cargos de la nomina
+     * @param id id de la nomina
+     * @returns array()
+     */
+    getCargosNomina(tipo, id) {
+        return this.http.get(`${this.URL}/dao/sno/asignacion_cargos_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MAsignacionCargo(e));
+            }
+            return res;
+        }));
+    }
+    /**
+   * @description Obtiene un personal de la nómina
+   * @return Observable<IResponse>
+   * @author Dimaly Crespo
+   */
+    getPersonalSRH(tipo, id) {
+        return this.http.get(`${this.URL}/dao/sno/personal_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MPersonal(e));
+            }
+            return res;
+        }));
+    }
+    /**
+   * @description Obtiene las agencia de banco
+   * @return Observable<IResponse>
+   * @author Dimaly Crespo
+   */
+    getAgenciaBanco(tipo, id) {
+        return this.http.get(`${this.URL}/dao/scb/agencia_dao.php?code=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MAgenciaBanco(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene la hojas de tiempo
+     * @return Observable<IResponse>
+     * @author Dimaly Crespo
+     */
+    getHojaTiempo(tipo, idPersonal, idNomina) {
+        return this.http.get(`${this.URL}/dao/sno/hoja_tiempo_dao.php?idPersonal=${idPersonal}&idNomina=${idNomina}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MHojaTiempo(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Obtiene los clientes
+     * @return Observable<IResponse>
+     * @author Dimaly Crespo
+     * @tipo [basico,codigo,cedula]
+     *
+     */
+    getCliente(tipo = 'default', id = 0, codigo = '', cedula = '') {
+        return this.http.get(`${this.URL}/dao/sfv/client_dao.php?tipo=${tipo}&id=${id}&codigo=${codigo}&cedrifcli=${cedula}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MClient(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @description Valida si la fecha esta dentro del periodo fiscal y el mes esta abierto o cerrado
+     * @return Observable<IResponse>
+     * @author Dimaly Crespo
+     * @author 11-10-2023
+     */
+    getValidarPeriodo(fecha, periodoFiscal) {
+        return this.http.get(`${this.URL}/dao/scg/configuracion_contabilidad_dao.php?fecha=${fecha}&periodo=${periodoFiscal}`, { headers: this.getHttpHeaders() }).pipe(map((res) => { return res; }));
+    }
+    userHasRights(column) {
+        return this.http.get(`${this.URL}/dao/sss/derechos_usuario_dao.php?idComponent=${this.currentComponent.id}&column=${column}`, { headers: this.getHttpHeaders() });
+    }
+    /**
+      * @description Retorna los headers para hacer las peticiones
+      * @params type: Tipo MIME permitido por defecto se toma application/json
+      * @return HttpHeaders
+      * @author Miguel Ramírez
+      * @date-update: 15-06-2022
+      */
+    getHttpHeaders(type) {
+        !type ? type = 'application/json' : '';
+        const headers = new HttpHeaders({
+            'Content-Type': type,
+            'Authorization': `${this.usuarioActivo.token}`
+        });
+        return headers;
+    }
+    /**
+     * @description Obtiene el servidor guardado en el sessionStorage
+     * @return string
+     * @author Miguel Ramírez
+     */
+    getServer() {
+        return this.URL;
+    }
+    /**
+     * @description Obtiene el usuario guardado en el sessionStorage
+     * @return MUsuario
+     * @author Miguel Ramírez
+     */
+    async getUser() {
+        let conexion = await (sessionStorage.getItem('user')) ? JSON.parse(atob(sessionStorage.getItem('user'))) : null;
+        //console.log(conexion)
+        // debugger
+        if (conexion) {
+            this.usuarioActivo = new MUsuario(conexion.usuario);
+            this.URL = conexion.servidor;
+        }
+    }
+    /**
+     * @description Muestra un toast de success
+     * @param message Mensaje que se va a mostrar
+     * @return void
+     * @author Miguel Ramírez
+     */
+    showToastSuccess(message) {
+        this.toast.success(message);
+    }
+    /**
+     * @description Muestra un toast de error
+     * @param message Mensaje que se va a mostrar
+     * @return void
+     * @author Miguel Ramírez
+     */
+    showToastError(message) {
+        this.toast.error(message);
+    }
+    /**
+   * @description Muestra un sweetalert2 de éxito
+   * @param message Mensaje que se va a mostrar
+   * @return void
+   * @date 22-11-2021
+   */
+    showToastSuccessSwal(message) {
+        Swal.fire({
+            icon: 'success',
+            title: 'Éxito',
+            text: message,
+        });
+    }
+    /**
+    * @description Muestra un sweetalert2 de error
+    * @param message Mensaje que se va a mostrar
+    * @return void
+    * @date 22-11-2021
+    */
+    showToastErrorSwal(message) {
+        Swal.fire({
+            icon: 'error',
+            title: '¡Error!',
+            text: message,
+        });
+    }
+    /**
+     * @description Guarda el usuario logueado en el SessionStorage
+     * @param user Usuario que se va a guardar en el SessionStorage
+     * @return void
+     * @author Miguel Ramírez
+     */
+    saveUser(data) {
+        this.usuarioActivo = new MUsuario(data.usuario);
+        this.URL = data.servidor;
+        let encryptedUser = btoa(JSON.stringify(data));
+        sessionStorage.setItem('user', encryptedUser);
+    }
+    /**
+     * @description Sete a la url a la cual se le van a realizar peticiones al backEnd
+     * @param url URl donde se van a realizar las peticiones
+     * @return void
+     * @author Miguel Ramírez
+     */
+    setUrl(url) {
+        this.URL = url;
+    }
+    /**
+     * @description Inicializa el servicio de sigesp
+     * @return void
+     * @author Miguel Ramírez
+     */
+    init() {
+        // Verificamos si hay un usuario en la sessionStorage, esto es necesario para recargar la página
+        if (sessionStorage.getItem('user')) {
+            // console.log(sessionStorage.getItem('user'))
+            this.getUser();
+        }
+    }
+    /**
+     * @description Verifica si un usuario está logueado
+     * @return Promise<boolean>
+     * @author Miguel Ramírez
+     */
+    async isLogged() {
+        return new Promise((resolve, reject) => {
+            if (sessionStorage.getItem('user')) {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+        });
+    }
+    handlerError(error) {
+        return throwError('Ocurrió un error');
+    }
+    /**
+   * @description obtiene el personal segun filtro
+   * @return Observable<IResponse>
+   * @date 15-11-2021
+   * @param tipo: valores ['catalogo','catalogoSno','default','nomina','responsables']
+   * @params dato:object {nombre:string, apellido:string, cedula.string} use para la opcion 'catalogo' o 'catalogoSno'
+   */
+    getPersonal(tipo, dato) {
+        let cedula = '';
+        let nombre = '';
+        let apellido = '';
+        let idEnterprise = 0;
+        if (dato) {
+            cedula = dato.cedula;
+            nombre = dato.nombre;
+            apellido = dato.apellido;
+            idEnterprise = dato.idEnterprise;
+        }
+        return this.http.get(`${this.URL}/dao/sno/personal_dao.php?tipo=${tipo}&cedula=${cedula}&nombre=${nombre}&apellido=${apellido}&e=${idEnterprise}`, { headers: this.getHttpHeaders() }).pipe(retry(3), catchError(this.handlerError), map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MPersonal(e));
+            }
+            return res;
+        }));
+    }
+    /**
+   * @description obtener personal Nomina segun filtro
+   * @return Observable<IResponse>
+   * @date 15-11-2021
+   * * @param tipo: valores ['catalogo','default','nomina']
+   * @params dato:object {nombre:string, apellido:string, cedula.string} use para la opcion 'catalogo'
+
+   */
+    getPersonalNomina(tipo, dato) {
+        let cedula = '';
+        let nombre = '';
+        let apellido = '';
+        let idEnterprise = 0;
+        let idNomina = 0;
+        if (dato) {
+            cedula = dato.cedula;
+            nombre = dato.nombre;
+            apellido = dato.apellido;
+            idEnterprise = dato.idEnterprise;
+            idNomina = dato.idNomina;
+        }
+        return this.http.get(`${this.URL}/dao/sno/asignacion_personal_nomina_dao.php?
+          tipo=${tipo}&cedula=${cedula}&nombre=${nombre}&apellido=${apellido}&idNomina=${idNomina}&idEnterprise=${idEnterprise}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MPersonalNomina(e));
+            }
+            return res;
+        }));
+    }
+    /**
+     * @param idPersonal: id del personal
+     * @param tipo: valores['nomina_personal']
+     * @description Obtiene las nominas del personal resumida
+     * @deprecated; 20-01-22
+     * @returns
+     */
+    getPersonalNominaResumida(idPersonal, tipo) {
+        return this.http.get(`${this.URL}/dao/sno/personal_dao.php?idPersonal=${idPersonal}&tipo=${tipo}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MNominaSimple(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene el Json Sistemas para el usuario definido segun su permisologia del Sistema
+    * @return Json data
+    * @author Ing. Dimaly Crespo
+    */
+    getPerfilSistema(id_usuario) {
+        return this.http.get(`${this.URL}/dao/sss/usuarios_sistemas_dao.php?id_usuario=${id_usuario}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.data.length > 0) {
+                res.data = res.data.map(e => new MUsuarioSistema(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema
+    * @return Json data
+    * @author Ing. Wilmer Briceno
+    */
+    getPerfilNoComponent(id_usuario, sistema, nameComponent) {
+        return this.http.get(`${this.URL}/dao/sss/derechos_usuario_dao.php?id_usuario=${id_usuario}&sistema=${sistema}&namecomponent=${nameComponent}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema
+    * @return Json data
+    * @author Ing. Wilmer Briceno
+    */
+    getJsonMenu(id_usuario, sistema) {
+        return this.http.get(`${this.URL}/dao/sss/menu_dao.php?id_usuario=${id_usuario}&sistema=${sistema}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            this.userMenu = res.data;
+            return this.userMenu;
+        }));
+    }
+    /**
+ * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema
+ * @return Json data
+ * @author Ing. Wilmer Briceno
+ */
+    log(body) {
+        return this.http.post(`${this.URL}/dao/sss/log_dao.php`, body, {
+            headers: this.getHttpHeaders()
+        }).pipe(map((res) => {
+            return res;
+        }));
+    }
+    /**
+     * @name EncryptData
+     * @description Enscripta una expresion data
+     * @author Ing. Wilmer Briceño
+     */
+    EncryptData(expresion) {
+        const key = CryptoJS.enc.Utf8.parse("0123456789SIGESP"); // número hexadecimal de 16 dígitos como clave
+        const iv = CryptoJS.enc.Utf8.parse('SIGESP0123456789'); // Número hexadecimal como desplazamiento de clave
+        let srcs = CryptoJS.enc.Utf8.parse(expresion);
+        let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
+        return encrypted.ciphertext.toString().toUpperCase();
+    }
+    /**
+    * @name DecryptData
+    * @description Desencripta una expresion data
+    * @author Ing. Wilmer Briceño
+    */
+    DecryptData(expresion) {
+        const key = CryptoJS.enc.Utf8.parse("0123456789SIGESP"); // número hexadecimal de 16 dígitos como clave
+        const iv = CryptoJS.enc.Utf8.parse('SIGESP0123456789'); // Número hexadecimal como desplazamiento de clave
+        let encryptedHexStr = CryptoJS.enc.Hex.parse(expresion);
+        let srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
+        let decrypt = CryptoJS.AES.decrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
+        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
+        return decryptedStr.toString();
+    }
+    /**
+    * @name getResponsePerfilToolbar
+    * @description Metodo que obtiene una respuesta true o false basado en una estructura sring binanria segun
+    *              la posicion dada del toolbar. se pasa string binario que contiene 1 y 0 en representacion
+    *              de las propiestades administrador,consultar,ejecutar,imprimir etc ... cada posicion secuencial
+    *              si esta en 1 es true y 0 en false y devuleve el valor segun lo requiera el usuario:
+    *              stringbinario : '1011' y posicion es 2, por tanto se tare 0 y es false que representa opcion consultar.
+    *              Estructura string binario:
+    *              Posición :
+    *              0.  Administrador        6.  Descargar      12. Reversar aprobar      18. Reversar anular contabilizado
+    *              1.  insertar             7.  Ejecutar       13. Anular.
+    *              2.  Actualizar           8.  Enviar         14. reversar anular
+    *              3.  consultar            9. Imprimir        15. contabilizar
+    *              4.  Eliminar             10. Visible        16. reversar contabilizar
+    *              5.  Anular               11. Aprobar        17. anular contabilizado
+    *
+    * @author Ing. Wilmer Briceño
+    */
+    getResponsePerfilToolbar(stringbinario, position) {
+        let binario = stringbinario.substring(position, position + 1);
+        if (binario == "1") {
+            return true;
+        }
+        return false;
+    }
+    /**
+       * @description Obtiene el Ip del cliente
+       * @return Json data
+       * @author Ing. Wilmer Briceno
+       */
+    getIPAddress() {
+        return this.http.get("http://api.ipify.org/?format=json")
+            .pipe(catchError((err) => {
+            console.log('error caught in service');
+            console.error(err);
+            sessionStorage.setItem('ip_adress', '127.0.0.1');
+            //Handle the error here
+            return throwError(err); //Rethrow it back to component
+        }));
+    }
+    /**
+     * @description Obtiene el Ip del cliente
+     * @return Json data
+     * @author Ing. Wilmer Briceno
+     */
+    setIpAdress() {
+        this.getIPAddress().subscribe((resp) => {
+            sessionStorage.setItem('ip_adress', resp.ip);
+            this.ip_adress = resp.ip;
+        });
+    }
+    /**
+     * @description Obtiene el Ip del cliente
+     * @return Json data
+     * @author Ing. Wilmer Briceno
+     */
+    getIpAdress() {
+        this.ip_adress = sessionStorage.getItem('ip_adress');
+    }
+    /**
+   * @description Obtiene el Ip del cliente
+   * @return Json data
+   * @dia 19-05-2022
+   */
+    createAuditoria(sno) {
+        let body = [];
+        sno.forEach(e => { body.push(e.dataInteface()); });
+        return this.http.post(`${this.URL}/dao/sno/seguridad_dao.php?`, body, { headers: this.getHttpHeaders() })
+            .pipe(map((res) => { return res; }));
+    }
+    /**
+     * @description Obtiene los tipos de depositos  *
+     * @param procede : procede del modulo
+     * @param idArticulo : id del articulo
+     * @param idUsuario : id usuario permitido
+     * @returns
+     * @author Javier Tovar
+     * @date 23-11-2022
+     */
+    getDepositType(procede, idArticulo, idUsuario) {
+        return this.http.get(`${this.URL}/dao/siv/catalogo_parametrizado_dao.php?get=${procede}&id=${idArticulo}&i=${idUsuario}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MTipoDepositos(e));
+            }
+            return res;
+        }));
+    }
+    /**
+    * @description Obtiene Cargos Adicionales  *
+    * @param tipo : one,default
+    * @param id : id del cargo
+    * @returns
+    * @author Dimaly Crespo
+    * @date 13-11-2022
+    */
+    getCargosAdicionales(tipo, id) {
+        return this.http.get(`${this.URL}/dao/stb/cargos_adicionales_dao.php?tipo=${tipo}&id=${id}`, { headers: this.getHttpHeaders() }).pipe(map((res) => {
+            if (res.success) {
+                res.data = res.data.map(e => new MCargosAdicionales(e));
+            }
+            return res;
+        }));
+    }
+}
+SigespService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SigespService, deps: [{ token: i1.HttpClient }, { token: i2.MatDialog }, { token: i3.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable });
+SigespService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SigespService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SigespService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.MatDialog }, { type: i3.ToastrService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sigesp.service.js","sourceRoot":"","sources":["../../../../projects/sigesp/src/lib/sigesp.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { MPrefijo } from './core/models/CFG/MPrefijo.model';\r\nimport { MEnterprise } from './core/models/CFG/Enterprise.model';\r\nimport { MPersonalNomina } from './core/models/SNO/MPersonalNomina.model';\r\nimport { MHojaTiempo } from './core/models/SNO/MHojaTiempo.model';\r\nimport { Injectable } from '@angular/core';\r\nimport { MUsuario } from './core/models/SSS/user.model';\r\nimport { HttpClient, HttpErrorResponse, HttpHeaders} from '@angular/common/http';\r\nimport { IRequest } from './core/interfaces/Request';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { MProveedor } from './core/models/RPC/proveedores.model';\r\nimport { map, catchError, retry } from 'rxjs/operators';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { MUsuarioPrefijo } from './core/models/CFG/userPrefix.model';\r\nimport { ICatalogo, filterData } from './core/interfaces/Catalogo';\r\nimport { CatalogoComponent } from './shared/components/catalogo/catalogo.component';\r\nimport { MCuentaPresupuesto } from './core/models/SPG/cuentaPresupuesto.model';\r\nimport { MCuentaInstitucional } from './core/models/SCG/cuentaInstitucional.model';\r\nimport { MMoneda, MMonedaConfig } from './core/models/CFG/moneda.model';\r\nimport { ToastrService } from 'ngx-toastr';\r\nimport { MUnidadTributaria } from './core/models/STB/unidadTributaria.model';\r\nimport { AbstractControl, UntypedFormGroup } from '@angular/forms';\r\nimport { ConfirmComponent } from './shared/components/confirm/confirm.component';\r\nimport { MConfiguracionSCG } from './core/models/SCG/configuracionSCG.model';\r\nimport { MPlanUnicoCuenta } from './core/models/SCG/planUnicoCuenta.model';\r\nimport { IConexion } from './core/interfaces/Usuario';\r\nimport { TableSelectComponent } from './shared/components/table-select/table-select.component';\r\nimport { MConfigurationSPG } from './core/models/SPG/configurationSPG.model';\r\nimport { MEstructuraPresupuestariaOne, MEstructuraPresupuestariaTwo, MEstructuraPresupuestariaThree, MEstructuraPresupuestariaFour, MEstructuraPresupuestariaFiveComplete, MEstructuraPresupuestariaFive, MEstructuraPresupuestariaThreeComplete, MAllStructure } from './core/models/SPG/estructuraPresupuestaria.model';\r\nimport { IEstructuraPresupuestariaOne, IEstructuraPresupuestariaTwo, IEstructuraPresupuestariaThree, IEstructuraPresupuestariaFour, IEstructuraPresupuestariaFiveComplete, IEstructuraPresupuestariaFive } from './core/interfaces/EstructuraPresupuestaria';\r\nimport { MCentroCosto, MUsuarioCentroCosto } from './core/models/SCG/centroCosto.model';\r\nimport { MFuenteFinanciamiento } from './core/models/SPG/fuenteFinanciamiento.model';\r\nimport { MCuentaEgresos } from './core/models/SPG/expensiveAccount.model';\r\nimport { CatalogoEstructurasComponent } from './shared/components/catalogo-estructuras/catalogo-estructuras.component';\r\nimport { IUpdateDistribution, IUpdateDistribution2, IUpdateDistributionIngresos, IUpdateDistributionIngresos2 } from './core/interfaces/CuentaEgresos';\r\nimport { CatalogoDobleInputComponent } from './shared/components/catalogo-doble-input/catalogo-doble-input.component';\r\nimport { MSistema, MUsuarioSistema } from './core/models/SSS/sistema';\r\nimport { IComprobantePresupuestarioEgresos, IComprobantePresupuestarioIngresos } from './core/interfaces/ComprobantePresupuestario';\r\nimport { MComprobantePresupuestarioEgresos, MComprobantePresupuestarioIngresos } from './core/models/SPG/comprobantePresupuestario.model';\r\nimport { MCuentaIngresos } from './core/models/SCG/IncomeAccount';\r\nimport { MIncomeStructureAccount } from './core/models/SPG/incomeStructureAccount.model';\r\nimport { MOrganizationType } from './core/models/SPG/organizationType.model';\r\nimport { MSpecialty } from './core/models/RPC/specialty.model';\r\nimport { MDocument } from './core/models/RPC/document.model';\r\nimport { MClasification } from './core/models/RPC/clasification.model';\r\nimport { MCountry, MState, MMunicipality, MParish, MCity, MCommunity } from './core/models/CFG/locations.model';\r\nimport { MProviderBeneficiary } from './core/models/RPC/providerBeneficiary.model';\r\nimport { MSigecofBank, MBank, MBankAccountType, MAgenciaBanco, MCuentaBanco } from './core/models/SCB/bank.model';\r\nimport { IResponse } from './core/interfaces/Response';\r\nimport { MConfigurationRPC } from './core/models/RPC/configuracionRPC.model';\r\nimport { MConfigSOC } from './core/models/SOC/configuracionSOC.model';\r\nimport { MDeductionType } from './core/models/STB/deductionType.model';\r\nimport { MCargo } from './core/models/SOC/charge.model';\r\nimport { MConceptoRetencion, MDeduction } from './core/models/STB/deduction.model';\r\nimport { MConfigSSS } from './core/models/SSS/securityConfiguration.model';\r\nimport { MAdministrativeUnit } from './core/models/SPG/administrativeUnit.model';\r\nimport { MComponent } from './core/models/SSS/component.model';\r\nimport { MLog } from './core/models/SSS/log.model';\r\nimport { MServiceCharge } from './core/models/SOC/serviceCharge.model';\r\nimport { MEmpresa } from './core/models/CFG/Empresa.model';\r\nimport { MConceptosCXP } from './core/models/CXP/MConceptosCXP.model';\r\nimport { MTipoDocumentoCXP } from './core/models/CXP/MTipoDocumentoCXP.model';\r\nimport { MConfiguracionSNO } from './core/models/SNO/MConfiguracionSNO.model';\r\nimport { MDefinicionNomina } from './core/models/SNO/MDefinicionNomina.model';\r\nimport { MAsignacionCargo } from './core/models/SNO/MAsignacionCargo.model';\r\nimport { MNominaSimple } from './core/models/SNO/MNominaSimple.model';\r\nimport { MPersonal } from './core/models/SNO/MPersonal.model';\r\nimport { MEntradaSuministros } from './core/models/SIV/MEntradaSuministro.model';\r\nimport Swal from 'sweetalert2'\r\nimport * as CryptoJS from 'crypto-js'; \r\nimport { MSnoLog } from './core/models/SNO/MAuditoria.model';\r\nimport { MTipoDepositos } from './core/models/SIV/MTipoDepositos.model';\r\nimport { MComunidad } from './core/models/CFG/comunidad.model';\r\nimport { MExchangeRate } from './core/models/CFG/TasaCambio.model';\r\nimport { MCargosAdicionales} from './core/models/STB/MCargosAdicionales';\r\nimport { MClient } from './core/models/SFV/MClienteModel';\r\n\r\n  \r\n  @Injectable({\r\n    providedIn: 'root'\r\n  })\r\n  export class SigespService {\r\n\r\n    public usuarioActivo: MUsuario = null;\r\n    public URL: string;\r\n    public currentComponent: MComponent = null;\r\n    public userMenu  = null; \r\n    public ip_adress = '127.0.0.1';\r\n    // public URL: string = \"http://192.168.1.67/sigesp_php\";\r\n    // usuarioActivo: MUsuario = {\r\n    //   conexionDB: {\r\n    //     baseDeDatos: \"db_sigesp_demov3\",\r\n    //     gestor: \"postgres\",\r\n    //     login: \"postgres\",\r\n    //     nombre: \"SIGESP C.A, servidor 85 (SE PUEDE USAR)\",\r\n    //     password: \"adminsigesp\",\r\n    //     puerto: \"5432\",\r\n    //     servidor: \"192.168.1.67\",\r\n    //   },\r\n    //   empresa: {\r\n    //     id: 1,\r\n    //     periodoFiscal: \"2019-01-01\",\r\n    //     titulo: \"SIGESP C.A.\"\r\n    //   },\r\n    //   nombre: \"SIGESP\",\r\n    //   token: \"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzM4NCJ9.eyJwYXNzd29yZF91c3UiOiIxMjM0NTY3OCIsImlkX2VtcHJlc2EiOiIxIiwidGl0ZW1wIjoiU0lHRVNQIEMuQS4iLCJwZXJmaXNjYWwiOiIyMDE5LTAxLTAxIiwibF91c3VhcmlvIjoiU0lHRVNQIiwic2Vydmlkb3IiOiIxOTIuMTY4LjEuNjciLCJwdWVydG8iOiI1NDMyIiwiYmFzZWRlZGF0b3MiOiJkYl9zaWdlc3BfZGVtb3YzIiwibG9naW4iOiJwb3N0Z3JlcyIsInBhc3N3b3JkIjoiYWRtaW5zaWdlc3AifQ.PISBSfueRAdsWsJ1AaGcVCgW-2aJkgtvLdsW0Bgo5ltyYowD8oy_nqK5sjE2URGk\"\r\n    // }\r\n    // procede: string = 'SCGCMP';\r\n    // codsis: string = 'SCG';\r\n\r\n\r\n    constructor(private http: HttpClient, private dialog: MatDialog, private toast: ToastrService) { }\r\n\r\n    /**\r\n     * @description Valida que selo se escriban guiones y 9\r\n     * @param event\r\n     */\r\n    public onlyGuionesAndNine(event: any) {\r\n      if (event.key === '-' || event.key === '9') {\r\n        return true;\r\n      }\r\n      return false;\r\n    }\r\n   \r\n\r\n\r\n    /**\r\n     * @description Actualiza el moncmp de sigesp_comprobante\r\n     */\r\n    public updateComprobanteAmount(amount: number, idComprobante: number): Observable<any> {\r\n      return this.http.put<any>(`${this.URL}/dao/sigesp/comprobante_dao.php?monto=true`, {\r\n        moncmp: amount,\r\n        id_comprobante: idComprobante\r\n      }, {\r\n        headers: this.getHttpHeaders()\r\n      });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza el comprobante prsupuestario de Egresos\r\n     * @param comprobante\r\n     */\r\n    public updateComprobantePresupuestarioEgresos(comprobante: IComprobantePresupuestarioEgresos): Observable<any> {\r\n      return this.http.put<any>(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`,\r\n      { ...comprobante, id: comprobante.id_dt_spgcmp }, { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el comprobante presupuestario de Egresos\r\n     */\r\n    public getComprobantePresupuestarioEgresos(): Observable<MComprobantePresupuestarioEgresos[]> {\r\n      return this.http.get<MComprobantePresupuestarioEgresos[]>(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`, {\r\n        headers: this.getHttpHeaders()\r\n      }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => res.data.map(element => new MComprobantePresupuestarioEgresos(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza el comprobante prsupuestario de Ingresos\r\n     * @param comprobante\r\n     */\r\n    public updateComprobantePresupuestarioIngresos(comprobante: IComprobantePresupuestarioIngresos): Observable<any> {\r\n      return this.http.put<any>(`${this.URL}/dao/spg/comprobante_presupuestario_egresos_dao.php`,\r\n      { ...comprobante, id: comprobante.id_dt_spicmp }, { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el comprobante presupuestario de Ingresos\r\n     */\r\n    public getComprobantePresupuestarioIngresos(): Observable<MComprobantePresupuestarioIngresos[]> {\r\n      return this.http.get<MComprobantePresupuestarioIngresos[]>(`${this.URL}/dao/spi/comprobante_presupuestario_ingresos_dao.php`, {\r\n        headers: this.getHttpHeaders()\r\n      }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => res.data.map(element => new MComprobantePresupuestarioIngresos(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @Actualiza la distribución de la cuenta de egreso\r\n     * @param distribution\r\n     */\r\n    public updateDistributionExpenseAccount(distribution: IUpdateDistribution): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/cuentas_egresos_dao.php`, distribution,\r\n      {headers: this.getHttpHeaders()});\r\n    }\r\n\r\n       /**\r\n     * @Actualiza la distribución de la cuenta de egreso\r\n     * @param distribution\r\n     */\r\n       public updateDistributionExpenseAccount2(distribution: IUpdateDistribution2[]): Observable<any> {\r\n        return this.http.put(`${this.URL}/dao/spg/cuentas_egresos_dao.php`, distribution,\r\n        {headers: this.getHttpHeaders()});\r\n      }\r\n\r\n    /**\r\n     * @Actualiza la distribución de la cuenta de Ingreso\r\n     * @param distribution\r\n     */\r\n    public updateDistributionIncomeAccount(distribution: IUpdateDistributionIngresos): Observable<IResponse> {\r\n      return this.http.put<IResponse>(`${this.URL}/dao/spi/cuentas_ingresos_dao.php`, distribution,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res: any) => {\r\n          if (res.success){\r\n            res.data = new MCuentaIngresos(res.data);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    public updateDistributionIncomeAccount2(distribution: IUpdateDistributionIngresos2[]): Observable<IResponse> {\r\n      return this.http.put<IResponse>(`${this.URL}/dao/spi/cuentas_ingresos_dao.php`, distribution,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res: any) => {\r\n          if (res.success){\r\n            res.data = new MCuentaIngresos(res.data);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @Actualiza la distribución de la cuenta de Ingreso de Estructura\r\n     * @param distribution\r\n     */\r\n    public updateDistributionIncomeStructureAccount(distribution: IUpdateDistributionIngresos, level: number): Observable<IResponse> {\r\n      return this.http.put<IResponse>(`${this.URL}/dao/spi/cuenta_estructura_ingresos_dao.php`, distribution,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res: any) => {\r\n          if (res.success){\r\n            res.data = new MIncomeStructureAccount(res.data, level);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las cuentas por nivel de las cuenats de egresos\r\n     * @param level Número de niveles de la configuración\r\n     * @param id id del nivel 3 o 5 que se va a buscar\r\n     * @return Observable<MCuentaEgresos[]>\r\n     */\r\n    public getExpenseAccountsForLevel(level: number, id: string): Observable<MCuentaEgresos[]>{\r\n      return this.http.get<MCuentaEgresos[]>(`${this.URL}/dao/spg/cuentas_egresos_dao.php?level=${level}&id=${id}`,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res:any) => res.data.map(element => new MCuentaEgresos(element)))\r\n      )\r\n    }\r\n\r\n    /**\r\n     * @description Abre el catálogo de estructura presupuesaria\r\n     * @param data Data que se va a mostrar\r\n     * @param configuration Configuración de la estructura\r\n     * @return Promise<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public openCatalogoEstructuraPresupuestaria(data: any[], configuration: MConfigurationSPG): Promise<any> {\r\n      const catalogo = this.dialog.open(CatalogoEstructurasComponent, {\r\n        data: {\r\n          data,\r\n          configuration\r\n        },\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return catalogo.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las cuentas de egresos\r\n     * @param onlyAvailable\r\n     * @return Observable<MCuentaEgresos[]>\r\n     */\r\n     public getExpenseAccounts(onlyAvailable: boolean = false): Observable<MCuentaEgresos[]>{\r\n      return this.http.get<MCuentaEgresos[]>(`${this.URL}/dao/spg/cuentas_egresos_dao.php${\r\n        onlyAvailable ? '?available=true' : ''\r\n      }`, {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res:any) => res.data.map(element => new MCuentaEgresos(element)))\r\n      )\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene todas las estructuras presupuetsarias de las 5 tablas\r\n     * @return Promise<MAllStructure>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getAllBudgetStructure(): Promise<MAllStructure> {\r\n      return new Promise((resolve, reject) => {\r\n        this.getBudgetStructureOne().subscribe(structureOne => {\r\n          this.getBudgetStructureTwoAll().subscribe(structureTwo => {\r\n            this.getBudgetStructureThree().subscribe(structureThree => {\r\n              this.getBudgetStructureFour().subscribe(structureFour => {\r\n                this.getBudgetStructureFiveByIdEp4().subscribe(structureFive => {\r\n                  resolve(new MAllStructure({\r\n                    structureOne,\r\n                    structureTwo,\r\n                    structureThree,\r\n                    structureFour,\r\n                    structureFive\r\n                  }));\r\n                });\r\n              });\r\n            });\r\n          });\r\n        });\r\n      })\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la estructura completa dependiendo de la configuración\r\n     * @return Promise<any[]>\r\n     * @author Miguel Ramírez\r\n     * @type= {}\r\n     */\r\n    public async getBudgetStructureComplete(nivel:number,tipo?:string): Promise<any[]> {\r\n      return new Promise(async (resolve) => {\r\n        let data = [];\r\n        await this.getBudgetStructureFive(nivel,tipo).subscribe(result => {\r\n          data.push(...result)\r\n        })\r\n        // await this.getBudgetStructureThreeComplete(3).subscribe(result => {\r\n        //   data.push(...result)\r\n        // })\r\n\r\n        await resolve(data);\r\n\r\n      });\r\n    }\r\n\r\n    /**\r\n     * @description Elimina una o varias estructuras presupuestarias\r\n     * @param idStructures Id de las estructuras presupuestarias 5 que van a ser eliminadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public deleteBudgetStructureFive(idStructures: any[]): Observable<any> {\r\n      return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`,\r\n      { body: idStructures, headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza una o varias estructuras 4\r\n     * @param structures Estructuras presupuestarias que van a ser actualizadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public updateBudgetStructureFive(structures: IEstructuraPresupuestariaFive[]): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Agrega una o varias estructuras presupuestarias 4\r\n     * @param structures Las estructuras que van a ser registradas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setBudgetStructureFive(structures: IEstructuraPresupuestariaFive[]): Observable<any> {\r\n      return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria5_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene toda la estructura presupuestaria 5\r\n     * @return Observable<MEstructuraPresupuestariaFive[]>\r\n     * @author Miguel Ramírez\r\n     * @params tipo:\"sss\" \r\n     */\r\n    public getBudgetStructureFive(level: number = null, tipo:string=''): Observable<MEstructuraPresupuestariaFiveComplete[]> {\r\n      return this.http.get<MEstructuraPresupuestariaFiveComplete[]>(\r\n        `${this.URL}/dao/spg/estructura_presupuestaria5_dao.php?complete=true&tipo=${tipo}`,\r\n      { headers: this.getHttpHeaders() }).pipe(       \r\n        map((resp: any) => resp.data.map(e => new MEstructuraPresupuestariaFiveComplete(e, level)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la estructura presupuestaria 5 por el Id de la estructura 4\r\n     * @param idEp4 id de la estructura presupuestaria 4\r\n     */\r\n    public getBudgetStructureFiveByIdEp4(idEp4?: string): Observable<any[]> {\r\n      return this.http.get<any[]>(\r\n        `${this.URL}/dao/spg/estructura_presupuestaria5_dao.php${idEp4 ? `?id_ep4=${idEp4}` : ''}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaFive(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Elimina una o varias estructuras presupuestarias\r\n     * @param idStructures Id de las estructuras presupuestarias 3 que vana  ser eliminadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public deleteBudgetStructureFour(idStructures: any[]): Observable<any> {\r\n      return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`,\r\n      { body: idStructures, headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza una o varias estructuras 4\r\n     * @param structures Estructuras presupuestarias que van a ser actualizadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public updateBudgetStructureFour(structures: IEstructuraPresupuestariaFour[]): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Agrega una o varias estructuras presupuestarias 4\r\n     * @param structures Las estructuras que van a ser registradas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setBudgetStructureFour(structures: IEstructuraPresupuestariaFour[]): Observable<any> {\r\n      return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria4_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las estructuras presupuestarias 4\r\n     * @param idEp3 Id de la estructura presupuestaria 3\r\n     * @return Observable<MEstructurapresupuestaria[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureFour(idEp3?: string): Observable<MEstructuraPresupuestariaFour[]> {\r\n      return this.http.get<MEstructuraPresupuestariaFour[]>(\r\n        `${this.URL}/dao/spg/estructura_presupuestaria4_dao.php${idEp3 ? `?id_ep3=${idEp3}` : ''}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaFour(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Elimina una o varias estructuras presupuestarias\r\n     * @param idStructures Id de las estructuras presupuestarias 3 que vana  ser eliminadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public deleteBudgetStructureThree(idStructures: any[]): Observable<any> {\r\n      return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`,\r\n      { body: idStructures, headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza una o varias estructuras 3\r\n     * @param structures Estructuras presupuestarias que van a ser actualizadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public updateBudgetStructureThree(structures: IEstructuraPresupuestariaThree[]): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Agrega una o varias estructuras presupuestarias 3\r\n     * @param structures Las estructuras que van a ser registradas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setBudgetStructureThree(structures: IEstructuraPresupuestariaThree[]): Observable<any> {\r\n      return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria3_dao.php`, structures,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Se trae la estructura presupuestaria completa hasta el nivel 3\r\n     * @return Observable<any[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureThreeComplete(level: number): Observable<MEstructuraPresupuestariaFiveComplete[]> {\r\n      return this.http.get<MEstructuraPresupuestariaFiveComplete[]>(\r\n        `${this.URL}/dao/spg/estructura_presupuestaria3_dao.php?complete=true`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaFiveComplete(element, level)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las estructuras presupuestarias 3\r\n     * @param idEp2 Id de la estructura presupuestaria 2\r\n     * @return Observable<MEstructurapresupuestaria[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureThree(idEp2?: string): Observable<MEstructuraPresupuestariaThree[]> {\r\n      return this.http.get<MEstructuraPresupuestariaThree[]>(\r\n        `${this.URL}/dao/spg/estructura_presupuestaria3_dao.php${idEp2 ? `?id_ep2=${idEp2}` : ''}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaThree(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Elimina una o varias estructuras presupuestarias uno\r\n     * @param idStructures Id de la o las estructuras presupuestarias que van a ser eliminadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public deleteBudgetStructureTwo(idStructures: any[]): Observable<any> {\r\n      return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`,\r\n      { body: idStructures, headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza una estructura presupuestaria dos\r\n     * @param structure Estructura presupuestaria uno que se va a actualizar\r\n     * @return Observable<any>\r\n     */\r\n    public updateBudgetStructureTwo(structure: IEstructuraPresupuestariaTwo[]): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`, structure,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Registra las estructuras presupuestrias dos en la base de datos\r\n     * @param budgetStructures Array de estructuras presupuestaria que se van a registrar\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setBudgetStructureTwo(budgetStructures: IEstructuraPresupuestariaTwo[]): Observable<any> {\r\n      return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`,\r\n      budgetStructures, { headers: this.getHttpHeaders() })\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la estructura presupuestaria\r\n     * @return Observable<MEstructuraPresupuestaria[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureTwo(idEp1: string): Observable<MEstructuraPresupuestariaTwo[]> {\r\n      return this.http.get<MEstructuraPresupuestariaTwo[]>(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php?id_ep1=${idEp1}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map(((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaTwo(element))))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la estructura presupuestaria\r\n     * @return Observable<MEstructuraPresupuestaria[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureTwoAll(): Observable<MEstructuraPresupuestariaTwo[]> {\r\n      return this.http.get<MEstructuraPresupuestariaTwo[]>(`${this.URL}/dao/spg/estructura_presupuestaria2_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map(((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaTwo(element))))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Elimina una o varias estructuras presupuestarias uno\r\n     * @param idStructures Id de la o las estructuras presupuestarias que van a ser eliminadas\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public deleteBudgetStructureOne(idStructures: any[]): Observable<any> {\r\n      return this.http.request('delete', `${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`,\r\n      { body: idStructures, headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Actualiza una estructura presupuestaria uno\r\n     * @param structure Estructura presupuestaria uno que se va a actualizar\r\n     * @return Observable<any>\r\n     */\r\n    public updateBudgetStructureOne(structure: IEstructuraPresupuestariaOne[]): Observable<any> {\r\n      return this.http.put(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`, structure,\r\n      { headers: this.getHttpHeaders() });\r\n    }\r\n\r\n    /**\r\n     * @description Registra las estructuras presupuestrias en la base de datos\r\n     * @param budgetStructures Array de estructuras presupuestaria que s evan a registrar\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setBudgetStructureOne(budgetStructures: IEstructuraPresupuestariaOne[]): Observable<any> {\r\n      return this.http.post(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`,\r\n      budgetStructures, { headers: this.getHttpHeaders() })\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la estructura presupuestaria\r\n     * @return Observable<MEstructuraPresupuestaria[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getBudgetStructureOne(): Observable<MEstructuraPresupuestariaOne[]> {\r\n        return this.http.get<MEstructuraPresupuestariaOne[]>(`${this.URL}/dao/spg/estructura_presupuestaria1_dao.php`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map(((resp: any) => resp.data.map(element => new MEstructuraPresupuestariaOne(element))))\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las configuraciones de la estructura presupuestaria\r\n     * @return Observable<MConfigurationSPG[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getConfigurationSPG(): Observable<MConfigurationSPG> {\r\n\r\n      return this.http.get<MConfigurationSPG>(`${this.URL}/dao/spg/estructura_presupuestaria_config_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => new MConfigurationSPG(resp.data[0]))\r\n      );\r\n    }\r\n    /**\r\n     * @description Obtiene las configuraciones de los proveedores\r\n     * @return Observable<MConfigurationRPC[]>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getConfigurationRPC(): Observable<IResponse> {\r\n\r\n      return this.http.get<MConfigurationRPC>(`${this.URL}/dao/rpc/proveedor_config_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: IResponse) => {\r\n          if (resp.success) {\r\n            resp.data = new MConfigurationRPC(resp.data)\r\n          }\r\n          return resp\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las MConfiguracionSNO de la nomina\r\n     * @return Observable<MConfiguracionSNO[]>\r\n     * @date 27-07-2021\r\n     */\r\n     public getConfigurationSNO(): Observable<IResponse> {\r\n\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sno/configuracion_dao.php?tipo=${'configuracion'}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: IResponse) => {\r\n          if (resp.success) {\r\n            if(resp.data !=null){\r\n              resp.data = resp.data.map(e => new MConfiguracionSNO(e));\r\n            } else {\r\n              resp.data=[];\r\n            }\r\n          }\r\n          return resp\r\n        })\r\n      );\r\n    }\r\n\r\n\r\n    public dateToString(date: Date): string{\r\n      return `${date.getFullYear()}-${\r\n        date.getMonth() + 1 >= 10 ? date.getMonth() + 1 : `0${date.getMonth() + 1}`\r\n      }-${\r\n        date.getDate() >= 10 ? date.getDate() : `0${date.getDate()}`\r\n      }`\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las configuraciones de Seguridad\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getConfigSSS(): Observable<IResponse> {\r\n\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sss/seguridad_config_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: IResponse) => {\r\n          if (resp.success) {\r\n            resp.data = new MConfigSSS(resp.data)\r\n          }\r\n          return resp\r\n        })\r\n      );\r\n    }\r\n\r\n    public getComponents(systemCode: string = null, permit: boolean): Observable<IResponse>{\r\n\r\n      return this.http.get<IResponse>(\r\n        `${this.URL}/dao/sss/componentes_dao.php?${systemCode ? `codsis=${systemCode}${\r\n          permit ? `&permit=true` : ''\r\n        }` : ''}`,\r\n        { headers: this.getHttpHeaders() }\r\n      ).pipe(\r\n  \r\n        map(res => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MComponent(e));\r\n          }\r\n          return res;\r\n        })\r\n      )\r\n  \r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las fuentes de financiamiento\r\n     * @return Observable<MFuenteFinanciamiento[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getFuenteFinanciamiento(): Observable<MFuenteFinanciamiento[]> {\r\n      return this.http.get<MFuenteFinanciamiento[]>(`${this.URL}/dao/spg/fuente_financiamiento_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MFuenteFinanciamiento(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los centros de costo\r\n     * @return Observable<MCentroCosto[]>\r\n     * @author Miguel Ramírez\r\n     * @param id:idusurio o id del ecntro de costo\r\n     * modificado 28-12-2022\r\n     */\r\n    public getCentroCosto(tipo: 'all'|'one'|'user'|'enter'= null, id?:string): Observable<MCentroCosto[]> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/scg/centro_costo_dao.php?tipo=${tipo}&id=${id}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MCentroCosto(element)))\r\n        );\r\n    }\r\n\r\n\r\n\r\n    /**\r\n     * @description Obtiene los centros de costo\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getCostCenters(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/scg/centro_costo_dao.php`, \r\n      {headers: this.getHttpHeaders()}\r\n      ).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: IResponse) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(element => new MCentroCosto(element))\r\n          }\r\n          return res\r\n        })\r\n      );\r\n    }\r\n\r\n    public getUserCostCenters(codigo:string): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/scg/centro_costo_usuario_dao.php?codigo=${codigo}`, \r\n      {headers: this.getHttpHeaders()}\r\n      ).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: IResponse) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(element => new MUsuarioCentroCosto(element))\r\n          }\r\n          return res\r\n        })\r\n      );\r\n    }\r\n\r\n\r\n    /**\r\n     * @description Abre el dialog de checkks\r\n     * @param columns Columnas que va a tener la tabla\r\n     * @param title Título de la modal\r\n     * @param dataSource Data que s eva a mostrar en la tabla\r\n     */\r\n    public openDialogMultiSelect(\r\n      // columns: string[], \r\n      // title: string, \r\n      // dataSource: any[],\r\n      // columnNames?: string[]\r\n      columns: string[], \r\n      title: string, \r\n      dataSource: any[], \r\n      columnNames: string[] = null, \r\n      width: string = '450px',\r\n      options: {\r\n        hasBackdrop?: boolean,\r\n        disableClose?: boolean,\r\n       // disableMasterToggle?: boolean\r\n      } = {\r\n        disableClose: false, \r\n        hasBackdrop: false, \r\n      //  disableMasterToggle: false\r\n      }\r\n    ): Promise<any[]> {\r\n      let dialogRef = this.dialog.open(TableSelectComponent, {\r\n        data: {\r\n          title: title,\r\n          columns: columns,\r\n          dataSource: dataSource,\r\n          columnNames,\r\n         // disableMasterToggle: options.disableMasterToggle\r\n        },\r\n        width: width,\r\n        maxHeight: '90vh',\r\n        hasBackdrop: options.hasBackdrop,\r\n        disableClose: options.disableClose\r\n      });\r\n\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n    /**\r\n     * @description Abre el dialog de las comunidades\r\n     * @return Promise<MPlanUnicoCuenta>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogPlanUnicoCuentas(): Promise<MPlanUnicoCuenta> {\r\n      let planes: MPlanUnicoCuenta[] = await this.getListadoPLanUnicoCuentas().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['cuenta', 'denominacion'],\r\n          columnNames: ['cuenta', 'denominación'],\r\n          title: 'Catálogo de Plan de Cuentas Géneral',\r\n          dataSource: planes\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el listado del plan único de cuentas\r\n     * @return Observable<MplanUnicoCuenta[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getListadoPLanUnicoCuentas(): Observable<MPlanUnicoCuenta[]> {\r\n      return this.http.get<MPlanUnicoCuenta[]>(`${this.URL}/dao/scg/plan_unico_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MPlanUnicoCuenta(element)))\r\n      )\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la configuración de SCG\r\n     * @return Observable<MConfiguracionSCG[]>\r\n     * @author Miguel Ramírez\r\n     * @modifit 25-07-2021\r\n     */\r\n    public getConfigurationSCG(): Observable<MConfiguracionSCG[]> {      \r\n      return this.http.get<MConfiguracionSCG[]>(`${this.URL}/dao/scg/configuracion_contabilidad_dao.php`,\r\n      {headers: this.getHttpHeaders()}\r\n      ).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MConfiguracionSCG(element)))\r\n      )\r\n    }\r\n\r\n    /**\r\n     * @description Abre un dialog de confirmación\r\n     * @param title Título de la modal de confirm\r\n     * @param message Mensaje (opcional) para el ususario\r\n     * @return Promise<boolean>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public openDialogConfirm(title: string, message?: string): Promise<boolean> {\r\n      let dialogRef = this.dialog.open(ConfirmComponent, {\r\n        data: {\r\n          title: title,\r\n          message: (message) ? message : null\r\n        },\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Convierte el contenido de un AbstractControl en mayúscula (Usar en evento keyup)\r\n     * @param formGroup Formulario dónde se va a buscar el AbstractControl\r\n     * @param name Nombre del AbstractControl\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public changeToUpperCase(formGroup: UntypedFormGroup, name: string): void {\r\n      this.getAbstractControl(formGroup, name).setValue(this.getAbstractControl(formGroup, name).value.toUpperCase());\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el AbstractControl de un formulario\r\n     * @param formGroup Formulario donde se va a buscar el AbstractControl\r\n     * @param name Nombre del AbstractControl\r\n     * @return AbstractControl\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getAbstractControl(formGroup: UntypedFormGroup, name: string): AbstractControl {\r\n      return formGroup.get(name);\r\n    }\r\n\r\n    /**\r\n     * @description Previene que se escriban letras en el input (Usar en keypress)\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @author Miguel Ramírez\r\n     * @modificado como onlyNumero para corregir codigo, usar currency-input si quiere usar decimales \r\n     */\r\n    public onlyDecimal(event?: any): boolean {\r\n        if (!isNaN(+event.key) && event.keyCode != 32) {\r\n          return true;\r\n        }\r\n        return false;      \r\n    }\r\n\r\n    /**\r\n     * @description Previene que se escriban letras en el input (Usar en keypress)\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @author Miguel Ramírez\r\n     */\r\n    public onlyNumbers(event?: any): boolean {\r\n      // console.log(event);\r\n      if (!isNaN(+event.key) && event.keyCode != 32) {\r\n        return true;\r\n      }\r\n      return false;\r\n    }\r\n\r\n     /**\r\n     * @description Acepta solo numero, delete y backspace\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @author Dimaly Crespo\r\n     */\r\n    public onlyNumbers2(event?: any): boolean {\r\n      if (!isNaN(+event.key)  || event.keyCode == 8 || event.keyCode == 46) {\r\n        return true;\r\n      }\r\n      return false;\r\n    }\r\n\r\n     /**\r\n     * @description Acepta solo numero,guiones, parentesis,espacios\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @author Dimaly Crespo\r\n     */\r\n     public typeNumbersHyphen(event?: any): boolean {\r\n      if (!isNaN(+event.key) || event.keyCode == 8 ||  event.keyCode == 32  || event.keyCode == 46 \r\n      || event.keyCode == 58 || event.keyCode == 57 || event.keyCode == 189) {\r\n        return true;\r\n      }\r\n      return false;\r\n    }\r\n\r\n     /**\r\n     * @description Permite (a-z A-Z á-ú ñÑ üÜ ',.) que se escriban numeros en el input (Usar en keypress)\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @date 14-05-2022\r\n     * \r\n     */\r\n      public typeName(event?: any): boolean {\r\n        if ((event.key>='a' && event.key<='z')  || (event.key>='A' && event.key<='Z') ||  event.key==\"ñ\" ||  event.key==\"Ñ\" \r\n          || (event.key>='á' && event.key<='ú') || event.key>='ü'  || event.key>='Ü'  || event.key==\"'\"  || event.keyCode==32 \r\n          ||  event.key==\".\" ||  event.key==\",\" || event.keyCode == 8 ||  event.keyCode == 32  || event.keyCode == 46  ){\r\n          return true;\r\n        }\r\n        return false;\r\n      }\r\n    /**\r\n     * @description Permite (0-9 a-z A-Z á-ú ñÑ üÜ ',.-_/:()%#º&$€£¥) que se escriban  en el input (Usar en keypress)\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @date 14-05-2022\r\n     * \r\n     */\r\n      public typeText(event?: any): boolean {      \r\n        if ((event.key>='a'  && event.key<='z') || (event.key>='A' && event.key<='Z') || event.key==\"ñ\" || event.key==\"Ñ\" \r\n          || (event.key>='á' && event.key<='ú') || event.key=='ü' || event.key=='Ü' || event.key==\"'\" || isNaN(+event.key) \r\n          || event.key==\".\"  ||  event.key==\",\" || event.key==\"&\" ||  event.key==\"_\"|| event.key==\"-\" || event.key==\"#\"\r\n          || event.key==\"º\"  ||  event.key==\"$\" || event.key==\"(\" || event.key==\")\" || event.key==\"%\" || event.key==' '\r\n          || event.key==':'  ||event.key=='/'|| event.keyCode==8364 ||  event.keyCode==165 ||event.keyCode==163 \r\n          || event.keyCode == 8 ||  event.keyCode == 32  || event.keyCode == 46 ){\r\n          return true;\r\n        }        \r\n        return false;      \r\n      }\r\n\r\n      /**\r\n     * @description Permite (0-9 a-z A-Z ñÑ .-_) que se escriban  en el input (Usar en keypress)\r\n     * @param event Evento del teclado\r\n     * @return boolean\r\n     * @date 14-05-2022\r\n     */\r\n       public typeCode(event?: any): boolean {\r\n        if ((event.key>='a'  && event.key<='z') || (event.key>='A' && event.key<='Z')  || event.key==\"ñ\" || event.key==\"Ñ\" \r\n          ||isNaN(+event.key) || event.key==\".\" ||  event.key==\"_\" || event.key==\"-\" || event.keyCode == 8 ||  event.keyCode == 32  || event.keyCode == 46 ){\r\n          return true;\r\n        }        \r\n        return false;      \r\n      }\r\n\r\n    /**\r\n     * @description Abre el dialog de las comunidades\r\n     * @return Promise<MComunidad>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogUnidadesTributarias(): Promise<any> {\r\n      let udTributarias: MUnidadTributaria[] = await this.getUnidadesTributarias().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['año', 'nro_decreto', 'fecha_decreto', 'entrada_videncia', 'publicacion_gaceta', 'nro_gaceta', 'valorut'],\r\n          title: 'Catálogo de Unidades Tributarias',\r\n          dataSource: udTributarias\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las unidades tributarias\r\n     * @return Observable<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getUnidadesTributarias(): Observable<MUnidadTributaria[]> {\r\n      const request: IRequest = {\r\n        operacion: 'obtenerData',\r\n        sigesp_conexion: {\r\n          servidor: this.URL,\r\n          usuario: this.usuarioActivo.getInterface()\r\n        }\r\n      }\r\n      return this.http.post<MUnidadTributaria[]>(`${this.URL}/dao/cfg/undtributaria_dao.php`, request).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any[]) => resp.map(element => new MUnidadTributaria(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Abre una modal génerica\r\n     * @param columns Columnas que va a tener la tabla\r\n     * @param title Título del dialog\r\n     * @param dataSource Data que se va a mostrar en la tabla\r\n     * @return Promise<any>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openCatalogoGenerico(\r\n      columns: string[], \r\n      title: string, \r\n      dataSource: any[], \r\n      columnNames: string[] = null, \r\n      width: string = '450px',\r\n      options: {\r\n        hasBackdrop?: boolean,\r\n        disableClose?: boolean\r\n      } = {disableClose: false, hasBackdrop: false}\r\n    ): Promise<any> {\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns,\r\n          title,\r\n          dataSource,\r\n          columnNames\r\n        } as ICatalogo,\r\n        width: width,\r\n        maxHeight: '90vh',\r\n        hasBackdrop: options.hasBackdrop ? options.hasBackdrop : false,\r\n        disableClose: options.disableClose ? options.disableClose : false,\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Abre una modal génerica con 2 inputs\r\n     * @param columns Columnas que va a tener la tabla\r\n     * @param title Título del dialog\r\n     * @param dataSource Data que se va a mostrar en la tabla\r\n     * @return Promise<any>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public async openCatalogoDosInputs(\r\n      columns: string[],\r\n      title: string, \r\n      dataSource: any[], \r\n      filterData: filterData[],\r\n      columnNames: string[] = null,\r\n      width: string = \"450px\"\r\n    ): Promise<any> {\r\n      let dialogRef = this.dialog.open(CatalogoDobleInputComponent, {\r\n        data: {\r\n          columns,\r\n          title,\r\n          dataSource,\r\n          columnNames,\r\n          filterData\r\n        } as ICatalogo,\r\n        width: width,\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Abre el dialog de las comunidades\r\n     * @return Promise<MComunidad>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogComunidad(): Promise<MComunidad> {\r\n      let comunidades: MComunidad[] = await this.getComunidades().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['prefijo', 'pais', 'estado', 'municipio', 'parroquia', 'codigo', 'comunidad'],\r\n          title: 'Catálogo de Comunidades',\r\n          dataSource: comunidades\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las comunidades\r\n     * @return Observable<MComunidad[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getComunidades(): Observable<MComunidad[]> {\r\n      const request: IRequest = {\r\n        operacion: 'obtenerData',\r\n        sigesp_conexion: {\r\n          servidor: this.URL,\r\n          usuario: this.usuarioActivo.getInterface()\r\n        }\r\n      }\r\n      return this.http.post<MComunidad[]>(`${this.URL}/dao/cfg/comunidades_dao.php`, request).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any[]) => resp.map(element => new MComunidad(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Abre el dialog de las las monedas\r\n     * @return Promise<MMoneda>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogMonedas(): Promise<MMoneda> {\r\n      let coins: MMoneda[] = await this.getMonedas('todas').toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['codigo', 'denominacion', 'codigoIso', 'simbolo'],\r\n          title: 'Catálogo de Monedas',\r\n          columnNames: ['código', 'denominación', 'iso', 'simbolo'],\r\n          dataSource: coins\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n  /**\r\n   * @description Obtiene las monedas\r\n   * @return Observable<MMoneda[]>\r\n   * @author Miguel Ramírez\r\n   * actualizado 4-12-2022\r\n   * @param tipo :string {'todas','uno','actual}\r\n   * @param id : number\r\n   * @returns \r\n   */ \r\n    \r\n    \r\n    public getMonedas(tipo:string,id?:number): Observable<MMoneda[]> {     \r\n      return this.http.get<MMoneda[]>(`${this.URL}/dao/cfg/moneda_dao.php?tipo=${tipo}&id=${id}`,\r\n      { headers: this.getHttpHeaders()}).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MMoneda(element)))\r\n      );\r\n    }\r\n\r\n\r\n    /**\r\n     * @Description: Obtiene la tasa de cambio asociadas a uno o varias monedas\r\n     * @param tipo string\r\n     * @param id codigo moneda\r\n     * @returns array/null\r\n     * @tipo:all->todas, (moneda->una moneda id->id de moneda)\r\n     */\r\n    public getCurrencyExchangeRate(tipo: 'all'| 'moneda'= null, id?:number): Observable<MExchangeRate[]> {     \r\n      return this.http.get<MExchangeRate[]>(`${this.URL}/dao/cfg/tasa_cambio_dao.php?tipo=${tipo}&id=${id}`,\r\n      { headers: this.getHttpHeaders()}).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MExchangeRate(element)))\r\n      );\r\n    }\r\n\r\n\r\n\r\n  \r\n\r\n    /**\r\n     * @description Abre el dialog de las las cuentas contables (Cuentas Institucionales)\r\n     * @return Promise<McuentaInstitucional>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogCuentasInstitucionales(): Promise<MCuentaInstitucional> {\r\n      let accounts: MCuentaInstitucional[] = await this.getCuentasInstitucionales().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['cuenta', 'denominacion'],\r\n          columnNames: ['cuenta', 'denominación'],\r\n          title: 'Catálogo de plan de cuenta institucional',\r\n          dataSource: accounts\r\n        } as ICatalogo,\r\n        width: '800px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las cuentas contables (Cuentas Institucionales)\r\n     * @return Observable<MCuentaInstitucional[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getCuentasInstitucionales(inventory?: boolean): Observable<MCuentaInstitucional[]> {\r\n      return this.http.get<MCuentaInstitucional[]>(`${this.URL}/dao/scg/cuentas_dao.php${(inventory) ? '?inventory=true' : ''}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((resp: any) => resp.data.map(element => new MCuentaInstitucional(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Abre el dialog de las cuentas de presupuesto (Recursos y Egresos)\r\n     * @return Promise<MCuentaPresupuesto>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogCuentasPresupuesto(): Promise<MCuentaPresupuesto> {\r\n      let accounts: MCuentaPresupuesto[] = await this.getCuentasPresupuesto().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columnNames: ['cuenta', 'denominación'],\r\n          columns: ['cuenta', 'denominacion'],\r\n          title: 'Catálogo de Cuentas de Presupuesto',\r\n          dataSource: accounts\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las cuentas de recursos y egresos\r\n     * @return Observable<MCuentaPresupuesto>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getCuentasPresupuesto(filter?:string): Observable<MCuentaPresupuesto[]> {\r\n      return this.http.get<MCuentaPresupuesto>(`${this.URL}/dao/scg/plan_unico_cuentas_dao.php?filter=${filter}`,\r\n      { headers: this.getHttpHeaders() }).pipe( map((res: any) => res.data.map(element => new MCuentaPresupuesto(element))));\r\n    }\r\n\r\n   \r\n    /**\r\n     * @description Abre el cátalogo de cuentas de la tabla \"scg_plan_unico_re\"\r\n     * @returns Promise<MCuentaPresupuesto>\r\n     * @author Carlos Albornoz\r\n     * @params filtro: Indica bajo que parametros se va a filtrar el catalogo\r\n     */\r\n    public async openCatalogoCuentasPresuspuesto(\r\n      titulo: string,\r\n      filtro: filtroCuentasPresupuesto = null,\r\n      ancho: string = '750px'\r\n    ): Promise<MCuentaPresupuesto> {\r\n      let cuentas: MCuentaPresupuesto[] = [];\r\n\r\n      await this.getCuentasPresupuesto().toPromise().then((res) => {\r\n        cuentas = res;\r\n        if (filtro) {\r\n          if (filtro.estado) {\r\n            cuentas = cuentas.filter(c => {\r\n              return c.status == filtro.estado\r\n            })\r\n          }\r\n          if (filtro.tipo) {\r\n            cuentas = cuentas.filter(c => {\r\n              return c.tipo == filtro.tipo\r\n            })\r\n          }\r\n        }\r\n        cuentas = cuentas.map(e => {\r\n          e['provStatus'] = e.status == \"C\" ? \"Movimientos\" : \"Totalizadora\"\r\n          e['provType'] = e.status == \"R\" ? \"Recursos\" : \"Ingresos\"\r\n          return e\r\n        })\r\n      })\r\n      return this.openCatalogoGenerico(\r\n        [\"cuenta\",\"denominacion\",\"provStatus\",\"provType\"],\r\n        titulo,\r\n        cuentas,\r\n        [\"Cuenta\",\"Denominación\",\"Estado\",\"Tipo\"],\r\n        ancho\r\n      )\r\n    }\r\n\r\n    /**\r\n     * @description Abre el cátalogo de cuentas de la tabla \"spg_cuentas\"\r\n     * @returns Promise<MCuentaEgresos>\r\n     * @author Carlos Albornoz\r\n     * @params presupuesto: Indica si se a trabajar con estructura de presupuesto o no\r\n     */\r\n    public async openCatalogoCuentasEgreso(\r\n      titulo: string,\r\n      presupuesto: boolean = true,\r\n      ancho: string = \"750px\"\r\n    ): Promise<MCuentaEgresos>{\r\n      let cuentas: MCuentaEgresos[] = [];\r\n      await this.getExpenseAccounts().toPromise().then(res => {\r\n        cuentas = res\r\n        cuentas = cuentas.filter(e => {\r\n          return e.status == \"C\"\r\n        }).map(e => {\r\n          e['provStatus'] = e.status == \"C\" ? \"Movimientos\" : \"Totalizadora\"\r\n          return e;\r\n        })\r\n      })\r\n      if (presupuesto) {\r\n        return this.openCatalogoDosInputs(\r\n          [\"cuenta\",\"denominacion\",\"estructura\",\"provStatus\"],\r\n          titulo,\r\n          cuentas,\r\n          [{\r\n            placeholder: \"Cuenta\",\r\n            property: \"cuenta\"\r\n          }, {\r\n            placeholder: \"Estructura\",\r\n            property: \"estructura\"\r\n          }],\r\n          [\"Cuenta\", \"Denominación\", \"Estructura\", \"Estado\"],\r\n          ancho\r\n        )\r\n      } else {\r\n        let filteredAccounts: MCuentaEgresos[] = [];\r\n        cuentas.forEach(c => {\r\n          if (!filteredAccounts.find(e => e.cuenta == c.cuenta)) {\r\n            filteredAccounts.push(c)\r\n          }\r\n        })\r\n        return this.openCatalogoGenerico(\r\n          [\"cuenta\",\"denominacion\",\"provStatus\"],\r\n          titulo,\r\n          filteredAccounts,\r\n          [\"Cuenta\", \"Denominación\", \"Estado\"],\r\n          ancho\r\n        )\r\n      }\r\n    }\r\n\r\n    /**\r\n     * @description Abre el cátalogo de cuentas de la tabla \"spi_cuentas\"\r\n     * @returns Promise<MCuentaIngresos>\r\n     * @author Carlos Albornoz\r\n     * @params presupuesto: Indica si se a trabajar con estructura de presupuesto o no\r\n     */\r\n    public async openCatalogoCuentasIngreso(\r\n      titulo: string,\r\n      presupuesto: boolean = true,\r\n      ancho: string = \"750px\"\r\n    ): Promise<MCuentaIngresos>{\r\n      let cuentas: MCuentaIngresos[] = [];\r\n      await this.getIncomeAccounts().toPromise().then((res: IResponse) => {\r\n        cuentas = res.data\r\n        cuentas = cuentas.filter(e => {\r\n          return e.estado == \"C\"\r\n        }).map(e => {\r\n          e['provStatus'] = e.estado == \"C\" ? \"Movimientos\" : \"Totalizadora\"\r\n          return e;\r\n        })\r\n      })\r\n      if (presupuesto) {\r\n        return this.openCatalogoDosInputs(\r\n          [\"cuenta\",\"denominacion\",\"estructura\",\"provStatus\"],\r\n          titulo,\r\n          cuentas,\r\n          [{\r\n            placeholder: \"Cuenta\",\r\n            property: \"cuenta\"\r\n          }, {\r\n            placeholder: \"Estructura\",\r\n            property: \"estructura\"\r\n          }],\r\n          [\"Cuenta\", \"Denominación\", \"Estructura\", \"Estado\"],\r\n          ancho\r\n        )\r\n      } else {\r\n        let filteredAccounts: MCuentaIngresos[] = [];\r\n        cuentas.forEach(c => {\r\n          if (!filteredAccounts.find(e => e.cuenta == c.cuenta)) {\r\n            filteredAccounts.push(c)\r\n          }\r\n        })\r\n        return this.openCatalogoGenerico(\r\n          [\"cuenta\",\"denominacion\",\"provStatus\"],\r\n          titulo,\r\n          filteredAccounts,\r\n          [\"Cuenta\", \"Denominación\", \"Estado\"],\r\n          ancho\r\n        )\r\n      }\r\n    }    \r\n\r\n    public getUnidadAdministrativa(tipo?:string){\r\n      return this.http.get(`${this.URL}/dao/spg/unidad_administrativa_dao.php?tipo=${tipo}`,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res:any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MAdministrativeUnit(e));\r\n          }\r\n          return res;\r\n        }) \r\n      )\r\n    }\r\n\r\n    /** \r\n     * @description Obtiene los cargos de servicios\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getServiceCharges(serviceId:number = null): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/soc/servicio_cargo_dao.php${\r\n        serviceId ? `?service_id=${serviceId}` : ''\r\n      }`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MServiceCharge(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n     /** \r\n     * @description Obtiene los paises\r\n     * @return Observable<MCountry>\r\n     * @author Carlos Albornoz\r\n     * @modified 10-01-2022\r\n     * @param codigo: Codigo del pais\r\n\r\n     */\r\n      public getCountries(codigo?:string): Observable<MCountry[]> {\r\n        \r\n        return this.http.get<MCountry>(`${this.URL}/dao/cfg/paises_dao.php?codigo=${codigo}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => res.data.map(e => new MCountry(e)))\r\n        );\r\n      }\r\n  \r\n      /**\r\n       * @description Obtiene los estados\r\n       * @return Observable<MState>\r\n       * @author Carlos Albornoz\r\n       * @modificado 4-12-2022\r\n       * @param codigo: Codigo del pais\r\n       */\r\n      public getStates(codigo?:string): Observable<MState[]> {\r\n        return this.http.get<MState>(`${this.URL}/dao/cfg/estados_dao.php?codigo=${codigo}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => res.data.map(e => new MState(e)))\r\n        );\r\n      }\r\n  \r\n      /**\r\n       * @description Obtiene los municipios\r\n       * @return Observable<MMunicipality>\r\n       * @author Carlos Albornoz\r\n       * @modificado 10-01-2022\r\n       * @param pais: Codigo del pais ,\r\n       * @param estado: Codigo del estado\r\n       * @actualizado 4-12-2022\r\n       */\r\n      public getMunicipalities(pais?:string,estado?:string): Observable<MMunicipality[]> {\r\n        return this.http.get<MMunicipality>(`${this.URL}/dao/cfg/municipios_dao.php?pais=${pais}&estado=${estado}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => res.data.map(e => new MMunicipality(e)))\r\n        );\r\n      }\r\n  \r\n      /**\r\n       * @description Obtiene las parroquias \r\n       * @return Observable<MParish>\r\n       * @author Carlos Albornoz\r\n       * @modificado 10-01-2022\r\n       * @param pais: Codigo del pais\r\n       * @param estado: Codigo del estado\r\n       * @param municipio:codigo Municipio\r\n       * @actualizado 4-12-2022\r\n\r\n       */\r\n      public getParishes(pais?:string,estado?:string,municipio?:string): Observable<MParish[]> {\r\n        return this.http.get<MParish>(`${this.URL}/dao/cfg/parroquias_dao.php?pais=${pais}&estado=${estado}&municipio=${municipio}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => res.data.map(e => new MParish(e)))\r\n        );\r\n      }\r\n  \r\n      /**\r\n       * @description Obtiene las ciudades\r\n       * @return Observable<MParish>\r\n       * @author Carlos Albornoz\r\n       * @modificado 10-01-2022\r\n       * @param pais: Codigo del pais\r\n       * @param estado: Codigo del estado\r\n\r\n\r\n       */\r\n        public getCity(pais?:string,estado?:string): Observable<MCity[]> {\r\n        return this.http.get<MCity>(`${this.URL}/dao/cfg/ciudades_dao.php?pais=${pais}&estado=${estado}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => res.data.map(e => new MCity(e)))\r\n        );\r\n      }\r\n\r\n            /**\r\n       * @description Obtiene las ciudades\r\n       * @return Observable<MParish>\r\n       * @author Dimaly Crespo\r\n       * @modificado 10-01-2022\r\n       * @param pais: Codigo del pais\r\n\r\n       */\r\n        public getCommunities(pais?:string,estado?:string, municipio?:string,parroquia?:string): Observable<MCommunity[]> {\r\n          return this.http.get<MCommunity>(`${this.URL}/dao/cfg/comunidades_dao.php?pais=${pais}&estado=${estado}&municipio=${municipio}&parroquia=${parroquia}`,\r\n          { headers: this.getHttpHeaders() }).pipe(\r\n            retry(3),\r\n            catchError(this.handlerError),\r\n            map((res: any) => res.data.map(e => new MCommunity(e)))\r\n          );\r\n        }\r\n  \r\n    /**\r\n     * @description Obtiene los sistemas activas\r\n     * @return Observable<MSistema>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getSistemas(): Observable<MSistema[]> {\r\n      return this.http.get<MSistema>(`${this.URL}/dao/sss/sistemas_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => res.data.map(e => new MSistema(e)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la moneda actual\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     * @actualizado: 4-12-20222\r\n     * @params id: id de la moneda,\r\n     * @params tipo: todas->obtiene todas las moneda, (uno-> obtiene una moneda + id)\r\n     * (mon:formato para inputCurrency + id )\r\n     */\r\n    public getCurrentCurrency(tipo:'todas'|'uno'|'mon'=null,id?:number): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/cfg/moneda_dao.php?tipo=${tipo}&id=${id}`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = new MMonedaConfig(res.data);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n        /**\r\n     * @description Obtiene la linea empresa\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @actualizado: 5-12-20222\r\n     */\r\n         public getEnterprise(tipo:'linea' |'proceso'|'default'=null ,id?:number): Observable<IResponse> {\r\n          return this.http.get<IResponse>(`${this.URL}/dao/cfg/enterprise_dao.php?tipo=${tipo}`,\r\n          { headers: this.getHttpHeaders() }).pipe(\r\n            retry(3),\r\n            catchError(this.handlerError),\r\n            map((res: any) => {\r\n              if (res.success) {\r\n                res.data = res.data.map(e => new MEnterprise(e));\r\n              }\r\n              return res;\r\n            })\r\n          );\r\n        }\r\n    \r\n\r\n    /**\r\n     * @description Obtiene los tipos de organizacion\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getOrganizationTypes(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/rpc/tipo_organizacion_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MOrganizationType(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los tipos de organizacion\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getSpecialties(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/rpc/especialidad_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MSpecialty(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los documentos\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getDocuments(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/rpc/documento_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MDocument(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene las clasificaciones\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getClasifications(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/rpc/clasificacion_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MClasification(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el prefijo de los usuarios\r\n     * @param procede De que módulo procede\r\n     * @param codsis Código del sistema\r\n     * @return Observable<MUsuarioPrefijo[]>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getUserPrefix(filter: 'detail' = null, code: string = null): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/cfg/control_numero_dao.php${\r\n        filter ? `?filter=${filter}&code=${code}` : ''\r\n      }`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MUsuarioPrefijo(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n\r\n    /**\r\n     * @description Obtiene los pefijo\r\n     * @param procede De que módulo procede\r\n     * @param codsis Código del sistema\r\n     * @return Observable<MUsuarioPrefijo[]>\r\n     * @author DimalyCrespo 17-12-2022\r\n     */\r\n    public getPrefix(filter: 'all' | 'one' = null, code: string = null): Observable<IResponse> {\r\n\r\n      return this.http.get<IResponse>(`${this.URL}/dao/cfg/control_numero_dao.php${\r\n        filter ? `?filter=${filter}&code=${code}` : ''\r\n      }`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MPrefijo(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Abre el dialog para buscar los proveedores\r\n     * @return Promise<MProveedor>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async openDialogProveedores(): Promise<MProveedor> {\r\n      let proveedores: MProveedor[] = await this.getProveedores().toPromise();\r\n      let dialogRef = this.dialog.open(CatalogoComponent, {\r\n        data: {\r\n          columns: ['tipo', 'rif', 'nombre'],\r\n          title: 'Catálogo de Proveedores y Beneficiarios',\r\n          dataSource: proveedores\r\n        } as ICatalogo,\r\n        width: '450px',\r\n        maxHeight: '90vh'\r\n      });\r\n\r\n      return dialogRef.afterClosed().toPromise();\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los proveedores\r\n     * @return Observable<MProveedor[]>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getProveedores(): Observable<MProveedor[]> {\r\n      let request: IRequest = {\r\n        operacion: 'obtenerData',\r\n        sigesp_conexion: {\r\n          servidor: this.URL,\r\n          usuario: this.usuarioActivo.getInterface()\r\n        }\r\n      }\r\n      return this.http.post<MProveedor[]>(`${this.URL}/dao/rpc/proveedor_beneficiario_dao.php`, request).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => res.map(element => new MProveedor(element)))\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los proveedores y beneficiarios\r\n     * @Note Si quiere solo los datos basicos use los parametros ('S','P','N')\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     * @type ={'P','B','S'}\r\n     * @destination ={'P','B','C','A','N'}≈{Proveedor,Beneficiario,Contatista,Ambos,Ninguno}\r\n     * @account ={'S','N'} para traer las cuentas bancarias del proveedor por defecto esta en N\r\n     * @modificado 17-07-2023\r\n     */\r\n\r\n    public getProvidersAndBeneficiaries(type: string ='default', destination:string=null, account:string='N'): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/rpc/proveedor_beneficiario_dao.php${type ? `?provider_type=${type}`  : ''}&destination=${destination}&account=${account}`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MProviderBeneficiary(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n\r\n    /**\r\n     * @description Obtiene un Usuario segun su ID\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getUserById(id: number): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sss/usuario_dao.php?id=${id}`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = new MUsuario(res.data);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los bancos\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getBanks(idEnterprise?:number): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/scb/banco_dao.php?e=${idEnterprise}`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MBank(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los tipos de cuenta bancarias\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getBankAccountTypes(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/scb/banco_tipo_cuenta_dao.php`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MBankAccountType(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n\r\n    /**\r\n     * @description obtiene las cuenta segun el id\r\n     * @param tipo {'banco', 'default'}\r\n     * @param id para la opcion banco usar id=idBanco, opcion defaulf id=idEnterprise\r\n     * @returns \r\n     */\r\n    public getAllBankAccount(tipo:string,id:number){        \r\n      return this.http.get(`${this.URL}/dao/scb/cuenta_banco_dao.php?tipo=${tipo}&e=${id}`,\r\n      {headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res:any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(element => new MCuentaBanco(element));\r\n          } else {\r\n            res.data = [];\r\n          }\r\n          return res\r\n        }) \r\n      )\r\n    } \r\n\r\n    /**\r\n     * @description Obtiene los bancos sigecof\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getSigecofBanks(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sigesp/banco_sigecof_dao.php`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MSigecofBank(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene la configuracion de SOC\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getConfigSOC(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/soc/configuracion_dao.php`, \r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = new MConfigSOC(res.data);\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene los tipos de deduccion\r\n     * @return Observable<IResponse>\r\n     * @author Carlos Albornoz\r\n     */\r\n    public getDeductionTypes(): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/stb/tipo_deduccion_dao.php`,\r\n      { headers: this.getHttpHeaders() }).pipe(\r\n        retry(3),\r\n        catchError(this.handlerError),\r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MDeductionType(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    public getIncomeAccounts(onlyAvailable: boolean = false): Observable<any>{\r\n      return this.http.get(`${this.URL}/dao/spi/cuentas_ingresos_dao.php${\r\n        onlyAvailable ? '?available=true' : ''\r\n      }`, {headers: this.getHttpHeaders()}).pipe(\r\n        map((res:any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MCuentaIngresos(e))\r\n          }\r\n          return res;\r\n        })\r\n      )\r\n    }\r\n\r\n    public getCharges(){\r\n\r\n      return this.http.get<IResponse>(\r\n        `${this.URL}/dao/stb/cargos_dao.php`, \r\n        { headers: this.getHttpHeaders() }\r\n      ).pipe(\r\n        map((res: IResponse) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MCargo(e))\r\n          }\r\n          return res;\r\n        })\r\n      )\r\n  \r\n    }\r\n\r\n    public getDeductions(){\r\n      return this.http.get<IResponse>(\r\n        `${this.URL}/dao/stb/deducciones_dao.php`, \r\n        { headers: this.getHttpHeaders() }\r\n      ).pipe(\r\n        map((res: IResponse) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MDeduction(e))\r\n          }\r\n          return res;\r\n        })\r\n      )  \r\n    }\r\n\r\n    /** \r\n     * @description Obtiene la los datos de Empresa\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * \r\n     */\r\n     public getCompany(tipo?:string,id?:number): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/cfg/empresas_dao.php?tipo=${tipo}&id=${id}`,\r\n      { headers: this.getHttpHeaders() }).pipe(        \r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MEmpresa(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n     /** \r\n     * @description Obtiene los tipos de documentos registrados en CXP\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @date 20-07-2021\r\n     */\r\n      public getTiposDocumetos(): Observable<IResponse> {\r\n        return this.http.get<IResponse>(`${this.URL}/dao/cxp/tipo_documento_dao.php?operacion=${'buscar'}&existen=${'existen'}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MTipoDocumentoCXP(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      }\r\n\r\n     /**\r\n      * @param get toma los valores: [ idOrdenCompra ,'recepcion','existen','codigo', 'ordenesSOC', 'op', 'art' ]\r\n      * @param n codigo Documento Orden, se usa para obtener los detalles de la orden de compra, es obligatorio al combinar con la opcion get: idOrdenCompra\r\n      * @description 'recepcion': Obtine las ordenes de suministro,\r\n      * existe y codigo: Obtiene los codigos registrados, \r\n      * ordenesSOC: obtiene las ordenes de compra,\r\n      * op: obtiene las ordenes pendientes\r\n      * art: obtiene los articulos \r\n      * @return Observable<IResponse>\r\n      * @date 3-10-2021\r\n      * @returns \r\n      */\r\n       public getEntradaSuministros(get:any, n?:string): Observable<IResponse> {\r\n        return this.http.get<IResponse>(`${this.URL}/dao/siv/entrada_suministro_dao.php?get=${get}&n=${n}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n              res.data = res.data.map(e => new MEntradaSuministros(e))\r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      }\r\n    /** \r\n     * @description Obtiene los tipos de documentos registrados en CXP\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @date 20-07-2021\r\n     */\r\n\r\n      public getConceptosCxP(){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/cxp/concepto_dao.php?operacion=${'buscar'}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MConceptosCXP(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      }\r\n\r\n       /** \r\n     * @description Obtiene los los conceptos Retencion ISRL\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @date 26-07-2021\r\n     */\r\n\r\n        public getConceptosRetencion(){\r\n          return this.http.get<IResponse>(`${this.URL}/dao/stb/deducciones_dao.php?code=${'conceptos'}`,\r\n          { headers: this.getHttpHeaders() }).pipe(\r\n            retry(3),\r\n            catchError(this.handlerError),\r\n            map((res: any) => {\r\n              if (res.success) {            \r\n                  res.data = res.data.map(e => new MConceptoRetencion(e));              \r\n              }\r\n              return res;\r\n            })\r\n          );\r\n        }\r\n\r\n     /** \r\n     * @description Obtiene la configuración de RRHH y de SNO\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     */\r\n      public obtenerConfiguracionSNO(){\r\n      \r\n        return this.http.get<IResponse>(`${this.URL}/dao/sno/configuracion_dao.php?tipo=${'configuracion'}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) { \r\n                if (res.data.length>0){\r\n                  res.data = res.data.map(e => new MConfiguracionSNO(e));  \r\n                }        \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n          \r\n      }\r\n\r\n     /**\r\n      * \r\n      * @param tipo ['default', 'uno', 'cargos'] dafault:Todas las nominas, uno: una nomina, 'cargos': nominas por cargos\r\n      * @param id :id de la nomina. Campo requerido para uno y cargos\r\n      * @returns array()      \r\n      * @description Obtiene las nominas registradas\r\n      * @return Observable<IResponse>\r\n      * @date 20-10-21\r\n      *\r\n     */     \r\n\r\n       public getNomina(tipo:string,id?:number){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/sno/definicion_nomina_dao.php?tipo=${tipo}&id=${id}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MDefinicionNomina(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      }\r\n\r\n   /**\r\n    * @description Obtiene los cargos de las nomina\r\n    * @param tipo ['codigo','default'] ->codigo: obtiene el proximo codigo. ->default: obtiene todos los cargos de la nomina\r\n    * @param id id de la nomina\r\n    * @returns array()\r\n    */\r\n      public getCargosNomina(tipo:string,id?:number){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/sno/asignacion_cargos_dao.php?tipo=${tipo}&id=${id}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MAsignacionCargo(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      }  \r\n      \r\n      /**\r\n     * @description Obtiene un personal de la nómina\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     */\r\n       public getPersonalSRH(tipo:string,id?:number){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/sno/personal_dao.php?tipo=${tipo}&id=${id}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MPersonal(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      } \r\n\r\n      /**\r\n     * @description Obtiene las agencia de banco\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     */\r\n       public getAgenciaBanco(tipo:string,id?:number){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/scb/agencia_dao.php?code=${tipo}&id=${id}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MAgenciaBanco(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      } \r\n\r\n    /**\r\n     * @description Obtiene la hojas de tiempo\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     */\r\n           public getHojaTiempo(tipo:string,idPersonal?:number,idNomina?:number){\r\n            return this.http.get<IResponse>(`${this.URL}/dao/sno/hoja_tiempo_dao.php?idPersonal=${idPersonal}&idNomina=${idNomina}`,\r\n            { headers: this.getHttpHeaders() }).pipe(\r\n              retry(3),\r\n              catchError(this.handlerError),\r\n              map((res: any) => {\r\n                if (res.success) {            \r\n                    res.data = res.data.map(e => new MHojaTiempo(e));              \r\n                }\r\n                return res;\r\n              })\r\n            );\r\n          }         \r\n         \r\n    /**\r\n     * @description Obtiene los clientes \r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @tipo [basico,codigo,cedula]\r\n     * \r\n     */\r\n\r\n    public getCliente(tipo: string ='default', id:number=0, codigo:string='', cedula:string=''): Observable<IResponse> {\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sfv/client_dao.php?tipo=${tipo}&id=${id}&codigo=${codigo}&cedrifcli=${cedula}`, \r\n      { headers: this.getHttpHeaders() }).pipe(       \r\n        map((res: any) => {\r\n          if (res.success) {\r\n            res.data = res.data.map(e => new MClient(e));\r\n          }\r\n          return res;\r\n        })\r\n      );\r\n    }\r\n\r\n    /**\r\n     * @description Valida si la fecha esta dentro del periodo fiscal y el mes esta abierto o cerrado\r\n     * @return Observable<IResponse>\r\n     * @author Dimaly Crespo\r\n     * @author 11-10-2023\r\n     */\r\n       public getValidarPeriodo(fecha:string, periodoFiscal:string){\r\n        return this.http.get<IResponse>(`${this.URL}/dao/scg/configuracion_contabilidad_dao.php?fecha=${fecha}&periodo=${periodoFiscal}`,\r\n        { headers: this.getHttpHeaders() }).pipe(map((res: any) => { return res;}));\r\n      } \r\n      \r\n\r\n    \r\n  \r\n\r\n\r\n    public userHasRights(column:'administrador' | 'insertar' | 'actualizar' | 'consultar' \r\n    | 'eliminar' | 'anular' |'descargar' | 'ejecutar__procesar_' | 'imprimir' \r\n    | 'enviar__correo_' | 'visible'){\r\n\r\n      return this.http.get<IResponse>(\r\n        `${this.URL}/dao/sss/derechos_usuario_dao.php?idComponent=${\r\n          this.currentComponent.id\r\n        }&column=${column}`, \r\n        { headers: this.getHttpHeaders() }\r\n      )\r\n\r\n    }\r\n\r\n   /**\r\n     * @description Retorna los headers para hacer las peticiones\r\n     * @params type: Tipo MIME permitido por defecto se toma application/json\r\n     * @return HttpHeaders\r\n     * @author Miguel Ramírez\r\n     * @date-update: 15-06-2022 \r\n     */\r\n    public getHttpHeaders(type?:string): HttpHeaders { \r\n      !type? type='application/json':'';      \r\n      const headers = new HttpHeaders({\r\n        'Content-Type': type,\r\n        'Authorization': `${this.usuarioActivo.token}`\r\n      });\r\n      return headers;\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el servidor guardado en el sessionStorage\r\n     * @return string\r\n     * @author Miguel Ramírez\r\n     */\r\n    public getServer(): string {\r\n      return this.URL;\r\n    }\r\n\r\n    /**\r\n     * @description Obtiene el usuario guardado en el sessionStorage\r\n     * @return MUsuario\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async getUser() {\r\n      let conexion: IConexion = await (sessionStorage.getItem('user')) ? JSON.parse(atob(sessionStorage.getItem('user'))) : null;\r\n      //console.log(conexion)\r\n      // debugger\r\n      if (conexion) {\r\n        this.usuarioActivo = new MUsuario(conexion.usuario);\r\n        this.URL = conexion.servidor;\r\n      }\r\n\r\n    }\r\n\r\n    /**\r\n     * @description Muestra un toast de success\r\n     * @param message Mensaje que se va a mostrar\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public showToastSuccess(message: string): void {\r\n      this.toast.success(message);\r\n    }\r\n\r\n    /**\r\n     * @description Muestra un toast de error\r\n     * @param message Mensaje que se va a mostrar\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public showToastError(message: string): void {\r\n      this.toast.error(message);\r\n    }\r\n\r\n      /**\r\n     * @description Muestra un sweetalert2 de éxito\r\n     * @param message Mensaje que se va a mostrar\r\n     * @return void\r\n     * @date 22-11-2021\r\n     */\r\n       public showToastSuccessSwal(message: string): void {\r\n        Swal.fire({\r\n          icon: 'success',\r\n          title: 'Éxito',\r\n          text: message,  \r\n        })\r\n      }\r\n\r\n      \r\n\r\n     /**\r\n     * @description Muestra un sweetalert2 de error\r\n     * @param message Mensaje que se va a mostrar\r\n     * @return void\r\n     * @date 22-11-2021\r\n     */\r\n    public showToastErrorSwal(message: string): void {\r\n      Swal.fire({\r\n        icon: 'error',\r\n        title: '¡Error!',\r\n        text: message,  \r\n             \r\n      })\r\n    }\r\n\r\n    /**\r\n     * @description Guarda el usuario logueado en el SessionStorage\r\n     * @param user Usuario que se va a guardar en el SessionStorage\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public saveUser(data: IConexion): void {\r\n      this.usuarioActivo = new MUsuario(data.usuario);\r\n      this.URL = data.servidor;\r\n      let encryptedUser: string = btoa(JSON.stringify(data));\r\n      sessionStorage.setItem('user', encryptedUser);\r\n    }\r\n\r\n    /**\r\n     * @description Sete a la url a la cual se le van a realizar peticiones al backEnd\r\n     * @param url URl donde se van a realizar las peticiones\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public setUrl(url: string): void {\r\n      this.URL = url;\r\n    }\r\n\r\n    /**\r\n     * @description Inicializa el servicio de sigesp\r\n     * @return void\r\n     * @author Miguel Ramírez\r\n     */\r\n    public init(): void {\r\n      // Verificamos si hay un usuario en la sessionStorage, esto es necesario para recargar la página\r\n      if (sessionStorage.getItem('user')) {\r\n        // console.log(sessionStorage.getItem('user'))\r\n        this.getUser();\r\n      }\r\n    }\r\n\r\n    /**\r\n     * @description Verifica si un usuario está logueado\r\n     * @return Promise<boolean>\r\n     * @author Miguel Ramírez\r\n     */\r\n    public async isLogged(): Promise<boolean> {\r\n      return new Promise((resolve, reject) => {\r\n        if (sessionStorage.getItem('user')) {\r\n          resolve(true)\r\n        } else {\r\n          resolve(false)\r\n        }\r\n      })\r\n    }\r\n\r\n    private handlerError(error: HttpErrorResponse): any {\r\n      return throwError('Ocurrió un error')\r\n    }\r\n\r\n      /**\r\n     * @description obtiene el personal segun filtro\r\n     * @return Observable<IResponse>\r\n     * @date 15-11-2021\r\n     * @param tipo: valores ['catalogo','catalogoSno','default','nomina','responsables']\r\n     * @params dato:object {nombre:string, apellido:string, cedula.string} use para la opcion 'catalogo' o 'catalogoSno'\r\n     */\r\n       public getPersonal(tipo:string, dato?:any){\r\n          let cedula='';\r\n          let nombre='';\r\n          let apellido='';\r\n          let idEnterprise=0;\r\n        if(dato){\r\n          cedula=dato.cedula\r\n          nombre=dato.nombre\r\n          apellido=dato.apellido\r\n          idEnterprise=dato.idEnterprise\r\n        }        \r\n        return this.http.get<IResponse>(`${this.URL}/dao/sno/personal_dao.php?tipo=${tipo}&cedula=${cedula}&nombre=${nombre}&apellido=${apellido}&e=${idEnterprise}`,\r\n        { headers: this.getHttpHeaders() }).pipe(\r\n          retry(3),\r\n          catchError(this.handlerError),\r\n          map((res: any) => {\r\n            if (res.success) {            \r\n                res.data = res.data.map(e => new MPersonal(e));              \r\n            }\r\n            return res;\r\n          })\r\n        );\r\n      } \r\n\r\n      /**\r\n     * @description obtener personal Nomina segun filtro\r\n     * @return Observable<IResponse>\r\n     * @date 15-11-2021\r\n     * * @param tipo: valores ['catalogo','default','nomina']\r\n     * @params dato:object {nombre:string, apellido:string, cedula.string} use para la opcion 'catalogo'\r\n\r\n     */\r\n        public getPersonalNomina(tipo:string,dato?:any){\r\n          let cedula='';\r\n          let nombre='';\r\n          let apellido='';\r\n          let idEnterprise=0;\r\n          let idNomina=0;\r\n        if(dato){\r\n          cedula=dato.cedula\r\n          nombre=dato.nombre\r\n          apellido=dato.apellido\r\n          idEnterprise=dato.idEnterprise\r\n          idNomina=dato.idNomina\r\n        }        \r\n          return this.http.get<IResponse>(`${this.URL}/dao/sno/asignacion_personal_nomina_dao.php?\r\n          tipo=${tipo}&cedula=${cedula}&nombre=${nombre}&apellido=${apellido}&idNomina=${idNomina}&idEnterprise=${idEnterprise}`,\r\n          { headers: this.getHttpHeaders() }).pipe(           \r\n            map((res: any) => {\r\n              if (res.success) {            \r\n                  res.data = res.data.map(e => new MPersonalNomina(e));              \r\n              }\r\n              return res;\r\n            })\r\n          );\r\n        }\r\n\r\n\r\n  /**\r\n   * @param idPersonal: id del personal\r\n   * @param tipo: valores['nomina_personal'] \r\n   * @description Obtiene las nominas del personal resumida\r\n   * @deprecated; 20-01-22\r\n   * @returns \r\n   */\r\n  \r\n  public getPersonalNominaResumida(idPersonal:number,tipo:string){\r\n      return this.http.get<IResponse>(`${this.URL}/dao/sno/personal_dao.php?idPersonal=${idPersonal}&tipo=${tipo}`,\r\n      { headers: this.getHttpHeaders() }).pipe(       \r\n        map((res: any) => {\r\n          if (res.success) {            \r\n              res.data = res.data.map(e => new MNominaSimple(e));              \r\n          }\r\n          return res;\r\n        })\r\n      );\r\n  }\r\n\r\n       /**\r\n       * @description Obtiene el Json Sistemas para el usuario definido segun su permisologia del Sistema\r\n       * @return Json data\r\n       * @author Ing. Dimaly Crespo\r\n       */\r\n       public getPerfilSistema(id_usuario:number ){\r\n        return this.http.get(`${this.URL}/dao/sss/usuarios_sistemas_dao.php?id_usuario=${id_usuario}`,\r\n        { headers: this.getHttpHeaders() }).pipe(          \r\n          map((res: any) => { \r\n            if(res.data.length>0){\r\n              res.data = res.data.map(e => new MUsuarioSistema(e));  \r\n            }\r\n            return res;     \r\n           })\r\n          \r\n        );\r\n      \r\n   }\r\n\r\n  \r\n       /**\r\n       * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema\r\n       * @return Json data\r\n       * @author Ing. Wilmer Briceno\r\n       */\r\n          public getPerfilNoComponent(id_usuario:number,sistema:string, nameComponent: string ){\r\n            return this.http.get(`${this.URL}/dao/sss/derechos_usuario_dao.php?id_usuario=${id_usuario}&sistema=${sistema}&namecomponent=${nameComponent}`,\r\n            { headers: this.getHttpHeaders() }).pipe(          \r\n              map((res: any) => { \r\n                 return res;\r\n               })\r\n            );\r\n          \r\n       }\r\n  \r\n       /**\r\n       * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema\r\n       * @return Json data\r\n       * @author Ing. Wilmer Briceno\r\n       */\r\n        public getJsonMenu(id_usuario:number,sistema:string){\r\n          return this.http.get(`${this.URL}/dao/sss/menu_dao.php?id_usuario=${id_usuario}&sistema=${sistema}`,\r\n          { headers: this.getHttpHeaders() }).pipe(          \r\n            map((res: any) => { \r\n               this.userMenu = res.data;\r\n               return this.userMenu;\r\n             })\r\n          );\r\n        \r\n        }\r\n\r\n         /**\r\n      * @description Obtiene el Json Menu para el usuario definido segun su permisologia del Sistema\r\n      * @return Json data\r\n      * @author Ing. Wilmer Briceno\r\n      */\r\n      public log(body: MLog ){  \r\n\r\n        return this.http.post(`${this.URL}/dao/sss/log_dao.php`, body , {\r\n              headers: this.getHttpHeaders()\r\n        }).pipe(  \r\n          map((res: any) => {  \r\n                  \r\n              return res;\r\n          })\r\n        )\r\n    \r\n    }\r\n\r\n  \r\n        \r\n   /**\r\n    * @name EncryptData\r\n    * @description Enscripta una expresion data\r\n    * @author Ing. Wilmer Briceño\r\n    */\r\n    public EncryptData( expresion : string){\r\n       const key = CryptoJS.enc.Utf8.parse (\"0123456789SIGESP\"); // número hexadecimal de 16 dígitos como clave\r\n       const iv = CryptoJS.enc.Utf8.parse ('SIGESP0123456789'); // Número hexadecimal como desplazamiento de clave\r\n       let srcs = CryptoJS.enc.Utf8.parse(expresion);\r\n       let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });\r\n       return encrypted.ciphertext.toString().toUpperCase();\r\n    }\r\n \r\n    /**\r\n    * @name DecryptData\r\n    * @description Desencripta una expresion data\r\n    * @author Ing. Wilmer Briceño\r\n    */\r\n    public DecryptData( expresion : string){\r\n       const key = CryptoJS.enc.Utf8.parse (\"0123456789SIGESP\"); // número hexadecimal de 16 dígitos como clave\r\n       const iv = CryptoJS.enc.Utf8.parse ('SIGESP0123456789'); // Número hexadecimal como desplazamiento de clave\r\n       let encryptedHexStr = CryptoJS.enc.Hex.parse(expresion);\r\n       let srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);\r\n       let decrypt = CryptoJS.AES.decrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });\r\n       let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\r\n       return decryptedStr.toString();\r\n    }\r\n \r\n \r\n    /**\r\n    * @name getResponsePerfilToolbar\r\n    * @description Metodo que obtiene una respuesta true o false basado en una estructura sring binanria segun \r\n    *              la posicion dada del toolbar. se pasa string binario que contiene 1 y 0 en representacion \r\n    *              de las propiestades administrador,consultar,ejecutar,imprimir etc ... cada posicion secuencial \r\n    *              si esta en 1 es true y 0 en false y devuleve el valor segun lo requiera el usuario:\r\n    *              stringbinario : '1011' y posicion es 2, por tanto se tare 0 y es false que representa opcion consultar.\r\n    *              Estructura string binario:\r\n    *              Posición :\r\n    *              0.  Administrador        6.  Descargar      12. Reversar aprobar      18. Reversar anular contabilizado\r\n    *              1.  insertar             7.  Ejecutar       13. Anular.\r\n    *              2.  Actualizar           8.  Enviar         14. reversar anular\r\n    *              3.  consultar            9. Imprimir        15. contabilizar\r\n    *              4.  Eliminar             10. Visible        16. reversar contabilizar\r\n    *              5.  Anular               11. Aprobar        17. anular contabilizado       \r\n    *                           \r\n    * @author Ing. Wilmer Briceño\r\n    */\r\n     public getResponsePerfilToolbar( stringbinario : string, position : number ){\r\n          let binario = stringbinario.substring(position,position+1) ;\r\n          if (binario==\"1\"){\r\n              return true; \r\n          }   \r\n          return false; \r\n     }\r\n\r\n /**\r\n    * @description Obtiene el Ip del cliente\r\n    * @return Json data\r\n    * @author Ing. Wilmer Briceno\r\n    */\r\n  public getIPAddress(){  \r\n\r\n    return this.http.get(\"http://api.ipify.org/?format=json\") \r\n    .pipe(\r\n      catchError((err) => {\r\n        console.log('error caught in service')\r\n        console.error(err);\r\n        sessionStorage.setItem('ip_adress', '127.0.0.1');\r\n        //Handle the error here\r\n\r\n        return throwError(err);    //Rethrow it back to component\r\n      })\r\n    );\r\n    \r\n  }\r\n /**\r\n  * @description Obtiene el Ip del cliente\r\n  * @return Json data\r\n  * @author Ing. Wilmer Briceno\r\n  */\r\n  public setIpAdress(){\r\n    this.getIPAddress().subscribe( (resp: any)   => {\r\n         sessionStorage.setItem('ip_adress', resp.ip);\r\n         this.ip_adress = resp.ip;\r\n    });  \r\n  } \r\n /**\r\n  * @description Obtiene el Ip del cliente\r\n  * @return Json data\r\n  * @author Ing. Wilmer Briceno\r\n  */\r\n  public getIpAdress(){\r\n    this.ip_adress = sessionStorage.getItem('ip_adress');  \r\n  } \r\n\r\n   /**\r\n  * @description Obtiene el Ip del cliente\r\n  * @return Json data\r\n  * @dia 19-05-2022\r\n  */  \r\n\r\n    public createAuditoria(sno:MSnoLog[]){\r\n      let body=[];\r\n      sno.forEach(e=> {body.push(e.dataInteface())});\r\n      return this.http.post<IResponse>(`${this.URL}/dao/sno/seguridad_dao.php?`,body,\r\n      { headers: this.getHttpHeaders()})\r\n      .pipe(\r\n        map((res: any) => {return res;})\r\n      );\r\n    }  \r\n\r\n /**  \r\n  * @description Obtiene los tipos de depositos  * \r\n  * @param procede : procede del modulo\r\n  * @param idArticulo : id del articulo\r\n  * @param idUsuario : id usuario permitido\r\n  * @returns \r\n  * @author Javier Tovar\r\n  * @date 23-11-2022\r\n  */      \r\n  public getDepositType(procede:string,idArticulo:number,idUsuario?:number){\r\n    return this.http.get<IResponse>(`${this.URL}/dao/siv/catalogo_parametrizado_dao.php?get=${procede}&id=${idArticulo}&i=${idUsuario}`,\r\n    { headers: this.getHttpHeaders() }).pipe(     \r\n      map((res: any) => {\r\n        if (res.success) {            \r\n            res.data = res.data.map(e => new MTipoDepositos(e));              \r\n        }\r\n        return res;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**  \r\n  * @description Obtiene Cargos Adicionales  * \r\n  * @param tipo : one,default\r\n  * @param id : id del cargo \r\n  * @returns \r\n  * @author Dimaly Crespo\r\n  * @date 13-11-2022\r\n  */      \r\n  public getCargosAdicionales(tipo:string,id?:number){\r\n    return this.http.get<IResponse>(`${this.URL}/dao/stb/cargos_adicionales_dao.php?tipo=${tipo}&id=${id}`,\r\n    { headers: this.getHttpHeaders() }).pipe(    \r\n      map((res: any) => {\r\n        if (res.success) {            \r\n            res.data = res.data.map(e => new MCargosAdicionales(e));              \r\n        }\r\n        return res;\r\n      })\r\n    );\r\n  }\r\n\r\n\r\n\r\n        \r\n}\r\n\r\n  \r\ninterface filtroCuentasPresupuesto {\r\n  tipo?: 'E' | 'R',\r\n  estado?: 'C' | 'S'\r\n}\r\n\r\n\r\n"]}