@senior-gestao-pessoas/payroll-core 9.8.0-feature-hcmgdp-12459-4d08efe5 → 9.9.0-feature-hcmgdp-12490-b88ad694

package/components/transportation-voucher-scale-lookup/autocomplete.service.d.ts

@@ -0,0 +1,31 @@
+import { HttpClientService } from '../shared/http-client.service';
+import { ServiceType } from '../../core/enums/serviceType';
+export declare class AutocompleteService {
+    private httpClienteService;
+    constructor(httpClienteService: HttpClientService);
+    getAutoComplete(entity: string, params: object, searchFields: any, codeIsString: boolean, service: ServiceType): import("rxjs").Observable<any>;
+    getAutoCompleteQuery(query: string, params: object, service?: ServiceType): import("rxjs").Observable<any>;
+    /**
+     * Gera os parametros de pesquisa via pesquisa na grid
+     * @param filterData
+     */
+    private generateGridParameters;
+    /**
+     * 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
+     */
+    private getParameterByType;
+    /**
+     * Retorna o filtro formatador para ser chamdo no endpoint
+     * @param valueFilterSearch valor pra adicionar no filtro
+     */
+    private getParameterBySearchType;
+    /**
+     * Formata o filtro quando for "Ou"
+     * @param attribute Nome do atributo da entidade.
+     * @param value Valor da propriedade do objeto.
+     */
+    private getSearchFilterString;
+}

package/components/transportation-voucher-scale-lookup/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./transportation-voucher-scale-lookup.component";
+export * from "./transportation-voucher-scale-lookup.module";
+export * from "./transportation-voucher-scale-lookup.dto";
+export * from "./autocomplete.service";
+export * from "./lookup.service";

package/components/transportation-voucher-scale-lookup/lookup.service.d.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from "@angular/common/http";
+import { TranslateService } from "@ngx-translate/core";
+import { FormField } from "@seniorsistemas/angular-components";
+import { MessageService } from "primeng/api";
+import { Observable } from "rxjs";
+export declare class LookupService {
+    private http;
+    private messageService;
+    private translateService;
+    private concatFields;
+    private concatOtherFields;
+    private lookupDisplayField;
+    private httpPostParams;
+    private page;
+    constructor(http: HttpClient, messageService: MessageService, translateService: TranslateService);
+    lookupRequestPost(httpPostParams: any, endpoint: string, concatFields: Array<FormField>, lookupDisplayField: string): Observable<any>;
+    postConfigPageSize(httpPostParams: any): void;
+    /**
+     * POST
+     * @param endpoint Busca e faz o tratamento dos dados do lookup.
+     * @param httpParams HttpParams
+     */
+    private postDataLookup;
+    /**
+     * Converte o valor do campo para apresentação no lookup.
+     *
+     * @param content Valor do campo para conversão.
+     * @param field FormField do campo.
+     */
+    private convertLookupFieldValue;
+    /**
+     * Converte os dados para visualização na grid
+     * @param content
+     */
+    private convertGridFieldValue;
+    /**
+     * Faz a concatenação de valores do registro para ser apresentado no lookup ao selecionar o dado.
+     * @param contentValue Valor do registro.
+     */
+    private generateDisplayFieldValue;
+    /**
+     * Faz a requisição POST na URL do lookup.
+     * @param endpoint - URL do endpoint.
+     * @param httpParams - Parâmetros HTTP.
+     */
+    private postUrlDataLookup;
+}

package/components/transportation-voucher-scale-lookup/transportation-voucher-scale-lookup.component.d.ts

