cabloy 5.1.66 → 5.1.68

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',
+  Operations: 'Operations',
+  Subject: 'Subject',
+  SubjectName: 'Subject Name',
+  SubjectScore: 'Subject Score',
+  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: '描述',
+  Operations: '操作',
+  Subject: '科目',
+  SubjectName: '科目名称',
+  SubjectScore: '科目得分',
+  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('SubjectName')), v.required(), v.min(2), ZovaRender.order(1))
+  name: string;
+
+  @Api.field(v.title($locale('SubjectScore')), v.required(), 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/.metadata/index.ts

@@ -86,7 +86,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-training-student' {
   export interface IModelOptionsStudent {
         relations: {
-          trainingRecords: IModelRelationHasMany<'training-record:record', 'studentId', false, 'id'|'name'|'score'|'description', undefined, undefined, undefined>;
+          trainingRecords: IModelRelationHasMany<'training-record:record', 'studentId', false, 'id'|'name'|'subjectCount'|'totalScore'|'averageScore'|'trainingTime'|'description', undefined, undefined, undefined>;
         };
       }
   export interface ModelStudent {

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

@@ -5,15 +5,19 @@ export default {
   LevelBeginner: 'Foundation Track',
   LevelIntermediate: 'Progress Track',
   Mobile: 'Mobile',
-  Name: 'Name',
   Operations: 'Operations',
   Student: 'Student',
+  StudentName: 'Student Name',
   Summary: 'Summary',
   LevelTitle: 'Level Title',
   DescriptionLength: 'Description Length',
   ForceDelete: 'Force Delete',
-  TrainingRecords: 'Training Records',
-  AddTrainingRecord: 'Add Training Record',
-  EditTrainingRecord: 'Edit Training Record',
-  ViewTrainingRecord: 'View Training Record',
+  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

@@ -5,15 +5,19 @@ export default {
   LevelBeginner: '基础班',
   LevelIntermediate: '提升班',
   Mobile: '手机号',
-  Name: '名称',
   Operations: '操作',
   Student: '学生',
+  StudentName: '学生姓名',
   Summary: '摘要',
   LevelTitle: '阶段名称',
   DescriptionLength: '描述长度',
   ForceDelete: '强制删除',
-  TrainingRecords: '培训记录',
-  AddTrainingRecord: '添加培训记录',
-  EditTrainingRecord: '编辑培训记录',
-  ViewTrainingRecord: '查看培训记录',
+  TrainingRecords: '学生培训记录',
+  AddTrainingRecord: '添加学生培训记录',
+  EditTrainingRecord: '编辑学生培训记录',
+  ViewTrainingRecord: '查看学生培训记录',
+  TrainingRecordSubjects: '学生培训记录明细',
+  AddTrainingRecordSubject: '添加学生培训记录明细',
+  EditTrainingRecordSubject: '编辑学生培训记录明细',
+  ViewTrainingRecordSubject: '查看学生培训记录明细',
 };

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

@@ -1,18 +1,36 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
-import { $makeMetadata } from 'vona-module-a-openapiutils';
+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>({
   fields: {
     id: $makeMetadata(ZovaRender.visible(false)),
+    trainingRecordSubjects: $makeMetadata(
+      v.title($locale('TrainingRecordSubjects')),
+      ZovaRender.order(8),
+      ZovaRender.field('basic-details:formFieldDetails'),
+      v.optional(),
+    ),
   },
 })
 export class DtoDetailRecordBase extends $Dto.get(() => ModelRecord, {
-  columns: ['id', 'deleted', 'name', 'score', 'description'],
+  columns: [
+    'id',
+    'deleted',
+    'name',
+    'subjectCount',
+    'totalScore',
+    'averageScore',
+    'trainingTime',
+    'description',
+  ],
+  include: { trainingRecordSubjects: true },
 }) {}

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

@@ -1,8 +1,13 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
+import { Api, 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 {
+  DtoDetailRecordSubjectMutate,
+  DtoDetailRecordSubjectResItem,
+  ModelRecord,
+} from 'vona-module-training-record';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { DtoDetailRecordBase } from './detailRecordBase.tsx';
@@ -14,4 +19,8 @@ export interface IDtoOptionsDetailRecordMutate extends IDecoratorDtoOptions {}
 })
 export class DtoDetailRecordMutate extends $Dto.mutate(() => ModelRecord, {
   dtoClass: DtoDetailRecordBase,
-}) {}
+  include: { trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectMutate } },
+}) {
+  @Api.field(ZovaRender.visible(false), v.optional(), v.array(DtoDetailRecordSubjectResItem))
+  _trainingRecordSubjects?: DtoDetailRecordSubjectResItem[];
+}

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

