chore: 代码风格统一和项目文档添加

主要变更：

1. 代码风格统一
   - 统一使用双引号替代单引号
   - 保持项目代码风格一致性
   - 涵盖所有模块、配置、实体和服务文件

2. 项目文档
   - 新增 SECURITY_FIXES_SUMMARY.md - 安全修复总结文档
   - 新增 项目问题评估报告.md - 项目问题评估文档

3. 包含修改的文件类别
   - 配置文件：app, database, jwt, redis, cache, performance
   - 实体文件：所有 TypeORM 实体
   - 模块文件：所有业务模块
   - 公共模块：guards, decorators, interceptors, filters, utils
   - 测试文件：单元测试和 E2E 测试

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

src/modules/schedules/dto/schedule.dto.ts

@@ -7,42 +7,42 @@ import {
   IsArray,
   ValidateNested,
   IsDateString,
-} from 'class-validator';
-import { ApiProperty } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
+} from "class-validator";
+import { ApiProperty } from "@nestjs/swagger";
+import { Type } from "class-transformer";
 
 export class TimeSlotDto {
-  @ApiProperty({ description: '开始时间', example: '2024-01-20T19:00:00Z' })
+  @ApiProperty({ description: "开始时间", example: "2024-01-20T19:00:00Z" })
   @IsDateString()
   startTime: Date;
 
-  @ApiProperty({ description: '结束时间', example: '2024-01-20T23:00:00Z' })
+  @ApiProperty({ description: "结束时间", example: "2024-01-20T23:00:00Z" })
   @IsDateString()
   endTime: Date;
 
-  @ApiProperty({ description: '备注', required: false })
+  @ApiProperty({ description: "备注", required: false })
   @IsString()
   @IsOptional()
   note?: string;
 }
 
 export class CreateScheduleDto {
-  @ApiProperty({ description: '小组ID' })
+  @ApiProperty({ description: "小组ID" })
   @IsString()
-  @IsNotEmpty({ message: '小组ID不能为空' })
+  @IsNotEmpty({ message: "小组ID不能为空" })
   groupId: string;
 
-  @ApiProperty({ description: '标题', example: '本周空闲时间' })
+  @ApiProperty({ description: "标题", example: "本周空闲时间" })
   @IsString()
-  @IsNotEmpty({ message: '标题不能为空' })
+  @IsNotEmpty({ message: "标题不能为空" })
   title: string;
 
-  @ApiProperty({ description: '描述', required: false })
+  @ApiProperty({ description: "描述", required: false })
   @IsString()
   @IsOptional()
   description?: string;
 
-  @ApiProperty({ description: '空闲时间段', type: [TimeSlotDto] })
+  @ApiProperty({ description: "空闲时间段", type: [TimeSlotDto] })
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => TimeSlotDto)
@@ -50,17 +50,21 @@ export class CreateScheduleDto {
 }
 
 export class UpdateScheduleDto {
-  @ApiProperty({ description: '标题', required: false })
+  @ApiProperty({ description: "标题", required: false })
   @IsString()
   @IsOptional()
   title?: string;
 
-  @ApiProperty({ description: '描述', required: false })
+  @ApiProperty({ description: "描述", required: false })
   @IsString()
   @IsOptional()
   description?: string;
 
-  @ApiProperty({ description: '空闲时间段', type: [TimeSlotDto], required: false })
+  @ApiProperty({
+    description: "空闲时间段",
+    type: [TimeSlotDto],
+    required: false,
+  })
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => TimeSlotDto)
@@ -69,34 +73,34 @@ export class UpdateScheduleDto {
 }
 
 export class QuerySchedulesDto {
-  @ApiProperty({ description: '小组ID', required: false })
+  @ApiProperty({ description: "小组ID", required: false })
   @IsString()
   @IsOptional()
   groupId?: string;
 
-  @ApiProperty({ description: '用户ID', required: false })
+  @ApiProperty({ description: "用户ID", required: false })
   @IsString()
   @IsOptional()
   userId?: string;
 
-  @ApiProperty({ description: '开始时间', required: false })
+  @ApiProperty({ description: "开始时间", required: false })
   @IsDateString()
   @IsOptional()
   startTime?: Date;
 
-  @ApiProperty({ description: '结束时间', required: false })
+  @ApiProperty({ description: "结束时间", required: false })
   @IsDateString()
   @IsOptional()
   endTime?: Date;
 
-  @ApiProperty({ description: '页码', example: 1, required: false })
+  @ApiProperty({ description: "页码", example: 1, required: false })
   @IsNumber()
   @Min(1)
   @IsOptional()
   @Type(() => Number)
   page?: number;
 
-  @ApiProperty({ description: '每页数量', example: 10, required: false })
+  @ApiProperty({ description: "每页数量", example: 10, required: false })
   @IsNumber()
   @Min(1)
   @IsOptional()
@@ -105,20 +109,20 @@ export class QuerySchedulesDto {
 }
 
 export class FindCommonSlotsDto {
-  @ApiProperty({ description: '小组ID' })
+  @ApiProperty({ description: "小组ID" })
   @IsString()
-  @IsNotEmpty({ message: '小组ID不能为空' })
+  @IsNotEmpty({ message: "小组ID不能为空" })
   groupId: string;
 
-  @ApiProperty({ description: '开始时间' })
+  @ApiProperty({ description: "开始时间" })
   @IsDateString()
   startTime: Date;
 
-  @ApiProperty({ description: '结束时间' })
+  @ApiProperty({ description: "结束时间" })
   @IsDateString()
   endTime: Date;
 
-  @ApiProperty({ description: '最少参与人数', example: 3, required: false })
+  @ApiProperty({ description: "最少参与人数", example: 3, required: false })
   @IsNumber()
   @Min(1)
   @IsOptional()

src/modules/schedules/schedules.controller.ts

@@ -8,92 +8,89 @@ import {
   Param,
   Query,
   UseGuards,
-} from '@nestjs/common';
+} from "@nestjs/common";
 import {
   ApiTags,
   ApiOperation,
   ApiResponse,
   ApiBearerAuth,
   ApiQuery,
-} from '@nestjs/swagger';
-import { SchedulesService } from './schedules.service';
+} from "@nestjs/swagger";
+import { SchedulesService } from "./schedules.service";
 import {
   CreateScheduleDto,
   UpdateScheduleDto,
   QuerySchedulesDto,
   FindCommonSlotsDto,
-} from './dto/schedule.dto';
-import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
-import { CurrentUser } from '../../common/decorators/current-user.decorator';
+} from "./dto/schedule.dto";
+import { JwtAuthGuard } from "../../common/guards/jwt-auth.guard";
+import { CurrentUser } from "../../common/decorators/current-user.decorator";
 