@@ -0,0 +1,80 @@
+import { OnDestroy, OnInit, ElementRef, EventEmitter, AfterViewInit, ChangeDetectorRef } from "@angular/core";
+import { FormGroup } from "@angular/forms";
+import { TranslateService } from "@ngx-translate/core";
+import { FieldType, FormField } from "@seniorsistemas/angular-components";
+import { BehaviorSubject } from "rxjs";
+import { AutocompleteService } from "./autocomplete.service";
+import { LookupService } from "./lookup.service";
+export declare class TransportationVoucherScaleLookupComponent implements OnInit, OnDestroy, AfterViewInit {
+    private autocompleteService;
+    private lookupService;
+    private translate;
+    private cdr;
+    transportationVoucherScaleEl: ElementRef;
+    required: boolean;
+    disabled: boolean;
+    form: FormGroup;
+    name: string;
+    onSelect: EventEmitter<any>;
+    onClear: EventEmitter<any>;
+    onBlur: EventEmitter<any>;
+    lookupSuggestions: any[];
+    searchGridData: FormField[];
+    suggestionsObservable: BehaviorSubject<any>;
+    totalRecords: number;
+    private concatFieldsName;
+    private concatName;
+    gridFields: FormField[];
+    searchFields: (FormField | {
+        name: string;
+        label: any;
+        type: FieldType;
+        dataKey?: undefined;
+        appendTo?: undefined;
+        fullWidth?: undefined;
+        onSearch?: undefined;
+        suggestionsObservable?: undefined;
+        displayField?: undefined;
+    } | {
+        name: string;
+        type: FieldType;
+        label: any;
+        dataKey: string;
+        appendTo: string;
+        fullWidth: boolean;
+        onSearch: (val: string) => void;
+        suggestionsObservable: BehaviorSubject<any>;
+        displayField: string;
+    })[];
+    transportationVoucherScaleFilterForm: FormGroup;
+    private unsubscribe;
+    private initialLoad;
+    constructor(autocompleteService: AutocompleteService, lookupService: LookupService, translate: TranslateService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Evento disparado ao selecionar um item no lookup
+     */
+    selectOption(event: any): void;
+    /**
+     * Evento disparado ao limpar o campo
+     */
+    onClearItem(event: any): void;
+    /**
+     * Requisição de busca no lookup
+     */
+    searchRequest($event: any): void;
+    /**
+     * Formata o evento de pesquisa
+     */
+    private getValueEvent;
+    /**
+     * Busca dados do autocomplete
+     */
+    private getAutoComplete;
+    /**
+     * Busca dados via query customizada
+     */
+    private getAutocompleteQuery;
+}

package/components/transportation-voucher-scale-lookup/transportation-voucher-scale-lookup.dto.d.ts

@@ -0,0 +1,8 @@
+export declare class TransportationVoucherScaleLookupDto {
+    private code?;
+    private searchText?;
+    private transportationVoucherScaleGroupId?;
+    private page;
+    constructor(payload: any);
+    getToFilter(): this;
+}

package/components/transportation-voucher-scale-lookup/transportation-voucher-scale-lookup.module.d.ts

@@ -0,0 +1,2 @@
+export declare class TransportationVoucherScaleLookupModule {
+}

package/esm2015/components/transportation-voucher-scale-lookup/autocomplete.service.js

@@ -0,0 +1,114 @@
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClientService } from '../shared/http-client.service';
+import { CoreFieldType } from '../../core/enums/coreFieldType';
+import { FieldType } from '@seniorsistemas/angular-components';
+import * as _moment from 'moment';
+import { map } from 'rxjs/operators';
+import { ServiceType } from '../../core/enums/serviceType';
+const moment = _moment;
+let AutocompleteService = class AutocompleteService {
+    constructor(httpClienteService) {
+        this.httpClienteService = httpClienteService;
+    }
+    getAutoComplete(entity, params, searchFields, codeIsString, service) {
+        const getParams = this.generateGridParameters(params, searchFields, codeIsString);
+        return this.httpClienteService.getAutoComplete(entity, getParams, service)
+            .pipe(map((result) => result && result.contents));
+    }
+    getAutoCompleteQuery(query, params, service = ServiceType.PAYROLL) {
+        return this.httpClienteService.query(query, params, service)
+            .pipe(map((data) => data && data.result));
+    }
+    /**
+     * Gera os parametros de pesquisa via pesquisa na grid
+     * @param filterData
+     */
+    generateGridParameters(filterData, searchFields, codeIsString) {
+        let gridParameters = "";
+        Object.keys(filterData).forEach((attribute) => {
+            const filterSearchField = searchFields && searchFields.filter(field => attribute === field.name)[0];
+            let filterQueryString = null;
+            let operatorsQuery = "";
+            let searchField = filterSearchField && filterSearchField.type;
+            if (!filterSearchField && attribute != CoreFieldType.searchValue)
+                searchField = FieldType.String;
+            if (!filterSearchField && attribute === CoreFieldType.searchValue)
+                searchField = CoreFieldType.searchValue;
+            if (gridParameters)
+                operatorsQuery = " and ";
+            filterQueryString = this.getParameterByType(searchField, attribute, filterData[attribute], codeIsString);
+            if (filterQueryString)
+                gridParameters += ` ${operatorsQuery} ${filterQueryString}`;
+        });
+        return 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, codeIsString) {
+        if (!value && type != CoreFieldType.searchValue)
+            return `${attribute} is null`;
+        if (value && value === 'not null' && type != CoreFieldType.searchValue)
+            return `${attribute} is not null`;
+        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}'`;
+            case CoreFieldType.searchValue:
+                return `${this.getParameterBySearchType(value, codeIsString)}`;
+            default:
+                return this.getSearchFilterString(attribute, value);
+        }
+    }
+    /**
+     * Retorna o filtro formatador para ser chamdo no endpoint
+     * @param valueFilterSearch valor pra adicionar no filtro
+     */
+    getParameterBySearchType(valueFilterSearch, codeIsString) {
+        let searchFilter = "";
+        if (valueFilterSearch) {
+            for (const [key, value] of Object.entries(valueFilterSearch)) {
+                if (key === "code" && Number(value)) {
+                    const hasQuote = codeIsString ? "'" : "";
+                    if (searchFilter)
+                        searchFilter += ` or ${key} eq ${hasQuote}${value}${hasQuote}`;
+                    else
+                        searchFilter += `${key} eq ${hasQuote}${value}${hasQuote}`;
+                }
+                else if (key != "code") {
+                    if (searchFilter)
+                        searchFilter += ` or ${this.getSearchFilterString(key, value)}`;
+                    else
+                        searchFilter += this.getSearchFilterString(key, value);
+                }
+            }
+            searchFilter = searchFilter ? `(${searchFilter})` : '';
+        }
+        return searchFilter;
+    }
+    /**
+     * Formata o filtro quando for "Ou"
+     * @param attribute Nome do atributo da entidade.
+     * @param value Valor da propriedade do objeto.
+     */
+    getSearchFilterString(attribute, value) {
+        return `contains(tolower(${attribute}), '${value.toLowerCase()}')`;
+    }
+};
+AutocompleteService.ctorParameters = () => [
+    { type: HttpClientService }
+];
+AutocompleteService = tslib_1.__decorate([
+    Injectable()
+], AutocompleteService);
+export { AutocompleteService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/transportation-voucher-scale-lookup/autocomplete.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClientService } from '../shared/http-client.service';\nimport { CoreFieldType } from '../../core/enums/coreFieldType';\nimport { FieldType } from '@seniorsistemas/angular-components';\nimport * as _moment from 'moment';\nimport { map } from 'rxjs/operators';\nimport { ServiceType } from '../../core/enums/serviceType';\n\nconst moment = _moment;\n\n@Injectable()\nexport class AutocompleteService {\n\n    constructor(private httpClienteService: HttpClientService) { }\n\n    public getAutoComplete(entity: string, params: object, searchFields: any, codeIsString: boolean, service: ServiceType) {\n        const getParams = this.generateGridParameters(params, searchFields, codeIsString);\n        return this.httpClienteService.getAutoComplete(entity, getParams, service)\n            .pipe(map((result) => result && result.contents));\n    }\n\n    public getAutoCompleteQuery(query: string, params: object, service: ServiceType = ServiceType.PAYROLL) {\n        return this.httpClienteService.query(query, params, service)\n            .pipe(map((data) => data && data.result));\n    }\n\n    /**\n     * Gera os parametros de pesquisa via pesquisa na grid\n     * @param filterData\n     */\n    private generateGridParameters(filterData: object, searchFields: any, codeIsString: boolean): string {\n        let gridParameters = \"\";\n        Object.keys(filterData).forEach((attribute: string) => {\n            const filterSearchField = searchFields && searchFields.filter(field => attribute === field.name)[0];\n            let filterQueryString = null;\n            let operatorsQuery = \"\";\n            let searchField: any = filterSearchField && filterSearchField.type;\n            if (!filterSearchField && attribute != CoreFieldType.searchValue) searchField = FieldType.String;\n            if (!filterSearchField && attribute === CoreFieldType.searchValue) searchField = CoreFieldType.searchValue;\n            if (gridParameters) operatorsQuery = \" and \";\n            filterQueryString = this.getParameterByType(searchField, attribute, filterData[attribute], codeIsString);\n            if (filterQueryString) gridParameters += ` ${operatorsQuery} ${filterQueryString}`;\n        });\n        return 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: any, attribute: string, value: any, codeIsString: boolean): string {\n        if (!value && type != CoreFieldType.searchValue) return `${attribute} is null`;\n        if (value && value === 'not null' && type != CoreFieldType.searchValue) return `${attribute} is not null`;\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            case CoreFieldType.searchValue:\n                return `${this.getParameterBySearchType(value, codeIsString)}`;\n            default:\n                return this.getSearchFilterString(attribute, value);\n        }\n    }\n\n    /**\n     * Retorna o filtro formatador para ser chamdo no endpoint\n     * @param valueFilterSearch valor pra adicionar no filtro\n     */\n    private getParameterBySearchType(valueFilterSearch: any, codeIsString: boolean): string {\n        let searchFilter = \"\";\n        if (valueFilterSearch) {\n            for (const [key, value] of Object.entries(valueFilterSearch)) {\n                if (key === \"code\" && Number(value)) {\n                    const hasQuote = codeIsString ? \"'\" : \"\";\n                    if (searchFilter)\n                        searchFilter += ` or ${key} eq ${hasQuote}${value}${hasQuote}`;\n                    else\n                        searchFilter += `${key} eq ${hasQuote}${value}${hasQuote}`;\n                } else if (key != \"code\") {\n                    if (searchFilter)\n                        searchFilter += ` or ${this.getSearchFilterString(key, value)}`;\n                    else\n                        searchFilter += this.getSearchFilterString(key, value);\n                }\n            }\n            searchFilter = searchFilter ? `(${searchFilter})` : '';\n        }\n        return searchFilter;\n    }\n\n    /**\n     * Formata o filtro quando for \"Ou\"\n     * @param attribute Nome do atributo da entidade.\n     * @param value Valor da propriedade do objeto.\n     */\n    private getSearchFilterString(attribute: string, value: any): string {\n        return `contains(tolower(${attribute}), '${value.toLowerCase()}')`;\n    }\n}\n"]}

