@acorex/modules 19.1.13 → 19.1.14

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

@@ -1,6 +1,8 @@
 import * as i1$1 from '@acorex/platform/common';
 import { AXPSettingScope, AXPSettingService, AXP_SETTING_DEFINITION_PROVIDER, AXPComponentSlotModule, AXMEntityCrudServiceImpl, AXPEntityQueryType, AXPEntityCommandScope, AXP_MENU_PROVIDER } from '@acorex/platform/common';
 import { AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
+import * as i1$2 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
 import * as i0 from '@angular/core';
 import { inject, Injector, Injectable, signal, Component, NgModule } from '@angular/core';
 import { objectKeyValueTransforms, AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
@@ -14,6 +16,7 @@ import * as i1 from '@acorex/components/dropdown';
 import { AXDropdownModule } from '@acorex/components/dropdown';
 import { AXPopoverModule } from '@acorex/components/popover';
 import { CommonModule } from '@angular/common';
+import { AXPopupService } from '@acorex/components/popup';
 import { AXPSessionService } from '@acorex/platform/auth';
 
 class AXMCommonModuleEntityProvider {
@@ -35,7 +38,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
-const path$1 = 'regional:';
+const path = 'regional:';
 var AXPRegionalSetting;
 (function (AXPRegionalSetting) {
     AXPRegionalSetting["TimeZone"] = "regional:timezone";
@@ -337,203 +340,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ imports: [AXDropdownModule, AXDecoratorModule, AXPopoverModule, AXButtonModule, CommonModule], template: "<ax-button look=\"blank\">\n  <ax-icon class=\"fa-regular fa-globe\"> </ax-icon>\n  <ax-dropdown-panel>\n    <ax-button-item-list>\n      @for(lang of items(); track lang){\n      <ax-button-item [text]=\"lang.title\" [selected]=\"store.language()===lang.code\"\n        (onClick)=\"store.changeLanguage(lang.code)\">\n        <ax-prefix>\n          <ax-icon icon=\"fa-solid fa-flag\"> </ax-icon>\n        </ax-prefix>\n      </ax-button-item>\n      }\n    </ax-button-item-list>\n  </ax-dropdown-panel>\n</ax-button>" }]
         }] });
 
