BC-5833-Add Submissions Entities Deletion to the Main User Deletion Use Case

apps/server/src/modules/deletion/uc/deletion-request.uc.spec.ts

@@ -16,7 +16,7 @@ import { ObjectId } from 'bson';
 import { RegistrationPinService } from '@modules/registration-pin';
 import { FilesStorageClientAdapterService } from '@src/modules/files-storage-client';
 import { DomainName, OperationType } from '@shared/domain/types';
-import { TaskService } from '@modules/task';
+import { SubmissionService, TaskService } from '@modules/task';
 import { DomainOperationBuilder } from '@shared/domain/builder';
 import { NewsService } from '@src/modules/news/service/news.service';
 import { DeletionStatusModel } from '../domain/types';
@@ -49,6 +49,7 @@ describe(DeletionRequestUc.name, () => {
 	let dashboardService: DeepMocked<DashboardService>;
 	let taskService: DeepMocked<TaskService>;
 	let newsService: DeepMocked<NewsService>;
+	let submissionService: DeepMocked<SubmissionService>;
 
 	beforeAll(async () => {
 		module = await Test.createTestingModule({
@@ -127,6 +128,7 @@ describe(DeletionRequestUc.name, () => {
 					useValue: createMock<TaskService>(),
 				},
 				{ provide: NewsService, useValue: createMock<NewsService>() },
+				{ provide: SubmissionService, useValue: createMock<SubmissionService>() },
 			],
 		}).compile();
 
@@ -149,6 +151,7 @@ describe(DeletionRequestUc.name, () => {
 		dashboardService = module.get(DashboardService);
 		taskService = module.get(TaskService);
 		newsService = module.get(NewsService);
+		submissionService = module.get(SubmissionService);
 		await setupEntities();
 	});
 
@@ -295,6 +298,13 @@ describe(DeletionRequestUc.name, () => {
 					new ObjectId().toHexString(),
 				]);
 
+				const submissionsDeleted = DomainOperationBuilder.build(DomainName.SUBMISSIONS, OperationType.DELETE, 1, [
+					new ObjectId().toHexString(),
+				]);
+				const submissionsUpdated = DomainOperationBuilder.build(DomainName.SUBMISSIONS, OperationType.UPDATE, 1, [
+					new ObjectId().toHexString(),
+				]);
+
 				const user = userDoFactory.buildWithId();
 
 				accountService.deleteAccountByUserId.mockResolvedValueOnce(accountDeleted);
@@ -316,6 +326,8 @@ describe(DeletionRequestUc.name, () => {
 				taskService.removeUserFromFinished.mockResolvedValueOnce(tasksModifiedByRemoveUserFromFinished);
 				taskService.deleteTasksByOnlyCreator.mockResolvedValueOnce(tasksDeleted);
 				newsService.deleteCreatorOrUpdaterReference.mockResolvedValueOnce(newsUpdated);
+				submissionService.deleteSubmissionsByUserId.mockResolvedValueOnce(submissionsDeleted);
+				submissionService.updateSubmissionByUserId.mockResolvedValueOnce(submissionsUpdated);
 
 				return {
 					deletionRequestToExecute,
@@ -553,14 +565,34 @@ describe(DeletionRequestUc.name, () => {
 				expect(newsService.deleteCreatorOrUpdaterReference).toHaveBeenCalledWith(deletionRequestToExecute.targetRefId);
 			});
 
+			it('should call submissionService.deleteSubmissionsByUserId to delete submissions', async () => {
+				const { deletionRequestToExecute } = setup();
+
+				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequestToExecute]);
+
+				await uc.executeDeletionRequests();
+
+				expect(submissionService.deleteSubmissionsByUserId).toHaveBeenCalledWith(deletionRequestToExecute.targetRefId);
+			});
+
+			it('should call submissionService.updateSubmissionByUserId to update submissions', async () => {
+				const { deletionRequestToExecute } = setup();
+
+				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequestToExecute]);
+
+				await uc.executeDeletionRequests();
+
+				expect(submissionService.updateSubmissionByUserId).toHaveBeenCalledWith(deletionRequestToExecute.targetRefId);
+			});
+
 			it('should call deletionLogService.createDeletionLog to create logs for deletionRequest', async () => {
 				const { deletionRequestToExecute } = setup();
 
 				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequestToExecute]);
 
 				await uc.executeDeletionRequests();
 
-				expect(deletionLogService.createDeletionLog).toHaveBeenCalledTimes(13);
+				expect(deletionLogService.createDeletionLog).toHaveBeenCalledTimes(15);
 			});
 		});
 

