@acorex/platform-generator 1.0.1

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

@@ -0,0 +1,83 @@
+import { AXPAuthStrategy, AXPBaseCredentials, AXPRefreshTokenResult, AXPSignInResult, AXPUser } from '@acorex/platform/auth';
+import { AXPDataProvider } from '@acorex/platform/common';
+import { Injectable, Injector, inject } from '@angular/core';
+
+
+export interface <%= upperCase(name) %>UserPassCredentials extends AXPBaseCredentials {
+  username: string;
+  password: string;
+}
+
+@Injectable()
+export class <%= upperCase(name) %>Strategy implements AXPAuthStrategy {
+
+  constructor() {
+
+  }
+
+  get name(): string {
+    return 'user-pass';
+  }
+
+  async signin(credentials: <%= upperCase(name) %>UserPassCredentials): Promise<AXPSignInResult> {
+    try {
+      if (credentials.username == 'root' && credentials.password=='123') {
+        const user: AXPUser = {
+          id: 'a683a19a-e3eb-46a7-b81c-7cf9468ae831',
+          name: 'Root',
+          title: 'Root User',
+          avatar: 'https://avatar.iran.liara.run/public/29'
+        };
+        const accessToken = 'access_token';
+        const refreshToken = 'refresh_token';
+        return {
+          succeed: true,
+          data: { user, accessToken, refreshToken },
+        };
+      }
+      if (credentials.username == 'admin' && credentials.password=='123') {
+        const user: AXPUser = {
+          id: 'a683a19a-e3eb-46a7-b81c-7cf9468ae831',
+          name: 'Admin',
+          title: 'Admin User',
+          avatar: 'https://avatar.iran.liara.run/public/47'
+        };
+        const accessToken = 'access_token';
+        const refreshToken = 'refresh_token';
+        return {
+          succeed: true,
+          data: { user, accessToken, refreshToken },
+        };
+      }
+      if (credentials.username == 'user' && credentials.password=='123') {
+        const user: AXPUser = {
+          id: 'a683a19a-e3eb-76a7-b81c-7cf9468ae831',
+          name: 'User',
+          title: 'Sample User',
+          avatar: 'https://avatar.iran.liara.run/public/56'
+        };
+        const accessToken = 'access_token';
+        const refreshToken = 'refresh_token';
+        return {
+          succeed: true,
+          data: { user, accessToken, refreshToken },
+        };
+      }
+      return {
+        succeed: false,
+      };
+    } catch (error: any) {
+      if (error?.message) throw new Error(error.message);
+      // Depending on the error type, you might want to throw a specific error
+      throw new Error('Network or server error occurred');
+    }
+  }
+
+  async signout(): Promise<void> {
+    console.log('User signed out');
+  }
+
+  refreshToken(refreshToken: string): Promise<AXPRefreshTokenResult> {
+    throw new Error('Method not implemented.');
+  }
+}

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

@@ -0,0 +1,17 @@
+import { AXPFeature, AXPFeatureLoader } from '@acorex/platform/auth';
+import { Observable, delay, of } from 'rxjs';
+
+export class <%= upperCase(name) %>FeatureLoader implements AXPFeatureLoader {
+
+  private list: AXPFeature[] = [
+    // {
+    //   name: 'feature name',
+    //   title: 'Feature Title',
+    //   value: false
+    // },
+  ]
+
+  getList(): Observable < AXPFeature[] > {
+    return of(this.list).pipe(delay(0));
+  }
+}

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

@@ -0,0 +1,21 @@
+import { AXPPermission, AXPPermissionLoader, AXPSessionContext } from '@acorex/platform/auth';
+import { AXP_ROOT_CONFIG_TOKEN } from '@acorex/platform/core';
+import { Injectable, inject } from '@angular/core';
+import { Observable, map, of } from 'rxjs';
+
+@Injectable()
+export class <%= upperCase(name) %>PermissionLoader implements AXPPermissionLoader {
+
+  getList(context: AXPSessionContext): Observable<AXPPermission[]> {
+    if (context.user?.name == 'Root') {
+      return of(['admin', 'platform.admin.settings', 'platform.admin.reports']);
+    }
+    else if (context.user?.name == 'Admin') {
+      return of(['admin', '<%= name %>.admin.settings']);
+    }
+    else  {
+      return of(['<%= name %>_app.forms']);
+    }
+  }
+
+}

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

