cabloy 5.1.66 → 5.1.68

package/vona/src/suite/a-training/modules/training-record/src/dto/recordSelectReq.tsx

@@ -0,0 +1,38 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeSchema, $resourceName, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { EntityRecord } from '../entity/record.tsx';
+
+export interface IDtoOptionsRecordSelectReq extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRecordSelectReq>({
+  openapi: { filter: { table: 'trainingRecord' } },
+  fields: {
+    name: $makeSchema(v.optional(), z.string()),
+    studentId: $makeSchema(
+      v.title($locale('Student')),
+      ZovaRender.field('basic-resource:formFieldResourcePicker', {
+        resource: $resourceName('training-student:student'),
+      }),
+      v.optional(),
+      z.number(),
+    ),
+    createdAt: $makeSchema(
+      ZovaRender.field('basic-date:formFieldDateRange'),
+      v.filterTransform('a-web:dateRange'),
+      v.optional(),
+      z.string(),
+    ),
+  },
+})
+export class DtoRecordSelectReq extends $Dto.queryPage(EntityRecord, [
+  'name',
+  'studentId',
+  'createdAt',
+]) {}

package/vona/src/suite/a-training/modules/training-record/src/dto/recordSelectRes.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoRecordSelectResItem } from './recordSelectResItem.tsx';
+
+export interface IDtoOptionsRecordSelectRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRecordSelectRes>()
+export class DtoRecordSelectRes extends $Dto.listAndCount(DtoRecordSelectResItem) {}

package/vona/src/suite/a-training/modules/training-record/src/dto/recordSelectResItem.tsx

@@ -0,0 +1,39 @@
+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 { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelRecord } from '../model/record.ts';
+
+export interface IDtoOptionsRecordSelectResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRecordSelectResItem>({
+  blocks: [
+    ZovaRender.block('basic-page:blockPage', {
+      blocks: [
+        ZovaRender.block('basic-page:blockFilter'),
+        ZovaRender.block('basic-page:blockToolbarBulk', {
+          actions: [ZovaRender.tableActionBulk('basic-table:actionCreate')],
+        }),
+        ZovaRender.block('basic-page:blockTable'),
+        ZovaRender.block('basic-page:blockPager'),
+      ],
+    }),
+  ],
+})
+export class DtoRecordSelectResItem extends $Dto.get(() => ModelRecord) {
+  @Api.field(
+    v.title($locale('Operations')),
+    ZovaRender.order(1, 'max'),
+    ZovaRender.cell('basic-table:actionOperationsRow', {
+      actions: [
+        ZovaRender.tableActionRow('basic-table:actionUpdate'),
+        ZovaRender.tableActionRow('basic-table:actionDelete'),
+      ],
+    }),
+  )
+  _operationsRow?: unknown;
+}

package/vona/src/suite/a-training/modules/training-record/src/dto/recordUpdate.tsx

@@ -0,0 +1,45 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelRecord } from '../model/record.ts';
+import { DtoDetailRecordSubjectMutate } from './detailRecordSubjectMutate.tsx';
+import { DtoDetailRecordSubjectResItem } from './detailRecordSubjectResItem.tsx';
+
+export interface IDtoOptionsRecordUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRecordUpdate>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionSubmit', {
+              permission: { actionInherit: 'update', formScene: ['create', 'edit'] },
+            }),
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+  fields: {
+    trainingRecordSubjects: $makeMetadata(
+      v.title($locale('TrainingRecordSubjects')),
+      ZovaRender.order(8),
+      ZovaRender.field('basic-details:formFieldDetails'),
+      v.optional(),
+    ),
+  },
+})
+export class DtoRecordUpdate extends $Dto.update(() => ModelRecord, {
+  include: { trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectMutate } },
+}) {
+  @Api.field(ZovaRender.visible(false), v.optional(), v.array(DtoDetailRecordSubjectResItem))
+  _trainingRecordSubjects?: DtoDetailRecordSubjectResItem[];
+}

package/vona/src/suite/a-training/modules/training-record/src/dto/recordView.tsx

@@ -0,0 +1,42 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelRecord } from '../model/record.ts';
+import { DtoDetailRecordSubjectResItem } from './detailRecordSubjectResItem.tsx';
+import { DtoDetailRecordSubjectView } from './detailRecordSubjectView.tsx';
+
+export interface IDtoOptionsRecordView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRecordView>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+  fields: {
+    trainingRecordSubjects: $makeMetadata(
+      v.title($locale('TrainingRecordSubjects')),
+      ZovaRender.order(8),
+      ZovaRender.field('basic-details:formFieldDetails'),
+      v.optional(),
+    ),
+  },
+})
+export class DtoRecordView extends $Dto.get(() => ModelRecord, {
+  include: { trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectView } },
+}) {
+  @Api.field(ZovaRender.visible(false), v.optional(), v.array(DtoDetailRecordSubjectResItem))
+  _trainingRecordSubjects?: DtoDetailRecordSubjectResItem[];
+}

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

@@ -1,7 +1,7 @@
 import type { TableIdentity } from 'table-identity';
 import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
 
-import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { $makeMetadata, $resourceName, Api, v } from 'vona-module-a-openapiutils';
 import { Entity, EntityBase } from 'vona-module-a-orm';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
