@senior-gestao-pessoas/payroll-core 8.7.0 → 9.0.0

package/esm2015/services/lookup-parameters.service.js

@@ -0,0 +1,345 @@
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { TranslateService } from "@ngx-translate/core";
+import { MessageService } from "primeng/api";
+import { map, catchError } from "rxjs/operators";
+import { throwError } from "rxjs";
+import { FieldType } from '@seniorsistemas/angular-components';
+import * as moment_ from 'moment';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "primeng/components/common/messageservice";
+import * as i3 from "@ngx-translate/core";
+const moment = moment_;
+let LookupParametersService = class LookupParametersService {
+    constructor(http, messageService, translateService) {
+        this.http = http;
+        this.messageService = messageService;
+        this.translateService = translateService;
+        this._httpParams = new HttpParams();
+    }
+    lookupRequestPost(httpPostParams, endpoint, concatFields = null, lookupDisplayField) {
+        this.httpPostParams = httpPostParams;
+        this.postConfigPageSize(httpPostParams);
+        this.lookupDisplayField = lookupDisplayField;
+        this.concatFields = concatFields;
+        return this.postDataLookup(endpoint);
+    }
+    postConfigPageSize(httpPostParams) {
+        if (httpPostParams) {
+            this.httpPostParams.page.size = httpPostParams.page && httpPostParams.page.size ? httpPostParams.page.size : 10;
+            this.httpPostParams.page.current = httpPostParams.page && httpPostParams.page.current ? httpPostParams.page.current : 0;
+        }
+    }
+    /**
+     * Função chamada no change do autocomplete (Lookup fechado).
+     * @param event valor atribuido no autocomplete do lookup fechado
+     * @param endpoint endpoint que sera feito a requisição.
+     * @param searchLookupFields campos que seram filtrados pelo autocomplete (lookup fechado)
+     * @param searchFields array com os campos do filtro
+     * @param concatFields array com os formFields que seram concatenados
+     * @param concatOtherFields converte os campos enumeração para serem concatenados na grid
+     * @param lookupDisplayField campo que sera alterado com os dados concatenados informado acima
+     * @param params parâmetros para ser usado no lookup
+     */
+    lookupRequest(event, endpoint, searchLookupFields, searchFields, concatFields, lookupDisplayField, concatOtherFields = [], params = []) {
+        this.searchLookupFields = searchLookupFields;
+        this.endpoint = endpoint;
+        this.parameters = params;
+        this.concatFields = concatFields;
+        this.concatOtherFields = concatOtherFields;
+        this.lookupDisplayField = lookupDisplayField;
+        this.searchFields = searchFields;
+        this.generateLookupParameters(event);
+        this.configHttpParamsPagination('10', '0');
+        this.configHttpParamsOrderBy(event.multiSortMeta);
+        return this.getDataLookup();
+    }
+    /**
+     * Função chamada no change do filtro do lookup (Lookup aberto).
+     * @param event valor atribuido no autocomplete do lookup fechado
+     * @param endpoint endpoint que sera feito a requisição.
+     * @param searchFields array com os campos do filtro
+     * @param concatFields array com os formFields que seram concatenados
+     * @param concatOtherFields converte os campos enumeração para serem concatenados na grid
+     * @param lookupDisplayField campo que sera alterado com os dados concatenados informado acima
+     * @param params parâmetros para ser usado no lookup
+     */
+    searchRequest(event, endpoint, searchFields, concatFields, lookupDisplayField, concatOtherFields = [], params = []) {
+        this.endpoint = endpoint;
+        this.parameters = params;
+        this.concatFields = concatFields;
+        this.concatOtherFields = concatOtherFields;
+        this.lookupDisplayField = lookupDisplayField;
+        this.searchFields = searchFields;
+        this.generateGridParameters(event.filterData);
+        this.configHttpParamsPagination(event.rows.toString(), Math.floor(event.first / event.rows).toString());
+        this.configHttpParamsOrderBy(event.multiSortMeta);
+        return this.getDataLookup();
+    }
+    /**
+     * GET
+     * @param endpoint Busca e faz o tratamento dos dados do lookup.
+     * @param httpParams HttpParams
+     */
+    getDataLookup() {
+        return this.getUrlDataLookup(this.endpoint, this.httpParams).pipe(map((payload) => {
+            const { contents } = payload;
+            if (this.concatFields && this.concatFields.length) {
+                contents.map(value => {
+                    this.convertGridFieldValue(value);
+                    value[this.lookupDisplayField] = this.generateDisplayFieldValue(Object.assign({}, value));
+                });
+            }
+            return payload;
+        }));
+    }
+    /**
+     * POST
+     * @param endpoint Busca e faz o tratamento dos dados do lookup.
+     * @param httpParams HttpParams
+     */
+    postDataLookup(endpoint) {
+        return this.postUrlDataLookup(endpoint, this.httpPostParams).pipe(map((payload) => {
+            const { contents } = payload;
+            if (this.concatFields && this.concatFields.length) {
+                contents.map(value => {
+                    if (this.concatOtherFields) {
+                        this.convertGridFieldValue(value);
+                    }
+                    value[this.lookupDisplayField] = this.generateDisplayFieldValue(Object.assign({}, value));
+                });
+            }
+            return payload;
+        }));
+    }
+    /**
+     * Converte o valor do campo para apresentação no lookup.
+     *
+     * @param content Valor do campo para conversão.
+     * @param field FormField do campo.
+     */
+    convertLookupFieldValue(content, field) {
+        if (content) {
+            switch (field.type) {
+                case FieldType.Date:
+                    content = moment(content).format('L');
+                    break;
+                case FieldType.Enum:
+                    const enumValue = field.options.filter((enumeration) => enumeration.value === content)[0];
+                    content = enumValue ? enumValue.label : content;
+                    break;
+            }
+        }
+        return content;
+    }
+    /**
+     * Converte os dados para visualização na grid
+     * @param content
+     */
+    convertGridFieldValue(content) {
+        if (content) {
+            this.concatOtherFields.forEach((field) => {
+                switch (field.type) {
+                    case FieldType.Enum:
+                        const enumValue = field.options.filter((enumeration) => enumeration.value === content[field.name])[0];
+                        content[field.name] = enumValue ? enumValue.label : content[field.name];
+                        break;
+                }
+            });
+        }
+    }
+    /**
+     * Faz a concatenação de valores do registro para ser apresentado no lookup ao selecionar o dado.
+     * @param contentValue Valor do registro.
+     */
+    generateDisplayFieldValue(contentValue) {
+        let displayField = '';
+        this.concatFields.forEach((field) => {
+            const fieldValue = this.convertLookupFieldValue(contentValue[field.name], field);
+            if (fieldValue) {
+                if (displayField) {
+                    displayField += ` - ${fieldValue}`;
+                }
+                else {
+                    displayField = fieldValue;
+                }
+            }
+        });
+        return displayField;
+    }
+    /**
+     * Gera os parametros de pesquisa via lookup
+     * @param value
+     */
+    generateLookupParameters(value) {
+        let lookupParameters = '';
+        this.searchLookupFields.forEach((lookupField) => {
+            const searchField = this.searchFields.filter(field => lookupField === field.name)[0];
+            if (lookupParameters) {
+                lookupParameters += ` or ${this.getParameterByType(searchField.type, lookupField, value)}`;
+            }
+            else {
+                lookupParameters = `${this.getParameterByType(searchField.type, lookupField, value)}`;
+            }
+        });
+        this.parameters.forEach((parameter) => {
+            if (lookupParameters) {
+                lookupParameters += ` and ${parameter.toString()}`;
+            }
+            else {
+                lookupParameters = `${parameter.toString()}`;
+            }
+        });
+        this.httpParams = new HttpParams().set('filter', lookupParameters);
+    }
+    /**
+     * Gera os parametros de pesquisa via pesquisa na grid
+     * @param filterData
+     */
+    generateGridParameters(filterData) {
+        let gridParameters = '';
+        Object.keys(filterData).forEach((attribute) => {
+            if (filterData[attribute]) {
+                const searchField = this.searchFields.filter(field => attribute === field.name)[0];
+                if (gridParameters) {
+                    gridParameters += ` and ${this.getParameterByType(searchField.type, attribute, filterData[attribute])}`;
+                }
+                else {
+                    gridParameters += this.getParameterByType(searchField.type, attribute, filterData[attribute]);
+                }
+            }
+        });
+        this.parameters.forEach((parameter) => {
+            if (gridParameters) {
+                gridParameters += ` and ${parameter.toString()}`;
+            }
+            else {
+                gridParameters = `${parameter.toString()}`;
+            }
+        });
+        this.httpParams = new HttpParams().set('filter', gridParameters);
+    }
+    /**
+     * Gera a string de consulta CRUD de um campo.
+     * @param type Tipo do campo.
+     * @param attribute Nome do atribute da entidade
+     * @param value Valor do campo
+     */
+    getParameterByType(type, attribute, value) {
+        switch (type) {
+            case FieldType.Date:
+                return `${attribute} eq '${moment(value).format('YYYY-MM-DD')}'`;
+            case FieldType.Enum:
+                return `${attribute} eq '${value}'`;
+            case FieldType.Integer:
+                return `${attribute} eq ${value}`;
+            case FieldType.Autocomplete:
+                return `${attribute} eq '${value.id}'`;
+            default:
+                return `containing(lower(${attribute}), lower('${value}'))`;
+        }
+    }
+    /**
+     *
+     * @param size a quantidade de registros na página.
+     * @param offset o número da página a ser recuperada, lembrando que a numeração de páginas começa em 0 (zero).
+     */
+    configHttpParamsPagination(size, offset) {
+        this.httpParams = this.httpParams.set('size', size);
+        this.httpParams = this.httpParams.set('offset', offset);
+    }
+    /**
+     * Gera o orderby do HttpParams
+     */
+    configHttpParamsOrderBy(multiSortMeta) {
+        if (multiSortMeta && multiSortMeta.length) {
+            let orderBy = '';
+            multiSortMeta.map(value => {
+                if (orderBy) {
+                    orderBy += `,${value.field}+${value.order === 1 ? 'asc' : 'desc'}`;
+                }
+                else {
+                    orderBy += `${value.field}+${value.order === 1 ? 'asc' : 'desc'}`;
+                }
+            });
+            this.httpParams = this.httpParams.set('orderby', orderBy);
+        }
+    }
+    set httpParams(value) {
+        this._httpParams = value;
+    }
+    get httpParams() {
+        return this._httpParams;
+    }
+    getUrlDataLookup(endpoint, httpParams) {
+        if (httpParams) {
+            return this.http.get(`${endpoint}`, { params: httpParams })
+                .pipe(catchError((exception) => {
+                if (exception && exception.status === 403)
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: this.translateService.instant('hcm.payroll.error'),
+                        detail: this.translateService.instant("hcm.payroll.permission_error_not_allowed_search"),
+                        sticky: true,
+                    });
+                return throwError(exception);
+            }));
+        }
+        else {
+            return this.http.get(`${endpoint}`)
+                .pipe(catchError((exception) => {
+                if (exception && exception.status === 403)
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: this.translateService.instant('hcm.payroll.error'),
+                        detail: this.translateService.instant("hcm.payroll.permission_error_not_allowed_search"),
+                        sticky: true,
+                    });
+                return throwError(exception);
+            }));
+        }
+    }
+    postUrlDataLookup(endpoint, httpParams) {
+        if (httpParams) {
+            return this.http.post(`${endpoint}`, Object.assign({}, httpParams))
+                .pipe(catchError((exception) => {
+                if (exception.status === 403)
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: this.translateService.instant('hcm.payroll.error'),
+                        detail: this.translateService.instant("hcm.payroll.permission_error_not_allowed"),
+                        sticky: true,
+                    });
+                return throwError(exception);
+            }));
+        }
+        else {
+            return this.http.post(`${endpoint}`, {})
+                .pipe(catchError((exception) => {
+                if (exception.status === 403)
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: this.translateService.instant('hcm.payroll.error'),
+                        detail: this.translateService.instant("hcm.payroll.permission_error_not_allowed"),
+                        sticky: true,
+                    });
+                return throwError(exception);
+            }));
+        }
+    }
+};
+LookupParametersService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: MessageService },
+    { type: TranslateService }
+];
+LookupParametersService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function LookupParametersService_Factory() { return new LookupParametersService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.MessageService), i0.ɵɵinject(i3.TranslateService)); }, token: LookupParametersService, providedIn: "root" });
+LookupParametersService = tslib_1.__decorate([
+    Injectable({
+        providedIn: 'root',
+    })
+], LookupParametersService);
+export { LookupParametersService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lookup-parameters.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["services/lookup-parameters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { TranslateService } from \"@ngx-translate/core\";\nimport { MessageService } from \"primeng/api\";\nimport { map, catchError } from \"rxjs/operators\";\nimport { Observable, throwError } from \"rxjs\";\nimport { EntityODataParameter } from '../core/entities';\nimport { FieldType, FormField } from '@seniorsistemas/angular-components';\nimport * as moment_ from 'moment';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { PaginationData } from '../core/interfaces';\n\nconst moment = moment_;\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class LookupParametersService {\n\n    private searchLookupFields: any;\n    private endpoint: string;\n    private parameters: any;\n    private concatFields: any;\n    private concatOtherFields: any;\n    private lookupDisplayField: string;\n    private searchFields: any;\n    private httpPostParams: any;\n    private page: PaginationData;\n    private _httpParams: HttpParams = new HttpParams();\n\n    constructor(private http: HttpClient, private messageService: MessageService, private translateService: TranslateService) {\n    }\n\n\n    lookupRequestPost(httpPostParams: any, endpoint: string, concatFields: Array<FormField> = null, lookupDisplayField: string) {\n        this.httpPostParams = httpPostParams;\n        this.postConfigPageSize(httpPostParams);\n        this.lookupDisplayField = lookupDisplayField;\n        this.concatFields = concatFields;\n        return this.postDataLookup(endpoint);\n    }\n\n    postConfigPageSize(httpPostParams: any) {\n        if (httpPostParams) {\n            this.httpPostParams.page.size = httpPostParams.page && httpPostParams.page.size ? httpPostParams.page.size : 10;\n            this.httpPostParams.page.current = httpPostParams.page && httpPostParams.page.current ? httpPostParams.page.current : 0;\n        }\n    }\n\n    /**\n     * Função chamada no change do autocomplete (Lookup fechado).\n     * @param event valor atribuido no autocomplete do lookup fechado\n     * @param endpoint endpoint que sera feito a requisição.\n     * @param searchLookupFields campos que seram filtrados pelo autocomplete (lookup fechado)\n     * @param searchFields array com os campos do filtro\n     * @param concatFields array com os formFields que seram concatenados\n     * @param concatOtherFields converte os campos enumeração para serem concatenados na grid\n     * @param lookupDisplayField campo que sera alterado com os dados concatenados informado acima\n     * @param params parâmetros para ser usado no lookup\n     */\n    lookupRequest(event: any, endpoint: string, searchLookupFields: Array<String>, searchFields: Array<FormField>,\n                  concatFields: Array<FormField>, lookupDisplayField: string, concatOtherFields: Array<FormField> = [], params: any = []) {\n\n        this.searchLookupFields = searchLookupFields;\n        this.endpoint = endpoint;\n        this.parameters = params;\n        this.concatFields = concatFields;\n        this.concatOtherFields = concatOtherFields;\n        this.lookupDisplayField = lookupDisplayField;\n        this.searchFields = searchFields;\n\n        this.generateLookupParameters(event);\n        this.configHttpParamsPagination('10', '0');\n        this.configHttpParamsOrderBy(event.multiSortMeta);\n        return this.getDataLookup();\n    }\n\n    /**\n     * Função chamada no change do filtro do lookup (Lookup aberto).\n     * @param event valor atribuido no autocomplete do lookup fechado\n     * @param endpoint endpoint que sera feito a requisição.\n     * @param searchFields array com os campos do filtro\n     * @param concatFields array com os formFields que seram concatenados\n     * @param concatOtherFields converte os campos enumeração para serem concatenados na grid\n     * @param lookupDisplayField campo que sera alterado com os dados concatenados informado acima\n     * @param params parâmetros para ser usado no lookup\n     */\n    searchRequest(event: any, endpoint: string, searchFields: Array<FormField>,\n                  concatFields: Array<FormField>, lookupDisplayField: string, concatOtherFields: Array<FormField> = [], params: any = []) {\n\n        this.endpoint = endpoint;\n        this.parameters = params;\n        this.concatFields = concatFields;\n        this.concatOtherFields = concatOtherFields;\n        this.lookupDisplayField = lookupDisplayField;\n        this.searchFields = searchFields;\n        this.generateGridParameters(event.filterData);\n        this.configHttpParamsPagination(event.rows.toString(), Math.floor(event.first / event.rows).toString());\n        this.configHttpParamsOrderBy(event.multiSortMeta);\n        return this.getDataLookup();\n    }\n\n\n    /**\n     * GET\n     * @param endpoint Busca e faz o tratamento dos dados do lookup.\n     * @param httpParams HttpParams\n     */\n    private getDataLookup() {\n        return this.getUrlDataLookup(this.endpoint, this.httpParams).pipe(\n            map((payload: any) => {\n                const { contents } = payload;\n\n                if (this.concatFields && this.concatFields.length) {\n                    contents.map(value => {\n                        this.convertGridFieldValue(value);\n                        value[this.lookupDisplayField] = this.generateDisplayFieldValue({ ...value });\n                    });\n                }\n\n                return payload;\n            }),\n        );\n    }\n\n\n    /**\n     * POST\n     * @param endpoint Busca e faz o tratamento dos dados do lookup.\n     * @param httpParams HttpParams\n     */\n    private postDataLookup(endpoint) {\n        return this.postUrlDataLookup(endpoint, this.httpPostParams).pipe(\n            map((payload: any) => {\n                const { contents } = payload;\n\n                if (this.concatFields && this.concatFields.length) {\n                    contents.map(value => {\n                        if (this.concatOtherFields) {\n                            this.convertGridFieldValue(value);\n                        }\n                        value[this.lookupDisplayField] = this.generateDisplayFieldValue({ ...value });\n                    });\n                }\n\n                return payload;\n            }),\n        );\n    }\n\n    /**\n     * Converte o valor do campo para apresentação no lookup.\n     *\n     * @param content Valor do campo para conversão.\n     * @param field FormField do campo.\n     */\n    private convertLookupFieldValue(content: any, field: FormField): any {\n        if (content) {\n            switch (field.type) {\n                case FieldType.Date:\n                    content = moment(content).format('L');\n                    break;\n                case FieldType.Enum:\n                    const enumValue = field.options.filter((enumeration: any) => enumeration.value === content)[0];\n                    content = enumValue ? enumValue.label : content;\n                    break;\n            }\n        }\n\n        return content;\n    }\n\n    /**\n     * Converte os dados para visualização na grid\n     * @param content\n     */\n    private convertGridFieldValue(content: any): void {\n        if (content) {\n            this.concatOtherFields.forEach((field: FormField) => {\n                switch (field.type) {\n                    case FieldType.Enum:\n                        const enumValue = field.options.filter((enumeration: any) => enumeration.value === content[field.name])[0];\n                        content[field.name] = enumValue ? enumValue.label : content[field.name];\n                        break;\n                }\n            });\n        }\n    }\n\n    /**\n     * Faz a concatenação de valores do registro para ser apresentado no lookup ao selecionar o dado.\n     * @param contentValue Valor do registro.\n     */\n    private generateDisplayFieldValue(contentValue: any): string {\n        let displayField = '';\n\n        this.concatFields.forEach((field: FormField) => {\n            const fieldValue = this.convertLookupFieldValue(contentValue[field.name], field);\n            if (fieldValue) {\n                if (displayField) {\n                    displayField += ` - ${fieldValue}`;\n                } else {\n                    displayField = fieldValue;\n                }\n            }\n        });\n        return displayField;\n    }\n\n    /**\n     * Gera os parametros de pesquisa via lookup\n     * @param value\n     */\n    private generateLookupParameters(value?: string): void {\n        let lookupParameters = '';\n        this.searchLookupFields.forEach((lookupField: string) => {\n            const searchField = this.searchFields.filter(field => lookupField === field.name)[0];\n            if (lookupParameters) {\n                lookupParameters += ` or ${this.getParameterByType(searchField.type, lookupField, value)}`;\n            } else {\n                lookupParameters = `${this.getParameterByType(searchField.type, lookupField, value)}`;\n            }\n        });\n\n        this.parameters.forEach((parameter: EntityODataParameter) => {\n            if (lookupParameters) {\n                lookupParameters += ` and ${parameter.toString()}`;\n            } else {\n                lookupParameters = `${parameter.toString()}`;\n            }\n        });\n\n        this.httpParams = new HttpParams().set('filter', lookupParameters);\n    }\n\n    /**\n     * Gera os parametros de pesquisa via pesquisa na grid\n     * @param filterData\n     */\n    private generateGridParameters(filterData: object): void {\n        let gridParameters = '';\n        Object.keys(filterData).forEach((attribute: string) => {\n            if (filterData[attribute]) {\n                const searchField = this.searchFields.filter(field => attribute === field.name)[0];\n                if (gridParameters) {\n                    gridParameters += ` and ${this.getParameterByType(searchField.type, attribute, filterData[attribute])}`;\n                } else {\n                    gridParameters += this.getParameterByType(searchField.type, attribute, filterData[attribute]);\n                }\n            }\n        });\n\n        this.parameters.forEach((parameter: EntityODataParameter) => {\n            if (gridParameters) {\n                gridParameters += ` and ${parameter.toString()}`;\n            } else {\n                gridParameters = `${parameter.toString()}`;\n            }\n        });\n\n        this.httpParams = new HttpParams().set('filter', gridParameters);\n    }\n\n    /**\n     * Gera a string de consulta CRUD de um campo.\n     * @param type Tipo do campo.\n     * @param attribute Nome do atribute da entidade\n     * @param value Valor do campo\n     */\n    private getParameterByType(type: FieldType, attribute: string, value: any): string {\n        switch (type) {\n            case FieldType.Date:\n                return `${attribute} eq '${moment(value).format('YYYY-MM-DD')}'`;\n            case FieldType.Enum:\n                return `${attribute} eq '${value}'`;\n            case FieldType.Integer:\n                return `${attribute} eq ${value}`;\n            case FieldType.Autocomplete:\n                return `${attribute} eq '${value.id}'`;\n            default:\n                return `containing(lower(${attribute}), lower('${value}'))`;\n        }\n    }\n\n    /**\n     *\n     * @param size a quantidade de registros na página.\n     * @param offset o número da página a ser recuperada, lembrando que a numeração de páginas começa em 0 (zero).\n     */\n    private configHttpParamsPagination(size: string, offset: string): void {\n        this.httpParams = this.httpParams.set('size', size);\n        this.httpParams = this.httpParams.set('offset', offset);\n    }\n\n    /**\n     * Gera o orderby do HttpParams\n     */\n    private configHttpParamsOrderBy(multiSortMeta: { field: string; order: number }[]): void {\n        if (multiSortMeta && multiSortMeta.length) {\n            let orderBy = '';\n            multiSortMeta.map(value => {\n                if (orderBy) {\n                    orderBy += `,${value.field}+${value.order === 1 ? 'asc' : 'desc'}`;\n                } else {\n                    orderBy += `${value.field}+${value.order === 1 ? 'asc' : 'desc'}`;\n                }\n            });\n\n            this.httpParams = this.httpParams.set('orderby', orderBy);\n        }\n    }\n\n    set httpParams(value: HttpParams) {\n        this._httpParams = value;\n    }\n\n    get httpParams() {\n        return this._httpParams;\n    }\n\n    private getUrlDataLookup(endpoint: string, httpParams: HttpParams): Observable<any> {\n        if (httpParams) {\n            return this.http.get(`${endpoint}`, { params: httpParams })\n                .pipe(\n                    catchError((exception: any): any => {\n                        if (exception && exception.status === 403)\n                            this.messageService.add({\n                                severity: 'error',\n                                summary: this.translateService.instant('hcm.payroll.error'),\n                                detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed_search\"),\n                                sticky: true,\n                            });\n\n                        return throwError(exception);\n                    })\n                );\n        } else {\n            return this.http.get(`${endpoint}`)\n                .pipe(\n                    catchError((exception: any): any => {\n                        if (exception && exception.status === 403)\n                            this.messageService.add({\n                                severity: 'error',\n                                summary: this.translateService.instant('hcm.payroll.error'),\n                                detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed_search\"),\n                                sticky: true,\n                            });\n\n                        return throwError(exception);\n                    })\n                );\n        }\n    }\n\n    private postUrlDataLookup(endpoint: string, httpParams: any): Observable<any> {\n        if (httpParams) {\n            return this.http.post(`${endpoint}`, { ...httpParams })\n                .pipe(\n                    catchError((exception: any): any => {\n                        if (exception.status === 403)\n                            this.messageService.add({\n                                severity: 'error',\n                                summary: this.translateService.instant('hcm.payroll.error'),\n                                detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed\"),\n                                sticky: true,\n                            });\n\n                        return throwError(exception);\n                    })\n                );\n        } else {\n            return this.http.post(`${endpoint}`, {})\n                .pipe(\n                    catchError((exception: any): any => {\n                        if (exception.status === 403)\n                            this.messageService.add({\n                                severity: 'error',\n                                summary: this.translateService.instant('hcm.payroll.error'),\n                                detail: this.translateService.instant(\"hcm.payroll.permission_error_not_allowed\"),\n                                sticky: true,\n                            });\n\n                        return throwError(exception);\n                    })\n                );\n        }\n    }\n}\n"]}