apps/server/src/modules/deletion/uc/deletion-request.uc.ts

@@ -13,7 +13,7 @@ import { Injectable } from '@nestjs/common';
 import { DomainName, EntityId, OperationType } from '@shared/domain/types';
 import { LegacyLogger } from '@src/core/logger';
 import { FilesStorageClientAdapterService } from '@modules/files-storage-client';
-import { TaskService } from '@modules/task';
+import { SubmissionService, TaskService } from '@modules/task';
 import { DomainOperation } from '@shared/domain/interface';
 import { DomainOperationBuilder } from '@shared/domain/builder/domain-operation.builder';
 import { NewsService } from '@src/modules/news/service/news.service';
@@ -43,6 +43,7 @@ export class DeletionRequestUc {
 		private readonly filesStorageClientAdapterService: FilesStorageClientAdapterService,
 		private readonly dashboardService: DashboardService,
 		private readonly taskService: TaskService,
+		private readonly submissionService: SubmissionService,
 		private readonly newsService: NewsService
 	) {
 		this.logger.setContext(DeletionRequestUc.name);
@@ -113,6 +114,7 @@ export class DeletionRequestUc {
 				this.removeUserFromRocketChat(deletionRequest),
 				this.removeUsersDashboard(deletionRequest),
 				this.removeUserFromTasks(deletionRequest),
+				this.removeUserFromSubmissions(deletionRequest),
 				this.removeUsersDataFromNews(deletionRequest),
 			]);
 			await this.deletionRequestService.markDeletionRequestAsExecuted(deletionRequest.id);
@@ -374,6 +376,31 @@ export class DeletionRequestUc {
 		);
 	}
 
+	private async removeUserFromSubmissions(deletionRequest: DeletionRequest) {
+		this.logger.debug({ action: 'removeUserFromSubmissions', deletionRequest });
+
+		const [submissionsDeleted, submissionsModified] = await Promise.all([
+			this.submissionService.deleteSubmissionsByUserId(deletionRequest.targetRefId),
+			this.submissionService.updateSubmissionByUserId(deletionRequest.targetRefId),
+		]);
+
+		await this.logDeletion(
+			deletionRequest,
+			submissionsDeleted.domain,
+			submissionsDeleted.operation,
+			submissionsDeleted.count,
+			submissionsDeleted.refs
+		);
+
+		await this.logDeletion(
+			deletionRequest,
+			submissionsModified.domain,
+			submissionsModified.operation,
+			submissionsModified.count,
+			submissionsModified.refs
+		);
+	}
+
 	private async removeUsersDataFromNews(deletionRequest: DeletionRequest) {
 		this.logger.debug({ action: 'removeUsersDataFromNews', deletionRequest });
 		const newsModified = await this.newsService.deleteCreatorOrUpdaterReference(deletionRequest.targetRefId);

apps/server/src/modules/task/service/submission.service.spec.ts

@@ -5,7 +5,9 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { Submission } from '@shared/domain/entity';
 import { Counted } from '@shared/domain/types';
 import { SubmissionRepo } from '@shared/repo';
-import { setupEntities, submissionFactory, taskFactory } from '@shared/testing';
+import { setupEntities, submissionFactory, taskFactory, userFactory } from '@shared/testing';
+import { Logger } from '@src/core/logger';
+import { ObjectId } from 'bson';
 import { SubmissionService } from './submission.service';
 
 describe('Submission Service', () => {
@@ -29,6 +31,10 @@ describe('Submission Service', () => {
 					provide: FilesStorageClientAdapterService,
 					useValue: createMock<FilesStorageClientAdapterService>(),
 				},
+				{
+					provide: Logger,
+					useValue: createMock<Logger>(),
+				},
 			],
 		}).compile();
 
@@ -211,4 +217,101 @@ describe('Submission Service', () => {
 			});
 		});
 	});