@@ -0,0 +1,32 @@
+import { AXPTenant, AXPTenantLoader, AXPSessionContext } from '@acorex/platform/auth';
+import { AXP_ROOT_CONFIG_TOKEN } from '@acorex/platform/core';
+import { Injectable, inject } from '@angular/core';
+import { Observable, delay, of } from 'rxjs';
+
+@Injectable()
+export class <%= upperCase(name) %>TenantLoader implements AXPTenantLoader {
+  
+   getList(context: AXPSessionContext): Observable<AXPTenant[]> {
+
+    const acorex_tenant = {
+        id: '99',
+        name: 'acorex-tenant',
+        title: 'ACoreX Platform Tenant',
+    };
+
+    const <%= name %>_tenant = {
+        id: '1',
+        name: '<%= name %>-tenant',
+        title: '<%= upperCase(name) %> Tenant',
+    };
+
+    if (context.user?.name == 'Root') {
+      return of([<%= name %>_tenant, acorex_tenant]).pipe(delay(500));
+    }
+    else  {
+      return of([<%= name %>_tenant]).pipe(delay(500));
+    }
+    
+  }
+  
+}

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

@@ -0,0 +1,45 @@
+import {
+  AX_TRANSLATION_CONFIG,
+  AX_TRANSLATION_LOADER,
+  AXTranslation,
+  AXTranslationLoader,
+  AXTranslationLoaderOptions,
+  AXTranslationModule,
+  translationConfig,
+} from '@acorex/core/translation';
+import { HttpClient } from '@angular/common/http';
+
+import { Injectable, NgModule } from '@angular/core';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class MyTranslationLoader implements AXTranslationLoader {
+  constructor(private http: HttpClient) { }
+
+  getTranslation(options: AXTranslationLoaderOptions): Observable<AXTranslation> {
+    return this.http
+      .get<AXTranslation>(`/assets/i18n/${options.lang}/${options.scope}.json`)
+      .pipe();
+  }
+}
+
+@NgModule({
+  exports: [AXTranslationModule],
+  imports: [],
+  providers: [
+    {
+      provide: AX_TRANSLATION_LOADER,
+      useClass: MyTranslationLoader,
+    },
+    {
+      provide: AX_TRANSLATION_CONFIG,
+      useValue: translationConfig({
+        preloadLangs: ['en'],
+        preloadScopes: ['common', 'auth'],
+        defaultLang: 'en',
+        availableLangs: ['en'],
+      }),
+    },
+  ],
+})
+export class AXPTranslationRootModule { }

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

@@ -0,0 +1,21 @@
+import { AXPEntityConfig, AXPEntityLoader } from '@acorex/platform/layouts';
+import { Injectable, Injector, inject } from '@angular/core';
+
+@Injectable()
+export class AXPRootEntityLoader implements AXPEntityLoader {
+  private injector = inject(Injector);
+
+  async get(moduleName: string, entityName: string): Promise<AXPEntityConfig | null> {
+    return new Promise(async (resolve) => {
+      switch (entityName) {
+        case 'sample': {
+          const entity = (await import('../<%= name %>/sample/sample.entity')).entityFactory;
+          resolve(entity(this.injector));
+          break;
+        }
+        default:
+          resolve(null);
+      }
+    });
+  }
+}

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

