cabloy 5.1.65 → 5.1.67

package/vona/src/suite/a-training/modules/training-record/test/record.test.ts

@@ -0,0 +1,138 @@
+import type {
+  DtoRecordCreate,
+  DtoRecordSelectRes,
+  DtoRecordUpdate,
+} from 'vona-module-training-record';
+import type { DtoStudentCreate } from 'vona-module-training-student';
+
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('record.test.ts', () => {
+  it('action:record', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const studentData: DtoStudentCreate = {
+        name: '__Student__',
+        description: 'This is a student for record test',
+        mobile: '13812345678',
+        level: 1,
+        trainingRecords: [],
+      };
+      const recordData = {
+        studentId: 0 as any,
+        name: '__Record__',
+        score: 88,
+        description: 'This is a record',
+        trainingRecordSubjects: [
+          {
+            name: '__Math__',
+            score: 95,
+            description: 'Math subject',
+          },
+        ],
+      } as any as DtoRecordCreate;
+      await app.bean.passport.signinMock();
+      const studentId = await app.bean.executor.performAction('post', '/training/student', {
+        body: studentData,
+      });
+      recordData.studentId = studentId;
+      const recordId = await app.bean.executor.performAction('post', '/training/record', {
+        body: recordData,
+      });
+      assert.equal(!!recordId, true);
+
+      const selectRes: DtoRecordSelectRes = await app.bean.executor.performAction(
+        'get',
+        '/training/record',
+      );
+      const recordItem = selectRes.list.find(item => String(item.id) === String(recordId));
+      assert.equal(!!recordItem, true);
+      assert.equal(recordItem!.name, recordData.name);
+      assert.equal(String(recordItem!.studentId), String(studentId));
+
+      let record: any = await app.bean.executor.performAction('get', '/training/record/:id', {
+        params: { id: recordId },
+      });
+      const recordSubject = record.trainingRecordSubjects?.[0];
+      assert.equal(record.name, recordData.name);
+      assert.equal(String(record.studentId), String(studentId));
+      assert.equal(record.trainingRecordSubjects?.length, 1);
+      assert.equal(recordSubject?.name, '__Math__');
+      assert.equal(recordSubject?.score, 95);
+
+      let student: any = await app.bean.executor.performAction('get', '/training/student/:id', {
+        params: { id: studentId },
+      });
+      let studentRecord = student.trainingRecords?.find(
+        (item: any) => String(item.id) === String(recordId),
+      );
+      assert.equal(!!studentRecord, true);
+      assert.equal(studentRecord?.trainingRecordSubjects?.length, 1);
+
+      const dataUpdate = {
+        studentId,
+        name: '__RecordNew__',
+        score: 89,
+        description: 'This is an updated record',
+        trainingRecordSubjects: [
+          {
+            id: recordSubject.id,
+            name: '__MathNew__',
+            score: 96,
+            description: 'Updated math subject',
+          },
+          {
+            name: '__English__',
+            score: 87,
+            description: 'English subject',
+          },
+        ],
+      } as any as DtoRecordUpdate;
+      await app.bean.executor.performAction('patch', '/training/record/:id', {
+        params: { id: recordId },
+        body: dataUpdate,
+      });
+
+      record = await app.bean.executor.performAction('get', '/training/record/:id', {
+        params: { id: recordId },
+      });
+      const [updatedMathSubject, updatedEnglishSubject] = record.trainingRecordSubjects ?? [];
+      assert.equal(record.name, dataUpdate.name);
+      assert.equal(record.score, dataUpdate.score);
+      assert.equal(record.trainingRecordSubjects?.length, 2);
+      assert.equal(updatedMathSubject?.name, '__MathNew__');
+      assert.equal(updatedMathSubject?.score, 96);
+      assert.equal(updatedEnglishSubject?.name, '__English__');
+      assert.equal(updatedEnglishSubject?.score, 87);
+
+      student = await app.bean.executor.performAction('get', '/training/student/:id', {
+        params: { id: studentId },
+      });
+      studentRecord = student.trainingRecords?.find(
+        (item: any) => String(item.id) === String(recordId),
+      );
+      assert.equal(studentRecord?.name, dataUpdate.name);
+      assert.equal(studentRecord?.trainingRecordSubjects?.length, 2);
+
+      await app.bean.executor.performAction('delete', '/training/record/:id', {
+        params: { id: recordId },
+      });
+
+      record = await app.bean.executor.performAction('get', '/training/record/:id', {
+        params: { id: recordId },
+      });
+      assert.equal(record, undefined);
+
+      student = await app.bean.executor.performAction('get', '/training/student/:id', {
+        params: { id: studentId },
+      });
+      studentRecord = student.trainingRecords?.find(
+        (item: any) => String(item.id) === String(recordId),
+      );
+      assert.equal(studentRecord, undefined);
+
+      await app.bean.passport.signout();
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+{
+  "name": "vona-module-training-recordsubject",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "training-recordsubject",
+  "vonaModule": {
+    "dependencies": {
+      "a-vona": "5.0.0"
+    },
+    "fileVersion": 1
+  }
+}

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

@@ -0,0 +1,198 @@
+// eslint-disable
+import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { TableIdentity } from 'table-identity';
+/** entity: begin */
+export * from '../entity/subject.tsx';
+import type { IEntityOptionsSubject } from '../entity/subject.tsx';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IEntityRecord {
+      'training-recordsubject:subject': IEntityOptionsSubject;
+    }
+
+  
+}
+declare module 'vona-module-training-recordsubject' {
+   
+}
+/** entity: end */
+/** entity: begin */
+import type { EntitySubject } from '../entity/subject.tsx';
+export interface IModuleEntity {
+  'subject': EntitySubjectMeta;
+}
+/** entity: end */
+/** entity: begin */
+export type EntitySubjectTableName = 'trainingRecordSubject';
+export type EntitySubjectMeta=TypeEntityMeta<EntitySubject,EntitySubjectTableName>;
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    'trainingRecordSubject': EntitySubjectMeta;
+  }
+}
+declare module 'vona-module-training-recordsubject' {
+  
+    export interface IEntityOptionsSubject {
+      fields?: TypeEntityOptionsFields<EntitySubject, IEntityOptionsSubject[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** entity: end */
+/** model: begin */
+export * from '../model/subject.ts';
+import type { IModelOptionsSubject } from '../model/subject.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IModelRecord {
+      'training-recordsubject:subject': IModelOptionsSubject;
+    }
+
+  
+}
+declare module 'vona-module-training-recordsubject' {
+  
+        export interface ModelSubject {
+          /** @internal */
+          get scope(): ScopeModuleTrainingRecordsubject;
+        }
+
+          export interface ModelSubject {
+            get $beanFullName(): 'training-recordsubject.model.subject';
+            get $onionName(): 'training-recordsubject:subject';
+            get $onionOptions(): IModelOptionsSubject;
+          } 
+}
+/** model: end */
+/** model: begin */
+import type { ModelSubject } from '../model/subject.ts';
+export interface IModuleModel {
+  'subject': ModelSubject;
+}
+/** model: end */
+/** model: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'training-recordsubject.model.subject': ModelSubject;
+  }
+}
+/** model: end */
+/** model: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelIncrementParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-training-recordsubject' {
+  
+  export interface ModelSubject {
+      [SymbolKeyEntity]: EntitySubject;
+      [SymbolKeyEntityMeta]: EntitySubjectMeta;
+      [SymbolKeyModelOptions]: IModelOptionsSubject;
+      get<T extends IModelGetOptions<EntitySubject,ModelSubject>>(where: TypeModelWhere<EntitySubject>, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+      mget<T extends IModelGetOptions<EntitySubject,ModelSubject>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntitySubject, ModelSubject, T>>;
+      select<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;
+      insert<T extends IModelInsertOptions<EntitySubject,ModelSubject>>(data?: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>, options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntitySubject,ModelSubject>>(items: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>[], options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntitySubject,ModelSubject>>(data: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>, options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntitySubject,ModelSubject>>(items: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>[], options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T>[]>;
+      delete<T extends IModelDeleteOptions<EntitySubject,ModelSubject>>(where?: TypeModelWhere<EntitySubject>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntitySubject,ModelSubject>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntitySubject,ModelSubject>>(data?: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>, options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntitySubject,ModelSubject>>(items: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>[], options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T>[]>;
+      count<T extends IModelSelectCountParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntitySubject, T>[]>;
+      getById<T extends IModelGetOptions<EntitySubject,ModelSubject>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntitySubject,ModelSubject>>(id: TableIdentity, data: TypeModelMutateRelationData<EntitySubject,ModelSubject, T>, options?: T): Promise<TypeModelMutateRelationData<EntitySubject,ModelSubject, T>>;
+deleteById<T extends IModelDeleteOptions<EntitySubject,ModelSubject>>(id: TableIdentity, options?: T): Promise<void>;
+getByName<T extends IModelGetOptions<EntitySubject,ModelSubject>>(name?: string, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+getByNameEqI<T extends IModelGetOptions<EntitySubject,ModelSubject>>(name?: string, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+selectByName<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;
+selectByNameEqI<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    'training-recordsubject:subject': ModelSubject;
+  }
+}
+/** model: 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-recordsubject:index': IMetaOptionsIndex;
+'training-recordsubject:version': never;
+    }
+
+  
+}
+declare module 'vona-module-training-recordsubject' {
+  
+        export interface MetaIndex {
+          /** @internal */
+          get scope(): ScopeModuleTrainingRecordsubject;
+        }
+
+          export interface MetaIndex {
+            get $beanFullName(): 'training-recordsubject.meta.index';
+            get $onionName(): 'training-recordsubject:index';
+            get $onionOptions(): IMetaOptionsIndex;
+          }
+
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleTrainingRecordsubject;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'training-recordsubject.meta.version';
+            get $onionName(): 'training-recordsubject:version';
+            
+          } 
+}
+/** meta: end */
+/** locale: begin */
+import { locales } from './locales.ts';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleTrainingRecordsubject extends BeanScopeBase {}
+
+export interface ScopeModuleTrainingRecordsubject {
+  util: BeanScopeUtil;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+entity: IModuleEntity;
+model: IModuleModel;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'training-recordsubject': ScopeModuleTrainingRecordsubject;
+  }
+
+  export interface IBeanScopeContainer {
+    trainingRecordsubject: ScopeModuleTrainingRecordsubject;
+  }
+  
+  
+
+  export interface IBeanScopeLocale {
+    'training-recordsubject': (typeof locales)[TypeLocaleBase];
+  }
+
+  
+}
+/** scope: end */

