@acorex/modules 19.1.4 → 19.1.5

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

@@ -1,5 +1,5 @@
 import * as i1$2 from '@acorex/platform/common';
-import { AXP_MENU_PROVIDER, AXPComponentSlotModule, AXPEntityStorageService, AXPEntityDataProviderImpl, AXPDataGenerator, AXPEntityQueryType, AXPEntityCommandScope } from '@acorex/platform/common';
+import { AXP_MENU_PROVIDER, AXPComponentSlotModule, AXMEntityCrudServiceImpl, AXPDataGenerator, AXPEntityQueryType, AXPEntityCommandScope, AXPEntityStorageService, AXPEntityDataProviderImpl } from '@acorex/platform/common';
 import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
 import { input, output, computed, Component, ChangeDetectionStrategy, inject, signal, effect, Injector, Injectable, NgModule } from '@angular/core';
@@ -25,7 +25,6 @@ import { AXAvatarModule } from '@acorex/components/avatar';
 import * as i4 from '@acorex/components/image';
 import { AXImageModule } from '@acorex/components/image';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
-import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 
 class AXMNotificationService {
 }
@@ -214,6 +213,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                     ], template: "<ax-button class=\"ax-relative\" look=\"blank\" #notification>\n  <ax-icon>\n    <i class=\"fa-regular fa-bell\"></i>\n  </ax-icon>\n  <ax-suffix class=\"ax-absolute ax-top-0 ax-left-1/2\">\n    @if(totalNewNotification()){\n    <ax-badge color=\"success\" [text]=\"totalNewNotification().toString()\"></ax-badge>\n    }\n  </ax-suffix>\n</ax-button>\n<ax-popover [target]=\"notification\" [openOn]=\"'toggle'\" [closeOn]=\"'clickOut'\" [adaptivityEnabled]=\"true\">\n  <div class=\"ax-bg-surface ax-border ax-border-default ax-rounded-md ax-shadow-md ax-w-full\">\n    <axm-admin-notification-panel (onNewNotfication)=\"setTotalNewNotification($event)\"> </axm-admin-notification-panel>\n  </div>\n</ax-popover>\n" }]
         }] });
 
