merge sandbox/f0cf2f4: chg_0006 LMS bootstrap (3 子系统 + 5 S 场景 + 6 cases)

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
xstudio agentandClaude Code committed 2026-09-28 16:46:52 +08:00
1 parent f1a15c44f4
commit 5c27b0fd39
17 files changed
+1039 -1

No files matched your search

+2 -1
View File
@@ -1,8 +1,9 @@
import { Module } from '@nestjs/common';
import { AuthModule } from './auth/auth.module';
import { DthExperimentModule } from './dth/experiment/experiment.module';
import { LmsModule } from './lms/lms.module';
@Module({
imports: [AuthModule, DthExperimentModule],
imports: [AuthModule, DthExperimentModule, LmsModule],
})
export class AppModule {}
+45
View File
@@ -33,6 +33,37 @@ export async function initPglite(): Promise<PGlite> {
is_admin BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
-- chg_0006 LMS schema: lms_student / lms_course / lms_enrollment
CREATE TABLE IF NOT EXISTS lms_student (
id TEXT PRIMARY KEY,
student_no TEXT UNIQUE NOT NULL,
name TEXT NOT NULL,
email TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_lms_student_no ON lms_student(student_no);
CREATE TABLE IF NOT EXISTS lms_course (
id TEXT PRIMARY KEY,
code TEXT UNIQUE NOT NULL,
name TEXT NOT NULL,
credits INTEGER NOT NULL DEFAULT 1,
instructor TEXT,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_lms_course_code ON lms_course(code);
CREATE TABLE IF NOT EXISTS lms_enrollment (
id TEXT PRIMARY KEY,
student_id TEXT NOT NULL,
course_id TEXT NOT NULL,
enrolled_at TIMESTAMP NOT NULL DEFAULT NOW(),
status TEXT NOT NULL DEFAULT 'active',
UNIQUE(student_id, course_id)
);
CREATE INDEX IF NOT EXISTS idx_lms_enroll_student ON lms_enrollment(student_id);
CREATE INDEX IF NOT EXISTS idx_lms_enroll_course ON lms_enrollment(course_id);
`);
// Seed admin if not present
@@ -53,6 +84,20 @@ export async function initPglite(): Promise<PGlite> {
ON CONFLICT (username) DO NOTHING;`,
);
// chg_0006 LMS seed: 2 students + 2 courses (fixed UUIDs for e2e stability)
await db.exec(
`INSERT INTO lms_student (id, student_no, name, email) VALUES
('11111111-1111-1111-1111-111111111111', 'S20200001', '李雷', '[email protected]'),
('22222222-2222-2222-2222-222222222222', 'S20200002', '韩梅梅', '[email protected]')
ON CONFLICT (id) DO NOTHING;`,
);
await db.exec(
`INSERT INTO lms_course (id, code, name, credits, instructor) VALUES
('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'CS101', '数据安全导论', 3, '王老师'),
('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'CS201', '隐私计算实战', 4, '陈老师')
ON CONFLICT (id) DO NOTHING;`,
);
return db;
}
@@ -0,0 +1,52 @@
import {
Body,
Controller,
Delete,
Get,
Param,
Post,
Put,
UseGuards,
} from '@nestjs/common';
import { JwtAuthGuard, RequireAdmin } from '../auth/jwt.guard';
import {
CoursesService,
CreateCourseDto,
UpdateCourseDto,
} from './courses.courses.service';
@Controller('api/ssw/dth/lms/courses')
@UseGuards(JwtAuthGuard)
export class CoursesController {
constructor(private readonly courses: CoursesService) {}
@Get()
@RequireAdmin()
async listCourses() {
return { code: 200, msg: 'ok', data: await this.courses.list() };
}
@Post()
@RequireAdmin()
async createCourse(@Body() dto: CreateCourseDto) {
return { code: 200, msg: 'ok', data: await this.courses.create(dto) };
}
@Get(':id')
@RequireAdmin()
async getCourse(@Param('id') id: string) {
return { code: 200, msg: 'ok', data: await this.courses.getOrThrow(id) };
}
@Put(':id')
@RequireAdmin()
async updateCourse(@Param('id') id: string, @Body() dto: UpdateCourseDto) {
return { code: 200, msg: 'ok', data: await this.courses.update(id, dto) };
}
@Delete(':id')
@RequireAdmin()
async deleteCourse(@Param('id') id: string) {
return { code: 200, msg: 'ok', data: await this.courses.delete(id) };
}
}
@@ -0,0 +1,116 @@
import {
BadRequestException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { v4 as uuidv4 } from 'uuid';
import { getDb } from '../common/pglite/init';
export interface CourseRow {
id: string;
code: string;
name: string;
credits: number;
instructor: string | null;
created_at: string;
}
export interface CreateCourseDto {
code: string;
name: string;
credits?: number;
instructor?: string;
}
export interface UpdateCourseDto {
name?: string;
credits?: number;
instructor?: string;
}
@Injectable()
export class CoursesService {
async list(): Promise<CourseRow[]> {
const db = getDb();
const r = await db.query<CourseRow>(
`SELECT id, code, name, credits, instructor, created_at::text AS created_at
FROM lms_course ORDER BY created_at ASC`,
);
return r.rows;
}
async create(dto: CreateCourseDto): Promise<CourseRow> {
if (!dto?.code || !dto?.name) {
throw new BadRequestException('code / name are required');
}
const db = getDb();
const exist = await db.query<{ id: string }>(
`SELECT id FROM lms_course WHERE code = $1 LIMIT 1`,
[dto.code],
);
if (exist.rows.length > 0) {
throw new BadRequestException(`course code ${dto.code} already exists`);
}
const id = uuidv4();
const credits = dto.credits ?? 1;
await db.query(
`INSERT INTO lms_course (id, code, name, credits, instructor)
VALUES ($1, $2, $3, $4, $5)`,
[id, dto.code, dto.name, credits, dto.instructor ?? null],
);
return (await this.get(id))!;
}
async get(id: string): Promise<CourseRow | null> {
const db = getDb();
const r = await db.query<CourseRow>(
`SELECT id, code, name, credits, instructor, created_at::text AS created_at
FROM lms_course WHERE id = $1 LIMIT 1`,
[id],
);
return r.rows[0] ?? null;
}
async getOrThrow(id: string): Promise<CourseRow> {
const row = await this.get(id);
if (!row) throw new NotFoundException(`course ${id} not found`);
return row;
}
async update(id: string, dto: UpdateCourseDto): Promise<CourseRow> {
await this.getOrThrow(id);
const sets: string[] = [];
const params: any[] = [];
if (dto.name !== undefined) {
params.push(dto.name);
sets.push(`name = $${params.length}`);
}
if (dto.credits !== undefined) {
params.push(dto.credits);
sets.push(`credits = $${params.length}`);
}
if (dto.instructor !== undefined) {
params.push(dto.instructor);
sets.push(`instructor = $${params.length}`);
}
if (sets.length === 0) {
return this.getOrThrow(id);
}
params.push(id);
const db = getDb();
await db.query(
`UPDATE lms_course SET ${sets.join(', ')} WHERE id = $${params.length}`,
params,
);
return this.getOrThrow(id);
}
async delete(id: string): Promise<{ id: string }> {
await this.getOrThrow(id);
const db = getDb();
// Cascade: 课程被删则其选课记录也清掉
await db.query(`DELETE FROM lms_enrollment WHERE course_id = $1`, [id]);
await db.query(`DELETE FROM lms_course WHERE id = $1`, [id]);
return { id };
}
}
@@ -0,0 +1,46 @@
import {
Body,
Controller,
Get,
Param,
Post,
UseGuards,
} from '@nestjs/common';
import { JwtAuthGuard, RequireAdmin } from '../auth/jwt.guard';
import { EnrollDto, EnrollmentsService } from './enrollments.enrollments.service';
@Controller('api/ssw/dth/lms')
@UseGuards(JwtAuthGuard)
export class EnrollmentsController {
constructor(private readonly enrollments: EnrollmentsService) {}
@Post('courses/:id/enroll')
@RequireAdmin()
async enroll(@Param('id') courseId: string, @Body() dto: EnrollDto) {
return {
code: 200,
msg: 'ok',
data: await this.enrollments.enroll(courseId, dto),
};
}
@Get('courses/:id/enrollments')
@RequireAdmin()
async listByCourse(@Param('id') courseId: string) {
return {
code: 200,
msg: 'ok',
data: await this.enrollments.listByCourse(courseId),
};
}
@Get('students/:id/enrollments')
@RequireAdmin()
async listByStudent(@Param('id') studentId: string) {
return {
code: 200,
msg: 'ok',
data: await this.enrollments.listByStudent(studentId),
};
}
}
@@ -0,0 +1,89 @@
import {
BadRequestException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { v4 as uuidv4 } from 'uuid';
import { getDb } from '../common/pglite/init';
import { CoursesService } from './courses.courses.service';
import { StudentsService } from './students.students.service';
export interface EnrollmentRow {
id: string;
student_id: string;
course_id: string;
enrolled_at: string;
status: string;
}
export interface EnrollDto {
student_id: string;
}
@Injectable()
export class EnrollmentsService {
constructor(
private readonly students: StudentsService,
private readonly courses: CoursesService,
) {}
async enroll(courseId: string, dto: EnrollDto): Promise<EnrollmentRow> {
if (!dto?.student_id) {
throw new BadRequestException('student_id is required');
}
// 课程 + 学员必须存在(先校验,让 NotFound 比 UNIQUE 冲突优先)
await this.courses.getOrThrow(courseId);
await this.students.getOrThrow(dto.student_id);
const db = getDb();
const exist = await db.query<{ id: string }>(
`SELECT id FROM lms_enrollment WHERE student_id = $1 AND course_id = $2 LIMIT 1`,
[dto.student_id, courseId],
);
if (exist.rows.length > 0) {
throw new BadRequestException(
`student ${dto.student_id} already enrolled in course ${courseId}`,
);
}
const id = uuidv4();
await db.query(
`INSERT INTO lms_enrollment (id, student_id, course_id, status)
VALUES ($1, $2, $3, 'active')`,
[id, dto.student_id, courseId],
);
return (await this.get(id))!;
}
async get(id: string): Promise<EnrollmentRow | null> {
const db = getDb();
const r = await db.query<EnrollmentRow>(
`SELECT id, student_id, course_id, enrolled_at::text AS enrolled_at, status
FROM lms_enrollment WHERE id = $1 LIMIT 1`,
[id],
);
return r.rows[0] ?? null;
}
async listByStudent(studentId: string): Promise<EnrollmentRow[]> {
// 校验学生存在(404 比空 [] 更明确)
await this.students.getOrThrow(studentId);
const db = getDb();
const r = await db.query<EnrollmentRow>(
`SELECT id, student_id, course_id, enrolled_at::text AS enrolled_at, status
FROM lms_enrollment WHERE student_id = $1 ORDER BY enrolled_at ASC`,
[studentId],
);
return r.rows;
}
async listByCourse(courseId: string): Promise<EnrollmentRow[]> {
await this.courses.getOrThrow(courseId);
const db = getDb();
const r = await db.query<EnrollmentRow>(
`SELECT id, student_id, course_id, enrolled_at::text AS enrolled_at, status
FROM lms_enrollment WHERE course_id = $1 ORDER BY enrolled_at ASC`,
[courseId],
);
return r.rows;
}
}
+15
View File
@@ -0,0 +1,15 @@
import { Module } from '@nestjs/common';
import { AuthModule } from '../auth/auth.module';
import { CoursesController } from './courses.courses.controller';
import { CoursesService } from './courses.courses.service';
import { EnrollmentsController } from './enrollments.enrollments.controller';
import { EnrollmentsService } from './enrollments.enrollments.service';
import { StudentsController } from './students.students.controller';
import { StudentsService } from './students.students.service';
@Module({
imports: [AuthModule],
controllers: [StudentsController, CoursesController, EnrollmentsController],
providers: [StudentsService, CoursesService, EnrollmentsService],
})
export class LmsModule {}
@@ -0,0 +1,52 @@
import {
Body,
Controller,
Delete,
Get,
Param,
Post,
Put,
UseGuards,
} from '@nestjs/common';
import { JwtAuthGuard, RequireAdmin } from '../auth/jwt.guard';
import {
CreateStudentDto,
StudentsService,
UpdateStudentDto,
} from './students.students.service';
@Controller('api/ssw/dth/lms/students')
@UseGuards(JwtAuthGuard)
export class StudentsController {
constructor(private readonly students: StudentsService) {}
@Get()
@RequireAdmin()
async listStudents() {
return { code: 200, msg: 'ok', data: await this.students.list() };
}
@Post()
@RequireAdmin()
async createStudent(@Body() dto: CreateStudentDto) {
return { code: 200, msg: 'ok', data: await this.students.create(dto) };
}
@Get(':id')
@RequireAdmin()
async getStudent(@Param('id') id: string) {
return { code: 200, msg: 'ok', data: await this.students.getOrThrow(id) };
}
@Put(':id')
@RequireAdmin()
async updateStudent(@Param('id') id: string, @Body() dto: UpdateStudentDto) {
return { code: 200, msg: 'ok', data: await this.students.update(id, dto) };
}
@Delete(':id')
@RequireAdmin()
async deleteStudent(@Param('id') id: string) {
return { code: 200, msg: 'ok', data: await this.students.delete(id) };
}
}
@@ -0,0 +1,110 @@
import {
BadRequestException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { v4 as uuidv4 } from 'uuid';
import { getDb } from '../common/pglite/init';
export interface StudentRow {
id: string;
student_no: string;
name: string;
email: string;
created_at: string;
}
export interface CreateStudentDto {
student_no: string;
name: string;
email: string;
}
export interface UpdateStudentDto {
name?: string;
email?: string;
}
@Injectable()
export class StudentsService {
async list(): Promise<StudentRow[]> {
const db = getDb();
const r = await db.query<StudentRow>(
`SELECT id, student_no, name, email, created_at::text AS created_at
FROM lms_student ORDER BY created_at ASC`,
);
return r.rows;
}
async create(dto: CreateStudentDto): Promise<StudentRow> {
if (!dto?.student_no || !dto?.name || !dto?.email) {
throw new BadRequestException('student_no / name / email are required');
}
const db = getDb();
// Pre-check uniqueness (UNIQUE 约束兜底;这里给出更友好提示)
const exist = await db.query<{ id: string }>(
`SELECT id FROM lms_student WHERE student_no = $1 LIMIT 1`,
[dto.student_no],
);
if (exist.rows.length > 0) {
throw new BadRequestException(`student_no ${dto.student_no} already exists`);
}
const id = uuidv4();
await db.query(
`INSERT INTO lms_student (id, student_no, name, email)
VALUES ($1, $2, $3, $4)`,
[id, dto.student_no, dto.name, dto.email],
);
return (await this.get(id))!;
}
async get(id: string): Promise<StudentRow | null> {
const db = getDb();
const r = await db.query<StudentRow>(
`SELECT id, student_no, name, email, created_at::text AS created_at
FROM lms_student WHERE id = $1 LIMIT 1`,
[id],
);
return r.rows[0] ?? null;
}
async getOrThrow(id: string): Promise<StudentRow> {
const row = await this.get(id);
if (!row) throw new NotFoundException(`student ${id} not found`);
return row;
}
async update(id: string, dto: UpdateStudentDto): Promise<StudentRow> {
await this.getOrThrow(id);
const sets: string[] = [];
const params: any[] = [];
if (dto.name !== undefined) {
params.push(dto.name);
sets.push(`name = $${params.length}`);
}
if (dto.email !== undefined) {
params.push(dto.email);
sets.push(`email = $${params.length}`);
}
if (sets.length === 0) {
// no-op: just return as-is
return this.getOrThrow(id);
}
params.push(id);
const db = getDb();
await db.query(
`UPDATE lms_student SET ${sets.join(', ')} WHERE id = $${params.length}`,
params,
);
return this.getOrThrow(id);
}
async delete(id: string): Promise<{ id: string }> {
await this.getOrThrow(id);
const db = getDb();
// Cascade: 学员被删则其选课记录也清掉(lms_enrollment 是依附资源)
await db.query(`DELETE FROM lms_enrollment WHERE student_id = $1`, [id]);
await db.query(`DELETE FROM lms_student WHERE id = $1`, [id]);
return { id };
}
}