@senior-gestao-empresarial/angular-components 7.29.1 → 8.0.0

package/esm2022/lookups/lib/erp-lookups.mjs

@@ -0,0 +1,492 @@
+import moment from 'moment';
+import { Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
+/** Filter System Query Option - Operators supported in the expression language */
+export var EnumLogicalOperator;
+(function (EnumLogicalOperator) {
+    /** Equal (Ex: /Suppliers?$filter=Address/City eq 'Redmond') */
+    EnumLogicalOperator["Eq"] = "eq";
+    /** Not equal (Ex: /Suppliers?$filter=Address/City ne 'London') */
+    EnumLogicalOperator["Ne"] = "ne";
+    /** Greater than (Ex: /Products?$filter=Price gt 20) */
+    EnumLogicalOperator["Gt"] = "gt";
+    /** Greater than or equal (Ex: /Products?$filter=Price ge 10) */
+    EnumLogicalOperator["Ge"] = "ge";
+    /** Less than (Ex: /Products?$filter=Price lt 20)*/
+    EnumLogicalOperator["Lt"] = "lt";
+    /** Less than or equal (Ex: /Products?$filter=Price le 100)*/
+    EnumLogicalOperator["Le"] = "le";
+    /** Logical and	 (Ex: /Products?$filter=Price le 200 and Price gt 3.5)*/
+    EnumLogicalOperator["And"] = "and";
+    /** Logical or (Ex: /Products?$filter=Price le 3.5 or Price gt 200)*/
+    EnumLogicalOperator["Or"] = "or";
+    /** Logical negation (Ex: /Products?$filter=not endswith(Description,'milk'))*/
+    EnumLogicalOperator["Not"] = "not";
+    /** Logical is (Ex: /Products?$filter=id is null */
+    EnumLogicalOperator["Is"] = "is";
+    /** Negation of logical is (Ex: /Products?$filter=id is not null */
+    EnumLogicalOperator["IsNot"] = "is not";
+    /** Contains string value (Ex: /Products?$filter=containing(lower(name), lower('my name'))) */
+    EnumLogicalOperator["Contains"] = "containing";
+})(EnumLogicalOperator || (EnumLogicalOperator = {}));
+export class ErpLookupsFormField {
+    constructor(erpLookupsFormField, fieldConfig = {}) {
+        this.erpLookupsFormField = erpLookupsFormField;
+        Object.assign(this, fieldConfig);
+    }
+}
+// TODO: strict-review: @Injectable removido — esta classe não pode ser injetada via DI do Angular.
+// Os parâmetros do constructor não são tipos injetáveis (primitivos ou sem ?prov). Instanciar com `new`.
+/**
+ * Erp Lookups
+ * @class ErpLookups
+ */
+export class ErpLookups {
+    /**
+     * Criação de um lookup.
+     * @param entity Nome da entidade.
+     * @param lookupFields Campos exibidos no autocomplete.
+     * @param searchFields Campos exibidos no filtro dentro da modal.
+     * @param searchGridFields Campos exibidos na tabela dentro da modal.
+     */
+    constructor(lookupService, translate, entity, lookupFields, searchFields, searchGridFields, domain, service) {
+        this.lookupService = lookupService;
+        this.translate = translate;
+        this.entity = entity;
+        this.lookupFields = lookupFields;
+        this.searchFields = searchFields;
+        this.searchGridFields = searchGridFields;
+        this.domain = domain;
+        this.service = service;
+        this.lookupSuggestionsObservable = new Subject();
+        this.lookupSearchObservable = new Subject();
+        this.ngUnsubscribe = new Subject();
+        this.entity = entity;
+        this.domain = domain;
+        this.service = service;
+        this.lookupFields = lookupFields ?? [];
+        this.searchFields = searchFields ?? [];
+        this.searchGridFields = searchGridFields ?? [];
+    }
+    toSnakeCase(value = '') {
+        return value
+            .replace(/(?:^|\.?)([A-Z])/g, function (_x, y) {
+            return '_' + y.toLowerCase();
+        })
+            .replace(/^_/, '');
+    }
+    mountFormField(fields, prefix) {
+        return fields.map((field) => {
+            let translationKey = `${prefix}.lookup_${this.toSnakeCase(this.entity)}_${this.toSnakeCase(field.name)}`;
+            let label = this.translate.instant(translationKey);
+            if (label === translationKey) {
+                // Manter compatibilidade com os lookups atuais até todos ajustarem
+                const fieldName = field.name.split('.').join('_');
+                translationKey = `${prefix}.lookup_${this.toSnakeCase(this.entity)}_${this.toSnakeCase(fieldName)}`;
+                label = this.translate.instant(translationKey);
+            }
+            return {
+                ...field,
+                label,
+            };
+        });
+    }
+    mountDefaultFilter(defaultFilter = [
+        {
+            field: 'excluido',
+            operator: EnumLogicalOperator.Eq,
+            values: ['false'],
+        },
+    ]) {
+        return defaultFilter
+            .map((filter) => {
+            return ('(' +
+                filter.values
+                    .map((value) => {
+                    if (filter.operator === EnumLogicalOperator.Contains) {
+                        return `containing(lower(${filter.field}), lower('${value}'))`;
+                    }
+                    if ((filter.operator ===
+                        EnumLogicalOperator.IsNot ||
+                        filter.operator ===
+                            EnumLogicalOperator.Is) &&
+                        !value) {
+                        return `${filter.field} ${filter.operator} null`;
+                    }
+                    return `${filter.field} ${filter.operator} '${value}'`;
+                })
+                    .join(' or ') +
+                ')');
+        })
+            .join(' and ');
+    }
+    mountDynamicFilter(dynamicFilter) {
+        if (!dynamicFilter) {
+            return undefined;
+        }
+        return dynamicFilter
+            .map((filter) => {
+            let values = filter.value();
+            const field = filter.field();
+            const operator = filter.operator;
+            if (!(values instanceof Array)) {
+                values = [values];
+            }
+            return ('(' +
+                values
+                    .map((value) => {
+                    if (operator === EnumLogicalOperator.Contains) {
+                        return `containing(lower(${field}), lower('${String(value)}'))`;
+                    }
+                    if ((operator === EnumLogicalOperator.IsNot ||
+                        operator === EnumLogicalOperator.Is) &&
+                        !value) {
+                        return `${field} ${operator} null`;
+                    }
+                    return `${field} ${operator} '${String(value)}'`;
+                })
+                    .join(' or ') +
+                ')');
+        })
+            .join(' and ');
+    }
+    mountFilterQuery(value, lookupFields, defaultFilter, dynamicFilter) {
+        let filterQuery;
+        if (Number.isInteger(Number(value))) {
+            filterQuery = lookupFields
+                .map((field) => {
+                if (field.type === 'string') {
+                    return `(containing(lower(${field.name}), lower('${value}')))`;
+                }
+                if (field.type === 'integer') {
+                    const sanitizedValue = value
+                        .toString()
+                        .replace(/\D/g, '');
+                    if (!sanitizedValue) {
+                        return null;
+                    }
+                    return `(${field.name} eq '${sanitizedValue}')`;
+                }
+                return `(${field.name} eq '${value}')`;
+            })
+                .filter((filter) => !!filter)
+                .join(' or ');
+        }
+        else {
+            filterQuery = lookupFields
+                .filter((field) => field.type === 'string')
+                .map((field) => {
+                return `(containing(lower(${field.name}), lower('${value.replace(/\\/g, '').replace(/'/g, "\\'")}')))`;
+            })
+                .join(' or ');
+        }
+        const defaultFilterQuery = this.mountDefaultFilter(defaultFilter);
+        if (defaultFilterQuery) {
+            filterQuery = `((${defaultFilterQuery}) and (${filterQuery}))`;
+        }
+        else {
+            filterQuery = '(' + filterQuery + ')';
+        }
+        const dynamicFilterQuery = this.mountDynamicFilter(dynamicFilter);
+        if (dynamicFilterQuery) {
+            filterQuery = `((${dynamicFilterQuery}) and (${filterQuery}))`;
+        }
+        else {
+            filterQuery = '(' + filterQuery + ')';
+        }
+        return filterQuery;
+    }
+    mountEnumFilter(name, value, multiple) {
+        return multiple
+            ? `(${value.map((selected) => `${name} eq '${selected}'`).join(' or ')})`
+            : `(${name} eq '${value}')`;
+    }
+    /** Método responsável por montar as opções padrões para o lookup do Dynamic Form */
+    mountOptions(options) {
+        const prefix = options?.prefix
+            ? options.prefix
+            : options?.domain && options?.service
+                ? `${options.domain}.${options.service}`
+                : `${this.domain}.${this.service}`;
+        const suffix = options?.suffix ? `_${options.suffix}` : '';
+        options = {
+            ...options,
+            lookupFields: options?.lookupFields
+                ? options.lookupFields
+                : this.lookupFields,
+        };
+        return {
+            name: options?.formGroup ?? this.entity,
+            label: this.translate.instant(`${prefix}.lookup_${this.toSnakeCase(options?.entity) || this.toSnakeCase(this.entity)}${suffix}`),
+            searchTitle: this.translate.instant(`${prefix}.lookup_${this.toSnakeCase(options?.entity) ||
+                this.toSnakeCase(this.entity)}_search_title`),
+            type: 'lookup',
+            multiple: options?.multiple !== false,
+            dataKey: options?.dataKey ?? 'id',
+            lookupDisplayField: 'label',
+            searchEmptyTitle: this.translate.instant(`${prefix}.nothing_found`),
+            filterLabel: this.translate.instant(`${prefix}.filter`),
+            clearLabel: this.translate.instant(`${prefix}.clear`),
+            cancelLabel: this.translate.instant(`${prefix}.cancel`),
+            selectLabel: this.translate.instant(`${prefix}.select`),
+            searchFields: this.mountFormField(options?.searchFields ?? this.searchFields, prefix),
+            searchGridFields: this.mountFormField(options?.searchGridFields ?? this.searchGridFields, prefix),
+            suggestionsObservable: this.lookupSuggestionsObservable.asObservable(),
+            searchObservable: this.lookupSearchObservable.asObservable(),
+            onLookupRequest: (value) => this.onLookupRequest(value, prefix, options),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onSearchRequest: (event) => 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            this.onSearchRequest(event, prefix, options),
+        };
+    }
+    getProp(obj, path, prefix) {
+        return path
+            .split('.')
+            .reduce((result, prop) => result[prop] === undefined || result[prop] === null
+            ? this.translate.instant(`${prefix}.empty_label`)
+            : result[prop], obj);
+    }
+    hasValue(value) {
+        if (Array.isArray(value) && !value.length) {
+            return false;
+        }
+        return !!value;
+    }
+    mountEntityFilter(entity, value) {
+        return entity.field
+            ? `(${entity.name}.${entity.field} eq '${value[entity.field]}')`
+            : `(${entity.name} eq '${value[entity.name]}')`;
+    }
+    onLookupRequest(value, prefix, options) {
+        const lookupFields = options?.lookupFields ?? this.lookupFields;
+        const lookupDisplayFields = lookupFields.map((field) => field.name);
+        let filterQuery = this.mountFilterQuery(value, lookupFields, options?.defaultFilter, options?.dynamicFilter);
+        let displayFields = lookupDisplayFields.concat((options?.searchGridFields ?? this.searchGridFields).map(({ name }) => name));
+        if (options?.queryFields) {
+            displayFields = displayFields.concat(options.queryFields);
+        }
+        displayFields = displayFields.filter((v, i) => displayFields.indexOf(v) === i);
+        if (options?.entityDependency) {
+            const entityFilter = options.entityDependency
+                .map((entity) => {
+                const newValue = entity.value();
+                if (!this.hasValue(newValue)) {
+                    return;
+                }
+                if (Array.isArray(newValue)) {
+                    return `(${newValue.map((val) => this.mountEntityFilter(entity, val)).join(' or ')})`;
+                }
+                return `(${this.mountEntityFilter(entity, newValue)})`;
+            })
+                .filter((filter) => !!filter)
+                .join(' and ');
+            if (entityFilter) {
+                filterQuery
+                    ? (filterQuery += ` and (${entityFilter})`)
+                    : (filterQuery = entityFilter);
+            }
+        }
+        this.lookupService
+            .list({
+            sort: options?.lookupSort,
+            filterQuery,
+            displayFields,
+        }, options?.entity ?? this.entity, options?.domain ?? this.domain, options?.service ?? this.service)
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .pipe(map((list) => list.contents.map((item) => ({
+            ...item,
+            label: this.getItemLabel(item, prefix, lookupDisplayFields),
+        }))))
+            .subscribe((data) => {
+            this.lookupSuggestionsObservable.next(data);
+        });
+    }
+    onSearchRequest(event, prefix, options = {}) {
+        const { first, rows, multiSortMeta, filterData } = event;
+        const page = first / rows;
+        const sort = multiSortMeta ?? options.searchSort;
+        const lookupFields = options.lookupFields ?? this.lookupFields;
+        const lookupDisplayFields = lookupFields.map((field) => field.name);
+        let filterQuery = (options.searchFields ?? this.searchFields)
+            .filter(({ name }) => filterData[name] !==
+            undefined &&
+            filterData[name] !== null &&
+            filterData[name] !== '')
+            .map((formField) => {
+            const { name, type, multiple, erpLookupsFormField } = formField;
+            const value = filterData[name];
+            if (erpLookupsFormField) {
+                return this.mountCustomFilter({
+                    erpLookupsSearchField: formField,
+                    filterData: filterData,
+                });
+            }
+            if (typeof value === 'number') {
+                return `${name} eq ${value}`;
+            }
+            if (type === 'date') {
+                return `${name} eq '${moment(value).format('YYYY-MM-DD')}'`;
+            }
+            if (type === 'time') {
+                return `${name} eq '${moment(value).format('HH:mm:ss')}'`;
+            }
+            if (type === 'dateTime') {
+                return `${name} eq '${moment(value).format()}'`;
+            }
+            if (type === 'enum') {
+                return this.mountEnumFilter(name, value, multiple);
+            }
+            if (type === 'string') {
+                return `(containing(lower(${name}), lower('${value}')))`;
+            }
+            if (type === 'lookup') {
+                return `(${name} eq '${value['id']}')`;
+            }
+            return `${name} eq '${value}'`;
+        })
+            .join(' and ');
+        if (options.entityDependency) {
+            const entityFilter = options.entityDependency
+                .map((entity) => {
+                const value = entity.value();
+                if (!this.hasValue(value)) {
+                    return;
+                }
+                if (Array.isArray(value)) {
+                    return `(${value.map((val) => this.mountEntityFilter(entity, val)).join(' or ')})`;
+                }
+                return `(${this.mountEntityFilter(entity, value)})`;
+            })
+                .filter((filter) => !!filter)
+                .join(' and ');
+            if (entityFilter) {
+                filterQuery
+                    ? (filterQuery += ` and (${entityFilter})`)
+                    : (filterQuery = entityFilter);
+            }
+        }
+        const defaultFilterQuery = this.mountDefaultFilter(options.defaultFilter);
+        if (defaultFilterQuery) {
+            filterQuery
+                ? (filterQuery += ` and (${defaultFilterQuery})`)
+                : (filterQuery = `(${defaultFilterQuery})`);
+        }
+        const dynamicFilterQuery = this.mountDynamicFilter(options.dynamicFilter);
+        if (dynamicFilterQuery) {
+            filterQuery
+                ? (filterQuery += ` and (${dynamicFilterQuery})`)
+                : (filterQuery = `(${dynamicFilterQuery})`);
+        }
+        let displayFields = lookupDisplayFields.concat((options.searchGridFields ?? this.searchGridFields)
+            .concat(options.searchGridFields ?? [])
+            .map(({ name }) => name) ?? []);
+        if (options.queryFields) {
+            displayFields = displayFields.concat(options.queryFields);
+        }
+        displayFields = displayFields.filter((v, i) => displayFields.indexOf(v) === i);
+        this.lookupService
+            .list({ page, sort, filterQuery, displayFields }, options.entity ?? this.entity, options.domain ?? this.domain, options.service ?? this.service)
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .pipe(map((list) => {
+            // Criar um mapa de campos com maxLength definido
+            const fieldsWithMaxLength = new Map();
+            [
+                ...(options.searchFields ?? this.searchFields),
+                ...(options.searchGridFields ?? this.searchGridFields),
+            ].forEach((field) => {
+                const maxLength = 'maxLength' in field ? field.maxLength : undefined;
+                if (maxLength &&
+                    (field.type === 'string' ||
+                        field.type === 'textArea')) {
+                    fieldsWithMaxLength.set(field.name, maxLength);
+                }
+            });
+            return {
+                gridData: list.contents.map((item) => {
+                    const processedItem = JSON.parse(JSON.stringify(item));
+                    // Aplicar maxLength nos campos que possuem a configuração
+                    fieldsWithMaxLength.forEach((maxLength, fieldName) => {
+                        const fieldValue = this.getNestedValue(processedItem, fieldName);
+                        if (fieldValue &&
+                            typeof fieldValue === 'string' &&
+                            fieldValue.length > maxLength) {
+                            this.setNestedValue(processedItem, fieldName, fieldValue.substring(0, maxLength) +
+                                '...');
+                        }
+                    });
+                    return {
+                        ...processedItem,
+                        label: this.getItemLabel(processedItem, prefix, lookupDisplayFields),
+                    };
+                }),
+                totalRecords: list.totalElements,
+            };
+        }))
+            .subscribe((data) => {
+            this.lookupSearchObservable.next(data);
+        });
+    }
+    getItemLabel(item, prefix, lookupDisplayFields) {
+        return lookupDisplayFields
+            .map((field) => {
+            if (field.indexOf('.') > 0) {
+                return this.getProp(item, field, prefix);
+            }
+            return (item[field] ??
+                this.translate.instant(`${prefix}.empty_label`));
+        })
+            .join(' - ');
+    }
+    mountCustomFilter({ erpLookupsSearchField, filterData, }) {
+        const { erpLookupsFormField, name } = erpLookupsSearchField;
+        return `(${(erpLookupsFormField?.customFilters ?? [])
+            .map(({ operator, value }) => {
+            value =
+                typeof value === 'function'
+                    ? value({
+                        value: filterData[name],
+                        filterData,
+                    })
+                    : value;
+            if (operator === EnumLogicalOperator.Contains) {
+                return `(containing(lower(${name}), lower('${value}')))`;
+            }
+            if ((operator === EnumLogicalOperator.IsNot ||
+                operator === EnumLogicalOperator.Is) &&
+                !value) {
+                return `(${name} ${operator} null)`;
+            }
+            return `(${name} ${operator} '${value}')`;
+        })
+            .join(' and ')})`;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            if (current && typeof current === 'object') {
+                const currentObj = current;
+                return currentObj[key] !== undefined
+                    ? currentObj[key]
+                    : undefined;
+            }
+            return undefined;
+        }, obj);
+    }
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        const lastKey = keys.pop();
+        const target = keys.reduce((current, key) => {
+            if (current && typeof current === 'object') {
+                const currentObj = current;
+                return currentObj[key] !== undefined
+                    ? currentObj[key]
+                    : undefined;
+            }
+            return undefined;
+        }, obj);
+        if (target && typeof target === 'object' && lastKey) {
+            target[lastKey] = value;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erp-lookups.js","sourceRoot":"","sources":["../../../../projects/snr-erpx-angular-components/lookups/src/lib/erp-lookups.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from 'moment';\n\nimport { TranslateService } from '@ngx-translate/core';\nimport {\n    DynamicType,\n    LookupFieldConfig,\n} from '@seniorsistemas/angular-components/dynamic-form';\nimport { SortMeta } from 'primeng/api';\nimport { Subject } from 'rxjs';\nimport { map, takeUntil } from 'rxjs/operators';\nimport { ErpLookupsService } from './erp-lookups.service';\n\n/** Entidades de que depende */\nexport interface EntityDependency {\n    /** Nome da entidade que depende (pai) */\n    name: string;\n    /** Campo da entidade pai que será comparado */\n    field?: string;\n    /** Valor da entidade pai */\n    value: () => unknown;\n}\n\n/** Filtro padrão aplicado em todas requisições da entidade. Por padrão filtra registros não excluidos */\nexport interface DefaultFilter {\n    /** Campo que será filtrado */\n    field: string | DefaultFilter;\n    /** Comparação que será aplicada na consulta */\n    operator: EnumLogicalOperator;\n    /** Valores que serão buscados */\n    values: string[];\n}\n\n/** Filtro dinamico para consultas mais complexas */\nexport interface DynamicFilter {\n    /** Campo que será filtrado */\n    field: () => string;\n    /** Comparação que será aplicada na consulta */\n    operator: EnumLogicalOperator;\n    /** Valores que serão buscados */\n    value: () => unknown;\n}\n\n/** Filter System Query Option - Operators supported in the expression language */\nexport enum EnumLogicalOperator {\n    /** Equal (Ex: /Suppliers?$filter=Address/City eq 'Redmond') */\n    Eq = 'eq',\n    /** Not equal (Ex: /Suppliers?$filter=Address/City ne 'London') */\n    Ne = 'ne',\n    /** Greater than (Ex: /Products?$filter=Price gt 20) */\n    Gt = 'gt',\n    /** Greater than or equal (Ex: /Products?$filter=Price ge 10) */\n    Ge = 'ge',\n    /** Less than (Ex: /Products?$filter=Price lt 20)*/\n    Lt = 'lt',\n    /** Less than or equal (Ex: /Products?$filter=Price le 100)*/\n    Le = 'le',\n    /** Logical and\t (Ex: /Products?$filter=Price le 200 and Price gt 3.5)*/\n    And = 'and',\n    /** Logical or (Ex: /Products?$filter=Price le 3.5 or Price gt 200)*/\n    Or = 'or',\n    /** Logical negation (Ex: /Products?$filter=not endswith(Description,'milk'))*/\n    Not = 'not',\n    /** Logical is (Ex: /Products?$filter=id is null */\n    Is = 'is',\n    /** Negation of logical is (Ex: /Products?$filter=id is not null */\n    IsNot = 'is not',\n    /** Contains string value (Ex: /Products?$filter=containing(lower(name), lower('my name'))) */\n    Contains = 'containing',\n}\n\nexport interface SortOptions {\n    field: string;\n    order: number;\n}\n\n/** Parâmetros para customizações do lookup */\nexport interface LookupOptions {\n    /** Nome da entidade */\n    entity?: string;\n    /** Nome do formGroup */\n    formGroup?: string;\n    /** Filtro padrão */\n    defaultFilter?: DefaultFilter[];\n    /** Filtro dinâmico */\n    dynamicFilter?: DynamicFilter[];\n    /** Campos do lookup (autocomplete) */\n    lookupFields?: (DynamicType | ErpLookupsFormField)[];\n    /** Campos que serão solicitados na consulta */\n    queryFields?: string[];\n    /** Campos exibidos no filtro da modal de listagem */\n    searchFields?: (DynamicType | ErpLookupsFormField)[];\n    /** Campos exibidos na grid da modal de listagem */\n    /** Define se o lookup permitirá multi seleção */\n    searchGridFields?: (DynamicType | ErpLookupsFormField)[];\n    multiple?: boolean;\n    /** Entidades de que depende */\n    entityDependency?: EntityDependency[];\n    /** Prefixo utilizado para montar os labels (por padrão utiliza domínio e serviço) */\n    prefix?: string;\n    /** Sufixo utilizado para montar os labels (por padrão é vazio) */\n    suffix?: string;\n    /** Domínio */\n    domain?: string;\n    /** Serviço */\n    service?: string;\n    /** Data key */\n    dataKey?: string;\n    /** Campos para ordenação do lookup (autocomplete)*/\n    lookupSort?: SortOptions[];\n    /** Campos para a ordenação ao abrir a modal de listagem */\n    searchSort?: SortOptions[];\n}\n\nexport type CustomFilterFunction<T = unknown> = (options: {\n    value: T;\n    filterData: Record<string, unknown>;\n}) => string;\n\nexport type CustomFilter<T = unknown> = {\n    operator: EnumLogicalOperator;\n    value: string | CustomFilterFunction<T>;\n};\n\nexport class ErpLookupsFormField<T = unknown> {\n    public name!: string;\n    public type!: string;\n    public maxLength?: number;\n    public multiple?: boolean;\n    [key: string]: unknown;\n\n    public constructor(\n        public erpLookupsFormField?: {\n            customFilters?: CustomFilter<T>[];\n        },\n        fieldConfig: Record<string, unknown> = {}\n    ) {\n        Object.assign(this, fieldConfig);\n    }\n}\n\n// TODO: strict-review: @Injectable removido — esta classe não pode ser injetada via DI do Angular.\n// Os parâmetros do constructor não são tipos injetáveis (primitivos ou sem ?prov). Instanciar com `new`.\n/**\n * Erp Lookups\n * @class ErpLookups\n */\nexport class ErpLookups {\n    public lookupSuggestionsObservable = new Subject<any>();\n    public lookupSearchObservable = new Subject<any>();\n\n    private readonly ngUnsubscribe = new Subject<void>();\n\n    /**\n     * Criação de um lookup.\n     * @param entity Nome da entidade.\n     * @param lookupFields Campos exibidos no autocomplete.\n     * @param searchFields Campos exibidos no filtro dentro da modal.\n     * @param searchGridFields Campos exibidos na tabela dentro da modal.\n     */\n    public constructor(\n        protected lookupService: ErpLookupsService,\n        protected translate: TranslateService,\n        protected entity: string,\n        protected lookupFields: DynamicType[],\n        public searchFields: (DynamicType | ErpLookupsFormField)[],\n        public searchGridFields: DynamicType[],\n        protected domain: string,\n        protected service: string\n    ) {\n        this.entity = entity;\n        this.domain = domain;\n        this.service = service;\n        this.lookupFields = lookupFields ?? [];\n        this.searchFields = searchFields ?? [];\n        this.searchGridFields = searchGridFields ?? [];\n    }\n\n    public toSnakeCase(value: string = ''): string {\n        return value\n            .replace(/(?:^|\\.?)([A-Z])/g, function (_x, y) {\n                return '_' + y.toLowerCase();\n            })\n            .replace(/^_/, '');\n    }\n\n    public mountFormField(\n        fields: (DynamicType | ErpLookupsFormField)[],\n        prefix: string\n    ): DynamicType[] {\n        return fields.map((field) => {\n            let translationKey = `${prefix}.lookup_${this.toSnakeCase(this.entity)}_${this.toSnakeCase(field.name)}`;\n\n            let label = this.translate.instant(translationKey);\n\n            if (label === translationKey) {\n                // Manter compatibilidade com os lookups atuais até todos ajustarem\n                const fieldName = field.name.split('.').join('_');\n                translationKey = `${prefix}.lookup_${this.toSnakeCase(this.entity)}_${this.toSnakeCase(fieldName)}`;\n                label = this.translate.instant(translationKey);\n            }\n\n            return {\n                ...field,\n                label,\n            } as DynamicType;\n        });\n    }\n\n    public mountDefaultFilter(\n        defaultFilter: DefaultFilter[] = [\n            {\n                field: 'excluido',\n                operator: EnumLogicalOperator.Eq,\n                values: ['false'],\n            },\n        ]\n    ): string {\n        return defaultFilter\n            .map((filter) => {\n                return (\n                    '(' +\n                    filter.values\n                        .map((value) => {\n                            if (\n                                filter.operator === EnumLogicalOperator.Contains\n                            ) {\n                                return `containing(lower(${filter.field}), lower('${value}'))`;\n                            }\n\n                            if (\n                                (filter.operator ===\n                                    EnumLogicalOperator.IsNot ||\n                                    filter.operator ===\n                                        EnumLogicalOperator.Is) &&\n                                !value\n                            ) {\n                                return `${filter.field} ${filter.operator} null`;\n                            }\n                            return `${filter.field} ${filter.operator} '${value}'`;\n                        })\n                        .join(' or ') +\n                    ')'\n                );\n            })\n            .join(' and ');\n    }\n\n    public mountDynamicFilter(\n        dynamicFilter?: DynamicFilter[]\n    ): string | undefined {\n        if (!dynamicFilter) {\n            return undefined;\n        }\n        return dynamicFilter\n            .map((filter) => {\n                let values = filter.value();\n                const field = filter.field();\n                const operator = filter.operator;\n\n                if (!(values instanceof Array)) {\n                    values = [values];\n                }\n\n                return (\n                    '(' +\n                    (values as unknown[])\n                        .map((value: unknown) => {\n                            if (operator === EnumLogicalOperator.Contains) {\n                                return `containing(lower(${field}), lower('${String(value)}'))`;\n                            }\n\n                            if (\n                                (operator === EnumLogicalOperator.IsNot ||\n                                    operator === EnumLogicalOperator.Is) &&\n                                !value\n                            ) {\n                                return `${field} ${operator} null`;\n                            }\n\n                            return `${field} ${operator} '${String(value)}'`;\n                        })\n                        .join(' or ') +\n                    ')'\n                );\n            })\n            .join(' and ');\n    }\n\n    public mountFilterQuery(\n        value: string,\n        lookupFields: DynamicType[],\n        defaultFilter?: DefaultFilter[],\n        dynamicFilter?: DynamicFilter[]\n    ): string {\n        let filterQuery: string;\n\n        if (Number.isInteger(Number(value))) {\n            filterQuery = lookupFields\n                .map((field) => {\n                    if (field.type === 'string') {\n                        return `(containing(lower(${field.name}), lower('${value}')))`;\n                    }\n\n                    if (field.type === 'integer') {\n                        const sanitizedValue = value\n                            .toString()\n                            .replace(/\\D/g, '');\n                        if (!sanitizedValue) {\n                            return null;\n                        }\n                        return `(${field.name} eq '${sanitizedValue}')`;\n                    }\n                    return `(${field.name} eq '${value}')`;\n                })\n                .filter((filter) => !!filter)\n                .join(' or ');\n        } else {\n            filterQuery = lookupFields\n                .filter((field) => field.type === 'string')\n                .map((field) => {\n                    return `(containing(lower(${field.name}), lower('${value.replace(/\\\\/g, '').replace(/'/g, \"\\\\'\")}')))`;\n                })\n                .join(' or ');\n        }\n\n        const defaultFilterQuery = this.mountDefaultFilter(defaultFilter);\n\n        if (defaultFilterQuery) {\n            filterQuery = `((${defaultFilterQuery}) and (${filterQuery}))`;\n        } else {\n            filterQuery = '(' + filterQuery + ')';\n        }\n\n        const dynamicFilterQuery = this.mountDynamicFilter(dynamicFilter);\n\n        if (dynamicFilterQuery) {\n            filterQuery = `((${dynamicFilterQuery}) and (${filterQuery}))`;\n        } else {\n            filterQuery = '(' + filterQuery + ')';\n        }\n\n        return filterQuery;\n    }\n    public mountEnumFilter(\n        name: string,\n        value: string | string[],\n        multiple?: boolean\n    ): string {\n        return multiple\n            ? `(${(value as string[]).map((selected: string) => `${name} eq '${selected}'`).join(' or ')})`\n            : `(${name} eq '${value}')`;\n    }\n    /** Método responsável por montar as opções padrões para o lookup do Dynamic Form */\n    public mountOptions(options?: LookupOptions): LookupFieldConfig {\n        const prefix = options?.prefix\n            ? options.prefix\n            : options?.domain && options?.service\n              ? `${options.domain}.${options.service}`\n              : `${this.domain}.${this.service}`;\n\n        const suffix = options?.suffix ? `_${options.suffix}` : '';\n\n        options = {\n            ...options,\n            lookupFields: options?.lookupFields\n                ? options.lookupFields\n                : this.lookupFields,\n        };\n\n        return {\n            name: options?.formGroup ?? this.entity,\n            label: this.translate.instant(\n                `${prefix}.lookup_${this.toSnakeCase(options?.entity) || this.toSnakeCase(this.entity)}${suffix}`\n            ) as string,\n            searchTitle: this.translate.instant(\n                `${prefix}.lookup_${\n                    this.toSnakeCase(options?.entity) ||\n                    this.toSnakeCase(this.entity)\n                }_search_title`\n            ) as string,\n            type: 'lookup',\n            multiple: options?.multiple !== false,\n            dataKey: options?.dataKey ?? 'id',\n            lookupDisplayField: 'label',\n            searchEmptyTitle: this.translate.instant(`${prefix}.nothing_found`),\n            filterLabel: this.translate.instant(`${prefix}.filter`),\n            clearLabel: this.translate.instant(`${prefix}.clear`),\n            cancelLabel: this.translate.instant(`${prefix}.cancel`),\n            selectLabel: this.translate.instant(`${prefix}.select`),\n            searchFields: this.mountFormField(\n                options?.searchFields ?? this.searchFields,\n                prefix\n            ),\n            searchGridFields: this.mountFormField(\n                options?.searchGridFields ?? this.searchGridFields,\n                prefix\n            ),\n            suggestionsObservable:\n                this.lookupSuggestionsObservable.asObservable(),\n            searchObservable: this.lookupSearchObservable.asObservable(),\n            onLookupRequest: (value: string) =>\n                this.onLookupRequest(value, prefix, options),\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            onSearchRequest: (event: any) =>\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n                this.onSearchRequest(event, prefix, options),\n        };\n    }\n\n    public getProp(\n        obj: Record<string, unknown>,\n        path: string,\n        prefix: string\n    ): unknown {\n        return path\n            .split('.')\n            .reduce(\n                (result: Record<string, unknown>, prop: string) =>\n                    result[prop] === undefined || result[prop] === null\n                        ? this.translate.instant(`${prefix}.empty_label`)\n                        : (result[prop] as Record<string, unknown>),\n                obj\n            );\n    }\n\n    public hasValue(value: unknown): boolean {\n        if (Array.isArray(value) && !value.length) {\n            return false;\n        }\n        return !!value;\n    }\n\n    public mountEntityFilter(entity: EntityDependency, value: any): string {\n        return entity.field\n            ? `(${entity.name}.${entity.field} eq '${value[entity.field]}')`\n            : `(${entity.name} eq '${value[entity.name]}')`;\n    }\n\n    public onLookupRequest(\n        value: string,\n        prefix: string,\n        options?: LookupOptions\n    ): void {\n        const lookupFields = options?.lookupFields ?? this.lookupFields;\n        const lookupDisplayFields = lookupFields.map((field) => field.name);\n\n        let filterQuery = this.mountFilterQuery(\n            value,\n            lookupFields as DynamicType[],\n            options?.defaultFilter,\n            options?.dynamicFilter\n        );\n\n        let displayFields = lookupDisplayFields.concat(\n            (options?.searchGridFields ?? this.searchGridFields).map(\n                ({ name }) => name\n            )\n        );\n\n        if (options?.queryFields) {\n            displayFields = displayFields.concat(options.queryFields);\n        }\n\n        displayFields = displayFields.filter(\n            (v, i) => displayFields.indexOf(v) === i\n        );\n\n        if (options?.entityDependency) {\n            const entityFilter = options.entityDependency\n                .map((entity) => {\n                    const newValue = entity.value();\n\n                    if (!this.hasValue(newValue)) {\n                        return;\n                    }\n\n                    if (Array.isArray(newValue)) {\n                        return `(${newValue.map((val: any) => this.mountEntityFilter(entity, val)).join(' or ')})`;\n                    }\n\n                    return `(${this.mountEntityFilter(entity, newValue)})`;\n                })\n                .filter((filter) => !!filter)\n                .join(' and ');\n\n            if (entityFilter) {\n                filterQuery\n                    ? (filterQuery += ` and (${entityFilter})`)\n                    : (filterQuery = entityFilter);\n            }\n        }\n\n        this.lookupService\n            .list(\n                {\n                    sort: options?.lookupSort,\n                    filterQuery,\n                    displayFields,\n                },\n                options?.entity ?? this.entity,\n                options?.domain ?? this.domain,\n                options?.service ?? this.service\n            )\n            .pipe(takeUntil(this.ngUnsubscribe))\n            .pipe(\n                map((list: any) =>\n                    list.contents.map((item: any) => ({\n                        ...item,\n                        label: this.getItemLabel(\n                            item,\n                            prefix,\n                            lookupDisplayFields\n                        ),\n                    }))\n                )\n            )\n            .subscribe((data) => {\n                this.lookupSuggestionsObservable.next(data);\n            });\n    }\n\n    public onSearchRequest(\n        event: Record<string, unknown>,\n        prefix: string,\n        options: LookupOptions = {}\n    ): void {\n        const { first, rows, multiSortMeta, filterData } = event;\n        const page = (first as number) / (rows as number);\n        const sort =\n            (multiSortMeta as SortMeta[] | undefined) ?? options.searchSort;\n        const lookupFields = options.lookupFields ?? this.lookupFields;\n        const lookupDisplayFields = lookupFields.map((field) => field.name);\n\n        let filterQuery = (options.searchFields ?? this.searchFields)\n            .filter(\n                ({ name }) =>\n                    (filterData as Record<string, unknown>)[name] !==\n                        undefined &&\n                    (filterData as Record<string, unknown>)[name] !== null &&\n                    (filterData as Record<string, unknown>)[name] !== ''\n            )\n            .map((formField) => {\n                const { name, type, multiple, erpLookupsFormField } =\n                    formField as ErpLookupsFormField;\n\n                const value = (filterData as Record<string, unknown>)[name];\n\n                if (erpLookupsFormField) {\n                    return this.mountCustomFilter({\n                        erpLookupsSearchField: formField as ErpLookupsFormField,\n                        filterData: filterData as Record<string, unknown>,\n                    });\n                }\n\n                if (typeof value === 'number') {\n                    return `${name} eq ${value}`;\n                }\n                if (type === 'date') {\n                    return `${name} eq '${moment(value as string).format('YYYY-MM-DD')}'`;\n                }\n                if (type === 'time') {\n                    return `${name} eq '${moment(value as string).format('HH:mm:ss')}'`;\n                }\n                if (type === 'dateTime') {\n                    return `${name} eq '${moment(value as string).format()}'`;\n                }\n                if (type === 'enum') {\n                    return this.mountEnumFilter(\n                        name,\n                        value as string | string[],\n                        multiple\n                    );\n                }\n                if (type === 'string') {\n                    return `(containing(lower(${name}), lower('${value}')))`;\n                }\n                if (type === 'lookup') {\n                    return `(${name} eq '${(value as Record<string, unknown>)['id']}')`;\n                }\n\n                return `${name} eq '${value}'`;\n            })\n            .join(' and ');\n        if (options.entityDependency) {\n            const entityFilter = options.entityDependency\n                .map((entity: EntityDependency) => {\n                    const value = entity.value();\n                    if (!this.hasValue(value)) {\n                        return;\n                    }\n                    if (Array.isArray(value)) {\n                        return `(${value.map((val: any) => this.mountEntityFilter(entity, val)).join(' or ')})`;\n                    }\n                    return `(${this.mountEntityFilter(entity, value as Record<string, unknown>)})`;\n                })\n                .filter((filter) => !!filter)\n                .join(' and ');\n            if (entityFilter) {\n                filterQuery\n                    ? (filterQuery += ` and (${entityFilter})`)\n                    : (filterQuery = entityFilter);\n            }\n        }\n        const defaultFilterQuery = this.mountDefaultFilter(\n            options.defaultFilter\n        );\n\n        if (defaultFilterQuery) {\n            filterQuery\n                ? (filterQuery += ` and (${defaultFilterQuery})`)\n                : (filterQuery = `(${defaultFilterQuery})`);\n        }\n\n        const dynamicFilterQuery = this.mountDynamicFilter(\n            options.dynamicFilter\n        );\n\n        if (dynamicFilterQuery) {\n            filterQuery\n                ? (filterQuery += ` and (${dynamicFilterQuery})`)\n                : (filterQuery = `(${dynamicFilterQuery})`);\n        }\n\n        let displayFields = lookupDisplayFields.concat(\n            (options.searchGridFields ?? this.searchGridFields)\n                .concat(options.searchGridFields ?? [])\n                .map(({ name }) => name) ?? []\n        );\n\n        if (options.queryFields) {\n            displayFields = displayFields.concat(options.queryFields);\n        }\n\n        displayFields = displayFields.filter(\n            (v, i) => displayFields.indexOf(v) === i\n        );\n\n        this.lookupService\n            .list(\n                { page, sort, filterQuery, displayFields },\n                options.entity ?? this.entity,\n                options.domain ?? this.domain,\n                options.service ?? this.service\n            )\n            .pipe(takeUntil(this.ngUnsubscribe))\n            .pipe(\n                map((list: any) => {\n                    // Criar um mapa de campos com maxLength definido\n                    const fieldsWithMaxLength = new Map<string, number>();\n\n                    [\n                        ...(options.searchFields ?? this.searchFields),\n                        ...(options.searchGridFields ?? this.searchGridFields),\n                    ].forEach((field) => {\n                        const maxLength =\n                            'maxLength' in field ? field.maxLength : undefined;\n                        if (\n                            maxLength &&\n                            (field.type === 'string' ||\n                                field.type === 'textArea')\n                        ) {\n                            fieldsWithMaxLength.set(\n                                field.name,\n                                maxLength as number\n                            );\n                        }\n                    });\n\n                    return {\n                        gridData: list.contents.map((item: any) => {\n                            const processedItem = JSON.parse(\n                                JSON.stringify(item)\n                            );\n\n                            // Aplicar maxLength nos campos que possuem a configuração\n                            fieldsWithMaxLength.forEach(\n                                (maxLength, fieldName) => {\n                                    const fieldValue = this.getNestedValue(\n                                        processedItem,\n                                        fieldName\n                                    );\n                                    if (\n                                        fieldValue &&\n                                        typeof fieldValue === 'string' &&\n                                        fieldValue.length > maxLength\n                                    ) {\n                                        this.setNestedValue(\n                                            processedItem,\n                                            fieldName,\n                                            fieldValue.substring(0, maxLength) +\n                                                '...'\n                                        );\n                                    }\n                                }\n                            );\n\n                            return {\n                                ...processedItem,\n                                label: this.getItemLabel(\n                                    processedItem,\n                                    prefix,\n                                    lookupDisplayFields\n                                ),\n                            };\n                        }),\n                        totalRecords: list.totalElements,\n                    };\n                })\n            )\n            .subscribe((data) => {\n                this.lookupSearchObservable.next(data);\n            });\n    }\n\n    public getItemLabel(\n        item: Record<string, unknown>,\n        prefix: string,\n        lookupDisplayFields: string[]\n    ): string {\n        return lookupDisplayFields\n            .map((field: string) => {\n                if (field.indexOf('.') > 0) {\n                    return this.getProp(item, field, prefix);\n                }\n                return (\n                    item[field] ??\n                    this.translate.instant(`${prefix}.empty_label`)\n                );\n            })\n            .join(' - ');\n    }\n\n    private mountCustomFilter({\n        erpLookupsSearchField,\n        filterData,\n    }: {\n        erpLookupsSearchField: ErpLookupsFormField;\n        filterData: Record<string, unknown>;\n    }): string {\n        const { erpLookupsFormField, name } = erpLookupsSearchField;\n\n        return `(${(erpLookupsFormField?.customFilters ?? [])\n            .map(({ operator, value }) => {\n                value =\n                    typeof value === 'function'\n                        ? value({\n                              value: filterData[name],\n                              filterData,\n                          })\n                        : value;\n\n                if (operator === EnumLogicalOperator.Contains) {\n                    return `(containing(lower(${name}), lower('${value}')))`;\n                }\n\n                if (\n                    (operator === EnumLogicalOperator.IsNot ||\n                        operator === EnumLogicalOperator.Is) &&\n                    !value\n                ) {\n                    return `(${name} ${operator} null)`;\n                }\n\n                return `(${name} ${operator} '${value}')`;\n            })\n            .join(' and ')})`;\n    }\n\n    private getNestedValue(\n        obj: Record<string, unknown>,\n        path: string\n    ): unknown {\n        return path.split('.').reduce((current: unknown, key: string) => {\n            if (current && typeof current === 'object') {\n                const currentObj = current as Record<string, unknown>;\n                return currentObj[key] !== undefined\n                    ? currentObj[key]\n                    : undefined;\n            }\n            return undefined;\n        }, obj as unknown);\n    }\n\n    private setNestedValue(\n        obj: Record<string, unknown>,\n        path: string,\n        value: unknown\n    ): void {\n        const keys = path.split('.');\n        const lastKey = keys.pop();\n        const target = keys.reduce((current: unknown, key: string) => {\n            if (current && typeof current === 'object') {\n                const currentObj = current as Record<string, unknown>;\n                return currentObj[key] !== undefined\n                    ? currentObj[key]\n                    : undefined;\n            }\n            return undefined;\n        }, obj as unknown);\n        if (target && typeof target === 'object' && lastKey) {\n            (target as Record<string, unknown>)[lastKey] = value;\n        }\n    }\n}\n"]}