BC-4973-rewrite-data-retrival-in-course

apps/server/src/modules/learnroom/service/course.service.spec.ts

@@ -50,6 +50,43 @@ describe('CourseService', () => {
 		});
 	});
 
+	describe('findUserDataFromCourses', () => {
+		describe('when finding by userId', () => {
+			const setup = () => {
+				const user = userFactory.buildWithId();
+				const course1 = courseFactory.buildWithId({ students: [user] });
+				const course2 = courseFactory.buildWithId({ teachers: [user] });
+				const course3 = courseFactory.buildWithId({ substitutionTeachers: [user] });
+				const allCourses = [course1, course2, course3];
+
+				userRepo.findById.mockResolvedValue(user);
+				courseRepo.findAllByUserId.mockResolvedValue([allCourses, allCourses.length]);
+
+				return {
+					user,
+					allCourses,
+				};
+			};
+
+			it('should call courseRepo.findAllByUserId', async () => {
+				const { user } = setup();
+
+				await courseService.findUserDataFromCourses(user.id);
+
+				expect(courseRepo.findAllByUserId).toBeCalledWith(user.id);
+			});
+
+			it('should return array of courses with userId', async () => {
+				const { user, allCourses } = setup();
+
+				const [courses] = await courseService.findUserDataFromCourses(user.id);
+
+				expect(courses.length).toEqual(3);
+				expect(courses).toEqual(allCourses);
+			});
+		});
+	});
+
 	describe('when deleting by userId', () => {
 		const setup = () => {
 			const user = userFactory.buildWithId();

apps/server/src/modules/learnroom/service/course.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { CourseRepo } from '@shared/repo';
-import { Course, EntityId } from '@shared/domain';
+import { Counted, Course, EntityId } from '@shared/domain';
 
 @Injectable()
 export class CourseService {
@@ -10,6 +10,12 @@ export class CourseService {
 		return this.repo.findById(courseId);
 	}
 
+	public async findUserDataFromCourses(userId: EntityId): Promise<Counted<Course[]>> {
+		const [courses, count] = await this.repo.findAllByUserId(userId);
+
+		return [courses, count];
+	}
+
 	public async deleteUserDataFromCourse(userId: EntityId): Promise<number> {
 		const [courses, count] = await this.repo.findAllByUserId(userId);
 

apps/server/src/modules/learnroom/service/coursegroup.service.spec.ts

@@ -38,6 +38,42 @@ describe('CourseGroupService', () => {
 		jest.clearAllMocks();
 	});
 
+	describe('finUserDataFromCourseGroup', () => {
+		describe('when finding by userId', () => {
+			const setup = () => {
+				const user = userFactory.buildWithId();
+				const courseGroup1 = courseGroupFactory.buildWithId({ students: [user] });
+				const courseGroup2 = courseGroupFactory.buildWithId({ students: [user] });
+				const courseGroups = [courseGroup1, courseGroup2];
+
+				userRepo.findById.mockResolvedValue(user);
+				courseGroupRepo.findByUserId.mockResolvedValue([courseGroups, courseGroups.length]);
+
+				return {
+					user,
+					courseGroups,
+				};
+			};
+
+			it('should call courseGroupRepo.findByUserId', async () => {
+				const { user } = setup();
+
+				await courseGroupService.finUserDataFromCourseGroup(user.id);
+
+				expect(courseGroupRepo.findByUserId).toBeCalledWith(user.id);
+			});
+
+			it('should return array with coursesGroup with userId', async () => {
+				const { user, courseGroups } = setup();
+
+				const [courseGroup] = await courseGroupService.finUserDataFromCourseGroup(user.id);
+
+				expect(courseGroup.length).toEqual(2);
+				expect(courseGroup).toEqual(courseGroups);
+			});
+		});
+	});
+
 	describe('when deleting by userId', () => {
 		const setup = () => {
 			const user = userFactory.buildWithId();

apps/server/src/modules/learnroom/service/coursegroup.service.ts

@@ -1,11 +1,17 @@
 import { Injectable } from '@nestjs/common';
-import { EntityId } from '@shared/domain';
+import { Counted, CourseGroup, EntityId } from '@shared/domain';
 import { CourseGroupRepo } from '@shared/repo';
 
 @Injectable()
 export class CourseGroupService {
 	constructor(private readonly repo: CourseGroupRepo) {}
 
+	public async finUserDataFromCourseGroup(userId: EntityId): Promise<Counted<CourseGroup[]>> {
+		const [courseGroups, count] = await this.repo.findByUserId(userId);
+
+		return [courseGroups, count];
+	}
+
 	public async deleteUserDataFromCourseGroup(userId: EntityId): Promise<number> {
 		const [courseGroups, count] = await this.repo.findByUserId(userId);
 

apps/server/src/modules/lesson/service/lesson.service.spec.ts

@@ -77,6 +77,47 @@ describe('LessonService', () => {
 		});
 	});
 
+	describe('findUserDataFromLessons', () => {
+		describe('when finding by userId', () => {
+			const setup = () => {
+				const userId = new ObjectId().toHexString();
+				const contentExample: IComponentProperties = {
+					title: 'title',
+					hidden: false,
+					user: userId,
+					component: ComponentType.TEXT,
+					content: { text: 'test of content' },
+				};
+				const lesson1 = lessonFactory.buildWithId({ contents: [contentExample] });
+				const lesson2 = lessonFactory.buildWithId({ contents: [contentExample] });
+				const lessons = [lesson1, lesson2];
+
+				lessonRepo.findByUserId.mockResolvedValue(lessons);
+
+				return {
+					userId,
+					lessons,
+				};
+			};
+
+			it('should call findByCourseIds from lesson repo', async () => {
+				const { userId } = setup();
+
+				await expect(lessonService.findUserDataFromLessons(userId)).resolves.not.toThrow();
+				expect(lessonRepo.findByUserId).toBeCalledWith(userId);
+			});
+
+			it('should return array of lessons with userId', async () => {
+				const { userId, lessons } = setup();
+
+				const result = await lessonService.findUserDataFromLessons(userId);
+
+				expect(result).toHaveLength(2);
+				expect(result).toEqual(lessons);
+			});
+		});
+	});
+
 	describe('deleteUserDataFromTeams', () => {
 		describe('when deleting by userId', () => {
 			const setup = () => {

apps/server/src/modules/lesson/service/lesson.service.ts

@@ -24,6 +24,12 @@ export class LessonService {
 		return this.lessonRepo.findAllByCourseIds(courseIds);
 	}
 
+	async findUserDataFromLessons(userId: EntityId): Promise<LessonEntity[]> {
+		const lessons = await this.lessonRepo.findByUserId(userId);
+
+		return lessons;
+	}
+
 	async deleteUserDataFromLessons(userId: EntityId): Promise<number> {
 		const lessons = await this.lessonRepo.findByUserId(userId);