@seniorsistemas/platform-components 5.3.2 → 5.3.3-develop-73308358

package/esm2022/modules/advanced-filter/components/form-filter/form-filter.component.mjs

@@ -0,0 +1,651 @@
+import { ToastService } from "@seniorsistemas/angular-components/toast";
+import { ChangeDetectorRef, Component, EventEmitter, HostListener, Input, Output, inject } from '@angular/core';
+import { BehaviorSubject, from, Subject } from 'rxjs';
+import { filter as rxFilter, map, mergeMap, takeUntil, tap } from 'rxjs/operators';
+import { FilterType, Scope } from '../../models';
+import { ContextTab, TabView } from '../../models/tab-view';
+import { AdvancedFilterService } from '../../services/advanced-filter.service';
+import { FormFilter } from '../../models/form-filter';
+import { filterOperators, fromJson, getFilterId, getSearchType, getTabId, jsonPath, parseFilterValue, toFilterFormat, toUserFormat } from '../../utils/index';
+import { createFormControl } from '../../utils/form-field';
+import { clone, equals } from 'ramda';
+import { compare, isSupportedType, isValidOperator } from '../../utils/comparator';
+import { AutocompleteField, CalendarField, RadioButtonField, CurrencyField, FieldType, NumberField, SelectField, TextField } from '@seniorsistemas/angular-components/dynamic-form';
+import { searchDisplayName, searchKeyName } from '../../shared/constants';
+import { TranslateService } from '@ngx-translate/core';
+import { CalendarOptionsService } from '../../services/calendar-options.service';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/tabview";
+import * as i2 from "@angular/common";
+import * as i3 from "@seniorsistemas/angular-components/dynamic-form";
+import * as i4 from "@seniorsistemas/angular-components/empty-state";
+import * as i5 from "../../pipes/map-values.pipe";
+const TRANSLATE_PREFIX = 'platform.filter_service';
+const TOAST_LIFE = 5000;
+export class FormFilterComponent {
+    filterService = inject(AdvancedFilterService);
+    translate = inject(TranslateService);
+    toastService = inject(ToastService);
+    calendarOptionsService = inject(CalendarOptionsService);
+    changeDetectorRef = inject(ChangeDetectorRef);
+    destroy$ = new Subject();
+    errorState;
+    tabs;
+    contexts = [];
+    formFilters = [];
+    oldFormFilters = [];
+    actualFormFilters = [];
+    general = new TabView({ name: 'Geral' });
+    totalFiltersActive = 0;
+    isMobile = false;
+    tabViewOrientation = 'left';
+    error = false;
+    activeIndex = 0;
+    errorMessages = {
+        min: this.translate.instant(`${TRANSLATE_PREFIX}.error_min_value`),
+        max: this.translate.instant(`${TRANSLATE_PREFIX}.error_max_value`),
+        pattern: this.translate.instant(`${TRANSLATE_PREFIX}.invalid_pattern`)
+    };
+    showMessages = true;
+    isModal = false;
+    contextId = '';
+    totalFiltersActiveOutput = new EventEmitter();
+    errorOutput = new EventEmitter();
+    showDialogOutput = new EventEmitter();
+    closeModalOutput = new EventEmitter();
+    onResizeWindow(event) {
+        const { innerWidth } = event.target;
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+    }
+    ngOnInit() {
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+        this.subscribeContextsObservable();
+        this.subscribeFiltersObservable();
+        window.addEventListener('message', event => {
+            const data = event.data;
+            const message = data.message && data.message.split(':')[1];
+            if (message === 'addContext') {
+                this.filterService.addContexts(...data.payload);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+    }
+    hasChanges() {
+        if (!this.oldFormFilters?.length) {
+            return true;
+        }
+        const filtered = this.formFilters.filter((currentFilter, index) => {
+            const oldFilter = this.oldFormFilters[index];
+            const oldValue = oldFilter ? oldFilter.value : undefined;
+            return !equals(currentFilter.value, oldValue);
+        });
+        return filtered.length > 0;
+    }
+    onApplyFilters() {
+        this.hasChanges() && this.closeModalOutput.emit();
+    }
+    getFilters() {
+        this.hasChanges() && this.filterService.tryAgain(this.contexts);
+    }
+    applyFilters(showToast = false) {
+        if (this.hasChanges()) {
+            this.showDialogOutput.emit(false);
+            this.counterUpdate();
+            const filters = this.getFiltersValues(this.formFilters);
+            this.filterService.saveTickedFilters(filters);
+        }
+        else if (showToast) {
+            const message = {
+                severity: 'info',
+                duration: TOAST_LIFE,
+                text: this.translate.instant(`${TRANSLATE_PREFIX}.applied_filter_nochange`, { activeFilters: this.totalFiltersActive })
+            };
+            this.sendMessage(message);
+        }
+        this.oldFormFilters = clone(this.formFilters);
+    }
+    getDefaultValue(defaultValue, isMultiple) {
+        if (defaultValue === undefined || (isMultiple && defaultValue[0] === '')) {
+            return [];
+        }
+        return defaultValue;
+    }
+    clearFilters() {
+        const keys = Object.keys(this.formFilters);
+        keys.forEach(key => this.cleanFieldAndSetDefaultValue(key));
+    }
+    sendCloseMessage() {
+        window.parent.postMessage({
+            message: 'dashboard:close-modal',
+            payload: {
+                modalName: 'advanced-filter-1'
+            }
+        }, '*');
+    }
+    sendMessage(message) {
+        if (this.showMessages) {
+            this.toastService.show(message);
+        }
+        else {
+            window.parent.postMessage({
+                message: 'dashboard:toastr',
+                payload: {
+                    type: 'success',
+                    message: message.detail
+                }
+            }, '*');
+        }
+    }
+    saveFilters(forceSave = false) {
+        const filters = this.parseToUserFilters(this.formFilters);
+        const savedFilterSuccess = () => {
+            if (!forceSave) {
+                const message = {
+                    severity: 'info',
+                    duration: TOAST_LIFE,
+                    text: this.translate.instant(`${TRANSLATE_PREFIX}.saved_filters_success`, { activeFilters: this.totalFiltersActive })
+                };
+                this.sendMessage(message);
+            }
+            this.counterUpdate();
+        };
+        const savedFiltersError = () => {
+            const message = {
+                severity: 'error',
+                duration: TOAST_LIFE,
+                text: this.translate.instant(`${TRANSLATE_PREFIX}.saved_filters_error`, { activeFilters: this.totalFiltersActive })
+            };
+            this.sendMessage(message);
+        };
+        this.filterService
+            .saveFilters(filters)
+            .subscribe(savedFilterSuccess, savedFiltersError);
+    }
+    saveFiltersWithCallbackFunction(callbackFunction) {
+        const filters = this.parseToUserFilters(this.formFilters);
+        this.filterService
+            .saveFilters(filters)
+            .subscribe(callbackFunction);
+    }
+    counterUpdate() {
+        this.totalFiltersActive = this.countActiveFilters(this.tabs);
+        this.totalFiltersActiveOutput.emit(this.totalFiltersActive);
+    }
+    countActiveFilters(tabs) {
+        let totalFiltersActive = 0;
+        tabs.forEach(tabView => {
+            const { value } = tabView.form;
+            tabView.activeFilters = Object.keys(value).reduce((appliedFilters, key) => {
+                const filterValue = value[key];
+                const isArray = Array.isArray(filterValue);
+                const isValidArray = isArray && filterValue.length > 0;
+                if (isValidArray || (!isArray && filterValue)) {
+                    appliedFilters++;
+                }
+                return appliedFilters;
+            }, 0);
+            totalFiltersActive += tabView.activeFilters;
+        });
+        return totalFiltersActive;
+    }
+    parseToUserFilters(filters) {
+        return filters.reduce((all, filter) => {
+            const { type, services, name, value, domain, contexts } = filter;
+            const filterValue = toUserFormat(value, type);
+            const values = services.map(service => ({ name, service, value: filterValue, domain, contexts }));
+            return [...all, ...values];
+        }, []);
+    }
+    getFiltersValues(filters) {
+        const filtersAsObject = filters;
+        const ids = Object.keys(filtersAsObject);
+        return ids.reduce((all, filterId) => {
+            const { type, services, name, value, domain } = filtersAsObject[filterId];
+            const filterValue = toFilterFormat(value, type);
+            const values = services.map(service => ({ name, service, value: filterValue, domain }));
+            return [...all, ...values];
+        }, []);
+    }
+    subscribeContextsObservable() {
+        const { contextsObserver } = this.filterService;
+        contextsObserver.pipe(takeUntil(this.destroy$)).subscribe((contexts) => (this.contexts = contexts));
+    }
+    errorStateAction() {
+        this.filterService.tryAgain(this.contexts);
+    }
+    subscribeFiltersObservable() {
+        const { filtersObserver } = this.filterService;
+        filtersObserver
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(({ filters, applyFilter, error, message }) => {
+            this.errorOutput.emit(error);
+            this.error = error;
+            this.errorState = message;
+            if (!error) {
+                this.createForm(filters, applyFilter);
+            }
+        });
+    }
+    createForm(filters, applyFilter) {
+        this.tabs = this.createTabs(filters);
+        this.counterUpdate();
+        this.setDependencies(this.formFilters);
+        this.createChildArray();
+        if (filters.length > 0 && applyFilter) {
+            this.applyFilters();
+        }
+    }
+    setDependencies(filters) {
+        const filtersMap = {};
+        filters.forEach(f => {
+            const id = getFilterId(f.domain, f.name);
+            filtersMap[id] = f;
+        });
+        const names = Object.keys(filtersMap);
+        const dependencies = from(names).pipe(map(key => filtersMap[key]), rxFilter(({ dependsOn }) => dependsOn && dependsOn.length > 0), tap(({ dependsOn, domain, filterControl }) => {
+            const invalidFilters = dependsOn
+                .filter(dep => dep.required)
+                .filter(dep => {
+                const id = getFilterId(domain, dep.filterName);
+                const formFilter = filtersMap[id];
+                if (!formFilter) {
+                    return true;
+                }
+                const { value, type } = formFilter;
+                const { comparator } = dep;
+                if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {
+                    const fieldValue = parseFilterValue(value, type);
+                    return !compare(comparator.operator, comparator.value, fieldValue);
+                }
+                return dep.required ? !formFilter.value : formFilter.value;
+            });
+            if (invalidFilters.length > 0) {
+                filterControl.disable();
+            }
+        }), map(({ domain, dependsOn, filterControl }) => ({ domain, dependsOn, filterControl })));
+        dependencies.subscribe(({ dependsOn, domain, filterControl }) => from(dependsOn)
+            .pipe(rxFilter(dep => dep.required), map(({ filterName }) => getFilterId(domain, filterName)), map(filterId => filtersMap[filterId]), mergeMap(formFilter => from(formFilter.valueChanges || [])), map(val => {
+            const comparation = dependsOn.every(dep => {
+                const filterId = getFilterId(domain, dep.filterName);
+                if (this.formFilters[filterId]) {
+                    const type = this.formFilters[filterId].type;
+                    const { comparator } = dep;
+                    if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {
+                        const value = parseFilterValue(val, type);
+                        return compare(comparator.operator, comparator.value, value);
+                    }
+                    return true;
+                }
+                return true;
+            });
+            return !this.IsEmpty(val) && comparation ? 'enable' : 'disable';
+        }))
+            .subscribe(status => filterControl[status]()));
+    }
+    addGeneralField(filter) {
+        const { name, domain, type } = filter;
+        const controlName = getFilterId(domain, name);
+        const fieldControl = createFormControl(filter);
+        fieldControl.valueChanges
+            .pipe(takeUntil(this.destroy$), map(v => parseFilterValue(v, type)), tap(value => (this.formFilters[controlName].value = value)))
+            .subscribe(val => this.tabs.forEach(tab => {
+            const control = tab.form.controls[name];
+            if (control && tab.domain === domain) {
+                control.setValue(val, { emitEvent: false });
+            }
+        }));
+        const newFilter = { ...filter, ...{ name: controlName } };
+        const newField = this.createField(newFilter);
+        this.general.form.addControl(controlName, fieldControl);
+        this.general.fields.push(newField);
+    }
+    /*
+     * Verifica os contextos de cada filtro, caso todos os contextos foram informados:
+     * @return true
+     * Caso não tenha nenhum contexto, considera-se por padrão que é todos:
+     * @return true
+     */
+    containsAllContexts(myContexts) {
+        if (!myContexts.length) {
+            return true;
+        }
+        const allContexts = this.contexts.map(data => data.contextId);
+        return equals(myContexts.sort(), allContexts.sort());
+    }
+    /**
+     *
+     * @todo Refatorar. O método possui muitas responsabilidades
+     *
+     */
+    createTabs(filters) {
+        return filters.reduce((tabs, filter) => {
+            const { domain, services, name, type, scope, contexts, dependsOn, value, search, defaultValue } = filter;
+            const isNotMultiple = search && getSearchType(search).output.maxSelectedItems === 1;
+            const field = this.createField(filter);
+            const filterId = getFilterId(domain, name);
+            const filterConfig = {
+                domain,
+                contexts,
+                services,
+                name,
+                dependsOn,
+                value: fromJson(value, type, isNotMultiple),
+                type,
+                isMultiple: !isNotMultiple,
+                defaultValue: fromJson(defaultValue, type, isNotMultiple)
+            };
+            this.formFilters[filterId] = new FormFilter(filterConfig);
+            const formFilter = this.formFilters[filterId];
+            if (scope === Scope.DOMAIN && this.containsAllContexts(contexts)) {
+                this.addGeneralField(filter);
+            }
+            contexts.forEach(contextId => {
+                if ((contextId === this.contextId) || (this.contextId === '')) {
+                    const tabId = getTabId(domain, contextId);
+                    const fieldControl = createFormControl(filter);
+                    if (!tabs.has(tabId)) {
+                        const { contextLabel } = this.contexts.find(context => context.contextId === contextId);
+                        const tab = new ContextTab({ domain, name: contextLabel });
+                        tabs.set(tabId, tab);
+                    }
+                    fieldControl.valueChanges
+                        .pipe(takeUntil(this.destroy$))
+                        .subscribe((val) => this.updateFilterValue(tabId, name, val, domain, type));
+                    const contextTab = tabs.get(tabId);
+                    contextTab.fields.push(field);
+                    contextTab.form.addControl(filter.name, fieldControl);
+                    if (!formFilter.filterControl) {
+                        formFilter.filterControl = fieldControl;
+                    }
+                }
+            });
+            return tabs;
+        }, new Map());
+    }
+    updateFilterValue(tabId, filterName, value, domain, type) {
+        const controlOpts = { emitEvent: false };
+        const fieldValue = parseFilterValue(value, type);
+        const filterId = getFilterId(domain, filterName);
+        const generalFieldControl = this.general.form.controls[filterId];
+        this.tabs.forEach(({ form }, key) => {
+            const control = form.controls[filterName];
+            if (tabId !== key && control) {
+                control.setValue(value, controlOpts);
+            }
+        });
+        const { childs } = this.formFilters[filterId];
+        childs && childs.forEach((child) => this.cleanFieldAndSetDefaultValue(child.filter.key));
+        generalFieldControl && generalFieldControl.setValue(value, controlOpts);
+        this.formFilters[filterId].value = fieldValue;
+    }
+    cleanFieldAndSetDefaultValue(key) {
+        const { isMultiple, defaultValue, filterControl, type } = this.formFilters[key];
+        const finalValue = this.getDefaultValue(defaultValue, isMultiple);
+        if (filterControl) {
+            if (type === 'DATE' || (type === 'SEARCH' && isMultiple)) {
+                filterControl.setValue(finalValue);
+            }
+            if (type === 'INTEGER' || type === 'DOUBLE' || type === 'MONEY') {
+                finalValue === '' ? filterControl.setValue(null) : filterControl.setValue(finalValue);
+            }
+            else {
+                filterControl.setValue(finalValue, { onlySelf: true });
+            }
+        }
+    }
+    createChildArray() {
+        const keys = Object.keys(this.formFilters);
+        keys.forEach(key => {
+            const { dependsOn, domain } = this.formFilters[key];
+            dependsOn.forEach((field) => {
+                const filterId = getFilterId(domain, field.filterName);
+                if (this.formFilters[filterId]) {
+                    if (!this.formFilters[filterId].childs) {
+                        this.formFilters[filterId].childs = [];
+                    }
+                    this.formFilters[filterId].childs.push({ filter: { key, required: field.required } });
+                }
+            });
+        });
+    }
+    createField(filter) {
+        const { name, label, enumItems, type, mask } = filter;
+        const translatedEnumItems = enumItems && enumItems.map((item) => ({ label: this.translate.instant(item.label), value: item.value }));
+        const field = { name, label: this.translate.instant(label), placeholder: '' };
+        const creators = {
+            [FilterType.STRING]: () => new TextField({ ...field, mask: mask ? () => mask : null, type: FieldType.String }),
+            [FilterType.MONEY]: () => new CurrencyField({ ...field, type: FieldType.Money }),
+            [FilterType.BOOLEAN]: () => this.createRadioButton({ ...field }),
+            [FilterType.DATE]: () => this.createCalendar({ ...field, type: FieldType.Date }),
+            [FilterType.DATETIME]: () => this.createCalendar({ ...field, type: FieldType.DateTime }),
+            [FilterType.TIME]: () => this.createCalendar({ ...field, type: FieldType.Time }),
+            [FilterType.ENUMERATION]: () => new SelectField({
+                ...field,
+                placeholder: this.translate.instant('platform.filter_service.select'),
+                options: [...translatedEnumItems],
+                type: FieldType.Enum
+            }),
+            [FilterType.INTEGER]: () => new NumberField({
+                ...field,
+                numberLocaleOptions: this.optionsInteger(),
+                mask: mask ? () => mask : null,
+                type: FieldType.Integer
+            }),
+            [FilterType.DOUBLE]: () => new CurrencyField({ ...field, type: FieldType.Double }),
+            [FilterType.SEARCH]: () => this.createAutocompleteField(field, filter)
+        };
+        return creators[type]();
+    }
+    createRadioButton(field) {
+        const options = [
+            { label: this.translate.instant(`${TRANSLATE_PREFIX}.yes`), value: true },
+            { label: this.translate.instant(`${TRANSLATE_PREFIX}.no`), value: false }
+        ];
+        return new RadioButtonField({ ...field, type: FieldType.Radio, options });
+    }
+    createCalendar(config) {
+        const calendar = new CalendarField(config);
+        calendar.calendarLocaleOptions = this.calendarOptionsService.getOptions();
+        if (!this.isModal)
+            calendar.appendTo = 'body';
+        return calendar;
+    }
+    createAutocompleteField(field, { dependsOn, search, domain, name }) {
+        const suggestionsObservable = new BehaviorSubject([]);
+        const { queryParam } = getSearchType(search).input;
+        const { displayFields, keyFields, resultDataJsonPath, displayFieldConcatToken, maxSelectedItems } = getSearchType(search).output;
+        const filterId = getFilterId(domain, name);
+        const suggestionsError = (messageError) => {
+            const messageDetail = messageError ? messageError : this.translate.instant(`${TRANSLATE_PREFIX}.find_suggestions_error`, { activeFilters: this.totalFiltersActive });
+            const message = {
+                severity: 'error',
+                duration: TOAST_LIFE,
+                text: messageDetail
+            };
+            this.sendMessage(message);
+        };
+        const onSearch = (val) => {
+            const params = { [queryParam]: val };
+            dependsOn && Object.assign(params, this.getDependenciesValues(dependsOn, domain));
+            const searchUrl = search && search.type === 'ENTITY'
+                ? this.getEntitySearchUrl(search.entitySearch.input, val, dependsOn)
+                : getSearchType(search).input.url;
+            this.filterService
+                .searchFieldSuggestions(searchUrl, params, search.type)
+                .pipe(map(response => jsonPath(response, resultDataJsonPath)), map((suggestions) => this.addSuggestionFields(suggestions, displayFields, keyFields, displayFieldConcatToken, filterId)))
+                .subscribe(result => {
+                suggestionsObservable.next(result);
+                this.changeDetectorRef.detectChanges();
+            }, (error) => {
+                let messageError = undefined;
+                if (error && error.error.message)
+                    messageError = error.error.message;
+                suggestionsError(messageError);
+            });
+        };
+        return new AutocompleteField({
+            ...field,
+            onSearch,
+            appendTo: 'body',
+            suggestionsObservable,
+            displayField: searchDisplayName,
+            dataKey: searchKeyName,
+            multiple: maxSelectedItems > 1,
+            size: { lg: 12, md: 12, xl: 12 },
+            emptyMessage: this.translate.instant(`${TRANSLATE_PREFIX}.search_empty_message`)
+        });
+    }
+    safeReplaceCommas(input, operator) {
+        let output = '';
+        let parenCount = 0;
+        let justAddedOperator = false;
+        for (const char of input) {
+            let charToAdd = char;
+            ({ parenCount, justAddedOperator } = this.updateParenAndOperatorState(char, parenCount, justAddedOperator));
+            ({ charToAdd, justAddedOperator } = this.processCommaSubstitution(char, parenCount, justAddedOperator, operator, charToAdd));
+            justAddedOperator = this.updateNonCommaOperatorState(char, charToAdd, justAddedOperator);
+            output += charToAdd;
+        }
+        return output;
+    }
+    updateParenAndOperatorState(char, parenCount, justAddedOperator) {
+        if (char === '(') {
+            parenCount++;
+            justAddedOperator = false;
+        }
+        else if (char === ')') {
+            parenCount--;
+            justAddedOperator = false;
+        }
+        else {
+            // Nenhuma ação necessária para outros caracteres
+        }
+        return { parenCount, justAddedOperator };
+    }
+    processCommaSubstitution(char, parenCount, justAddedOperator, operator, charToAdd) {
+        if (char === ',') {
+            if (parenCount === 0) {
+                if (!justAddedOperator) {
+                    charToAdd = ` ${operator} `;
+                    justAddedOperator = true;
+                }
+                else {
+                    charToAdd = '';
+                }
+            }
+            else {
+                justAddedOperator = false;
+            }
+        }
+        return { charToAdd, justAddedOperator };
+    }
+    updateNonCommaOperatorState(char, charToAdd, justAddedOperator) {
+        if (char !== ',') {
+            if (charToAdd !== char) {
+                return false;
+            }
+            if (char !== '(' && char !== ')') {
+                return false;
+            }
+        }
+        return justAddedOperator;
+    }
+    getEntitySearchUrl(search, value, dependsOn) {
+        const { attributes, domainName, entityName, serviceName } = search;
+        const url = `${domainName}/${serviceName}/entities/${entityName}/?filter=`;
+        const filters = attributes.map(attr => filterOperators[attr.comparator](attr.name, value));
+        dependsOn &&
+            dependsOn.forEach(obj => {
+                const filterId = getFilterId(domainName, obj.filterName);
+                const fieldValue = this.formFilters[filterId].value[searchKeyName];
+                filters.push(`${obj.entityAttribute} eq '${fieldValue}'`);
+            });
+        const filtersString = filters.join(',');
+        const finalFilter = this.safeReplaceCommas(filtersString, search.operator);
+        return url.concat(finalFilter);
+    }
+    addSuggestionFields(suggestions, displayFields, keyFields, separator, filterId) {
+        const addValue = (acc, value, token) => (acc ? `${acc}${token}${value}` : value);
+        const result = suggestions.map(suggestion => ({
+            ...suggestion,
+            [searchDisplayName]: displayFields.reduce((value, display) => {
+                return addValue(value, this.translate.instant(suggestion[display]), separator);
+            }, ''),
+            [searchKeyName]: keyFields.reduce((value, key) => addValue(value, suggestion[key], ', '), '')
+        }));
+        this.formFilters[filterId].invalidValue = result.length === 0;
+        return result.filter(item => {
+            const { value } = this.formFilters[filterId];
+            if (Array.isArray(value)) {
+                const index = value.findIndex((i) => i.$$__keyValue__ === item.$$__keyValue__);
+                if (index === -1) {
+                    return item;
+                }
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    getDependenciesValues(dependencies, domain) {
+        return dependencies.reduce((params, { filterName }) => {
+            const filterId = getFilterId(domain, filterName);
+            if (this.formFilters[filterId]) {
+                const { value, type } = this.formFilters[filterId];
+                if (type === 'ENUMERATION') {
+                    params[filterName] = value;
+                }
+                else {
+                    if (Array.isArray(value)) {
+                        params[filterName] = value.map(arr => arr[searchKeyName]);
+                    }
+                    else {
+                        params[filterName] = value ? value[searchKeyName] : [''];
+                    }
+                }
+                this.IsEmpty(params[filterName]) && delete params[filterName];
+            }
+            return params;
+        }, {});
+    }
+    /*
+     * Verifica se o valor informado é falso, em arrays, é verificado cada item
+     */
+    IsEmpty(value) {
+        return Array.isArray(value) ? value.every(data => !data) : !value;
+    }
+    /**
+     * Return format to specify for integer type field
+     */
+    optionsInteger() {
+        return { currencySymbol: '', decimalSeparator: '', thousandsSeparator: '' };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FormFilterComponent, selector: "s-app-form-filter", inputs: { showMessages: "showMessages", isModal: "isModal", contextId: "contextId" }, outputs: { totalFiltersActiveOutput: "totalFiltersActiveOutput", errorOutput: "errorOutput", showDialogOutput: "showDialogOutput", closeModalOutput: "closeModalOutput" }, host: { listeners: { "window:resize": "onResizeWindow($event)" } }, ngImport: i0, template: "<s-empty-state\n  *ngIf=\"error\"\n  iconClass=\"fa fa-exclamation-triangle\"\n  title=\"{{ errorState?.status }} - {{ errorState?.statusText }}\"\n  (primaryAction)=\"errorStateAction()\"\n  [primaryActionLabel]=\"translate.instant('platform.filter_service.try')\"\n  [description]=\"translate.instant('platform.filter_service.error_state')\"\n></s-empty-state>\n\n<div *ngIf=\"!error\">\n  <p-tabView *ngIf=\"tabs && tabs.size > 1\"\n    [(activeIndex)]=\"activeIndex\">\n\n    <p-tabPanel header=\"{{ general.name }}\" *ngIf=\"general.fields.length\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"general.fields\"\n        [form]=\"general.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n\n    <p-tabPanel *ngFor=\"let tab of (tabs | mapValues)\"\n      header=\"{{ tab.label }}\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"tab.fields\"\n        [form]=\"tab.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n  </p-tabView>\n\n  <div *ngIf=\"tabs && tabs.size === 1\">\n    <s-dynamic-form\n      *ngFor=\"let tab of (tabs | mapValues)\"\n      [errorMessages]=\"errorMessages\"\n      [fields]=\"tab.fields\"\n      [form]=\"tab.form\">\n    </s-dynamic-form>\n  </div>\n</div>\n", styles: [".filter-dialog{width:800px;top:100px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"], dependencies: [{ kind: "component", type: i1.TabView, selector: "p-tabView, p-tabview", inputs: ["style", "styleClass", "controlClose", "scrollable", "activeIndex", "selectOnFocus", "nextButtonAriaLabel", "prevButtonAriaLabel", "autoHideButtons", "tabindex"], outputs: ["onChange", "onClose", "activeIndexChange"] }, { kind: "component", type: i1.TabPanel, selector: "p-tabPanel, p-tabpanel", inputs: ["closable", "headerStyle", "headerStyleClass", "cache", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "selected", "disabled", "header", "leftIcon", "rightIcon"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DynamicFormComponent, selector: "s-dynamic-form", inputs: ["id", "configs", "fields", "form", "errorMessages"] }, { kind: "component", type: i4.EmptyStateComponent, selector: "s-empty-state", inputs: ["id", "title", "iconClass", "description", "showPrimaryAction", "showSecondaryAction", "primaryActionLabel", "secondaryActionLabel", "primaryModel"], outputs: ["primaryAction", "secondaryAction"] }, { kind: "pipe", type: i5.MapValuesPipe, name: "mapValues" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-app-form-filter', template: "<s-empty-state\n  *ngIf=\"error\"\n  iconClass=\"fa fa-exclamation-triangle\"\n  title=\"{{ errorState?.status }} - {{ errorState?.statusText }}\"\n  (primaryAction)=\"errorStateAction()\"\n  [primaryActionLabel]=\"translate.instant('platform.filter_service.try')\"\n  [description]=\"translate.instant('platform.filter_service.error_state')\"\n></s-empty-state>\n\n<div *ngIf=\"!error\">\n  <p-tabView *ngIf=\"tabs && tabs.size > 1\"\n    [(activeIndex)]=\"activeIndex\">\n\n    <p-tabPanel header=\"{{ general.name }}\" *ngIf=\"general.fields.length\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"general.fields\"\n        [form]=\"general.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n\n    <p-tabPanel *ngFor=\"let tab of (tabs | mapValues)\"\n      header=\"{{ tab.label }}\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"tab.fields\"\n        [form]=\"tab.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n  </p-tabView>\n\n  <div *ngIf=\"tabs && tabs.size === 1\">\n    <s-dynamic-form\n      *ngFor=\"let tab of (tabs | mapValues)\"\n      [errorMessages]=\"errorMessages\"\n      [fields]=\"tab.fields\"\n      [form]=\"tab.form\">\n    </s-dynamic-form>\n  </div>\n</div>\n", styles: [".filter-dialog{width:800px;top:100px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"] }]
+        }], propDecorators: { showMessages: [{
+                type: Input
+            }], isModal: [{
+                type: Input
+            }], contextId: [{
+                type: Input
+            }], totalFiltersActiveOutput: [{
+                type: Output
+            }], errorOutput: [{
+                type: Output
+            }], showDialogOutput: [{
+                type: Output
+            }], closeModalOutput: [{
+                type: Output
+            }], onResizeWindow: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-filter.component.js","sourceRoot":"","sources":["../../../../../../lib/src/modules/advanced-filter/components/form-filter/form-filter.component.ts","../../../../../../lib/src/modules/advanced-filter/components/form-filter/form-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { ToastService } from \"@seniorsistemas/angular-components/toast\";\nimport { ChangeDetectorRef, Component, EventEmitter, HostListener, Input, OnDestroy, OnInit, Output, inject } from '@angular/core';\nimport { BehaviorSubject, from, Subject } from 'rxjs';\nimport { filter as rxFilter, map, mergeMap, takeUntil, tap } from 'rxjs/operators';\n\nimport { Context, DependsOn, EntitySearchInput, EnumItem, Filter, FilterType, Scope } from '../../models';\nimport { ContextTab, TabView } from '../../models/tab-view';\nimport { AdvancedFilterService } from '../../services/advanced-filter.service';\nimport { FormFilter } from '../../models/form-filter';\nimport {\n  filterOperators,\n  fromJson,\n  getFilterId,\n  getSearchType,\n  getTabId,\n  jsonPath,\n  parseFilterValue,\n  toFilterFormat,\n  toUserFormat\n} from '../../utils/index';\nimport { createFormControl } from '../../utils/form-field';\nimport { clone, equals } from 'ramda';\nimport { compare, isSupportedType, isValidOperator } from '../../utils/comparator';\n\nimport {\n  AutocompleteField,\n  CalendarField,\n  RadioButtonField,\n  CurrencyField,\n  Field,\n  FieldConfig,\n  FieldType,\n  NumberField,\n  SelectField,\n  TextField,\n  RationButtonOption,\n  CalendarFieldConfig\n} from '@seniorsistemas/angular-components/dynamic-form';\n\nimport { searchDisplayName, searchKeyName } from '../../shared/constants';\nimport { TranslateService } from '@ngx-translate/core';\nimport { CalendarOptionsService } from '../../services/calendar-options.service';\n\nconst TRANSLATE_PREFIX = 'platform.filter_service';\nconst TOAST_LIFE = 5000;\n\n@Component({\n  selector: 's-app-form-filter',\n  templateUrl: './form-filter.component.html',\n  styleUrls: ['./form-filter.component.scss']\n})\nexport class FormFilterComponent implements OnInit, OnDestroy {\n  private readonly filterService = inject(AdvancedFilterService);\n  translate = inject(TranslateService);\n  private readonly toastService = inject(ToastService);\n  private readonly calendarOptionsService = inject(CalendarOptionsService);\n  private readonly changeDetectorRef = inject(ChangeDetectorRef);\n\n  destroy$ = new Subject();\n  errorState: HttpErrorResponse;\n  tabs: Map<string, ContextTab>;\n  contexts: Context[] = [];\n  formFilters: FormFilter[] = [];\n  oldFormFilters: FormFilter[] = [];\n  actualFormFilters: any[] = [];\n  general = new TabView({ name: 'Geral' });\n  totalFiltersActive = 0;\n  isMobile = false;\n  tabViewOrientation = 'left';\n  error = false;\n  activeIndex = 0;\n\n  errorMessages = {\n    min: this.translate.instant(`${TRANSLATE_PREFIX}.error_min_value`),\n    max: this.translate.instant(`${TRANSLATE_PREFIX}.error_max_value`),\n    pattern: this.translate.instant(`${TRANSLATE_PREFIX}.invalid_pattern`)\n  };\n\n  @Input() showMessages = true;\n  @Input() isModal = false;\n  @Input() contextId = '';\n\n\n  @Output() totalFiltersActiveOutput = new EventEmitter<number>();\n  @Output() errorOutput = new EventEmitter<boolean>();\n  @Output() showDialogOutput = new EventEmitter<boolean>();\n  @Output() closeModalOutput = new EventEmitter();\n\n  @HostListener('window:resize', ['$event'])\n  onResizeWindow(event: any) {\n    const { innerWidth } = event.target;\n    this.isMobile = innerWidth <= 640;\n    this.tabViewOrientation = this.isMobile ? 'top' : 'left';\n  }\n\n  ngOnInit() {\n    this.isMobile = innerWidth <= 640;\n    this.tabViewOrientation = this.isMobile ? 'top' : 'left';\n    this.subscribeContextsObservable();\n    this.subscribeFiltersObservable();\n\n    window.addEventListener('message', event => {\n      const data = event.data;\n      const message = data.message && data.message.split(':')[1];\n      if (message === 'addContext') {\n        this.filterService.addContexts(...data.payload);\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next(true);\n  }\n\n  hasChanges(): boolean {\n    if (!this.oldFormFilters?.length) {\n      return true;\n    }\n\n    const filtered = this.formFilters.filter((currentFilter, index) => {\n      const oldFilter = this.oldFormFilters[index];\n      const oldValue = oldFilter ? oldFilter.value : undefined;\n      return !equals(currentFilter.value, oldValue);\n    });\n\n    return filtered.length > 0;\n  }\n\n  onApplyFilters() {\n    this.hasChanges() && this.closeModalOutput.emit();\n  }\n\n  public getFilters() {\n    this.hasChanges() && this.filterService.tryAgain(this.contexts);\n  }\n\n  applyFilters(showToast = false) {\n    if (this.hasChanges()) {\n      this.showDialogOutput.emit(false);\n      this.counterUpdate();\n      const filters = this.getFiltersValues(this.formFilters);\n\n      this.filterService.saveTickedFilters(filters);\n    } else if (showToast) {\n      const message = {\n        severity: 'info',\n        duration: TOAST_LIFE,\n        text: this.translate.instant(`${TRANSLATE_PREFIX}.applied_filter_nochange`, { activeFilters: this.totalFiltersActive })\n      };\n      this.sendMessage(message);\n    }\n    this.oldFormFilters = clone(this.formFilters);\n  }\n\n  getDefaultValue(defaultValue: any, isMultiple: boolean) {\n    if (defaultValue === undefined || (isMultiple && defaultValue[0] === '')) {\n      return [];\n    }\n\n    return defaultValue;\n  }\n\n  clearFilters() {\n    const keys = Object.keys(this.formFilters);\n    keys.forEach(key => this.cleanFieldAndSetDefaultValue(key));\n  }\n\n  sendCloseMessage() {\n    window.parent.postMessage(\n      {\n        message: 'dashboard:close-modal',\n        payload: {\n          modalName: 'advanced-filter-1'\n        }\n      },\n      '*'\n    );\n  }\n\n  sendMessage(message: any) {\n    if (this.showMessages) {\n      this.toastService.show(message);\n    } else {\n      window.parent.postMessage(\n        {\n          message: 'dashboard:toastr',\n          payload: {\n            type: 'success',\n            message: message.detail\n          }\n        },\n        '*'\n      );\n    }\n  }\n\n  saveFilters(forceSave = false) {\n    const filters = this.parseToUserFilters(this.formFilters);\n    const savedFilterSuccess = () => {\n      if (!forceSave) {\n        const message = {\n          severity: 'info',\n          duration: TOAST_LIFE,\n          text: this.translate.instant(`${TRANSLATE_PREFIX}.saved_filters_success`, { activeFilters: this.totalFiltersActive })\n        };\n        this.sendMessage(message);\n      }\n\n      this.counterUpdate();\n    };\n\n    const savedFiltersError = () => {\n      const message = {\n        severity: 'error',\n        duration: TOAST_LIFE,\n        text: this.translate.instant(`${TRANSLATE_PREFIX}.saved_filters_error`, { activeFilters: this.totalFiltersActive })\n      };\n\n      this.sendMessage(message);\n    };\n\n    this.filterService\n      .saveFilters(filters)\n      .subscribe(savedFilterSuccess, savedFiltersError);\n  }\n\n  saveFiltersWithCallbackFunction(callbackFunction: any) {\n    const filters = this.parseToUserFilters(this.formFilters);\n\n    this.filterService\n      .saveFilters(filters)\n      .subscribe(callbackFunction);\n  }\n\n  private counterUpdate() {\n    this.totalFiltersActive = this.countActiveFilters(this.tabs);\n    this.totalFiltersActiveOutput.emit(this.totalFiltersActive);\n  }\n\n  private countActiveFilters(tabs: Map<string, ContextTab>) {\n    let totalFiltersActive = 0;\n\n    tabs.forEach(tabView => {\n      const { value } = tabView.form;\n      tabView.activeFilters = Object.keys(value).reduce((appliedFilters, key) => {\n        const filterValue = value[key];\n        const isArray = Array.isArray(filterValue);\n        const isValidArray = isArray && filterValue.length > 0;\n\n        if (isValidArray || (!isArray && filterValue)) {\n          appliedFilters++;\n        }\n\n        return appliedFilters;\n      }, 0);\n      totalFiltersActive += tabView.activeFilters;\n    });\n\n    return totalFiltersActive;\n  }\n\n  private parseToUserFilters(filters: FormFilter[]) {\n    return filters.reduce((all, filter) => {\n      const { type, services, name, value, domain, contexts } = filter as unknown as Filter;\n      const filterValue = toUserFormat(value, type);\n\n      const values = services.map(service => ({ name, service, value: filterValue, domain, contexts }));\n\n      return [...all, ...values];\n    }, [] as any[]);\n  }\n\n  private getFiltersValues(filters: FormFilter[]) {\n    const filtersAsObject = filters as unknown as { [key: string]: Filter };\n    const ids = Object.keys(filtersAsObject);\n\n    return ids.reduce((all, filterId) => {\n      const { type, services, name, value, domain } = filtersAsObject[filterId];\n      const filterValue = toFilterFormat(value, type);\n      const values = services.map(service => ({ name, service, value: filterValue, domain }));\n\n      return [...all, ...values];\n    }, []);\n  }\n\n  private subscribeContextsObservable() {\n    const { contextsObserver } = this.filterService;\n    contextsObserver.pipe(takeUntil(this.destroy$)).subscribe((contexts: Context[]) => (this.contexts = contexts));\n  }\n\n  errorStateAction() {\n    this.filterService.tryAgain(this.contexts);\n  }\n\n  private subscribeFiltersObservable() {\n    const { filtersObserver } = this.filterService;\n\n    filtersObserver\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(({ filters, applyFilter, error, message }) => {\n        this.errorOutput.emit(error);\n        this.error = error;\n        this.errorState = message;\n        if (!error) {\n          this.createForm(filters, applyFilter)\n        }\n      });\n  }\n\n  private createForm(filters: any, applyFilter: any) {\n    this.tabs = this.createTabs(filters);\n    this.counterUpdate();\n    this.setDependencies(this.formFilters);\n    this.createChildArray();\n    if (filters.length > 0 && applyFilter) {\n      this.applyFilters();\n    }\n  }\n\n  private setDependencies(filters: FormFilter[]) {\n      const filtersMap: Record<string, FormFilter> = {};\n      filters.forEach(f => {\n          const id = getFilterId(f.domain, f.name);\n          filtersMap[id] = f;\n      });\n\n      const names = Object.keys(filtersMap);\n\n      const dependencies = from(names).pipe(\n          map(key => filtersMap[key]),\n          rxFilter(({ dependsOn }) => dependsOn && dependsOn.length > 0),\n          tap(({ dependsOn, domain, filterControl }) => {\n              const invalidFilters = dependsOn\n                  .filter(dep => dep.required)\n                  .filter(dep => {\n                      const id = getFilterId(domain, dep.filterName);\n                      const formFilter = filtersMap[id];\n\n                      if (!formFilter) {\n                          return true;\n                      }\n\n                      const { value, type } = formFilter;\n                      const { comparator } = dep;\n                      if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {\n                          const fieldValue = parseFilterValue(value, type);\n                          return !compare(comparator.operator, comparator.value, fieldValue);\n                      }\n                      return dep.required ? !formFilter.value : formFilter.value;\n                  });\n\n              if (invalidFilters.length > 0) {\n                  filterControl.disable();\n              }\n          }),\n          map(({ domain, dependsOn, filterControl }) => ({ domain, dependsOn, filterControl }))\n      );\n\n      dependencies.subscribe(({ dependsOn, domain, filterControl }) =>\n          from(dependsOn)\n              .pipe(\n                  rxFilter(dep => dep.required),\n                  map(({ filterName }) => getFilterId(domain, filterName)),\n                  map(filterId => filtersMap[filterId]),\n                  mergeMap(formFilter => from(formFilter.valueChanges || [])),\n                  map(val => {\n                      const comparation = dependsOn.every(dep => {\n                          const filterId = getFilterId(domain, dep.filterName);\n                          if (this.formFilters[filterId as any]) {\n                              const type = this.formFilters[filterId as any].type;\n                              const { comparator } = dep;\n                              if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {\n                                  const value = parseFilterValue(val, type);\n                                  return compare(comparator.operator, comparator.value, value);\n                              }\n                              return true;\n                          }\n                          return true;\n                      });\n                      return !this.IsEmpty(val) && comparation ? 'enable' : 'disable';\n                  })\n              )\n              .subscribe(status => filterControl[status]())\n      );\n  }\n\n  private addGeneralField(filter: Filter) {\n    const { name, domain, type } = filter;\n    const controlName = getFilterId(domain, name);\n    const fieldControl = createFormControl(filter);\n\n    fieldControl.valueChanges\n      .pipe(\n        takeUntil(this.destroy$),\n        map(v => parseFilterValue(v, type)),\n        tap(value => (this.formFilters[controlName as any].value = value))\n      )\n      .subscribe(val =>\n        this.tabs.forEach(tab => {\n          const control = tab.form.controls[name];\n          if (control && tab.domain === domain) {\n            control.setValue(val, { emitEvent: false });\n          }\n        })\n      );\n\n    const newFilter = { ...filter, ...{ name: controlName } };\n    const newField = this.createField(newFilter);\n    this.general.form.addControl(controlName, fieldControl);\n    this.general.fields.push(newField);\n  }\n\n  /*\n   * Verifica os contextos de cada filtro, caso todos os contextos foram informados:\n   * @return true\n   * Caso não tenha nenhum contexto, considera-se por padrão que é todos:\n   * @return true\n   */\n  private containsAllContexts(myContexts: string[]) {\n    if (!myContexts.length) {\n      return true;\n    }\n    const allContexts = this.contexts.map(data => data.contextId);\n    return equals(myContexts.sort(), allContexts.sort());\n  }\n\n  /**\n   *\n   * @todo Refatorar. O método possui muitas responsabilidades\n   *\n   */\n  private createTabs(filters: Filter[]) {\n    return filters.reduce((tabs, filter) => {\n      const { domain, services, name, type, scope, contexts, dependsOn, value, search, defaultValue } = filter;\n      const isNotMultiple = search && getSearchType(search).output.maxSelectedItems === 1;\n      const field = this.createField(filter);\n      const filterId = getFilterId(domain, name);\n      const filterConfig = {\n        domain,\n        contexts,\n        services,\n        name,\n        dependsOn,\n        value: fromJson(value, type, isNotMultiple),\n        type,\n        isMultiple: !isNotMultiple,\n        defaultValue: fromJson(defaultValue, type, isNotMultiple)\n      };\n      this.formFilters[filterId as any] = new FormFilter(filterConfig);\n      const formFilter = this.formFilters[filterId as any];\n      if (scope === Scope.DOMAIN && this.containsAllContexts(contexts)) {\n        this.addGeneralField(filter);\n      }\n\n      contexts.forEach(contextId => {\n        if ((contextId === this.contextId) || (this.contextId === '')) {\n          const tabId = getTabId(domain, contextId);\n          const fieldControl = createFormControl(filter);\n\n          if (!tabs.has(tabId)) {\n            const { contextLabel } = this.contexts.find(context => context.contextId === contextId);\n            const tab = new ContextTab({ domain, name: contextLabel });\n            tabs.set(tabId, tab);\n          }\n\n          fieldControl.valueChanges\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((val: any) => this.updateFilterValue(tabId, name, val, domain, type));\n\n          const contextTab = tabs.get(tabId);\n\n\n          contextTab.fields.push(field);\n          contextTab.form.addControl(filter.name, fieldControl);\n\n          if (!formFilter.filterControl) {\n            formFilter.filterControl = fieldControl;\n          }\n        }\n      });\n\n\n      return tabs;\n    }, new Map<string, ContextTab>());\n  }\n\n  private updateFilterValue(tabId: string, filterName: string, value: any, domain: string, type: FilterType) {\n    const controlOpts = { emitEvent: false };\n    const fieldValue = parseFilterValue(value, type);\n    const filterId = getFilterId(domain, filterName);\n    const generalFieldControl = this.general.form.controls[filterId];\n\n    this.tabs.forEach(({ form }, key) => {\n      const control = form.controls[filterName];\n\n      if (tabId !== key && control) {\n        control.setValue(value, controlOpts);\n      }\n    });\n    const { childs } = this.formFilters[filterId as any];\n    childs && childs.forEach((child: any) => this.cleanFieldAndSetDefaultValue(child.filter.key));\n    generalFieldControl && generalFieldControl.setValue(value, controlOpts);\n    this.formFilters[filterId as any].value = fieldValue;\n  }\n\n  private cleanFieldAndSetDefaultValue(key: string) {\n    const { isMultiple, defaultValue, filterControl, type } = this.formFilters[key as any];\n    const finalValue = this.getDefaultValue(defaultValue, isMultiple);\n\n    if (filterControl) {\n      if (type === 'DATE' || (type === 'SEARCH' && isMultiple)) {\n        filterControl.setValue(finalValue);\n      }\n      if (type === 'INTEGER' || type === 'DOUBLE' || type === 'MONEY') {\n        finalValue === '' ? filterControl.setValue(null) : filterControl.setValue(finalValue);\n      } else {\n        filterControl.setValue(finalValue, { onlySelf: true });\n      }\n    }\n  }\n\n  private createChildArray() {\n    const keys = Object.keys(this.formFilters);\n    keys.forEach(key => {\n      const { dependsOn, domain } = this.formFilters[key as any];\n      dependsOn.forEach((field: any) => {\n        const filterId = getFilterId(domain, field.filterName);\n        if (this.formFilters[filterId as any]) {\n          if (!this.formFilters[filterId as any].childs) {\n            this.formFilters[filterId as any].childs = [];\n          }\n          (this.formFilters as any)[filterId].childs.push({ filter: { key, required: field.required } });\n\n        }\n      });\n    });\n  }\n\n  private createField(filter: Filter): Field {\n    const { name, label, enumItems, type, mask } = filter;\n    const translatedEnumItems =\n      enumItems && enumItems.map((item: EnumItem) => ({ label: this.translate.instant(item.label), value: item.value }));\n    const field = { name, label: this.translate.instant(label), placeholder: '' };\n\n    const creators = {\n      [FilterType.STRING]: () => new TextField({ ...field, mask: mask ? () => mask : null, type: FieldType.String }),\n      [FilterType.MONEY]: () => new CurrencyField({ ...field, type: FieldType.Money }),\n      [FilterType.BOOLEAN]: () => this.createRadioButton({ ...field }),\n      [FilterType.DATE]: () => this.createCalendar({ ...field, type: FieldType.Date }),\n      [FilterType.DATETIME]: () => this.createCalendar({ ...field, type: FieldType.DateTime }),\n      [FilterType.TIME]: () => this.createCalendar({ ...field, type: FieldType.Time }),\n      [FilterType.ENUMERATION]: () =>\n        new SelectField({\n          ...field,\n          placeholder: this.translate.instant('platform.filter_service.select'),\n          options: [...translatedEnumItems] as any,\n          type: FieldType.Enum\n        }),\n      [FilterType.INTEGER]: () =>\n        new NumberField({\n          ...field,\n          numberLocaleOptions: this.optionsInteger(),\n          mask: mask ? () => mask : null,\n          type: FieldType.Integer\n        }),\n      [FilterType.DOUBLE]: () => new CurrencyField({ ...field, type: FieldType.Double }),\n      [FilterType.SEARCH]: () => this.createAutocompleteField(field, filter)\n    };\n\n    return creators[type]();\n  }\n\n  private createRadioButton(field: FieldConfig) {\n    const options = [\n      { label: this.translate.instant(`${TRANSLATE_PREFIX}.yes`), value: true },\n      { label: this.translate.instant(`${TRANSLATE_PREFIX}.no`), value: false }\n    ] as RationButtonOption[];\n\n    return new RadioButtonField({ ...field, type: FieldType.Radio, options });\n  }\n\n  private createCalendar(config: CalendarFieldConfig) {\n    const calendar = new CalendarField(config);\n    calendar.calendarLocaleOptions = this.calendarOptionsService.getOptions();\n    if (!this.isModal) calendar.appendTo = 'body';\n    return calendar;\n  }\n\n  private createAutocompleteField(field: FieldConfig, { dependsOn, search, domain, name }: Filter) {\n    const suggestionsObservable = new BehaviorSubject<any[]>([]);\n    const { queryParam } = getSearchType(search).input;\n    const { displayFields, keyFields, resultDataJsonPath, displayFieldConcatToken, maxSelectedItems } = getSearchType(search).output;\n    const filterId = getFilterId(domain, name);\n    const suggestionsError = (messageError?: string) => {\n      const messageDetail = messageError ? messageError : this.translate.instant(`${TRANSLATE_PREFIX}.find_suggestions_error`, { activeFilters: this.totalFiltersActive })\n      const message = {\n        severity: 'error',\n        duration: TOAST_LIFE,\n        text: messageDetail\n      };\n      this.sendMessage(message);\n    };\n    const onSearch = (val: string) => {\n      const params = { [queryParam]: val };\n      dependsOn && Object.assign(params, this.getDependenciesValues(dependsOn, domain));\n\n      const searchUrl =\n        search && search.type === 'ENTITY'\n          ? this.getEntitySearchUrl(search.entitySearch.input, val, dependsOn)\n          : getSearchType(search).input.url;\n\n      this.filterService\n        .searchFieldSuggestions(searchUrl, params, search.type)\n        .pipe(\n          map(response => jsonPath(response, resultDataJsonPath)),\n          map((suggestions: any[]) => this.addSuggestionFields(suggestions, displayFields, keyFields, displayFieldConcatToken, filterId))\n        )\n        .subscribe(result => {\n          suggestionsObservable.next(result);\n          this.changeDetectorRef.detectChanges();\n        }, (error) => {\n          let messageError = undefined\n          if (error && error.error.message) messageError = error.error.message\n          suggestionsError(messageError)\n        });\n    };\n\n    return new AutocompleteField({\n      ...field,\n      onSearch,\n      appendTo: 'body',\n      suggestionsObservable,\n      displayField: searchDisplayName,\n      dataKey: searchKeyName,\n      multiple: maxSelectedItems > 1,\n      size: { lg: 12, md: 12, xl: 12 },\n      emptyMessage: this.translate.instant(`${TRANSLATE_PREFIX}.search_empty_message`)\n    });\n  }\n\n  private safeReplaceCommas(input: string, operator: string): string {\n    let output = '';\n    let parenCount = 0;\n    let justAddedOperator = false;\n\n    for (const char of input) {\n      let charToAdd = char;\n\n      ({ parenCount, justAddedOperator } = this.updateParenAndOperatorState(char, parenCount, justAddedOperator));\n      ({ charToAdd, justAddedOperator } = this.processCommaSubstitution(char, parenCount, justAddedOperator, operator, charToAdd));\n\n      justAddedOperator = this.updateNonCommaOperatorState(char, charToAdd, justAddedOperator);\n      output += charToAdd;\n    }\n\n    return output;\n  }\n\n  private updateParenAndOperatorState(char: string, parenCount: number, justAddedOperator: boolean): { parenCount: number, justAddedOperator: boolean } {\n    if (char === '(') {\n      parenCount++;\n      justAddedOperator = false;\n    } else if (char === ')') {\n      parenCount--;\n      justAddedOperator = false;\n    } else {\n      // Nenhuma ação necessária para outros caracteres\n    }\n\n    return { parenCount, justAddedOperator };\n  }\n\n  private processCommaSubstitution(char: string, parenCount: number, justAddedOperator: boolean, operator: string, charToAdd: string): { charToAdd: string, justAddedOperator: boolean } {\n    if (char === ',') {\n      if (parenCount === 0) {\n        if (!justAddedOperator) {\n          charToAdd = ` ${operator} `;\n          justAddedOperator = true;\n        } else {\n          charToAdd = '';\n        }\n      } else {\n        justAddedOperator = false;\n      }\n    }\n    return { charToAdd, justAddedOperator };\n  }\n\n  private updateNonCommaOperatorState(char: string, charToAdd: string, justAddedOperator: boolean): boolean {\n    if (char !== ',') {\n      if (charToAdd !== char) {\n        return false;\n      }\n\n      if (char !== '(' && char !== ')') {\n        return false;\n      }\n    }\n    return justAddedOperator;\n  }\n\n  private getEntitySearchUrl(search: EntitySearchInput, value: string, dependsOn: DependsOn[]) {\n    const { attributes, domainName, entityName, serviceName } = search;\n    const url = `${domainName}/${serviceName}/entities/${entityName}/?filter=`;\n\n    const filters = attributes.map(attr =>\n      filterOperators[attr.comparator as keyof typeof filterOperators](attr.name, value)\n    );\n\n    dependsOn &&\n      dependsOn.forEach(obj => {\n        const filterId = getFilterId(domainName, obj.filterName);\n        const fieldValue = this.formFilters[filterId as any].value[searchKeyName];\n        filters.push(`${obj.entityAttribute} eq '${fieldValue}'`);\n      });\n\n    const filtersString = filters.join(',');\n    const finalFilter = this.safeReplaceCommas(filtersString, search.operator);\n\n    return url.concat(finalFilter);\n  }\n\n  private addSuggestionFields(suggestions: any[], displayFields: string[], keyFields: string[], separator: string, filterId: string) {\n    const addValue = (acc: string, value: any, token: string) => (acc ? `${acc}${token}${value}` : value);\n\n    const result = suggestions.map(suggestion => ({\n      ...suggestion,\n      [searchDisplayName]: displayFields.reduce((value, display) => {\n        return addValue(value, this.translate.instant(suggestion[display]), separator);\n      }, ''),\n      [searchKeyName]: keyFields.reduce((value, key) => addValue(value, suggestion[key], ', '), '')\n    }));\n    (this.formFilters as any)[filterId].invalidValue = result.length === 0;\n\n\n    return result.filter(item => {\n      const { value } = this.formFilters[filterId as any];\n      if (Array.isArray(value)) {\n        const index = value.findIndex((i: any) => i.$$__keyValue__ === item.$$__keyValue__);\n        if (index === -1) {\n          return item;\n        }\n      } else {\n        return item;\n      }\n    });\n  }\n\n  private getDependenciesValues(dependencies: DependsOn[], domain: string) {\n    return dependencies.reduce((params, { filterName }) => {\n      const filterId = getFilterId(domain, filterName);\n      if ((this.formFilters as any)[filterId]) {\n        const { value, type } = (this.formFilters as any)[filterId];\n        if (type === 'ENUMERATION') {\n          params[filterName] = value;\n        } else {\n          if (Array.isArray(value)) {\n            params[filterName] = value.map(arr => arr[searchKeyName]);\n          } else {\n            params[filterName] = value ? value[searchKeyName] : [''];\n          }\n        }\n        this.IsEmpty(params[filterName]) && delete params[filterName];\n      }\n      return params;\n    }, {} as Record<string, any>);\n  }\n\n\n  /*\n   * Verifica se o valor informado é falso, em arrays, é verificado cada item\n   */\n  private IsEmpty(value: any) {\n    return Array.isArray(value) ? value.every(data => !data) : !value;\n  }\n\n  /**\n   * Return format to specify for integer type field\n   */\n  private optionsInteger() {\n    return { currencySymbol: '', decimalSeparator: '', thousandsSeparator: '' };\n  }\n}\n","<s-empty-state\n  *ngIf=\"error\"\n  iconClass=\"fa fa-exclamation-triangle\"\n  title=\"{{ errorState?.status }} - {{ errorState?.statusText }}\"\n  (primaryAction)=\"errorStateAction()\"\n  [primaryActionLabel]=\"translate.instant('platform.filter_service.try')\"\n  [description]=\"translate.instant('platform.filter_service.error_state')\"\n></s-empty-state>\n\n<div *ngIf=\"!error\">\n  <p-tabView *ngIf=\"tabs && tabs.size > 1\"\n    [(activeIndex)]=\"activeIndex\">\n\n    <p-tabPanel header=\"{{ general.name }}\" *ngIf=\"general.fields.length\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"general.fields\"\n        [form]=\"general.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n\n    <p-tabPanel *ngFor=\"let tab of (tabs | mapValues)\"\n      header=\"{{ tab.label }}\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"tab.fields\"\n        [form]=\"tab.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n  </p-tabView>\n\n  <div *ngIf=\"tabs && tabs.size === 1\">\n    <s-dynamic-form\n      *ngFor=\"let tab of (tabs | mapValues)\"\n      [errorMessages]=\"errorMessages\"\n      [fields]=\"tab.fields\"\n      [form]=\"tab.form\">\n    </s-dynamic-form>\n  </div>\n</div>\n"]}