package/esm2015/services/permissions.service.js

@@ -0,0 +1,89 @@
+import * as tslib_1 from "tslib";
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { service, user } from '@seniorsistemas/senior-platform-data';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+let PermissionService = class PermissionService {
+    constructor(http) {
+        this.http = http;
+        this.actionUrl = `platform/authorization/queries/checkAccess`;
+        this.resourceAddress = `res://senior.com.br/hcm/payroll/`;
+        this.defaultActions = ['Visualizar', 'Incluir', 'Editar', 'Excluir'];
+        this._resources = [];
+        this._attributes = [];
+        user.getAuthHeader().then(token => {
+            this.httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    Authorization: token,
+                }),
+            };
+        });
+        service.getRestUrl().then(restUrl => (this.restUrl = restUrl));
+    }
+    get(resource = '') {
+        if (this.permissions) {
+            this.observable = Observable.of(this.permissions);
+        }
+        else if (!this.observable) {
+            this.observable = this.getPermissions().pipe(map((permissions) => (this.permissions = permissions)));
+        }
+        return this.observable.pipe(map((permissions) => (resource ? permissions[resource] : permissions)));
+    }
+    getAbac(resource, attributes) {
+        this.attributes = attributes;
+        return this.getAbacPermission(resource);
+    }
+    getAbacPermission(resource) {
+        return this.http.post(this.actionUrl, {
+            includeFilters: false,
+            permissions: [
+                {
+                    resource: `${this.resourceAddress}${resource}`,
+                    action: 'Visualizar',
+                    attributes: this._attributes.map((res) => ({
+                        attribute: res.name,
+                        value: res.value,
+                    })),
+                }
+            ]
+        }, this.httpOptions);
+    }
+    getPermissions() {
+        const permissions = [];
+        this._resources.forEach((resource) => this.defaultActions.forEach((action) => permissions.push({ action, resource: `${this.resourceAddress}${resource}` })));
+        return this.http
+            .post(this.actionUrl, {
+            includeFilters: false,
+            permissions: [
+                ...permissions
+            ]
+        }, this.httpOptions)
+            .pipe(map((res) => {
+            const permissoes = res.permissions;
+            const values = {};
+            permissoes.forEach((perm) => {
+                const name = perm.resource.replace(this.resourceAddress, '');
+                values[name] = values[name] || {};
+                values[name][perm.action.toLowerCase()] = perm.authorized;
+            });
+            return values;
+        }));
+    }
+    set attributes(value) {
+        this._attributes = value;
+    }
+    setResources(values) {
+        this._resources = values;
+    }
+};
+PermissionService.ctorParameters = () => [
+    { type: HttpClient }
+];
+PermissionService = tslib_1.__decorate([
+    Injectable()
+], PermissionService);
+export { PermissionService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["services/permissions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { service, user } from '@seniorsistemas/senior-platform-data';\nimport { from, Observable } from 'rxjs';\nimport { flatMap, map } from 'rxjs/operators';\n\n@Injectable()\nexport class PermissionService {\n    private actionUrl = `platform/authorization/queries/checkAccess`;\n    private resourceAddress = `res://senior.com.br/hcm/payroll/`;\n    private defaultActions = ['Visualizar', 'Incluir', 'Editar', 'Excluir'];\n    private _resources: string[] = [];\n    private _attributes: { name: string; value: string }[] = [];\n    private observable: Observable<any>;\n    private permissions: any;\n    private httpOptions;\n    private restUrl;\n\n    constructor(private http: HttpClient) {\n        user.getAuthHeader().then(token => {\n            this.httpOptions = {\n                headers: new HttpHeaders({\n                    'Content-Type': 'application/json',\n                    Accept: 'application/json',\n                    Authorization: token,\n                }),\n            };\n        });\n\n        service.getRestUrl().then(restUrl => (this.restUrl = restUrl));\n    }\n\n    protected get(resource: string = ''): Observable<any> {\n        if (this.permissions) {\n            this.observable = Observable.of(this.permissions);\n        } else if (!this.observable) {\n            this.observable = this.getPermissions().pipe(map((permissions: any) => (this.permissions = permissions)));\n        }\n\n        return this.observable.pipe(map((permissions: any) => (resource ? permissions[resource] : permissions)));\n    }\n\n    protected getAbac(resource: string, attributes: { name: string; value: string }[]): Observable<any> {\n        this.attributes = attributes;\n\n        return this.getAbacPermission(resource);\n    }\n\n    private getAbacPermission(resource: string): Observable<any> {\n        return this.http.post(\n            this.actionUrl,\n            {\n                includeFilters: false,\n                permissions: [\n                    {\n                        resource: `${this.resourceAddress}${resource}`,\n                        action: 'Visualizar',\n                        attributes: this._attributes.map((res: { name: string; value: string }) => ({\n                            attribute: res.name,\n                            value: res.value,\n                        })),\n                    }\n                ]\n            },\n            this.httpOptions\n        );\n    }\n\n    private getPermissions() {\n        const permissions = [];\n        this._resources.forEach((resource: string) =>\n            this.defaultActions.forEach((action: string) =>\n                permissions.push({ action, resource: `${this.resourceAddress}${resource}` })\n            )\n        );\n        return this.http\n            .post(this.actionUrl, {\n                includeFilters: false,\n                permissions: [\n                    ...permissions\n                ]\n            },\n                this.httpOptions\n            )\n            .pipe(\n                map((res: any) => {\n                    const permissoes = res.permissions;\n                    const values = {};\n\n                    permissoes.forEach((perm: any) => {\n                        const name = perm.resource.replace(this.resourceAddress, '');\n                        values[name] = values[name] || {};\n                        values[name][perm.action.toLowerCase()] = perm.authorized;\n                    });\n\n                    return values;\n                })\n            );\n    }\n\n    private set attributes(value: { name: string; value: string }[]) {\n        this._attributes = value;\n    }\n\n    protected setResources(values: string[]) {\n        this._resources = values;\n    }\n}\n"]}