-const path = 'organization:';
-var AXPOrganizationSetting;
-(function (AXPOrganizationSetting) {
-    AXPOrganizationSetting["OrganizationName"] = "organization:organization-name";
-    AXPOrganizationSetting["OrganizationID"] = "organization:organization-id";
-    AXPOrganizationSetting["ContactEmail"] = "organization:contact-email";
-    AXPOrganizationSetting["ContactPhone"] = "organization:contact-phone";
-    AXPOrganizationSetting["OrganizationAddress"] = "organization:organization-address";
-    AXPOrganizationSetting["OrganizationCity"] = "organization:organization-city";
-    AXPOrganizationSetting["OrganizationCountry"] = "organization:organization-country";
-    AXPOrganizationSetting["BrandingColor"] = "organization:branding-color";
-    AXPOrganizationSetting["BrandingLogo"] = "organization:branding-logo";
-    AXPOrganizationSetting["CopyrightText"] = "organization:copyright-text";
-    AXPOrganizationSetting["ApplicationHeaderTitle"] = "organization:application-header-title";
-    AXPOrganizationSetting["SupportEmail"] = "organization:support-email";
-    AXPOrganizationSetting["InfoEmail"] = "organization:info-email";
-    AXPOrganizationSetting["FaxNumber"] = "organization:fax-number";
-})(AXPOrganizationSetting || (AXPOrganizationSetting = {}));
-
-class AXMOrganizationSettingProvider {
-    constructor() {
-        this.sessionService = inject(AXPSessionService);
-    }
-    async provide(context) {
-        context
-            .addGroup('organization-settings', 'Organization Settings', 'Manage organizational preferences.', 'fa-solid fa-building')
-            // Branding Section
-            .addSection('branding', 'Branding', 'Configure company branding.')
-            .addSetting({
-            key: AXPOrganizationSetting.OrganizationName,
-            title: 'Company Name',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: this.sessionService.tenant?.title,
-            widget: {
-                type: AXPWidgetsCatalog.text,
-            },
-            description: 'Specify the official name of the company.',
-        })
-            .addSetting({
-            key: 'branding-logo',
-            title: 'Company Logo',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.avatar,
-                options: {
-                    fileTypes: ['image/png', 'image/jpeg'],
-                },
-            },
-            description: 'Upload the company logo.',
-        })
-            .addSetting({
-            key: 'copyright-text',
-            title: 'Copyright Text',
-            scope: 'T',
-            isInherited: true,
-            defaultValue: '© 2024 Your Company',
-            widget: {
-                type: AXPWidgetsCatalog.text,
-            },
-            description: 'Text displayed in the footer of the application.',
-        })
-            .addSetting({
-            key: 'application-header-title',
-            title: 'Application Header Title',
-            scope: 'T',
-            isInherited: true,
-            defaultValue: this.sessionService.application?.title,
-            widget: {
-                type: AXPWidgetsCatalog.text,
-            },
-            description: 'Title displayed in the application header.',
-        })
-            .endSection()
-            // Contact Details Section
-            .addSection('contact', 'Contact Details', 'Set company contact information.')
-            .addSetting({
-            key: AXPOrganizationSetting.ContactEmail,
-            title: 'Company Email',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.contact,
-                options: {
-                    type: 'email',
-                    hasLabel: false,
-                }
-            },
-            description: 'Primary email address for the company.',
-        })
-            .addSetting({
-            key: 'support-email',
-            title: 'Support Email',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.contact,
-                options: {
-                    type: 'email',
-                    hasLabel: false,
-                }
-            },
-            description: 'Support email address for customer inquiries.',
-        })
-            .addSetting({
-            key: 'info-email',
-            title: 'Info Email',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.contact,
-                options: {
-                    type: 'email',
-                    hasLabel: false,
-                }
-            },
-            description: 'General information email address.',
-        })
-            .addSetting({
-            key: AXPOrganizationSetting.ContactPhone,
-            title: 'Company Phone',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.contact,
-                options: {
-                    type: 'phone',
-                    hasLabel: false,
-                }
-            },
-            description: 'Primary contact phone number.',
-        })
-            .addSetting({
-            key: 'fax-number',
-            title: 'Fax Number',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.contact,
-                options: {
-                    type: 'phone',
-                    hasLabel: false,
-                }
-            },
-            description: 'Fax number for the company.',
-        })
-            .endSection()
-            // Address Section
-            .addSection('address', 'Address', 'Manage company address details.')
-            .addSetting({
-            key: AXPOrganizationSetting.OrganizationAddress,
-            title: 'Street Address',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.text,
-            },
-            description: 'Street address of the company.',
-        })
-            .addSetting({
-            key: AXPOrganizationSetting.OrganizationCity,
-            title: 'City',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.text,
-            },
-            description: 'City where the company is located.',
-        })
-            .addSetting({
-            key: AXPOrganizationSetting.OrganizationCountry,
-            title: 'Country',
-            scope: 'T',
-            isInherited: false,
-            defaultValue: '',
-            widget: {
-                type: AXPWidgetsCatalog.select,
-                options: {
-                    dataSource: ['United States', 'United Kingdom', 'France', 'Germany', 'Japan', 'China'],
-                },
-            },
-            description: 'Country where the company is based.',
-        })
-            .endSection()
-            .endGroup();
-    }
-}
-
 class AXMPlatformManagementCommonModule {
     constructor(appInitService, injector) {
         const service = injector.get(AXPRegionalStoreService);
@@ -558,11 +364,6 @@ class AXMPlatformManagementCommonModule {
                 useClass: AXMRegionalSettingProvider,
                 multi: true
             },
-            {
-                provide: AXP_SETTING_DEFINITION_PROVIDER,
-                useClass: AXMOrganizationSettingProvider,
-                multi: true
-            },
         ], imports: [AXPComponentSlotModule.forChild({
                 'header-end': [
                     {
@@ -585,57 +386,496 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             ]
                         })
                     ],
-                    exports: [],
-                    declarations: [],
-                    providers: [
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMCommonModuleEntityProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMRegionalSettingProvider,
+                            multi: true
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
+
+const config = {
+    i18n: 'platform-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'platform-management',
+        name: 'PlatformManagement',
+        title: `t('module-name', {scope:"${config.i18n}"})`,
+        icon: 'fa-solid fa-cogs',
+    },
+    entities: {
+        localizationManagement: {
+            name: 'Localization Management',
+            title: `t("localization-management", {scope:"${config.i18n}"})`,
+            icon: 'fa-solid fa-globe',
+        },
+        globalVariable: {
+            name: 'Global Variables',
+            title: `t("variables", {scope:"${config.i18n}"})`,
+            icon: 'fa-solid fa-object-exclude',
+        },
+        appVersion: {
+            name: 'app-version',
+            title: `t("appVersion", {scope:"${config.i18n}"})`,
+            icon: 'fa-regular fa-code-branch',
+        },
+        appTerm: {
+            name: 'app-term',
+            title: `t("appTerm", {scope:"${config.i18n}"})`,
+            icon: 'fa-solid fa-scale-balanced',
+        },
+    },
+};
+
+class AXMAppTermService extends AXMEntityCrudServiceImpl {
+}
+class AXMAppTermServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.appTerm.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppTermServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppTermServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppTermServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function appTermEntityEntityFactory(injector) {
+    const dataService = injector.get(AXMAppTermService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.appTerm.name,
+        source: '',
+        title: RootConfig.entities.appTerm.title,
+        formats: {
+            individual: 'Application Term',
+            plural: 'Application Terms',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.appTerm.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 'Name',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'content',
+                title: 'Content',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'version',
+                title: 'Version',
+                groupId: 'section',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog.number,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'effectiveDate',
+                title: 'Effective Date',
+                groupId: 'section',
+                schema: {
+                    dataType: 'dateTime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'isActive',
+                title: 'Is Active',
+                groupId: 'section',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'title' },
+            { name: 'content' },
+            { name: 'version' },
+            { name: 'effectiveDate' },
+            { name: 'isActive' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        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) => {
+                    const x = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    console.log(x);
+                    return x;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isActive',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isActive',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{versionNumber}}',
+                    sections: [
                         {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMCommonModuleEntityProvider,
-                            multi: true,
+                            id: 'section',
                         },
+                    ],
+                    properties: [
                         {
-                            provide: AXP_SETTING_DEFINITION_PROVIDER,
-                            useClass: AXMRegionalSettingProvider,
-                            multi: true
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
                         },
                         {
-                            provide: AXP_SETTING_DEFINITION_PROVIDER,
-                            useClass: AXMOrganizationSettingProvider,
-                            multi: true
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isActive',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
                         },
                     ],
-                }]
-        }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
-
-const config = {
-    i18n: 'platform-management',
-};
-const RootConfig = {
-    config,
-    module: {
-        route: 'platform-management',
-        name: 'PlatformManagement',
-        title: `t('module-name', {scope:"${config.i18n}"})`,
-        icon: 'fa-solid fa-cogs',
-    },
-    entities: {
-        localizationManagement: {
-            name: 'Localization Management',
-            title: `t("localization-management", {scope:"${config.i18n}"})`,
-            icon: 'fa-solid fa-globe',
-        },
-        globalVariable: {
-            name: 'Global Variables',
-            title: `t("variables", {scope:"${config.i18n}"})`,
-            icon: 'fa-solid fa-object-exclude',
-        },
-        appVersion: {
-            name: 'app-version',
-            title: `t("appVersion", {scope:"${config.i18n}"})`,
-            icon: 'fa-regular fa-code-branch',
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Create New',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 'Delete Items',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
         },
-    },
-};
+    };
+    return entityDef;
+}
 
 class AXMAppVersionService extends AXMEntityCrudServiceImpl {
 }