@@ -0,0 +1,75 @@
+import {
+  AXPAdminLayoutModule,
+  AXPFooterTextSlotComponent,
+  AXPLayoutModule,
+  AXPNavBarSlotComponent,
+  AXPThemeSlotComponent,
+  AXP_ENTITY_LOADER,
+} from '@acorex/platform/layouts';
+import { NgModule, inject } from '@angular/core';
+import { AXPRootMenuLoader } from './menu.loader';
+import { AXPRootEntityLoader } from './entity.loader';
+import { AXPCommonModule, AXPMenuItem, AXPNavigateAction, AXP_MENU_LOADER, AXP_PLATFORM_CONFIG_TOKEN } from '@acorex/platform/common';
+import pkg from '../../../../../../package.json';
+import { AXPComponentSlotModule } from '@acorex/platform/layout';
+
+
+@NgModule({
+  imports: [
+    AXPAdminLayoutModule,
+    AXPCommonModule,
+    AXPLayoutModule,
+    AXPComponentSlotModule.forRoot({
+      "footer-start": [
+        {
+          name: "version",
+          component: AXPFooterTextSlotComponent,
+          options: () => {
+            return { text: `v${pkg.version}` };
+          }
+        },
+        {
+          name: "copyright",
+          component: AXPFooterTextSlotComponent,
+          options: () => {
+            const a = inject(AXP_PLATFORM_CONFIG_TOKEN);
+            return { text: a.copyright };
+          }
+        },
+      ],
+      "auth-footer-links": [
+        {
+          name: "links",
+          component: AXPNavBarSlotComponent,
+          options: () => {
+            const items: AXPMenuItem[] = [
+              // {
+              //   text: 'About',
+              //   command: AXPNavigateAction({ payload: { commands: ['asc/help/about'] } })
+              // }
+            ];
+            return { items };
+          }
+        }      
+      ],
+      "header-end": [
+        {
+          name: 'theme',
+          component: AXPThemeSlotComponent,
+        },
+      ],
+    })
+  ],
+  exports: [],
+  providers: [
+    {
+      provide: AXP_MENU_LOADER,
+      useClass: AXPRootMenuLoader
+    },
+    {
+      provide: AXP_ENTITY_LOADER,
+      useClass: AXPRootEntityLoader
+    },
+  ],
+})
+export class AXPLayoutRootModule { }

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

@@ -0,0 +1,159 @@
+import { AXPMenuItem, AXPMenuLoader } 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 AXPRootMenuLoader implements AXPMenuLoader {
+  private initialMenu: AXPMenuItem[] = [
+    {
+      text: 'Home',
+      path: '/<%= name %>/home',
+      icon: 'fa-solid fa-grid-2',
+      data: {
+        //requiredPermission: '',
+      },
+    },
+    {
+      text: 'Administration',
+      type: 'group',
+      data: {
+        requiredPermission: 'admin',
+      },
+    },
+    {
+      text: 'General Settings',
+      icon: 'fa-solid fa-gear',
+      data: {
+        requiredPermission: '<%= name %>.admin.settings',
+      },
+      children: [
+        {
+          text: 'Sample Dynamic Entity',
+          path: '/<%= name %>/sample/e/sample/list',
+        },
+      ]
+    },
+    {
+      text: 'Security Management',
+      path: '/security',
+      icon: 'fa-solid fa-lock',
+      data: {
+        requiredPermission: '<%= name %>.admin.settings',
+      },
+      opened: false,
+      children: [
+        {
+          text: 'User Management',
+          icon: 'fa-solid fa-users',
+        },
+        {
+          text: 'Roles Management',
+          icon: 'fa-solid fa-key',
+        },
+      ],
+    },
+    {
+      text: 'Security Management',
+      path: '/security',
+      icon: 'fa-solid fa-lock',
+      data: {
+        requiredPermission: 'platform.admin.settings',
+      },
+      opened: false,
+      children: [
+        {
+          text: 'User Management',
+          icon: 'fa-solid fa-users',
+        },
+        {
+          text: 'Roles Management',
+          icon: 'fa-solid fa-key',
+        },
+      ],
+    },
+    {
+      text: 'Tenant Management',
+      path: '/tenant-managemenet',
+      icon: 'fa-solid fa-sitemap',
+      data: {
+        requiredPermission: 'platform.admin.settings',
+      },
+    },
+    {
+      text: 'Reports',
+      type: 'group',
+      data: {
+        requiredPermission: 'platform.admin.reports',
+      },
+    },
+    {
+      text: 'log Management',
+      path: '/log-managemenet',
+      icon: 'fa-solid fa-file-lines',
+      data: {
+        requiredPermission: 'platform.admin.reports',
+      },
+    },
+  ];
+
+  constructor(private router: Router) { }
+
+  getItems(depth: number | null = null): Observable<AXPMenuItem[]> {
+    const menuClone = cloneDeep(this.initialMenu);
+    const result = this.internalGetMenuItemsByDepth(menuClone, depth);
+    return of(result);
+  }
+
+  private internalGetMenuItemsByDepth(menuItems: AXPMenuItem[], depth: number | null, parent: AXPMenuItem | undefined = undefined): AXPMenuItem[] {
+    return menuItems.map((item) => {
+      // Create a new item with parent set
+      const newItem: AXPMenuItem = { ...item, parent: parent };
+
+      if (depth !== null) {
+        if (depth === 0) {
+          // If depth is 0, return the item without children
+          return omit(newItem, 'children');
+        } else if (item.children) {
+          // If the item has children, recursively set their parent and limit depth
+          newItem.children = this.internalGetMenuItemsByDepth(item.children, depth - 1, newItem);
+        }
+      } else if (item.children) {
+        // If depth is null, process all children without depth limit
+        newItem.children = this.internalGetMenuItemsByDepth(item.children, null, newItem);
+      }
+
+      return newItem;
+    });
+  }
+
+  currentMenuItem(): AXPMenuItem | null {
+    return this.internalCurrentMenuItem(this.internalGetMenuItemsByDepth(this.initialMenu, null), this.getCurrentRoutePath());
+  }
+
+  private internalCurrentMenuItem(menuItems: AXPMenuItem[], currentPath: string): AXPMenuItem | null {
+    for (const item of menuItems) {
+      // Check if the current item's path matches the current path
+      if (item.path === currentPath) {
+        return item;
+      }
+
+      // If the current item has children, search recursively in the children
+      if (item.children && item.children.length > 0) {
+        const found = this.internalCurrentMenuItem(item.children, currentPath);
+        if (found) {
+          return found;
+        }
+      }
+    }
+
+    // Return null if no matching item is found
+    return null;
+  }
+
+  private getCurrentRoutePath(): string {
+    // Using window.location to get the current browser URL
+    return window.location.pathname;
+  }
+}

