@acorex/connectivity 19.2.12 → 19.2.16

package/fesm2022/acorex-connectivity-mock.mjs

@@ -1,24 +1,27 @@
 import { APPLICATION_SOURCE_NAME, MODULE_SOURCE_NAME, ENTITY_SOURCE_NAME, FEATURE_SOURCE_NAME, PERMISSION_SOURCE_NAME, PROPERTY_SOURCE_NAME, AXPModuleDesignerService } from '@acorex/modules/application-management';
-import { RootConfig as RootConfig$1, AXMNotificationEntityService } from '@acorex/modules/notification-management';
+import { RootConfig, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMFolderService, AXMDocumentService } from '@acorex/modules/document-management';
+import { RootConfig as RootConfig$3, AXMNotificationEntityService } from '@acorex/modules/notification-management';
 import * as i1$1 from '@acorex/platform/auth';
-import { AXPSessionService, AXPAuthModule } from '@acorex/platform/auth';
-import { AXPDataGenerator, AXPDexieEntityStorageService, AXP_DATA_SEEDER_TOKEN, AXPEntityStorageService, AXPRegionalService, AXPFileStorageStatus, AXPFileStorageService, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPSessionService, AXPPermissionProviderService, AXPAuthModule } from '@acorex/platform/auth';
+import { AXPDataGenerator, AXPRegionalService, AXPFileStorageStatus, AXPFileStorageService, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPDexieEntityStorageService, AXPEntityDefinitionRegistryService, AXP_DATA_SEEDER_TOKEN, AXPEntityStorageService } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
 import { inject, Injectable, NgModule } from '@angular/core';
-import { AXPEntityDefinitionRegistryService } from '@acorex/platform/layout/entity';
 import * as i1 from '@acorex/modules/conversation';
 import { AXMConverstionModuleConst, AXMChatServiceImpl, AXMCommentServiceImpl, AXMChatModule, AXMChatService } from '@acorex/modules/conversation';
+import { AXPDataGenerator as AXPDataGenerator$1 } from '@acorex/platform/core';
 import Dexie from 'dexie';
 import { AXP_WIDGET_DATASOURCE_PROVIDER } from '@acorex/platform/layout/builder';
+import { RootConfig as RootConfig$1 } from '@acorex/modules/form-template-management';
 import { convertArrayToDataSource } from '@acorex/components/common';
-import { RootConfig } from '@acorex/modules/form-template-management';
-import { AXMOrganizationNodeType, RootConfig as RootConfig$2 } from '@acorex/modules/organization-management';
-import { RootConfig as RootConfig$3 } from '@acorex/modules/platform-management';
+import { RootConfig as RootConfig$2 } from '@acorex/modules/security-management';
+import { AXMOrganizationNodeType, RootConfig as RootConfig$4 } from '@acorex/modules/organization-management';
+import { RootConfig as RootConfig$5 } from '@acorex/modules/platform-management';
 import { AXTranslationService } from '@acorex/core/translation';
 import { firstValueFrom } from 'rxjs';
 import { AXFileService } from '@acorex/core/file';
