@acorex/modules 19.1.10 → 19.1.12

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

@@ -607,20 +607,339 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
 
-const AXMPlatformManagementModuleConst = {
-    moduleName: 'common',
-    moduleRoute: 'platform-management',
+const config = {
     i18n: 'platform-management',
-    localizationManagement: 'localization-management',
-    globalVariableEntity: 'variables',
-    textSearchEntity: 'text-search',
 };
+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',
+        },
+    },
+};
+
+class AXMAppVersionService extends AXMEntityCrudServiceImpl {
+}
+class AXMAppVersionServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.appVersion.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppVersionServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppVersionServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMAppVersionServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function appVersionEntityEntityFactory(injector) {
+    const dataService = injector.get(AXMAppVersionService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.appVersion.name,
+        source: '',
+        title: RootConfig.entities.appVersion.title,
+        formats: {
+            individual: 'Application Version',
+            plural: 'Application Versions',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.appVersion.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'versionNumber',
+                title: 'Version Number',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'changeLog',
+                title: 'Change Log',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            multiple: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'publishDate',
+                title: 'Publish Date',
+                groupId: 'section',
+                schema: {
+                    dataType: 'dateTime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'versionNumber' }, { name: 'changeLog' }, { name: 'publishDate' }],
+        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: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{versionNumber}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    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 AXMGlobalVariablesService extends AXMEntityCrudServiceImpl {
 }
 class AXMGlobalVariablesServiceImpl extends AXMEntityCrudServiceImpl {
     constructor() {
-        super(`${AXMPlatformManagementModuleConst.moduleName}.${AXMPlatformManagementModuleConst.globalVariableEntity}`);
+        super(`${RootConfig.module.name}.${RootConfig.entities.globalVariable.name}`);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMGlobalVariablesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMGlobalVariablesServiceImpl }); }
@@ -631,9 +950,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
 
 async function globalVariableEntityFactory(injector) {
     const dataService = injector.get(AXMGlobalVariablesService);
+    const i18n = RootConfig.config.i18n;
     const entityDef = {
-        module: AXMPlatformManagementModuleConst.moduleName,
-        name: AXMPlatformManagementModuleConst.globalVariableEntity,
+        module: RootConfig.module.name,
+        name: RootConfig.entities.globalVariable.name,
         source: '',
         title: 'Global Variable',
         formats: {
@@ -650,7 +970,7 @@ async function globalVariableEntityFactory(injector) {
         properties: [
             {
                 name: 'name',
-                title: 'Name',
+                title: `t("name", { scope: "${i18n}" })`,
                 groupId: 'section',
                 schema: {
                     dataType: 'string',
@@ -666,7 +986,7 @@ async function globalVariableEntityFactory(injector) {
             },
             {
                 name: 'title',
-                title: 'Title',
+                title: `t("title", { scope: "${i18n}" })`,
                 groupId: 'section',
                 schema: {
                     dataType: 'string',
@@ -682,7 +1002,7 @@ async function globalVariableEntityFactory(injector) {
             },
             {
                 name: 'value',
-                title: 'Data Value',
+                title: `t("value", { scope: "${i18n}" })`,
                 groupId: 'section',
                 schema: {
                     dataType: 'string',
@@ -698,7 +1018,7 @@ async function globalVariableEntityFactory(injector) {
             },
             {
                 name: 'dataType',
-                title: 'Data Type',
+                title: `t("dataType", { scope: "${i18n}" })`,
                 groupId: 'section',
                 schema: {
                     dataType: 'string',
@@ -727,7 +1047,7 @@ async function globalVariableEntityFactory(injector) {
                 ],
             },
         ],
-        columns: [{ name: 'title' }, { name: 'value' }, { name: 'dataType' }],
+        columns: [{ name: 'title' }, { name: 'dataType' }, { name: 'value' }],
         commands: {
             create: {
                 execute: async (data) => {
@@ -926,28 +1246,28 @@ async function globalVariableEntityFactory(injector) {
                 list: {
                     actions: [
                         {
-                            title: 'Create New',
+                            title: `t("create", { scope: "common" })`,
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: 'Delete Items',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: 'Details',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: 'Delete',
+                            title: 't("delete", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'secondary',
                             type: 'delete',
@@ -957,7 +1277,7 @@ async function globalVariableEntityFactory(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: 'All Items',
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -971,28 +1291,52 @@ async function globalVariableEntityFactory(injector) {
     return entityDef;
 }
 
-var globalVariable_entity = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    AXMAppVersionService: AXMAppVersionService,
+    AXMAppVersionServiceImpl: AXMAppVersionServiceImpl,
+    AXMGlobalVariablesService: AXMGlobalVariablesService,
+    AXMGlobalVariablesServiceImpl: AXMGlobalVariablesServiceImpl,
+    appVersionEntityEntityFactory: appVersionEntityEntityFactory,
     globalVariableEntityFactory: globalVariableEntityFactory
 });
 
-class AXMGlobalVariableModuleEntityLoader {
+class AXMEntityLoader {
     constructor() {
         this.injector = inject(Injector);
     }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
     async get(moduleName, entityName) {
-        switch (entityName) {
-            case AXMPlatformManagementModuleConst.globalVariableEntity: {
-                const entity = (await Promise.resolve().then(function () { return globalVariable_entity; })).globalVariableEntityFactory;
-                return entity(this.injector);
-            }
+        if (moduleName == RootConfig.module.name) {
+            return new Promise(async (resolve) => {
+                switch (entityName) {
+                    case RootConfig.entities.globalVariable.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).globalVariableEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.appVersion.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).appVersionEntityEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    default:
+                        resolve(null);
+                }
+            });
         }
         return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityLoader, decorators: [{
             type: Injectable
         }] });
 
@@ -1002,7 +1346,7 @@ class AXMMenuProvider {
         this.sessionService = inject(AXPSessionService);
     }
     async provide(context) {
-        const scope = AXMPlatformManagementModuleConst.i18n;
+        const scope = RootConfig.config.i18n;
         const appName = this.sessionService.application?.name;
         context.addItems([
             {
@@ -1037,8 +1381,17 @@ class AXMMenuProvider {
                     {
                         priority: 9001,
                         text: `t('globalVariables', {scope: "${scope}"})`,
-                        path: this.entityService.createPath(AXMPlatformManagementModuleConst.moduleName, AXMPlatformManagementModuleConst.globalVariableEntity),
-                        icon: 'fa-solid fa-object-exclude',
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.globalVariable.name),
+                        icon: RootConfig.entities.globalVariable.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9002,
+                        text: `t('appVersion', {scope: "${scope}"})`,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.appVersion.name),
+                        icon: RootConfig.entities.appVersion.icon,
                         data: {
                         // requiredPermission: '',
                         },
@@ -1057,9 +1410,13 @@ class AXMPlatformManagementModule {
                 provide: AXMGlobalVariablesService,
                 useClass: AXMGlobalVariablesServiceImpl,
             },
+            {
+                provide: AXMAppVersionService,
+                useClass: AXMAppVersionServiceImpl,
+            },
             {
                 provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMGlobalVariableModuleEntityLoader,
+                useClass: AXMEntityLoader,
                 multi: true,
             },
             {
@@ -1080,9 +1437,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             provide: AXMGlobalVariablesService,
                             useClass: AXMGlobalVariablesServiceImpl,
                         },
+                        {
+                            provide: AXMAppVersionService,
+                            useClass: AXMAppVersionServiceImpl,
+                        },
                         {
                             provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMGlobalVariableModuleEntityLoader,
+                            useClass: AXMEntityLoader,
                             multi: true,
                         },
                         {
@@ -1098,5 +1459,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXMCommonModuleEntityProvider, AXMGlobalVariableModuleEntityLoader, AXMGlobalVariablesService, AXMGlobalVariablesServiceImpl, AXMPlatformManagementModule, AXMPlatformManagementModuleConst, globalVariableEntityFactory };
+export { AXMCommonModuleEntityProvider, AXMPlatformManagementModule, RootConfig };
 //# sourceMappingURL=acorex-modules-platform-management.mjs.map