@@ -28,15 +28,47 @@ export interface IEntityOptionsRecord extends IDecoratorEntityOptions {}
   },
 })
 export class EntityRecord extends EntityBase {
-  @Api.field(v.required(), ZovaRender.visible(false))
+  @Api.field(
+    v.title($locale('TrainingRecordName')),
+    v.required(),
+    v.min(2),
+    ZovaRender.order(1),
+    ZovaRender.cell('basic-table:actionView'),
+  )
+  name: string;
+
+  @Api.field(
+    v.title($locale('Student')),
+    v.required(),
+    ZovaRender.order(2),
+    ZovaRender.field('basic-resource:formFieldResourcePicker', {
+      resource: $resourceName('training-student:student'),
+    }),
+    ZovaRender.cell('basic-resource:resourcePicker', {
+      resource: $resourceName('training-student:student'),
+    }),
+    v.tableIdentity(),
+  )
   studentId: TableIdentity;
 
-  @Api.field(v.title($locale('Name')), v.required(), v.min(2), ZovaRender.order(1))
-  name: string;
+  @Api.field(v.title($locale('SubjectCount')), v.optional(), ZovaRender.order(3))
+  subjectCount?: number;
+
+  @Api.field(v.title($locale('TotalScore')), v.optional(), ZovaRender.order(4))
+  totalScore?: number;
+
+  @Api.field(v.title($locale('AverageScore')), v.optional(), ZovaRender.order(5))
+  averageScore?: number;
 
-  @Api.field(v.title($locale('Score')), v.optional(), ZovaRender.order(2))
-  score?: number;
+  @Api.field(
+    v.title($locale('TrainingTime')),
+    v.optional(),
+    ZovaRender.order(6),
+    ZovaRender.field('basic-date:formFieldDate'),
+    ZovaRender.cell('basic-date:date'),
+  )
+  trainingTime?: Date;
 
-  @Api.field(v.title($locale('Description')), v.optional(), ZovaRender.order(3))
+  @Api.field(v.title($locale('Description')), v.optional(), ZovaRender.order(7))
   description?: string;
 }

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

@@ -1,10 +1,23 @@
 import type { IDecoratorModelOptions } from 'vona-module-a-orm';
 
-import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
 
 import { EntityRecord } from '../entity/record.tsx';
 
 export interface IModelOptionsRecord extends IDecoratorModelOptions<EntityRecord> {}
 
-@Model<IModelOptionsRecord>({ entity: EntityRecord })
+@Model<IModelOptionsRecord>({
+  entity: EntityRecord,
+  relations: {
+    student: $relation.belongsTo(
+      'training-record:record',
+      'training-student:student',
+      'studentId',
+      { columns: ['id', 'name'] },
+    ),
+    trainingRecordSubjects: $relation.hasMany('training-recordsubject:subject', 'recordId', {
+      columns: ['id', 'name', 'score', 'description'],
+    }),
+  },
+})
 export class ModelRecord extends BeanModelBase<EntityRecord> {}

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

@@ -0,0 +1,50 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { DtoRecordCreate } from '../dto/recordCreate.tsx';
+import type { DtoRecordSelectRes } from '../dto/recordSelectRes.tsx';
+import type { DtoRecordUpdate } from '../dto/recordUpdate.tsx';
+import type { DtoRecordView } from '../dto/recordView.tsx';
+import type { EntityRecord } from '../entity/record.tsx';
+import type { ModelRecord } from '../model/record.ts';
+
+function getRecordSubjectsInclude(): { trainingRecordSubjects: true; student: true } {
+  return { trainingRecordSubjects: true, student: true };
+}
+
+@Service()
+export class ServiceRecord extends BeanBase {
+  async create(record: DtoRecordCreate): Promise<EntityRecord> {
+    return await this.scope.model.record.insert(record, {
+      include: getRecordSubjectsInclude(),
+    });
+  }
+
+  async select(params?: IQueryParams<ModelRecord>): Promise<DtoRecordSelectRes> {
+    return await this.scope.model.record.selectAndCount({
+      ...params,
+      include: { student: true },
+    });
+  }
+
+  async view(id: TableIdentity): Promise<DtoRecordView | undefined> {
+    return await this.scope.model.record.getById(id, {
+      include: getRecordSubjectsInclude(),
+    });
+  }
+
+  async update(id: TableIdentity, record: DtoRecordUpdate) {
+    return await this.scope.model.record.updateById(id, record, {
+      include: getRecordSubjectsInclude(),
+    });
+  }
+
+  async delete(id: TableIdentity) {
+    return await this.scope.model.record.deleteById(id, {
+      include: getRecordSubjectsInclude(),
+    });
+  }
+}

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

@@ -0,0 +1,162 @@
+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 trainingTime = new Date('2026-01-15T09:30:00.000Z');
+      const trainingTimeUpdate = new Date('2026-02-20T14:45:00.000Z');
+      const recordData = {
+        studentId: 0 as any,
+        name: '__Record__',
+        subjectCount: 1,
+        totalScore: 88,
+        averageScore: 88,
+        trainingTime,
+        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.subjectCount, recordData.subjectCount);
+      assert.equal(record.totalScore, recordData.totalScore);
+      assert.equal(record.averageScore, recordData.averageScore);
+      assert.equal(new Date(record.trainingTime).toISOString(), trainingTime.toISOString());
+      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__',
+        subjectCount: 2,
+        totalScore: 183,
+        averageScore: 91.5,
+        trainingTime: trainingTimeUpdate,
+        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.subjectCount, dataUpdate.subjectCount);
+      assert.equal(record.totalScore, dataUpdate.totalScore);
+      assert.equal(record.averageScore, dataUpdate.averageScore);
+      assert.equal(new Date(record.trainingTime).toISOString(), trainingTimeUpdate.toISOString());
+      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.executor.performAction('delete', '/training/student/:id', {
+        params: { id: studentId },
+      });
+
+      student = await app.bean.executor.performAction('get', '/training/student/:id', {
+        params: { id: studentId },
+      });
+      assert.equal(student, 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
+  }
+}