package/src/generators/app-module/files/src/app/modules/root/home/home.page.html.template

@@ -0,0 +1,3 @@
+<div class="ax-flex ax-p-7">
+    <div class="ax-font-bold ax-text-3xl">Welcome to ACoreX Platform</div>
+</div>

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

@@ -0,0 +1,10 @@
+import { Component } from '@angular/core';
+
+@Component({
+    templateUrl: 'home.page.html',
+    standalone: true
+})
+
+export class <%= upperCase(name) %>HomePage  {
+
+}

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

@@ -0,0 +1,30 @@
+import { AXPAuthGuard, AXPPermissionGuard } from '@acorex/platform/auth';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+
+const routes: Routes = [
+  {
+    path: '',
+    redirectTo: 'home',
+    pathMatch: 'full',
+  },
+  {
+    path: '',
+    children: [
+      {
+        //canActivate: [AXPAuthGuard],
+        path: 'home',
+        loadComponent: () => import('./home/home.page').then((c) => c.<%= upperCase(name) %>HomePage),
+      }
+    ]
+  },
+];
+
+@NgModule({
+  imports: [CommonModule, RouterModule.forChild(routes)],
+  exports: [RouterModule],
+  providers: [],
+  declarations: [],
+})
+export class <%= upperCase(name) %>RootModule { }

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