@@ -37,6 +37,7 @@ export interface IDtoOptionsDetailRecordResItem extends IDecoratorDtoOptions {}
 })
 export class DtoDetailRecordResItem extends $Dto.get(() => ModelRecord, {
   dtoClass: DtoDetailRecordBase,
+  include: { trainingRecordSubjects: false },
 }) {
   @Api.field(v.title('#'), ZovaRender.order(1, 'core'), ZovaRender.cell('basic-details:lineNumber'))
   _lineNumber?: number;

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

@@ -1,8 +1,13 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
+import { Api, 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 {
+  DtoDetailRecordSubjectResItem,
+  DtoDetailRecordSubjectView,
+  ModelRecord,
+} from 'vona-module-training-record';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { DtoDetailRecordBase } from './detailRecordBase.tsx';
@@ -14,4 +19,8 @@ export interface IDtoOptionsDetailRecordView extends IDecoratorDtoOptions {}
 })
 export class DtoDetailRecordView extends $Dto.get(() => ModelRecord, {
   dtoClass: DtoDetailRecordBase,
-}) {}
+  include: { trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectView } },
+}) {
+  @Api.field(ZovaRender.visible(false), v.optional(), v.array(DtoDetailRecordSubjectResItem))
+  _trainingRecordSubjects?: DtoDetailRecordSubjectResItem[];
+}

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

@@ -13,7 +13,7 @@ export class DtoStudentSummary {
   @Api.field(v.tableIdentity())
   id: TableIdentity;
 
-  @Api.field(v.title($locale('Name')))
+  @Api.field(v.title($locale('StudentName')))
   name: string;
 
   @Api.field(

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

@@ -2,6 +2,7 @@ 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 z from 'zod';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { $locale } from '../.metadata/locales.ts';
@@ -34,7 +35,7 @@ export interface IEntityOptionsStudent extends IDecoratorEntityOptions {}
 })
 export class EntityStudent extends EntityBase {
   @Api.field(
-    v.title($locale('Name')),
+    v.title($locale('StudentName')),
     v.required(),
     v.min(2),
     ZovaRender.order(1),
@@ -75,6 +76,7 @@ export class EntityStudent extends EntityBase {
     }),
     // Tutorial 4 custom table cell renderer example used by the current implementation.
     ZovaRender.cell('training-student:level', { items: studentLevelItems }),
+    z.union([z.literal(1), z.literal(2), z.literal(3)]),
   )
   level: number;
 }

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

@@ -10,7 +10,15 @@ export interface IModelOptionsStudent extends IDecoratorModelOptions<EntityStude
   entity: EntityStudent,
   relations: {
     trainingRecords: $relation.hasMany('training-record:record', 'studentId', {
-      columns: ['id', 'name', 'score', 'description'],
+      columns: [
+        'id',
+        'name',
+        'subjectCount',
+        'totalScore',
+        'averageScore',
+        'trainingTime',
+        'description',
+      ],
     }),
   },
 })

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

@@ -12,10 +12,18 @@ import type { DtoStudentView } from '../dto/studentView.tsx';
 import type { EntityStudent } from '../entity/student.tsx';
 import type { ModelStudent } from '../model/student.ts';
 
+function getStudentRecordSubjectsInclude(): {
+  trainingRecords: { include: { trainingRecordSubjects: true } };
+} {
+  return { trainingRecords: { include: { trainingRecordSubjects: true } } };
+}
+
 @Service()
 export class ServiceStudent extends BeanBase {
   async create(student: DtoStudentCreate): Promise<EntityStudent> {
-    return await this.scope.model.student.insert(student, { include: { trainingRecords: true } });
+    return await this.scope.model.student.insert(student, {
+      include: getStudentRecordSubjectsInclude(),
+    });
   }
 
   async select(params?: IQueryParams<ModelStudent>): Promise<DtoStudentSelectRes> {
@@ -23,12 +31,14 @@ export class ServiceStudent extends BeanBase {
   }
 
   async view(id: TableIdentity): Promise<DtoStudentView | undefined> {
-    return await this.scope.model.student.getById(id, { include: { trainingRecords: true } });
+    return await this.scope.model.student.getById(id, {
+      include: getStudentRecordSubjectsInclude(),
+    });
   }
 
   async update(id: TableIdentity, student: DtoStudentUpdate) {
     return await this.scope.model.student.updateById(id, student, {
-      include: { trainingRecords: true },
+      include: getStudentRecordSubjectsInclude(),
     });
   }
 
@@ -50,13 +60,15 @@ export class ServiceStudent extends BeanBase {
   }
 
   async delete(id: TableIdentity) {
-    return await this.scope.model.student.deleteById(id, { include: { trainingRecords: true } });
+    return await this.scope.model.student.deleteById(id, {
+      include: getStudentRecordSubjectsInclude(),
+    });
   }
 
   async deleteForce(id: TableIdentity) {
     return await this.scope.model.student.deleteById(id, {
       disableDeleted: true,
-      include: { trainingRecords: true },
+      include: getStudentRecordSubjectsInclude(),
     });
   }
 }