@acorex/modules 19.1.2 → 19.1.4

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

@@ -1,11 +1,11 @@
 import * as i1$1 from '@acorex/platform/common';
-import { AXPSettingValueProviderService, AXP_SETTING_DEFINITION_PROVIDER, AXPComponentSlotModule, AXMEntityCrudServiceImpl, AXPEntityQueryType, AXPEntityCommandScope, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXPSettingScope, AXPSettingValueProviderService, 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 i0 from '@angular/core';
 import { inject, Injector, Injectable, signal, Component, NgModule } from '@angular/core';
-import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import { objectKeyValueTransforms, AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
 import { AXTranslationService } from '@acorex/core/translation';
-import { signalStore, withState, withMethods, patchState } from '@ngrx/signals';
+import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
 import * as i3 from '@acorex/components/button';
 import { AXButtonModule } from '@acorex/components/button';
 import * as i2 from '@acorex/components/decorators';
@@ -14,6 +14,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 { AXPSessionService } from '@acorex/platform/auth';
 
 class AXMCommonModuleEntityProvider {
     constructor() {
@@ -34,7 +35,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
-const path = 'settings:regional:';
+const path$1 = 'settings:regional:';
 var AXPRegionalSetting;
 (function (AXPRegionalSetting) {
     AXPRegionalSetting["TimeZone"] = "settings:regional:timezone";
@@ -50,91 +51,51 @@ var AXPRegionalSetting;
     AXPRegionalSetting["LongTime"] = "settings:regional:long-time";
 })(AXPRegionalSetting || (AXPRegionalSetting = {}));
 
-// ThemeStore - Manages theme settings and system changes
-const AXPRegionalStoreService = signalStore({ providedIn: 'root' }, 
-// Initial State
-withState((translationService = inject(AXTranslationService)) => {
-    const state = {
-        language: translationService.getDefaultLang(),
-    };
-    return state;
-}), 
-// Computed Signals
-// withComputed(({ }) => ({
-// })),
-// Methods for State Management
-withMethods((store, settingService = inject(AXPSettingValueProviderService), translationService = inject(AXTranslationService)) => {
-    return {
-        changeLanguage(lang) {
-            settingService.set(AXPRegionalSetting.Language, lang);
-            translationService.setActiveLang(lang);
-            patchState(store, { language: lang });
-        },
-        async loadSetting() {
-            const lang = (await settingService.get(AXPRegionalSetting.Language)) ?? translationService.getDefaultLang();
-            settingService.set(AXPRegionalSetting.Language, lang);
-            translationService.setActiveLang(lang);
-            patchState(store, { language: lang });
-        },
-        async getCountries() {
-            const { countries } = await import('./acorex-modules-platform-management-countries-CuJVdPLt.mjs');
-            return countries;
-        },
-        async getTimeZones() {
-            const { timeZones } = await Promise.resolve().then(function () { return timezones; });
-            return timeZones;
-        },
-        async getCurrencies() {
-            const { currencies } = await import('./acorex-modules-platform-management-currencies-vgPg4Hj3.mjs');
-            return currencies;
-        },
-        async getRegionalFormats() {
-            const { regionalFormats } = await import('./acorex-modules-platform-management-regional-formats-BSMV12dQ.mjs');
-            return regionalFormats;
-        },
-        async getLanguages() {
-            return (await this.getRegionalFormats())
-                .map(c => ({ code: c.locale, title: c.title }));
-        },
-        async getAvailableLanguages() {
-            return (await this.getLanguages()).filter(c => ['fa-IR', 'en-US'].some(e => e == c.code));
-        }
-    };
-}));
-
-const timeZones = [
-    { code: 'UTC-5', title: 'UTC-5 (Eastern Time)', offset: '-05:00' },
-    { code: 'UTC+0', title: 'UTC+0 (Greenwich Mean Time)', offset: '+00:00' },
-    { code: 'UTC+1', title: 'UTC+1 (Central European Time)', offset: '+01:00' },
-    { code: 'UTC+2', title: 'UTC+2 (Eastern European Time)', offset: '+02:00' },
-    { code: 'UTC+3', title: 'UTC+3 (Arabian Time)', offset: '+03:00' },
-    { code: 'UTC+3:30', title: 'UTC+3:30 (Iran Standard Time)', offset: '+03:30' },
-    { code: 'UTC+4', title: 'UTC+4 (Gulf Standard Time)', offset: '+04:00' },
-    { code: 'UTC+9', title: 'UTC+9 (Japan Standard Time)', offset: '+09:00' },
-    { code: 'UTC+10', title: 'UTC+10 (Australian Eastern Time)', offset: '+10:00' },
-    { code: 'UTC+12', title: 'UTC+12 (New Zealand Standard Time)', offset: '+12:00' }
-];
-
-var timezones = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    timeZones: timeZones
-});
-
-async function getBrowserTimeZoneCode() {
-    const now = new Date();
-    // Calculate offset in hours and minutes
-    const offsetMinutes = now.getTimezoneOffset();
-    const offsetHours = Math.floor(-offsetMinutes / 60);
-    const offsetRemainder = Math.abs(offsetMinutes % 60);
-    // Format the offset properly
-    const formattedOffset = `UTC${offsetHours >= 0 ? '+' : ''}${offsetHours}${offsetRemainder ? `:${offsetRemainder.toString().padStart(2, '0')}` : ''}`;
-    // Find matching time zone
-    const matchedZone = timeZones.find(zone => zone.code === formattedOffset);
-    return matchedZone ? matchedZone.code : 'UTC';
+class AXPRegionalService {
+    async getCountries() {
+        const { countries } = await import('./acorex-modules-platform-management-countries-CuJVdPLt.mjs');
+        return countries;
+    }
+    async getCurrencies() {
+        const { currencies } = await import('./acorex-modules-platform-management-currencies-vgPg4Hj3.mjs');
+        return currencies;
+    }
+    async getRegionalFormats() {
+        const { regionalFormats } = await import('./acorex-modules-platform-management-regional-formats-BaHofjWg.mjs');
+        return regionalFormats;
+    }
+    async getLanguages() {
+        return (await this.getRegionalFormats())
+            .map(c => ({ code: c.locale, title: c.title }));
+    }
+    async getAvailableLanguages() {
+        return (await this.getLanguages()).filter(c => ['fa-IR', 'en-US'].some(e => e == c.code));
+    }
+    async getBrowserTimeZoneCode() {
+        const { timeZones } = await import('./acorex-modules-platform-management-timezones-BoScbn0h.mjs');
+        const now = new Date();
+        // Calculate offset in hours and minutes
+        const offsetMinutes = now.getTimezoneOffset();
+        const offsetHours = Math.floor(-offsetMinutes / 60);
+        const offsetRemainder = Math.abs(offsetMinutes % 60);
+        // Format the offset properly
+        const formattedOffset = `UTC${offsetHours >= 0 ? '+' : ''}${offsetHours}${offsetRemainder ? `:${offsetRemainder.toString().padStart(2, '0')}` : ''}`;
+        // Find matching time zone
+        const matchedZone = timeZones.find(zone => zone.code === formattedOffset);
+        return matchedZone ? matchedZone.code : 'UTC';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPRegionalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPRegionalService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPRegionalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXMRegionalSettingProvider {
     constructor() {
-        this.store = inject(AXPRegionalStoreService);
+        this.translationService = inject(AXTranslationService);
+        this.regionalService = inject(AXPRegionalService);
     }
     async provide(context) {
         context
@@ -144,81 +105,85 @@ class AXMRegionalSettingProvider {
             .addSetting({
             key: AXPRegionalSetting.TimeZone,
             title: 'Time Zone',
-            scope: 'G',
-            defaultValue: await getBrowserTimeZoneCode(),
+            scope: 'T',
+            isInherited: true,
+            defaultValue: await this.regionalService.getBrowserTimeZoneCode(),
+            valueTransforms: objectKeyValueTransforms('code'),
             widget: {
                 type: AXPWidgetsCatalog.select,
                 options: {
                     valueField: 'code',
-                    dataSource: await this.store.getTimeZones(),
+                    dataSource: await import('./acorex-modules-platform-management-timezones-BoScbn0h.mjs'),
                 },
             },
             description: 'Set the default time zone for the application.',
         })
             .endSection()
-            // Language Section
-            .addSection('language', 'Language', 'Configure display language settings.')
+            // Region Section
+            .addSection('region', 'Region', 'Configure regional format and preferences.')
             .addSetting({
             key: AXPRegionalSetting.Language,
             title: 'Display Language',
             scope: 'U',
+            isInherited: true,
             defaultValue: 'en-US',
+            valueTransforms: objectKeyValueTransforms('code'),
             widget: {
                 type: AXPWidgetsCatalog.select,
                 options: {
                     valueField: 'code',
-                    dataSource: await this.store.getAvailableLanguages(),
+                    dataSource: await this.regionalService.getAvailableLanguages(),
                 },
             },
             description: 'Set the preferred display language for the user.',
-        })
-            .endSection()
-            // Region Section
-            .addSection('region', 'Region', 'Configure regional format and preferences.')
-            .addSetting({
-            key: AXPRegionalSetting.Country,
-            title: 'Country',
-            scope: 'G',
-            defaultValue: 'US',
-            widget: {
-                type: AXPWidgetsCatalog.select,
-                options: {
-                    valueField: 'code',
-                    dataSource: await this.store.getCountries(),
-                },
-            },
-            description: 'Set the default country for the application.',
         })
             .addSetting({
             key: AXPRegionalSetting.Regional,
             title: 'Regional Format',
             scope: 'U',
-            defaultValue: 'English (United States)',
+            isInherited: true,
+            defaultValue: await this.translationService.getDefaultLang(),
+            valueTransforms: objectKeyValueTransforms('locale'),
             widget: {
                 type: AXPWidgetsCatalog.select,
                 options: {
-                    dataSource: ['English (United States)', 'English (United Kingdom)', 'French (France)', 'German (Germany)'],
+                    valueField: 'locale',
+                    dataSource: await import('./acorex-modules-platform-management-regional-formats-BaHofjWg.mjs'),
                 },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.Language}') }}`,
+                        action: `{{ widget.setValue(context.eval('${AXPRegionalSetting.Language}')) }}`,
+                    },
+                ],
             },
             description: 'Set the regional format for numbers, dates, and times.',
         })
             .addSetting({
             key: AXPRegionalSetting.Calendar,
             title: 'Calendar',
-            scope: 'G',
+            scope: 'U',
+            isInherited: true,
             defaultValue: 'Gregorian',
             widget: {
                 type: AXPWidgetsCatalog.select,
                 options: {
                     dataSource: ['Gregorian', 'Hijri'],
                 },
+                triggers: [
+                    {
+                        event: `{{ events.context('${AXPRegionalSetting.Regional}') }}`,
+                        action: `{{ console.log(widget.find('${AXPRegionalSetting.Regional}').output('selectedItems')[0]) }}`,
+                    },
+                ],
             },
             description: 'Select the calendar type for the application.',
         })
             .addSetting({
             key: AXPRegionalSetting.FirstDayOfWeek,
             title: 'First Day of Week',
-            scope: 'U',
+            scope: 'T',
+            isInherited: false,
             defaultValue: 'Monday',
             widget: {
                 type: AXPWidgetsCatalog.select,
@@ -231,7 +196,8 @@ class AXMRegionalSettingProvider {
             .addSetting({
             key: AXPRegionalSetting.WorkDays,
             title: 'Work Days',
-            scope: 'U',
+            scope: 'T',
+            isInherited: false,
             defaultValue: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'],
             widget: {
                 type: AXPWidgetsCatalog.selectionList,
@@ -246,6 +212,7 @@ class AXMRegionalSettingProvider {
             key: AXPRegionalSetting.ShortDate,
             title: 'Short Date Format',
             scope: 'U',
+            isInherited: true,
             defaultValue: 'MM/dd/yyyy',
             widget: {
                 type: AXPWidgetsCatalog.select,
@@ -259,6 +226,7 @@ class AXMRegionalSettingProvider {
             key: AXPRegionalSetting.LongDate,
             title: 'Long Date Format',
             scope: 'U',
+            isInherited: true,
             defaultValue: 'MMMM dd, yyyy',
             widget: {
                 type: AXPWidgetsCatalog.select,
@@ -272,6 +240,7 @@ class AXMRegionalSettingProvider {
             key: AXPRegionalSetting.ShortTime,
             title: 'Short Time Format',
             scope: 'U',
+            isInherited: true,
             defaultValue: 'hh:mm a',
             widget: {
                 type: AXPWidgetsCatalog.select,
@@ -289,6 +258,7 @@ class AXMRegionalSettingProvider {
             key: AXPRegionalSetting.LongTime,
             title: 'Long Time Format',
             scope: 'U',
+            isInherited: true,
             defaultValue: 'hh:mm:ss a',
             widget: {
                 type: AXPWidgetsCatalog.select,
@@ -307,13 +277,56 @@ class AXMRegionalSettingProvider {
     }
 }
 
+// ThemeStore - Manages theme settings and system changes
+const AXPRegionalStoreService = signalStore({ providedIn: 'root' }, 
+// Initial State
+withState((translationService = inject(AXTranslationService)) => {
+    const state = {
+        language: translationService.getDefaultLang(),
+    };
+    return state;
+}), 
+// Computed Signals
+// withComputed(({ }) => ({
+// })),
+// Methods for State Management
+withMethods((store, settingService = inject(AXPSettingValueProviderService), translationService = inject(AXTranslationService), regionalService = inject(AXPRegionalService)) => {
+    return {
+        async changeLanguage(lang) {
+            if (lang != store.language()) {
+                settingService.scope(AXPSettingScope.User).set(AXPRegionalSetting.Language, lang);
+                patchState(store, { language: lang });
+            }
+            translationService.setActiveLang(lang);
+            const reg = await (await regionalService.getRegionalFormats()).find(c => c.locale == lang);
+            const html = document.getElementsByTagName('html')[0];
+            reg?.layout == 'rtl' ? html.setAttribute('dir', 'rtl') : html.removeAttribute('dir');
+        },
+        async loadSetting() {
+            const lang = (await settingService.get(AXPRegionalSetting.Language)) ?? translationService.getDefaultLang();
+            await this.changeLanguage(lang);
+        },
+    };
+}), withHooks((store, settingService = inject(AXPSettingValueProviderService)) => ({
+    onInit() {
+        settingService.onChanged.subscribe(async (setting) => {
+            if (setting.keys.includes(AXPRegionalSetting.Language)) {
+                await store.loadSetting();
+            }
+        });
+    },
+    onDestroy() {
+    },
+})));
+
 class AXMLanguageSlotComponent {
     constructor() {
+        this.regionalService = inject(AXPRegionalService);
         this.store = inject(AXPRegionalStoreService);
         this.items = signal([]);
     }
     async ngOnInit() {
-        const items = await this.store.getAvailableLanguages();
+        const items = await this.regionalService.getAvailableLanguages();
         this.items.set(items);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMLanguageSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
@@ -324,6 +337,203 @@ 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 = 'settings:organization:';
+var AXPOrganizationSetting;
+(function (AXPOrganizationSetting) {
+    AXPOrganizationSetting["OrganizationName"] = "settings:organization:organization-name";
+    AXPOrganizationSetting["OrganizationID"] = "settings:organization:organization-id";
+    AXPOrganizationSetting["ContactEmail"] = "settings:organization:contact-email";
+    AXPOrganizationSetting["ContactPhone"] = "settings:organization:contact-phone";
+    AXPOrganizationSetting["OrganizationAddress"] = "settings:organization:organization-address";
+    AXPOrganizationSetting["OrganizationCity"] = "settings:organization:organization-city";
+    AXPOrganizationSetting["OrganizationCountry"] = "settings:organization:organization-country";
+    AXPOrganizationSetting["BrandingColor"] = "settings:organization:branding-color";
+    AXPOrganizationSetting["BrandingLogo"] = "settings:organization:branding-logo";
+    AXPOrganizationSetting["CopyrightText"] = "settings:organization:copyright-text";
+    AXPOrganizationSetting["ApplicationHeaderTitle"] = "settings:organization:application-header-title";
+    AXPOrganizationSetting["SupportEmail"] = "settings:organization:support-email";
+    AXPOrganizationSetting["InfoEmail"] = "settings:organization:info-email";
+    AXPOrganizationSetting["FaxNumber"] = "settings: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);
@@ -348,6 +558,11 @@ class AXMPlatformManagementCommonModule {
                 useClass: AXMRegionalSettingProvider,
                 multi: true
             },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMOrganizationSettingProvider,
+                multi: true
+            },
         ], imports: [AXPComponentSlotModule.forChild({
                 'header-end': [
                     {
@@ -383,6 +598,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXMRegionalSettingProvider,
                             multi: true
                         },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMOrganizationSettingProvider,
+                            multi: true
+                        },
                     ],
                 }]
         }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
@@ -464,7 +684,7 @@ async function globalVariableEntityFactory(injector) {
                 ],
             },
             {
-                name: 'dataValue',
+                name: 'value',
                 title: 'Data Value',
                 groupId: 'section',
                 schema: {
@@ -510,11 +730,11 @@ async function globalVariableEntityFactory(injector) {
                 ],
             },
         ],
-        columns: [{ name: 'title' }, { name: 'dataValue' }, { name: 'dataType' }],
+        columns: [{ name: 'title' }, { name: 'value' }, { name: 'dataType' }],
         commands: {
             create: {
                 execute: async (data) => {
-                    return Promise.resolve(dataService.insertOne(data));
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
                 },
             },
             delete: {
@@ -585,7 +805,7 @@ async function globalVariableEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'dataValue',
+                            name: 'value',
                             layout: {
                                 positions: {
                                     lg: {
@@ -634,7 +854,7 @@ async function globalVariableEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'dataValue',
+                            name: 'value',
                             layout: {
                                 positions: {
                                     lg: {
@@ -684,7 +904,7 @@ async function globalVariableEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'dataValue',
+                            name: 'value',
                             layout: {
                                 positions: {
                                     lg: {
@@ -782,15 +1002,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
 class AXMPlatformManagmentModuleMenuProvider {
     constructor() {
         this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
     }
     async provide(context) {
         const scope = AXMPlatformManagementModuleConst.i18n;
+        const appName = this.sessionService.application?.name;
         context.addItems([
             {
                 name: 'administration-group',
                 priority: 2000,
                 text: `t('administration',{scope: "${scope}"})`,
                 type: 'group',
+                data: {
+                // requiredPermission: 'admin',
+                },
+            },
+            {
+                name: 'tenant-application-settings',
+                priority: 10000,
+                text: `t('settings.tenant.title', {scope: "${scope}"})`,
+                type: 'menu',
+                icon: 'fa-solid fa-gear',
+                path: `/${appName}/settings/tenant`,
                 data: {
                     requiredPermission: 'admin',
                 },
@@ -801,7 +1034,7 @@ class AXMPlatformManagmentModuleMenuProvider {
                 type: 'menu',
                 priority: 9100,
                 data: {
-                // requiredPermission: 'demo.admin.settings',
+                    requiredPermission: 'platform',
                 },
                 children: [
                     {