+
+	describe('deleteSubmissionsByUserId', () => {
+		describe('when submission with specified userId was not found ', () => {
+			const setup = () => {
+				const submission = submissionFactory.buildWithId();
+
+				submissionRepo.findAllByUserId.mockResolvedValueOnce([[], 0]);
+
+				return { submission };
+			};
+
+			it('should return deletedSubmissions number of 0', async () => {
+				const { submission } = setup();
+
+				const result = await service.deleteSubmissionsByUserId(new ObjectId().toString());
+
+				expect(result.count).toEqual(0);
+				expect(result.refs.length).toEqual(0);
+				expect(submission).toBeDefined();
+			});
+		});
+
+		describe('when submission with specified userId was found ', () => {
+			const setup = () => {
+				const user = userFactory.buildWithId();
+				const submission = submissionFactory.buildWithId({ student: user, teamMembers: [user] });
+
+				submissionRepo.findAllByUserId.mockResolvedValueOnce([[submission], 1]);
+				submissionRepo.delete.mockResolvedValueOnce();
+
+				return { submission, user };
+			};
+
+			it('should return deletedSubmissions number of 1', async () => {
+				const { submission, user } = setup();
+
+				const result = await service.deleteSubmissionsByUserId(user.id);
+
+				expect(result.count).toEqual(1);
+				expect(result.refs.length).toEqual(1);
+				expect(submissionRepo.delete).toBeCalledTimes(1);
+				expect(submissionRepo.delete).toHaveBeenCalledWith([submission]);
+			});
+		});
+	});
+
+	describe('updateSubmissionByUserId', () => {
+		describe('when submission with specified userId was not found ', () => {
+			const setup = () => {
+				const user1 = userFactory.buildWithId();
+				const user2 = userFactory.buildWithId();
+				const submission = submissionFactory.buildWithId({ student: user1, teamMembers: [user1, user2] });
+
+				submissionRepo.findAllByUserId.mockResolvedValueOnce([[], 0]);
+
+				return { submission, user1, user2 };
+			};
+
+			it('should return updated submission number of 0', async () => {
+				const { submission, user1 } = setup();
+
+				const result = await service.updateSubmissionByUserId(new ObjectId().toString());
+
+				expect(result.count).toEqual(0);
+				expect(result.refs.length).toEqual(0);
+				expect(submission.student).toEqual(user1);
+				expect(submission.teamMembers.length).toEqual(2);
+			});
+		});
+
+		describe('when submission with specified userId was found ', () => {
+			const setup = () => {
+				const user1 = userFactory.buildWithId();
+				const user2 = userFactory.buildWithId();
+				const submission = submissionFactory.buildWithId({ student: user1, teamMembers: [user1, user2] });
+
+				submissionRepo.findAllByUserId.mockResolvedValueOnce([[submission], 1]);
+				submissionRepo.delete.mockResolvedValueOnce();
+
+				return { submission, user1, user2 };
+			};
+
+			it('should return updated submission number of 1', async () => {
+				const { submission, user1, user2 } = setup();
+
+				const result = await service.updateSubmissionByUserId(user1.id);
+
+				expect(result.count).toEqual(1);
+				expect(result.refs.length).toEqual(1);
+				expect(submission.student).toBeUndefined();
+				expect(submission.teamMembers.length).toEqual(1);
+				expect(submission.teamMembers[0]).toEqual(user2);
+				expect(submissionRepo.save).toBeCalledTimes(1);
+				expect(submissionRepo.save).toHaveBeenCalledWith([submission]);
+			});
+		});
+	});
 });

apps/server/src/modules/task/service/submission.service.ts

@@ -1,14 +1,19 @@
 import { FilesStorageClientAdapterService } from '@modules/files-storage-client';
 import { Injectable } from '@nestjs/common';
+import { DataDeletionDomainOperationLoggable } from '@shared/common/loggable';
+import { DomainOperationBuilder } from '@shared/domain/builder';
 import { Submission } from '@shared/domain/entity';
