@acorex/platform 18.0.0 → 18.0.1

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget-filter.component.mjs

@@ -0,0 +1,20 @@
+import { AXPWidgetBase } from '@acorex/platform/layout/builder';
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class AXPLookupWidgetFilterComponent extends AXPWidgetBase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetFilterComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPLookupWidgetFilterComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetFilterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, FormsModule],
+                    inputs: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLXdpZGdldC1maWx0ZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wbGF0Zm9ybS9sYXlvdXQvZW50aXR5L3NyYy9saWIvd2lkZ2V0cy9sb29rdXAtd2lkZ2V0L2xvb2t1cC13aWRnZXQtZmlsdGVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDaEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFDM0UsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQVM3QyxNQUFNLE9BQU8sOEJBQStCLFNBQVEsYUFBa0I7OEdBQXpELDhCQUE4QjtrR0FBOUIsOEJBQThCLCtGQU4vQixFQUFFLDJEQUdGLFlBQVksOEJBQUUsV0FBVzs7MkZBR3hCLDhCQUE4QjtrQkFQMUMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsRUFBRTtvQkFDWixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLENBQUM7b0JBQ3BDLE1BQU0sRUFBRSxFQUFFO2lCQUNYIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQVhQV2lkZ2V0QmFzZSB9IGZyb20gJ0BhY29yZXgvcGxhdGZvcm0vbGF5b3V0L2J1aWxkZXInO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogYGAsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZV0sXG4gIGlucHV0czogW11cbn0pXG5leHBvcnQgY2xhc3MgQVhQTG9va3VwV2lkZ2V0RmlsdGVyQ29tcG9uZW50IGV4dGVuZHMgQVhQV2lkZ2V0QmFzZTxhbnk+IHt9Il19

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget-print.component.mjs

@@ -0,0 +1,19 @@
+import { AXPWidgetBase } from '@acorex/platform/layout/builder';
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXPLookupWidgetPrintComponent extends AXPWidgetBase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetPrintComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPLookupWidgetPrintComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetPrintComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLXdpZGdldC1wcmludC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL2xheW91dC9lbnRpdHkvc3JjL2xpYi93aWRnZXRzL2xvb2t1cC13aWRnZXQvbG9va3VwLXdpZGdldC1wcmludC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFVLE1BQU0sZUFBZSxDQUFDOztBQVEzRSxNQUFNLE9BQU8sNkJBQThCLFNBQVEsYUFBa0I7OEdBQXhELDZCQUE2QjtrR0FBN0IsNkJBQTZCLCtGQU45QixFQUFFLDJEQUdGLFlBQVk7OzJGQUdYLDZCQUE2QjtrQkFQekMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsRUFBRTtvQkFDWixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsTUFBTSxFQUFFLEVBQUU7aUJBQ1giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBWFBXaWRnZXRCYXNlIH0gZnJvbSAnQGFjb3JleC9wbGF0Zm9ybS9sYXlvdXQvYnVpbGRlcic7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBgLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGlucHV0czogW11cbn0pXG5leHBvcnQgY2xhc3MgQVhQTG9va3VwV2lkZ2V0UHJpbnRDb21wb25lbnQgZXh0ZW5kcyBBWFBXaWRnZXRCYXNlPGFueT4ge30iXX0=

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget-selector.component.mjs