package/vona/src/suite/a-training/modules/training-recordsubject/src/.metadata/locales.ts

@@ -0,0 +1,18 @@
+import type { TypeLocaleBase } from 'vona';
+
+import { $makeLocaleMagic } from 'vona';
+
+import locale_en_us from '../config/locale/en-us.ts';
+import locale_zh_cn from '../config/locale/zh-cn.ts';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};
+
+export function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(
+  key: K,
+  ...args: any[]
+): any {
+  return $makeLocaleMagic(`training-recordsubject::${key}`, ...args);
+}

package/vona/src/suite/a-training/modules/training-recordsubject/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'training-recordsubject';
+export { ScopeModuleTrainingRecordsubject as ScopeModule } from './index.ts';

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

@@ -0,0 +1,12 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+import { $tableColumns } from 'vona-module-a-ormutils';
+
+@Meta<IMetaOptionsIndex>({
+  indexes: {
+    ...$tableColumns('trainingRecordSubject', 'recordId'),
+  },
+})
+export class MetaIndex extends BeanBase {}

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

@@ -0,0 +1,21 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version === 1) {
+      const entitySubject = this.scope.entity.subject;
+      await this.bean.model.createTable(entitySubject.$table, table => {
+        table.comment(entitySubject.$comment.$table);
+        table.basicFields();
+        table.tableIdentity(entitySubject.recordId).comment(entitySubject.$comment.recordId);
+        table.string(entitySubject.name, 50).comment(entitySubject.$comment.name);
+        table.integer(entitySubject.score).comment(entitySubject.$comment.score);
+        table.string(entitySubject.description, 255).comment(entitySubject.$comment.description);
+      });
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+export default {
+  Description: 'Description',
+  Name: 'Name',
+  Operations: 'Operations',
+  Score: 'Score',
+  Subject: 'Subject',
+  TrainingRecord: 'Student Training Record',
+  TrainingRecordSubject: 'Student Training Record Detail',
+};

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

@@ -0,0 +1,9 @@
+export default {
+  Description: '描述',
+  Name: '名称',
+  Operations: '操作',
+  Score: '科目得分',
+  Subject: '科目',
+  TrainingRecord: '学生培训记录',
+  TrainingRecordSubject: '学生培训记录明细',
+};

package/vona/src/suite/a-training/modules/training-recordsubject/src/entity/subject.tsx

@@ -0,0 +1,42 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsSubject extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsSubject>('trainingRecordSubject', {
+  openapi: { title: $locale('TrainingRecordSubject') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(
+      ZovaRender.order(-1, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+  },
+})
+export class EntitySubject extends EntityBase {
+  @Api.field(v.required(), ZovaRender.visible(false))
+  recordId: TableIdentity;
+
+  @Api.field(v.title($locale('Name')), v.required(), v.min(2), ZovaRender.order(1))
+  name: string;
+
+  @Api.field(v.title($locale('Score')), v.optional(), ZovaRender.order(2))
+  score?: number;
+
+  @Api.field(v.title($locale('Description')), v.optional(), ZovaRender.order(3))
+  description?: string;
+}

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

@@ -0,0 +1,2 @@
+export * from './.metadata/locales.ts';
+export * from './.metadata/index.ts';

package/vona/src/suite/a-training/modules/training-recordsubject/src/model/subject.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntitySubject } from '../entity/subject.tsx';
+
+export interface IModelOptionsSubject extends IDecoratorModelOptions<EntitySubject> {}
+
+@Model<IModelOptionsSubject>({ entity: EntitySubject })
+export class ModelSubject extends BeanModelBase<EntitySubject> {}

package/vona/src/suite/a-training/modules/training-recordsubject/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite/a-training/modules/training-recordsubject/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

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

@@ -28,7 +28,7 @@
     "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run tsc:publish",
     "prepack": "clean-package",
-    "postpack": "clean-package restore && npm run clean"
+    "postpack": "clean-package restore"
   },
   "dependencies": {},
   "devDependencies": {

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

@@ -12,5 +12,12 @@ export default {
   LevelTitle: 'Level Title',
   DescriptionLength: 'Description Length',
   ForceDelete: 'Force Delete',
-  TrainingRecords: 'Training Records',
+  TrainingRecords: 'Student Training Records',
+  AddTrainingRecord: 'Add Student Training Record',
+  EditTrainingRecord: 'Edit Student Training Record',
+  ViewTrainingRecord: 'View Student Training Record',
+  TrainingRecordSubjects: 'Student Training Record Details',
+  AddTrainingRecordSubject: 'Add Student Training Record Detail',
+  EditTrainingRecordSubject: 'Edit Student Training Record Detail',
+  ViewTrainingRecordSubject: 'View Student Training Record Detail',
 };

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

@@ -12,5 +12,12 @@ export default {
   LevelTitle: '阶段名称',
   DescriptionLength: '描述长度',
   ForceDelete: '强制删除',
-  TrainingRecords: '培训记录',
+  TrainingRecords: '学生培训记录',
+  AddTrainingRecord: '添加学生培训记录',
+  EditTrainingRecord: '编辑学生培训记录',
+  ViewTrainingRecord: '查看学生培训记录',
+  TrainingRecordSubjects: '学生培训记录明细',
+  AddTrainingRecordSubject: '添加学生培训记录明细',
+  EditTrainingRecordSubject: '编辑学生培训记录明细',
+  ViewTrainingRecordSubject: '查看学生培训记录明细',
 };

package/vona/src/suite/a-training/modules/training-student/src/dto/detailRecordBase.tsx

@@ -1,12 +1,27 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
+import { $makeMetadata, v } from 'vona-module-a-openapiutils';
 import { $Dto } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 import { ModelRecord } from 'vona-module-training-record';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
 
 export interface IDtoOptionsDetailRecordBase extends IDecoratorDtoOptions {}
 
-@Dto<IDtoOptionsDetailRecordBase>()
+@Dto<IDtoOptionsDetailRecordBase>({
+  fields: {
+    id: $makeMetadata(ZovaRender.visible(false)),
+    trainingRecordSubjects: $makeMetadata(
+      v.title($locale('TrainingRecordSubjects')),
+      ZovaRender.order(4),
+      ZovaRender.field('basic-details:formFieldDetails'),
+      v.optional(),
+    ),
+  },
+})
 export class DtoDetailRecordBase extends $Dto.get(() => ModelRecord, {
-  columns: ['id', 'name', 'score', 'description'],
+  columns: ['id', 'deleted', 'name', 'score', 'description'],
+  include: { trainingRecordSubjects: true },
 }) {}