-import { Counted, EntityId } from '@shared/domain/types';
+import { DomainOperation } from '@shared/domain/interface';
+import { Counted, DomainName, EntityId, OperationType, StatusModel } from '@shared/domain/types';
 import { SubmissionRepo } from '@shared/repo';
+import { Logger } from '@src/core/logger';
 
 @Injectable()
 export class SubmissionService {
 	constructor(
 		private readonly submissionRepo: SubmissionRepo,
-		private readonly filesStorageClientAdapterService: FilesStorageClientAdapterService
+		private readonly filesStorageClientAdapterService: FilesStorageClientAdapterService,
+		private readonly logger: Logger
 	) {}
 
 	async findById(submissionId: EntityId): Promise<Submission> {
@@ -26,4 +31,104 @@ export class SubmissionService {
 
 		await this.submissionRepo.delete(submission);
 	}
+
+	async deleteSubmissionsByUserId(userId: EntityId): Promise<DomainOperation> {
+		this.logger.info(
+			new DataDeletionDomainOperationLoggable(
+				'Deleting data from Submissions',
+				DomainName.SUBMISSIONS,
+				userId,
+				StatusModel.PENDING
+			)
+		);
+		const submissions = await this.submissionRepo.findAllByUserId(userId);
+		const submissionsToDelete: Submission[] = [];
+
+		if (submissions[1] > 0) {
+			submissions[0].forEach((submission) => {
+				if (submission.courseGroup === null && submission.teamMembers.length === 1) {
+					submissionsToDelete.push(submission);
+				}
+			});
+		}
+
+		const submissionsToDeleteCount = submissionsToDelete.length;
+		if (submissionsToDeleteCount > 0) {
+			await this.submissionRepo.delete(submissionsToDelete);
+		}
+
+		const result = DomainOperationBuilder.build(
+			DomainName.SUBMISSIONS,
+			OperationType.DELETE,
+			submissionsToDelete.length,
+			this.getSubmissionsId(submissionsToDelete)
+		);
+
+		this.logger.info(
+			new DataDeletionDomainOperationLoggable(
+				'Successfully deleted data from Submissions',
+				DomainName.SUBMISSIONS,
+				userId,
+				StatusModel.FINISHED,
+				submissionsToDeleteCount,
+				0
+			)
+		);
+
+		return result;
+	}
+
+	async updateSubmissionByUserId(userId: EntityId): Promise<DomainOperation> {
+		this.logger.info(
+			new DataDeletionDomainOperationLoggable(
+				'Deleting user data from Submissions',
+				DomainName.SUBMISSIONS,
+				userId,
+				StatusModel.PENDING
+			)
+		);
+
+		const submissions = await this.submissionRepo.findAllByUserId(userId);
+		const submissionsToUpdate: Submission[] = [];
+
+		if (submissions[1] > 0) {
+			submissions[0].forEach((submission) => {
+				if (submission.courseGroup !== null || (submission.courseGroup === null && submission.teamMembers.length > 1)) {
+					submissionsToUpdate.push(submission);
+				}
+			});
+		}
+
+		const submissionsToUpdateCount = submissionsToUpdate.length;
+		if (submissionsToUpdateCount > 0) {
+			submissionsToUpdate.forEach((submission) => {
+				submission.removeStudentById(userId);
+				submission.removeUserFromTeamMembers(userId);
+			});
+
+			await this.submissionRepo.save(submissionsToUpdate);
+		}
+		const result = DomainOperationBuilder.build(
+			DomainName.SUBMISSIONS,
+			OperationType.UPDATE,
+			submissionsToUpdateCount,
+			this.getSubmissionsId(submissionsToUpdate)
+		);
+
+		this.logger.info(
+			new DataDeletionDomainOperationLoggable(
+				'Successfully deleted user data from Submissions collection',
+				DomainName.SUBMISSIONS,
+				userId,
+				StatusModel.FINISHED,
+				submissionsToUpdateCount,
+				0
+			)
+		);
+		return result;
+	}
+
+	private getSubmissionsId(submissions: Submission[]): EntityId[] {
+		return submissions.map((submission) => submission.id);
+	}
 }