@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/esm2022/lib/components/dynamic-form/fields/dynamic-field-lookup.component.mjs

@@ -0,0 +1,599 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { ButtonModule } from 'primeng/button';
+import { InputTextModule } from 'primeng/inputtext';
+import { DialogModule } from 'primeng/dialog';
+import { TableModule } from 'primeng/table';
+import { TooltipModule } from 'primeng/tooltip';
+import { TranslatePipe } from '../../../pipes/translate.pipe';
+import { DynamicFieldWrapperComponent } from './dynamic-field-wrapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/translation.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "primeng/button";
+import * as i5 from "primeng/api";
+import * as i6 from "primeng/inputtext";
+import * as i7 from "primeng/dialog";
+import * as i8 from "primeng/table";
+import * as i9 from "primeng/tooltip";
+export class DynamicFieldLookupComponent {
+    translationService;
+    field;
+    form;
+    formGroup;
+    mode = 'form';
+    displayValue = '';
+    showLookupDialog = false;
+    loading = false;
+    searchTerm = '';
+    data = [];
+    filteredData = [];
+    totalRecords = 0;
+    currentPage = 0;
+    pageSize = 5;
+    selectedItem = null;
+    columns = [];
+    displayField = 'name';
+    valueField = 'id';
+    searchFields = ['name'];
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    ngOnInit() {
+        this.setupLookupConfig();
+        this.watchValueChanges();
+    }
+    watchValueChanges() {
+        const control = this.form.get(this.field.field);
+        if (control) {
+            // Carregar valor inicial
+            if (control.value) {
+                this.handleValueDisplay(control.value);
+            }
+            // Observar mudanças
+            control.valueChanges.subscribe(value => {
+                if (value !== null && value !== undefined && value !== '') {
+                    this.handleValueDisplay(value);
+                }
+                else {
+                    this.displayValue = '';
+                }
+            });
+        }
+    }
+    get value() {
+        return this.form.get(this.field.field)?.value;
+    }
+    get currentValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.form.get(this.field.field)?.setValue(value);
+    }
+    setupLookupConfig() {
+        if (this.field) {
+            this.displayField = this.field.lookupDisplayField || 'name';
+            this.valueField = this.field.lookupValueField || 'id';
+            this.searchFields = this.field.lookupSearchFields || ['name'];
+            this.columns = this.field.lookupColumns || [
+                { field: this.displayField, header: 'Nome', width: '100%' }
+            ];
+        }
+    }
+    handleValueDisplay(value) {
+        if (value === null || value === undefined || value === '') {
+            this.displayValue = '';
+            return;
+        }
+        if (typeof value === 'object' && value !== null) {
+            this.displayValue = this.formatDisplayValue(value);
+            // Em modo filter, manter o objeto completo
+            // Em modo form, extrair apenas o ID EXCETO se já temos o objeto completo
+            // (evita requisições desnecessárias quando o objeto já está carregado)
+            if (this.mode === 'form') {
+                // Verificar se o objeto tem o campo de display preenchido
+                // Se tiver, significa que já temos os dados completos e não precisamos fazer nada
+                const hasDisplayData = this.field?.lookupDisplayFields
+                    ? this.field.lookupDisplayFields.some(f => this.getFieldValue(value, f))
+                    : value[this.displayField];
+                if (!hasDisplayData) {
+                    // Só extrair o ID se não temos os dados de display
+                    const newValue = value[this.valueField] || value.id || value;
+                    if (this.value !== newValue) {
+                        this.setValue(newValue);
+                    }
+                }
+            }
+            return;
+        }
+        // Se é um ID (string ou number), não fazer requisição
+        // Deixar vazio e só carregar quando abrir o lookup
+        if (typeof value === 'string' || typeof value === 'number') {
+            this.displayValue = '';
+            return;
+        }
+    }
+    formatDisplayValue(item) {
+        if (!item)
+            return '';
+        if (this.field?.lookupDisplayFields && this.field.lookupDisplayFields.length > 0) {
+            const values = this.field.lookupDisplayFields
+                .map(fieldName => this.getFieldValue(item, fieldName))
+                .filter(value => value !== null && value !== undefined && value !== '');
+            return values.join(' - ');
+        }
+        return this.getFieldValue(item, this.displayField) || '';
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDisabled() {
+        const control = this.form.get(this.field.field);
+        return control?.disabled || false;
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_search_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || 'Clique para selecionar';
+    }
+    openLookup() {
+        if (this.isFieldDisabled()) {
+            return;
+        }
+        this.updateSelectedItem();
+        this.showLookupDialog = true;
+        this.currentPage = 0;
+        this.searchTerm = '';
+        this.loadData();
+    }
+    onDialogHide() {
+        this.searchTerm = '';
+        this.currentPage = 0;
+    }
+    onPageChange(event) {
+        if (!this.showLookupDialog) {
+            return;
+        }
+        this.currentPage = event.first / event.rows;
+        this.loadData();
+    }
+    loadData() {
+        if (!this.field?.lookupService) {
+            return;
+        }
+        this.loading = true;
+        const listParams = {
+            page: this.currentPage,
+            size: this.pageSize
+        };
+        if (this.searchTerm.trim()) {
+            const term = this.searchTerm.trim();
+            const filterConditions = [];
+            const isNumericTerm = !isNaN(Number(term)) && term !== '';
+            this.searchFields.forEach(field => {
+                const column = this.columns.find(col => col.field === field);
+                const fieldType = column?.type || 'text';
+                if (fieldType === 'number') {
+                    if (isNumericTerm) {
+                        filterConditions.push(`${field} eq ${term}`);
+                    }
+                }
+                else {
+                    const upperTerm = term.toUpperCase();
+                    filterConditions.push(`UPPER(${field}) like '%${upperTerm}%'`);
+                }
+            });
+            if (filterConditions.length > 0) {
+                listParams.filterQuery = filterConditions.join(' or ');
+            }
+        }
+        if (this.field.lookupFilters) {
+            Object.keys(this.field.lookupFilters).forEach(key => {
+                listParams[key] = this.field.lookupFilters[key];
+            });
+        }
+        if (this.field.lookupDynamicFilters && this.formGroup) {
+            const dynamicFilters = this.field.lookupDynamicFilters(this.formGroup.value);
+            const dynamicFilterConditions = [];
+            Object.keys(dynamicFilters).forEach(key => {
+                const value = dynamicFilters[key];
+                if (value !== null && value !== undefined) {
+                    dynamicFilterConditions.push(`${key} eq '${value}'`);
+                }
+            });
+            if (dynamicFilterConditions.length > 0) {
+                const dynamicFilterQuery = dynamicFilterConditions.join(' and ');
+                if (listParams.filterQuery) {
+                    listParams.filterQuery = `(${listParams.filterQuery}) and (${dynamicFilterQuery})`;
+                }
+                else {
+                    listParams.filterQuery = dynamicFilterQuery;
+                }
+            }
+        }
+        this.field.lookupService.list(listParams).subscribe({
+            next: (response) => {
+                this.data = response.contents || [];
+                this.filteredData = [...this.data];
+                this.totalRecords = response.totalElements || 0;
+                this.updateSelectedItem();
+                // Após carregar os dados da grid, se temos um valor selecionado mas sem displayValue,
+                // tentar encontrar o item nos dados carregados
+                if (this.value && !this.displayValue) {
+                    const item = this.filteredData.find(i => i[this.valueField] === this.value);
+                    if (item) {
+                        this.displayValue = this.formatDisplayValue(item);
+                    }
+                }
+                this.loading = false;
+            },
+            error: (_error) => {
+                this.data = [];
+                this.filteredData = [];
+                this.totalRecords = 0;
+                this.loading = false;
+            }
+        });
+    }
+    updateSelectedItem() {
+        if (!this.value) {
+            this.selectedItem = null;
+            return;
+        }
+        const item = this.filteredData.find(i => i[this.valueField] === this.value);
+        if (item) {
+            this.selectedItem = item;
+        }
+    }
+    onSearch() {
+        if (!this.showLookupDialog) {
+            return;
+        }
+        this.currentPage = 0;
+        this.loadData();
+    }
+    clearSearch() {
+        this.searchTerm = '';
+        this.currentPage = 0;
+        this.loadData();
+    }
+    selectItem(item) {
+        if (this.mode === 'filter') {
+            this.setValue(item);
+            this.displayValue = this.formatDisplayValue(item);
+        }
+        else {
+            const newValue = item[this.valueField];
+            this.setValue(newValue);
+            this.displayValue = this.formatDisplayValue(item);
+        }
+        this.showLookupDialog = false;
+    }
+    onRowSelect(event) {
+        this.selectItem(event.data);
+    }
+    clearValue() {
+        this.setValue(null);
+        this.displayValue = '';
+        this.selectedItem = null;
+    }
+    getFieldValue(item, field) {
+        return field.split('.').reduce((obj, key) => obj?.[key], item) || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldLookupComponent, deps: [{ token: i1.TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldLookupComponent, isStandalone: true, selector: "sia-dynamic-field-lookup", inputs: { field: "field", form: "form", formGroup: "formGroup", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form" class="lookup-field" [ngClass]="{'disabled': isFieldDisabled()}">
+        <!-- Hidden input para o formControl -->
+        <input type="hidden" [formControlName]="field.field" />
+        
+        <div class="lookup-input-group">
+          <input
+            pInputText
+            [value]="displayValue"
+            [placeholder]="getPlaceholder()"
+            [class.p-invalid]="isFieldInvalid()"
+            [disabled]="isFieldDisabled()"
+            readonly
+            class="lookup-display"
+            (click)="openLookup()"
+          />
+          <div class="lookup-buttons">
+            <p-button
+              *ngIf="currentValue"
+              icon="pi pi-trash"
+              severity="danger"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="clearValue()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Limpar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+            <p-button
+              icon="pi pi-search"
+              severity="secondary"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="openLookup()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Buscar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Lookup Dialog -->
+      <p-dialog
+        [(visible)]="showLookupDialog"
+        [modal]="true"
+        [style]="{ width: '800px', maxHeight: '80vh' }"
+        [contentStyle]="{ maxHeight: 'calc(80vh - 120px)', overflow: 'auto' }"
+        [draggable]="false"
+        [resizable]="true"
+        [header]="'Selecionar ' + (field.label | translate)"
+        [appendTo]="'body'"
+        (onHide)="onDialogHide()"
+      >
+        <div class="lookup-dialog-content">
+          <!-- Search Input -->
+          <div class="search-wrapper">
+            <input
+              pInputText
+              [(ngModel)]="searchTerm"
+              [placeholder]="'Buscar ' + (field.label | translate).toLowerCase() + '...'"
+              (keydown.enter)="onSearch()"
+              class="search-input-full"
+            />
+            <div class="search-buttons-inside">
+              <p-button
+                *ngIf="searchTerm"
+                icon="pi pi-trash"
+                severity="danger"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="clearSearch()"
+                class="search-button-clear"
+                pTooltip="Limpar busca"
+                tooltipPosition="top"
+              ></p-button>
+              <p-button
+                icon="pi pi-search"
+                severity="secondary"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="onSearch()"
+                class="search-button-search"
+                pTooltip="Buscar"
+                tooltipPosition="top"
+              ></p-button>
+            </div>
+          </div>
+
+          <!-- Data Table -->
+          <p-table
+            [value]="filteredData"
+            [loading]="loading"
+            [paginator]="true"
+            [rows]="pageSize"
+            [totalRecords]="totalRecords"
+            [lazy]="true"
+            (onLazyLoad)="onPageChange($event)"
+            [showCurrentPageReport]="true"
+            currentPageReportTemplate="Mostrando {first} a {last} de {totalRecords} registros"
+            dataKey="id"
+            [rowHover]="true"
+            responsiveLayout="scroll"
+            styleClass="p-datatable-striped lookup-table"
+            [(selection)]="selectedItem"
+            (onRowSelect)="onRowSelect($event)"
+            selectionMode="single"
+          >
+            <ng-template pTemplate="header">
+              <tr>
+                <th *ngFor="let col of columns" [style.width]="col.width">
+                  {{ col.header }}
+                </th>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="body" let-item>
+              <tr [pSelectableRow]="item">
+                <td *ngFor="let col of columns">
+                  {{ getFieldValue(item, col.field) }}
+                </td>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="emptymessage">
+              <tr>
+                <td [attr.colspan]="columns.length" class="empty-message">
+                  <div class="empty-state">
+                    <i class="pi pi-search"></i>
+                    <p>Nenhum registro encontrado</p>
+                    <small>Tente ajustar os termos de busca</small>
+                  </div>
+                </td>
+              </tr>
+            </ng-template>
+          </p-table>
+        </div>
+      </p-dialog>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: [".lookup-field{width:100%;position:relative}.lookup-input-group{position:relative;width:100%;.lookup-display{width:100%;cursor:pointer;height:2.857rem;padding:.75rem 4rem .75rem .75rem;font-size:1rem;line-height:1.5;box-sizing:border-box;display:flex;align-items:center;&:focus{outline:none}&:hover{background:transparent}}.lookup-buttons{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;z-index:10}::ng-deep .p-button{width:2rem!important;height:2rem!important;min-width:2rem!important;min-height:2rem!important;padding:0!important;margin:0!important;display:flex!important;align-items:center!important;justify-content:center!important;box-sizing:border-box!important;.p-button-icon{margin:0!important;font-size:.875rem!important}.p-button-label{display:none!important}}}.lookup-dialog-content{height:100%;display:flex;flex-direction:column;padding:0;.search-wrapper{position:relative;margin-bottom:16px;width:100%;.search-input-full{width:100%;padding-right:5.5rem}.search-buttons-inside{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;::ng-deep .p-button{width:2.5rem!important;height:2.5rem!important}}}.lookup-table{flex:1;.empty-state{text-align:center;padding:32px;color:var(--p-text-color-secondary);i{font-size:48px;margin-bottom:16px;display:block}p{margin:8px 0;font-size:16px}small{font-size:14px}}}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i4.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "directive", type: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i6.InputText, selector: "[pInputText]", inputs: ["variant", "fluid", "pSize"] }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i7.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "closeButtonProps", "maximizeButtonProps", "visible", "style", "position", "role", "content", "contentTemplate", "footerTemplate", "closeIconTemplate", "maximizeIconTemplate", "minimizeIconTemplate", "headlessTemplate"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "ngmodule", type: TableModule }, { kind: "component", type: i8.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "size", "showGridlines", "stripedRows", "groupRowsByOrder", "responsiveLayout", "breakpoint", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "virtualRowHeight", "selectAll"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i8.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i9.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldLookupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-lookup', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormsModule,
+                        ButtonModule,
+                        InputTextModule,
+                        DialogModule,
+                        TableModule,
+                        TooltipModule,
+                        TranslatePipe,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form" class="lookup-field" [ngClass]="{'disabled': isFieldDisabled()}">
+        <!-- Hidden input para o formControl -->
+        <input type="hidden" [formControlName]="field.field" />
+        
+        <div class="lookup-input-group">
+          <input
+            pInputText
+            [value]="displayValue"
+            [placeholder]="getPlaceholder()"
+            [class.p-invalid]="isFieldInvalid()"
+            [disabled]="isFieldDisabled()"
+            readonly
+            class="lookup-display"
+            (click)="openLookup()"
+          />
+          <div class="lookup-buttons">
+            <p-button
+              *ngIf="currentValue"
+              icon="pi pi-trash"
+              severity="danger"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="clearValue()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Limpar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+            <p-button
+              icon="pi pi-search"
+              severity="secondary"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="openLookup()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Buscar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Lookup Dialog -->
+      <p-dialog
+        [(visible)]="showLookupDialog"
+        [modal]="true"
+        [style]="{ width: '800px', maxHeight: '80vh' }"
+        [contentStyle]="{ maxHeight: 'calc(80vh - 120px)', overflow: 'auto' }"
+        [draggable]="false"
+        [resizable]="true"
+        [header]="'Selecionar ' + (field.label | translate)"
+        [appendTo]="'body'"
+        (onHide)="onDialogHide()"
+      >
+        <div class="lookup-dialog-content">
+          <!-- Search Input -->
+          <div class="search-wrapper">
+            <input
+              pInputText
+              [(ngModel)]="searchTerm"
+              [placeholder]="'Buscar ' + (field.label | translate).toLowerCase() + '...'"
+              (keydown.enter)="onSearch()"
+              class="search-input-full"
+            />
+            <div class="search-buttons-inside">
+              <p-button
+                *ngIf="searchTerm"
+                icon="pi pi-trash"
+                severity="danger"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="clearSearch()"
+                class="search-button-clear"
+                pTooltip="Limpar busca"
+                tooltipPosition="top"
+              ></p-button>
+              <p-button
+                icon="pi pi-search"
+                severity="secondary"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="onSearch()"
+                class="search-button-search"
+                pTooltip="Buscar"
+                tooltipPosition="top"
+              ></p-button>
+            </div>
+          </div>
+
+          <!-- Data Table -->
+          <p-table
+            [value]="filteredData"
+            [loading]="loading"
+            [paginator]="true"
+            [rows]="pageSize"
+            [totalRecords]="totalRecords"
+            [lazy]="true"
+            (onLazyLoad)="onPageChange($event)"
+            [showCurrentPageReport]="true"
+            currentPageReportTemplate="Mostrando {first} a {last} de {totalRecords} registros"
+            dataKey="id"
+            [rowHover]="true"
+            responsiveLayout="scroll"
+            styleClass="p-datatable-striped lookup-table"
+            [(selection)]="selectedItem"
+            (onRowSelect)="onRowSelect($event)"
+            selectionMode="single"
+          >
+            <ng-template pTemplate="header">
+              <tr>
+                <th *ngFor="let col of columns" [style.width]="col.width">
+                  {{ col.header }}
+                </th>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="body" let-item>
+              <tr [pSelectableRow]="item">
+                <td *ngFor="let col of columns">
+                  {{ getFieldValue(item, col.field) }}
+                </td>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="emptymessage">
+              <tr>
+                <td [attr.colspan]="columns.length" class="empty-message">
+                  <div class="empty-state">
+                    <i class="pi pi-search"></i>
+                    <p>Nenhum registro encontrado</p>
+                    <small>Tente ajustar os termos de busca</small>
+                  </div>
+                </td>
+              </tr>
+            </ng-template>
+          </p-table>
+        </div>
+      </p-dialog>
+    </sia-dynamic-field-wrapper>
+  `, styles: [".lookup-field{width:100%;position:relative}.lookup-input-group{position:relative;width:100%;.lookup-display{width:100%;cursor:pointer;height:2.857rem;padding:.75rem 4rem .75rem .75rem;font-size:1rem;line-height:1.5;box-sizing:border-box;display:flex;align-items:center;&:focus{outline:none}&:hover{background:transparent}}.lookup-buttons{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;z-index:10}::ng-deep .p-button{width:2rem!important;height:2rem!important;min-width:2rem!important;min-height:2rem!important;padding:0!important;margin:0!important;display:flex!important;align-items:center!important;justify-content:center!important;box-sizing:border-box!important;.p-button-icon{margin:0!important;font-size:.875rem!important}.p-button-label{display:none!important}}}.lookup-dialog-content{height:100%;display:flex;flex-direction:column;padding:0;.search-wrapper{position:relative;margin-bottom:16px;width:100%;.search-input-full{width:100%;padding-right:5.5rem}.search-buttons-inside{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;::ng-deep .p-button{width:2.5rem!important;height:2.5rem!important}}}.lookup-table{flex:1;.empty-state{text-align:center;padding:32px;color:var(--p-text-color-secondary);i{font-size:48px;margin-bottom:16px;display:block}p{margin:8px 0;font-size:16px}small{font-size:14px}}}}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-field-lookup.component.js","sourceRoot":"","sources":["../../../../../../projects/components-ai/src/lib/components/dynamic-form/fields/dynamic-field-lookup.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormGroup, ReactiveFormsModule, FormsModule } from '@angular/forms';\nimport { ButtonModule } from 'primeng/button';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { DialogModule } from 'primeng/dialog';\nimport { TableModule } from 'primeng/table';\nimport { TooltipModule } from 'primeng/tooltip';\nimport { DynamicFormFieldConfig } from '../models/dynamic-form.models';\nimport { TranslatePipe } from '../../../pipes/translate.pipe';\nimport { TranslationService } from '../../../services/translation.service';\nimport { DynamicFieldWrapperComponent } from './dynamic-field-wrapper.component';\nimport { LookupColumn } from '../../../models/entity-list.config';\n\n@Component({\n  selector: 'sia-dynamic-field-lookup',\n  standalone: true,\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    FormsModule,\n    ButtonModule,\n    InputTextModule,\n    DialogModule,\n    TableModule,\n    TooltipModule,\n    TranslatePipe,\n    DynamicFieldWrapperComponent\n  ],\n  template: `\n    <sia-dynamic-field-wrapper [field]=\"field\" [form]=\"form\" [mode]=\"mode\">\n      <div [formGroup]=\"form\" class=\"lookup-field\" [ngClass]=\"{'disabled': isFieldDisabled()}\">\n        <!-- Hidden input para o formControl -->\n        <input type=\"hidden\" [formControlName]=\"field.field\" />\n        \n        <div class=\"lookup-input-group\">\n          <input\n            pInputText\n            [value]=\"displayValue\"\n            [placeholder]=\"getPlaceholder()\"\n            [class.p-invalid]=\"isFieldInvalid()\"\n            [disabled]=\"isFieldDisabled()\"\n            readonly\n            class=\"lookup-display\"\n            (click)=\"openLookup()\"\n          />\n          <div class=\"lookup-buttons\">\n            <p-button\n              *ngIf=\"currentValue\"\n              icon=\"pi pi-trash\"\n              severity=\"danger\"\n              [text]=\"true\"\n              [rounded]=\"true\"\n              (onClick)=\"clearValue()\"\n              [disabled]=\"isFieldDisabled()\"\n              pTooltip=\"Limpar\"\n              tooltipPosition=\"top\"\n              size=\"small\"\n            ></p-button>\n            <p-button\n              icon=\"pi pi-search\"\n              severity=\"secondary\"\n              [text]=\"true\"\n              [rounded]=\"true\"\n              (onClick)=\"openLookup()\"\n              [disabled]=\"isFieldDisabled()\"\n              pTooltip=\"Buscar\"\n              tooltipPosition=\"top\"\n              size=\"small\"\n            ></p-button>\n          </div>\n        </div>\n      </div>\n\n      <!-- Lookup Dialog -->\n      <p-dialog\n        [(visible)]=\"showLookupDialog\"\n        [modal]=\"true\"\n        [style]=\"{ width: '800px', maxHeight: '80vh' }\"\n        [contentStyle]=\"{ maxHeight: 'calc(80vh - 120px)', overflow: 'auto' }\"\n        [draggable]=\"false\"\n        [resizable]=\"true\"\n        [header]=\"'Selecionar ' + (field.label | translate)\"\n        [appendTo]=\"'body'\"\n        (onHide)=\"onDialogHide()\"\n      >\n        <div class=\"lookup-dialog-content\">\n          <!-- Search Input -->\n          <div class=\"search-wrapper\">\n            <input\n              pInputText\n              [(ngModel)]=\"searchTerm\"\n              [placeholder]=\"'Buscar ' + (field.label | translate).toLowerCase() + '...'\"\n              (keydown.enter)=\"onSearch()\"\n              class=\"search-input-full\"\n            />\n            <div class=\"search-buttons-inside\">\n              <p-button\n                *ngIf=\"searchTerm\"\n                icon=\"pi pi-trash\"\n                severity=\"danger\"\n                [text]=\"true\"\n                [rounded]=\"true\"\n                (onClick)=\"clearSearch()\"\n                class=\"search-button-clear\"\n                pTooltip=\"Limpar busca\"\n                tooltipPosition=\"top\"\n              ></p-button>\n              <p-button\n                icon=\"pi pi-search\"\n                severity=\"secondary\"\n                [text]=\"true\"\n                [rounded]=\"true\"\n                (onClick)=\"onSearch()\"\n                class=\"search-button-search\"\n                pTooltip=\"Buscar\"\n                tooltipPosition=\"top\"\n              ></p-button>\n            </div>\n          </div>\n\n          <!-- Data Table -->\n          <p-table\n            [value]=\"filteredData\"\n            [loading]=\"loading\"\n            [paginator]=\"true\"\n            [rows]=\"pageSize\"\n            [totalRecords]=\"totalRecords\"\n            [lazy]=\"true\"\n            (onLazyLoad)=\"onPageChange($event)\"\n            [showCurrentPageReport]=\"true\"\n            currentPageReportTemplate=\"Mostrando {first} a {last} de {totalRecords} registros\"\n            dataKey=\"id\"\n            [rowHover]=\"true\"\n            responsiveLayout=\"scroll\"\n            styleClass=\"p-datatable-striped lookup-table\"\n            [(selection)]=\"selectedItem\"\n            (onRowSelect)=\"onRowSelect($event)\"\n            selectionMode=\"single\"\n          >\n            <ng-template pTemplate=\"header\">\n              <tr>\n                <th *ngFor=\"let col of columns\" [style.width]=\"col.width\">\n                  {{ col.header }}\n                </th>\n              </tr>\n            </ng-template>\n\n            <ng-template pTemplate=\"body\" let-item>\n              <tr [pSelectableRow]=\"item\">\n                <td *ngFor=\"let col of columns\">\n                  {{ getFieldValue(item, col.field) }}\n                </td>\n              </tr>\n            </ng-template>\n\n            <ng-template pTemplate=\"emptymessage\">\n              <tr>\n                <td [attr.colspan]=\"columns.length\" class=\"empty-message\">\n                  <div class=\"empty-state\">\n                    <i class=\"pi pi-search\"></i>\n                    <p>Nenhum registro encontrado</p>\n                    <small>Tente ajustar os termos de busca</small>\n                  </div>\n                </td>\n              </tr>\n            </ng-template>\n          </p-table>\n        </div>\n      </p-dialog>\n    </sia-dynamic-field-wrapper>\n  `,\n  styles: [`\n    .lookup-field {\n      width: 100%;\n      position: relative;\n    }\n\n    .lookup-input-group {\n      position: relative;\n      width: 100%;\n      \n      .lookup-display {\n        width: 100%;\n        cursor: pointer;\n        height: 2.857rem;\n        padding: 0.75rem 4rem 0.75rem 0.75rem;\n        font-size: 1rem;\n        line-height: 1.5;\n        box-sizing: border-box;\n        display: flex;\n        align-items: center;\n        \n        &:focus {\n          outline: none;\n        }\n        \n        &:hover {\n          background: transparent;\n        }\n      }\n\n      .lookup-buttons {\n        position: absolute;\n        right: 4px;\n        top: 50%;\n        transform: translateY(-50%);\n        display: flex;\n        gap: 2px;\n        z-index: 10;\n      }\n\n      ::ng-deep .p-button {\n        width: 2rem !important;\n        height: 2rem !important;\n        min-width: 2rem !important;\n        min-height: 2rem !important;\n        padding: 0 !important;\n        margin: 0 !important;\n        display: flex !important;\n        align-items: center !important;\n        justify-content: center !important;\n        box-sizing: border-box !important;\n        \n        .p-button-icon {\n          margin: 0 !important;\n          font-size: 0.875rem !important;\n        }\n        \n        .p-button-label {\n          display: none !important;\n        }\n      }\n    }\n\n    .lookup-dialog-content {\n      height: 100%;\n      display: flex;\n      flex-direction: column;\n      padding: 0;\n\n      .search-wrapper {\n        position: relative;\n        margin-bottom: 16px;\n        width: 100%;\n\n        .search-input-full {\n          width: 100%;\n          padding-right: 5.5rem;\n        }\n\n        .search-buttons-inside {\n          position: absolute;\n          right: 4px;\n          top: 50%;\n          transform: translateY(-50%);\n          display: flex;\n          gap: 2px;\n          \n          ::ng-deep .p-button {\n            width: 2.5rem !important;\n            height: 2.5rem !important;\n          }\n        }\n      }\n\n      .lookup-table {\n        flex: 1;\n        \n        .empty-state {\n          text-align: center;\n          padding: 32px;\n          color: var(--p-text-color-secondary);\n\n          i {\n            font-size: 48px;\n            margin-bottom: 16px;\n            display: block;\n          }\n\n          p {\n            margin: 8px 0;\n            font-size: 16px;\n          }\n\n          small {\n            font-size: 14px;\n          }\n        }\n      }\n    }\n  `]\n})\nexport class DynamicFieldLookupComponent implements OnInit {\n  @Input() field!: DynamicFormFieldConfig;\n  @Input() form!: FormGroup;\n  @Input() formGroup!: FormGroup;\n  @Input() mode: 'form' | 'filter' = 'form';\n\n  displayValue: string = '';\n  showLookupDialog: boolean = false;\n  loading: boolean = false;\n  searchTerm: string = '';\n  \n  data: any[] = [];\n  filteredData: any[] = [];\n  totalRecords: number = 0;\n  currentPage: number = 0;\n  pageSize: number = 5;\n  selectedItem: any = null;\n  \n  columns: LookupColumn[] = [];\n  displayField: string = 'name';\n  valueField: string = 'id';\n  searchFields: string[] = ['name'];\n\n  constructor(private translationService: TranslationService) {}\n\n  ngOnInit(): void {\n    this.setupLookupConfig();\n    this.watchValueChanges();\n  }\n\n  private watchValueChanges(): void {\n    const control = this.form.get(this.field.field);\n    if (control) {\n      // Carregar valor inicial\n      if (control.value) {\n        this.handleValueDisplay(control.value);\n      }\n      \n      // Observar mudanças\n      control.valueChanges.subscribe(value => {\n        if (value !== null && value !== undefined && value !== '') {\n          this.handleValueDisplay(value);\n        } else {\n          this.displayValue = '';\n        }\n      });\n    }\n  }\n\n  private get value(): any {\n    return this.form.get(this.field.field)?.value;\n  }\n\n  get currentValue(): any {\n    return this.value;\n  }\n\n  private setValue(value: any): void {\n    this.form.get(this.field.field)?.setValue(value);\n  }\n\n  private setupLookupConfig(): void {\n    if (this.field) {\n      this.displayField = this.field.lookupDisplayField || 'name';\n      this.valueField = this.field.lookupValueField || 'id';\n      this.searchFields = this.field.lookupSearchFields || ['name'];\n      this.columns = this.field.lookupColumns || [\n        { field: this.displayField, header: 'Nome', width: '100%' }\n      ];\n    }\n  }\n\n  private handleValueDisplay(value: any): void {\n    if (value === null || value === undefined || value === '') {\n      this.displayValue = '';\n      return;\n    }\n    \n    if (typeof value === 'object' && value !== null) {\n      this.displayValue = this.formatDisplayValue(value);\n      // Em modo filter, manter o objeto completo\n      // Em modo form, extrair apenas o ID EXCETO se já temos o objeto completo\n      // (evita requisições desnecessárias quando o objeto já está carregado)\n      if (this.mode === 'form') {\n        // Verificar se o objeto tem o campo de display preenchido\n        // Se tiver, significa que já temos os dados completos e não precisamos fazer nada\n        const hasDisplayData = this.field?.lookupDisplayFields \n          ? this.field.lookupDisplayFields.some(f => this.getFieldValue(value, f))\n          : value[this.displayField];\n        \n        if (!hasDisplayData) {\n          // Só extrair o ID se não temos os dados de display\n          const newValue = value[this.valueField] || value.id || value;\n          if (this.value !== newValue) {\n            this.setValue(newValue);\n          }\n        }\n      }\n      return;\n    }\n    \n    // Se é um ID (string ou number), não fazer requisição\n    // Deixar vazio e só carregar quando abrir o lookup\n    if (typeof value === 'string' || typeof value === 'number') {\n      this.displayValue = '';\n      return;\n    }\n  }\n\n  private formatDisplayValue(item: any): string {\n    if (!item) return '';\n    \n    if (this.field?.lookupDisplayFields && this.field.lookupDisplayFields.length > 0) {\n      const values = this.field.lookupDisplayFields\n        .map(fieldName => this.getFieldValue(item, fieldName))\n        .filter(value => value !== null && value !== undefined && value !== '');\n      \n      return values.join(' - ');\n    }\n    \n    return this.getFieldValue(item, this.displayField) || '';\n  }\n\n  isFieldInvalid(): boolean {\n    const control = this.form.get(this.field.field);\n    return !!(control && control.invalid && (control.dirty || control.touched));\n  }\n\n  isFieldDisabled(): boolean {\n    const control = this.form.get(this.field.field);\n    return control?.disabled || false;\n  }\n\n  getPlaceholder(): string {\n    if (this.mode === 'filter') {\n      return this.translationService.translate('crmx.business.filter_search_placeholder', { \n        label: this.field.label.toLowerCase() \n      });\n    }\n    return this.field.placeholder || 'Clique para selecionar';\n  }\n\n  openLookup(): void {\n    if (this.isFieldDisabled()) {\n      return;\n    }\n    \n    this.updateSelectedItem();\n    \n    this.showLookupDialog = true;\n    this.currentPage = 0;\n    this.searchTerm = '';\n    this.loadData();\n  }\n\n  onDialogHide(): void {\n    this.searchTerm = '';\n    this.currentPage = 0;\n  }\n\n  onPageChange(event: any): void {\n    if (!this.showLookupDialog) {\n      return;\n    }\n    \n    this.currentPage = event.first / event.rows;\n    this.loadData();\n  }\n\n  private loadData(): void {\n    if (!this.field?.lookupService) {\n      return;\n    }\n\n    this.loading = true;\n    \n    const listParams: any = { \n      page: this.currentPage,\n      size: this.pageSize\n    };\n    \n    if (this.searchTerm.trim()) {\n      const term = this.searchTerm.trim();\n      const filterConditions: string[] = [];\n      const isNumericTerm = !isNaN(Number(term)) && term !== '';\n      \n      this.searchFields.forEach(field => {\n        const column = this.columns.find(col => col.field === field);\n        const fieldType = column?.type || 'text';\n        \n        if (fieldType === 'number') {\n          if (isNumericTerm) {\n            filterConditions.push(`${field} eq ${term}`);\n          }\n        } else {\n          const upperTerm = term.toUpperCase();\n          filterConditions.push(`UPPER(${field}) like '%${upperTerm}%'`);\n        }\n      });\n      \n      if (filterConditions.length > 0) {\n        listParams.filterQuery = filterConditions.join(' or ');\n      }\n    }\n    \n    if (this.field.lookupFilters) {\n      Object.keys(this.field.lookupFilters).forEach(key => {\n        listParams[key] = this.field.lookupFilters![key];\n      });\n    }\n    \n    if (this.field.lookupDynamicFilters && this.formGroup) {\n      const dynamicFilters = this.field.lookupDynamicFilters(this.formGroup.value);\n      \n      const dynamicFilterConditions: string[] = [];\n      Object.keys(dynamicFilters).forEach(key => {\n        const value = dynamicFilters[key];\n        if (value !== null && value !== undefined) {\n          dynamicFilterConditions.push(`${key} eq '${value}'`);\n        }\n      });\n      \n      if (dynamicFilterConditions.length > 0) {\n        const dynamicFilterQuery = dynamicFilterConditions.join(' and ');\n        if (listParams.filterQuery) {\n          listParams.filterQuery = `(${listParams.filterQuery}) and (${dynamicFilterQuery})`;\n        } else {\n          listParams.filterQuery = dynamicFilterQuery;\n        }\n      }\n    }\n    \n    this.field.lookupService.list(listParams).subscribe({\n      next: (response: any) => {\n        this.data = response.contents || [];\n        this.filteredData = [...this.data];\n        this.totalRecords = response.totalElements || 0;\n        \n        this.updateSelectedItem();\n        \n        // Após carregar os dados da grid, se temos um valor selecionado mas sem displayValue,\n        // tentar encontrar o item nos dados carregados\n        if (this.value && !this.displayValue) {\n          const item = this.filteredData.find(i => i[this.valueField] === this.value);\n          if (item) {\n            this.displayValue = this.formatDisplayValue(item);\n          }\n        }\n        \n        this.loading = false;\n      },\n      error: (_error: unknown) => {\n        this.data = [];\n        this.filteredData = [];\n        this.totalRecords = 0;\n        this.loading = false;\n      }\n    });\n  }\n\n  private updateSelectedItem(): void {\n    if (!this.value) {\n      this.selectedItem = null;\n      return;\n    }\n    \n    const item = this.filteredData.find(i => i[this.valueField] === this.value);\n    if (item) {\n      this.selectedItem = item;\n    }\n  }\n\n  onSearch(): void {\n    if (!this.showLookupDialog) {\n      return;\n    }\n    \n    this.currentPage = 0;\n    this.loadData();\n  }\n\n  clearSearch(): void {\n    this.searchTerm = '';\n    this.currentPage = 0;\n    this.loadData();\n  }\n\n  selectItem(item: any): void {\n    if (this.mode === 'filter') {\n      this.setValue(item);\n      this.displayValue = this.formatDisplayValue(item);\n    } else {\n      const newValue = item[this.valueField];\n      this.setValue(newValue);\n      this.displayValue = this.formatDisplayValue(item);\n    }\n    this.showLookupDialog = false;\n  }\n\n  onRowSelect(event: any): void {\n    this.selectItem(event.data);\n  }\n\n  clearValue(): void {\n    this.setValue(null);\n    this.displayValue = '';\n    this.selectedItem = null;\n  }\n\n  getFieldValue(item: any, field: string): any {\n    return field.split('.').reduce((obj, key) => obj?.[key], item) || '';\n  }\n}\n"]}