@@ -720,8 +960,29 @@ async function appVersionEntityEntityFactory(injector) {
                     },
                 ],
             },
+            {
+                name: 'showFirstTimePopup',
+                title: 'Show First Time Popup',
+                groupId: 'section',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'versionNumber' },
+            { name: 'changeLog' },
+            { name: 'publishDate' },
+            { name: 'showFirstTimePopup' },
         ],
-        columns: [{ name: 'versionNumber' }, { name: 'changeLog' }, { name: 'publishDate' }],
         commands: {
             create: {
                 execute: async (data) => {
@@ -800,7 +1061,17 @@ async function appVersionEntityEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
                                     },
                                 },
                             },
@@ -839,7 +1110,17 @@ async function appVersionEntityEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
                                     },
                                 },
                             },
@@ -879,7 +1160,17 @@ async function appVersionEntityEntityFactory(injector) {
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
                                     },
                                 },
                             },
@@ -935,6 +1226,70 @@ async function appVersionEntityEntityFactory(injector) {
     return entityDef;
 }
 
+class AXMAppVersionTestComponent {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppVersionTestComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMAppVersionTestComponent, isStandalone: true, selector: "app-test", ngImport: i0, template: "<div>\n  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna\n  aliqua.\n</div>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppVersionTestComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-test', template: "<div>\n  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna\n  aliqua.\n</div>\n" }]
+        }], ctorParameters: () => [] });
+
+class AXMChangeLogPopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+    }
+    async execute(context) {
+        // const data = context.getVariable<any>('data');
+        //const options = context.getVariable<any>('options');
+        const result = await this.popupService.open(AXMAppVersionTestComponent, 'test');
+        // context.setOutput('result', false);
+        // if (result.data?.save) {
+        context.setOutput('result', true);
+        //  const prevData = context.getVariable('data');
+        //  context.setVariable('data', { ...prevData, ...result.data.item });
+        // }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogPopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogPopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogPopupAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMChangeLogUpdateSettingAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.settingService = inject(AXPSettingService);
+    }
+    async execute(context) {
+        await this.settingService.scope(AXPSettingScope.User).set('is-see-check-version', true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMChangeLogWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXMChangeLogPopupAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'first-time-add-to-setting',
+                },
+            ],
+        },
+        'first-time-add-to-setting': {
+            action: 'AXMChangeLogUpdateSettingAction',
+        },
+    },
+};
+
 class AXMGlobalVariablesService extends AXMEntityCrudServiceImpl {
 }
 class AXMGlobalVariablesServiceImpl extends AXMEntityCrudServiceImpl {
@@ -1293,10 +1648,17 @@ async function globalVariableEntityFactory(injector) {
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    AXMAppTermService: AXMAppTermService,
+    AXMAppTermServiceImpl: AXMAppTermServiceImpl,
     AXMAppVersionService: AXMAppVersionService,
     AXMAppVersionServiceImpl: AXMAppVersionServiceImpl,
+    AXMAppVersionTestComponent: AXMAppVersionTestComponent,
+    AXMChangeLogPopupAction: AXMChangeLogPopupAction,
+    AXMChangeLogUpdateSettingAction: AXMChangeLogUpdateSettingAction,
+    AXMChangeLogWorkflow: AXMChangeLogWorkflow,
     AXMGlobalVariablesService: AXMGlobalVariablesService,
     AXMGlobalVariablesServiceImpl: AXMGlobalVariablesServiceImpl,
+    appTermEntityEntityFactory: appTermEntityEntityFactory,
     appVersionEntityEntityFactory: appVersionEntityEntityFactory,
     globalVariableEntityFactory: globalVariableEntityFactory
 });
