[Feature]: 回收站

server/src/models/responseSchema.entity.ts

@@ -31,4 +31,7 @@ export class ResponseSchema extends BaseEntity {
 
   @Column()
   isDeleted: boolean;
+
+  @Column()
+  isForeverDeleted: boolean;
 }

server/src/models/surveyMeta.entity.ts

@@ -70,6 +70,9 @@ export class SurveyMeta extends BaseEntity {
   @Column()
   deletedAt: Date;
 
+  @Column()
+  isForeverDeleted: boolean;
+
   @BeforeInsert()
   initDefaultInfo() {
     const now = Date.now();

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

@@ -210,6 +210,54 @@ describe('SurveyController', () => {
     });
   });
 
+  describe('recoverSurvey', () => {
+    it('should recover a survey and its related data', async () => {
+      const surveyId = new ObjectId();
+      const surveyMeta = {
+        _id: surveyId,
+        surveyType: 'exam',
+        owner: 'testUser',
+      };
+
+      jest
+        .spyOn(surveyMetaService, 'recoverSurveyMeta')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(responseSchemaService, 'recoverResponseSchema')
+        .mockResolvedValue(undefined);
+
+      const result = await controller.recoverSurvey({
+        surveyMeta,
+        user: { username: 'testUser', _id: new ObjectId() },
+      });
+      expect(result).toEqual({ code: 200 });
+    });
+  });
+
+  describe('foreverDeleteSurvey', () => {
+    it('should forever delete a survey and its related data', async () => {
+      const surveyId = new ObjectId();
+      const surveyMeta = {
+        _id: surveyId,
+        surveyType: 'exam',
+        owner: 'testUser',
+      };
+
+      jest
+        .spyOn(surveyMetaService, 'foreverDeleteSurveyMeta')
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(responseSchemaService, 'foreverDeleteResponseSchema')
+        .mockResolvedValue(undefined);
+
+      const result = await controller.recoverSurvey({
+        surveyMeta,
+        user: { username: 'testUser', _id: new ObjectId() },
+      });
+      expect(result).toEqual({ code: 200 });
+    });
+  });
+
   describe('getSurvey', () => {
     it('should return survey metadata and configuration', async () => {
       const surveyId = new ObjectId();

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

@@ -26,6 +26,10 @@ describe('SurveyMetaController', () => {
             getSurveyMetaList: jest
               .fn()
               .mockResolvedValue({ count: 0, data: [] }),
+            getSurveyRecycleList: jest
+              .fn()
+              .mockResolvedValue({ count: 0, data: [] }),
+            getRecycleTotal: jest.fn().mockResolvedValue(0),
           },
         },
         {
@@ -177,6 +181,109 @@ describe('SurveyMetaController', () => {
     });
   });
 
+  it('should get the number of recycle survey', async () => {
+    const userId = new ObjectId().toString();
+    const req = {
+      user: {
+        username: 'test-user',
+        _id: new ObjectId(userId),
+      },
+    };
+
+    jest.spyOn(surveyMetaService, 'getRecycleTotal').mockImplementation(() => {
+      return Promise.resolve(10);
+    });
+
+    const result = await controller.getRecycleTotal(req);
+
+    expect(result).toEqual({
+      code: 200,
+      data: {
+        total: 10,
+      },
+    });
+
+    expect(surveyMetaService.getRecycleTotal).toHaveBeenCalledWith(userId);
+  });
+
+  it('should get survey meta recycle list', async () => {
+    const queryInfo = {
+      curPage: 1,
+      pageSize: 10,
+    };
+    const userId = new ObjectId().toString();
+    const req = {
+      user: {
+        username: 'test-user',
+        _id: new ObjectId(userId),
+      },
+    };
+
+    jest
+      .spyOn(surveyMetaService, 'getSurveyRecycleList')
+      .mockImplementation(() => {
+        const date = new Date().getTime();
+        return Promise.resolve({
+          count: 10,
+          data: [
+            {
+              _id: new ObjectId(),
+              createdAt: date,
+              updatedAt: date,
+              curStatus: {
+                date: date,
+              },
+              subStatus: {
+                date: date,
+              },
+              surveyType: 'normal',
+            },
+          ],
+        });
+      });
+
+    const result = await controller.getRecycleList(queryInfo, req);
+
+    expect(result).toEqual({
+      code: 200,
+      data: {
+        count: 10,
+        data: expect.arrayContaining([
+          expect.objectContaining({
+            createdAt: expect.stringMatching(
+              /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+            ),
+            deletedAt: expect.stringMatching(
+              /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+            ),
+            curStatus: expect.objectContaining({
+              date: expect.stringMatching(
+                /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+              ),
+            }),
+            subStatus: expect.objectContaining({
+              date: expect.stringMatching(
+                /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+              ),
+            }),
+            surveyType: 'normal',
+          }),
+        ]),
+      },
+    });
+
+    expect(surveyMetaService.getSurveyRecycleList).toHaveBeenCalledWith({
+      pageNum: queryInfo.curPage,
+      pageSize: queryInfo.pageSize,
+      username: req.user.username,
+      filter: {},
+      order: {},
+      surveyIdList: [],
+      userId,
+      workspaceId: undefined,
+    });
+  });
+
   it('should get survey meta list with filter and order', async () => {
     const queryInfo = {
       curPage: 1,

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

@@ -26,6 +26,7 @@ describe('SurveyMetaService', () => {
             save: jest.fn(),
             updateOne: jest.fn(),
             findAndCount: jest.fn(),
+            countBy: jest.fn(),
           },
         },
         PluginManager,
@@ -180,6 +181,72 @@ describe('SurveyMetaService', () => {
     });
   });
 
+  describe('recoverSurveyMeta', () => {
+    it('should recover a survey', async () => {
+      const surveyId = new ObjectId().toString();
+      const operator = 'recoverer';
+      const operatorId = 'recovererId';
+
+      jest.spyOn(surveyRepository, 'updateOne').mockResolvedValue({
+        matchedCount: 1,
+        modifiedCount: 1,
+        acknowledged: true,
+      });
+
+      const result = await service.recoverSurveyMeta({
+        surveyId,
+        operator,
+        operatorId,
+      });
+
+      expect(surveyRepository.updateOne).toHaveBeenCalledWith(
+        { _id: new ObjectId(surveyId) },
+        {
+          $set: {
+            isDeleted: false,
+            operator,
+            operatorId,
+          },
+        },
+      );
+      expect(result.matchedCount).toBe(1);
+    });
+  });
+
+  describe('foreverDeleteSurveyMeta', () => {
+    it('should mark a survey as isForeverDeleted', async () => {
+      const surveyId = new ObjectId().toString();
+      const operator = 'deleter';
+      const operatorId = 'deleterId';
+
+      jest.spyOn(surveyRepository, 'updateOne').mockResolvedValue({
+        matchedCount: 1,
+        modifiedCount: 1,
+        acknowledged: true,
+      });
+
+      const result = await service.foreverDeleteSurveyMeta({
+        surveyId,
+        operator,
+        operatorId,
+      });
+
+      expect(surveyRepository.updateOne).toHaveBeenCalledWith(
+        { _id: new ObjectId(surveyId) },
+        {
+          $set: {
+            isDeleted: true,
+            operator,
+            operatorId,
+            deletedAt: expect.any(Date),
+            isForeverDeleted: true,
+          },
+        },
+      );
+      expect(result.matchedCount).toBe(1);
+    });
+  });
+
   describe('getSurveyMetaList', () => {
     it('should return a list of survey metadata', async () => {
       const mockData = [
@@ -207,6 +274,48 @@ describe('SurveyMetaService', () => {
     });
   });
 
+  describe('getRecycleTotal', () => {
+    it('should return the number of recycled survey metadata', async () => {
+      const mockCount = 1;
+
+      jest.spyOn(surveyRepository, 'countBy').mockResolvedValue(mockCount);
+
+      const userId = 'testUserId';
+
+      const result = await service.getRecycleTotal(userId);
+
+      expect(result).toEqual(mockCount);
+      expect(surveyRepository.countBy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('getSurveyRecycleList', () => {
+    it('should return a list of survey metadata', async () => {
+      const mockData = [
+        { _id: 1, title: 'Survey 1' },
+      ] as unknown as Array<SurveyMeta>;
+      const mockCount = 1;
+
+      jest
+        .spyOn(surveyRepository, 'findAndCount')
+        .mockResolvedValue([mockData, mockCount]);
+
+      const condition = {
+        pageNum: 1,
+        pageSize: 10,
+        userId: 'testUserId',
+        username: 'testUser',
+        filter: {},
+        order: {},
+      };
+
+      const result = await service.getSurveyRecycleList(condition);
+
+      expect(result).toEqual({ data: mockData, count: mockCount });
+      expect(surveyRepository.findAndCount).toHaveBeenCalledTimes(1);
+    });
+  });
+
   describe('publishSurveyMeta', () => {
     it('should publish a survey and update curStatus', async () => {
       const surveyMeta = new SurveyMeta();