ng-pli-commons 1.0.135 → 1.0.136

package/esm2022/lib/services/pli-cnf-config-minisite.service.mjs

@@ -0,0 +1,90 @@
+import { map } from 'rxjs/operators';
+import { Injectable, Inject } from '@angular/core';
+import { HttpParams, HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfConfigMinisiteService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+    }
+    save(pliCnfConfigMinisite) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'pliCnfConfigMiniSite/save', pliCnfConfigMinisite, this.headerJson);
+    }
+    saveMinisiteData({ configMiniSiteId, searchListId }) {
+        return this.httpClient.post(this.environment.host.backend.segmentation +
+            'PlicSegmentationTableController/saveMinisiteData', { configMiniSiteId, searchListId }, this.headerJson);
+    }
+    saveHeaderFooter(headerFooter) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'pliCnfConfigMiniSite/saveHeaderFooter', headerFooter, this.headerJson);
+    }
+    findById(id) {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findById', {
+            params: new HttpParams().set('id', id.toString())
+        });
+    }
+    findHeaderFooter() {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findHeaderFooter');
+    }
+    findAllByUserId(idUser) {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findAllByUserId', {
+            params: new HttpParams().set('idUser', idUser.toString())
+        });
+    }
+    // findAllByPromCodigo(promCodigo: number): Observable<any> {
+    //   return this.httpClient.get(
+    //     this.environment.host.backend.configuration +
+    //     'pliCnfConfigMiniSite/findAllByPromCodigo',
+    //     {
+    //       params: new HttpParams()
+    //         .set('promCodigo', promCodigo.toString())
+    //     }
+    //   );
+    // }
+    delete(id) {
+        return this.httpClient.delete(`${this.environment.host.backend.configuration}pliCnfConfigMiniSite/delete?id=${id}`);
+    }
+    getDatatableSearchListByDtblSearchListId(dtblSearchListId, type) {
+        return (this.httpClient
+            .get(this.environment.host.backend.configuration +
+            'PliDatatableSearchListController/getDatatableSearchListByDtblSearchListId', {
+            params: new HttpParams()
+                .set('dtblSearchListId', dtblSearchListId)
+                .set('type', type.toString())
+        })
+            // DJ - Committee sorting requirement
+            .pipe(map((lDatatableSearchList) => {
+            lDatatableSearchList.sort((a, b) => {
+                const textA = a['recordSize'];
+                const textB = b['recordSize'];
+                return textA < textB ? 1 : textA > textB ? -1 : 0;
+            });
+            return lDatatableSearchList;
+        })));
+    }
+    getByDataTablesParameters(dataTablesParameters) {
+        return this.httpClient.post(this.environment.host.backend.configuration +
+            'pliCnfConfigMiniSite/getByDataTablesParameters', dataTablesParameters, this.headerJson);
+    }
+    saveAllDatatableSearchList(lDatatableSearchList) {
+        return this.httpClient.post(this.environment.host.backend.configuration +
+            'PliDatatableSearchListController/saveAllDatatableSearchList', lDatatableSearchList, this.headerJson);
+    }
+    getDatatableSearchListById(id) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'PliDatatableSearchListController/getDatatableSearchListById', { params: new HttpParams().set('id', id) });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfConfigMinisiteService, 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: PliCnfConfigMinisiteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfConfigMinisiteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pli-cnf-config-minisite.service.js","sourceRoot":"","sources":["../../../../../projects/ng-pli-commons/src/lib/services/pli-cnf-config-minisite.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { map } from 'rxjs/operators';\r\nimport { Observable } from 'rxjs';\r\nimport { PliCnfConfigMinisite, DatatableSearchList, DataTableParameters } from 'ng-pli-util';\r\nimport { Injectable, Inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class PliCnfConfigMinisiteService {\r\n\tconstructor(@Inject('environment') private environment, private httpClient: HttpClient) {}\r\n\r\n\tprivate headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };\r\n\r\n\tsave(pliCnfConfigMinisite: PliCnfConfigMinisite): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfConfigMiniSite/save',\r\n\t\t\tpliCnfConfigMinisite,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\tsaveMinisiteData({ configMiniSiteId, searchListId }): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.segmentation +\r\n\t\t\t\t'PlicSegmentationTableController/saveMinisiteData',\r\n\t\t\t{ configMiniSiteId, searchListId },\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\tsaveHeaderFooter(headerFooter: any): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfConfigMiniSite/saveHeaderFooter',\r\n\t\t\theaderFooter,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\tfindById(id: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findById',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('id', id.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tfindHeaderFooter(): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findHeaderFooter'\r\n\t\t);\r\n\t}\r\n\r\n\tfindAllByUserId(idUser: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfConfigMiniSite/findAllByUserId',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('idUser', idUser.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// findAllByPromCodigo(promCodigo: number): Observable<any> {\r\n\t//   return this.httpClient.get(\r\n\t//     this.environment.host.backend.configuration +\r\n\t//     'pliCnfConfigMiniSite/findAllByPromCodigo',\r\n\t//     {\r\n\t//       params: new HttpParams()\r\n\t//         .set('promCodigo', promCodigo.toString())\r\n\t//     }\r\n\t//   );\r\n\t// }\r\n\r\n\tdelete(id: number): Observable<any> {\r\n\t\treturn this.httpClient.delete(\r\n\t\t\t`${this.environment.host.backend.configuration}pliCnfConfigMiniSite/delete?id=${id}`\r\n\t\t);\r\n\t}\r\n\r\n\tgetDatatableSearchListByDtblSearchListId(\r\n\t\tdtblSearchListId: string,\r\n\t\ttype: number\r\n\t): Observable<any> {\r\n\t\treturn (\r\n\t\t\tthis.httpClient\r\n\t\t\t\t.get<DatatableSearchList[]>(\r\n\t\t\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t\t\t'PliDatatableSearchListController/getDatatableSearchListByDtblSearchListId',\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tparams: new HttpParams()\r\n\t\t\t\t\t\t\t.set('dtblSearchListId', dtblSearchListId)\r\n\t\t\t\t\t\t\t.set('type', type.toString())\r\n\t\t\t\t\t}\r\n\t\t\t\t)\r\n\t\t\t\t// DJ - Committee sorting requirement\r\n\t\t\t\t.pipe(\r\n\t\t\t\t\tmap((lDatatableSearchList: DatatableSearchList[]) => {\r\n\t\t\t\t\t\tlDatatableSearchList.sort((a, b) => {\r\n\t\t\t\t\t\t\tconst textA = a['recordSize'];\r\n\t\t\t\t\t\t\tconst textB = b['recordSize'];\r\n\t\t\t\t\t\t\treturn textA < textB ? 1 : textA > textB ? -1 : 0;\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t\treturn lDatatableSearchList;\r\n\t\t\t\t\t})\r\n\t\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tgetByDataTablesParameters(dataTablesParameters: DataTableParameters): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'pliCnfConfigMiniSite/getByDataTablesParameters',\r\n\t\t\tdataTablesParameters,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\tsaveAllDatatableSearchList(lDatatableSearchList: DatatableSearchList[]): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'PliDatatableSearchListController/saveAllDatatableSearchList',\r\n\t\t\tlDatatableSearchList,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\tgetDatatableSearchListById(id: string): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'PliDatatableSearchListController/getDatatableSearchListById',\r\n\t\t\t{ params: new HttpParams().set('id', id) }\r\n\t\t);\r\n\t}\r\n}\r\n"]}

package/esm2022/lib/services/pli-cnf-configuration-credit-study.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfConfigurationCreditStudyService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+    }
+    getById(id) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfCreditStudyConfig/getById?id=${id}`);
+    }
+    getByPromCodigo(promCodigo) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfCreditStudyConfig/getByPromCodigo?promCodigo=${promCodigo}`);
+    }
+    save(pliCnfConfigCreditStudy) {
+        return this.httpClient.post(`${this.environment.host.backend.configuration}pliCnfCreditStudyConfig/save`, pliCnfConfigCreditStudy);
+    }
+    delete(id) {
+        return this.httpClient.delete(`${this.environment.host.backend.configuration}pliCnfCreditStudyConfig/${id}`);
+    }
+    getConfigCloningCreditStudy(oldPPP, newPPP) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfCreditStudyConfig/getConfigCloningCreditStudy`, {
+            params: new HttpParams()
+                .set('oldPPP', oldPPP.toString())
+                .set('newPPP', newPPP.toString())
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfConfigurationCreditStudyService, 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: PliCnfConfigurationCreditStudyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfConfigurationCreditStudyService, 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/pli-cnf-document-management.service.mjs

@@ -0,0 +1,40 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfDocumentManagementService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+    }
+    getByPromCodigo(promCodigo) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfDocumentManagement/getByPromCodigo', {
+            params: new HttpParams().set('promCodigo', promCodigo.toString())
+        });
+    }
+    save(pliCnfFormMultiaplicacion) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'pliCnfDocumentManagement/save', pliCnfFormMultiaplicacion, this.headerJson);
+    }
+    configCloningDocumentManagement(oldPromCodigo, newPromCodigo) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfDocumentManagement/configCloningDocumentManagement', {
+            params: new HttpParams()
+                .set('oldPromCodigo', oldPromCodigo.toString())
+                .set('newPromCodigo', newPromCodigo.toString())
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfDocumentManagementService, 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: PliCnfDocumentManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfDocumentManagementService, 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/pli-cnf-dynamic-keys-assign.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfDynamicKeysAssignService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+    }
+    getByPromCodigo(promCodigo) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfDynamicKeysAssign/getByPromCodigo?promCodigo=${promCodigo}`);
+    }
+    getByPromCodigoAndCategoryId(promCodigo, categoryId) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfDynamicKeysAssign/getByPromCodigoAndCategoryId', {
+            params: new HttpParams()
+                .set('promCodigo', promCodigo.toString())
+                .set('categoryId', categoryId.toString())
+        });
+    }
+    getByPromCodigoAndListStaticKeyId(promCodigo, lStaticKeyId) {
+        return this.httpClient.post(this.environment.host.backend.configuration +
+            'pliCnfDynamicKeysAssign/getByPromCodigoAndListStaticKeyId', {
+            promCodigo: promCodigo,
+            lStaticKeyId: lStaticKeyId
+        }, this.headerJson);
+    }
+    save(dynamicKeysAssignData) {
+        return this.httpClient.post(`${this.environment.host.backend.configuration}pliCnfDynamicKeysAssign/save`, dynamicKeysAssignData);
+    }
+    /**
+     *
+     * @param dynamicKeysAssignData
+     * @returns dynamicKeysAssignDataClonned Map key old Id, value new Object.
+     */
+    saveAll(dynamicKeysAssignData) {
+        return this.httpClient.post(`${this.environment.host.backend.configuration}pliCnfDynamicKeysAssign/saveAll`, dynamicKeysAssignData);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfDynamicKeysAssignService, 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: PliCnfDynamicKeysAssignService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfDynamicKeysAssignService, 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/pli-cnf-evaluation-task-mailing.service.mjs

@@ -0,0 +1,31 @@
+import { HttpParams } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfEvaluationTaskMailingService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.urlBase = this.environment.host.backend.configuration;
+    }
+    getByTaskId(taskId) {
+        return this.httpClient.get(this.urlBase + 'pliCnfEvaluationTaskMailing/getByTaskId', {
+            params: new HttpParams().set('taskId', taskId.toString())
+        });
+    }
+    save(pliCnfEvaluationTaskMailing) {
+        return this.httpClient.post(this.urlBase + 'pliCnfEvaluationTaskMailing/save', pliCnfEvaluationTaskMailing);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskMailingService, 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: PliCnfEvaluationTaskMailingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskMailingService, 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/pli-cnf-evaluation-task-template.service.mjs

@@ -0,0 +1,39 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfEvaluationTaskTemplateService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+    }
+    /** Returns a list of PliCnfEvaluationTaskTemplate */
+    getAll() {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'evaluationTaskTemplate/getAll');
+    }
+    /** Returns a list of PliCnfEvaluationTaskTemplate by ids
+     * @param ids id per template
+     */
+    getByIds(ids) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationTaskTemplate/getByTaskIdIn', ids);
+    }
+    // Método para actualizar el orden basado en taskIds
+    updateOrder(taskIds) {
+        return this.httpClient.put(this.environment.host.backend.configuration + 'evaluationTaskTemplate/updateOrder', taskIds);
+    }
+    /** Saves a task template array with its associated document and form records */
+    saveAll(pliCnfEvaluationTaskTemplate) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationTaskTemplate/saveAll', pliCnfEvaluationTaskTemplate);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskTemplateService, 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: PliCnfEvaluationTaskTemplateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskTemplateService, 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/pli-cnf-evaluation-task.service.mjs

