@acorex/modules 19.3.0-next.1 → 19.3.0-next.3

package/fesm2022/acorex-modules-security-management.mjs

@@ -1,10 +1,15 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, Injector, NgModule } from '@angular/core';
-import { AXMEntityCrudServiceImpl, AXPEntityService, AXPEntityResolver, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { AXPEntityCommandScope, AXPEntityQueryType, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { Injectable, NgModule, inject, Injector } from '@angular/core';
+import { AXMEntityCrudServiceImpl, AXPEntityService, AXPEntityResolver, AXPEntityDefinitionRegistryService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { createAllQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXPSearchCommandProvider, AXPRefreshEvent, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import * as i1 from '@acorex/platform/workflow';
+import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
 import { AXDataSource } from '@acorex/components/common';
 import { AXPPermissionProviderService } from '@acorex/platform/auth';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXLoadingDialogService } from '@acorex/components/loading-dialog';
+import { AXTranslationService } from '@acorex/core/translation';
 
 const config = {
     i18n: 'security-management',
@@ -19,6 +24,12 @@ const RootConfig = {
         icon: 'fa-light fa-file-invoice',
     },
     entities: {
+        deviceSessions: {
+            name: 'DeviceSessions',
+            title: `t("session", { scope: "${config.i18n}" })`,
+            titlePlural: `t("sessions", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-default',
+        },
         users: {
             name: 'users',
             title: `t("users", { scope: "${config.i18n}" })`,
@@ -90,124 +101,675 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }], ctorParameters: () => [] });
 
-const key = 'security-management';
-var AXPSecurityManagementMenuKeys;
-(function (AXPSecurityManagementMenuKeys) {
-    AXPSecurityManagementMenuKeys["Root"] = "security-management";
-    AXPSecurityManagementMenuKeys["Users"] = "security-management:users";
-    AXPSecurityManagementMenuKeys["Roles"] = "security-management:roles";
-})(AXPSecurityManagementMenuKeys || (AXPSecurityManagementMenuKeys = {}));
-
-class AXMMenuProvider {
-    constructor() {
-        this.entityService = inject(AXPEntityService);
-    }
-    async provide(context) {
-        const scope = RootConfig.config.i18n;
-        const moduleName = RootConfig.module.name;
-        context.addItems([
-            {
-                priority: 9001,
-                text: `t('root-menu', {scope: "${scope}"})`,
-                icon: 'fa-light fa-lock',
-                name: AXPSecurityManagementMenuKeys.Root,
-                data: {
-                // requiredPermission: 'demo.admin.settings',
-                },
-                children: [
-                    {
-                        priority: 9003,
-                        text: `t('users', { scope: "${scope}" })`,
-                        icon: 'fa-light fa-users',
-                        name: AXPSecurityManagementMenuKeys.Users,
-                        path: this.entityService.createPath(moduleName, RootConfig.entities.users.name),
-                        data: {
-                        // requiredPermission: 'demo.admin.settings',
-                        },
-                    },
-                    {
-                        priority: 9004,
-                        text: `t('roles', { scope: "${scope}" })`,
-                        path: this.entityService.createPath(moduleName, RootConfig.entities.roles.name),
-                        icon: 'fa-light fa-key',
-                        name: AXPSecurityManagementMenuKeys.Roles,
-                        data: {
-                        // requiredPermission: 'demo.admin.settings',
-                        },
-                    },
-                ],
-            },
-        ]);
-    }
+class AXMDeviceSessionsService extends AXMEntityCrudServiceImpl {
 }
-
-class AXMEntityProvider {
+class AXMDeviceSessionsServiceImpl extends AXMDeviceSessionsService {
     constructor() {
-        this.injector = inject(Injector);
-    }
-    preload() {
-        const { entities, module } = RootConfig;
-        return [entities.users.name, entities.roles.name].map((entity) => ({ module: module.name, entity }));
+        super(`${RootConfig.module.name}.${RootConfig.entities.deviceSessions.name}`);
     }
-    async get(moduleName, entityName) {
-        const { entities, module } = RootConfig;
-        if (moduleName == module.name) {
-            switch (entityName) {
-                case RootConfig.entities.users.name:
-                    return (await Promise.resolve().then(function () { return users_entity; })).factory(this.injector);
-                case RootConfig.entities.roles.name:
-                    return (await Promise.resolve().then(function () { return roles_entity; })).factory(this.injector);
-                case RootConfig.entities.profile.name:
-                    return (await Promise.resolve().then(function () { return profile_entity; })).factory(this.injector);
-            }
-        }
-        return null;
+    terminate(id) {
+        throw new Error('Method not implemented.');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDeviceSessionsServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDeviceSessionsServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDeviceSessionsServiceImpl, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
-async function factory$2(injector) {
-    const dataService = injector.get(AXMtUsersEntityService);
-    const entityResolver = injector.get(AXPEntityResolver);
-    const i18n = RootConfig.config.i18n;
+async function factory$3(injector) {
+    const dataService = injector.get(AXMDeviceSessionsService);
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.users.name,
+        name: RootConfig.entities.deviceSessions.name,
         source: '',
-        title: RootConfig.entities.users.title,
+        title: RootConfig.entities.deviceSessions.title,
         formats: {
-            individual: `t("user", { scope: "${i18n}" })`,
-            plural: `t("users", { scope: "${i18n}" })`,
+            individual: RootConfig.entities.deviceSessions.title,
+            plural: RootConfig.entities.deviceSessions.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
         },
         relatedEntities: [],
         groups: [
             {
-                id: 'info',
-                title: `t("information", { scope: "${i18n}" })`,
+                id: 'section',
+                title: RootConfig.entities.deviceSessions.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'tenant.name',
+                title: 't("tenant", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'user.name',
+                title: 't("user", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'application.name',
+                title: 't("application", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'clientName',
+                title: 't("clientName", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'location',
+                title: 't("location", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'ipAddress',
+                title: 't("ipAddress", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'lastLoginDate',
+                title: 't("lastLoginDate", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'dateTime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            format: 'MM/dd/yyyy hh:mm a',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'operatingSystem',
+                title: 't("operatingSystem", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'deviceName',
+                title: 't("deviceName", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'tenant.name' },
+            { name: 'user.name' },
+            { name: 'application.name' },
+            { name: 'clientName' },
+            { name: 'location' },
+            { name: 'deviceName' },
+            { name: 'lastLoginDate' },
+            { name: 'operatingSystem' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+            terminate: {
+                execute: async (id) => {
+                    const x = await dataService.terminate(id);
+                    return x;
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const res = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    console.log('res', res);
+                    return res;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'clientName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'ClientName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{user.name}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'location',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'user.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'tenant.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'application.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'clientName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'ipAddress',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'lastLoginDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'operatingSystem',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'deviceName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'deviceName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        // {
+                        //   title: `t("create", { scope: "common" })`,
+                        //   command: 'create-entity',
+                        //   priority: 'primary',
+                        //   type: 'create',
+                        //   scope: AXPEntityCommandScope.TypeLevel,
+                        // },
+                        // {
+                        //   title: 't("deleteItems", { scope: "common" })',
+                        //   command: 'delete-entity',
+                        //   priority: 'primary',
+                        //   type: 'delete',
+                        //   scope: AXPEntityCommandScope.Selected,
+                        // },
+                        {
+                            title: 't("terminate.Selected", { scope: "common" })',
+                            command: 'terminate-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("terminate", { scope: "common" })',
+                            command: 'terminate-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var deviceSessions_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factory: factory$3
+});
+
+class AXMSecurityManagementDeviceSessionsEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementDeviceSessionsEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementDeviceSessionsEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementDeviceSessionsEntityModule, providers: [
+            {
+                provide: AXMDeviceSessionsService,
+                useClass: AXMDeviceSessionsServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementDeviceSessionsEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDeviceSessionsService,
+                            useClass: AXMDeviceSessionsServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+var AXMSessionStatusTypes;
+(function (AXMSessionStatusTypes) {
+    AXMSessionStatusTypes["revoked"] = "revoked";
+    AXMSessionStatusTypes["expired"] = "expired";
+    AXMSessionStatusTypes["active"] = "active";
+})(AXMSessionStatusTypes || (AXMSessionStatusTypes = {}));
+
+const key = 'security-management';
+var AXPSecurityManagementMenuKeys;
+(function (AXPSecurityManagementMenuKeys) {
+    AXPSecurityManagementMenuKeys["Root"] = "security-management";
+    AXPSecurityManagementMenuKeys["Users"] = "security-management:users";
+    AXPSecurityManagementMenuKeys["Roles"] = "security-management:roles";
+    AXPSecurityManagementMenuKeys["DeviceSessions"] = "security-management:deviceSessions";
+})(AXPSecurityManagementMenuKeys || (AXPSecurityManagementMenuKeys = {}));
+
+class AXMEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const { entities, module } = RootConfig;
+        return [entities.users.name, entities.roles.name].map((entity) => ({ module: module.name, entity }));
+    }
+    async get(moduleName, entityName) {
+        const { entities, module } = RootConfig;
+        if (moduleName == module.name) {
+            switch (entityName) {
+                case RootConfig.entities.users.name:
+                    return (await Promise.resolve().then(function () { return users_entity; })).factory(this.injector);
+                case RootConfig.entities.roles.name:
+                    return (await Promise.resolve().then(function () { return roles_entity; })).factory(this.injector);
+                case RootConfig.entities.profile.name:
+                    return (await Promise.resolve().then(function () { return profile_entity; })).factory(this.injector);
+                case RootConfig.entities.deviceSessions.name:
+                    return (await Promise.resolve().then(function () { return deviceSessions_entity; })).factory(this.injector);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const moduleName = RootConfig.module.name;
+        context.addItems([
+            {
+                priority: 9001,
+                text: `t('root-menu', {scope: "${scope}"})`,
+                icon: 'fa-light fa-lock',
+                name: AXPSecurityManagementMenuKeys.Root,
+                data: {
+                // requiredPermission: 'demo.admin.settings',
+                },
+                children: [
+                    {
+                        priority: 9003,
+                        text: `t('users', { scope: "${scope}" })`,
+                        icon: 'fa-light fa-users',
+                        name: AXPSecurityManagementMenuKeys.Users,
+                        path: this.entityService.createPath(moduleName, RootConfig.entities.users.name),
+                        data: {
+                        // requiredPermission: 'demo.admin.settings',
+                        },
+                    },
+                    {
+                        priority: 9004,
+                        text: `t('roles', { scope: "${scope}" })`,
+                        path: this.entityService.createPath(moduleName, RootConfig.entities.roles.name),
+                        icon: 'fa-light fa-key',
+                        name: AXPSecurityManagementMenuKeys.Roles,
+                        data: {
+                        // requiredPermission: 'demo.admin.settings',
+                        },
+                    },
+                    {
+                        priority: 9005,
+                        text: `t('deviceSessions', { scope: "${scope}" })`,
+                        path: this.entityService.createPath(moduleName, RootConfig.entities.deviceSessions.name),
+                        icon: 'fa-light fa-key',
+                        name: AXPSecurityManagementMenuKeys.DeviceSessions,
+                        data: {
+                        // requiredPermission: 'demo.admin.settings',
+                        },
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+async function factory$2(injector) {
+    const dataService = injector.get(AXMSecurityManagementProfileEntityService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.profile.name,
+        source: '',
+        title: RootConfig.entities.profile.title,
+        formats: {
+            individual: `t("profile", { scope: "${i18n}" })`,
+            plural: RootConfig.entities.profile.title,
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'info',
+                title: `t("profile", { scope: "${i18n}" })`,
+            },
+            {
+                id: 'contact',
+                title: `t("contactInformation", { scope: "${i18n}" })`,
             },
             {
-                id: 'authorizations',
-                title: `t("authorizations", { scope: "${i18n}" })`,
+                id: 'address',
+                title: `t("addressInformation", { scope: "${i18n}" })`,
             },
         ],
         properties: [
             {
-                name: 'username',
-                title: `t("username", { scope: "${i18n}" })`,
+                name: 'firstName',
+                title: `t("firstName", { scope: "${i18n}" })`,
                 groupId: 'info',
                 options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: true,
-                        },
-                    },
                     sort: {
                         enabled: true,
                     },
@@ -225,18 +787,13 @@ async function factory$2(injector) {
                 ],
             },
             {
-                name: 'firstname',
-                title: `t("firstname", { scope: "${i18n}" })`,
+                name: 'lastName',
+                title: `t("lastName", { scope: "${i18n}" })`,
                 groupId: 'info',
                 options: {
                     sort: {
                         enabled: true,
                     },
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                    },
                 },
                 schema: {
                     dataType: 'string',
@@ -251,50 +808,51 @@ async function factory$2(injector) {
                 ],
             },
             {
-                name: 'lastname',
-                title: `t("lastname", { scope: "${i18n}" })`,
-                groupId: 'info',
+                name: 'email',
+                title: `t("email", { scope: "${i18n}" })`,
+                groupId: 'contact',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
+                        type: AXPWidgetsCatalog.contact,
+                        options: {
+                            type: 'email',
+                            hasLabel: false,
                         },
                     },
-                    sort: {
-                        enabled: true,
-                    },
                 },
                 validations: [
                     {
                         rule: 'required',
                     },
+                    {
+                        rule: 'email',
+                    },
                 ],
             },
             {
-                name: 'nationalCode',
-                title: `t("nationalCode", { scope: "${i18n}" })`,
-                groupId: 'info',
+                name: 'phone',
+                title: `t("phone", { scope: "${i18n}" })`,
+                groupId: 'contact',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
+                        type: AXPWidgetsCatalog.contact,
+                        options: {
+                            type: 'phone',
+                            hasLabel: false,
                         },
                     },
-                    sort: {
-                        enabled: true,
-                    },
                 },
                 validations: [
                     {
@@ -303,126 +861,77 @@ async function factory$2(injector) {
                 ],
             },
             {
-                name: 'mobile',
-                title: `t("mobile", { scope: "${i18n}" })`,
-                groupId: 'info',
+                name: 'address',
+                title: `t("address", { scope: "${i18n}" })`,
+                groupId: 'address',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
-                        options: {
-                            hasLabel: false,
-                            placeholder: ``,
-                        },
+                        type: AXPWidgetsCatalog.largeText,
                     },
                 },
+            },
+            {
+                name: 'city',
+                title: `t("city", { scope: "${i18n}" })`,
+                groupId: 'address',
                 options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                    },
                     sort: {
                         enabled: true,
                     },
                 },
-                validations: [],
-            },
-            {
-                name: 'password',
-                title: `t("password", { scope: "${i18n}" })`,
-                groupId: 'authorizations',
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+            },
+            {
+                name: 'suburb',
+                title: `t("suburb", { scope: "${i18n}" })`,
+                groupId: 'address',
                 options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                    },
                     sort: {
                         enabled: true,
                     },
                 },
-            },
-            {
-                name: 'roles',
-                title: `t("roles", { scope: "${i18n}" })`,
-                groupId: 'authorizations',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            triggers: [
-                                {
-                                    event: "{{ events.context('lastname') }}",
-                                    action: `{{console.log(context.eval('lastname'))}}`,
-                                },
-                            ],
-                            dataSource: new AXDataSource({
-                                load: async () => {
-                                    const rolesEntity = await entityResolver.get(RootConfig.module.name, 'roles');
-                                    const roles = await (rolesEntity?.queries.list?.execute)({ skip: 0, take: 100 });
-                                    return roles;
-                                },
-                                pageSize: 100,
-                                key: 'id',
-                            }),
-                            valueField: 'id',
-                            textField: 'title',
-                            multiple: true,
-                        },
+                        type: AXPWidgetsCatalog.text,
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
         ],
-        columns: [
-            { name: 'username' },
-            { name: 'firstname' },
-            { name: 'lastname' },
-            { name: 'nationalCode' },
-            { name: 'mobile' },
-        ],
+        columns: [{ name: 'firstName' }, { name: 'lastName' }, { name: 'email' }, { name: 'phone' }],
         commands: {
             create: {
-                execute: async (data) => {
-                    console.log({ data });
-                    const res = await dataService.insertOne(data);
-                    return { id: res };
-                },
+                execute: async (data) => { },
             },
             delete: {
-                execute: async (id) => {
-                    return await dataService.deleteOne(id);
-                },
+                execute: async (id) => { },
             },
             update: {
                 execute: async (data) => {
-                    return await dataService.updateOne(data.id, data);
+                    return await dataService.update(data.id, data);
                 },
             },
         },
         queries: {
             byKey: {
                 execute: async (id) => {
-                    return await dataService.getOne(id);
+                    return await dataService.get();
                 },
                 type: AXPEntityQueryType.Single,
             },
             list: {
-                execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
-                },
+                execute: async (e) => { },
                 type: AXPEntityQueryType.List,
             },
         },
@@ -434,12 +943,15 @@ async function factory$2(injector) {
                             id: 'info',
                         },
                         {
-                            id: 'authorizations',
+                            id: 'contact',
+                        },
+                        {
+                            id: 'address',
                         },
                     ],
                     properties: [
                         {
-                            name: 'username',
+                            name: 'firstName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -449,7 +961,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'firstname',
+                            name: 'lastName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -459,7 +971,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'lastname',
+                            name: 'email',
                             layout: {
                                 positions: {
                                     lg: {
@@ -469,7 +981,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'nationalCode',
+                            name: 'phone',
                             layout: {
                                 positions: {
                                     lg: {
@@ -479,31 +991,31 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'mobile',
+                            name: 'address',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'roles',
+                            name: 'city',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'password',
+                            name: 'suburb',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
@@ -516,12 +1028,15 @@ async function factory$2(injector) {
                             id: 'info',
                         },
                         {
-                            id: 'authorizations',
+                            id: 'contact',
+                        },
+                        {
+                            id: 'address',
                         },
                     ],
                     properties: [
                         {
-                            name: 'username',
+                            name: 'firstName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -531,7 +1046,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'firstname',
+                            name: 'lastName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -541,7 +1056,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'lastname',
+                            name: 'email',
                             layout: {
                                 positions: {
                                     lg: {
@@ -551,7 +1066,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'nationalCode',
+                            name: 'phone',
                             layout: {
                                 positions: {
                                     lg: {
@@ -561,31 +1076,31 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'mobile',
+                            name: 'address',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'roles',
+                            name: 'city',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'password',
+                            name: 'suburb',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
@@ -593,7 +1108,7 @@ async function factory$2(injector) {
                     ],
                 },
                 single: {
-                    title: '{{firstname}} {{lastname}}',
+                    title: '{{firstName}} {{lastName}}',
                     sections: [
                         {
                             id: 'info',
@@ -606,7 +1121,17 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            id: 'authorizations',
+                            id: 'contact',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            id: 'address',
                             layout: {
                                 positions: {
                                     lg: {
@@ -618,7 +1143,7 @@ async function factory$2(injector) {
                     ],
                     properties: [
                         {
-                            name: 'username',
+                            name: 'firstName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -628,7 +1153,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'firstname',
+                            name: 'lastName',
                             layout: {
                                 positions: {
                                     lg: {
@@ -638,7 +1163,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'lastname',
+                            name: 'email',
                             layout: {
                                 positions: {
                                     lg: {
@@ -648,7 +1173,7 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'nationalCode',
+                            name: 'phone',
                             layout: {
                                 positions: {
                                     lg: {
@@ -658,31 +1183,31 @@ async function factory$2(injector) {
                             },
                         },
                         {
-                            name: 'mobile',
+                            name: 'address',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'password',
+                            name: 'city',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'roles',
+                            name: 'suburb',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
@@ -699,32 +1224,32 @@ async function factory$2(injector) {
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
-                        // {
-                        //   title: `t("deleteItems", {scope: "common"})`,
-                        //   command: 'delete-entity',
-                        //   priority: 'primary',
-                        //   type: 'delete',
-                        //   scope: AXPEntityCommandScope.Selected,
-                        // },
                         {
-                            title: `t("detail", {scope: "common"})`,
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
-                        // {
-                        //   title: `t("delete", {scope: "common"})`,
-                        //   command: 'delete-entity',
-                        //   priority: 'secondary',
-                        //   type: 'delete',
-                        //   scope: AXPEntityCommandScope.Individual,
-                        // },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
                     ],
                     views: [
                         {
                             name: 'all',
-                            title: `t("allItem", {scope: "common"})`,
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -735,26 +1260,25 @@ async function factory$2(injector) {
             },
         },
     };
-    const x = entityDef.properties.find((x) => x.name === 'roles')?.schema.interface?.options;
     return entityDef;
 }
 
-var users_entity = /*#__PURE__*/Object.freeze({
+var profile_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
     factory: factory$2
 });
 
-class AXMSecurityManagementUsersEntityModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, providers: [
+class AXMSecurityManagementProfileEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, providers: [
             {
-                provide: AXMtUsersEntityService,
-                useClass: AXMUsersEntityServiceImpl,
+                provide: AXMSecurityManagementProfileEntityService,
+                useClass: AXMSecurityManagementProfileEntityServiceImpl,
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
@@ -762,8 +1286,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                     declarations: [],
                     providers: [
                         {
-                            provide: AXMtUsersEntityService,
-                            useClass: AXMUsersEntityServiceImpl,
+                            provide: AXMSecurityManagementProfileEntityService,
+                            useClass: AXMSecurityManagementProfileEntityServiceImpl,
                         },
                     ],
                 }]
@@ -1193,79 +1717,44 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
-class AXMSearchCommandProvider extends AXPSearchCommandProvider {
-    constructor() {
-        super(...arguments);
-        this.commands = [
-            {
-                id: 'create-security-user',
-                group: 'command',
-                title: 'New User',
-                icon: RootConfig.entities.users.icon,
-                description: 'Create a new user entity in the system.', // Added meaningful description
-                command: {
-                    // 'create-entity': {
-                    //   entity: `${RootConfig.module.name}.${RootConfig.entities.users.name}`,
-                    // },
-                    name: 'create-entity',
-                    options: {
-                        entity: `${RootConfig.module.name}.${RootConfig.entities.users.name}`
-                    }
-                },
-            },
-            {
-                id: 'create-security-role',
-                group: 'command',
-                title: 'New Security Role',
-                icon: RootConfig.entities.roles.icon,
-                description: 'Define a new security role to manage permissions.', // Added meaningful description
-                command: {
-                    // 'create-entity': {
-                    //   entity: `${RootConfig.module.name}.${RootConfig.entities.roles.name}`,
-                    // },
-                    name: 'create-entity',
-                    options: {
-                        entity: `${RootConfig.module.name}.${RootConfig.entities.roles.name}`,
-                    }
-                },
-            },
-        ];
-    }
-}
-
 async function factory(injector) {
-    const dataService = injector.get(AXMSecurityManagementProfileEntityService);
+    const dataService = injector.get(AXMtUsersEntityService);
+    const entityResolver = injector.get(AXPEntityResolver);
     const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.profile.name,
+        name: RootConfig.entities.users.name,
         source: '',
-        title: RootConfig.entities.profile.title,
+        title: RootConfig.entities.users.title,
         formats: {
-            individual: `t("profile", { scope: "${i18n}" })`,
-            plural: RootConfig.entities.profile.title,
+            individual: `t("user", { scope: "${i18n}" })`,
+            plural: `t("users", { scope: "${i18n}" })`,
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'info',
-                title: `t("profile", { scope: "${i18n}" })`,
-            },
-            {
-                id: 'contact',
-                title: `t("contactInformation", { scope: "${i18n}" })`,
+                title: `t("information", { scope: "${i18n}" })`,
             },
             {
-                id: 'address',
-                title: `t("addressInformation", { scope: "${i18n}" })`,
+                id: 'authorizations',
+                title: `t("authorizations", { scope: "${i18n}" })`,
             },
         ],
         properties: [
             {
-                name: 'firstName',
-                title: `t("firstName", { scope: "${i18n}" })`,
+                name: 'username',
+                title: `t("username", { scope: "${i18n}" })`,
                 groupId: 'info',
                 options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
                     sort: {
                         enabled: true,
                     },
@@ -1283,13 +1772,18 @@ async function factory(injector) {
                 ],
             },
             {
-                name: 'lastName',
-                title: `t("lastName", { scope: "${i18n}" })`,
+                name: 'firstname',
+                title: `t("firstname", { scope: "${i18n}" })`,
                 groupId: 'info',
                 options: {
                     sort: {
                         enabled: true,
                     },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
                 },
                 schema: {
                     dataType: 'string',
@@ -1304,51 +1798,50 @@ async function factory(injector) {
                 ],
             },
             {
-                name: 'email',
-                title: `t("email", { scope: "${i18n}" })`,
-                groupId: 'contact',
-                options: {
-                    sort: {
-                        enabled: true,
-                    },
-                },
+                name: 'lastname',
+                title: `t("lastname", { scope: "${i18n}" })`,
+                groupId: 'info',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.contact,
-                        options: {
-                            type: 'email',
-                            hasLabel: false,
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
                         },
                     },
+                    sort: {
+                        enabled: true,
+                    },
                 },
                 validations: [
                     {
                         rule: 'required',
                     },
-                    {
-                        rule: 'email',
-                    },
                 ],
             },
             {
-                name: 'phone',
-                title: `t("phone", { scope: "${i18n}" })`,
-                groupId: 'contact',
-                options: {
-                    sort: {
-                        enabled: true,
-                    },
-                },
+                name: 'nationalCode',
+                title: `t("nationalCode", { scope: "${i18n}" })`,
+                groupId: 'info',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.contact,
-                        options: {
-                            type: 'phone',
-                            hasLabel: false,
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
                         },
                     },
+                    sort: {
+                        enabled: true,
+                    },
                 },
                 validations: [
                     {
@@ -1357,77 +1850,126 @@ async function factory(injector) {
                 ],
             },
             {
-                name: 'address',
-                title: `t("address", { scope: "${i18n}" })`,
-                groupId: 'address',
-                options: {
-                    sort: {
-                        enabled: true,
-                    },
-                },
+                name: 'mobile',
+                title: `t("mobile", { scope: "${i18n}" })`,
+                groupId: 'info',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            hasLabel: false,
+                            placeholder: ``,
+                        },
                     },
                 },
-            },
-            {
-                name: 'city',
-                title: `t("city", { scope: "${i18n}" })`,
-                groupId: 'address',
                 options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
                     sort: {
                         enabled: true,
                     },
                 },
+                validations: [],
+            },
+            {
+                name: 'password',
+                title: `t("password", { scope: "${i18n}" })`,
+                groupId: 'authorizations',
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
-            },
-            {
-                name: 'suburb',
-                title: `t("suburb", { scope: "${i18n}" })`,
-                groupId: 'address',
                 options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
                     sort: {
                         enabled: true,
                     },
                 },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
+            },
+            {
+                name: 'roles',
+                title: `t("roles", { scope: "${i18n}" })`,
+                groupId: 'authorizations',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            triggers: [
+                                {
+                                    event: "{{ events.context('lastname') }}",
+                                    action: `{{console.log(context.eval('lastname'))}}`,
+                                },
+                            ],
+                            dataSource: new AXDataSource({
+                                load: async () => {
+                                    const rolesEntity = await entityResolver.get(RootConfig.module.name, 'roles');
+                                    const roles = await (rolesEntity?.queries.list?.execute)({ skip: 0, take: 100 });
+                                    return roles;
+                                },
+                                pageSize: 100,
+                                key: 'id',
+                            }),
+                            valueField: 'id',
+                            textField: 'title',
+                            multiple: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
         ],
-        columns: [{ name: 'firstName' }, { name: 'lastName' }, { name: 'email' }, { name: 'phone' }],
+        columns: [
+            { name: 'username' },
+            { name: 'firstname' },
+            { name: 'lastname' },
+            { name: 'nationalCode' },
+            { name: 'mobile' },
+        ],
         commands: {
             create: {
-                execute: async (data) => { },
+                execute: async (data) => {
+                    console.log({ data });
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
             },
             delete: {
-                execute: async (id) => { },
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
             },
             update: {
                 execute: async (data) => {
-                    return await dataService.update(data.id, data);
+                    return await dataService.updateOne(data.id, data);
                 },
             },
         },
         queries: {
             byKey: {
                 execute: async (id) => {
-                    return await dataService.get();
+                    return await dataService.getOne(id);
                 },
                 type: AXPEntityQueryType.Single,
             },
             list: {
-                execute: async (e) => { },
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
                 type: AXPEntityQueryType.List,
             },
         },
@@ -1439,15 +1981,12 @@ async function factory(injector) {
                             id: 'info',
                         },
                         {
-                            id: 'contact',
-                        },
-                        {
-                            id: 'address',
+                            id: 'authorizations',
                         },
                     ],
                     properties: [
                         {
-                            name: 'firstName',
+                            name: 'username',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1457,7 +1996,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'lastName',
+                            name: 'firstname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1467,7 +2006,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'email',
+                            name: 'lastname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1477,7 +2016,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'phone',
+                            name: 'nationalCode',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1487,31 +2026,31 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'address',
+                            name: 'mobile',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'city',
+                            name: 'roles',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'suburb',
+                            name: 'password',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
@@ -1524,15 +2063,12 @@ async function factory(injector) {
                             id: 'info',
                         },
                         {
-                            id: 'contact',
-                        },
-                        {
-                            id: 'address',
+                            id: 'authorizations',
                         },
                     ],
                     properties: [
                         {
-                            name: 'firstName',
+                            name: 'username',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1542,7 +2078,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'lastName',
+                            name: 'firstname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1552,7 +2088,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'email',
+                            name: 'lastname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1562,7 +2098,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'phone',
+                            name: 'nationalCode',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1572,31 +2108,31 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'address',
+                            name: 'mobile',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'city',
+                            name: 'roles',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'suburb',
+                            name: 'password',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
@@ -1604,7 +2140,7 @@ async function factory(injector) {
                     ],
                 },
                 single: {
-                    title: '{{firstName}} {{lastName}}',
+                    title: '{{firstname}} {{lastname}}',
                     sections: [
                         {
                             id: 'info',
@@ -1617,17 +2153,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            id: 'contact',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            id: 'address',
+                            id: 'authorizations',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1639,7 +2165,7 @@ async function factory(injector) {
                     ],
                     properties: [
                         {
-                            name: 'firstName',
+                            name: 'username',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1649,7 +2175,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'lastName',
+                            name: 'firstname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1659,7 +2185,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'email',
+                            name: 'lastname',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1669,7 +2195,7 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'phone',
+                            name: 'nationalCode',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1679,31 +2205,31 @@ async function factory(injector) {
                             },
                         },
                         {
-                            name: 'address',
+                            name: 'mobile',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'city',
+                            name: 'password',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'suburb',
+                            name: 'roles',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
@@ -1720,32 +2246,32 @@ async function factory(injector) {
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
+                        // {
+                        //   title: `t("deleteItems", {scope: "common"})`,
+                        //   command: 'delete-entity',
+                        //   priority: 'primary',
+                        //   type: 'delete',
+                        //   scope: AXPEntityCommandScope.Selected,
+                        // },
                         {
-                            title: 't("deleteItems", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Selected,
-                        },
-                        {
-                            title: 't("detail", { scope: "common" })',
+                            title: `t("detail", {scope: "common"})`,
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
-                        {
-                            title: 't("delete", { scope: "common" })',
-                            command: 'delete-entity',
-                            priority: 'secondary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
+                        // {
+                        //   title: `t("delete", {scope: "common"})`,
+                        //   command: 'delete-entity',
+                        //   priority: 'secondary',
+                        //   type: 'delete',
+                        //   scope: AXPEntityCommandScope.Individual,
+                        // },
                     ],
                     views: [
                         {
                             name: 'all',
-                            title: 't("allItem", { scope: "common" })',
+                            title: `t("allItem", {scope: "common"})`,
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -1756,25 +2282,26 @@ async function factory(injector) {
             },
         },
     };
+    const x = entityDef.properties.find((x) => x.name === 'roles')?.schema.interface?.options;
     return entityDef;
 }
 
-var profile_entity = /*#__PURE__*/Object.freeze({
+var users_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
     factory: factory
 });
 
-class AXMSecurityManagementProfileEntityModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, providers: [
+class AXMSecurityManagementUsersEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, providers: [
             {
-                provide: AXMSecurityManagementProfileEntityService,
-                useClass: AXMSecurityManagementProfileEntityServiceImpl,
+                provide: AXMtUsersEntityService,
+                useClass: AXMUsersEntityServiceImpl,
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementProfileEntityModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementUsersEntityModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
@@ -1782,16 +2309,149 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                     declarations: [],
                     providers: [
                         {
-                            provide: AXMSecurityManagementProfileEntityService,
-                            useClass: AXMSecurityManagementProfileEntityServiceImpl,
+                            provide: AXMtUsersEntityService,
+                            useClass: AXMUsersEntityServiceImpl,
                         },
                     ],
                 }]
         }] });
 
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                id: 'create-security-user',
+                group: 'command',
+                title: 'New User',
+                icon: RootConfig.entities.users.icon,
+                description: 'Create a new user entity in the system.', // Added meaningful description
+                command: {
+                    // 'create-entity': {
+                    //   entity: `${RootConfig.module.name}.${RootConfig.entities.users.name}`,
+                    // },
+                    name: 'create-entity',
+                    options: {
+                        entity: `${RootConfig.module.name}.${RootConfig.entities.users.name}`
+                    }
+                },
+            },
+            {
+                id: 'create-security-role',
+                group: 'command',
+                title: 'New Security Role',
+                icon: RootConfig.entities.roles.icon,
+                description: 'Define a new security role to manage permissions.', // Added meaningful description
+                command: {
+                    // 'create-entity': {
+                    //   entity: `${RootConfig.module.name}.${RootConfig.entities.roles.name}`,
+                    // },
+                    name: 'create-entity',
+                    options: {
+                        entity: `${RootConfig.module.name}.${RootConfig.entities.roles.name}`,
+                    }
+                },
+            },
+        ];
+    }
+}
+
+const AXPSessionTerminateEvent = createWorkFlowEvent('[Entity] Terminated!');
+class AXPSessionTerminatePopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const moduleEntity = context.getVariable('entity');
+        const [moduleName, entityName] = moduleEntity.split('.');
+        const data = context.getVariable('data');
+        const meta = context.getVariable('meta');
+        const ids = Array.isArray(data) ? data.map((c) => c.id) : [data.id];
+        const entity = await this.entityRegistery.resolve(moduleName, entityName);
+        if (entity.parentKey && data[entity.parentKey]) {
+            context.setVariable('meta', { ...meta, refreshTargetId: data[entity.parentKey] });
+        }
+        context.setVariable('terminateSuccessful', false);
+        const dialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('workflow.terminating'),
+            mode: 'determinate',
+            status: 'Terminating...',
+            progressValue: 0,
+            text: `0/${ids.length}`,
+            buttons: [
+                {
+                    text: await this.translationService.translateAsync('cancel'),
+                    color: 'danger',
+                    onClick: () => {
+                        dialog.close();
+                    },
+                },
+            ],
+        });
+        if (entity.commands.terminate != null) {
+            const terminateExec = entity.commands.terminate?.execute;
+            let faildCounter = 0;
+            for (const element of ids) {
+                const res = await terminateExec(element);
+                if (!res) {
+                    faildCounter++;
+                    await this.dialogService.alert(await this.translationService.translateAsync('workflow.fail-delete-title'), await this.translationService.translateAsync('workflow.fail-delete-body', {
+                        params: { item: 1 },
+                    }), 'danger');
+                }
+            }
+            context.setOutput('result', faildCounter == 0 ? true : false);
+            setTimeout(() => {
+                dialog.close();
+                this.dispatch(AXPRefreshEvent({ entity: moduleEntity, meta: context.getVariable('meta') }));
+            }, 300);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSessionTerminatePopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSessionTerminatePopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSessionTerminatePopupAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPSessionTerminateWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXPSessionTerminatePopupAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'show-toast',
+                },
+            ],
+        },
+        'show-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.session-terminated',
+                content: 'workflow.session-terminated-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'dispatch-event',
+                },
+            ],
+        },
+    },
+};
+
 class AXMSecurityManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementModule, imports: [AXMSecurityManagementProfileEntityModule, AXMSecurityManagementRolesEntityModule, AXMSecurityManagementUsersEntityModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementModule, imports: [AXMSecurityManagementDeviceSessionsEntityModule,
+            AXMSecurityManagementProfileEntityModule,
+            AXMSecurityManagementRolesEntityModule,
+            AXMSecurityManagementUsersEntityModule, i1.AXPWorkflowModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementModule, providers: [
             {
                 provide: AXP_MENU_PROVIDER,
@@ -1808,12 +2468,38 @@ class AXMSecurityManagementModule {
                 useClass: AXMSearchCommandProvider,
                 multi: true,
             },
-        ], imports: [AXMSecurityManagementProfileEntityModule, AXMSecurityManagementRolesEntityModule, AXMSecurityManagementUsersEntityModule] }); }
+        ], imports: [AXMSecurityManagementDeviceSessionsEntityModule,
+            AXMSecurityManagementProfileEntityModule,
+            AXMSecurityManagementRolesEntityModule,
+            AXMSecurityManagementUsersEntityModule,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXPSessionTerminatePopupAction
+                },
+                workflows: {
+                    'terminate-entity': AXPSessionTerminateWorkflow,
+                },
+                functions: {},
+            })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMSecurityManagementModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXMSecurityManagementProfileEntityModule, AXMSecurityManagementRolesEntityModule, AXMSecurityManagementUsersEntityModule],
+                    imports: [
+                        AXMSecurityManagementDeviceSessionsEntityModule,
+                        AXMSecurityManagementProfileEntityModule,
+                        AXMSecurityManagementRolesEntityModule,
+                        AXMSecurityManagementUsersEntityModule,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXPSessionTerminatePopupAction
+                            },
+                            workflows: {
+                                'terminate-entity': AXPSessionTerminateWorkflow,
+                            },
+                            functions: {},
+                        }),
+                    ],
                     exports: [],
                     declarations: [],
                     providers: [
@@ -1832,7 +2518,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXMSearchCommandProvider,
                             multi: true,
                         },
-                    ]
+                    ],
                 }]
         }] });
 
@@ -1840,5 +2526,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXMSecurityManagementModule, AXMSecurityManagementProfileEntityService, AXMSecurityManagementProfileEntityServiceImpl, AXMSecurityManagementRolesEntityService, AXMSecurityManagementRolesEntityServiceImpl, AXMUsersEntityServiceImpl, AXMtUsersEntityService, AXPSecurityManagementMenuKeys, RootConfig };
+export { AXMDeviceSessionsService, AXMDeviceSessionsServiceImpl, AXMSecurityManagementDeviceSessionsEntityModule, AXMSecurityManagementModule, AXMSecurityManagementProfileEntityService, AXMSecurityManagementProfileEntityServiceImpl, AXMSecurityManagementRolesEntityService, AXMSecurityManagementRolesEntityServiceImpl, AXMSessionStatusTypes, AXMUsersEntityServiceImpl, AXMtUsersEntityService, AXPSecurityManagementMenuKeys, RootConfig, factory$3 as factory };
 //# sourceMappingURL=acorex-modules-security-management.mjs.map