+const AXMNotificationManagementModuleConst = {
+    moduleName: 'NotificationManagement',
+    moduleRoute: 'notification-management',
+    i18n: 'notification-management',
+    myNotificationEntity: 'my-notification',
+    notificationTemplateEntity: 'Templates',
+    notificationChannelEntity: 'Channels',
+    notificationEntity: 'Notifications',
+};
+
 class AXMNotificationModuleEntityLoader {
     constructor() {
         this.injector = inject(Injector);
@@ -221,13 +230,13 @@ class AXMNotificationModuleEntityLoader {
     async get(moduleName, entityName) {
         return new Promise(async (resolve) => {
             switch (entityName) {
-                case 'notificationTemplate': {
-                    const entity = (await Promise.resolve().then(function () { return notificationTemplate_entity; })).notificationTemplateEntityFactory;
+                case AXMNotificationManagementModuleConst.notificationTemplateEntity: {
+                    const entity = (await Promise.resolve().then(function () { return template_entity; })).notificationTemplateEntityFactory;
                     resolve(entity(this.injector));
                     break;
                 }
-                case 'notificationChannel': {
-                    const entity = (await Promise.resolve().then(function () { return notificationChannel_entity; })).notificationChannelEntityFactory;
+                case AXMNotificationManagementModuleConst.notificationChannelEntity: {
+                    const entity = (await Promise.resolve().then(function () { return channel_entity; })).notificationChannelEntityFactory;
                     resolve(entity(this.injector));
                     break;
                 }
@@ -236,7 +245,7 @@ class AXMNotificationModuleEntityLoader {
                     resolve(entity(this.injector));
                     break;
                 }
-                case 'notification': {
+                case AXMNotificationManagementModuleConst.notificationEntity: {
                     const entity = (await Promise.resolve().then(function () { return notification_entity; })).notificationEntityFactory;
                     resolve(entity(this.injector));
                     break;
@@ -253,15 +262,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
-const AXMNotificationManagementModuleConst = {
-    moduleName: 'NotificationManagement',
-    moduleRoute: 'notification-management',
-    i18n: 'notification-management',
-    myNotificationEntity: 'my-notification',
-    notificationTemplateEntity: 'notification-template',
-    notificationEntity: 'notification',
-};
-
 class AXMNotificationManagmentModuleMenuProvider {
     constructor() {
         this.entityService = inject(AXPEntityService);
@@ -367,501 +367,180 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
-async function myNotificationEntityFactory(injector) {
-    const storageService = injector.get(AXPEntityStorageService);
-    const dataProvider = new AXPEntityDataProviderImpl(storageService, 'notifications');
-    const moduleName = 'notification-management';
-    const scope = `#${moduleName}`;
+class AXMNotificationManagementChannelEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMNotificationManagementChannelEntityServiceImpl extends AXMNotificationManagementChannelEntityService {
+    constructor() {
+        super(`${AXMNotificationManagementModuleConst.moduleName}.${AXMNotificationManagementModuleConst.notificationChannelEntity}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementChannelEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function notificationChannelEntityFactory(injector) {
+    const dataService = injector.get(AXMNotificationManagementChannelEntityService);
     const entityDef = {
-        module: moduleName,
-        name: 'notification',
-        source: 'notification-management.notification',
-        title: `t('my',{scope: 'notification-management'})`,
+        module: AXMNotificationManagementModuleConst.moduleName,
+        name: AXMNotificationManagementModuleConst.notificationChannelEntity,
+        source: '',
+        title: 'Notification Channel',
         formats: {
-            individual: `t('my',{scope: 'notification-management'})`,
-            plural: `t('my',{scope: 'notification-management'})`,
+            individual: 'Channel',
+            plural: 'Channels',
         },
+        relatedEntities: [],
         groups: [
-            { id: 'data', title: 'Data' },
-            { id: 'content', title: 'Content' },
-            { id: 'action', title: 'Action' },
-            { id: 'user', title: 'User' },
-            { id: 'template', title: 'Template' },
-        ],
-        properties: [
             {
-                name: 'id',
-                title: 'ID',
-                groupId: 'data',
-                schema: {
-                    dataType: 'string',
-                    hidden: true,
-                    nullable: false,
-                    readonly: true,
-                    unique: { enabled: true },
-                },
+                id: 'notificationChannel',
+                title: 'Notification Channel',
             },
+        ],
+        properties: [
             {
                 name: 'title',
-                title: 't("title", { scope: "common" })',
-                groupId: 'data',
+                title: 'Title',
+                groupId: 'notificationChannel',
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
-            },
-            {
-                name: 'body',
-                title: 'Body',
-                groupId: 'data',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.largeText,
-                    },
-                },
-            },
-            {
-                name: 'channel',
-                title: 'Channel',
-                groupId: 'data',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: { dataSource: ['InApp', 'Email', 'SMS'], multiple: false },
-                    },
-                },
-            },
-            {
-                name: 'content.type',
-                title: 'Content Data',
-                groupId: 'content',
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.richText,
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
             {
-                name: 'action.type',
-                title: 'Action Type',
-                groupId: 'action',
+                name: 'template',
+                title: 'Template',
+                groupId: 'notificationChannel',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: { dataSource: ['Link', 'Entity', 'Popup'], multiple: false },
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'templateManagement.template',
+                            expose: { source: 'content', target: 'body' },
+                        },
                     },
                 },
             },
             {
-                name: 'User.name',
-                title: 'Username',
-                groupId: 'user',
+                name: 'body',
+                title: 'Body',
+                groupId: 'notificationChannel',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog.richText,
                     },
                 },
-            },
-            {
-                name: 'template.category',
-                title: 'Category',
-                groupId: 'template',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: { dataSource: ['Inbox', 'Archive'], multiple: false },
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
             {
-                name: 'template.prority',
-                title: 'Prority',
-                groupId: 'template',
+                name: 'channel',
+                title: 'Channel',
+                groupId: 'notificationChannel',
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.select,
-                        options: { dataSource: ['Warning', 'Danger', 'Notice'], multiple: false },
-                    },
-                },
-            },
-            {
-                name: 'template.isPinned',
-                title: 'Is Pinned',
-                groupId: 'template',
-                schema: {
-                    dataType: 'boolean',
-                    interface: {
-                        type: AXPWidgetsCatalog.checkbox,
                         options: {
-                            label: 'Is Pinned',
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'SMS', name: 'sms' },
+                                { title: 'Email', name: 'email' },
+                                { title: 'In App', name: 'inApp' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
                         },
                     },
                 },
-            },
-            {
-                name: 'readAt',
-                title: 'Read At',
-                groupId: 'data',
-                schema: {
-                    dataType: 'datetime',
-                    interface: {
-                        type: AXPWidgetsCatalog.dateTime,
-                        options: { format: 'date' },
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
             {
-                name: 'createAt',
-                title: 'Created At',
-                groupId: 'data',
+                name: 'title',
+                title: 'Title',
+                groupId: 'notificationChannel',
                 schema: {
-                    dataType: 'datetime',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.dateTime,
-                        options: { format: 'date' },
+                        type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
-        columns: [
-            { name: 'title' },
-            { name: 'body' },
-            { name: 'channel' },
-            { name: 'user.name' },
-            { name: 'template.category' },
-            { name: 'template.prority' },
-            { name: 'createAt' },
-            { name: 'readAt' },
-        ],
+        columns: [{ name: 'title' }, { name: 'body' }, { name: 'channel' }],
         commands: {
             create: {
                 execute: async (data) => {
-                    console.log('CREATE', data);
                     const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
-                    await dataProvider.insertOne(entity);
-                    return entity;
+                    dataService.insertOne(entity);
+                    return Promise.resolve(entity);
                 },
             },
             delete: {
                 execute: async (id) => {
-                    console.log('CREATE', id);
-                    await dataProvider.deleteOne(id);
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
                 },
             },
             update: {
                 execute: async (data) => {
-                    await dataProvider.updateOne(data.id, data);
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
                 },
             },
         },
         queries: {
             byKey: {
                 execute: async (id) => {
-                    return await dataProvider.getOne(id);
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
                 },
                 type: AXPEntityQueryType.Single,
             },
             list: {
                 execute: async (e) => {
-                    const list = await dataProvider.getAll();
-                    return {
-                        total: list.length,
-                        items: list.slice(e.skip, e.skip + e.take),
-                    };
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
                 },
                 type: AXPEntityQueryType.List,
             },
         },
         interfaces: {
             master: {
-                list: {
-                    actions: [
+                create: {
+                    sections: [
                         {
-                            title: 'Delete',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Selected,
-                        },
-                    ],
-                    views: [{ name: 'all', title: 'All Notifications', fixed: true, columns: [], conditions: [], sorts: [] }],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var myNotification = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    myNotificationEntityFactory: myNotificationEntityFactory
-});
-
-const CHANNELS = ['InApp', 'Email', 'SMS'];
-const TITLES = ['Buy Me!', 'Black Friday', 'New Message'];
-const BODIES = ['Buy New Glass From Shop', 'New Offers For Black Friday!', 'Saeed Send New File Message'];
-const CATEGORIES = ['Inbox', 'Archive', 'Role'];
-const TYPES = ['File', 'Person', 'Notification'];
-const PRORITIES = ['Warning', 'Danger', 'Notice'];
-const NOTIFICATION_TEMPLATES = Array.from({ length: 5 }).map((_, i) => {
-    const name = AXPDataGenerator.string();
-    return {
-        id: AXPDataGenerator.uuid(),
-        name: name,
-        title: name,
-        description: AXPDataGenerator.string(200),
-    };
-});
-const NOTIFICATION_CHANNELS = Array.from({ length: 3 }).map((_, i) => {
-    return {
-        body: BODIES[i],
-        title: TITLES[i],
-        channel: CHANNELS[i],
-        inApp: {
-            category: AXPDataGenerator.pick(CATEGORIES),
-            level: AXPDataGenerator.pick(PRORITIES),
-            type: AXPDataGenerator.pick(TYPES),
-        },
-    };
-});
-const NOTIFICATIONS = Array.from({ length: 5 }).map((_, i) => {
-    return {
-        id: AXPDataGenerator.uuid(),
-        title: AXPDataGenerator.pick(TITLES),
-        body: AXPDataGenerator.pick(BODIES),
-        channel: AXPDataGenerator.pick(CHANNELS),
-        data: {},
-        RelativeType: 'demo.sample',
-        RelativeId: '535c8c8a-5e64-4079-929d-752394669b51',
-        user: {
-            id: AXPDataGenerator.uuid(),
-            name: AXPDataGenerator.firstName() + ' ' + AXPDataGenerator.lastName(),
-            image: 'https://i.pravatar.cc/300',
-        },
-        template: {
-            category: AXPDataGenerator.pick(CATEGORIES),
-            prority: AXPDataGenerator.pick(PRORITIES),
-            type: AXPDataGenerator.pick(TYPES),
-            icon: 'fa-image',
-            isPinned: AXPDataGenerator.boolean(),
-        },
-        readAt: AXPDataGenerator.pick([AXPDataGenerator.date(), null]),
-        createAt: AXPDataGenerator.date(),
-        entityName: 'notifications',
-    };
-});
-
-class NotificationManagementService {
-    constructor() {
-        this.storageService = inject(AXPEntityStorageService);
-        //
-        this._notificationTemplateDataProvider = new AXPEntityDataProviderImpl(this.storageService, 'notificationTemplates');
-        this._notificationTemplateDataProvider.initial(NOTIFICATION_TEMPLATES);
-        //
-        this._notificationChannelDataProvider = new AXPEntityDataProviderImpl(this.storageService, 'notificationChannels');
-        this._notificationChannelDataProvider.initial(NOTIFICATION_CHANNELS);
-        //
-        this._notificationDataProvider = new AXPEntityDataProviderImpl(this.storageService, 'notifications');
-        this._notificationDataProvider.initial(NOTIFICATIONS);
-    }
-    notificationTemplateList() {
-        return this._notificationTemplateDataProvider.getAll();
-    }
-    get notificationTemplateDataProvider() {
-        return this._notificationTemplateDataProvider;
-    }
-    get notificationChannelDataProvider() {
-        return this._notificationChannelDataProvider;
-    }
-    get notificationDataProvider() {
-        return this._notificationDataProvider;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: NotificationManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: NotificationManagementService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: NotificationManagementService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-
-async function notificationChannelEntityFactory(injector) {
-    const dataService = injector.get(NotificationManagementService);
-    const entityDef = {
-        module: 'notification-management',
-        name: 'notificationChannel',
-        source: 'notificationManagement.notificationChannel',
-        title: 'Notification Channel',
-        formats: {
-            individual: 'Channel',
-            plural: 'Channels',
-        },
-        relatedEntities: [],
-        groups: [
-            {
-                id: 'notificationChannel',
-                title: 'Notification Channel',
-            },
-        ],
-        properties: [
-            {
-                name: 'title',
-                title: 'Title',
-                groupId: 'notificationChannel',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'template',
-                title: 'Template',
-                groupId: 'notificationChannel',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: 'templateManagement.template',
-                            expose: { source: 'content', target: 'body' },
-                        },
-                    },
-                },
-            },
-            {
-                name: 'body',
-                title: 'Body',
-                groupId: 'notificationChannel',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.richText,
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'channel',
-                title: 'Channel',
-                groupId: 'notificationChannel',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            valueField: 'name',
-                            textField: 'title',
-                            dataSource: [
-                                { title: 'SMS', name: 'sms' },
-                                { title: 'Email', name: 'email' },
-                                { title: 'In App', name: 'inApp' },
-                            ],
-                            direction: 'horizontal',
-                            multiple: false,
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'title',
-                title: 'Title',
-                groupId: 'notificationChannel',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-        ],
-        columns: [{ name: 'title' }, { name: 'body' }, { name: 'channel' }],
-        commands: {
-            create: {
-                execute: async (data) => {
-                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
-                    dataService.notificationChannelDataProvider.insertOne(entity);
-                    return Promise.resolve(entity);
-                },
-            },
-            delete: {
-                execute: async (id) => {
-                    await await dataService.notificationChannelDataProvider.deleteOne(id);
-                    return Promise.resolve();
-                },
-            },
-            update: {
-                execute: async (data) => {
-                    return new Promise((resolve) => {
-                        setTimeout(async () => {
-                            await dataService.notificationChannelDataProvider.updateOne(data.id, data);
-                            resolve(data);
-                        }, 1000);
-                    });
-                },
-            },
-        },
-        queries: {
-            byKey: {
-                execute: async (id) => {
-                    return new Promise((resolve) => {
-                        setTimeout(async () => {
-                            const entity = await dataService.notificationChannelDataProvider.getOne(id);
-                            resolve(entity);
-                        }, 500);
-                    });
-                },
-                type: AXPEntityQueryType.Single,
-            },
-            list: {
-                execute: async (e) => {
-                    const list = await dataService.notificationChannelDataProvider.getAll();
-                    const sortedItems = applySortArray(list, e.sort);
-                    const filteredItems = applyFilterArray(sortedItems, e.filter ? [e.filter] : []);
-                    return Promise.resolve({
-                        total: filteredItems.length,
-                        items: filteredItems.slice(e.skip, (e.skip ?? 0) + (e.take ?? 0)),
-                    });
-                },
-                type: AXPEntityQueryType.List,
-            },
-        },
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'notificationChannel',
+                            id: 'notificationChannel',
                         },
                     ],
                     properties: [
@@ -1035,44 +714,495 @@ async function notificationChannelEntityFactory(injector) {
     return entityDef;
 }
 
-var notificationChannel_entity = /*#__PURE__*/Object.freeze({
+var channel_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
     notificationChannelEntityFactory: notificationChannelEntityFactory
 });
 
-async function notificationLogEntityFactory(injector) {
-    const dataService = injector.get(NotificationManagementService);
+async function myNotificationEntityFactory(injector) {
+    const storageService = injector.get(AXPEntityStorageService);
+    const dataProvider = new AXPEntityDataProviderImpl(storageService, 'notifications');
+    const moduleName = 'notification-management';
+    const scope = `#${moduleName}`;
     const entityDef = {
-        module: 'notification-management',
+        module: moduleName,
         name: 'notification',
-        source: 'notification-management.notificationLog',
-        title: 'Notification',
+        source: 'notification-management.notification',
+        title: `t('my',{scope: 'notification-management'})`,
         formats: {
-            individual: 'NotificationLog',
-            plural: 'NotificationLogs',
+            individual: `t('my',{scope: 'notification-management'})`,
+            plural: `t('my',{scope: 'notification-management'})`,
         },
-        relatedEntities: [],
         groups: [
+            { id: 'data', title: 'Data' },
+            { id: 'content', title: 'Content' },
+            { id: 'action', title: 'Action' },
+            { id: 'user', title: 'User' },
+            { id: 'template', title: 'Template' },
+        ],
+        properties: [
             {
-                id: 'notification',
-                title: 'Notification',
+                name: 'id',
+                title: 'ID',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    hidden: true,
+                    nullable: false,
+                    readonly: true,
+                    unique: { enabled: true },
+                },
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'body',
+                title: 'Body',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                    },
+                },
+            },
+            {
+                name: 'channel',
+                title: 'Channel',
+                groupId: 'data',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['InApp', 'Email', 'SMS'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'content.type',
+                title: 'Content Data',
+                groupId: 'content',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+            {
+                name: 'action.type',
+                title: 'Action Type',
+                groupId: 'action',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Link', 'Entity', 'Popup'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'User.name',
+                title: 'Username',
+                groupId: 'user',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'template.category',
+                title: 'Category',
+                groupId: 'template',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Inbox', 'Archive'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'template.prority',
+                title: 'Prority',
+                groupId: 'template',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: { dataSource: ['Warning', 'Danger', 'Notice'], multiple: false },
+                    },
+                },
+            },
+            {
+                name: 'template.isPinned',
+                title: 'Is Pinned',
+                groupId: 'template',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                        options: {
+                            label: 'Is Pinned',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'readAt',
+                title: 'Read At',
+                groupId: 'data',
+                schema: {
+                    dataType: 'datetime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { format: 'date' },
+                    },
+                },
+            },
+            {
+                name: 'createAt',
+                title: 'Created At',
+                groupId: 'data',
+                schema: {
+                    dataType: 'datetime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { format: 'date' },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'title' },
+            { name: 'body' },
+            { name: 'channel' },
+            { name: 'user.name' },
+            { name: 'template.category' },
+            { name: 'template.prority' },
+            { name: 'createAt' },
+            { name: 'readAt' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    console.log('CREATE', data);
+                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
+                    await dataProvider.insertOne(entity);
+                    return entity;
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    console.log('CREATE', id);
+                    await dataProvider.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    await dataProvider.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataProvider.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const list = await dataProvider.getAll();
+                    return {
+                        total: list.length,
+                        items: list.slice(e.skip, e.skip + e.take),
+                    };
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                list: {
+                    actions: [
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                    ],
+                    views: [{ name: 'all', title: 'All Notifications', fixed: true, columns: [], conditions: [], sorts: [] }],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var myNotification = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    myNotificationEntityFactory: myNotificationEntityFactory
+});
+
+async function notificationLogEntityFactory(injector) {
+    const dataService = injector.get(AXMNotificationManagementChannelEntityService);
+    const entityDef = {
+        module: 'notification-management',
+        name: 'notification',
+        source: 'notification-management.notificationLog',
+        title: 'Notification',
+        formats: {
+            individual: 'NotificationLog',
+            plural: 'NotificationLogs',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'notification',
+                title: 'Notification',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 'Name',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'status',
+                title: 'Status',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'notification',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'user.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'body',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'channel',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'primary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+async function notificationEntityFactory(injector) {
+    const dataService = injector.get(AXMNotificationManagementChannelEntityService);
+    const entityDef = {
+        module: AXMNotificationManagementModuleConst.moduleName,
+        name: AXMNotificationManagementModuleConst.notificationEntity,
+        source: '',
+        title: 't("notifications",{scope: "notification-management"})',
+        formats: {
+            individual: 't("notifications",{scope: "notification-management"})',
+            plural: 't("notifications",{scope: "notification-management"})',
+        },
+        relatedEntities: [
+            {
+                entity: 'notification-management.notificationLog',
+                columns: ['title', 'status'],
+            },
+        ],
+        groups: [
+            {
+                id: 'notification',
+                title: 'Notification',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 'Name',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'notification',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
-        ],
-        properties: [
             {
-                name: 'name',
-                title: 'Name',
+                name: 'body',
+                title: 'Body',
                 groupId: 'notification',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog.richText,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'title',
-                title: 'Title',
+                name: 'channel',
+                title: 'Channel',
                 groupId: 'notification',
                 schema: {
                     dataType: 'string',
@@ -1082,24 +1212,24 @@ async function notificationLogEntityFactory(injector) {
                 },
             },
             {
-                name: 'status',
-                title: 'Status',
+                name: 'user.name',
+                title: 'User Name',
                 groupId: 'notification',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.richText,
+                        type: AXPWidgetsCatalog.text,
                     },
                 },
             },
         ],
-        columns: [{ name: 'name' }, { name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
+        columns: [{ name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
         queries: {
             byKey: {
                 execute: async (id) => {
                     return new Promise((resolve) => {
                         setTimeout(async () => {
-                            const entity = await dataService.notificationDataProvider.getOne(id);
+                            const entity = await dataService.getOne(id);
                             resolve(entity);
                         }, 500);
                     });
@@ -1108,13 +1238,7 @@ async function notificationLogEntityFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    const list = await dataService.notificationDataProvider.getAll();
-                    const sortedItems = applySortArray(list, e.sort);
-                    const filteredItems = applyFilterArray(sortedItems, e.filter ? [e.filter] : []);
-                    return Promise.resolve({
-                        total: filteredItems.length,
-                        items: filteredItems.slice(e.skip, (e.skip ?? 0) + (e.take ?? 0)),
-                    });
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -1216,12 +1340,30 @@ async function notificationLogEntityFactory(injector) {
     return entityDef;
 }
 
+var notification_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    notificationEntityFactory: notificationEntityFactory
+});
+
+class AXMNotificationManagementTemplateEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMNotificationManagementTemplateEntityServiceImpl extends AXMNotificationManagementTemplateEntityService {
+    constructor() {
+        super(`${AXMNotificationManagementModuleConst.moduleName}.${AXMNotificationManagementModuleConst.notificationTemplateEntity}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMNotificationManagementTemplateEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 async function notificationTemplateEntityFactory(injector) {
-    const dataService = injector.get(NotificationManagementService);
+    const dataService = injector.get(AXMNotificationManagementTemplateEntityService);
     const entityDef = {
-        module: 'notification-management',
-        name: 'notificationTemplate',
-        source: 'notification-management.notificationTemplate',
+        module: AXMNotificationManagementModuleConst.moduleName,
+        name: AXMNotificationManagementModuleConst.notificationTemplateEntity,
+        source: '',
         title: 't("template",{scope: "notification-management"})',
         formats: {
             individual: 't("template",{scope: "notification-management"})',
@@ -1229,7 +1371,7 @@ async function notificationTemplateEntityFactory(injector) {
         },
         relatedEntities: [
             {
-                entity: 'notification-management.notificationChannel',
+                entity: AXMNotificationManagementModuleConst.notificationChannelEntity,
                 columns: ['title', 'body', 'channel'],
                 conditions: [
                     {
@@ -1259,6 +1401,11 @@ async function notificationTemplateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'title',
@@ -1270,6 +1417,11 @@ async function notificationTemplateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'description',
@@ -1281,6 +1433,11 @@ async function notificationTemplateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
         columns: [{ name: 'name' }, { name: 'title' }],
@@ -1288,13 +1445,13 @@ async function notificationTemplateEntityFactory(injector) {
             create: {
                 execute: async (data) => {
                     const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
-                    dataService.notificationTemplateDataProvider.insertOne(entity);
+                    dataService.insertOne(entity);
                     return Promise.resolve(entity);
                 },
             },
             delete: {
                 execute: async (id) => {
-                    await await dataService.notificationTemplateDataProvider.deleteOne(id);
+                    await await dataService.deleteOne(id);
                     return Promise.resolve();
                 },
             },
@@ -1302,7 +1459,7 @@ async function notificationTemplateEntityFactory(injector) {
                 execute: async (data) => {
                     return new Promise((resolve) => {
                         setTimeout(async () => {
-                            await dataService.notificationTemplateDataProvider.updateOne(data.id, data);
+                            await dataService.updateOne(data.id, data);
                             resolve(data);
                         }, 1000);
                     });
@@ -1314,7 +1471,7 @@ async function notificationTemplateEntityFactory(injector) {
                 execute: async (id) => {
                     return new Promise((resolve) => {
                         setTimeout(async () => {
-                            const entity = await dataService.notificationTemplateDataProvider.getOne(id);
+                            const entity = await dataService.getOne(id);
                             resolve(entity);
                         }, 500);
                     });
@@ -1323,13 +1480,7 @@ async function notificationTemplateEntityFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    const list = await dataService.notificationTemplateDataProvider.getAll();
-                    const sortedItems = applySortArray(list, e.sort);
-                    const filteredItems = applyFilterArray(sortedItems, e.filter ? [e.filter] : []);
-                    return Promise.resolve({
-                        total: filteredItems.length,
-                        items: filteredItems.slice(e.skip, (e.skip ?? 0) + (e.take ?? 0)),
-                    });
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -1510,219 +1661,11 @@ async function notificationTemplateEntityFactory(injector) {
     return entityDef;
 }
 
-var notificationTemplate_entity = /*#__PURE__*/Object.freeze({
+var template_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
     notificationTemplateEntityFactory: notificationTemplateEntityFactory
 });
 
-async function notificationEntityFactory(injector) {
-    const dataService = injector.get(NotificationManagementService);
-    const entityDef = {
-        module: 'notification-management',
-        name: 'notification',
-        source: 'notification-management.notification',
-        title: 't("notifications",{scope: "notification-management"})',
-        formats: {
-            individual: 't("notifications",{scope: "notification-management"})',
-            plural: 't("notifications",{scope: "notification-management"})',
-        },
-        relatedEntities: [
-            {
-                entity: 'notification-management.notificationLog',
-                columns: ['title', 'status'],
-            },
-        ],
-        groups: [
-            {
-                id: 'notification',
-                title: 'Notification',
-            },
-        ],
-        properties: [
-            {
-                name: 'name',
-                title: 'Name',
-                groupId: 'notification',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-            },
-            {
-                name: 'title',
-                title: 'Title',
-                groupId: 'notification',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-            },
-            {
-                name: 'body',
-                title: 'Body',
-                groupId: 'notification',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.richText,
-                    },
-                },
-            },
-            {
-                name: 'channel',
-                title: 'Channel',
-                groupId: 'notification',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-            },
-            {
-                name: 'user.name',
-                title: 'User Name',
-                groupId: 'notification',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                    },
-                },
-            },
-        ],
-        columns: [{ name: 'title' }, { name: 'body' }, { name: 'user.name' }, { name: 'channel' }],
-        queries: {
-            byKey: {
-                execute: async (id) => {
-                    return new Promise((resolve) => {
-                        setTimeout(async () => {
-                            const entity = await dataService.notificationDataProvider.getOne(id);
-                            resolve(entity);
-                        }, 500);
-                    });
-                },
-                type: AXPEntityQueryType.Single,
-            },
-            list: {
-                execute: async (e) => {
-                    const list = await dataService.notificationDataProvider.getAll();
-                    const sortedItems = applySortArray(list, e.sort);
-                    const filteredItems = applyFilterArray(sortedItems, e.filter ? [e.filter] : []);
-                    return Promise.resolve({
-                        total: filteredItems.length,
-                        items: filteredItems.slice(e.skip, (e.skip ?? 0) + (e.take ?? 0)),
-                    });
-                },
-                type: AXPEntityQueryType.List,
-            },
-        },
-        interfaces: {
-            master: {
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        {
-                            id: 'notification',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'user.name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'body',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'channel',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    actions: [],
-                },
-                list: {
-                    actions: [
-                        {
-                            title: 'Details',
-                            command: 'open-entity',
-                            priority: 'primary',
-                            type: 'view',
-                            scope: AXPEntityCommandScope.Individual,
-                        },
-                    ],
-                    views: [
-                        {
-                            name: 'all',
-                            title: 'All Items',
-                            fixed: true,
-                            columns: [],
-                            conditions: [],
-                            sorts: [],
-                        },
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var notification_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    notificationEntityFactory: notificationEntityFactory
-});
-
 /**
  * Generated bundle index. Do not edit.
  */