@@ -0,0 +1,105 @@
+import { AXDataTableModule } from '@acorex/components/data-table';
+import { AXPLayoutBuilderModule } from '@acorex/platform/layout/builder';
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXSearchBoxModule } from '@acorex/components/search-box';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXDropdownButtonModule } from '@acorex/components/dropdown-button';
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/components/decorators";
+import * as i2 from "@acorex/components/data-table";
+import * as i3 from "@acorex/components/search-box";
+import * as i4 from "@acorex/platform/layout/builder";
+export class AXPLookupWidgetSelectorComponent extends AXBasePageComponent {
+    handleRowDbClick(e) {
+        this.close({ items: [e.data] });
+    }
+    async handleSelectedRowsChange(rows) {
+        //this.vm.selectedItems.set(rows);
+    }
+    handleChangeSearchValue(e) {
+        if (e.isUserInteraction) {
+            this.vm.applyInlineFilter(e.value);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetSelectorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPLookupWidgetSelectorComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <div class="ax-p-4 ax-flex ax-flex-col ax-gap-4  ax-overflow-hidden">
+      @if(vm.hasInlineFilters())
+      {
+      <div class="ax-w-full" >
+        <ax-search-box [placeholder]="'Search on '+vm.inlineFiltersPlaceholders().join(', ')"
+          (onValueChanged)="handleChangeSearchValue($event)"><ax-clear-button></ax-clear-button></ax-search-box>
+      </div>
+      }
+      <ax-data-table #grid [showFooter]="false" class="ax-h-[50vh]" [paging]="true" [fetchDataMode]="'auto'"
+        [loading]="{ enabled: true, animation: true }" [dataSource]="vm.dataSource"
+        (selectedRowsChange)="handleSelectedRowsChange($event)" (onRowDbClick)="handleRowDbClick($event)">
+        <!-- <ax-select-column fixed="start" [width]="'50px'"></ax-select-column> -->
+        @for(col of vm.columns();track col.name) {
+        @if(col.visible)
+        {
+        <axp-widget-column-renderer [caption]="col.title" [node]="col.node()"></axp-widget-column-renderer>
+        }
+        }
+      </ax-data-table>
+    </div>
+     <!-- <ax-footer>
+     <ax-suffix>
+      <ax-button look="solid" color="ghost" text="Cancel" (onClick)="handleCloseClick()"> </ax-button>
+      <ax-dropdown-button [disabled]="vm.isInProgress()" color="primary" text="Save" look="solid"
+        (onClick)="handleSaveClick(form)">
+        <ax-loading *ngIf="vm.isInProgress()"></ax-loading>
+        <ax-button-item-list>
+          <ax-button-item text="Save & Create New" (onClick)="handleSaveAndNewClick(form)"> </ax-button-item>
+        </ax-button-item-list>
+      </ax-dropdown-button>
+    </ax-suffix>
+     </ax-footer> -->
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorClearButtonComponent, selector: "ax-clear-button", inputs: ["icon"] }, { kind: "ngmodule", type: AXDropdownButtonModule }, { kind: "ngmodule", type: AXDataTableModule }, { kind: "component", type: i2.AXDataTableComponent, selector: "ax-data-table", inputs: ["dataSource", "rowTemplate", "emptyTemplate", "alternative", "showHeader", "fixedHeader", "showFooter", "fixedFooter", "itemHeight", "allowReordering", "paging", "fetchDataMode", "loading", "focusedRow"], outputs: ["selectedRowsChange", "focusedRowChange", "onRowClick", "onRowDbClick", "onColumnsOrderChanged"] }, { kind: "ngmodule", type: AXSearchBoxModule }, { kind: "component", type: i3.AXSearchBoxComponent, selector: "ax-search-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "delayTime"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXPLayoutBuilderModule }, { kind: "component", type: i4.AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: ["caption", "node", "footerTemplate", "cellTemplate", "headerTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetSelectorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="ax-p-4 ax-flex ax-flex-col ax-gap-4  ax-overflow-hidden">
+      @if(vm.hasInlineFilters())
+      {
+      <div class="ax-w-full" >
+        <ax-search-box [placeholder]="'Search on '+vm.inlineFiltersPlaceholders().join(', ')"
+          (onValueChanged)="handleChangeSearchValue($event)"><ax-clear-button></ax-clear-button></ax-search-box>
+      </div>
+      }
+      <ax-data-table #grid [showFooter]="false" class="ax-h-[50vh]" [paging]="true" [fetchDataMode]="'auto'"
+        [loading]="{ enabled: true, animation: true }" [dataSource]="vm.dataSource"
+        (selectedRowsChange)="handleSelectedRowsChange($event)" (onRowDbClick)="handleRowDbClick($event)">
+        <!-- <ax-select-column fixed="start" [width]="'50px'"></ax-select-column> -->
+        @for(col of vm.columns();track col.name) {
+        @if(col.visible)
+        {
+        <axp-widget-column-renderer [caption]="col.title" [node]="col.node()"></axp-widget-column-renderer>
+        }
+        }
+      </ax-data-table>
+    </div>
+     <!-- <ax-footer>
+     <ax-suffix>
+      <ax-button look="solid" color="ghost" text="Cancel" (onClick)="handleCloseClick()"> </ax-button>
+      <ax-dropdown-button [disabled]="vm.isInProgress()" color="primary" text="Save" look="solid"
+        (onClick)="handleSaveClick(form)">
+        <ax-loading *ngIf="vm.isInProgress()"></ax-loading>
+        <ax-button-item-list>
+          <ax-button-item text="Save & Create New" (onClick)="handleSaveAndNewClick(form)"> </ax-button-item>
+        </ax-button-item-list>
+      </ax-dropdown-button>
+    </ax-suffix>
+     </ax-footer> -->
+  `,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, AXDecoratorModule, AXDropdownButtonModule, AXDataTableModule, AXSearchBoxModule, AXPLayoutBuilderModule],
+                    inputs: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget-selector.viewmodel.mjs

@@ -0,0 +1,85 @@
+import { AXDataSource } from '@acorex/components/common';
+import { AXPEntityListViewColumnViewModel } from '../../entity.viewmodel';
+import { computed } from '@angular/core';
+export class AXPLookupWidgetSelectorViewModel {
+    constructor(entityDef) {
+        this.entityDef = entityDef;
+        this.dataSource = new AXDataSource({
+            byKey: (key) => {
+                const func = this.entityDef.queries.byKey.execute;
+                return func();
+            },
+            load: (e) => {
+                const func = this.entityDef.queries.list?.execute;
+                return func(e);
+            },
+            pageSize: 10,
+            key: 'id'
+        });
+        this.inlineFiltersPlaceholders = computed(() => {
+            return this.entityDef.properties.filter(p => p.options?.filter?.inline?.enabled).map(c => c.title);
+        });
+        this.hasInlineFilters = computed(() => {
+            return this.inlineFiltersPlaceholders().length > 0;
+        });
+        this.columns = () => {
+            const props = this.entityDef.properties.filter(c => c.schema.hidden != true && c.options?.table?.enabled);
+            return props.map(e => {
+                return new AXPEntityListViewColumnViewModel(e);
+            });
+        };
+        this.inlineFilters = {
+            field: null,
+            logic: 'or',
+            operator: null,
+            filters: []
+        };
+        this.advanceFilters = {
+            field: null,
+            logic: 'and',
+            operator: null,
+            filters: []
+        };
+    }
+    applyInlineFilter(value) {
+        const props = this.entityDef.properties.filter(c => c.options?.filter?.inline?.enabled);
+        this.inlineFilters.filters = [];
+        if (value) {
+            props.forEach(p => {
+                this.inlineFilters.filters?.push({
+                    field: p.name,
+                    operator: {
+                        type: 'contains'
+                    },
+                    value
+                });
+            });
+        }
+        this.applyFilterAndSort();
+    }
+    applyFilterAndSort() {
+        this.dataSource.clearFilter();
+        //
+        //this.dataSource.sort(...this.sortedFields().map(s => ({ dir: s.dir, field: s.name } as AXDataSourceSortOption)));
+        //
+        const inline = this.inlineFilters.filters?.length ?? 0;
+        const advance = this.advanceFilters.filters?.length ?? 0;
+        if (inline && !advance) {
+            this.dataSource.filter(this.inlineFilters);
+        }
+        else if (!inline && advance) {
+            this.dataSource.filter(this.advanceFilters);
+        }
+        else if (inline && advance) {
+            this.dataSource.filter({
+                field: null,
+                logic: 'and',
+                operator: null,
+                filters: [this.inlineFilters, this.advanceFilters]
+            });
+        }
+        //
+        this.dataSource.refresh();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLXdpZGdldC1zZWxlY3Rvci52aWV3bW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL2xheW91dC9lbnRpdHkvc3JjL2xpYi93aWRnZXRzL2xvb2t1cC13aWRnZXQvbG9va3VwLXdpZGdldC1zZWxlY3Rvci52aWV3bW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBNEIsTUFBTSwyQkFBMkIsQ0FBQztBQUNuRixPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMxRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSXpDLE1BQU0sT0FBTyxnQ0FBZ0M7SUFFM0MsWUFBb0IsU0FBb0I7UUFBcEIsY0FBUyxHQUFULFNBQVMsQ0FBVztRQUl4QyxlQUFVLEdBQUcsSUFBSSxZQUFZLENBQUM7WUFDNUIsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7Z0JBQ2IsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQW1CLENBQUM7Z0JBQzlELE9BQU8sSUFBSSxFQUFFLENBQUM7WUFDaEIsQ0FBQztZQUNELElBQUksRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFO2dCQUNWLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxPQUFtQixDQUFDO2dCQUM5RCxPQUFPLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNqQixDQUFDO1lBQ0QsUUFBUSxFQUFFLEVBQUU7WUFDWixHQUFHLEVBQUUsSUFBSTtTQUNWLENBQUMsQ0FBQztRQUVJLDhCQUF5QixHQUFHLFFBQVEsQ0FBVyxHQUFHLEVBQUU7WUFDekQsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3JHLENBQUMsQ0FBQyxDQUFDO1FBRUkscUJBQWdCLEdBQUcsUUFBUSxDQUFVLEdBQUcsRUFBRTtZQUMvQyxPQUFPLElBQUksQ0FBQyx5QkFBeUIsRUFBRSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDckQsQ0FBQyxDQUFDLENBQUM7UUFHSSxZQUFPLEdBQUcsR0FBRyxFQUFFO1lBQ3BCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBTSxJQUFJLElBQUksSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQztZQUMxRyxPQUFPLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUU7Z0JBQ25CLE9BQU8sSUFBSSxnQ0FBZ0MsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNqRCxDQUFDLENBQUMsQ0FBQTtRQUNKLENBQUMsQ0FBQztRQUdNLGtCQUFhLEdBQTZCO1lBQ2hELEtBQUssRUFBRSxJQUFXO1lBQ2xCLEtBQUssRUFBRSxJQUFJO1lBQ1gsUUFBUSxFQUFFLElBQVc7WUFDckIsT0FBTyxFQUFFLEVBQUU7U0FDWixDQUFDO1FBRU0sbUJBQWMsR0FBNkI7WUFDakQsS0FBSyxFQUFFLElBQVc7WUFDbEIsS0FBSyxFQUFFLEtBQUs7WUFDWixRQUFRLEVBQUUsSUFBVztZQUNyQixPQUFPLEVBQUUsRUFBRTtTQUNaLENBQUM7SUE1Q0YsQ0FBQztJQThDRCxpQkFBaUIsQ0FBQyxLQUFhO1FBQzdCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN4RixJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDaEMsSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUNWLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUU7Z0JBQ2hCLElBQUksQ0FBQyxhQUFhLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQztvQkFDL0IsS0FBSyxFQUFFLENBQUMsQ0FBQyxJQUFJO29CQUNiLFFBQVEsRUFBRTt3QkFDUixJQUFJLEVBQUUsVUFBVTtxQkFDakI7b0JBQ0QsS0FBSztpQkFDTixDQUFDLENBQUE7WUFDSixDQUFDLENBQUMsQ0FBQTtRQUNKLENBQUM7UUFDRCxJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRUQsa0JBQWtCO1FBQ2hCLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDOUIsRUFBRTtRQUNGLG1IQUFtSDtRQUNuSCxFQUFFO1FBQ0YsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLEVBQUUsTUFBTSxJQUFJLENBQUMsQ0FBQztRQUN2RCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQyxDQUFDO1FBQ3pELElBQUksTUFBTSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQzdDLENBQUM7YUFDSSxJQUFJLENBQUMsTUFBTSxJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQzVCLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUM5QyxDQUFDO2FBQ0ksSUFBSSxNQUFNLElBQUksT0FBTyxFQUFFLENBQUM7WUFDM0IsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUM7Z0JBQ3JCLEtBQUssRUFBRSxJQUFXO2dCQUNsQixLQUFLLEVBQUUsS0FBSztnQkFDWixRQUFRLEVBQUUsSUFBVztnQkFDckIsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsY0FBYyxDQUFDO2FBQ25ELENBQUMsQ0FBQztRQUNMLENBQUM7UUFDRCxFQUFFO1FBQ0YsSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM1QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBWERhdGFTb3VyY2UsIEFYRGF0YVNvdXJjZUZpbHRlck9wdGlvbiB9IGZyb20gJ0BhY29yZXgvY29tcG9uZW50cy9jb21tb24nO1xyXG5pbXBvcnQgeyBBWFBFbnRpdHlMaXN0Vmlld0NvbHVtblZpZXdNb2RlbCB9IGZyb20gJy4uLy4uL2VudGl0eS52aWV3bW9kZWwnO1xyXG5pbXBvcnQgeyBjb21wdXRlZCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBBWFBFbnRpdHkgfSBmcm9tICdAYWNvcmV4L3BsYXRmb3JtL2NvbW1vbic7XHJcblxyXG5cclxuZXhwb3J0IGNsYXNzIEFYUExvb2t1cFdpZGdldFNlbGVjdG9yVmlld01vZGVsIHtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBlbnRpdHlEZWY6IEFYUEVudGl0eSkge1xyXG5cclxuICB9XHJcblxyXG4gIGRhdGFTb3VyY2UgPSBuZXcgQVhEYXRhU291cmNlKHtcclxuICAgIGJ5S2V5OiAoa2V5KSA9PiB7XHJcbiAgICAgIGNvbnN0IGZ1bmMgPSB0aGlzLmVudGl0eURlZi5xdWVyaWVzLmJ5S2V5LmV4ZWN1dGUgYXMgRnVuY3Rpb247XHJcbiAgICAgIHJldHVybiBmdW5jKCk7XHJcbiAgICB9LFxyXG4gICAgbG9hZDogKGUpID0+IHtcclxuICAgICAgY29uc3QgZnVuYyA9IHRoaXMuZW50aXR5RGVmLnF1ZXJpZXMubGlzdD8uZXhlY3V0ZSBhcyBGdW5jdGlvbjtcclxuICAgICAgcmV0dXJuIGZ1bmMoZSk7XHJcbiAgICB9LFxyXG4gICAgcGFnZVNpemU6IDEwLFxyXG4gICAga2V5OiAnaWQnXHJcbiAgfSk7XHJcblxyXG4gIHB1YmxpYyBpbmxpbmVGaWx0ZXJzUGxhY2Vob2xkZXJzID0gY29tcHV0ZWQ8c3RyaW5nW10+KCgpID0+IHtcclxuICAgIHJldHVybiB0aGlzLmVudGl0eURlZi5wcm9wZXJ0aWVzLmZpbHRlcihwID0+IHAub3B0aW9ucz8uZmlsdGVyPy5pbmxpbmU/LmVuYWJsZWQpLm1hcChjID0+IGMudGl0bGUpO1xyXG4gIH0pO1xyXG5cclxuICBwdWJsaWMgaGFzSW5saW5lRmlsdGVycyA9IGNvbXB1dGVkPGJvb2xlYW4+KCgpID0+IHtcclxuICAgIHJldHVybiB0aGlzLmlubGluZUZpbHRlcnNQbGFjZWhvbGRlcnMoKS5sZW5ndGggPiAwO1xyXG4gIH0pO1xyXG5cclxuXHJcbiAgcHVibGljIGNvbHVtbnMgPSAoKSA9PiB7XHJcbiAgICBjb25zdCBwcm9wcyA9IHRoaXMuZW50aXR5RGVmLnByb3BlcnRpZXMuZmlsdGVyKGMgPT4gYy5zY2hlbWEuaGlkZGVuICE9IHRydWUgJiYgYy5vcHRpb25zPy50YWJsZT8uZW5hYmxlZCk7XHJcbiAgICByZXR1cm4gcHJvcHMubWFwKGUgPT4ge1xyXG4gICAgICByZXR1cm4gbmV3IEFYUEVudGl0eUxpc3RWaWV3Q29sdW1uVmlld01vZGVsKGUpO1xyXG4gICAgfSlcclxuICB9O1xyXG5cclxuXHJcbiAgcHJpdmF0ZSBpbmxpbmVGaWx0ZXJzOiBBWERhdGFTb3VyY2VGaWx0ZXJPcHRpb24gPSB7XHJcbiAgICBmaWVsZDogbnVsbCBhcyBhbnksXHJcbiAgICBsb2dpYzogJ29yJyxcclxuICAgIG9wZXJhdG9yOiBudWxsIGFzIGFueSxcclxuICAgIGZpbHRlcnM6IFtdXHJcbiAgfTtcclxuXHJcbiAgcHJpdmF0ZSBhZHZhbmNlRmlsdGVyczogQVhEYXRhU291cmNlRmlsdGVyT3B0aW9uID0ge1xyXG4gICAgZmllbGQ6IG51bGwgYXMgYW55LFxyXG4gICAgbG9naWM6ICdhbmQnLFxyXG4gICAgb3BlcmF0b3I6IG51bGwgYXMgYW55LFxyXG4gICAgZmlsdGVyczogW11cclxuICB9O1xyXG5cclxuICBhcHBseUlubGluZUZpbHRlcih2YWx1ZTogc3RyaW5nKSB7XHJcbiAgICBjb25zdCBwcm9wcyA9IHRoaXMuZW50aXR5RGVmLnByb3BlcnRpZXMuZmlsdGVyKGMgPT4gYy5vcHRpb25zPy5maWx0ZXI/LmlubGluZT8uZW5hYmxlZCk7XHJcbiAgICB0aGlzLmlubGluZUZpbHRlcnMuZmlsdGVycyA9IFtdO1xyXG4gICAgaWYgKHZhbHVlKSB7XHJcbiAgICAgIHByb3BzLmZvckVhY2gocCA9PiB7XHJcbiAgICAgICAgdGhpcy5pbmxpbmVGaWx0ZXJzLmZpbHRlcnM/LnB1c2goe1xyXG4gICAgICAgICAgZmllbGQ6IHAubmFtZSxcclxuICAgICAgICAgIG9wZXJhdG9yOiB7XHJcbiAgICAgICAgICAgIHR5cGU6ICdjb250YWlucydcclxuICAgICAgICAgIH0sXHJcbiAgICAgICAgICB2YWx1ZVxyXG4gICAgICAgIH0pXHJcbiAgICAgIH0pXHJcbiAgICB9XHJcbiAgICB0aGlzLmFwcGx5RmlsdGVyQW5kU29ydCgpO1xyXG4gIH1cclxuXHJcbiAgYXBwbHlGaWx0ZXJBbmRTb3J0KCkge1xyXG4gICAgdGhpcy5kYXRhU291cmNlLmNsZWFyRmlsdGVyKCk7XHJcbiAgICAvL1xyXG4gICAgLy90aGlzLmRhdGFTb3VyY2Uuc29ydCguLi50aGlzLnNvcnRlZEZpZWxkcygpLm1hcChzID0+ICh7IGRpcjogcy5kaXIsIGZpZWxkOiBzLm5hbWUgfSBhcyBBWERhdGFTb3VyY2VTb3J0T3B0aW9uKSkpO1xyXG4gICAgLy9cclxuICAgIGNvbnN0IGlubGluZSA9IHRoaXMuaW5saW5lRmlsdGVycy5maWx0ZXJzPy5sZW5ndGggPz8gMDtcclxuICAgIGNvbnN0IGFkdmFuY2UgPSB0aGlzLmFkdmFuY2VGaWx0ZXJzLmZpbHRlcnM/Lmxlbmd0aCA/PyAwO1xyXG4gICAgaWYgKGlubGluZSAmJiAhYWR2YW5jZSkge1xyXG4gICAgICB0aGlzLmRhdGFTb3VyY2UuZmlsdGVyKHRoaXMuaW5saW5lRmlsdGVycyk7XHJcbiAgICB9XHJcbiAgICBlbHNlIGlmICghaW5saW5lICYmIGFkdmFuY2UpIHtcclxuICAgICAgdGhpcy5kYXRhU291cmNlLmZpbHRlcih0aGlzLmFkdmFuY2VGaWx0ZXJzKTtcclxuICAgIH1cclxuICAgIGVsc2UgaWYgKGlubGluZSAmJiBhZHZhbmNlKSB7XHJcbiAgICAgIHRoaXMuZGF0YVNvdXJjZS5maWx0ZXIoe1xyXG4gICAgICAgIGZpZWxkOiBudWxsIGFzIGFueSxcclxuICAgICAgICBsb2dpYzogJ2FuZCcsXHJcbiAgICAgICAgb3BlcmF0b3I6IG51bGwgYXMgYW55LFxyXG4gICAgICAgIGZpbHRlcnM6IFt0aGlzLmlubGluZUZpbHRlcnMsIHRoaXMuYWR2YW5jZUZpbHRlcnNdXHJcbiAgICAgIH0pO1xyXG4gICAgfVxyXG4gICAgLy9cclxuICAgIHRoaXMuZGF0YVNvdXJjZS5yZWZyZXNoKCk7XHJcbiAgfVxyXG59Il19

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget-view.component.mjs

@@ -0,0 +1,19 @@
+import { AXPWidgetBase } from '@acorex/platform/layout/builder';
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXPLookupWidgetViewComponent extends AXPWidgetBase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPLookupWidgetViewComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLookupWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLXdpZGdldC12aWV3LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcGxhdGZvcm0vbGF5b3V0L2VudGl0eS9zcmMvbGliL3dpZGdldHMvbG9va3VwLXdpZGdldC9sb29rdXAtd2lkZ2V0LXZpZXcuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNoRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQzs7QUFTM0UsTUFBTSxPQUFPLDRCQUE2QixTQUFRLGFBQWtCOzhHQUF2RCw0QkFBNEI7a0dBQTVCLDRCQUE0QiwrRkFON0IsRUFBRSwyREFHRixZQUFZOzsyRkFHWCw0QkFBNEI7a0JBUHhDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLEVBQUU7b0JBQ1osVUFBVSxFQUFFLElBQUk7b0JBQ2hCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO29CQUMvQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLE1BQU0sRUFBRSxFQUFFO2lCQUNWIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQVhQV2lkZ2V0QmFzZSB9IGZyb20gJ0BhY29yZXgvcGxhdGZvcm0vbGF5b3V0L2J1aWxkZXInO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBgLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGlucHV0czogW11cbiB9KVxuZXhwb3J0IGNsYXNzIEFYUExvb2t1cFdpZGdldFZpZXdDb21wb25lbnQgZXh0ZW5kcyBBWFBXaWRnZXRCYXNlPGFueT4ge30iXX0=

package/esm2022/layout/entity/lib/widgets/lookup-widget/lookup-widget.config.mjs

@@ -0,0 +1,24 @@
+export const AXPLookupWidget = {
+    name: "lookup",
+    components: {
+        view: {
+            component: () => import('./lookup-widget-view.component').then((c) => c.AXPLookupWidgetViewComponent),
+        },
+        edit: {
+            component: () => import('./lookup-widget-edit.component').then((c) => c.AXPLookupWidgetEditComponent),
+        },
+        filter: {
+            component: () => import('./lookup-widget-filter.component').then((c) => c.AXPLookupWidgetFilterComponent),
+        },
+        column: {
+            component: () => import('./lookup-widget-column.component').then((c) => c.AXPLookupWidgetColumnComponent),
+        },
+        print: {
+            component: () => import('./lookup-widget-print.component').then((c) => c.AXPLookupWidgetPrintComponent),
+        },
+        designer: {
+            component: () => import('./lookup-widget-designer.component').then((c) => c.AXPLookupWidgetDesignerComponent),
+        },
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/entity/lib/workflows/create-entity.workflow.mjs

@@ -0,0 +1,93 @@
+import { AXPopupService } from '@acorex/components/popup';
+import { AXPlatform } from '@acorex/core/platform';
+import { AXPWorkflowAction, createWorkFlowEvent } from '@acorex/platform/workflow';
+import { Injectable, inject } from '@angular/core';
+import { AXPEntityCreateViewModelFactory } from '../entity-master-create.viewmodel';
+import { AXPEntityDefinitionRegistryService } from '../entity-registery.service';
+import { AXP_ENTITY_CONFIG_TOKEN } from '../entity.config';
+import * as i0 from "@angular/core";
+export const AXPEntityCreateEvent = createWorkFlowEvent('[Entity] Created!');
+export class AXPEntityCreatePopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.popupService = inject(AXPopupService);
+        this.platform = inject(AXPlatform);
+        this.factory = inject(AXPEntityCreateViewModelFactory);
+        this.config = inject(AXP_ENTITY_CONFIG_TOKEN);
+    }
+    async execute(context) {
+        const { module, entity: entity } = context.getVariable('payload');
+        const entityRef = await this.entityRegistery.resolve(module, entity);
+        const com = await this.config.viewers.master.create();
+        const result = await this.popupService.open(com, {
+            title: `Create New ${entityRef.formats.individual}`,
+            size: this.platform.is('Mobile') || this.platform.is('SM') ? 'full' : 'md',
+            data: {
+                vm: await this.factory.create(module, entity),
+                entity,
+            },
+        });
+        if (result.data?.save) {
+            context.setOutput('popupResult', true);
+            context.setVariable('redirect', result.data.redirect);
+            context.setVariable('id', result.data.recordId);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityCreatePopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityCreatePopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityCreatePopupAction, decorators: [{
+            type: Injectable
+        }] });
+export class AXPEntityCreateSubmittedAction extends AXPWorkflowAction {
+    async execute(context) {
+        const { module, entity: entity } = context.getVariable('payload');
+        this.dispatch(AXPEntityCreateEvent({ entity, module }));
+    }
+}
+export const AXPCreateEntityWorkflow = {
+    startStepId: 'createPopup',
+    steps: {
+        createPopup: {
+            id: 'createPopup',
+            action: 'AXPEntityCreatePopupAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("popupResult") == true' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'Entity Created',
+                content: 'New Record has been successfully created.',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'createSubmitted',
+                },
+            ],
+        },
+        createSubmitted: {
+            id: 'createSubmitted',
+            action: 'AXPEntityCreateSubmittedAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getVariable("redirect") == true' }],
+                    nextStepId: 'showDetailView',
+                },
+            ],
+        },
+        showDetailView: {
+            id: 'showDetailView',
+            action: 'AXPShowDetailViewAction',
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-entity.workflow.js","sourceRoot":"","sources":["../../../../../../../../libs/platform/layout/entity/src/lib/workflows/create-entity.workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXPopupService } from '@acorex/components/popup';\r\nimport { AXPlatform } from '@acorex/core/platform';\r\nimport { AXPWorkflow, AXPWorkflowAction, AXPWorkflowContext, createWorkFlowEvent } from '@acorex/platform/workflow';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { AXPEntityCreateViewModelFactory } from '../entity-master-create.viewmodel';\r\nimport { AXPEntityDefinitionRegistryService } from '../entity-registery.service';\r\nimport { AXP_ENTITY_CONFIG_TOKEN } from '../entity.config';\r\n\r\nexport const AXPEntityCreateEvent = createWorkFlowEvent<{ module: string; entity: string }>('[Entity] Created!');\r\n\r\n@Injectable()\r\nexport class AXPEntityCreatePopupAction extends AXPWorkflowAction {\r\n  private entityRegistery = inject(AXPEntityDefinitionRegistryService);\r\n  private popupService = inject(AXPopupService);\r\n  private platform = inject(AXPlatform);\r\n  private factory = inject(AXPEntityCreateViewModelFactory);\r\n  private config = inject(AXP_ENTITY_CONFIG_TOKEN)\r\n\r\n  async execute(context: AXPWorkflowContext): Promise<void> {\r\n    const { module, entity: entity } = context.getVariable('payload');\r\n    const entityRef = await this.entityRegistery.resolve(module, entity);\r\n\r\n    const com = await this.config.viewers.master.create();\r\n    const result = await this.popupService.open(com, {\r\n      title: `Create New ${entityRef.formats.individual}`,\r\n      size: this.platform.is('Mobile') || this.platform.is('SM') ? 'full' : 'md',\r\n      data: {\r\n        vm: await this.factory.create(module, entity),\r\n        entity,\r\n      },\r\n    });\r\n    if (result.data?.save) {\r\n      context.setOutput('popupResult', true);\r\n      context.setVariable('redirect', result.data.redirect);\r\n      context.setVariable('id', result.data.recordId);\r\n    }\r\n  }\r\n}\r\n\r\nexport class AXPEntityCreateSubmittedAction extends AXPWorkflowAction {\r\n  async execute(context: AXPWorkflowContext): Promise<void> {\r\n    const { module, entity: entity } = context.getVariable('payload');\r\n    this.dispatch(AXPEntityCreateEvent({ entity, module }));\r\n  }\r\n}\r\n\r\nexport const AXPCreateEntityWorkflow: AXPWorkflow = {\r\n  startStepId: 'createPopup',\r\n  steps: {\r\n    createPopup: {\r\n      id: 'createPopup',\r\n      action: 'AXPEntityCreatePopupAction',\r\n      nextSteps: [\r\n        {\r\n          conditions: [{ type: 'SINGLE', expression: 'context.getOutput(\"popupResult\") == true' }],\r\n          nextStepId: 'successToast',\r\n        },\r\n      ],\r\n    },\r\n    successToast: {\r\n      id: 'successToast',\r\n      action: 'AXPToastAction',\r\n      input: {\r\n        color: 'success',\r\n        title: 'Entity Created',\r\n        content: 'New Record has been successfully created.',\r\n      },\r\n      nextSteps: [\r\n        {\r\n          conditions: [],\r\n          nextStepId: 'createSubmitted',\r\n        },\r\n      ],\r\n    },\r\n    createSubmitted: {\r\n      id: 'createSubmitted',\r\n      action: 'AXPEntityCreateSubmittedAction',\r\n      nextSteps: [\r\n        {\r\n          conditions: [{ type: 'SINGLE', expression: 'context.getVariable(\"redirect\") == true' }],\r\n          nextStepId: 'showDetailView',\r\n        },\r\n      ],\r\n    },\r\n    showDetailView: {\r\n      id: 'showDetailView',\r\n      action: 'AXPShowDetailViewAction',\r\n    },\r\n  },\r\n};\r\n"]}

package/esm2022/layout/entity/lib/workflows/delete-entity.workflow.mjs

@@ -0,0 +1,123 @@
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXLoadingDialogService } from '@acorex/components/loading-dialog';
+import { AXPWorkflowAction, createWorkFlowEvent, } from '@acorex/platform/workflow';
+import { Injectable, inject } from '@angular/core';
+import { AXPEntityDefinitionRegistryService } from '../entity-registery.service';
+import * as i0 from "@angular/core";
+export const AXPEntityDeletedEvent = createWorkFlowEvent('[Entity] Deleted');
+export class AXPEntityPerformDeleteAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+    }
+    async execute(context) {
+        const moduleName = context.getVariable('module');
+        const entityName = context.getVariable('entity');
+        const ids = context.getVariable('ids');
+        const entity = await this.entityRegistery.resolve(moduleName, entityName);
+        let deletedCount = 0;
+        context.setVariable('deleteSuccessful', false);
+        const dialog = this.loadingDialog.show({
+            title: 'Deleting Record...',
+            mode: 'determinate',
+            status: 'Deleting...',
+            progressValue: 0,
+            text: `0/${ids.length}`,
+            buttons: [
+                {
+                    text: 'Cancel',
+                    color: 'danger',
+                    onClick: () => {
+                        dialog.close();
+                    },
+                },
+            ],
+        });
+        if (entity.commands?.delete != null) {
+            const deleteExec = entity.commands?.delete?.execute;
+            const wrappedPromises = ids
+                .map((id, i) => {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(deleteExec(id));
+                    }, i * 200);
+                });
+            })
+                .map((p) => p?.then((value) => {
+                deletedCount++;
+                dialog.setProgressText(`${deletedCount}/${ids.length}`);
+                dialog.setProgressValue((deletedCount / ids.length) * 100);
+                return { status: 'fulfilled', value };
+            }, (reason) => ({ status: 'rejected', reason })));
+            const results = await Promise.all(wrappedPromises);
+            const successfulPromises = results.filter((result) => result?.status === 'fulfilled').length;
+            const failedPromises = results.filter((result) => result?.status === 'rejected').length;
+            setTimeout(() => {
+                dialog.close();
+            }, 300);
+            // Handle different scenarios for alerts
+            if (successfulPromises > 0 && failedPromises === 0) {
+                // All items deleted successfully
+                await this.dialogService.alert('Deletion Successful', `${successfulPromises} item(s) has been deleted.`, 'success');
+                // Dispatch actions
+                this.dispatch(AXPEntityDeletedEvent({ module: moduleName, entity: entityName, id: ids }));
+            }
+            else if (successfulPromises > 0 && failedPromises > 0) {
+                // Some items deleted successfully, some failed
+                await this.dialogService.alert('Partial Deletion Completed', `${successfulPromises} item(s) deleted successfully. However, ${failedPromises} item(s) could not be deleted.`, 'warning');
+                // Dispatch actions
+                this.dispatch(AXPEntityDeletedEvent({ module: moduleName, entity: entityName, id: ids }));
+            }
+            else if (successfulPromises === 0 && failedPromises > 0) {
+                // No items deleted, all failed
+                await this.dialogService.alert('Deletion Failed', `No items were deleted. ${failedPromises} item(s) failed to delete.`, 'danger');
+            }
+            else {
+                // No items to delete (no successful or failed promises)
+                await this.dialogService.alert('No Deletion Needed', 'No items were available to delete.', 'info');
+            }
+        }
+        else {
+            throw new Error(`The delete operation cannot be performed on ${entity.title}. This action might be restricted or not applicable for the selected item.`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityPerformDeleteAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityPerformDeleteAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityPerformDeleteAction, decorators: [{
+            type: Injectable
+        }] });
+export const AXPDeleteEntityWorkflow = {
+    startStepId: 'confirmDelete',
+    steps: {
+        confirmDelete: {
+            id: 'confirmDelete',
+            action: 'AXPDialogConfirmAction',
+            input: {
+                title: 'Warning',
+                message: `Are you sure want to delete selected item(s)?`,
+                type: 'danger',
+            },
+            nextSteps: [
+                {
+                    conditions: [
+                        {
+                            type: 'AND',
+                            conditions: [
+                                { type: 'SINGLE', expression: 'context.getOutput("deleteConfirmed") == true' },
+                            ],
+                        },
+                    ],
+                    nextStepId: 'performDelete',
+                },
+            ],
+        },
+        performDelete: {
+            id: 'performDelete',
+            action: 'AXPEntityPerformDeleteAction',
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delete-entity.workflow.js","sourceRoot":"","sources":["../../../../../../../../libs/platform/layout/entity/src/lib/workflows/delete-entity.workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXDialogService } from '@acorex/components/dialog';\r\nimport { AXLoadingDialogService } from '@acorex/components/loading-dialog';\r\nimport {\r\n  AXPWorkflow,\r\n  AXPWorkflowAction,\r\n  AXPWorkflowContext,\r\n  AXPWorkflowFunction,\r\n  createWorkFlowEvent,\r\n} from '@acorex/platform/workflow';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { AXPEntityDefinitionRegistryService } from '../entity-registery.service';\r\n\r\nexport const AXPEntityDeletedEvent = createWorkFlowEvent<{ module: string; entity: string; id: string }>(\r\n  '[Entity] Deleted'\r\n);\r\n\r\n@Injectable()\r\nexport class AXPEntityPerformDeleteAction extends AXPWorkflowAction {\r\n  private entityRegistery = inject(AXPEntityDefinitionRegistryService);\r\n  private dialogService = inject(AXDialogService);\r\n  private loadingDialog = inject(AXLoadingDialogService);\r\n\r\n  async execute(context: AXPWorkflowContext): Promise<void> {\r\n    const moduleName = context.getVariable('module');\r\n    const entityName = context.getVariable('entity');\r\n    const ids = context.getVariable('ids');\r\n    const entity = await this.entityRegistery.resolve(moduleName, entityName);\r\n    let deletedCount = 0;\r\n    context.setVariable('deleteSuccessful', false);\r\n    const dialog = this.loadingDialog.show({\r\n      title: 'Deleting Record...',\r\n      mode: 'determinate',\r\n      status: 'Deleting...',\r\n      progressValue: 0,\r\n      text: `0/${ids.length}`,\r\n      buttons: [\r\n        {\r\n          text: 'Cancel',\r\n          color: 'danger',\r\n          onClick: () => {\r\n            dialog.close();\r\n          },\r\n        },\r\n      ],\r\n    });\r\n\r\n    if (entity.commands?.delete != null) {\r\n      const deleteExec = entity.commands?.delete?.execute as Function\r\n      const wrappedPromises = (ids as any[])\r\n        .map((id, i) => {\r\n          return new Promise((resolve) => {\r\n            setTimeout(() => {\r\n              resolve(deleteExec(id));\r\n            }, i * 200);\r\n          });\r\n        })\r\n        .map((p) =>\r\n          p?.then(\r\n            (value) => {\r\n              deletedCount++;\r\n              dialog.setProgressText(`${deletedCount}/${ids.length}`);\r\n              dialog.setProgressValue((deletedCount / ids.length) * 100);\r\n              return { status: 'fulfilled', value };\r\n            },\r\n            (reason) => ({ status: 'rejected', reason })\r\n          )\r\n        );\r\n\r\n      const results = await Promise.all(wrappedPromises);\r\n      const successfulPromises = results.filter((result) => result?.status === 'fulfilled').length;\r\n      const failedPromises = results.filter((result) => result?.status === 'rejected').length;\r\n      setTimeout(() => {\r\n        dialog.close();\r\n      }, 300);\r\n\r\n      // Handle different scenarios for alerts\r\n      if (successfulPromises > 0 && failedPromises === 0) {\r\n        // All items deleted successfully\r\n        await this.dialogService.alert(\r\n          'Deletion Successful',\r\n          `${successfulPromises} item(s) has been deleted.`,\r\n          'success'\r\n        );\r\n        // Dispatch actions\r\n        this.dispatch(AXPEntityDeletedEvent({ module: moduleName, entity: entityName, id: ids }));\r\n      } else if (successfulPromises > 0 && failedPromises > 0) {\r\n        // Some items deleted successfully, some failed\r\n        await this.dialogService.alert(\r\n          'Partial Deletion Completed',\r\n          `${successfulPromises} item(s) deleted successfully. However, ${failedPromises} item(s) could not be deleted.`,\r\n          'warning'\r\n        );\r\n        // Dispatch actions\r\n        this.dispatch(AXPEntityDeletedEvent({ module: moduleName, entity: entityName, id: ids }));\r\n      } else if (successfulPromises === 0 && failedPromises > 0) {\r\n        // No items deleted, all failed\r\n        await this.dialogService.alert(\r\n          'Deletion Failed',\r\n          `No items were deleted. ${failedPromises} item(s) failed to delete.`,\r\n          'danger'\r\n        );\r\n      } else {\r\n        // No items to delete (no successful or failed promises)\r\n        await this.dialogService.alert('No Deletion Needed', 'No items were available to delete.', 'info');\r\n      }\r\n    } else {\r\n      throw new Error(\r\n        `The delete operation cannot be performed on ${entity.title}. This action might be restricted or not applicable for the selected item.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n\r\nexport const AXPDeleteEntityWorkflow: AXPWorkflow = {\r\n  startStepId: 'confirmDelete',\r\n  steps: {\r\n    confirmDelete: {\r\n      id: 'confirmDelete',\r\n      action: 'AXPDialogConfirmAction',\r\n      input: {\r\n        title: 'Warning',\r\n        message: `Are you sure want to delete selected item(s)?`,\r\n        type: 'danger',\r\n      },\r\n      nextSteps: [\r\n        {\r\n          conditions: [\r\n            {\r\n              type: 'AND',\r\n              conditions: [\r\n                { type: 'SINGLE', expression: 'context.getOutput(\"deleteConfirmed\") == true' },\r\n              ],\r\n            },\r\n          ],\r\n          nextStepId: 'performDelete',\r\n        },\r\n      ],\r\n    },\r\n    performDelete: {\r\n      id: 'performDelete',\r\n      action: 'AXPEntityPerformDeleteAction',\r\n    },\r\n  },\r\n};\r\n"]}