@@ -0,0 +1,185 @@
+import { AXDataSourceQuery } from '@acorex/components/common';
+import { applyFilterArray, applySortArray } from '@acorex/modules/backend';
+import {
+    AXPEntityConfig,
+    AXPEntityListDisplayColumnConfig,
+    AXPEntityProperty,
+    convertPropertiesToColumns,
+    widgetSchemas,
+} from '@acorex/platform/layouts';
+import { Injector } from '@angular/core';
+import { assign } from 'lodash-es';
+
+const properties: AXPEntityProperty[] = [
+    {
+        name: 'firstname',
+        title: 'First Name',
+        schema: widgetSchemas.text,
+        canEdit: true,
+        canInsert: true,
+        canInlineFilter: true,
+        validationRules: [
+            {
+                rule: 'required',
+            },
+        ],
+        layout: {
+            positions: {
+                default: {
+                    start: 0,
+                    span: 6,
+                },
+            },
+        },
+    },
+    {
+        name: 'lastname',
+        title: 'Last Name',
+        schema: widgetSchemas.text,
+        canEdit: true,
+        canInsert: true,
+        canInlineFilter: true,
+        validationRules: [
+            {
+                rule: 'required',
+            },
+        ],
+        layout: {
+            positions: {
+                default: {
+                    start: 6,
+                    span: 6,
+                },
+            },
+        },
+    },
+    {
+        name: 'birthDate',
+        title: 'Birth Date',
+        schema: widgetSchemas.date,
+        canEdit: true,
+        canInsert: true,
+        validationRules: [
+            {
+                rule: 'required',
+            },
+        ],
+    },
+    {
+        name: 'notify',
+        title: 'Notification',
+        schema: widgetSchemas.toggle,
+        canEdit: true,
+        canInsert: false,
+        component: {
+            common: {
+                options: {
+                    trulyText: 'Enabled',
+                    falsyText: 'Disabled',
+                },
+            },
+        },
+    },
+];
+
+const result = Array.from({ length: 30 }).map((_, i) => ({
+    id: i,
+    firstname: ['John', 'Allen', 'Jak', 'Rose', 'Kate'][Math.floor(Math.random() * 5)],
+    lastname: ['Gates', 'Jonsen', 'Smith', 'Ford', 'Jakson'][Math.floor(Math.random() * 5)],
+    birthDate: new Date(),
+    phone: `123456789${i}`,
+    email: `example@gmail.com`,
+    notify: Math.floor(Math.random() * 5) % 3 == 0,
+}));
+
+const entityName = 'sample';
+
+const columns: AXPEntityListDisplayColumnConfig[] = convertPropertiesToColumns(...properties);
+
+export async function entityFactory(injector: Injector): Promise<AXPEntityConfig> {
+
+    const entity: AXPEntityConfig = {
+        module: '<% name %>',
+        name: entityName,
+        title: 'Sample Entity',
+        properties: properties,
+        formats: {
+            default: '{{firstname}} {{lastname}}',
+        },
+        dataSource: {
+            key: 'id',
+            pageSize: 20,
+            load: async (e: AXDataSourceQuery) => {
+                const sortedItems = applySortArray(result, e.sort);
+                const filteredItems = applyFilterArray(sortedItems, e.filter?.filters);
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve({
+                            items: filteredItems.slice(e.skip, (e.skip ?? 0) + (e.take ?? 0)),
+                            total: filteredItems.length,
+                        });
+                    }, 100);
+                });
+            },
+            byKey: (id: any) => {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(result.find((c) => c.id.toString() == id));
+                    }, 100);
+                });
+            },
+        },
+        views: {
+            list: {
+                title: 'Sample Entity List',
+                views: [
+                    {
+                        name: 'all',
+                        title: 'All Items',
+                        fixed: true,
+                        columns: columns,
+                        conditions: [],
+                        sorts: [
+                            {
+                                name: 'firstname',
+                                dir: 'asc',
+                            },
+                            {
+                                name: 'lastname',
+                                dir: 'asc',
+                            },
+                        ],
+                    },
+                ],
+            },
+            quickView: {
+                root: {
+                    properties: properties.map((c) => c.name),
+                },
+            },
+            detailView: {
+                root: {
+                    properties: properties.map((c) => c.name),
+                },
+            },
+            createView: {
+                root: {
+                    properties: properties.slice(0, properties.length - 1).map((c) => c.name),
+                },
+            },
+        },
+        commands: {
+            create: async (values) => {
+                return Promise.resolve({ id: Math.floor(Math.random() * 10000) });
+            },
+            update: async (id: string, values) => {
+                return Promise.resolve();
+            },
+            delete: (id: string) => {
+                return Promise.resolve();
+            },
+        }
+    };
+
+    return entity;
+}