Merge pull request #9 from NanGua-QWQ/dev

NanGua-QWQ · web-flow · commit 400388c26781 · 2026-02-07T23:00:51.000+08:00
feat:现在可以添加学生Tag
diff --git a/src/main/db/DbManager.ts b/src/main/db/DbManager.ts
@@ -2,13 +2,13 @@ import { Context, Service } from '../../shared/kernel'
 import { DataSource } from 'typeorm'
 import path from 'path'
 import fs from 'fs'
-import {
-  ReasonEntity,
-  ScoreEventEntity,
-  SettlementEntity,
-  SettingEntity,
-  StudentEntity
-} from './entities'
+import { StudentEntity } from './entities/StudentEntity'
+import { ReasonEntity } from './entities/ReasonEntity'
+import { ScoreEventEntity } from './entities/ScoreEventEntity'
+import { SettlementEntity } from './entities/SettlementEntity'
+import { SettingEntity } from './entities/SettingEntity'
+import { TagEntity } from './entities/TagEntity'
+import { StudentTagEntity } from './entities/StudentTagEntity'
 import { migrations } from './migrations'
 
 declare module '../../shared/kernel' {
@@ -29,7 +29,7 @@ export class DbManager extends Service {
     this.dataSource = new DataSource({
       type: 'better-sqlite3',
       database: dbPath,
-      entities: [StudentEntity, ReasonEntity, ScoreEventEntity, SettlementEntity, SettingEntity],
+      entities: [StudentEntity, ReasonEntity, ScoreEventEntity, SettlementEntity, SettingEntity, TagEntity, StudentTagEntity],
       migrations,
       synchronize: false,
       logging: false
diff --git a/src/main/db/entities/StudentEntity.ts b/src/main/db/entities/StudentEntity.ts
@@ -1,4 +1,5 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
+import { Column, Entity, PrimaryGeneratedColumn, ManyToMany, JoinTable } from 'typeorm'
+import { TagEntity } from './TagEntity'
 
 @Entity({ name: 'students' })
 export class StudentEntity {
@@ -8,6 +9,9 @@ export class StudentEntity {
   @Column({ type: 'text' })
   name!: string
 
+  @Column({ type: 'text', default: '[]' })
+  tags!: string
+  
   @Column({ type: 'integer', default: 0 })
   score!: number
 
@@ -19,4 +23,12 @@ export class StudentEntity {
 
   @Column({ type: 'text', default: () => 'CURRENT_TIMESTAMP' })
   updated_at!: string
+
+  @ManyToMany(() => TagEntity, { cascade: true })
+  @JoinTable({
+    name: 'student_tags',
+    joinColumn: { name: 'student_id', referencedColumnName: 'id' },
+    inverseJoinColumn: { name: 'tag_id', referencedColumnName: 'id' }
+  })
+  tagEntities!: TagEntity[]
 }
diff --git a/src/main/db/entities/StudentTagEntity.ts b/src/main/db/entities/StudentTagEntity.ts
@@ -0,0 +1,27 @@
+import { Column, Entity, PrimaryGeneratedColumn, ManyToOne, JoinColumn, Index } from 'typeorm'
+import { StudentEntity } from './StudentEntity'
+import { TagEntity } from './TagEntity'
+
+@Entity({ name: 'student_tags' })
+@Index(['student_id', 'tag_id'], { unique: true })
+export class StudentTagEntity {
+  @PrimaryGeneratedColumn()
+  id!: number
+
+  @Column({ name: 'student_id', type: 'integer' })
+  student_id!: number
+
+  @Column({ name: 'tag_id', type: 'integer' })
+  tag_id!: number
+
+  @ManyToOne(() => StudentEntity, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'student_id' })
+  student!: StudentEntity
+
+  @ManyToOne(() => TagEntity, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'tag_id' })
+  tag!: TagEntity
+
+  @Column({ type: 'text', default: () => 'CURRENT_TIMESTAMP' })
+  created_at!: string
+}
diff --git a/src/main/db/entities/TagEntity.ts b/src/main/db/entities/TagEntity.ts
@@ -0,0 +1,16 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
+
+@Entity({ name: 'tags' })
+export class TagEntity {
+  @PrimaryGeneratedColumn()
+  id!: number
+
+  @Column({ type: 'text', unique: true })
+  name!: string
+
+  @Column({ type: 'text', default: () => 'CURRENT_TIMESTAMP' })
+  created_at!: string
+
+  @Column({ type: 'text', default: () => 'CURRENT_TIMESTAMP' })
+  updated_at!: string
+}
diff --git a/src/main/db/entities/index.ts b/src/main/db/entities/index.ts
@@ -3,3 +3,5 @@ export { ReasonEntity } from './ReasonEntity'
 export { ScoreEventEntity } from './ScoreEventEntity'
 export { SettlementEntity } from './SettlementEntity'
 export { SettingEntity } from './SettingEntity'
+export { TagEntity } from './TagEntity'
+export { StudentTagEntity } from './StudentTagEntity'
diff --git a/src/main/db/migrations/AddTagsSchema2026020600000.ts b/src/main/db/migrations/AddTagsSchema2026020600000.ts
@@ -0,0 +1,53 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class AddTagsSchema2026020600000 implements MigrationInterface {
+  name = 'AddTagsSchema2026020600000'
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    if (!(await queryRunner.hasTable('tags'))) {
+      await queryRunner.query(`
+        CREATE TABLE "tags" (
+          "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+          "name" text NOT NULL UNIQUE,
+          "created_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP),
+          "updated_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP)
+        )
+      `)
+    }
+
+    if (!(await queryRunner.hasTable('student_tags'))) {
+      await queryRunner.query(`
+        CREATE TABLE "student_tags" (
+          "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+          "student_id" integer NOT NULL,
+          "tag_id" integer NOT NULL,
+          "created_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP),
+          FOREIGN KEY ("student_id") REFERENCES "students"("id") ON DELETE CASCADE,
+          FOREIGN KEY ("tag_id") REFERENCES "tags"("id") ON DELETE CASCADE,
+          UNIQUE("student_id", "tag_id")
+        )
+      `)
+    }
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_student_tags_student_id" ON "student_tags" ("student_id")`
+    )
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_student_tags_tag_id" ON "student_tags" ("tag_id")`
+    )
+
+    await queryRunner.query(`
+      INSERT OR IGNORE INTO "tags" ("name") VALUES
+      ('优秀生'),
+      ('班干部'),
+      ('勤奋'),
+      ('活跃'),
+      ('进步快')
+    `)
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS "student_tags"`)
+    await queryRunner.query(`DROP TABLE IF EXISTS "tags"`)
+  }
+}
diff --git a/src/main/db/migrations/InitSchema2026011800000.ts b/src/main/db/migrations/InitSchema2026011800000.ts
@@ -11,6 +11,7 @@ export class InitSchema2026011800000 implements MigrationInterface {
           "name" text NOT NULL,
           "score" integer NOT NULL DEFAULT (0),
           "extra_json" text,
+          "tags" text NOT NULL DEFAULT '[]',
           "created_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP),
           "updated_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP)
         )
diff --git a/src/main/db/migrations/index.ts b/src/main/db/migrations/index.ts
@@ -1,3 +1,4 @@
 import { InitSchema2026011800000 } from './InitSchema2026011800000'
+import { AddTagsSchema2026020600000 } from './AddTagsSchema2026020600000'
 
-export const migrations = [InitSchema2026011800000]
+export const migrations = [InitSchema2026011800000, AddTagsSchema2026020600000]
diff --git a/src/main/hosting/index.ts b/src/main/hosting/index.ts
@@ -12,6 +12,7 @@ export {
   ReasonRepositoryToken,
   EventRepositoryToken,
   SettlementRepositoryToken,
+  TagRepositoryToken,
   ThemeServiceToken,
   WindowManagerToken,
   TrayServiceToken,
diff --git a/src/main/hosting/tokens.ts b/src/main/hosting/tokens.ts
@@ -10,6 +10,7 @@ export const StudentRepositoryToken = Symbol.for('secscore.studentRepository')
 export const ReasonRepositoryToken = Symbol.for('secscore.reasonRepository')
 export const EventRepositoryToken = Symbol.for('secscore.eventRepository')
 export const SettlementRepositoryToken = Symbol.for('secscore.settlementRepository')
+export const TagRepositoryToken = Symbol.for('secscore.tagRepository')
 export const ThemeServiceToken = Symbol.for('secscore.themeService')
 export const WindowManagerToken = Symbol.for('secscore.windowManager')
 export const TrayServiceToken = Symbol.for('secscore.trayService')
diff --git a/src/main/index.ts b/src/main/index.ts
@@ -13,13 +13,15 @@ import { PermissionService } from './services/PermissionService'
 import { AuthService } from './services/AuthService'
 import { DataService } from './services/DataService'
 import { ThemeService } from './services/ThemeService'
+import { HttpServerService } from './services/HttpServerService'
 import { WindowManager, type windowManagerOptions } from './services/WindowManager'
 import { TrayService } from './services/TrayService'
 import { AutoScoreService } from './services/AutoScoreService'
 import { StudentRepository } from './repos/StudentRepository'
 import { ReasonRepository } from './repos/ReasonRepository'
 import { EventRepository } from './repos/EventRepository'
 import { SettlementRepository } from './repos/SettlementRepository'
+import { TagRepository } from './repos/TagRepository'
 import {
   AppConfigToken,
   createHostBuilder,
@@ -32,13 +34,13 @@ import {
   SettlementRepositoryToken,
   SettingsStoreToken,
   StudentRepositoryToken,
+  TagRepositoryToken,
   ThemeServiceToken,
   WindowManagerToken,
   TrayServiceToken,
   AutoScoreServiceToken,
   HttpServerServiceToken
 } from './hosting'
-import { HttpServerService } from './services/HttpServerService'
 
 type mainAppConfig = {
   isDev: boolean
@@ -230,7 +232,7 @@ app.whenReady().then(async () => {
         (p) => new PermissionService(p.get(MainContext))
       )
       services.addSingleton(AuthService, (p) => new AuthService(p.get(MainContext)))
-      services.addSingleton(DataService, (p) => new DataService(p.get(MainContext)))
+      services.addSingleton(DataService, (p) => new DataService(p.get(MainContext), p.get(TagRepositoryToken)))
 
       services.addSingleton(
         StudentRepositoryToken,
@@ -242,6 +244,10 @@ app.whenReady().then(async () => {
         SettlementRepositoryToken,
         (p) => new SettlementRepository(p.get(MainContext))
       )
+      services.addSingleton(
+        TagRepositoryToken,
+        (p) => new TagRepository((p.get(DbManagerToken) as DbManager).dataSource)
+      )
 
       services.addSingleton(
         ThemeServiceToken,
diff --git a/src/main/repos/StudentRepository.ts b/src/main/repos/StudentRepository.ts
@@ -6,6 +6,7 @@ export interface student {
   id: number
   name: string
   score: number
+  tags?: string[]
   extra_json?: string
 }
 
@@ -74,7 +75,26 @@ export class StudentRepository extends Service {
 
   async findAll(): Promise<student[]> {
     const repo = this.ctx.db.dataSource.getRepository(StudentEntity)
-    return (await repo.find({ order: { score: 'DESC', name: 'ASC' } })) as any
+    const entities = await repo.find({
+      select: ['id', 'name', 'score', 'tags', 'extra_json', 'created_at', 'updated_at'],
+      order: { score: 'DESC', name: 'ASC' }
+    })
+
+    return entities.map(entity => {
+      let tags: string[] = []
+      try {
+        tags = Array.isArray(entity.tags) ? entity.tags : JSON.parse(entity.tags || '[]')
+      } catch {
+        tags = []
+      }
+      return {
+        id: entity.id,
+        name: entity.name,
+        score: entity.score,
+        tags,
+        extra_json: entity.extra_json ?? undefined
+      }
+    })
   }
 
   async create(student: { name: string }): Promise<number> {
@@ -83,6 +103,7 @@ export class StudentRepository extends Service {
       name: String(student?.name ?? '').trim(),
       score: 0,
       extra_json: null,
+      tags: '[]',
       created_at: new Date().toISOString(),
       updated_at: new Date().toISOString()
     })
@@ -94,7 +115,11 @@ export class StudentRepository extends Service {
     const next: any = {}
     for (const [key, val] of Object.entries(student)) {
       if (key === 'id') continue
+      if (key === 'tags') {
+        next[key] = JSON.stringify(val || [])
+    } else {
       next[key] = val
+      }
     }
     next.updated_at = new Date().toISOString()
     await this.ctx.db.dataSource.getRepository(StudentEntity).update(id, next)
@@ -142,6 +167,7 @@ export class StudentRepository extends Service {
               typeof i.secrandomId === 'number'
                 ? JSON.stringify({ secrandom_id: i.secrandomId })
                 : null,
+            tags: '[]',
             created_at: now,
             updated_at: now
           }))
diff --git a/src/main/repos/TagRepository.ts b/src/main/repos/TagRepository.ts
@@ -0,0 +1,79 @@
+import { DataSource, Repository } from 'typeorm'
+import { TagEntity } from '../db/entities/TagEntity'
+import { StudentTagEntity } from '../db/entities/StudentTagEntity'
+
+export class TagRepository {
+  private tagRepo: Repository<TagEntity>
+  private studentTagRepo: Repository<StudentTagEntity>
+
+  constructor(dataSource: DataSource) {
+    this.tagRepo = dataSource.getRepository(TagEntity)
+    this.studentTagRepo = dataSource.getRepository(StudentTagEntity)
+  }
+
+  async findAll(): Promise<TagEntity[]> {
+    return this.tagRepo.find({ order: { created_at: 'ASC' } })
+  }
+
+  async findByName(name: string): Promise<TagEntity | null> {
+    return this.tagRepo.findOne({ where: { name } })
+  }
+
+  async create(name: string): Promise<TagEntity> {
+    const tag = this.tagRepo.create({ name })
+    return this.tagRepo.save(tag)
+  }
+
+  async findOrCreate(name: string): Promise<TagEntity> {
+    const existing = await this.findByName(name)
+    if (existing) return existing
+    return this.create(name)
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this.tagRepo.delete(id)
+    return result.affected === 1
+  }
+
+  async findByStudent(studentId: number): Promise<TagEntity[]> {
+    const relations = await this.studentTagRepo
+      .createQueryBuilder('st')
+      .leftJoinAndSelect('st.tag', 'tag')
+      .where('st.student_id = :studentId', { studentId })
+      .orderBy('st.created_at', 'ASC')
+      .getMany()
+
+    return relations.map(r => r.tag).filter(Boolean)
+  }
+
+  async addTagToStudent(studentId: number, tagId: number): Promise<void> {
+    const exists = await this.studentTagRepo.findOne({
+      where: { student_id: studentId, tag_id: tagId }
+    })
+    if (!exists) {
+      const relation = this.studentTagRepo.create({
+        student_id: studentId,
+        tag_id: tagId
+      })
+      await this.studentTagRepo.save(relation)
+    }
+  }
+
+  async removeTagFromStudent(studentId: number, tagId: number): Promise<void> {
+    await this.studentTagRepo.delete({
+      student_id: studentId,
+      tag_id: tagId
+    })
+  }
+
+  async updateStudentTags(studentId: number, tagIds: number[]): Promise<void> {
+    await this.studentTagRepo.delete({ student_id: studentId })
+    for (const tagId of tagIds) {
+      const relation = this.studentTagRepo.create({
+        student_id: studentId,
+        tag_id: tagId
+      })
+      await this.studentTagRepo.save(relation)
+    }
+  }
+}
diff --git a/src/main/services/DataService.ts b/src/main/services/DataService.ts
diff --git a/src/preload/index.ts b/src/preload/index.ts
diff --git a/src/preload/types.ts b/src/preload/types.ts
diff --git a/src/renderer/src/components/StudentManager.tsx b/src/renderer/src/components/StudentManager.tsx
diff --git a/src/renderer/src/components/TagEditorDialog.tsx b/src/renderer/src/components/TagEditorDialog.tsx
diff --git a/tsconfig.node.tsbuildinfo b/tsconfig.node.tsbuildinfo

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ export class InitSchema2026011800000 implements MigrationInterface {`
`11`	`11`	`"name" text NOT NULL,`
`12`	`12`	`"score" integer NOT NULL DEFAULT (0),`
`13`	`13`	`"extra_json" text,`
	`14`	`+ "tags" text NOT NULL DEFAULT '[]',`
`14`	`15`	`"created_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP),`
`15`	`16`	`"updated_at" text NOT NULL DEFAULT (CURRENT_TIMESTAMP)`
`16`	`17`	`)`