package/esm2015/services/report.service.js

@@ -0,0 +1,109 @@
+import * as tslib_1 from "tslib";
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { map } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const ENDPOINTS = {
+    reportParameters: "platform/report/queries/getParameters",
+    reportUri: "platform/report/queries/getReportUri",
+    reportStatus: "platform/report/queries/getReportStatus",
+    reportsByName: "platform/report/queries/findReportsByName",
+    reportsRunning: "platform/report/queries/getRunningReports",
+    reportsGenerate: "platform/report/actions/generateReport"
+};
+let ReportService = class ReportService {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Procura por relatórios que contenham no seu nome a string conforme parâmetro `name`
+     * @param name Nome ou parte do nome do relatório
+     */
+    findReportsByName(name) {
+        return this.http
+            .post(`${ENDPOINTS.reportsByName}`, {
+            name: name
+        })
+            .pipe(map((payload) => {
+            const result = payload.reports ? payload.reports : [];
+            return result;
+        }));
+    }
+    /**
+     * Procura por relatórios que contenham o nome exato conforme parâmetro `name`.
+     * No momento a plataforma não disponibilza uma query exata para isso.
+     * Portanto este método procura pelo nome informado dentro do resultado da query `findReportsByName`
+     * @param name Nome exato do relatório
+     */
+    findReportByName(name) {
+        name = name || "";
+        return this.findReportsByName(name).pipe(map((payload) => {
+            const filtered = payload && payload.filter((report) => report.name && report.name === name);
+            return filtered && filtered.length == 1 ? filtered[0] : null;
+        }));
+    }
+    /**
+     * Retorna a lista de parâmetros de entrada do relatório
+     * @param reportId Id do relatório
+     * @param reportFileId Identificador de um arquivo de relatório (opcional)
+     */
+    getParameters(reportId, reportFileId) {
+        return this.http
+            .post(`${ENDPOINTS.reportParameters}`, { id: reportId, reportFileId: reportFileId })
+            .pipe(map((payload) => {
+            return payload ? payload : null;
+        }));
+    }
+    /**
+     * Retorna a URL para visualização do relatório gerado
+     * @param reportTicket Ticket do relatório gerado
+     */
+    getReportUri(reportTicket) {
+        return this.http.post(`${ENDPOINTS.reportUri}`, { reportTicket: reportTicket }).pipe(map((payload) => {
+            return payload && payload.reportUri;
+        }));
+    }
+    /**
+     * Retorna o status do relatório
+     * @param reportTicket Ticket do relatório gerado
+     */
+    getReportStatus(reportTicket) {
+        return this.http.post(`${ENDPOINTS.reportStatus}`, { reportTicket: reportTicket }).pipe(map((payload) => {
+            return payload && payload.reportStatus;
+        }));
+    }
+    /**
+     * Gera o relatório
+     * @param reportIn Dados do relatório a ser gerado
+     */
+    generateReport(reportIn) {
+        return this.http.post(`${ENDPOINTS.reportsGenerate}`, reportIn).pipe(map((payload) => {
+            return payload ? payload : null;
+        }));
+    }
+    /**
+     * Retorna uma lista com os relatórios sendo executados ou já finalizados
+     * @param page página inicial
+     * @param size tamanho da página
+     */
+    getRunningReports(page, size) {
+        return this.http.post(`${ENDPOINTS.reportsRunning}`, {
+            offset: page,
+            limit: size,
+            orderByDesc: true,
+            filterCancelled: true
+        });
+    }
+};
+ReportService.ctorParameters = () => [
+    { type: HttpClient }
+];
+ReportService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function ReportService_Factory() { return new ReportService(i0.ɵɵinject(i1.HttpClient)); }, token: ReportService, providedIn: "root" });
+ReportService = tslib_1.__decorate([
+    Injectable({
+        providedIn: "root"
+    })
+], ReportService);
+export { ReportService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["services/report.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { Injectable } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\nimport { Report, ReportIn, ReportOut, GetParametersOut } from \"../core/interfaces\";\n\nconst ENDPOINTS = {\n    reportParameters: \"platform/report/queries/getParameters\",\n    reportUri: \"platform/report/queries/getReportUri\",\n    reportStatus: \"platform/report/queries/getReportStatus\",\n    reportsByName: \"platform/report/queries/findReportsByName\",\n    reportsRunning: \"platform/report/queries/getRunningReports\",\n    reportsGenerate: \"platform/report/actions/generateReport\"\n};\n\n@Injectable({\n    providedIn: \"root\"\n})\nexport class ReportService {\n    constructor(private http: HttpClient) {}\n\n    /**\n     * Procura por relatórios que contenham no seu nome a string conforme parâmetro `name`\n     * @param name Nome ou parte do nome do relatório\n     */\n    public findReportsByName(\n        name: string,\n    ): Observable<Report[]> {\n        return this.http\n            .post(`${ENDPOINTS.reportsByName}`, {\n                name: name\n            })\n            .pipe(\n                map((payload: any) => {\n                    const result = payload.reports ? payload.reports : [];\n                    return result as Report[];\n                })\n            );\n    }\n\n    /**\n     * Procura por relatórios que contenham o nome exato conforme parâmetro `name`.\n     * No momento a plataforma não disponibilza uma query exata para isso.\n     * Portanto este método procura pelo nome informado dentro do resultado da query `findReportsByName`\n     * @param name Nome exato do relatório\n     */\n    public findReportByName(\n        name: string,\n    ): Observable<Report> {\n        name = name || \"\";\n        return this.findReportsByName(name).pipe(\n            map((payload: any) => {\n                const filtered =\n                    payload && payload.filter((report: any) => report.name && report.name === name);\n                return filtered && filtered.length == 1 ? (filtered[0] as Report) : null;\n            })\n        );\n    }\n\n    /**\n     * Retorna a lista de parâmetros de entrada do relatório\n     * @param reportId Id do relatório\n     * @param reportFileId Identificador de um arquivo de relatório (opcional)\n     */\n    public getParameters(reportId: string, reportFileId?: any): Observable<GetParametersOut> {\n        return this.http\n            .post(`${ENDPOINTS.reportParameters}`, { id: reportId, reportFileId: reportFileId })\n            .pipe(\n                map((payload: any) => {\n                    return payload ? (payload as GetParametersOut) : null;\n                })\n            );\n    }\n\n    /**\n     * Retorna a URL para visualização do relatório gerado\n     * @param reportTicket Ticket do relatório gerado\n     */\n    public getReportUri(reportTicket: string): Observable<string> {\n        return this.http.post(`${ENDPOINTS.reportUri}`, { reportTicket: reportTicket }).pipe(\n            map((payload: any) => {\n                return payload && payload.reportUri;\n            })\n        );\n    }\n\n    /**\n     * Retorna o status do relatório\n     * @param reportTicket Ticket do relatório gerado\n     */\n    public getReportStatus(reportTicket: string): Observable<string> {\n        return this.http.post(`${ENDPOINTS.reportStatus}`, { reportTicket: reportTicket }).pipe(\n            map((payload: any) => {\n                return payload && payload.reportStatus;\n            })\n        );\n    }\n\n    /**\n     * Gera o relatório\n     * @param reportIn Dados do relatório a ser gerado\n     */\n    public generateReport(reportIn: ReportIn): Observable<ReportOut> {\n        return this.http.post(`${ENDPOINTS.reportsGenerate}`, reportIn).pipe(\n            map((payload: any) => {\n                return payload ? (payload as ReportOut) : null;\n            })\n        );\n    }\n\n    /**\n     * Retorna uma lista com os relatórios sendo executados ou já finalizados\n     * @param page página inicial\n     * @param size tamanho da página\n     */\n    public getRunningReports(page: number, size: number): Observable<any> {\n        return this.http.post(`${ENDPOINTS.reportsRunning}`, {\n            offset: page,\n            limit: size,\n            orderByDesc: true,\n            filterCancelled: true\n        });\n    }\n}\n"]}