[Feature]：我的空间新增分组管理

server/src/app.module.ts

@@ -29,6 +29,7 @@ import { SurveyHistory } from './models/surveyHistory.entity';
 import { ResponseSchema } from './models/responseSchema.entity';
 import { Counter } from './models/counter.entity';
 import { SurveyResponse } from './models/surveyResponse.entity';
+import { SurveyGroup } from './models/surveyGroup.entity';
 import { ClientEncrypt } from './models/clientEncrypt.entity';
 import { Word } from './models/word.entity';
 import { MessagePushingTask } from './models/messagePushingTask.entity';
@@ -78,6 +79,7 @@ import { Logger } from './logger';
             SurveyConf,
             SurveyHistory,
             SurveyResponse,
+            SurveyGroup,
             Counter,
             ResponseSchema,
             ClientEncrypt,

server/src/models/surveyGroup.entity.ts

@@ -0,0 +1,11 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'surveyGroup' })
+export class SurveyGroup extends BaseEntity {
+  @Column()
+  ownerId: string;
+
+  @Column()
+  name: string;
+}

server/src/models/surveyMeta.entity.ts

@@ -37,6 +37,9 @@ export class SurveyMeta extends BaseEntity {
   @Column()
   workspaceId: string;
 
+  @Column()
+  groupId: string;
+
   @Column()
   curStatus: {
     status: RECORD_STATUS;

server/src/modules/survey/__test/surveyGroup.controller.spec.ts

@@ -0,0 +1,132 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { SurveyGroupController } from '../controllers/surveyGroup.controller';
+import { SurveyGroupService } from '../services/surveyGroup.service';
+import { SurveyMetaService } from '../services/surveyMeta.service';
+import { HttpException } from 'src/exceptions/httpException';
+import { ObjectId } from 'mongodb';
+import { Logger } from 'src/logger';
+
+jest.mock('src/guards/authentication.guard');
+
+describe('SurveyGroupController', () => {
+  let controller: SurveyGroupController;
+  let service: SurveyGroupService;
+
+  const mockService = {
+    create: jest.fn(),
+    findAll: jest.fn(),
+    update: jest.fn(),
+    remove: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [SurveyGroupController],
+      providers: [
+        {
+          provide: SurveyMetaService,
+          useValue: {
+            countSurveyMetaByGroupId: jest.fn().mockResolvedValue(0),
+          },
+        },
+        {
+          provide: SurveyGroupService,
+          useValue: mockService,
+        },
+        {
+          provide: Logger,
+          useValue: {
+            error: jest.fn(),
+            info: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get<SurveyGroupController>(SurveyGroupController);
+    service = module.get<SurveyGroupService>(SurveyGroupService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('create', () => {
+    it('should create a survey group', async () => {
+      const result = {
+        _id: new ObjectId(),
+        name: 'Test Group',
+        ownerId: '123',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }; // 确保这里返回的对象结构符合预期
+      jest.spyOn(service, 'create').mockResolvedValue(result);
+
+      // 创建模拟的请求对象
+      const req = {
+        user: {
+          _id: '123', // 模拟的用户ID
+        },
+      };
+
+      expect(await controller.create({ name: 'Test Group' }, req)).toEqual({
+        code: 200,
+        data: {
+          id: result._id,
+        },
+      });
+      expect(service.create).toHaveBeenCalledWith({
+        name: 'Test Group',
+        ownerId: req.user._id.toString(), // 这里用模拟的 req.user._id
+      });
+    });
+  });
+
+  describe('findAll', () => {
+    it('should return a list of survey groups', async () => {
+      const result = { total: 0, notTotal: 0, list: [], allList: [] };
+      jest.spyOn(service, 'findAll').mockResolvedValue(result);
+      const mockReq = { user: { _id: new ObjectId() } };
+      const mockQue = { curPage: 1, pageSize: 10, name: '' };
+      const userId = mockReq.user._id.toString();
+      expect(await controller.findAll(mockReq, mockQue)).toEqual({
+        code: 200,
+        data: result,
+      });
+      expect(service.findAll).toHaveBeenCalledWith(userId, '', 0, 10);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a survey group', async () => {
+      const updatedFields = { name: 'xxx' };
+      const updatedResult = { raw: 'xxx', generatedMaps: [] };
+      const id = '1';
+      jest.spyOn(service, 'update').mockResolvedValue(updatedResult);
+
+      expect(await controller.updateOne(id, updatedFields)).toEqual({
+        code: 200,
+        ret: updatedResult,
+      });
+      expect(service.update).toHaveBeenCalledWith(id, updatedFields);
+    });
+
+    it('should throw error on invalid parameter', async () => {
+      const id = '1';
+      const invalidFields: any = {};
+      await expect(controller.updateOne(id, invalidFields)).rejects.toThrow(
+        HttpException,
+      );
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove a survey group', async () => {
+      const id = '1';
+      jest.spyOn(service, 'remove').mockResolvedValue(undefined);
+
+      expect(await controller.remove(id)).toEqual({ code: 200 });
+      expect(service.remove).toHaveBeenCalledWith(id);
+    });
+  });
+});

server/src/modules/survey/__test/surveyGroup.service.spec.ts

@@ -0,0 +1,102 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { SurveyGroupService } from '../services/surveyGroup.service';
+import { SurveyGroup } from 'src/models/surveyGroup.entity';
+import { SurveyMeta } from 'src/models/surveyMeta.entity';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+describe('SurveyGroupService', () => {
+  let service: SurveyGroupService;
+
+  const mockSurveyGroupRepository = {
+    create: jest.fn(),
+    save: jest.fn(),
+    findAndCount: jest.fn(),
+    find: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+  };
+
+  const mockSurveyMetaRepository = {
+    updateMany: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        SurveyGroupService,
+        {
+          provide: getRepositoryToken(SurveyGroup),
+          useValue: mockSurveyGroupRepository,
+        },
+        {
+          provide: getRepositoryToken(SurveyMeta),
+          useValue: mockSurveyMetaRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<SurveyGroupService>(SurveyGroupService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('create', () => {
+    it('should create a survey group', async () => {
+      const createParams = { name: 'Test Group', ownerId: '123' };
+      const mockSavedGroup = { ...createParams, id: '1' };
+
+      mockSurveyGroupRepository.create.mockReturnValue(mockSavedGroup);
+      mockSurveyGroupRepository.save.mockResolvedValue(mockSavedGroup);
+
+      expect(await service.create(createParams)).toEqual(mockSavedGroup);
+      expect(mockSurveyGroupRepository.create).toHaveBeenCalledWith(
+        createParams,
+      );
+      expect(mockSurveyGroupRepository.save).toHaveBeenCalledWith(
+        mockSavedGroup,
+      );
+    });
+  });
+
+  describe('findAll', () => {
+    it('should return survey groups', async () => {
+      const list = [{ id: '1', name: 'Test Group', ownerId: '123' }];
+      const total = list.length;
+
+      mockSurveyGroupRepository.findAndCount.mockResolvedValue([list, total]);
+      mockSurveyGroupRepository.find.mockResolvedValue(list);
+
+      const result = await service.findAll('123', '', 0, 10);
+      expect(result).toEqual({ total, list, allList: list });
+      expect(mockSurveyGroupRepository.findAndCount).toHaveBeenCalled();
+      expect(mockSurveyGroupRepository.find).toHaveBeenCalled();
+    });
+  });
+
+  describe('update', () => {
+    it('should update a survey group', async () => {
+      const id = '1';
+      const updatedFields = { name: 'Updated Test Group' };
+
+      await service.update(id, updatedFields);
+      expect(mockSurveyGroupRepository.update).toHaveBeenCalledWith(id, {
+        ...updatedFields,
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove a survey group', async () => {
+      const id = '1';
+      await service.remove(id);
+      expect(mockSurveyMetaRepository.updateMany).toHaveBeenCalledWith(
+        { groupId: id },
+        { $set: { groupId: null } },
+      );
+      expect(mockSurveyGroupRepository.delete).toHaveBeenCalledWith(id);
+    });
+  });
+});

server/src/modules/survey/__test/surveyMeta.controller.spec.ts

@@ -77,6 +77,7 @@ describe('SurveyMetaController', () => {
       survey: {
         title: reqBody.title,
         remark: reqBody.remark,
+        groupId: null,
       },
     });
 

server/src/modules/survey/__test/surveyMeta.service.spec.ts

@@ -86,6 +86,7 @@ describe('SurveyMetaService', () => {
         createMethod: params.createMethod,
         createFrom: params.createFrom,
         workspaceId: params.workspaceId,
+        groupId: null,
       });
       expect(surveyRepository.save).toHaveBeenCalledWith(newSurvey);
       expect(result).toEqual(newSurvey);

server/src/modules/survey/controllers/survey.controller.ts

@@ -78,7 +78,7 @@ export class SurveyController {
       throw new HttpException('参数错误', EXCEPTION_CODE.PARAMETER_ERROR);
     }
 
-    const { title, remark, createMethod, createFrom } = value;
+    const { title, remark, createMethod, createFrom, groupId } = value;
 
     let surveyType = '',
       workspaceId = null;
@@ -100,6 +100,7 @@ export class SurveyController {
       createMethod,
       createFrom,
       workspaceId,
+      groupId,
     });
     await this.surveyConfService.createSurveyConf({
       surveyId: surveyMeta._id.toString(),