@acorex/platform-generator 20.3.0-next.8 → 20.4.0

package/src/generators/app-module/files/src/app/modules/auth/auth-root.module.ts.template

@@ -1,26 +1,9 @@
 import { AXMAuthModule, AXMAuthenticationTypes, AXM_AUTH_CONFIG_TOKEN, configAuthModule } from '@acorex/modules/auth';
-import {
-  AXPAuthModule,
-  AXP_APPLICATION_LOADER,
-  AXP_FEATURE_LOADER,
-  AXP_PERMISSION_LOADER,
-  AXP_TENANT_LOADER,
-} from '@acorex/platform/auth';
 import { NgModule } from '@angular/core';
 import { environment } from '../../../environments/environment';
-import { <%= className %>ApplicationLoader } from './application.loader';
-import { <%= className %>Strategy } from './auth.strategy';
-import { <%= className %>FeatureLoader } from './feature.loader';
-import { <%= className %>PermissionLoader } from './permission.loader';
-import { <%= className %>TenantLoader } from './tenant.loader';
 
 @NgModule({
-  imports: [
-    AXMAuthModule,
-    AXPAuthModule.forRoot({
-      strategies: [<%= className %>Strategy],
-    }),
-  ],
+  imports: [AXMAuthModule],
   exports: [],
   providers: [
     {
@@ -28,6 +11,18 @@ import { <%= className %>TenantLoader } from './tenant.loader';
       useValue: configAuthModule({
         type: AXMAuthenticationTypes.UsernameEmailPassword,
         authConfig: { ...environment.oidcConfig },
+        baseUrl: environment.baseUrl,
+        logoutUrl: environment.logoutUrl,
+        signup: {
+          enable: true,
+          url: '/auth/register',
+        },
+        defaultStrategyName: 'user-pass',
+        externalProviders: {
+          google: {
+            providerName: 'google',
+          },
+        },
         signinPage: {
           description: `In this kind of post, the blogger introduces a person they've
           interviewed and provides some background information about the
@@ -37,22 +32,6 @@ import { <%= className %>TenantLoader } from './tenant.loader';
         },
       }),
     },
-    {
-      provide: AXP_TENANT_LOADER,
-      useClass: <%= className %>TenantLoader,
-    },
-    {
-      provide: AXP_APPLICATION_LOADER,
-      useClass: <%= className %>ApplicationLoader,
-    },
-    {
-      provide: AXP_PERMISSION_LOADER,
-      useClass: <%= className %>PermissionLoader,
-    },
-    {
-      provide: AXP_FEATURE_LOADER,
-      useClass: <%= className %>FeatureLoader,
-    },
   ],
 })
 export class <%= className %>AuthRootModule {}

package/src/generators/app-module/files/src/app/{app-version.provider.ts.template → modules/common/app-version.provider.ts.template}

@@ -1,5 +1,5 @@
 import { AXPAppVersion, AXPAppVersionProvider } from '@acorex/platform/common';
-import pkg from '../../../../package.json';
+import pkg from '../../../../../../package.json';
 
 export class <%= className %>AppVersionProvider implements AXPAppVersionProvider {
   provider(): Promise<AXPAppVersion> {
@@ -9,4 +9,6 @@ export class <%= className %>AppVersionProvider implements AXPAppVersionProvider
       date: new Date(),
     });
   }
-} 
+}
+
+

package/src/generators/app-module/files/src/app/modules/common/default-settings.providers.ts.template

@@ -0,0 +1,38 @@
+//#region ----   Imports   ----
+
+import { AXPRegionalSetting } from '@acorex/modules/locale-management';
+import {
+  AXP_SETTING_DEFAULT_VALUES_PROVIDERS,
+  AXPCommonSettings,
+  AXPSettingDefaultValuesProvider,
+} from '@acorex/platform/common';
+import { AXPThemeLayoutSetting } from '@acorex/platform/themes/shared';
+
+//#endregion
+
+//#region ----   App Default Settings Providers   ----
+
+export const APP_DEFAULT_SETTINGS_PROVIDER: AXPSettingDefaultValuesProvider = {
+  priority: 50,
+  async provide() {
+    return {
+      [AXPRegionalSetting.LocaleProfile]: 'en-US',
+      [AXPRegionalSetting.Language]: 'en-US',
+      [AXPRegionalSetting.TimeZone]: 'UTC',
+      [AXPRegionalSetting.FirstDayOfWeek]: 1,
+      [AXPThemeLayoutSetting.Palette]: 'golden-dusk',
+      [AXPThemeLayoutSetting.MenuBadgeVisible]: true,
+      [AXPCommonSettings.EnableOperationToasts]: true,
+    } as Record<string, unknown>;
+  },
+};
+
+export const APP_DEFAULT_SETTINGS_PROVIDERS = {
+  provide: AXP_SETTING_DEFAULT_VALUES_PROVIDERS,
+  useValue: APP_DEFAULT_SETTINGS_PROVIDER,
+  multi: true,
+};
+
+//#endregion
+
+

package/src/generators/app-module/files/src/app/modules/common/translation-root.module.ts.template

@@ -19,7 +19,8 @@ export class MyTranslationLoader implements AXTranslationLoader {
 
   load(options: AXTranslationLoaderOptions): Observable<AXTranslation> {
     try {
-      return this.http.get<AXTranslation>(`/assets/i18n/${options.lang}/${options.scope}.json`);
+      const scope = options.scope?.startsWith('general-') ? options.scope?.replace('-', '/') : options.scope;
+      return this.http.get<AXTranslation>(`/assets/i18n/${options.lang}/${scope}.json`);
     } catch (error) {
       console.error(error);
       return of({});
@@ -41,11 +42,11 @@ export class MyTranslationLoader implements AXTranslationLoader {
       useValue: translationConfig({
         preload: {
           langs: ['en-US'],
-          scopes: ['common'],
+          scopes: ['acorex', 'general'],
         },
         defaults: {
           lang: 'en-US',
-          scope: 'common',
+          scope: 'general',
         },
       }),
     },

package/src/generators/app-module/files/src/app/modules/layout/entity.loader.ts.template

@@ -1,22 +1,39 @@
+//#region ----   Imports   ----
+
 import { AXPEntity } from '@acorex/platform/common';
 import { AXPEntityDefinitionLoader } from '@acorex/platform/layout/entity';
 import { Injectable, Injector, inject } from '@angular/core';
+import { RootConfig } from '../<%= name %>/const';
+
+//#endregion
+
+//#region ----   Root Entity Loader   ----
 
+/**
+ * Entity definition loader for <%= className %> module entities
+ */
 @Injectable()
 export class AXPRootEntityLoader implements AXPEntityDefinitionLoader {
+  
+  //#region ----   Services   ----
+  
   private injector = inject(Injector);
+  
+  //#endregion
+
+  //#region ----   Get Method   ----
 
   async get(moduleName: string, entityName: string): Promise<AXPEntity | null> {
-    return new Promise(async (resolve) => {
+    if (moduleName === RootConfig.module.name) {
       switch (entityName) {
-        case 'sample': {
-          const entity = (await import('../<%= name %>/sample/sample.entity')).sampleFactory;
-          resolve(entity(this.injector) as any);
-          break;
-        }
-        default:
-          resolve(null);
+        case RootConfig.entities.sample.name:
+          return (await import('../<%= name %>/sample/sample.entity')).sampleFactory(this.injector);
       }
-    });
+    }
+    return null;
   }
+
+  //#endregion
 }
+
+//#endregion

package/src/generators/app-module/files/src/app/modules/layout/layout-root.module.ts.template

@@ -1,46 +1,44 @@
+import { AXMAppVersionSlotComponent } from '@acorex/modules/platform-management';
 import {
   AXPCommonModule,
   AXPFooterTextSlotComponent,
   AXPNavBarSlotComponent,
+  AXPSettingService,
   AXP_MENU_PROVIDER,
   AXP_PLATFORM_CONFIG_TOKEN,
 } from '@acorex/platform/common';
-import { AXPLayoutBuilderModule, AXPWidgetsCatalog, AXP_WIDGETS_EDITOR_CATEGORY } from '@acorex/platform/layout/builder';
+import { AXPWidgetCoreModule, AXPWidgetGroupEnum, AXPWidgetsCatalog, AXP_WIDGETS_EDITOR_CATEGORY } from '@acorex/platform/layout/widget-core';
 import { AXPEntityModule, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import { AXPDefaultThemeModule } from '@acorex/platform/themes/default';
 import { AXP_THEME_PALETTE_PROVIDER } from '@acorex/platform/themes/shared';
-import { AXPComponentSlotModule } from '@acorex/platform/layout/components';
-
-
 import { NgModule, inject } from '@angular/core';
-import pkg from '../../../../../../package.json';
 import { AXPRootEntityLoader } from './entity.loader';
 import { AXPRootMenuProvider } from './menu.provider';
-
+import { AXPComponentSlotModule } from '@acorex/platform/layout/components';
+import { AXPPlatformScope } from '@acorex/platform/core';
 @NgModule({
   imports: [
     AXPDefaultThemeModule,
     AXPCommonModule,
     AXPEntityModule,
-    AXPLayoutBuilderModule.forChild({
+    AXPWidgetCoreModule.forChild({
       widgets: [],
       extendedWidgets: [],
     }),
     AXPComponentSlotModule.forRoot({
-      'rootfooter-start': [
+      'root-footer-start': [
         {
           name: 'version',
-          component: AXPFooterTextSlotComponent,
-          options: () => {
-            return { text: `v${pkg.version}` };
-          },
+          component: AXMAppVersionSlotComponent,
         },
         {
           name: 'copyright',
           component: AXPFooterTextSlotComponent,
-          options: () => {
-            const a = inject(AXP_PLATFORM_CONFIG_TOKEN);
-            return { text: a.copyright };
+          options: async () => {
+            const platformConfig = inject(AXP_PLATFORM_CONFIG_TOKEN);
+            const settingService = inject(AXPSettingService);
+            const copyrightText = await settingService.scope(AXPPlatformScope.Tenant).get("organization:copyright-text");
+            return { text: copyrightText ?? platformConfig.copyright };
           },
         },
       ],
@@ -52,7 +50,7 @@ import { AXPRootMenuProvider } from './menu.provider';
       ],
     }),
   ],
-  exports: [],
+  exports: [AXPDefaultThemeModule],
   providers: [
     {
       provide: AXP_MENU_PROVIDER,
@@ -73,4 +71,4 @@ import { AXPRootMenuProvider } from './menu.provider';
     },
   ],
 })
-export class AXPLayoutRootModule {}
+export class AXPLayoutRootModule { }

package/src/generators/app-module/files/src/app/modules/layout/menu.provider.ts.template

@@ -1,23 +1,9 @@
 import { AXPMenuProviderContext, AXPMenuProvider } from '@acorex/platform/common';
 import { Injectable } from '@angular/core';
-import { Router } from '@angular/router';
-import { cloneDeep, omit } from 'lodash-es';
-import { Observable, of } from 'rxjs';
 
 @Injectable()
 export class AXPRootMenuProvider implements AXPMenuProvider {
   async provide(context: AXPMenuProviderContext): Promise<void> {
-    context.addItems([
-    {
-      text: 'Sample',
-      path: '/<%= name %>/m/sample/e/sample/list',
-      icon: 'fa-solid fa-grid-2',
-      data: {
-        //requiredPermission: '',
-      },
-    },
-  ]);
+    // Intentionally empty; feature modules should register their own menus.
   }
-
-   
 }

package/src/generators/app-module/files/src/app/modules/layout/theme-palette.provider.ts.template

@@ -213,6 +213,63 @@ export class AXPRootThemePaletteProvider implements AXPThemePaletteProvider {
           light: '#fafafa',
         },
       },
+      {
+        name: 'cherry-blossom',
+        title: 'Cherry Blossom',
+        colors: {
+          primary: '#d63384',
+          secondary: '#f8b4cb',
+          success: '#20c997',
+          warning: '#fd7e14',
+          danger: '#dc3545',
+          accents: ['#6f42c1', '#0dcaf0', '#6c757d'],
+          dark: '#251821',
+          light: '#ffffff',
+        },
+      },
+      {
+        name: 'autumn-harvest',
+        title: 'Autumn Harvest',
+        colors: {
+          primary: '#d2691e',
+          secondary: '#cd853f',
+          success: '#228b22',
+          warning: '#daa520',
+          danger: '#b22222',
+          accents: ['#8b4513', '#4682b4', '#2f4f4f'],
+          dark: '#25140e',
+          light: '#ffffff',
+        },
+      },
+      {
+        name: 'arctic-glacier',
+        title: 'Arctic Glacier',
+        colors: {
+          primary: '#4169e1',
+          secondary: '#87ceeb',
+          success: '#32cd32',
+          warning: '#ffa500',
+          danger: '#dc143c',
+          accents: ['#483d8b', '#20b2aa', '#708090'],
+          dark: '#172028',
+          light: '#ffffff',
+        },
+      },
+      {
+        name: 'teal-ocean',
+        title: 'Teal Ocean',
+        colors: {
+          primary: '#018b77',
+          secondary: '#00a693',
+          neutral: '#606c76',
+          success: '#2d9c67',
+          warning: '#e9a01b',
+          danger: '#c02f1d',
+          accents: ['#006b5c', '#4db6ac', '#80cbc4'],
+          dark: '#131f1c',
+          light: '#ffffff',
+        },
+      },
     ]);
   }
 }

package/src/generators/app-module/files/src/app/modules/root/const.ts.template

@@ -1,6 +1,26 @@
-export const AXMSampleModuleConst = {
-  moduleName: 'sample',
-  moduleRoute: 'sample', 
-  categoryEntity: 'sample',
-  templateEntity: 'templates',
+//#region ----   Module Configuration   ----
+
+const config = {
+  i18n: '<%= name %>-module',
+  module: '<%= className %>Module',
 };
+
+export const RootConfig = {
+  config,
+  module: {
+    route: '<%= name %>',
+    name: '<%= className %>Module',
+    title: `t('module-name', {scope:"${config.i18n}"})`,
+    icon: 'fa-light fa-cube',
+  },
+  entities: {
+    sample: {
+      name: 'Sample',
+      title: `t("sample.individual-title",{scope:"${config.i18n}"})`,
+      source: `${config.module}.Sample`,
+      icon: 'fa-light fa-box',
+    },
+  },
+};
+
+//#endregion

package/src/generators/app-module/files/src/app/modules/root/menu.keys.ts.template

@@ -0,0 +1,9 @@
+//#region ----   Menu Keys   ----
+
+export const <%= className %>ModuleMenuKeys = {
+  Root: '<%= name %>-module:menu',
+  Samples: '<%= name %>-module:menu:samples',
+} as const;
+
+//#endregion
+

package/src/generators/app-module/files/src/app/modules/root/menu.provider.ts.template

@@ -0,0 +1,61 @@
+//#region ----   Imports   ----
+
+import { AXPSessionService } from '@acorex/platform/auth';
+import { AXPMenuProvider, AXPMenuProviderContext } from '@acorex/platform/common';
+import { AXPEntityService } from '@acorex/platform/layout/entity';
+import { inject } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { RootConfig } from './const';
+import { <%= className %>ModuleMenuKeys } from './menu.keys';
+import { <%= className %>ModulePermissionsKeys } from './permission.keys';
+
+//#endregion
+
+//#region ----   Menu Provider   ----
+
+export class <%= className %>ModuleMenuProvider implements AXPMenuProvider {
+  
+  //#region ----   Services   ----
+  
+  private entityService = inject(AXPEntityService);
+  private sessionService = inject(AXPSessionService);
+  
+  //#endregion
+
+  //#region ----   Provider Method   ----
+
+  async provide(context: AXPMenuProviderContext): Promise<void> {
+    const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+    if (!isAuthorized) {
+      return;
+    }
+
+    const scope = RootConfig.config.i18n;
+    const module = RootConfig.module;
+
+    context.addItems([
+      {
+        name: <%= className %>ModuleMenuKeys.Root,
+        priority: 9000,
+        text: `t('root-menu', {scope:"${scope}"})`,
+        icon: module.icon,
+        data: {},
+        children: [
+          {
+            name: <%= className %>ModuleMenuKeys.Samples,
+            text: `t('samples-menu', {scope:"${scope}"})`,
+            path: this.entityService.createPath(module.name, RootConfig.entities.sample.name),
+            icon: RootConfig.entities.sample.icon,
+            priority: 1,
+            data: {},
+          },
+        ],
+      },
+    ]);
+  }
+
+  //#endregion
+}
+
+//#endregion
+

package/src/generators/app-module/files/src/app/modules/root/mock.data.ts.template

@@ -1,50 +1,26 @@
+//#region ----   Imports   ----
+
 import { AXPDataGenerator } from '@acorex/platform/core';
 
-export const USERS = Array.from({ length: 20 }).map((_, i) => {
+//#endregion
+
+//#region ----   Sample Mock Data   ----
+
+/**
+ * Mock data for Sample entity (20 items)
+ * Used by the mock service for testing and development
+ */
+export const SAMPLE_DATA = Array.from({ length: 20 }).map((_, i) => {
   const firstName = AXPDataGenerator.firstName();
   const lastName = AXPDataGenerator.lastName();
   return {
     id: AXPDataGenerator.uuid(),
     firstname: firstName,
     lastname: lastName,
-    phone: AXPDataGenerator.phone(),
     email: AXPDataGenerator.email(firstName, lastName),
+    phone: AXPDataGenerator.phone(),
     address: AXPDataGenerator.address(),
   };
 });
 
-export interface SampleEntity {
-  id: string;
-  name: string;
-  description: string;
-  isActive: boolean;
-  createdDate: Date;
-  category: string;
-}
-
-export const sampleData: SampleEntity[] = [
-  {
-    id: '1',
-    name: 'Sample Item 1',
-    description: 'This is a sample item for testing',
-    isActive: true,
-    createdDate: new Date(2024, 0, 15),
-    category: 'Category A'
-  },
-  {
-    id: '2',
-    name: 'Sample Item 2',
-    description: 'Another sample item with different data',
-    isActive: false,
-    createdDate: new Date(2024, 1, 20),
-    category: 'Category B'
-  },
-  {
-    id: '3',
-    name: 'Sample Item 3',
-    description: 'Third sample item for demonstration',
-    isActive: true,
-    createdDate: new Date(2024, 2, 5),
-    category: 'Category A'
-  }
-];
+//#endregion

package/src/generators/app-module/files/src/app/modules/root/permission-definition.provider.ts.template

@@ -0,0 +1,51 @@
+//#region ----   Imports   ----
+
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPPermissionDefinitionProvider, AXPPermissionDefinitionProviderContext } from '@acorex/platform/auth';
+import { Injector } from '@angular/core';
+import { <%= className %>ModulePermissionsKeys } from './permission.keys';
+
+//#endregion
+
+//#region ----   Permission Definition Provider   ----
+
+export class <%= className %>ModulePermissionDefinitionProvider implements AXPPermissionDefinitionProvider {
+  
+  //#region ----   Services   ----
+
+  private readonly translateService = this.injector.get(AXTranslationService);
+
+  //#endregion
+
+  //#region ----   Constructor   ----
+
+  constructor(private injector: Injector) {}
+
+  //#endregion
+
+  //#region ----   Define Method   ----
+
+  async define(context: AXPPermissionDefinitionProviderContext): Promise<void> {
+    const trans = async (key: string) =>
+      await this.translateService.translateAsync(`permissions.<%= name %>-module.${key}`, {
+        scope: '<%= name %>-module',
+      });
+
+    const keys = <%= className %>ModulePermissionsKeys;
+
+    context
+      .addGroup(keys.Module.Management, await trans('manage.title'))
+      //
+      .addPermission(keys.Sample.Management, await trans('sample.manage.title'))
+      .addChild(keys.Sample.View, await trans('sample.view.title'))
+      .addChild(keys.Sample.Edit, await trans('sample.edit.title'))
+      .addChild(keys.Sample.Delete, await trans('sample.delete.title'))
+      .addChild(keys.Sample.Create, await trans('sample.create.title'))
+      .endPermission();
+  }
+
+  //#endregion
+}
+
+//#endregion
+

package/src/generators/app-module/files/src/app/modules/root/permission.keys.ts.template

@@ -0,0 +1,17 @@
+//#region ----   Permission Keys   ----
+
+export const <%= className %>ModulePermissionsKeys = {
+  Module: {
+    Management: '<%= name %>-module:manage',
+  },
+  Sample: {
+    Management: '<%= name %>-module:sample:manage',
+    View: '<%= name %>-module:sample:view',
+    Edit: '<%= name %>-module:sample:edit',
+    Delete: '<%= name %>-module:sample:delete',
+    Create: '<%= name %>-module:sample:create',
+  },
+};
+
+//#endregion
+

package/src/generators/app-module/files/src/app/modules/root/root.module.ts.template

@@ -1,9 +1,17 @@
-import { AXPAuthGuard } from '@acorex/platform/auth';
-import { AXPWidgetRegistryService } from '@acorex/platform/layout/builder';
+//#region ----   Imports   ----
+
+import { AXPAuthGuard, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { AXPWidgetRegistryService } from '@acorex/platform/layout/widget-core';
 import { AXPRootLayoutComponent } from '@acorex/platform/themes/default';
 import { CommonModule } from '@angular/common';
-import { inject, NgModule } from '@angular/core';
+import { inject, Injector, NgModule } from '@angular/core';
 import { RouterModule, Routes } from '@angular/router';
+import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXMSampleEntityModule } from './sample/sample.module';
+import { <%= className %>ModuleMenuProvider } from './menu.provider';
+import { <%= className %>ModuleSearchCommandProvider } from './search-command.provider';
+
+//#endregion
 
 const routes: Routes = [
   {
@@ -15,25 +23,46 @@ const routes: Routes = [
         path: 'home',
         loadComponent: () => import('./home/home.page').then((c) => c.<%= className %>HomePage),
       },
-      {
-        canActivate: [AXPAuthGuard],
-        path: 'sample',
-        loadComponent: () => import('./sample/sample.component').then((c) => c.SampleComponent),
-      },
     ],
   },
 ];
 
+//#region ----   Module Definition   ----
+
 @NgModule({
   imports: [
     CommonModule,
-    RouterModule.forChild(routes)
+    RouterModule.forChild(routes),
+    //
+    AXMSampleEntityModule,
   ],
   exports: [RouterModule],
-  providers: [],
+  providers: [
+    {
+      provide: AXP_MENU_PROVIDER,
+      useClass: <%= className %>ModuleMenuProvider,
+      multi: true,
+    },
+    {
+      provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+      useFactory: async () => {
+        const injector = inject(Injector);
+        const provider = (await import('./permission-definition.provider')).<%= className %>ModulePermissionDefinitionProvider;
+        return new provider(injector);
+      },
+      multi: true,
+    },
+    {
+      provide: AXP_SEARCH_PROVIDER,
+      useClass: <%= className %>ModuleSearchCommandProvider,
+      multi: true,
+    },
+  ],
   declarations: [],
 })
 export class <%= upperCase(name) %>RootModule {
   registry = inject(AXPWidgetRegistryService);
   extendedWidgets = [];
 }
+
+//#endregion