@@ -1326,6 +1688,11 @@ class AXMEntityLoader {
                         resolve(entity(this.injector));
                         break;
                     }
+                    case RootConfig.entities.appTerm.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).appTermEntityEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
                     default:
                         resolve(null);
                 }
@@ -1380,7 +1747,7 @@ class AXMMenuProvider {
                 children: [
                     {
                         priority: 9001,
-                        text: `t('globalVariables', {scope: "${scope}"})`,
+                        text: RootConfig.entities.globalVariable.title,
                         path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.globalVariable.name),
                         icon: RootConfig.entities.globalVariable.icon,
                         data: {
@@ -1389,13 +1756,22 @@ class AXMMenuProvider {
                     },
                     {
                         priority: 9002,
-                        text: `t('appVersion', {scope: "${scope}"})`,
+                        text: RootConfig.entities.appVersion.title,
                         path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.appVersion.name),
                         icon: RootConfig.entities.appVersion.icon,
                         data: {
                         // requiredPermission: '',
                         },
                     },
+                    {
+                        priority: 9003,
+                        text: RootConfig.entities.appTerm.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.appTerm.name),
+                        icon: RootConfig.entities.appTerm.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
                 ],
             },
         ]);
@@ -1404,7 +1780,7 @@ class AXMMenuProvider {
 
 class AXMPlatformManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMPlatformManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMPlatformManagementModule, imports: [AXMPlatformManagementCommonModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMPlatformManagementModule, imports: [AXMPlatformManagementCommonModule, i1$2.AXPWorkflowModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMPlatformManagementModule, providers: [
             {
                 provide: AXMGlobalVariablesService,
@@ -1414,6 +1790,10 @@ class AXMPlatformManagementModule {
                 provide: AXMAppVersionService,
                 useClass: AXMAppVersionServiceImpl,
             },
+            {
+                provide: AXMAppTermService,
+                useClass: AXMAppTermServiceImpl,
+            },
             {
                 provide: AXP_ENTITY_DEFINITION_LOADER,
                 useClass: AXMEntityLoader,
@@ -1424,12 +1804,32 @@ class AXMPlatformManagementModule {
                 useClass: AXMMenuProvider,
                 multi: true,
             },
-        ], imports: [AXMPlatformManagementCommonModule] }); }
+        ], imports: [AXMPlatformManagementCommonModule,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXMChangeLogPopupAction,
+                    AXMChangeLogUpdateSettingAction,
+                },
+                workflows: {
+                    'change-log-version': AXMChangeLogWorkflow,
+                },
+            })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMPlatformManagementModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXMPlatformManagementCommonModule],
+                    imports: [
+                        AXMPlatformManagementCommonModule,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMChangeLogPopupAction,
+                                AXMChangeLogUpdateSettingAction,
+                            },
+                            workflows: {
+                                'change-log-version': AXMChangeLogWorkflow,
+                            },
+                        }),
+                    ],
                     exports: [],
                     declarations: [],
                     providers: [
@@ -1441,6 +1841,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             provide: AXMAppVersionService,
                             useClass: AXMAppVersionServiceImpl,
                         },
+                        {
+                            provide: AXMAppTermService,
+                            useClass: AXMAppTermServiceImpl,
+                        },
                         {
                             provide: AXP_ENTITY_DEFINITION_LOADER,
                             useClass: AXMEntityLoader,