@@ -0,0 +1,112 @@
+import { Injectable, Inject } from '@angular/core';
+import { JwtUtil } from 'ng-pli-util';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfEvaluationTaskService {
+    static { this.TASK_STORAGE = 'tokenTask'; }
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+    }
+    getByPromCodigo(promCodigo) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfEvaluationTask/getByPromCodigo/${promCodigo}`);
+    }
+    getById(id) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfEvaluationTask/getById/${id}`);
+    }
+    getByPromCodeAndId(promCode, id) {
+        return this.httpClient.get(`${this.environment.host.backend.configuration}pliCnfEvaluationTask/promCode/${promCode}/id/${id}`);
+    }
+    save(pliCnfEvaluationTask) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'pliCnfEvaluationTask/save', pliCnfEvaluationTask);
+    }
+    delete(id) {
+        return this.httpClient.delete(`${this.environment.host.backend.configuration}pliCnfEvaluationTask/${id}`);
+    }
+    /** It returns a list of tasks according to list of prom codigo */
+    getByPromCodigoAndNoSegmentation(listPromCod) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfEvaluationTask/getByPromCodigoAndNoSegmentation', { params: new HttpParams().set('listPromCodigo', listPromCod.toString()) });
+    }
+    getByPromCodigoAndEvaluator(promCod, evaluator) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfEvaluationTask/getByPromCodigoAndEvaluator', {
+            params: new HttpParams()
+                .set('promCodigo', promCod.toString())
+                .set('evaluator', evaluator)
+        });
+    }
+    getByPromCodigoAndTypeAndVisible(promCodigo, type) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'pliCnfEvaluationTask/getByPromCodigoAndTypeAndVisible', {
+            params: new HttpParams()
+                .set('promCodigo', promCodigo.toString())
+                .set('type', type.toString())
+        });
+    }
+    /***
+     * Unencript the information from local Storage
+     * @author Jkatz
+     */
+    getEncryptedTasks(username, patCodigo, promCodigo) {
+        return new Promise((resolve, reject) => {
+            let taskStorage = localStorage.getItem(PliCnfEvaluationTaskService.TASK_STORAGE);
+            let map;
+            if (taskStorage) {
+                map = JSON.parse(taskStorage);
+                if (map[promCodigo]) {
+                    resolve(map[promCodigo]);
+                    return;
+                }
+            }
+            this.getByProfile(username, patCodigo, promCodigo).subscribe((taskByProfile) => {
+                if (taskByProfile) {
+                    let decrypt = JwtUtil.parseJwt(taskByProfile['encrypt']);
+                    if (decrypt && decrypt.tasks) {
+                        if (map)
+                            map[promCodigo] = decrypt.tasks;
+                        else
+                            map = {};
+                        localStorage.setItem(PliCnfEvaluationTaskService.TASK_STORAGE, JSON.stringify(map));
+                        resolve(decrypt.tasks);
+                        return;
+                    }
+                }
+                reject('No se logro generar token de tareas por perfil');
+            }, (error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * get task by profile encrypted
+     * @param username
+     * @param patCodigo
+     */
+    getByProfile(username, patCodigo, promCodigo) {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'pliCnfEvaluationTask/getByUserProfiles', {
+            params: new HttpParams()
+                .set('username', username)
+                .set('patCodigo', patCodigo)
+                .set('promCodigo', promCodigo)
+        });
+    }
+    /** Saves a task array with its associated document and form records */
+    saveAll(pliCnfEvaluationTask) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'pliCnfEvaluationTask/saveAll', pliCnfEvaluationTask);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskService, 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: PliCnfEvaluationTaskService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTaskService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pli-cnf-evaluation-task.service.js","sourceRoot":"","sources":["../../../../../projects/ng-pli-commons/src/lib/services/pli-cnf-evaluation-task.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\nimport { JwtUtil, PliCnfEvaluationTask, PliUser } from 'ng-pli-util';\r\nimport { Observable } from 'rxjs';\r\nimport { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class PliCnfEvaluationTaskService {\r\n\tprivate headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };\r\n\r\n\tstatic TASK_STORAGE = 'tokenTask';\r\n\r\n\tconstructor(@Inject('environment') private environment, private httpClient: HttpClient) {}\r\n\r\n\tpublic getByPromCodigo(promCodigo: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\t`${this.environment.host.backend.configuration}pliCnfEvaluationTask/getByPromCodigo/${promCodigo}`\r\n\t\t);\r\n\t}\r\n\r\n\tpublic getById(id: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\t`${this.environment.host.backend.configuration}pliCnfEvaluationTask/getById/${id}`\r\n\t\t);\r\n\t}\r\n\r\n\tpublic getByPromCodeAndId(promCode: number, id: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\t`${this.environment.host.backend.configuration}pliCnfEvaluationTask/promCode/${promCode}/id/${id}`\r\n\t\t);\r\n\t}\r\n\r\n\tpublic save(pliCnfEvaluationTask: PliCnfEvaluationTask): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfEvaluationTask/save',\r\n\t\t\tpliCnfEvaluationTask\r\n\t\t);\r\n\t}\r\n\r\n\tpublic delete(id: number) {\r\n\t\treturn this.httpClient.delete(\r\n\t\t\t`${this.environment.host.backend.configuration}pliCnfEvaluationTask/${id}`\r\n\t\t);\r\n\t}\r\n\r\n\t/** It returns a list of tasks according to list of prom codigo */\r\n\tpublic getByPromCodigoAndNoSegmentation(listPromCod: Array<number>): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'pliCnfEvaluationTask/getByPromCodigoAndNoSegmentation',\r\n\t\t\t{ params: new HttpParams().set('listPromCodigo', listPromCod.toString()) }\r\n\t\t);\r\n\t}\r\n\r\n\tpublic getByPromCodigoAndEvaluator(promCod: number, evaluator: string): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'pliCnfEvaluationTask/getByPromCodigoAndEvaluator',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams()\r\n\t\t\t\t\t.set('promCodigo', promCod.toString())\r\n\t\t\t\t\t.set('evaluator', evaluator)\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tpublic getByPromCodigoAndTypeAndVisible(promCodigo: number, type: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'pliCnfEvaluationTask/getByPromCodigoAndTypeAndVisible',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams()\r\n\t\t\t\t\t.set('promCodigo', promCodigo.toString())\r\n\t\t\t\t\t.set('type', type.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/***\r\n\t * Unencript the information from local Storage\r\n\t * @author Jkatz\r\n\t */\r\n\tgetEncryptedTasks(username: string, patCodigo: string, promCodigo: string): Promise<any> {\r\n\t\treturn new Promise((resolve, reject) => {\r\n\t\t\tlet taskStorage = localStorage.getItem(PliCnfEvaluationTaskService.TASK_STORAGE);\r\n\t\t\tlet map;\r\n\t\t\tif (taskStorage) {\r\n\t\t\t\tmap = JSON.parse(taskStorage);\r\n\t\t\t\tif (map[promCodigo]) {\r\n\t\t\t\t\tresolve(map[promCodigo]);\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tthis.getByProfile(username, patCodigo, promCodigo).subscribe(\r\n\t\t\t\t(taskByProfile) => {\r\n\t\t\t\t\tif (taskByProfile) {\r\n\t\t\t\t\t\tlet decrypt = JwtUtil.parseJwt(taskByProfile['encrypt']);\r\n\t\t\t\t\t\tif (decrypt && decrypt.tasks) {\r\n\t\t\t\t\t\t\tif (map) map[promCodigo] = decrypt.tasks;\r\n\t\t\t\t\t\t\telse map = {};\r\n\t\t\t\t\t\t\tlocalStorage.setItem(\r\n\t\t\t\t\t\t\t\tPliCnfEvaluationTaskService.TASK_STORAGE,\r\n\t\t\t\t\t\t\t\tJSON.stringify(map)\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tresolve(decrypt.tasks);\r\n\t\t\t\t\t\t\treturn;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treject('No se logro generar token de tareas por perfil');\r\n\t\t\t\t},\r\n\t\t\t\t(error) => {\r\n\t\t\t\t\treject(error);\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * get task by profile encrypted\r\n\t * @param username\r\n\t * @param patCodigo\r\n\t */\r\n\tpublic getByProfile(username: string, patCodigo: string, promCodigo: string): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfEvaluationTask/getByUserProfiles',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams()\r\n\t\t\t\t\t.set('username', username)\r\n\t\t\t\t\t.set('patCodigo', patCodigo)\r\n\t\t\t\t\t.set('promCodigo', promCodigo)\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Saves a task array with its associated document and form records */\r\n\tsaveAll(pliCnfEvaluationTask: PliCnfEvaluationTask[]): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'pliCnfEvaluationTask/saveAll',\r\n\t\t\tpliCnfEvaluationTask\r\n\t\t);\r\n\t}\r\n}\r\n"]}

