ng-pli-commons 1.0.135 → 1.0.137

package/esm2022/lib/services/committee-snapshot.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable, Inject } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CommitteeSnapshotService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+    }
+    getSnapshotMetadata(committeeId, segmentation, aggrupation) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getSnapshotMetadata?committeeId=${committeeId}&segmentation=${segmentation}&aggrupation=${aggrupation}`);
+    }
+    getSnapshotMetadataFindOne(committeeId) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getSnapshotMetadataFindOne?committeeId=${committeeId}`);
+    }
+    getListByPromCode(promCodigo) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getListByPromCode?promCodigo=${promCodigo}`);
+    }
+    getAll() {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getAll`);
+    }
+    getById(id) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getById?id=${id}`);
+    }
+    getByName(name) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getByName?name=${name}`);
+    }
+    getByPromCode(promCodigo) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getByPromCode?promCodigo=${promCodigo}`);
+    }
+    getByCommitteeId(committeeId) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getByCommitteeId?committeeId=${committeeId}`);
+    }
+    getByCommitteeType(committeeType) {
+        return this.httpClient.get(`${this.environment.host.backend.backoffice}committee-snapshot/getByCommitteeType?committeeType=${committeeType}`);
+    }
+    save(cs) {
+        return this.httpClient.post(`${this.environment.host.backend.backoffice}committee-snapshot/save`, cs);
+    }
+    deleteByName(name) {
+        return this.httpClient.delete(`${this.environment.host.backend.backoffice}committee-snapshot/deleteByName?name=${name}`);
+    }
+    deleteByPromCode(promCodigo) {
+        return this.httpClient.delete(`${this.environment.host.backend.backoffice}committee-snapshot/deleteByPromCode?promCodigo=${promCodigo}`);
+    }
+    deleteByCommitteeId(committeeId) {
+        return this.httpClient.delete(`${this.environment.host.backend.backoffice}committee-snapshot/deleteByCommitteeId?committeeId=${committeeId}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommitteeSnapshotService, deps: [{ token: 'environment' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommitteeSnapshotService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommitteeSnapshotService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/common-info.service.mjs

@@ -0,0 +1,51 @@
+import { Injectable, Inject } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CommonInfoService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+    }
+    /**
+     * Get properties info
+     */
+    getBackofficePropertyNames() {
+        return this.httpClient.get(this.environment.host.backend.backoffice + 'common-info/getPropertyNames');
+    }
+    /**
+     * Get properties info
+     */
+    getConfigurationPropertyNames() {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'common-info/getPropertyNames');
+    }
+    /**
+     * Get properties info
+     */
+    getFrontofficePropertyNames() {
+        return this.httpClient.get(this.environment.host.backend.frontoffice + 'common-info/getPropertyNames');
+    }
+    /**
+     * Get properties info
+     */
+    getSegmentationPropertyNames() {
+        return this.httpClient.get(this.environment.host.backend.segmentation + 'common-info/getPropertyNames');
+    }
+    /**
+     * Get properties info
+     */
+    getCommunicationPropertyNames() {
+        return this.httpClient.get(this.environment.host.backend.communication + 'common-info/getPropertyNames');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonInfoService, deps: [{ token: 'environment' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonInfoService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonInfoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/common.service.mjs

@@ -0,0 +1,285 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpParams, HttpHeaders } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { Moneda, Rubro, TasaCambio, DateUtil, Proceso } from 'ng-pli-util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./tasa.cambio.service";
+export class CommonService {
+    constructor(environment, httpClient, tasaCambioService) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.tasaCambioService = tasaCambioService;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+        /** Notify when the currencies info change */
+        this.currencyChanged = new BehaviorSubject(undefined);
+        /** Notify when the categories info change */
+        this.categoryChanged = new BehaviorSubject(undefined);
+        /** Notify when the exchange rate info change */
+        this.exchangeRateChanged = new BehaviorSubject(undefined);
+        /** Notify when the idioma has changed */
+        this.languageChanged = new BehaviorSubject(undefined);
+        /** Notify when the process info change */
+        this.processChanged = new BehaviorSubject(undefined);
+        this.initValues();
+    }
+    /**  It has an observable to notify if the language is changed */
+    onLanguageChanged() {
+        return this.languageChanged.asObservable();
+    }
+    /**  It has an observable to notify if the cateogry is changed */
+    onCurrencyChanged() {
+        return this.currencyChanged.asObservable();
+    }
+    /**  It has an observable to notify if the category is changed */
+    onCategoryChanged() {
+        return this.categoryChanged.asObservable();
+    }
+    /**  It has an observable to notify if the exchange rate is changed */
+    onExchangeRateChanged() {
+        return this.exchangeRateChanged.asObservable();
+    }
+    /**  It has an observable to notify if the list of process is changed */
+    onProcessChanged() {
+        return this.processChanged.asObservable();
+    }
+    /**
+     * Search the info of the variables, first try to search in the local storage,
+     * if not find info, get the info from the services
+     */
+    initValues() {
+        this.searchLCurrency();
+        this.searchLCategory();
+        this.searchLExchangeRate();
+        this.searchLLanguage();
+        this.searchLProcess();
+    }
+    /**
+     * Remove all variables of the local storage
+     */
+    reloadValues() {
+        localStorage.removeItem('lCurrency');
+        localStorage.removeItem('lCategory');
+        localStorage.removeItem('lExchangeRate');
+        localStorage.removeItem('lLanguage');
+        localStorage.removeItem('lProcess');
+    }
+    /** Search list of currencies */
+    getLanguages() {
+        this.httpClient
+            .get(this.environment.host.backend.plis + 'idioma/getAll')
+            .subscribe((lLanguage) => {
+            this.setLLanguage(lLanguage);
+        }, (error) => {
+            console.error('Error - getListCurrencies -El sistema no responde', error);
+        });
+    }
+    /** Search list of currencies */
+    getCurrencies() {
+        this.httpClient
+            .get(this.environment.host.backend.plis + 'moneda/getAll')
+            .subscribe((lCurrency) => {
+            this.setLCurrencies(lCurrency);
+        }, (error) => {
+            console.error('Error - getListCurrencies -El sistema no responde', error);
+        });
+    }
+    /** Search list of categories */
+    getCategories() {
+        this.httpClient
+            .get(this.environment.host.backend.plis + 'rubro/getAll', {
+            params: new HttpParams().set('cargarListas', 'true')
+        })
+            .subscribe((lCategory) => {
+            this.setLCategory(lCategory);
+        }, (error) => {
+            console.error('Error - getCategories -El sistema no responde', error);
+        });
+    }
+    /** Search list of exchange rates */
+    getExchangeRate(date) {
+        this.tasaCambioService.getAllTasaCambioLightInDate(date).subscribe((lExchangeRate) => {
+            this.setLExchangeRate(lExchangeRate);
+        }, (error) => {
+            console.error('Error - getExchangeRate -El sistema no responde', error);
+        });
+    }
+    /** Search list of exchange rates */
+    getProcess() {
+        this.httpClient
+            .get(this.environment.host.backend.plis + 'common/getAllProcesos')
+            .subscribe((lProcess) => {
+            this.setLProcess(lProcess);
+        }, (error) => {
+            console.error('Error - getProcess -El sistema no responde', error);
+        });
+    }
+    setLCurrencies(lCurrency) {
+        for (let key in lCurrency) {
+            let currency = Object.assign(new Moneda(), lCurrency[key]);
+            lCurrency[key] = currency;
+        }
+        this.lCurrency = lCurrency;
+        let lCurrencySlice = this.lCurrency.slice();
+        localStorage.setItem('lCurrency', JSON.stringify(lCurrencySlice));
+        this.currencyChanged.next(lCurrencySlice);
+    }
+    setLCategory(lCategory) {
+        for (let key in lCategory) {
+            let category = Object.assign(new Rubro(), lCategory[key]);
+            lCategory[key] = category;
+        }
+        this.lCategory = lCategory;
+        let lCategorySlice = this.lCategory.slice();
+        localStorage.setItem('lCategory', JSON.stringify(lCategorySlice));
+        this.categoryChanged.next(lCategorySlice);
+    }
+    setLLanguage(lLanguage) {
+        this.lLanguage = lLanguage;
+        let lLanguageSlice = this.lLanguage ? this.lLanguage.slice() : this.lLanguage;
+        localStorage.setItem('lLanguage', JSON.stringify(lLanguageSlice));
+        this.languageChanged.next(lLanguageSlice);
+    }
+    setLExchangeRate(lExchangeRate) {
+        for (let key in lExchangeRate) {
+            let exchangeRate = Object.assign(new TasaCambio(), lExchangeRate[key]);
+            lExchangeRate[key] = exchangeRate;
+        }
+        this.lExchangeRate = lExchangeRate;
+        let lExchangeRateSlice = this.lExchangeRate
+            ? this.lExchangeRate.slice()
+            : this.lExchangeRate;
+        localStorage.setItem('lExchangeRate', JSON.stringify(lExchangeRateSlice));
+        this.exchangeRateChanged.next(lExchangeRateSlice);
+    }
+    setLProcess(lProcess) {
+        for (let key in lProcess) {
+            let process = Object.assign(new Proceso(), lProcess[key]);
+            lProcess[key] = process;
+        }
+        this.lProcess = lProcess;
+        let lProcessSlice = this.lProcess ? this.lProcess.slice() : this.lProcess;
+        localStorage.setItem('lProcess', JSON.stringify(lProcessSlice));
+        this.processChanged.next(lProcessSlice);
+    }
+    searchLCurrency() {
+        let lCurrency = localStorage.getItem('lCurrency');
+        if (!lCurrency || lCurrency === 'undefined') {
+            this.getCurrencies();
+        }
+        else {
+            this.setLCurrencies(JSON.parse(lCurrency));
+        }
+    }
+    searchLLanguage() {
+        let lLanguage = localStorage.getItem('lLanguage');
+        if (!lLanguage || lLanguage === 'undefined') {
+            this.getLanguages();
+        }
+        else {
+            this.setLLanguage(JSON.parse(lLanguage));
+        }
+    }
+    searchLCategory() {
+        let lCategory = localStorage.getItem('lCategory');
+        if (!lCategory || lCategory === 'undefined') {
+            this.getCategories();
+        }
+        else {
+            this.setLCategory(JSON.parse(lCategory));
+        }
+    }
+    searchLExchangeRate() {
+        let searchER = false;
+        let searchDate = DateUtil.getMomentTimeZone();
+        // let searchDay = searchDate.date();
+        let lExchangeRateString = localStorage.getItem('lExchangeRate');
+        let lExchangeRate = [];
+        if (lExchangeRateString &&
+            lExchangeRateString != 'undefined' &&
+            lExchangeRateString.length > 0) {
+            lExchangeRate = JSON.parse(lExchangeRateString);
+            if (lExchangeRate && lExchangeRate.length > 0) {
+                let dayER = DateUtil.getFormatDateTimeZone(lExchangeRate[0].tcamFecha);
+                if (!DateUtil.isDayEqualString(searchDate.format(), dayER)) {
+                    searchER = true;
+                }
+            }
+        }
+        else {
+            searchER = true;
+        }
+        if (searchER || !lExchangeRate || lExchangeRate.length == 0) {
+            this.getExchangeRate(searchDate.format('YYYY-MM-DD') + ' 00:00:00');
+        }
+        else {
+            this.setLExchangeRate(lExchangeRate);
+        }
+    }
+    searchLProcess() {
+        let lProcess = localStorage.getItem('lProcess');
+        if (!lProcess || lProcess === 'undefined') {
+            this.getProcess();
+        }
+        else {
+            this.setLProcess(JSON.parse(lProcess));
+        }
+    }
+    /**
+     * It returns
+     * @param html
+     */
+    getBase64Pdf(requestPdf) {
+        return this.httpClient.post(this.environment.host.backend.backoffice + 'pdf/getBase64Pdf', requestPdf, this.headerJson);
+    }
+    /**
+     * It returns a pdf
+     * @param lPdfRequest
+     */
+    getBase64PdfList(lPdfRequest) {
+        return this.httpClient.post(this.environment.host.backend.backoffice + 'pdf/getBase64PdfList', lPdfRequest, this.headerJson);
+    }
+    /**
+     * It returns
+     * @param html
+     */
+    getBase64PdfByUrl(urlFile) {
+        return this.httpClient.post(this.environment.host.backend.backoffice + 'pdf/getBase64PdfByUrl', urlFile, this.headerJson);
+    }
+    /**
+     * It returns
+     * @param urlFile
+     */
+    getBase64ImageByUrl(urlFile) {
+        return this.httpClient.post(this.environment.host.backend.backoffice + 'pdf/getBase64ImageByUrl', urlFile, this.headerJson);
+    }
+    /** Get the actual date */
+    getActualDate() {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'configuration/getActualDate');
+    }
+    /** Get the actual date */
+    validateCloseApplicationProcess(promCodigo, appStateId, cnfIniStateId) {
+        let params = new HttpParams()
+            .set('promCodigo', promCodigo.toString())
+            .set('appStateId', appStateId.toString());
+        if (cnfIniStateId != undefined) {
+            params.set('cnfIniStateId', cnfIniStateId.toString());
+        }
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'configuration/validateCloseApplicationProcess', {
+            params
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonService, deps: [{ token: 'environment' }, { token: i1.HttpClient }, { token: i2.TasaCambioService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }, { type: i2.TasaCambioService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.service.js","sourceRoot":"","sources":["../../../../../projects/ng-pli-commons/src/lib/services/common.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { Moneda, Rubro, TasaCambio, DateUtil, Idioma, Proceso, RequestPdf } from 'ng-pli-util';\r\nimport { TasaCambioService } from './tasa.cambio.service';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class CommonService {\r\n\tprivate headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };\r\n\t/** Notify when the currencies info change */\r\n\tcurrencyChanged = new BehaviorSubject<Moneda[]>(undefined);\r\n\t/** List of currency */\r\n\tprivate lCurrency: Moneda[];\r\n\t/** Notify when the categories info change */\r\n\tcategoryChanged = new BehaviorSubject<Rubro[]>(undefined);\r\n\t/** List of currency */\r\n\tprivate lCategory: Rubro[];\r\n\t/** Notify when the exchange rate info change */\r\n\texchangeRateChanged = new BehaviorSubject<TasaCambio[]>(undefined);\r\n\t/** List of exchange rate */\r\n\tprivate lExchangeRate: TasaCambio[];\r\n\t/** Notify when the idioma has changed */\r\n\tlanguageChanged = new BehaviorSubject<Idioma[]>(undefined);\r\n\t/** List of exchange rate */\r\n\tprivate lLanguage: Idioma[];\r\n\t/** Notify when the process info change */\r\n\tprocessChanged = new BehaviorSubject<Proceso[]>(undefined);\r\n\t/** List of process */\r\n\tprivate lProcess: Proceso[];\r\n\r\n\tconstructor(\r\n\t\t@Inject('environment') private environment: any,\r\n\t\tprivate httpClient: HttpClient,\r\n\t\tprivate tasaCambioService: TasaCambioService\r\n\t) {\r\n\t\tthis.initValues();\r\n\t}\r\n\r\n\t/**  It has an observable to notify if the language is changed */\r\n\tonLanguageChanged(): Observable<Idioma[]> {\r\n\t\treturn this.languageChanged.asObservable();\r\n\t}\r\n\r\n\t/**  It has an observable to notify if the cateogry is changed */\r\n\tonCurrencyChanged(): Observable<Moneda[]> {\r\n\t\treturn this.currencyChanged.asObservable();\r\n\t}\r\n\r\n\t/**  It has an observable to notify if the category is changed */\r\n\tonCategoryChanged(): Observable<Rubro[]> {\r\n\t\treturn this.categoryChanged.asObservable();\r\n\t}\r\n\r\n\t/**  It has an observable to notify if the exchange rate is changed */\r\n\tonExchangeRateChanged(): Observable<TasaCambio[]> {\r\n\t\treturn this.exchangeRateChanged.asObservable();\r\n\t}\r\n\r\n\t/**  It has an observable to notify if the list of process is changed */\r\n\tonProcessChanged(): Observable<Proceso[]> {\r\n\t\treturn this.processChanged.asObservable();\r\n\t}\r\n\r\n\t/**\r\n\t * Search the info of the variables, first try to search in the local storage,\r\n\t * if not find info, get the info from the services\r\n\t */\r\n\tinitValues() {\r\n\t\tthis.searchLCurrency();\r\n\t\tthis.searchLCategory();\r\n\t\tthis.searchLExchangeRate();\r\n\t\tthis.searchLLanguage();\r\n\t\tthis.searchLProcess();\r\n\t}\r\n\r\n\t/**\r\n\t * Remove all variables of the local storage\r\n\t */\r\n\treloadValues() {\r\n\t\tlocalStorage.removeItem('lCurrency');\r\n\t\tlocalStorage.removeItem('lCategory');\r\n\t\tlocalStorage.removeItem('lExchangeRate');\r\n\t\tlocalStorage.removeItem('lLanguage');\r\n\t\tlocalStorage.removeItem('lProcess');\r\n\t}\r\n\r\n\t/** Search list of currencies */\r\n\tgetLanguages() {\r\n\t\tthis.httpClient\r\n\t\t\t.get<Idioma[]>(this.environment.host.backend.plis + 'idioma/getAll')\r\n\t\t\t.subscribe(\r\n\t\t\t\t(lLanguage: Idioma[]) => {\r\n\t\t\t\t\tthis.setLLanguage(lLanguage);\r\n\t\t\t\t},\r\n\t\t\t\t(error) => {\r\n\t\t\t\t\tconsole.error('Error - getListCurrencies -El sistema no responde', error);\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t}\r\n\r\n\t/** Search list of currencies */\r\n\tgetCurrencies() {\r\n\t\tthis.httpClient\r\n\t\t\t.get<Moneda[]>(this.environment.host.backend.plis + 'moneda/getAll')\r\n\t\t\t.subscribe(\r\n\t\t\t\t(lCurrency: Moneda[]) => {\r\n\t\t\t\t\tthis.setLCurrencies(lCurrency);\r\n\t\t\t\t},\r\n\t\t\t\t(error) => {\r\n\t\t\t\t\tconsole.error('Error - getListCurrencies -El sistema no responde', error);\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t}\r\n\r\n\t/** Search list of categories */\r\n\tgetCategories() {\r\n\t\tthis.httpClient\r\n\t\t\t.get<Rubro[]>(this.environment.host.backend.plis + 'rubro/getAll', {\r\n\t\t\t\tparams: new HttpParams().set('cargarListas', 'true')\r\n\t\t\t})\r\n\t\t\t.subscribe(\r\n\t\t\t\t(lCategory: Rubro[]) => {\r\n\t\t\t\t\tthis.setLCategory(lCategory);\r\n\t\t\t\t},\r\n\t\t\t\t(error) => {\r\n\t\t\t\t\tconsole.error('Error - getCategories -El sistema no responde', error);\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t}\r\n\r\n\t/** Search list of exchange rates */\r\n\tgetExchangeRate(date: string) {\r\n\t\tthis.tasaCambioService.getAllTasaCambioLightInDate(date).subscribe(\r\n\t\t\t(lExchangeRate: TasaCambio[]) => {\r\n\t\t\t\tthis.setLExchangeRate(lExchangeRate);\r\n\t\t\t},\r\n\t\t\t(error) => {\r\n\t\t\t\tconsole.error('Error - getExchangeRate -El sistema no responde', error);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Search list of exchange rates */\r\n\tgetProcess() {\r\n\t\tthis.httpClient\r\n\t\t\t.get<Proceso[]>(this.environment.host.backend.plis + 'common/getAllProcesos')\r\n\t\t\t.subscribe(\r\n\t\t\t\t(lProcess: Proceso[]) => {\r\n\t\t\t\t\tthis.setLProcess(lProcess);\r\n\t\t\t\t},\r\n\t\t\t\t(error) => {\r\n\t\t\t\t\tconsole.error('Error - getProcess -El sistema no responde', error);\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t}\r\n\r\n\tsetLCurrencies(lCurrency: Moneda[]) {\r\n\t\tfor (let key in lCurrency) {\r\n\t\t\tlet currency: Moneda = Object.assign(new Moneda(), lCurrency[key]);\r\n\t\t\tlCurrency[key] = currency;\r\n\t\t}\r\n\t\tthis.lCurrency = lCurrency;\r\n\t\tlet lCurrencySlice = this.lCurrency.slice();\r\n\t\tlocalStorage.setItem('lCurrency', JSON.stringify(lCurrencySlice));\r\n\t\tthis.currencyChanged.next(lCurrencySlice);\r\n\t}\r\n\r\n\tsetLCategory(lCategory: Rubro[]) {\r\n\t\tfor (let key in lCategory) {\r\n\t\t\tlet category: Rubro = Object.assign(new Rubro(), lCategory[key]);\r\n\t\t\tlCategory[key] = category;\r\n\t\t}\r\n\t\tthis.lCategory = lCategory;\r\n\t\tlet lCategorySlice = this.lCategory.slice();\r\n\t\tlocalStorage.setItem('lCategory', JSON.stringify(lCategorySlice));\r\n\t\tthis.categoryChanged.next(lCategorySlice);\r\n\t}\r\n\r\n\tsetLLanguage(lLanguage: Idioma[]) {\r\n\t\tthis.lLanguage = lLanguage;\r\n\t\tlet lLanguageSlice = this.lLanguage ? this.lLanguage.slice() : this.lLanguage;\r\n\t\tlocalStorage.setItem('lLanguage', JSON.stringify(lLanguageSlice));\r\n\t\tthis.languageChanged.next(lLanguageSlice);\r\n\t}\r\n\r\n\tsetLExchangeRate(lExchangeRate: TasaCambio[]) {\r\n\t\tfor (let key in lExchangeRate) {\r\n\t\t\tlet exchangeRate: TasaCambio = Object.assign(new TasaCambio(), lExchangeRate[key]);\r\n\t\t\tlExchangeRate[key] = exchangeRate;\r\n\t\t}\r\n\t\tthis.lExchangeRate = lExchangeRate;\r\n\t\tlet lExchangeRateSlice = this.lExchangeRate\r\n\t\t\t? this.lExchangeRate.slice()\r\n\t\t\t: this.lExchangeRate;\r\n\t\tlocalStorage.setItem('lExchangeRate', JSON.stringify(lExchangeRateSlice));\r\n\t\tthis.exchangeRateChanged.next(lExchangeRateSlice);\r\n\t}\r\n\r\n\tsetLProcess(lProcess: Proceso[]) {\r\n\t\tfor (let key in lProcess) {\r\n\t\t\tlet process: Proceso = Object.assign(new Proceso(), lProcess[key]);\r\n\t\t\tlProcess[key] = process;\r\n\t\t}\r\n\t\tthis.lProcess = lProcess;\r\n\t\tlet lProcessSlice = this.lProcess ? this.lProcess.slice() : this.lProcess;\r\n\t\tlocalStorage.setItem('lProcess', JSON.stringify(lProcessSlice));\r\n\t\tthis.processChanged.next(lProcessSlice);\r\n\t}\r\n\r\n\tsearchLCurrency() {\r\n\t\tlet lCurrency = localStorage.getItem('lCurrency');\r\n\t\tif (!lCurrency || lCurrency === 'undefined') {\r\n\t\t\tthis.getCurrencies();\r\n\t\t} else {\r\n\t\t\tthis.setLCurrencies(JSON.parse(lCurrency));\r\n\t\t}\r\n\t}\r\n\r\n\tsearchLLanguage() {\r\n\t\tlet lLanguage = localStorage.getItem('lLanguage');\r\n\t\tif (!lLanguage || lLanguage === 'undefined') {\r\n\t\t\tthis.getLanguages();\r\n\t\t} else {\r\n\t\t\tthis.setLLanguage(JSON.parse(lLanguage));\r\n\t\t}\r\n\t}\r\n\r\n\tsearchLCategory() {\r\n\t\tlet lCategory = localStorage.getItem('lCategory');\r\n\t\tif (!lCategory || lCategory === 'undefined') {\r\n\t\t\tthis.getCategories();\r\n\t\t} else {\r\n\t\t\tthis.setLCategory(JSON.parse(lCategory));\r\n\t\t}\r\n\t}\r\n\r\n\tsearchLExchangeRate() {\r\n\t\tlet searchER: boolean = false;\r\n\t\tlet searchDate = DateUtil.getMomentTimeZone();\r\n\t\t// let searchDay = searchDate.date();\r\n\t\tlet lExchangeRateString: string = localStorage.getItem('lExchangeRate');\r\n\t\tlet lExchangeRate: TasaCambio[] = [];\r\n\t\tif (\r\n\t\t\tlExchangeRateString &&\r\n\t\t\tlExchangeRateString != 'undefined' &&\r\n\t\t\tlExchangeRateString.length > 0\r\n\t\t) {\r\n\t\t\tlExchangeRate = JSON.parse(lExchangeRateString);\r\n\t\t\tif (lExchangeRate && lExchangeRate.length > 0) {\r\n\t\t\t\tlet dayER: string = DateUtil.getFormatDateTimeZone(lExchangeRate[0].tcamFecha);\r\n\t\t\t\tif (!DateUtil.isDayEqualString(searchDate.format(), dayER)) {\r\n\t\t\t\t\tsearchER = true;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tsearchER = true;\r\n\t\t}\r\n\t\tif (searchER || !lExchangeRate || lExchangeRate.length == 0) {\r\n\t\t\tthis.getExchangeRate(searchDate.format('YYYY-MM-DD') + ' 00:00:00');\r\n\t\t} else {\r\n\t\t\tthis.setLExchangeRate(lExchangeRate);\r\n\t\t}\r\n\t}\r\n\r\n\tsearchLProcess() {\r\n\t\tlet lProcess = localStorage.getItem('lProcess');\r\n\t\tif (!lProcess || lProcess === 'undefined') {\r\n\t\t\tthis.getProcess();\r\n\t\t} else {\r\n\t\t\tthis.setLProcess(JSON.parse(lProcess));\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * It returns\r\n\t * @param html\r\n\t */\r\n\tgetBase64Pdf(requestPdf: RequestPdf): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.backoffice + 'pdf/getBase64Pdf',\r\n\t\t\trequestPdf,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * It returns a pdf\r\n\t * @param lPdfRequest\r\n\t */\r\n\tgetBase64PdfList(lPdfRequest: RequestPdf[]): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.backoffice + 'pdf/getBase64PdfList',\r\n\t\t\tlPdfRequest,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * It returns\r\n\t * @param html\r\n\t */\r\n\tgetBase64PdfByUrl(urlFile: string): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.backoffice + 'pdf/getBase64PdfByUrl',\r\n\t\t\turlFile,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * It returns\r\n\t * @param urlFile\r\n\t */\r\n\tgetBase64ImageByUrl(urlFile: string): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.backoffice + 'pdf/getBase64ImageByUrl',\r\n\t\t\turlFile,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/** Get the actual date */\r\n\tgetActualDate(): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'configuration/getActualDate'\r\n\t\t);\r\n\t}\r\n\r\n\t/** Get the actual date */\r\n\tvalidateCloseApplicationProcess(\r\n\t\tpromCodigo: number,\r\n\t\tappStateId: number,\r\n\t\tcnfIniStateId?: number\r\n\t): Observable<any> {\r\n\t\tlet params = new HttpParams()\r\n\t\t\t.set('promCodigo', promCodigo.toString())\r\n\t\t\t.set('appStateId', appStateId.toString());\r\n\t\tif (cnfIniStateId != undefined) {\r\n\t\t\tparams.set('cnfIniStateId', cnfIniStateId.toString());\r\n\t\t}\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'configuration/validateCloseApplicationProcess',\r\n\t\t\t{\r\n\t\t\t\tparams\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n}\r\n"]}