-@ApiTags('schedules')
+@ApiTags("schedules")
 @ApiBearerAuth()
 @UseGuards(JwtAuthGuard)
-@Controller('schedules')
+@Controller("schedules")
 export class SchedulesController {
   constructor(private readonly schedulesService: SchedulesService) {}
 
   @Post()
-  @ApiOperation({ summary: '创建排班' })
-  @ApiResponse({ status: 201, description: '创建成功' })
+  @ApiOperation({ summary: "创建排班" })
+  @ApiResponse({ status: 201, description: "创建成功" })
   async create(
-    @CurrentUser('id') userId: string,
+    @CurrentUser("id") userId: string,
     @Body() createDto: CreateScheduleDto,
   ) {
     return this.schedulesService.create(userId, createDto);
   }
 
   @Get()
-  @ApiOperation({ summary: '获取排班列表' })
-  @ApiResponse({ status: 200, description: '获取成功' })
-  @ApiQuery({ name: 'groupId', required: false, description: '小组ID' })
-  @ApiQuery({ name: 'userId', required: false, description: '用户ID' })
-  @ApiQuery({ name: 'startTime', required: false, description: '开始时间' })
-  @ApiQuery({ name: 'endTime', required: false, description: '结束时间' })
-  @ApiQuery({ name: 'page', required: false, description: '页码' })
-  @ApiQuery({ name: 'limit', required: false, description: '每页数量' })
+  @ApiOperation({ summary: "获取排班列表" })
+  @ApiResponse({ status: 200, description: "获取成功" })
+  @ApiQuery({ name: "groupId", required: false, description: "小组ID" })
+  @ApiQuery({ name: "userId", required: false, description: "用户ID" })
+  @ApiQuery({ name: "startTime", required: false, description: "开始时间" })
+  @ApiQuery({ name: "endTime", required: false, description: "结束时间" })
+  @ApiQuery({ name: "page", required: false, description: "页码" })
+  @ApiQuery({ name: "limit", required: false, description: "每页数量" })
   async findAll(
-    @CurrentUser('id') userId: string,
+    @CurrentUser("id") userId: string,
     @Query() queryDto: QuerySchedulesDto,
   ) {
     return this.schedulesService.findAll(userId, queryDto);
   }
 
-  @Post('common-slots')
-  @ApiOperation({ summary: '查找共同空闲时间' })
-  @ApiResponse({ status: 200, description: '查询成功' })
+  @Post("common-slots")
+  @ApiOperation({ summary: "查找共同空闲时间" })
+  @ApiResponse({ status: 200, description: "查询成功" })
   async findCommonSlots(
-    @CurrentUser('id') userId: string,
+    @CurrentUser("id") userId: string,
     @Body() findDto: FindCommonSlotsDto,
   ) {
     return this.schedulesService.findCommonSlots(userId, findDto);
   }
 
-  @Get(':id')
-  @ApiOperation({ summary: '获取排班详情' })
-  @ApiResponse({ status: 200, description: '获取成功' })
-  async findOne(@Param('id') id: string) {
+  @Get(":id")
+  @ApiOperation({ summary: "获取排班详情" })
+  @ApiResponse({ status: 200, description: "获取成功" })
+  async findOne(@Param("id") id: string) {
     return this.schedulesService.findOne(id);
   }
 
-  @Put(':id')
-  @ApiOperation({ summary: '更新排班' })
-  @ApiResponse({ status: 200, description: '更新成功' })
+  @Put(":id")
+  @ApiOperation({ summary: "更新排班" })
+  @ApiResponse({ status: 200, description: "更新成功" })
   async update(
-    @CurrentUser('id') userId: string,
-    @Param('id') id: string,
+    @CurrentUser("id") userId: string,
+    @Param("id") id: string,
     @Body() updateDto: UpdateScheduleDto,
   ) {
     return this.schedulesService.update(userId, id, updateDto);
   }
 
-  @Delete(':id')
-  @ApiOperation({ summary: '删除排班' })
-  @ApiResponse({ status: 200, description: '删除成功' })
-  async remove(
-    @CurrentUser('id') userId: string,
-    @Param('id') id: string,
-  ) {
+  @Delete(":id")
+  @ApiOperation({ summary: "删除排班" })
+  @ApiResponse({ status: 200, description: "删除成功" })
+  async remove(@CurrentUser("id") userId: string, @Param("id") id: string) {
     return this.schedulesService.remove(userId, id);
   }
 }

src/modules/schedules/schedules.module.ts

@@ -1,10 +1,10 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { SchedulesService } from './schedules.service';
-import { SchedulesController } from './schedules.controller';
-import { Schedule } from '../../entities/schedule.entity';
-import { Group } from '../../entities/group.entity';
-import { GroupMember } from '../../entities/group-member.entity';
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { SchedulesService } from "./schedules.service";
+import { SchedulesController } from "./schedules.controller";
+import { Schedule } from "../../entities/schedule.entity";
+import { Group } from "../../entities/group.entity";
+import { GroupMember } from "../../entities/group-member.entity";
 
 @Module({
   imports: [TypeOrmModule.forFeature([Schedule, Group, GroupMember])],

src/modules/schedules/schedules.service.spec.ts

@@ -1,49 +1,49 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
+import { Test, TestingModule } from "@nestjs/testing";
+import { getRepositoryToken } from "@nestjs/typeorm";
 import {
   NotFoundException,
   ForbiddenException,
   BadRequestException,
-} from '@nestjs/common';
-import { SchedulesService } from './schedules.service';
-import { Schedule } from '../../entities/schedule.entity';
-import { Group } from '../../entities/group.entity';
-import { GroupMember } from '../../entities/group-member.entity';
-import { TimeSlotDto } from './dto/schedule.dto';
+} from "@nestjs/common";
+import { SchedulesService } from "./schedules.service";
+import { Schedule } from "../../entities/schedule.entity";
+import { Group } from "../../entities/group.entity";
+import { GroupMember } from "../../entities/group-member.entity";
+import { TimeSlotDto } from "./dto/schedule.dto";
 
-describe('SchedulesService', () => {
+describe("SchedulesService", () => {
   let service: SchedulesService;
   let mockScheduleRepository: any;
   let mockGroupRepository: any;
   let mockGroupMemberRepository: any;
 
-  const mockUser = { id: 'user-1', username: 'testuser' };
-  const mockGroup = { id: 'group-1', name: '测试小组', isActive: true };
+  const mockUser = { id: "user-1", username: "testuser" };
+  const mockGroup = { id: "group-1", name: "测试小组", isActive: true };
   const mockMembership = {
-    id: 'member-1',
-    userId: 'user-1',
-    groupId: 'group-1',
-    role: 'member',
+    id: "member-1",
+    userId: "user-1",
+    groupId: "group-1",
+    role: "member",
     isActive: true,
   };
 
   const mockTimeSlots: TimeSlotDto[] = [
     {
-      startTime: new Date('2024-01-20T19:00:00Z'),
-      endTime: new Date('2024-01-20T21:00:00Z'),
-      note: '晚上空闲',
+      startTime: new Date("2024-01-20T19:00:00Z"),
+      endTime: new Date("2024-01-20T21:00:00Z"),
+      note: "晚上空闲",
     },
     {
-      startTime: new Date('2024-01-21T14:00:00Z'),
-      endTime: new Date('2024-01-21T17:00:00Z'),
-      note: '下午空闲',
+      startTime: new Date("2024-01-21T14:00:00Z"),
+      endTime: new Date("2024-01-21T17:00:00Z"),
+      note: "下午空闲",
     },
   ];
 
   const mockSchedule = {
-    id: 'schedule-1',
-    userId: 'user-1',
-    groupId: 'group-1',
+    id: "schedule-1",
+    userId: "user-1",
+    groupId: "group-1",
     availableSlots: mockTimeSlots,
     createdAt: new Date(),
     updatedAt: new Date(),
@@ -89,8 +89,8 @@ describe('SchedulesService', () => {
     service = module.get<SchedulesService>(SchedulesService);
   });
 
-  describe('create', () => {
-    it('应该成功创建排班', async () => {
+  describe("create", () => {
+    it("应该成功创建排班", async () => {
       mockGroupRepository.findOne.mockResolvedValue(mockGroup);
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
       mockScheduleRepository.create.mockReturnValue(mockSchedule);
@@ -101,66 +101,66 @@ describe('SchedulesService', () => {
         group: mockGroup,
       });
 
-      const result = await service.create('user-1', {
-        groupId: 'group-1',
-        title: '测试排班',
+      const result = await service.create("user-1", {
+        groupId: "group-1",
+        title: "测试排班",
         availableSlots: mockTimeSlots,
       });
 
-      expect(result).toHaveProperty('id');
+      expect(result).toHaveProperty("id");
       expect(mockScheduleRepository.save).toHaveBeenCalled();
     });
 
-    it('应该在小组不存在时抛出异常', async () => {
+    it("应该在小组不存在时抛出异常", async () => {
       mockGroupRepository.findOne.mockResolvedValue(null);
 
       await expect(
-        service.create('user-1', {
-          groupId: 'group-1',
-          title: '测试排班',
+        service.create("user-1", {
+          groupId: "group-1",
+          title: "测试排班",
           availableSlots: mockTimeSlots,
         }),
       ).rejects.toThrow(NotFoundException);
     });
 
-    it('应该在用户不在小组中时抛出异常', async () => {
+    it("应该在用户不在小组中时抛出异常", async () => {
       mockGroupRepository.findOne.mockResolvedValue(mockGroup);
       mockGroupMemberRepository.findOne.mockResolvedValue(null);
 
       await expect(
-        service.create('user-1', {
-          groupId: 'group-1',
-          title: '测试排班',
+        service.create("user-1", {
+          groupId: "group-1",
+          title: "测试排班",
           availableSlots: mockTimeSlots,
         }),
       ).rejects.toThrow(ForbiddenException);
     });
 
-    it('应该在时间段为空时抛出异常', async () => {
+    it("应该在时间段为空时抛出异常", async () => {
       mockGroupRepository.findOne.mockResolvedValue(mockGroup);
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
 
       await expect(
-        service.create('user-1', {
-          groupId: 'group-1',
-          title: '测试排班',
+        service.create("user-1", {
+          groupId: "group-1",
+          title: "测试排班",
           availableSlots: [],
         }),
       ).rejects.toThrow(BadRequestException);
     });
 
-    it('应该在时间段无效时抛出异常', async () => {
+    it("应该在时间段无效时抛出异常", async () => {
       mockGroupRepository.findOne.mockResolvedValue(mockGroup);
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
 
       await expect(
-        service.create('user-1', {
-          groupId: 'group-1',
-          title: '测试排班',
+        service.create("user-1", {
+          groupId: "group-1",
+          title: "测试排班",
           availableSlots: [
             {
-              startTime: new Date('2024-01-20T21:00:00Z'),
-              endTime: new Date('2024-01-20T19:00:00Z'), // 结束时间早于开始时间
+              startTime: new Date("2024-01-20T21:00:00Z"),
+              endTime: new Date("2024-01-20T19:00:00Z"), // 结束时间早于开始时间
             },
           ],
         }),
@@ -168,106 +168,106 @@ describe('SchedulesService', () => {
     });
   });
 
-  describe('findAll', () => {
-    it('应该成功获取排班列表', async () => {
+  describe("findAll", () => {
+    it("应该成功获取排班列表", async () => {
       const mockQueryBuilder = {
         leftJoinAndSelect: jest.fn().mockReturnThis(),
         andWhere: jest.fn().mockReturnThis(),
         orderBy: jest.fn().mockReturnThis(),
         skip: jest.fn().mockReturnThis(),
         take: jest.fn().mockReturnThis(),
-        getManyAndCount: jest
-          .fn()
-          .mockResolvedValue([[mockSchedule], 1]),
+        getManyAndCount: jest.fn().mockResolvedValue([[mockSchedule], 1]),
       };
 
-      mockScheduleRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+      mockScheduleRepository.createQueryBuilder.mockReturnValue(
+        mockQueryBuilder,
+      );
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
 
-      const result = await service.findAll('user-1', {
-        groupId: 'group-1',
+      const result = await service.findAll("user-1", {
+        groupId: "group-1",
         page: 1,
         limit: 10,
       });
 
-      expect(result).toHaveProperty('items');
-      expect(result).toHaveProperty('total');
+      expect(result).toHaveProperty("items");
+      expect(result).toHaveProperty("total");
       expect(result.items).toHaveLength(1);
       expect(result.total).toBe(1);
     });
 
-    it('应该在指定小组且用户不在小组时抛出异常', async () => {
+    it("应该在指定小组且用户不在小组时抛出异常", async () => {
       const mockQueryBuilder = {
         leftJoinAndSelect: jest.fn().mockReturnThis(),
         andWhere: jest.fn().mockReturnThis(),
         orderBy: jest.fn().mockReturnThis(),
         skip: jest.fn().mockReturnThis(),
         take: jest.fn().mockReturnThis(),
-        getManyAndCount: jest
-          .fn()
-          .mockResolvedValue([[mockSchedule], 1]),
+        getManyAndCount: jest.fn().mockResolvedValue([[mockSchedule], 1]),
       };
 
-      mockScheduleRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+      mockScheduleRepository.createQueryBuilder.mockReturnValue(
+        mockQueryBuilder,
+      );
       mockGroupMemberRepository.findOne.mockResolvedValue(null);
 
       await expect(
-        service.findAll('user-1', {
-          groupId: 'group-1',
+        service.findAll("user-1", {
+          groupId: "group-1",
         }),
       ).rejects.toThrow(ForbiddenException);
     });
 
-    it('应该在无小组ID时返回用户所在所有小组的排班', async () => {
+    it("应该在无小组ID时返回用户所在所有小组的排班", async () => {
       const mockQueryBuilder = {
         leftJoinAndSelect: jest.fn().mockReturnThis(),
         andWhere: jest.fn().mockReturnThis(),
         orderBy: jest.fn().mockReturnThis(),
         skip: jest.fn().mockReturnThis(),
         take: jest.fn().mockReturnThis(),
-        getManyAndCount: jest
-          .fn()
-          .mockResolvedValue([[mockSchedule], 1]),
+        getManyAndCount: jest.fn().mockResolvedValue([[mockSchedule], 1]),
       };
 
-      mockScheduleRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+      mockScheduleRepository.createQueryBuilder.mockReturnValue(
+        mockQueryBuilder,
+      );
       mockGroupMemberRepository.find.mockResolvedValue([
-        { groupId: 'group-1' },
-        { groupId: 'group-2' },
+        { groupId: "group-1" },
+        { groupId: "group-2" },
       ]);
 
-      const result = await service.findAll('user-1', {});
+      const result = await service.findAll("user-1", {});
 
       expect(result.items).toHaveLength(1);
       expect(mockGroupMemberRepository.find).toHaveBeenCalled();
     });
   });
 
-  describe('findOne', () => {
-    it('应该成功获取排班详情', async () => {
+  describe("findOne", () => {
+    it("应该成功获取排班详情", async () => {
       mockScheduleRepository.findOne.mockResolvedValue({
         ...mockSchedule,
         user: mockUser,
         group: mockGroup,
       });
 
-      const result = await service.findOne('schedule-1');
+      const result = await service.findOne("schedule-1");
 
-      expect(result).toHaveProperty('id');
-      expect(result.id).toBe('schedule-1');
+      expect(result).toHaveProperty("id");
+      expect(result.id).toBe("schedule-1");
     });
 
-    it('应该在排班不存在时抛出异常', async () => {
+    it("应该在排班不存在时抛出异常", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(null);
 
-      await expect(service.findOne('schedule-1')).rejects.toThrow(
+      await expect(service.findOne("schedule-1")).rejects.toThrow(
         NotFoundException,
       );
     });
   });
 
-  describe('update', () => {
-    it('应该成功更新排班', async () => {
+  describe("update", () => {
+    it("应该成功更新排班", async () => {
       mockScheduleRepository.findOne
         .mockResolvedValueOnce(mockSchedule)
         .mockResolvedValueOnce({
@@ -277,118 +277,122 @@ describe('SchedulesService', () => {
         });
       mockScheduleRepository.save.mockResolvedValue(mockSchedule);
 
-      const result = await service.update('user-1', 'schedule-1', {
+      const result = await service.update("user-1", "schedule-1", {
         availableSlots: mockTimeSlots,
       });
 
-      expect(result).toHaveProperty('id');
+      expect(result).toHaveProperty("id");
       expect(mockScheduleRepository.save).toHaveBeenCalled();
     });
 
-    it('应该在排班不存在时抛出异常', async () => {
+    it("应该在排班不存在时抛出异常", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(null);
 
       await expect(
-        service.update('user-1', 'schedule-1', { availableSlots: mockTimeSlots }),
+        service.update("user-1", "schedule-1", {
+          availableSlots: mockTimeSlots,
+        }),
       ).rejects.toThrow(NotFoundException);
     });
 
-    it('应该在非创建者更新时抛出异常', async () => {
+    it("应该在非创建者更新时抛出异常", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(mockSchedule);
 
       await expect(
-        service.update('user-2', 'schedule-1', { availableSlots: mockTimeSlots }),
+        service.update("user-2", "schedule-1", {
+          availableSlots: mockTimeSlots,
+        }),
       ).rejects.toThrow(ForbiddenException);
     });
   });
 
-  describe('remove', () => {
-    it('应该成功删除排班', async () => {
+  describe("remove", () => {
+    it("应该成功删除排班", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(mockSchedule);
       mockScheduleRepository.remove.mockResolvedValue(mockSchedule);
 
-      const result = await service.remove('user-1', 'schedule-1');
+      const result = await service.remove("user-1", "schedule-1");
 
-      expect(result).toHaveProperty('message');
+      expect(result).toHaveProperty("message");
       expect(mockScheduleRepository.remove).toHaveBeenCalled();
     });
 
-    it('应该在排班不存在时抛出异常', async () => {
+    it("应该在排班不存在时抛出异常", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(null);
 
-      await expect(service.remove('user-1', 'schedule-1')).rejects.toThrow(
+      await expect(service.remove("user-1", "schedule-1")).rejects.toThrow(
         NotFoundException,
       );
     });
 
-    it('应该在非创建者删除时抛出异常', async () => {
+    it("应该在非创建者删除时抛出异常", async () => {
       mockScheduleRepository.findOne.mockResolvedValue(mockSchedule);
 
-      await expect(service.remove('user-2', 'schedule-1')).rejects.toThrow(
+      await expect(service.remove("user-2", "schedule-1")).rejects.toThrow(
         ForbiddenException,
       );
     });
   });
 
-  describe('findCommonSlots', () => {
-    it('应该成功查找共同空闲时间', async () => {
+  describe("findCommonSlots", () => {
+    it("应该成功查找共同空闲时间", async () => {
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
       mockScheduleRepository.find.mockResolvedValue([
         {
           ...mockSchedule,
-          userId: 'user-1',
-          user: { id: 'user-1' },
+          userId: "user-1",
+          user: { id: "user-1" },
         },
         {
           ...mockSchedule,
-          id: 'schedule-2',
-          userId: 'user-2',
-          user: { id: 'user-2' },
+          id: "schedule-2",
+          userId: "user-2",
+          user: { id: "user-2" },
           availableSlots: [
             {
-              startTime: new Date('2024-01-20T19:30:00Z'),
-              endTime: new Date('2024-01-20T22:00:00Z'),
+              startTime: new Date("2024-01-20T19:30:00Z"),
+              endTime: new Date("2024-01-20T22:00:00Z"),
             },
           ],
         },
       ]);
 
-      const result = await service.findCommonSlots('user-1', {
-        groupId: 'group-1',
-        startTime: new Date('2024-01-20T00:00:00Z'),
-        endTime: new Date('2024-01-22T00:00:00Z'),
+      const result = await service.findCommonSlots("user-1", {
+        groupId: "group-1",
+        startTime: new Date("2024-01-20T00:00:00Z"),
+        endTime: new Date("2024-01-22T00:00:00Z"),
         minParticipants: 2,
       });
 
-      expect(result).toHaveProperty('commonSlots');
-      expect(result).toHaveProperty('totalParticipants');
+      expect(result).toHaveProperty("commonSlots");
+      expect(result).toHaveProperty("totalParticipants");
       expect(result.totalParticipants).toBe(2);
     });
 
-    it('应该在用户不在小组时抛出异常', async () => {
+    it("应该在用户不在小组时抛出异常", async () => {
       mockGroupMemberRepository.findOne.mockResolvedValue(null);
 
       await expect(
-        service.findCommonSlots('user-1', {
-          groupId: 'group-1',
-          startTime: new Date('2024-01-20T00:00:00Z'),
-          endTime: new Date('2024-01-22T00:00:00Z'),
+        service.findCommonSlots("user-1", {
+          groupId: "group-1",
+          startTime: new Date("2024-01-20T00:00:00Z"),
+          endTime: new Date("2024-01-22T00:00:00Z"),
         }),
       ).rejects.toThrow(ForbiddenException);
     });
 
-    it('应该在没有排班数据时返回空结果', async () => {
+    it("应该在没有排班数据时返回空结果", async () => {
       mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
       mockScheduleRepository.find.mockResolvedValue([]);
 
-      const result = await service.findCommonSlots('user-1', {
-        groupId: 'group-1',
-        startTime: new Date('2024-01-20T00:00:00Z'),
-        endTime: new Date('2024-01-22T00:00:00Z'),
+      const result = await service.findCommonSlots("user-1", {
+        groupId: "group-1",
+        startTime: new Date("2024-01-20T00:00:00Z"),
+        endTime: new Date("2024-01-22T00:00:00Z"),
       });
 
       expect(result.commonSlots).toEqual([]);
-      expect(result.message).toBe('暂无排班数据');
+      expect(result.message).toBe("暂无排班数据");
     });
   });
 });

src/modules/schedules/schedules.service.ts

@@ -3,20 +3,23 @@ import {
   NotFoundException,
   ForbiddenException,
   BadRequestException,
-} from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, Between } from 'typeorm';
-import { Schedule } from '../../entities/schedule.entity';
-import { Group } from '../../entities/group.entity';
-import { GroupMember } from '../../entities/group-member.entity';
+} from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository, Between } from "typeorm";
+import { Schedule } from "../../entities/schedule.entity";
+import { Group } from "../../entities/group.entity";
+import { GroupMember } from "../../entities/group-member.entity";
 import {
   CreateScheduleDto,
   UpdateScheduleDto,
   QuerySchedulesDto,
   FindCommonSlotsDto,
-} from './dto/schedule.dto';
-import { ErrorCode, ErrorMessage } from '../../common/interfaces/response.interface';
-import { PaginationUtil } from '../../common/utils/pagination.util';
+} from "./dto/schedule.dto";
+import {
+  ErrorCode,
+  ErrorMessage,
+} from "../../common/interfaces/response.interface";
+import { PaginationUtil } from "../../common/utils/pagination.util";
 
 export interface TimeSlot {
   startTime: Date;
@@ -101,20 +104,20 @@ export class SchedulesService {
     const { offset } = PaginationUtil.formatPaginationParams(page, limit);
 
     const queryBuilder = this.scheduleRepository
-      .createQueryBuilder('schedule')
-      .leftJoinAndSelect('schedule.group', 'group')
-      .leftJoinAndSelect('schedule.user', 'user');
+      .createQueryBuilder("schedule")
+      .leftJoinAndSelect("schedule.group", "group")
+      .leftJoinAndSelect("schedule.user", "user");
 
     // 筛选条件
     if (groupId) {
       // 验证用户是否在小组中
       await this.checkGroupMembership(userId, groupId);
-      queryBuilder.andWhere('schedule.groupId = :groupId', { groupId });
+      queryBuilder.andWhere("schedule.groupId = :groupId", { groupId });
     } else {
       // 如果没有指定小组，只返回用户所在小组的排班
       const memberGroups = await this.groupMemberRepository.find({
         where: { userId, isActive: true },
-        select: ['groupId'],
+        select: ["groupId"],
       });
       const groupIds = memberGroups.map((m) => m.groupId);
       if (groupIds.length === 0) {
@@ -126,23 +129,28 @@ export class SchedulesService {
           totalPages: 0,
         };
       }
-      queryBuilder.andWhere('schedule.groupId IN (:...groupIds)', { groupIds });
+      queryBuilder.andWhere("schedule.groupId IN (:...groupIds)", { groupIds });
     }
 
     if (targetUserId) {
-      queryBuilder.andWhere('schedule.userId = :userId', { userId: targetUserId });
+      queryBuilder.andWhere("schedule.userId = :userId", {
+        userId: targetUserId,
+      });
     }
 
     if (startTime && endTime) {
-      queryBuilder.andWhere('schedule.createdAt BETWEEN :startTime AND :endTime', {
-        startTime: new Date(startTime),
-        endTime: new Date(endTime),
-      });
+      queryBuilder.andWhere(
+        "schedule.createdAt BETWEEN :startTime AND :endTime",
+        {
+          startTime: new Date(startTime),
+          endTime: new Date(endTime),
+        },
+      );
     }
 
     // 分页
     const [items, total] = await queryBuilder
-      .orderBy('schedule.createdAt', 'DESC')
+      .orderBy("schedule.createdAt", "DESC")
       .skip(offset)
       .take(limit)
       .getManyAndCount();
@@ -168,13 +176,13 @@ export class SchedulesService {
   async findOne(id: string) {
     const schedule = await this.scheduleRepository.findOne({
       where: { id },
-      relations: ['group', 'user'],
+      relations: ["group", "user"],
     });
 
     if (!schedule) {
       throw new NotFoundException({
         code: ErrorCode.NOT_FOUND,
-        message: '排班不存在',
+        message: "排班不存在",
       });
     }
 
@@ -195,7 +203,7 @@ export class SchedulesService {
     if (!schedule) {
       throw new NotFoundException({
         code: ErrorCode.NOT_FOUND,
-        message: '排班不存在',
+        message: "排班不存在",
       });
     }
 
@@ -229,7 +237,7 @@ export class SchedulesService {
     if (!schedule) {
       throw new NotFoundException({
         code: ErrorCode.NOT_FOUND,
-        message: '排班不存在',
+        message: "排班不存在",
       });
     }
 
@@ -243,7 +251,7 @@ export class SchedulesService {
 
     await this.scheduleRepository.remove(schedule);
 
-    return { message: '排班已删除' };
+    return { message: "排班已删除" };
   }
 
   /**
@@ -258,13 +266,13 @@ export class SchedulesService {
     // 获取时间范围内的所有排班
     const schedules = await this.scheduleRepository.find({
       where: { groupId },
-      relations: ['user'],
+      relations: ["user"],
     });
 
     if (schedules.length === 0) {
       return {
         commonSlots: [],
-        message: '暂无排班数据',
+        message: "暂无排班数据",
       };
     }
 
@@ -302,7 +310,11 @@ export class SchedulesService {
     userSlots: Map<string, TimeSlot[]>,
     minParticipants: number,
   ): CommonSlot[] {
-    const allSlots: Array<{ time: Date; userId: string; type: 'start' | 'end' }> = [];
+    const allSlots: Array<{
+      time: Date;
+      userId: string;
+      type: "start" | "end";
+    }> = [];
 
     // 收集所有时间点
     userSlots.forEach((slots, userId) => {
@@ -310,12 +322,12 @@ export class SchedulesService {
         allSlots.push({
           time: new Date(slot.startTime),
           userId,
-          type: 'start',
+          type: "start",
         });
         allSlots.push({
           time: new Date(slot.endTime),
           userId,
-          type: 'end',
+          type: "end",
         });
       });
     });
@@ -341,7 +353,7 @@ export class SchedulesService {
         }
       }
 
-      if (event.type === 'start') {
+      if (event.type === "start") {
         activeUsers.add(event.userId);
       } else {
         activeUsers.delete(event.userId);
@@ -365,7 +377,7 @@ export class SchedulesService {
 
     for (let i = 1; i < slots.length; i++) {
       const next = slots[i];
-      
+
       // 如果参与者相同且时间连续，则合并
       if (
         current.endTime.getTime() === next.startTime.getTime() &&
@@ -389,7 +401,7 @@ export class SchedulesService {
     if (slots.length === 0) {
       throw new BadRequestException({
         code: ErrorCode.PARAM_ERROR,
-        message: '至少需要一个时间段',
+        message: "至少需要一个时间段",
       });
     }