package/esm2022/lib/services/pli-cnf-evaluation-template.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpParams, HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PliCnfEvaluationTemplateService {
+    constructor(environment, httpClient) {
+        this.environment = environment;
+        this.httpClient = httpClient;
+        this.headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };
+    }
+    /** Returns a PliCnfEvaluationTemplate by id */
+    getById(id) {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'evaluationtemplate/getById', {
+            params: new HttpParams().set('id', id.toString())
+        });
+    }
+    /** Returns a list of PliCnfEvaluationTemplate by ids
+     * @param ids id per template
+     */
+    getByIds(ids) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationtemplate/getByIdIn', ids);
+    }
+    /** Returns a list of PliCnfEvaluationTemplate by promCode */
+    getAllByPromCode(promCode) {
+        return this.httpClient.get(this.environment.host.backend.configuration + 'evaluationtemplate/getAllByPromCode', {
+            params: new HttpParams().set('promCode', promCode.toString())
+        });
+    }
+    /**
+     * Returns a list of PliCnfEvaluationTemplate by promCode and active
+     * @param promCode
+     * @param active define if get templates actives or inactives
+     */
+    getAllByPromCodeAndActve(promCode, active) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'evaluationtemplate/getAllByPromCodeAndActive', {
+            params: new HttpParams().set('promCode', promCode.toString()).set('active', active)
+        });
+    }
+    /**
+     * Returns a valpro PliCnfEvaluationTemplate by promCode
+     * @param promCode
+     */
+    getByPromCodeAndisValpro(promCode) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'evaluationtemplate/getByPromCodeAndIsValpro', {
+            params: new HttpParams().set('promCode', promCode.toString())
+        });
+    }
+    /** Saves a template with its associated document and form records */
+    save(pliCnfEvaluationTemplate) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationtemplate/save', pliCnfEvaluationTemplate, this.headerJson);
+    }
+    /** Deletes a template with its associated document and form records,
+     * unless there is another configuration using the specified evaluation template */
+    delete(id) {
+        return this.httpClient.delete(this.environment.host.backend.configuration + 'evaluationtemplate/delete', {
+            params: new HttpParams().set('id', id.toString())
+        });
+    }
+    /** Returns a list of mongo forms by promCode */
+    getMongoFormByEvaluationTemplateId(evaluationTemplateId) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'evaluationtemplate/mongoForm/getByEvaluationTemplateId', {
+            params: new HttpParams().set('evaluationTemplateId', evaluationTemplateId.toString())
+        });
+    }
+    /** Returns a list of mongo forms by promCode */
+    getAllMongoFormsByPromCode(promCode) {
+        return this.httpClient.get(this.environment.host.backend.configuration +
+            'evaluationtemplate/mongoForm/getAllByPromCode', {
+            params: new HttpParams().set('promCode', promCode.toString())
+        });
+    }
+    /** Saves a template with its associated document and form records */
+    saveMongoForm(mongoForm) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationtemplate/mongoForm/save', mongoForm, this.headerJson);
+    }
+    /** Saves a template array with its associated document and form records */
+    saveAll(lEvaluationTemplate, promCodigo) {
+        return this.httpClient.post(this.environment.host.backend.configuration + 'evaluationtemplate/saveAll', { lEvaluationTemplate, promCodigo }, this.headerJson);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTemplateService, 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: PliCnfEvaluationTemplateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PliCnfEvaluationTemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pli-cnf-evaluation-template.service.js","sourceRoot":"","sources":["../../../../../projects/ng-pli-commons/src/lib/services/pli-cnf-evaluation-template.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 { Observable } from 'rxjs';\r\nimport { PliCnfEvaluationTemplate } from 'ng-pli-util';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class PliCnfEvaluationTemplateService {\r\n\tprivate headerJson = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) };\r\n\r\n\tconstructor(@Inject('environment') private environment: any, private httpClient: HttpClient) {}\r\n\r\n\t/** Returns a PliCnfEvaluationTemplate by id */\r\n\tgetById(id: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/getById',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('id', id.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Returns a list of PliCnfEvaluationTemplate by ids\r\n\t * @param ids id per template\r\n\t */\r\n\tgetByIds(ids: number[]): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/getByIdIn',\r\n\t\t\tids\r\n\t\t);\r\n\t}\r\n\r\n\t/** Returns a list of PliCnfEvaluationTemplate by promCode */\r\n\tgetAllByPromCode(promCode: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/getAllByPromCode',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('promCode', promCode.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a list of PliCnfEvaluationTemplate by promCode and active\r\n\t * @param promCode\r\n\t * @param active define if get templates actives or inactives\r\n\t */\r\n\tgetAllByPromCodeAndActve(promCode: number, active: string): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'evaluationtemplate/getAllByPromCodeAndActive',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('promCode', promCode.toString()).set('active', active)\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a valpro PliCnfEvaluationTemplate by promCode\r\n\t * @param promCode\r\n\t */\r\n\tgetByPromCodeAndisValpro(promCode: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'evaluationtemplate/getByPromCodeAndIsValpro',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('promCode', promCode.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Saves a template with its associated document and form records */\r\n\tsave(pliCnfEvaluationTemplate: PliCnfEvaluationTemplate): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/save',\r\n\t\t\tpliCnfEvaluationTemplate,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/** Deletes a template with its associated document and form records,\r\n\t * unless there is another configuration using the specified evaluation template */\r\n\tdelete(id: number): Observable<any> {\r\n\t\treturn this.httpClient.delete(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/delete',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('id', id.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Returns a list of mongo forms by promCode */\r\n\tgetMongoFormByEvaluationTemplateId(evaluationTemplateId: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'evaluationtemplate/mongoForm/getByEvaluationTemplateId',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set(\r\n\t\t\t\t\t'evaluationTemplateId',\r\n\t\t\t\t\tevaluationTemplateId.toString()\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Returns a list of mongo forms by promCode */\r\n\tgetAllMongoFormsByPromCode(promCode: number): Observable<any> {\r\n\t\treturn this.httpClient.get(\r\n\t\t\tthis.environment.host.backend.configuration +\r\n\t\t\t\t'evaluationtemplate/mongoForm/getAllByPromCode',\r\n\t\t\t{\r\n\t\t\t\tparams: new HttpParams().set('promCode', promCode.toString())\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/** Saves a template with its associated document and form records */\r\n\tsaveMongoForm(mongoForm: any): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/mongoForm/save',\r\n\t\t\tmongoForm,\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n\r\n\t/** Saves a template array with its associated document and form records */\r\n\tsaveAll(lEvaluationTemplate: PliCnfEvaluationTemplate[], promCodigo: number): Observable<any> {\r\n\t\treturn this.httpClient.post(\r\n\t\t\tthis.environment.host.backend.configuration + 'evaluationtemplate/saveAll',\r\n\t\t\t{ lEvaluationTemplate, promCodigo },\r\n\t\t\tthis.headerJson\r\n\t\t);\r\n\t}\r\n}\r\n"]}