-import { RootConfig as RootConfig$4 } from '@acorex/modules/scheduler-job-management';
-import { RootConfig as RootConfig$5 } from '@acorex/modules/text-template-management';
+import { RootConfig as RootConfig$6 } from '@acorex/modules/scheduler-job-management';
+import { RootConfig as RootConfig$7 } from '@acorex/modules/text-template-management';
 
 const APPLICATIONS = Array.from({ length: 5 }).map((_, i) => {
     const source = ['appOne', 'appTwo', 'appThree', 'myCoolApp', 'awesomeApp', 'superApp'];
@@ -547,6 +550,573 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
+const DocumentTypeMocks = [
+    {
+        id: AXPDataGenerator$1.uuid(),
+        name: 'OHS',
+        title: 'Occupational Health and Safety Policy',
+        maxSize: 5000,
+        isEncrypted: false,
+        meta: [
+            {
+                name: 'checkbox',
+                title: 'Check Box',
+                interface: '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"checkbox-editor","name":"checkbox-editor1","options":{"label":"i accept","readonly":false,"disabled":false},"defaultValue":false,"path":"accept-check-box"}],"name":"page-layout1"}],"name":"document"}',
+            },
+        ],
+        type: {
+            selectedItems: [
+                {
+                    name: 'image.jpg',
+                    title: 'Image/JPEG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.png',
+                    title: 'Image/PNG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.gif',
+                    title: 'Image/GIF',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+            ],
+            context: {
+                image: {
+                    width: '22',
+                    height: '33',
+                },
+                gift: {
+                    duration: '11',
+                },
+            },
+        },
+    },
+    {
+        id: AXPDataGenerator$1.uuid(),
+        name: 'WHS',
+        title: 'Workplace Health and Safety Guidelines',
+        maxSize: 10000,
+        isEncrypted: true,
+        meta: [{ name: 'external', title: 'External', interface: '' }],
+        type: {
+            selectedItems: [
+                {
+                    name: 'audio.mp3',
+                    title: 'MP3',
+                    icon: 'fa-light fa-file-audio ax-text-green-500',
+                },
+                {
+                    name: 'audio.wav',
+                    title: 'WAV',
+                    icon: 'fa-light fa-file-audio ax-text-green-500',
+                },
+            ],
+            context: {
+                audio: {
+                    bitrate: '320',
+                    duration: '180',
+                },
+            },
+        },
+    },
+];
+
+class AXCDocumentTypeDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig.module.name}.${RootConfig.entities.documentType.name}`, DocumentTypeMocks);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCDocumentTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCDocumentTypeDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCDocumentTypeDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const allFolders = [];
+const allFiles = [];
+const rootFolder = {
+    id: AXPDataGenerator$1.uuid(),
+    name: 'WHS Documentation',
+    color: '#FFFFFF',
+    description: 'Root folder for WHS/OHS Documentation',
+    parentId: undefined,
+    isSystem: true,
+    isHidden: false,
+    isDeleted: false,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    createdBy: 'system',
+    updatedBy: 'system',
+    folders: [],
+    documents: [],
+};
+// Updated sample file types with WHS/OHS specific examples
+const sampleFileTypes = [
+    {
+        ext: 'pdf',
+        titles: ['Risk Assessment Report', 'Safety Audit Checklist', 'Emergency Response Plan', 'Safety Training Manual'],
+    },
+    {
+        ext: 'docx',
+        titles: ['Incident Investigation Form', 'Safety Meeting Minutes', 'Hazard Report Template', 'Safe Work Procedure'],
+    },
+    {
+        ext: 'xlsx',
+        titles: ['Incident Statistics', 'Safety Training Matrix', 'PPE Inventory List', 'Risk Register'],
+    },
+    {
+        ext: 'jpg',
+        titles: ['Hazard Photo', 'Safety Signage', 'Emergency Exit Plan', 'PPE Requirements Chart'],
+    },
+    {
+        ext: 'png',
+        titles: ['Safety Infographic', 'Evacuation Map', 'Incident Scene Photo', 'Safety Procedure Diagram'],
+    },
+    {
+        ext: 'pptx',
+        titles: ['Safety Induction', 'WHS Training Module', 'Safety Committee Presentation', 'Toolbox Talk'],
+    },
+];
+const sites = ['Main Factory', 'Warehouse Complex', 'Office Building', 'Construction Site'];
+const whsFolders = [
+    {
+        name: 'Policies and Procedures',
+        subFolders: ['Safety Policies', 'Standard Operating Procedures', 'Emergency Procedures', 'Work Instructions'],
+        commonFiles: [
+            'WHS Policy Manual.pdf',
+            'Emergency Response Plan.pdf',
+            'Safety Management System.docx',
+            'Risk Management Framework.pdf',
+        ],
+    },
+    {
+        name: 'Risk Management',
+        subFolders: ['Risk Assessments', 'Hazard Reports', 'Control Measures', 'Safety Audits'],
+        commonFiles: [
+            'Risk Assessment Matrix.xlsx',
+            'Hazard Register.xlsx',
+            'Control Measure Checklist.pdf',
+            'Audit Schedule.xlsx',
+        ],
+    },
+    {
+        name: 'Incident Management',
+        subFolders: ['Incident Reports', 'Investigations', 'Corrective Actions', 'Statistics'],
+        commonFiles: [
+            'Incident Report Form.docx',
+            'Investigation Guidelines.pdf',
+            'Corrective Action Register.xlsx',
+            'Monthly Statistics.xlsx',
+        ],
+    },
+    {
+        name: 'Training and Compliance',
+        subFolders: ['Training Records', 'Certifications', 'Competency Assessments', 'Toolbox Talks'],
+        commonFiles: [
+            'Training Matrix.xlsx',
+            'Induction Package.pdf',
+            'Competency Framework.docx',
+            'Training Calendar.xlsx',
+        ],
+    },
+    {
+        name: 'Safety Equipment',
+        subFolders: ['PPE Records', 'Equipment Inspections', 'Maintenance Records', 'Safety Data Sheets'],
+        commonFiles: [
+            'PPE Register.xlsx',
+            'Equipment Maintenance Schedule.xlsx',
+            'Safety Equipment Inventory.xlsx',
+            'PPE Guidelines.pdf',
+        ],
+    },
+];
+sites.forEach((site) => {
+    const siteFolderId = AXPDataGenerator$1.uuid();
+    const siteFolder = {
+        id: siteFolderId,
+        name: site,
+        color: '#FFFFFF',
+        description: `WHS Documentation for ${site}`,
+        parentId: rootFolder.id,
+        isSystem: false,
+        isHidden: false,
+        isDeleted: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        createdBy: 'system',
+        updatedBy: 'system',
+        tenantId: site,
+        userId: undefined,
+        folders: [],
+        documents: [],
+    };
+    const safetyRoles = ['Safety Officer', 'Site Supervisor', 'WHS Representative'];
+    safetyRoles.forEach((role) => {
+        const roleFolderId = AXPDataGenerator$1.uuid();
+        const roleFolder = {
+            id: roleFolderId,
+            name: role,
+            color: '#FFFFFF',
+            description: `${role} Documentation`,
+            parentId: siteFolder.id,
+            isSystem: false,
+            isHidden: false,
+            isDeleted: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            createdBy: 'system',
+            updatedBy: 'system',
+            tenantId: site,
+            userId: role.toLowerCase().replace(/\s+/g, '_'),
+            folders: [],
+            documents: [],
+        };
+        sampleFileTypes.forEach((fileType) => {
+            fileType.titles.forEach((title) => {
+                if (Math.random() > 0.5) {
+                    const file = {
+                        id: AXPDataGenerator$1.uuid(),
+                        name: `${title.toLowerCase().replace(/\s+/g, '-')}.${fileType.ext}`,
+                        title: title,
+                        parentId: roleFolderId,
+                    };
+                    allFiles.push(file);
+                    roleFolder.documents?.push(file);
+                }
+            });
+        });
+        siteFolder.folders?.push(roleFolder);
+        allFolders.push(roleFolder);
+    });
+    whsFolders.forEach((dept) => {
+        const deptFolderId = AXPDataGenerator$1.uuid();
+        const deptFolder = {
+            id: deptFolderId,
+            name: dept.name,
+            color: '#' + Math.floor(Math.random() * 16777215).toString(16),
+            description: `${dept.name} documentation`,
+            parentId: siteFolder.id,
+            isSystem: false,
+            isHidden: false,
+            isDeleted: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            createdBy: 'system',
+            updatedBy: 'system',
+            tenantId: site,
+            folders: [],
+            documents: [],
+        };
+        dept.commonFiles.forEach((fileName) => {
+            const file = {
+                id: AXPDataGenerator$1.uuid(),
+                name: fileName,
+                title: fileName.split('.')[0],
+                parentId: deptFolderId,
+            };
+            allFiles.push(file);
+            deptFolder.documents?.push(file);
+        });
+        dept.subFolders.forEach((subFolderName) => {
+            const subFolderId = AXPDataGenerator$1.uuid();
+            const subFolder = {
+                id: subFolderId,
+                name: subFolderName,
+                color: '#' + Math.floor(Math.random() * 16777215).toString(16),
+                description: `${subFolderName} documentation`,
+                parentId: deptFolderId,
+                isSystem: false,
+                isHidden: false,
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                createdBy: 'system',
+                updatedBy: 'system',
+                tenantId: site,
+                folders: [],
+                documents: [],
+            };
+            sampleFileTypes.forEach((fileType) => {
+                fileType.titles.forEach((title) => {
+                    if (Math.random() > 0.7) {
+                        const file = {
+                            id: AXPDataGenerator$1.uuid(),
+                            name: `${title.toLowerCase().replace(/\s+/g, '-')}.${fileType.ext}`,
+                            title: title,
+                            parentId: subFolderId,
+                        };
+                        allFiles.push(file);
+                        subFolder.documents?.push(file);
+                    }
+                });
+            });
+            deptFolder.folders?.push(subFolder);
+            allFolders.push(subFolder);
+        });
+        siteFolder.folders?.push(deptFolder);
+        allFolders.push(deptFolder);
+    });
+    rootFolder.folders?.push(siteFolder);
+    allFolders.push(siteFolder);
+});
+allFolders.push(rootFolder);
+const FOLDER_MOCK_DATA = allFolders;
+const FILE_MOCK_DATA = allFiles;
+
+class AXCFileDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig.module.name}.${RootConfig.entities.document.name}`, FILE_MOCK_DATA);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMFolderMockService extends AXMFolderServiceImpl {
+    async updateParentFolders(folder) {
+        if (folder.parentId) {
+            const parent = await this.getOne(folder.parentId);
+            if (parent && parent.id) {
+                if (!parent.folders) {
+                    parent.folders = [];
+                }
+                const existingIndex = parent.folders.findIndex((f) => f.id === folder.id);
+                if (existingIndex === -1) {
+                    parent.folders.push(folder);
+                }
+                else {
+                    parent.folders[existingIndex] = folder;
+                }
+                await super.updateOne(parent.id, { folders: parent.folders });
+                await this.updateParentFolders(parent);
+            }
+        }
+    }
+    async removeFromParent(folder) {
+        if (folder.parentId) {
+            const parent = await this.getOne(folder.parentId);
+            if (parent && parent.id && parent.folders) {
+                parent.folders = parent.folders.filter((f) => f.id !== folder.id);
+                await super.updateOne(parent.id, { folders: parent.folders });
+                await this.updateParentFolders(parent);
+            }
+        }
+    }
+    async insertOne(request) {
+        const newId = await super.insertOne(request);
+        const folderData = {
+            ...request,
+            id: newId,
+        };
+        await this.updateParentFolders(folderData);
+        return newId;
+    }
+    async updateOne(id, values) {
+        const currentFolder = await this.getOne(id);
+        const updatedFolder = await super.updateOne(id, values);
+        if (currentFolder && values.parentId !== undefined && currentFolder.parentId !== values.parentId) {
+            await this.removeFromParent(currentFolder);
+        }
+        await this.updateParentFolders(updatedFolder);
+        return updatedFolder;
+    }
+    async deleteOne(id) {
+        const folderToDelete = await this.getOne(id);
+        if (folderToDelete) {
+            await this.removeFromParent(folderToDelete);
+            await super.deleteOne(id);
+        }
+    }
+    async getPath(folderId) {
+        const path = [];
+        let currentId = folderId;
+        while (currentId) {
+            const folder = await this.getOne(currentId);
+            if (!folder) {
+                // Folder not found in persisted storage
+                break;
+            }
+            path.push(folder);
+            currentId = folder.parentId ?? null;
+        }
+        return path.reverse();
+    }
+    /**
+     * جستجوی فولدرها با نام مشخص شده با استفاده از روش بازگشتی
+     * @param searchTerm عبارت جستجو
+     * @param rootFolderId شناسه فولدر ریشه برای شروع جستجو
+     */
+    async searchFolders(searchTerm, rootFolderId) {
+        const result = [];
+        await this.searchFoldersRecursive(searchTerm, rootFolderId, result);
+        return result;
+    }
+    /**
+     * جستجوی بازگشتی فولدرها
+     * @param searchTerm عبارت جستجو
+     * @param folderId شناسه فولدر فعلی
+     * @param result آرایه نتایج
+     */
+    async searchFoldersRecursive(searchTerm, folderId, result) {
+        try {
+            // دریافت فولدر فعلی
+            const currentFolder = await this.getOne(folderId);
+            if (!currentFolder) {
+                return;
+            }
+            // بررسی زیرفولدرها
+            const subFolders = currentFolder.folders || [];
+            // افزودن فولدرهایی که با عبارت جستجو مطابقت دارند
+            for (const folder of subFolders) {
+                if (folder.name.toLowerCase().includes(searchTerm.toLowerCase())) {
+                    result.push(folder);
+                }
+                // جستجوی بازگشتی در زیرفولدرها
+                if (folder.id) {
+                    await this.searchFoldersRecursive(searchTerm, folder.id, result);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error searching folders:', error);
+        }
+    }
+}
+
+class AXMFileMockService extends AXMDocumentServiceImpl {
+    constructor() {
+        super();
+        this.folderService = new AXMFolderMockService();
+    }
+    async updateParentFolder(file) {
+        if (!file.parentId) {
+            throw new Error('File must have a parent folder');
+        }
+        const parent = await this.folderService.getOne(file.parentId);
+        if (parent && parent.id) {
+            if (!parent.documents) {
+                parent.documents = [];
+            }
+            const existingIndex = parent.documents.findIndex((f) => f.id === file.id);
+            if (existingIndex === -1) {
+                parent.documents.push(file);
+            }
+            else {
+                parent.documents[existingIndex] = file;
+            }
+            await this.folderService.updateOne(parent.id, { documents: parent.documents });
+        }
+    }
+    async removeFromParent(file) {
+        if (!file.parentId) {
+            throw new Error('File must have a parent folder');
+        }
+        const parent = await this.folderService.getOne(file.parentId);
+        if (parent && parent.id && parent.documents) {
+            parent.documents = parent.documents.filter((f) => f.id !== file.id);
+            await this.folderService.updateOne(parent.id, { documents: parent.documents });
+        }
+    }
+    async insertOne(request) {
+        if (!request.parentId) {
+            throw new Error('File must have a parent folder');
+        }
+        const newId = await super.insertOne(request);
+        const fileData = {
+            ...request,
+            id: newId,
+        };
+        await this.updateParentFolder(fileData);
+        return newId;
+    }
+    async updateOne(id, values) {
+        const currentFile = await this.getOne(id);
+        const updatedFile = await super.updateOne(id, values);
+        if (currentFile && values.parentId !== undefined && currentFile.parentId !== values.parentId) {
+            await this.removeFromParent(currentFile);
+        }
+        await this.updateParentFolder(updatedFile);
+        return updatedFile;
+    }
+    async deleteOne(id) {
+        const fileToDelete = await this.getOne(id);
+        if (fileToDelete) {
+            await this.removeFromParent(fileToDelete);
+            await super.deleteOne(id);
+        }
+    }
+    async getPath(documentId) {
+        const file = await this.getOne(documentId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        return await this.folderService.getPath(file.parentId);
+    }
+    /**
+     * جستجوی فایل‌ها با نام مشخص شده با استفاده از روش بازگشتی
+     * @param searchTerm عبارت جستجو
+     * @param rootFolderId شناسه فولدر ریشه برای شروع جستجو
+     */
+    async searchFiles(searchTerm, rootFolderId) {
+        const result = [];
+        await this.searchFilesRecursive(searchTerm, rootFolderId, result);
+        return result;
+    }
+    /**
+     * جستجوی بازگشتی فایل‌ها
+     * @param searchTerm عبارت جستجو
+     * @param folderId شناسه فولدر فعلی
+     * @param result آرایه نتایج
+     */
+    async searchFilesRecursive(searchTerm, folderId, result) {
+        try {
+            const currentFolder = await this.folderService.getOne(folderId);
+            if (!currentFolder) {
+                return;
+            }
+            const files = currentFolder.documents || [];
+            for (const file of files) {
+                if (file.name.toLowerCase().includes(searchTerm.toLowerCase())) {
+                    result.push(file);
+                }
+            }
+            const subFolders = currentFolder.folders || [];
+            for (const folder of subFolders) {
+                if (folder.id) {
+                    await this.searchFilesRecursive(searchTerm, folder.id, result);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error searching files:', error);
+        }
+    }
+}
+
+class AXCFolderDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig.module.name}.${RootConfig.entities.folder.name}`, FOLDER_MOCK_DATA);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFolderDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFolderDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFolderDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 class EntitySearchProvider {
     async search(text) {
         const db = new Dexie('ACoreXPlatform');
@@ -561,11 +1131,16 @@ class EntitySearchProvider {
         return filteredRecords.map((record) => ({
             group: `Module.${record.entityName}`,
             data: record,
-            commands: {
-                'open-entity': {
+            command: {
+                // 'open-entity': {
+                //   entity: record.entityName,
+                //   data: record,
+                // },
+                name: 'open-entity',
+                options: {
                     entity: record.entityName,
                     data: record,
-                },
+                }
             },
         }));
     }
@@ -588,6 +1163,83 @@ class EntitySearchProvider {
     }
 }
 
+class AXPFormTemplateCategoryDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig$1.module.name}.${RootConfig$1.entities.category.name}`, this.generateCategories());
+    }
+    generateCategories() {
+        const categories = [];
+        const rootCategories = [
+            'Risk Assessment',
+            'Servicing',
+            'Checklists',
+            'Incident Reporting',
+            'Emergency Procedures',
+            'Hazardous Materials',
+            'PPE (Personal Protective Equipment)',
+            'Workplace Ergonomics',
+            'Equipment Safety',
+            'Fire Safety',
+            'First Aid',
+            'Manual Handling',
+            'Electrical Safety',
+            'Confined Spaces',
+            'Chemical Safety',
+        ];
+        rootCategories.forEach((title) => {
+            const categoryId = AXPDataGenerator.uuid();
+            categories.push({ id: categoryId, title, parentId: undefined });
+        });
+        const childCategories = [
+            {
+                parent: 'Risk Assessment',
+                children: ['Job Safety Analysis', 'Task Risk Assessment', 'General Hazard Identification'],
+            },
+            { parent: 'Incident Reporting', children: ['Near Miss Reports', 'Accident Reports', 'Injury Logs'] },
+            {
+                parent: 'Emergency Procedures',
+                children: ['Fire Evacuation', 'Medical Emergencies', 'Chemical Spill Response'],
+            },
+            {
+                parent: 'Hazardous Materials',
+                children: ['Material Safety Data Sheets', 'Storage & Handling', 'Hazardous Waste Disposal'],
+            },
+            {
+                parent: 'PPE (Personal Protective Equipment)',
+                children: ['Protective Gloves', 'Eye Protection', 'Hearing Protection'],
+            },
+            { parent: 'Workplace Ergonomics', children: ['Seating Arrangements', 'Lifting Techniques', 'Workstation Setup'] },
+            { parent: 'Equipment Safety', children: ['Machine Guarding', 'Lockout/Tagout', 'Inspection Procedures'] },
+            { parent: 'Fire Safety', children: ['Fire Extinguishers', 'Fire Drills', 'Smoke Alarms'] },
+            { parent: 'First Aid', children: ['CPR Training', 'First Aid Kits', 'Emergency Contacts'] },
+            { parent: 'Manual Handling', children: ['Proper Lifting', 'Load Limits', 'Back Injury Prevention'] },
+            {
+                parent: 'Electrical Safety',
+                children: ['Grounding & Wiring', 'High Voltage Procedures', 'Portable Equipment Checks'],
+            },
+            { parent: 'Confined Spaces', children: ['Permit-Required Spaces', 'Ventilation Protocols', 'Rescue Plans'] },
+            { parent: 'Chemical Safety', children: ['Chemical Labeling', 'Exposure Limits', 'Emergency Showers'] },
+        ];
+        childCategories.forEach(({ parent, children }) => {
+            const parentId = categories.find((c) => c.title === parent)?.id;
+            if (parentId) {
+                children.forEach((title) => {
+                    categories.push({ id: AXPDataGenerator.uuid(), title, parentId });
+                });
+            }
+        });
+        return categories;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 class AXPMockWidgetDataSourceProvider {
     async items() {
         return [
@@ -635,33 +1287,6 @@ class AXPMockWidgetDataSourceProvider {
     }
 }
 
-class AXPFormTemplateCategoryDataSeeder {
-    constructor() {
-        this.storageService = inject(AXPDexieEntityStorageService);
-    }
-    async seed() {
-        await this.storageService.initial(`${RootConfig.module.name}.${RootConfig.entities.category.name}`, [
-            {
-                id: AXPDataGenerator.uuid(),
-                title: 'Risk Assessment'
-            },
-            {
-                id: AXPDataGenerator.uuid(),
-                title: 'Servicing'
-            },
-            {
-                id: AXPDataGenerator.uuid(),
-                title: 'Checklists'
-            }
-        ]);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, decorators: [{
-            type: Injectable
-        }] });
-
 class AXCFormTemplateManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule }); }
@@ -700,11 +1325,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
         }] });
 
 class MOCKStrategy {
-    constructor() { }
+    constructor() {
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+    }
     get name() {
         return 'user-pass';
     }
     async signin(credentials) {
+        const entityRef = await this.entityRegistery.resolve(RootConfig$2.module.name, RootConfig$2.entities.users.name);
+        const accessToken = 'access_token';
+        const refreshToken = 'refresh_token';
         try {
             if (credentials.username == 'root' && credentials.password == '123') {
                 const user = {
@@ -713,8 +1343,6 @@ class MOCKStrategy {
                     title: 'Root User',
                     avatar: 'https://avatar.iran.liara.run/public/29',
                 };
-                const accessToken = 'access_token';
-                const refreshToken = 'refresh_token';
                 return {
                     succeed: true,
                     data: { user, accessToken, refreshToken },
@@ -727,8 +1355,6 @@ class MOCKStrategy {
                     title: 'Admin User',
                     avatar: 'https://avatar.iran.liara.run/public/47',
                 };
-                const accessToken = 'access_token';
-                const refreshToken = 'refresh_token';
                 return {
                     succeed: true,
                     data: { user, accessToken, refreshToken },
@@ -748,6 +1374,25 @@ class MOCKStrategy {
                     data: { user, accessToken, refreshToken },
                 };
             }
+            else {
+                const func = entityRef?.queries.list?.execute;
+                const users = await func({
+                    skip: 0,
+                    take: 1000,
+                });
+                const currentUser = users.items.find((u) => u.username === credentials.username && u.password === credentials.password);
+                if (currentUser) {
+                    const user = {
+                        id: currentUser.id,
+                        name: currentUser.username,
+                        title: `${currentUser.firstname} ${currentUser.lastname}`,
+                    };
+                    return {
+                        succeed: true,
+                        data: { user, accessToken, refreshToken },
+                    };
+                }
+            }
             return {
                 succeed: false,
             };
@@ -866,7 +1511,7 @@ class AXCNotificationTemplateDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$1.module.name}.${RootConfig$1.entities.template.name}`, NOTIFICATION_TEMPLATES);
+        await this.storageService.initial(`${RootConfig$3.module.name}.${RootConfig$3.entities.template.name}`, NOTIFICATION_TEMPLATES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCNotificationTemplateDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCNotificationTemplateDataSeeder }); }
@@ -1421,7 +2066,7 @@ class AXCOrganizationManagementDataSeeder {
     async seed() {
         const uuid = AXPDataGenerator.uuid;
         // Departments
-        await this.storageService.initial(RootConfig$2.entities.department.source, [
+        await this.storageService.initial(RootConfig$4.entities.department.source, [
             {
                 id: uuid(),
                 title: 'Engineering Division',
@@ -1439,7 +2084,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Divisions
-        await this.storageService.initial(RootConfig$2.entities.division.source, [
+        await this.storageService.initial(RootConfig$4.entities.division.source, [
             {
                 id: uuid(),
                 title: 'Software Development',
@@ -1457,7 +2102,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Branches
-        await this.storageService.initial(RootConfig$2.entities.branch.source, [
+        await this.storageService.initial(RootConfig$4.entities.branch.source, [
             {
                 id: uuid(),
                 title: 'San Francisco Office',
@@ -1475,7 +2120,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Positions
-        await this.storageService.initial(RootConfig$2.entities.position.source, [
+        await this.storageService.initial(RootConfig$4.entities.position.source, [
             {
                 id: uuid(),
                 title: 'Backend Developer',
@@ -1508,7 +2153,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Employment Types
-        await this.storageService.initial(RootConfig$2.entities.employmentType.source, [
+        await this.storageService.initial(RootConfig$4.entities.employmentType.source, [
             {
                 id: uuid(),
                 title: 'Full-Time',
@@ -1536,7 +2181,7 @@ class AXCOrganizationManagementDataSeeder {
             },
         ]);
         // Employees
-        await this.storageService.initial(RootConfig$2.entities.employee.source, [
+        await this.storageService.initial(RootConfig$4.entities.employee.source, [
             { id: uuid(), firstname: 'Jane', lastname: 'Smith', birthDate: new Date('1985-02-15'), employeeID: 'EMP002' },
             {
                 id: uuid(),
@@ -1560,11 +2205,11 @@ class AXCOrganizationManagementDataSeeder {
             { id: uuid(), firstname: 'Vikram', lastname: 'Singh', birthDate: new Date('1982-07-14'), employeeID: 'EMP007' },
         ]);
         // Store Chart Data
-        await this.storageService.initial(RootConfig$2.entities.chart.source, [
+        await this.storageService.initial(RootConfig$4.entities.chart.source, [
             {
                 id: uuid(),
                 version: '1.0',
-                data: PERSIAN_COMPANY_ORGANIZATION,
+                data: SOFTWARE_COMPANY_ORGANIZATION,
             },
         ]);
     }
@@ -1686,7 +2331,7 @@ class AXCAppTermDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$3.module.name}.${RootConfig$3.entities.appTerm.name}`, APP_TERMS);
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.appTerm.name}`, APP_TERMS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCAppTermDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCAppTermDataSeeder }); }
@@ -1697,7 +2342,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
 
 const changeLog = [];
 for (let i = 0; i < 10; i++) {
-    changeLog.push(`This is a detailed description of the changes made in version 1.5.3${i}. 
+    changeLog.push(`This is a detailed description of the changes made in version 1.6.0${i}. 
                       It includes various updates, bug fixes, and improvements. 
                       The changes are extensive and cover multiple aspects of the application, 
                       ensuring better performance, enhanced security, and a more user-friendly interface. 
@@ -1709,7 +2354,7 @@ const APP_VERSIONS = Array.from({ length: 10 }).map((element, i) => {
     publishDate.setDate(publishDate.getDate() - i * 7); // Subtract i weeks from the current date
     return {
         id: AXPDataGenerator.uuid(),
-        versionNumber: `1.5.3${i}`,
+        versionNumber: `1.6.0${i}`,
         changeLog: changeLog[i],
         publishDate: publishDate.toString(),
         showFirstTimePopup: true,
@@ -1721,7 +2366,7 @@ class AXCAppVersionDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$3.module.name}.${RootConfig$3.entities.appVersion.name}`, APP_VERSIONS);
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.appVersion.name}`, APP_VERSIONS);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCAppVersionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCAppVersionDataSeeder }); }
@@ -1752,7 +2397,7 @@ class AXCGlobalVariablesDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$3.module.name}.${RootConfig$3.entities.globalVariable.name}`, GLOBAL_VARIABLES);
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.globalVariable.name}`, GLOBAL_VARIABLES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCGlobalVariablesDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCGlobalVariablesDataSeeder }); }
@@ -1781,11 +2426,11 @@ class AXCRegionalServiceImpl extends AXPRegionalService {
             }
         });
     }
-    async getProvinces(countryCode) {
+    async getProvinces(countryId) {
         const lang = await firstValueFrom(this.languageService.langChanges$);
         const country = await this.getCountries();
         const data = country
-            .filter((c) => !countryCode || c.code === countryCode)
+            .filter((c) => !countryId || c.code === countryId)
             .flatMap((c) => c.provinces?.map((province) => {
             if (lang == c.regional) {
                 return {
@@ -1981,6 +2626,39 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }], ctorParameters: () => [] });
 
+const checkbox = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"checkbox-editor","name":"checkbox-editor1","options":{"label":"i accept","readonly":false,"disabled":false},"defaultValue":false,"path":"accept-check-box"}],"name":"page-layout1"}],"name":"document"}';
+const color = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"block-layout","name":"block-layout1","options":{"flexDirection":{"id":"ax-flex-row"},"flexJustifyContent":{"id":"ax-justify-normal"},"flexAlignItems":{"id":"ax-items-start"},"gap":2,"flexWrap":{"id":"ax-flex-nowrap"},"spacing":{"margin":"0px 0px 0px 0px","padding":"0px 0px 0px 0px"},"border":{"width":"0px","radius":"0px","color":"#000000","style":"none"},"flexOptions":{"gap":"0px","flexDirection":"row","flexWrap":"nowrap","justifyContent":"flex-start","alignItems":"flex-start"}}},"children":[{"type":"color-editor","name":"color-editor1","options":{"readonly":false,"disabled":false,"validations":{"required":{"rule":"required","message":"This field is required."}},"placeholder":"pick color"},"path":"color-box"}]}],"name":"page-layout1"}],"name":"document"}';
+const METADATA_MOCK = [
+    {
+        id: AXPDataGenerator$1.uuid(),
+        name: 'checkbox',
+        title: 'Checkbox',
+        defaultValue: false,
+        interface: checkbox,
+    },
+    {
+        id: AXPDataGenerator$1.uuid(),
+        name: 'color',
+        title: 'Color',
+        defaultValue: '#000000',
+        interface: color,
+    },
+];
+
+class AXCMetaDataDefinitionDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.metaDataDefinition.name}`, METADATA_MOCK);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMetaDataDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMetaDataDefinitionDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMetaDataDefinitionDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 const SCHEDULER_JOB = [
     {
         id: AXPDataGenerator.uuid(),
@@ -2003,7 +2681,7 @@ class AXCSchedulerJobDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$4.module.name}.${RootConfig$4.entities.schedulerJob.name}`, SCHEDULER_JOB);
+        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.schedulerJob.name}`, SCHEDULER_JOB);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCSchedulerJobDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCSchedulerJobDataSeeder }); }
@@ -2012,6 +2690,359 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
+class AXPSecurityManagementMockWidgetDataSourceProvider {
+    async items() {
+        return [
+            {
+                name: 'mock.securityUsers',
+                title: 'Security Users',
+                valueField: 'id',
+                textField: 'displayName',
+                columns: [
+                    {
+                        name: 'id',
+                        title: 'Id',
+                    },
+                    {
+                        name: 'username',
+                        title: 'Username',
+                    },
+                    {
+                        name: 'displayName',
+                        title: 'Display Name',
+                    },
+                ],
+                samples: [
+                    {
+                        id: '1',
+                        username: 'johndoe',
+                        displayName: 'John Doe',
+                    },
+                    {
+                        id: '2',
+                        username: 'janesmith',
+                        displayName: 'Jane Smith',
+                    },
+                ],
+                source: () => convertArrayToDataSource([
+                    {
+                        id: '1',
+                        username: 'johndoe',
+                        displayName: 'John Doe',
+                    },
+                    {
+                        id: '2',
+                        username: 'janesmith',
+                        displayName: 'Jane Smith',
+                    },
+                    {
+                        id: '3',
+                        username: 'mikeross',
+                        displayName: 'Mike Ross',
+                    },
+                ]),
+            },
+            {
+                name: 'mock.securityRoles',
+                title: 'Security Roles',
+                valueField: 'id',
+                textField: 'title',
+                columns: [
+                    {
+                        name: 'id',
+                        title: 'Id',
+                    },
+                    {
+                        name: 'title',
+                        title: 'Title',
+                    },
+                ],
+                samples: [
+                    {
+                        id: 'admin',
+                        title: 'Administrator',
+                    },
+                    {
+                        id: 'user',
+                        title: 'Regular User',
+                    },
+                ],
+                source: () => convertArrayToDataSource([
+                    {
+                        id: 'admin',
+                        title: 'Administrator',
+                    },
+                    {
+                        id: 'manager',
+                        title: 'Manager',
+                    },
+                    {
+                        id: 'user',
+                        title: 'Regular User',
+                    },
+                ]),
+            },
+        ];
+    }
+}
+
+// Now we only define role structure without permissions
+const mockRoleDefinitions = [
+    {
+        id: '1001',
+        name: 'admin',
+        title: 'Administrator',
+        description: 'Full system access with all administrative privileges',
+        permissions: [], // Will be filled dynamically
+    },
+    {
+        id: '1002',
+        name: 'manager',
+        title: 'Manager',
+        description: 'Manages users and has access to most system features',
+        permissions: [],
+    },
+    {
+        id: '1003',
+        name: 'user',
+        title: 'Regular User',
+        description: 'Standard user with basic system access',
+        permissions: [],
+    },
+    {
+        id: '1004',
+        name: 'readonly',
+        title: 'Read Only',
+        description: 'View-only access to specific system areas',
+        permissions: [],
+    },
+    {
+        id: '1005',
+        name: 'support',
+        title: 'Support Staff',
+        description: 'Customer support and ticket management access',
+        permissions: [],
+    },
+    {
+        id: '1006',
+        name: 'hr',
+        title: 'Human Resources',
+        description: 'Access to HR-related features and user management',
+        permissions: [],
+    },
+    {
+        id: '1007',
+        name: 'finance',
+        title: 'Finance',
+        description: 'Access to financial reports and invoicing features',
+        permissions: [],
+    },
+    {
+        id: '1008',
+        name: 'dev',
+        title: 'Developer',
+        description: 'Technical access to development and debugging features',
+        permissions: [],
+    },
+];
+const mockUsers = [
+    {
+        username: 'johndoe',
+        firstname: 'John',
+        lastname: 'Doe',
+        nationalCode: '1234567890',
+        mobile: '555-123-4567',
+        roleIds: [
+            { id: '1001', title: 'Administrator' },
+            { id: '1002', title: 'Manager' },
+        ],
+    },
+    {
+        username: 'janesmith',
+        firstname: 'Jane',
+        lastname: 'Smith',
+        nationalCode: '0987654321',
+        mobile: '555-987-6543',
+        roleIds: [
+            { id: '1002', title: 'Manager' },
+            { id: '1006', title: 'Human Resources' },
+        ],
+    },
+    {
+        username: 'mikeross',
+        firstname: 'Mike',
+        lastname: 'Ross',
+        nationalCode: '2468135790',
+        mobile: '555-246-8135',
+        roleIds: [
+            { id: '1008', title: 'Developer' },
+            { id: '1005', title: 'Support Staff' },
+        ],
+    },
+    {
+        username: 'emilyparker',
+        firstname: 'Emily',
+        lastname: 'Parker',
+        nationalCode: '1357924680',
+        mobile: '555-135-7924',
+        roleIds: [{ id: '1003', title: 'Regular User' }],
+    },
+    {
+        username: 'robertjohnson',
+        firstname: 'Robert',
+        lastname: 'Johnson',
+        nationalCode: '9876543210',
+        mobile: '555-987-6542',
+        roleIds: [{ id: '1007', title: 'Finance' }],
+    },
+    {
+        username: 'sarahwilliams',
+        firstname: 'Sarah',
+        lastname: 'Williams',
+        nationalCode: '5678901234',
+        mobile: '555-567-8901',
+        roleIds: [{ id: '1004', title: 'Read Only' }],
+    },
+    {
+        username: 'davidbrown',
+        firstname: 'David',
+        lastname: 'Brown',
+        nationalCode: '3456789012',
+        mobile: '555-345-6789',
+        roleIds: [
+            { id: '1003', title: 'Regular User' },
+            { id: '1005', title: 'Support Staff' },
+        ],
+    },
+    {
+        username: 'lisadavis',
+        firstname: 'Lisa',
+        lastname: 'Davis',
+        nationalCode: '7890123456',
+        mobile: '555-789-0123',
+        roleIds: [{ id: '1006', title: 'Human Resources' }],
+    },
+    {
+        username: 'michaelwilson',
+        firstname: 'Michael',
+        lastname: 'Wilson',
+        nationalCode: '6789012345',
+        mobile: '555-678-9012',
+        roleIds: [
+            { id: '1002', title: 'Manager' },
+            { id: '1007', title: 'Finance' },
+        ],
+    },
+    {
+        username: 'amandamiller',
+        firstname: 'Amanda',
+        lastname: 'Miller',
+        nationalCode: '4567890123',
+        mobile: '555-456-7890',
+        roleIds: [{ id: '1008', title: 'Developer' }],
+    },
+];
+
+class AXPSecurityManagementRoleDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+        this.permissionService = inject(AXPPermissionProviderService);
+    }
+    async seed() {
+        const permissions = await this.permissionService.permissions();
+        const permissionKeys = permissions.map((p) => p.name);
+        // Generate roles with random permissions from the actual permission list
+        const roles = mockRoleDefinitions.map((role) => ({
+            ...role,
+            permissions: this.getRandomPermissions(permissionKeys, 2, 5), // Get 2-5 random permissions
+        }));
+        await this.storageService.initial(`${RootConfig$2.module.name}.${RootConfig$2.entities.roles.name}`, roles);
+    }
+    getRandomPermissions(permissions, min, max) {
+        const count = Math.floor(Math.random() * (max - min + 1)) + min;
+        const shuffled = [...permissions].sort(() => 0.5 - Math.random());
+        return shuffled.slice(0, count);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementRoleDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementRoleDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementRoleDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPSecurityManagementUserDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig$2.module.name}.${RootConfig$2.entities.users.name}`, this.generateUsers());
+    }
+    generateUsers() {
+        return mockUsers.map((user) => ({
+            id: AXPDataGenerator.uuid(),
+            username: user.username,
+            firstname: user.firstname,
+            lastname: user.lastname,
+            nationalCode: user.nationalCode,
+            mobile: user.mobile,
+            password: '123',
+            roles: user.roleIds,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementUserDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementUserDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSecurityManagementUserDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+class AXCSecurityManagementMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCSecurityManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCSecurityManagementMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCSecurityManagementMockModule, providers: [
+            {
+                provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                useClass: AXPSecurityManagementMockWidgetDataSourceProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPSecurityManagementUserDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPSecurityManagementRoleDataSeeder,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCSecurityManagementMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                            useClass: AXPSecurityManagementMockWidgetDataSourceProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPSecurityManagementUserDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPSecurityManagementRoleDataSeeder,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
 const TEXT_TEMPLATE_CATEGORY = [
     {
         id: AXPDataGenerator.uuid(),
@@ -2134,7 +3165,7 @@ class AXCTextTemplateCategoryDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.category.name}`, TEXT_TEMPLATE_CATEGORY);
+        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.category.name}`, TEXT_TEMPLATE_CATEGORY);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCTextTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCTextTemplateCategoryDataSeeder }); }
@@ -2148,7 +3179,7 @@ class AXCTextTemplateDataSeeder {
         this.storageService = inject(AXPDexieEntityStorageService);
     }
     async seed() {
-        await this.storageService.initial(`${RootConfig$5.module.name}.${RootConfig$5.entities.template.name}`, TEXT_TEMPLATES);
+        await this.storageService.initial(`${RootConfig$7.module.name}.${RootConfig$7.entities.template.name}`, TEXT_TEMPLATES);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCTextTemplateDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCTextTemplateDataSeeder }); }
@@ -2161,7 +3192,8 @@ class AXCMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, imports: [i1$1.AXPAuthModule, AXCFormTemplateManagementMockModule,
             AXCFOrganizationManagementMockModule,
-            AXCConversationMockModule] }); }
+            AXCConversationMockModule,
+            AXCSecurityManagementMockModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, providers: [
             AXPDexieEntityStorageService,
             {
@@ -2212,11 +3244,31 @@ class AXCMockModule {
                 useClass: AXCAppTermDataSeeder,
                 multi: true,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCMetaDataDefinitionDataSeeder,
+                multi: true,
+            },
             {
                 provide: AXP_DATA_SEEDER_TOKEN,
                 useClass: AXCAppTermDataSeeder,
                 multi: true,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCFolderDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCDocumentTypeDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCFileDataSeeder,
+                multi: true,
+            },
             {
                 provide: AXPModuleDesignerService,
                 useClass: AXCModuleDesignerService,
@@ -2229,6 +3281,14 @@ class AXCMockModule {
                 provide: AXPRegionalService,
                 useClass: AXCRegionalServiceImpl,
             },
+            {
+                provide: AXMFolderService,
+                useClass: AXMFolderMockService,
+            },
+            {
+                provide: AXMDocumentService,
+                useClass: AXMFileMockService,
+            },
             {
                 provide: AXP_SEARCH_PROVIDER,
                 useClass: EntitySearchProvider,
@@ -2239,7 +3299,8 @@ class AXCMockModule {
             }),
             AXCFormTemplateManagementMockModule,
             AXCFOrganizationManagementMockModule,
-            AXCConversationMockModule] }); }
+            AXCConversationMockModule,
+            AXCSecurityManagementMockModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, decorators: [{
             type: NgModule,
@@ -2251,6 +3312,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                         AXCFormTemplateManagementMockModule,
                         AXCFOrganizationManagementMockModule,
                         AXCConversationMockModule,
+                        AXCSecurityManagementMockModule,
                     ],
                     exports: [],
                     declarations: [],
@@ -2304,11 +3366,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXCAppTermDataSeeder,
                             multi: true,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCMetaDataDefinitionDataSeeder,
+                            multi: true,
+                        },
                         {
                             provide: AXP_DATA_SEEDER_TOKEN,
                             useClass: AXCAppTermDataSeeder,
                             multi: true,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCFolderDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCDocumentTypeDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCFileDataSeeder,
+                            multi: true,
+                        },
                         {
                             provide: AXPModuleDesignerService,
                             useClass: AXCModuleDesignerService,
@@ -2321,6 +3403,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             provide: AXPRegionalService,
                             useClass: AXCRegionalServiceImpl,
                         },
+                        {
+                            provide: AXMFolderService,
+                            useClass: AXMFolderMockService,
+                        },
+                        {
+                            provide: AXMDocumentService,
+                            useClass: AXMFileMockService,
+                        },
                         {
                             provide: AXP_SEARCH_PROVIDER,
                             useClass: EntitySearchProvider,