package/esm2015/components/transportation-voucher-scale-lookup/index.js

@@ -0,0 +1,6 @@
+export * from "./transportation-voucher-scale-lookup.component";
+export * from "./transportation-voucher-scale-lookup.module";
+export * from "./transportation-voucher-scale-lookup.dto";
+export * from "./autocomplete.service";
+export * from "./lookup.service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yLWdlc3Rhby1wZXNzb2FzL3BheXJvbGwtY29yZS8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvdHJhbnNwb3J0YXRpb24tdm91Y2hlci1zY2FsZS1sb29rdXAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vdHJhbnNwb3J0YXRpb24tdm91Y2hlci1zY2FsZS1sb29rdXAuY29tcG9uZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90cmFuc3BvcnRhdGlvbi12b3VjaGVyLXNjYWxlLWxvb2t1cC5tb2R1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyYW5zcG9ydGF0aW9uLXZvdWNoZXItc2NhbGUtbG9va3VwLmR0b1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXV0b2NvbXBsZXRlLnNlcnZpY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvb2t1cC5zZXJ2aWNlXCI7XG4iXX0=

package/esm2015/components/transportation-voucher-scale-lookup/lookup.service.js

@@ -0,0 +1,147 @@
+import * as tslib_1 from "tslib";
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { TranslateService } from "@ngx-translate/core";
+import { FieldType } from "@seniorsistemas/angular-components";
+import * as moment_ from "moment";
+import { MessageService } from "primeng/api";
+import { throwError } from "rxjs";
+import { map, catchError } from "rxjs/operators";
+const moment = moment_;
+let LookupService = class LookupService {
+    constructor(http, messageService, translateService) {
+        this.http = http;
+        this.messageService = messageService;
+        this.translateService = translateService;
+    }
+    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;
+        }
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Faz a requisição POST na URL do lookup.
+     * @param endpoint - URL do endpoint.
+     * @param httpParams - Parâmetros HTTP.
+     */
+    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);
+            }));
+        }
+    }
+};
+LookupService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: MessageService },
+    { type: TranslateService }
+];
+LookupService = tslib_1.__decorate([
+    Injectable()
+], LookupService);
+export { LookupService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lookup.service.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/transportation-voucher-scale-lookup/lookup.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { Injectable } from \"@angular/core\";\nimport { TranslateService } from \"@ngx-translate/core\";\nimport { FieldType, FormField } from \"@seniorsistemas/angular-components\";\nimport * as moment_ from \"moment\";\nimport { MessageService } from \"primeng/api\";\nimport { Observable, throwError } from \"rxjs\";\nimport { map, catchError } from \"rxjs/operators\";\nimport { PaginationData } from \"../../core/interfaces\";\n\nconst moment = moment_;\n\n@Injectable()\nexport class LookupService {\n\n    private concatFields: any;\n    private concatOtherFields: any;\n    private lookupDisplayField: string;\n    private httpPostParams: any;\n    private page: PaginationData;\n\n    constructor(private http: HttpClient, private messageService: MessageService, private translateService: TranslateService) {\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     * 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\n        return displayField;\n    }\n\n    /**\n     * Faz a requisição POST na URL do lookup.\n     * @param endpoint - URL do endpoint.\n     * @param httpParams - Parâmetros HTTP.\n     */\n    private postUrlDataLookup(endpoint: string, httpParams: any): Observable<any> {\n        if (httpParams) {\n            return this.http.post(`${endpoint}`, { ...httpParams }).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}`, {}).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"]}