cabloy 5.1.148 → 5.1.149

package/repo-e2e/specs/cabloy-basic.spec.ts

@@ -1,4 +1,4 @@
-import type { Locator, Page } from '@playwright/test';
+import type { Locator, Page, Route } from '@playwright/test';
 
 import { expect, test } from '@playwright/test';
 
@@ -56,6 +56,39 @@ function waitForStudentSelect(page: Page) {
   });
 }
 
+function installStudentCreateResponseCapture(page: Page) {
+  let studentId: string | number | undefined;
+  const handler = async (route: Route) => {
+    const request = route.request();
+    const url = new URL(request.url());
+    if (
+      request.method() !== 'POST' ||
+      url.pathname !== '/api/training/student' ||
+      request.headers()['x-vona-openapi-schema']
+    ) {
+      await route.continue();
+      return;
+    }
+    const response = await route.fetch();
+    const payload = await response.json();
+    if (response.ok() && ['string', 'number'].includes(typeof payload.data)) {
+      studentId = payload.data;
+    }
+    await route.fulfill({ response });
+  };
+  return {
+    async install() {
+      await page.route('**/api/training/student', handler);
+    },
+    async uninstall() {
+      await page.unroute('**/api/training/student', handler);
+    },
+    get studentId() {
+      return studentId;
+    },
+  };
+}
+
 async function getFieldGeometry(locator: Locator): Promise<IFieldGeometry> {
   return locator.evaluate(element => {
     const field = element.closest('label')?.parentElement;
@@ -348,3 +381,145 @@ test(
     expect(pageErrors).toEqual([]);
   },
 );
+
+test(
+  'ATP-BASIC-FORM-01: Training Student content remains in the Basic Information tab',
+  { tag: ['@admin', '@flow'] },
+  async ({ page }) => {
+    const pageErrors = collectPageErrors(page);
+    await loginAsAdmin(page);
+
+    const response = await page.goto('/admin/rest/resource/training-student%3Astudent/create', {
+      waitUntil: 'load',
+    });
+    expect(response?.ok()).toBeTruthy();
+    await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+
+    const basicInformationTab = page.getByRole('tab', { name: 'Basic Information', exact: true });
+    const studentContentGroup = page
+      .locator('fieldset')
+      .filter({ has: page.locator('legend').filter({ hasText: /^Student Content$/ }) });
+    await expect(studentContentGroup).toHaveCount(1);
+    await expect(
+      studentContentGroup.getByText('Description Markdown', { exact: true }),
+    ).toBeVisible();
+
+    const studentContentPanel = studentContentGroup.locator('xpath=ancestor::*[@role="tabpanel"]');
+    await expect(studentContentPanel).toHaveCount(1);
+    const basicInformationTabId = await basicInformationTab.getAttribute('id');
+    expect(basicInformationTabId).not.toBeNull();
+    await expect(studentContentPanel).toHaveAttribute('aria-labelledby', basicInformationTabId!);
+    expect(pageErrors).toEqual([]);
+  },
+);
+
+test(
+  'ATP-BASIC-SUMMARY-01: Training Student summary renders Markdown HTML in a dialog',
+  { tag: ['@admin', '@flow'] },
+  async ({ page }) => {
+    const pageErrors = collectPageErrors(page);
+    await loginAsAdmin(page);
+
+    const studentName = `Summary E2E ${Date.now()}`;
+    const createResponseCapture = installStudentCreateResponseCapture(page);
+    let studentId: string | number | undefined;
+    await createResponseCapture.install();
+    try {
+      const createPageResponse = await page.goto(
+        '/admin/rest/resource/training-student%3Astudent/create',
+        { waitUntil: 'load' },
+      );
+      expect(createPageResponse?.ok()).toBeTruthy();
+      await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+      await page
+        .getByRole('group', { name: 'Student Name *', exact: true })
+        .getByRole('textbox')
+        .fill(studentName);
+      await page
+        .getByRole('group', { name: 'Mobile *', exact: true })
+        .getByRole('textbox')
+        .fill('13812345678');
+      await page
+        .locator('.ProseMirror')
+        .last()
+        .fill(`## Summary heading\n\nSummary paragraph ${studentName}`);
+      await page.getByRole('tab', { name: 'Student Training Records', exact: true }).click();
+      await page.getByText('Foundation Track', { exact: true }).click();
+
+      const submitButton = page.getByRole('button', { name: 'Submit', exact: true });
+      await expect(submitButton).toBeEnabled();
+      await submitButton.click();
+      await expect(page).toHaveURL(/\/admin\/(?:\?|$)/);
+      studentId = createResponseCapture.studentId;
+      expect(['string', 'number']).toContain(typeof studentId);
+
+      const response = await page.goto('/admin/rest/resource/training-student%3Astudent', {
+        waitUntil: 'load',
+      });
+      expect(response?.ok()).toBeTruthy();
+      await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+
+      const filterName = page.getByLabel('Student Name');
+      await expect(filterName).toBeVisible();
+      await filterName.fill(studentName);
+      const searchResponse = waitForStudentSelect(page);
+      await page.getByRole('button', { name: 'Search', exact: true }).click();
+      await searchResponse;
+
+      const row = page.locator('tr').filter({ hasText: studentName });
+      await expect(row).toHaveCount(1);
+      const summaryResponse = page.waitForResponse(response => {
+        const url = new URL(response.url());
+        return (
+          response.request().method() === 'GET' &&
+          response.ok() &&
+          url.pathname === `/api/training/student/summary/${studentId}` &&
+          !response.request().headers()['x-vona-openapi-schema']
+        );
+      });
+      await row.getByRole('button', { name: 'Summary', exact: true }).click();
+      await summaryResponse;
+
+      const description = page.locator('.student-summary-description');
+      await expect(description).toBeVisible();
+      await expect(description.locator('h2')).toHaveText('Summary heading');
+      await expect(description).toContainText(`Summary paragraph ${studentName}`);
+      expect(pageErrors).toEqual([]);
+    } finally {
+      try {
+        if (studentId !== undefined) {
+          const description = page.locator('.student-summary-description');
+          if (await description.count()) {
+            await description.locator('xpath=../..').getByRole('button').click();
+          }
+          const row = page.locator('tr').filter({ hasText: studentName });
+          if (!(await row.count())) {
+            const response = await page.goto('/admin/rest/resource/training-student%3Astudent', {
+              waitUntil: 'load',
+            });
+            expect(response?.ok()).toBeTruthy();
+            await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+            await page.getByLabel('Student Name').fill(studentName);
+            const searchResponse = waitForStudentSelect(page);
+            await page.getByRole('button', { name: 'Search', exact: true }).click();
+            await searchResponse;
+          }
+          const deleteResponse = page.waitForResponse(response => {
+            const url = new URL(response.url());
+            return (
+              response.request().method() === 'DELETE' &&
+              response.ok() &&
+              url.pathname === `/api/training/student/deleteForce/${studentId}` &&
+              !response.request().headers()['x-vona-openapi-schema']
+            );
+          });
+          await row.getByRole('button', { name: 'Force Delete', exact: true }).click();
+          await page.getByRole('button', { name: 'Yes', exact: true }).click();
+          await deleteResponse;
+        }
+      } finally {
+        await createResponseCapture.uninstall();
+      }
+    }
+  },
+);

package/vona/src/suite/a-training/modules/training-student/package.json

@@ -46,6 +46,7 @@
   "title": "training-student",
   "vonaModule": {
     "dependencies": {
+      "a-markdown": "5.0.0",
       "a-vona": "5.0.0"
     },
     "fileVersion": 1

package/vona/src/suite/a-training/modules/training-student/src/.metadata/index.ts

@@ -1,15 +1,18 @@
 // eslint-disable
-import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore,IModelRelationHasMany } from 'vona-module-a-orm';
+import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore,IModelRelationHasOne,IModelRelationBelongsTo,IModelRelationHasMany } from 'vona-module-a-orm';
 import type { TypeEntityOptionsFields,TypeControllerOptionsActions } from 'vona-module-a-openapi';
 import type { TableIdentity } from 'table-identity';
 /** entity: begin */
 export * from '../entity/student.tsx';
+export * from '../entity/studentContent.tsx';
 import type { IEntityOptionsStudent } from '../entity/student.tsx';
+import type { IEntityOptionsStudentContent } from '../entity/studentContent.tsx';
 import 'vona-module-a-orm';
 declare module 'vona-module-a-orm' {
 
     export interface IEntityRecord {
       'training-student:student': IEntityOptionsStudent;
+'training-student:studentContent': IEntityOptionsStudentContent;
     }
 
 
@@ -20,16 +23,21 @@ declare module 'vona-module-training-student' {
 /** entity: end */
 /** entity: begin */
 import type { EntityStudent } from '../entity/student.tsx';
+import type { EntityStudentContent } from '../entity/studentContent.tsx';
 export interface IModuleEntity {
   'student': EntityStudentMeta;
+'studentContent': EntityStudentContentMeta;
 }
 /** entity: end */
 /** entity: begin */
 export type EntityStudentTableName = 'trainingStudent';
+export type EntityStudentContentTableName = 'trainingStudentContent';
 export type EntityStudentMeta=TypeEntityMeta<EntityStudent,EntityStudentTableName>;
+export type EntityStudentContentMeta=TypeEntityMeta<EntityStudentContent,EntityStudentContentTableName>;
 declare module 'vona-module-a-orm' {
   export interface ITableRecord {
     'trainingStudent': EntityStudentMeta;
+'trainingStudentContent': EntityStudentContentMeta;
   }
 }
 declare module 'vona-module-training-student' {
@@ -37,16 +45,23 @@ declare module 'vona-module-training-student' {
     export interface IEntityOptionsStudent {
       fields?: TypeEntityOptionsFields<EntityStudent, IEntityOptionsStudent[TypeSymbolKeyFieldsMore]>;
     }
+
+    export interface IEntityOptionsStudentContent {
+      fields?: TypeEntityOptionsFields<EntityStudentContent, IEntityOptionsStudentContent[TypeSymbolKeyFieldsMore]>;
+    }
 }
 /** entity: end */
 /** model: begin */
 export * from '../model/student.ts';
+export * from '../model/studentContent.ts';
 import type { IModelOptionsStudent } from '../model/student.ts';
+import type { IModelOptionsStudentContent } from '../model/studentContent.ts';
 import 'vona-module-a-orm';
 declare module 'vona-module-a-orm' {
 
     export interface IModelRecord {
       'training-student:student': IModelOptionsStudent;
+'training-student:studentContent': IModelOptionsStudentContent;
     }
 
 
@@ -63,12 +78,25 @@ declare module 'vona-module-training-student' {
             get $onionName(): 'training-student:student';
             get $onionOptions(): IModelOptionsStudent;
           }
+
+        export interface ModelStudentContent {
+          /** @internal */
+          get scope(): ScopeModuleTrainingStudent;
+        }
+
+          export interface ModelStudentContent {
+            get $beanFullName(): 'training-student.model.studentContent';
+            get $onionName(): 'training-student:studentContent';
+            get $onionOptions(): IModelOptionsStudentContent;
+          }
 }
 /** model: end */
 /** model: begin */
 import type { ModelStudent } from '../model/student.ts';
+import type { ModelStudentContent } from '../model/studentContent.ts';
 export interface IModuleModel {
   'student': ModelStudent;
+'studentContent': ModelStudentContent;
 }
 /** model: end */
 /** model: begin */
@@ -77,6 +105,7 @@ import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGeneral {
     'training-student.model.student': ModelStudent;
+'training-student.model.studentContent': ModelStudentContent;
   }
 }
 /** model: end */
@@ -87,6 +116,13 @@ declare module 'vona-module-training-student' {
   export interface IModelOptionsStudent {
         relations: {
           trainingRecords: IModelRelationHasMany<'training-record:record', 'studentId', false, 'id'|'name'|'subjectCount'|'totalScore'|'averageScore'|'trainingTime'|'sceneImageIds'|'dossierFileIds'|'description', undefined, undefined, undefined>;
+studentContent: IModelRelationHasOne<'training-student:studentContent', 'studentId', false, 'id'|'studentId'|'descriptionMarkdown'|'descriptionHtml'>;
+studentContentForm: IModelRelationHasOne<'training-student:studentContent', 'studentId', false, 'id'|'studentId'|'descriptionMarkdown'>;
+        };
+      }
+export interface IModelOptionsStudentContent {
+        relations: {
+          student: IModelRelationBelongsTo<'training-student:studentContent', 'training-student:student', false, '*'>;
         };
       }
   export interface ModelStudent {
@@ -130,91 +166,51 @@ getByNameEqI<T extends IModelGetOptions<EntityStudent,ModelStudent>>(name?: stri
 selectByName<T extends IModelSelectParams<EntityStudent,ModelStudent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T>[]>;
 selectByNameEqI<T extends IModelSelectParams<EntityStudent,ModelStudent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T>[]>;
     }
+export interface ModelStudentContent {
+      [SymbolKeyEntity]: EntityStudentContent;
+      [SymbolKeyEntityMeta]: EntityStudentContentMeta;
+      [SymbolKeyModelOptions]: IModelOptionsStudentContent;
+      get<T extends IModelGetOptions<EntityStudentContent,ModelStudentContent>>(where: TypeModelWhere<EntityStudentContent>, options?: T): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T> | undefined>;
+      /**
+       * Retrieves one matching primary row with a pessimistic FOR UPDATE lock.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
+      getForUpdate<T extends IModelGetOptions<EntityStudentContent,ModelStudentContent>>(where: TypeModelWhere<EntityStudentContent>, options?: T): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T> | undefined>;
+      /**
+       * Retrieves a primary row by ID with the same pessimistic FOR UPDATE lock semantics.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
+      getByIdForUpdate<T extends IModelGetOptions<EntityStudentContent,ModelStudentContent>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityStudentContent,ModelStudentContent>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityStudentContent, ModelStudentContent, T>>;
+      select<T extends IModelSelectParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T>[]>;
+      insert<T extends IModelInsertOptions<EntityStudentContent,ModelStudentContent>>(data?: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityStudentContent,ModelStudentContent>>(items: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityStudentContent,ModelStudentContent>>(data: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityStudentContent,ModelStudentContent>>(items: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityStudentContent,ModelStudentContent>>(where?: TypeModelWhere<EntityStudentContent>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityStudentContent,ModelStudentContent>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityStudentContent,ModelStudentContent>>(data?: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityStudentContent,ModelStudentContent>>(items: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>[]>;
+      count<T extends IModelSelectCountParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityStudentContent,ModelStudentContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityStudentContent, T>[]>;
+      getById<T extends IModelGetOptions<EntityStudentContent,ModelStudentContent>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityStudentContent, ModelStudentContent, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityStudentContent,ModelStudentContent>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityStudentContent,ModelStudentContent, T>>;
+deleteById<T extends IModelDeleteOptions<EntityStudentContent,ModelStudentContent>>(id: TableIdentity, options?: T): Promise<void>;
+    }
 }
 declare module 'vona-module-a-orm' {
   export interface IModelClassRecord {
     'training-student:student': ModelStudent;
+'training-student:studentContent': ModelStudentContent;
   }
 }
 /** model: end */
-/** service: begin */
-export * from '../service/student.ts';
-
-import 'vona-module-a-bean';
-declare module 'vona-module-a-bean' {
-
-    export interface IServiceRecord {
-      'training-student:student': never;
-    }
-
-
-}
-declare module 'vona-module-training-student' {
-
-        export interface ServiceStudent {
-          /** @internal */
-          get scope(): ScopeModuleTrainingStudent;
-        }
-
-          export interface ServiceStudent {
-            get $beanFullName(): 'training-student.service.student';
-            get $onionName(): 'training-student:student';
-          }
-}
-/** service: end */
-/** service: begin */
-import type { ServiceStudent } from '../service/student.ts';
-export interface IModuleService {
-  'student': ServiceStudent;
-}
-/** service: end */
-/** service: begin */
-
-import 'vona';
-declare module 'vona' {
-  export interface IBeanRecordGeneral {
-    'training-student.service.student': ServiceStudent;
-  }
-}
-/** service: end */
-/** meta: begin */
-export * from '../bean/meta.index.ts';
-export * from '../bean/meta.version.ts';
-import type { IMetaOptionsIndex } from 'vona-module-a-index';
-import 'vona-module-a-meta';
-declare module 'vona-module-a-meta' {
-
-    export interface IMetaRecord {
-      'training-student:index': IMetaOptionsIndex;
-'training-student:version': never;
-    }
-
-
-}
-declare module 'vona-module-training-student' {
-
-        export interface MetaIndex {
-          /** @internal */
-          get scope(): ScopeModuleTrainingStudent;
-        }
-
-          export interface MetaIndex {
-            get $beanFullName(): 'training-student.meta.index';
-            get $onionName(): 'training-student:index';
-            get $onionOptions(): IMetaOptionsIndex;
-          }
-
-        export interface MetaVersion {
-          /** @internal */
-          get scope(): ScopeModuleTrainingStudent;
-        }
-
-          export interface MetaVersion {
-            get $beanFullName(): 'training-student.meta.version';
-            get $onionName(): 'training-student:version';
-          }
-}
-/** meta: end */
 /** dto: begin */
 export * from '../dto/detailRecordBase.tsx';
 export * from '../dto/detailRecordMutate.tsx';
@@ -381,58 +377,136 @@ import 'vona-module-a-openapi';
   }
 
 /** controller: end */
-/** ssrMenu: begin */
-export * from '../bean/ssrMenu.student.ts';
-import type { ISsrMenuOptionsStudent } from '../bean/ssrMenu.student.ts';
-import 'vona-module-a-ssr';
-declare module 'vona-module-a-ssr' {
+/** imageScene: begin */
+export * from '../bean/imageScene.studentImage.ts';
 
-    export interface ISsrMenuRecord {
-      'training-student:student': ISsrMenuOptionsStudent;
+import { type IDecoratorImageSceneOptions } from 'vona-module-a-image';
+declare module 'vona-module-a-image' {
+
+    export interface IImageSceneRecord {
+      'training-student:studentImage': IDecoratorImageSceneOptions;
     }
 
 
 }
 declare module 'vona-module-training-student' {
 
-        export interface SsrMenuStudent {
+        export interface ImageSceneStudentImage {
           /** @internal */
           get scope(): ScopeModuleTrainingStudent;
         }
 
-          export interface SsrMenuStudent {
-            get $beanFullName(): 'training-student.ssrMenu.student';
+          export interface ImageSceneStudentImage {
+            get $beanFullName(): 'training-student.imageScene.studentImage';
+            get $onionName(): 'training-student:studentImage';
+            get $onionOptions(): IDecoratorImageSceneOptions;
+          }
+}
+/** imageScene: end */
+/** service: begin */
+export * from '../service/student.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+
+    export interface IServiceRecord {
+      'training-student:student': never;
+    }
+
+
+}
+declare module 'vona-module-training-student' {
+
+        export interface ServiceStudent {
+          /** @internal */
+          get scope(): ScopeModuleTrainingStudent;
+        }
+
+          export interface ServiceStudent {
+            get $beanFullName(): 'training-student.service.student';
             get $onionName(): 'training-student:student';
-            get $onionOptions(): ISsrMenuOptionsStudent;
           }
 }
-/** ssrMenu: end */
-/** imageScene: begin */
-export * from '../bean/imageScene.studentImage.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceStudent } from '../service/student.ts';
+export interface IModuleService {
+  'student': ServiceStudent;
+}
+/** service: end */
+/** service: begin */
 
-import { type IDecoratorImageSceneOptions } from 'vona-module-a-image';
-declare module 'vona-module-a-image' {
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'training-student.service.student': ServiceStudent;
+  }
+}
+/** service: end */
+/** meta: begin */
+export * from '../bean/meta.index.ts';
+export * from '../bean/meta.version.ts';
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+import 'vona-module-a-meta';
+declare module 'vona-module-a-meta' {
 
-    export interface IImageSceneRecord {
-      'training-student:studentImage': IDecoratorImageSceneOptions;
+    export interface IMetaRecord {
+      'training-student:index': IMetaOptionsIndex;
+'training-student:version': never;
     }
 
 
 }
 declare module 'vona-module-training-student' {
 
-        export interface ImageSceneStudentImage {
+        export interface MetaIndex {
           /** @internal */
           get scope(): ScopeModuleTrainingStudent;
         }
 
-          export interface ImageSceneStudentImage {
-            get $beanFullName(): 'training-student.imageScene.studentImage';
-            get $onionName(): 'training-student:studentImage';
-            get $onionOptions(): IDecoratorImageSceneOptions;
+          export interface MetaIndex {
+            get $beanFullName(): 'training-student.meta.index';
+            get $onionName(): 'training-student:index';
+            get $onionOptions(): IMetaOptionsIndex;
+          }
+
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleTrainingStudent;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'training-student.meta.version';
+            get $onionName(): 'training-student:version';
           }
 }
-/** imageScene: end */
+/** meta: end */
+/** ssrMenu: begin */
+export * from '../bean/ssrMenu.student.ts';
+import type { ISsrMenuOptionsStudent } from '../bean/ssrMenu.student.ts';
+import 'vona-module-a-ssr';
+declare module 'vona-module-a-ssr' {
+
+    export interface ISsrMenuRecord {
+      'training-student:student': ISsrMenuOptionsStudent;
+    }
+
+
+}
+declare module 'vona-module-training-student' {
+
+        export interface SsrMenuStudent {
+          /** @internal */
+          get scope(): ScopeModuleTrainingStudent;
+        }
+
+          export interface SsrMenuStudent {
+            get $beanFullName(): 'training-student.ssrMenu.student';
+            get $onionName(): 'training-student:student';
+            get $onionOptions(): ISsrMenuOptionsStudent;
+          }
+}
+/** ssrMenu: end */
 /** locale: begin */
 import { locales } from './locales.ts';
 /** locale: end */

package/vona/src/suite/a-training/modules/training-student/src/bean/meta.index.ts

@@ -7,6 +7,7 @@ import { $tableColumns } from 'vona-module-a-ormutils';
 @Meta<IMetaOptionsIndex>({
   indexes: {
     ...$tableColumns('trainingStudent', 'name'),
+    ...$tableColumns('trainingStudentContent', 'studentId'),
   },
 })
 export class MetaIndex extends BeanBase {}

package/vona/src/suite/a-training/modules/training-student/src/bean/meta.version.ts

@@ -12,11 +12,29 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
         table.comment(entityStudent.$comment.$table);
         table.basicFields();
         table.string(entityStudent.name, 50).comment(entityStudent.$comment.name);
-        table.string(entityStudent.description, 255).comment(entityStudent.$comment.description);
         table.string(entityStudent.mobile, 50).comment(entityStudent.$comment.mobile);
         table.tableIdentity(entityStudent.imageId).comment(entityStudent.$comment.imageId);
         table.integer(entityStudent.level).comment(entityStudent.$comment.level);
       });
+
+      const entityStudentContent = this.scope.entity.studentContent;
+      await this.bean.model.createTable(entityStudentContent.$table, table => {
+        table.comment(entityStudentContent.$comment.$table);
+        table.basicFields();
+        table
+          .text(entityStudentContent.descriptionMarkdown)
+          .comment(entityStudentContent.$comment.descriptionMarkdown);
+        table
+          .text(entityStudentContent.descriptionHtml)
+          .comment(entityStudentContent.$comment.descriptionHtml);
+        table
+          .tableIdentity(entityStudentContent.studentId)
+          .comment(entityStudentContent.$comment.studentId);
+        table.index(
+          [entityStudentContent.studentId],
+          `idx_${entityStudentContent.$table}_studentId`,
+        );
+      });
     }
   }
 }

package/vona/src/suite/a-training/modules/training-student/src/config/locale/en-us.ts

@@ -1,5 +1,8 @@
 export default {
   Description: 'Description',
+  DescriptionMarkdown: 'Description Markdown',
+  DescriptionHtml: 'Description HTML',
+  StudentContent: 'Student Content',
   Level: 'Training Stage',
   BasicInformation: 'Basic Information',
   StudentProfile: 'Student Profile',

package/vona/src/suite/a-training/modules/training-student/src/config/locale/zh-cn.ts

@@ -1,5 +1,8 @@
 export default {
   Description: '描述',
+  DescriptionMarkdown: '描述 Markdown',
+  DescriptionHtml: '描述 HTML',
+  StudentContent: '学生内容',
   Level: '培训阶段',
   BasicInformation: '基本信息',
   StudentProfile: '学生资料',