N21-2075: sync existing course

apps/server/src/migrations/mikro-orm/Migration20240823151836.ts

@@ -0,0 +1,37 @@
+import { Migration } from '@mikro-orm/migrations-mongodb';
+
+export class Migration20240823151836 extends Migration {
+	async up(): Promise<void> {
+		const adminRoleUpdate = await this.getCollection('roles').updateOne(
+			{ name: 'administrator' },
+			{
+				$addToSet: {
+					permissions: {
+						$each: ['COURSE_ADMINISTRATION'],
+					},
+				},
+			}
+		);
+
+		if (adminRoleUpdate.modifiedCount > 0) {
+			console.info('Permission COURSE_ADMINISTRATION added to role administrator.');
+		}
+	}
+
+	async down(): Promise<void> {
+		const adminRoleUpdate = await this.getCollection('roles').updateOne(
+			{ name: 'administrator' },
+			{
+				$pull: {
+					permissions: {
+						$in: ['COURSE_ADMINISTRATION'],
+					},
+				},
+			}
+		);
+
+		if (adminRoleUpdate.modifiedCount > 0) {
+			console.info('Rollback: Permission COURSE_ADMINISTRATION added to role administrator.');
+		}
+	}
+}

apps/server/src/modules/authorization/domain/rules/course.rule.ts

@@ -1,6 +1,7 @@
 import { Course } from '@modules/learnroom/domain';
 import { Injectable } from '@nestjs/common';
 import { Course as CourseEntity, User } from '@shared/domain/entity';
+import { Permission } from '@shared/domain/interface';
 import { AuthorizationHelper } from '../service/authorization.helper';
 import { Action, AuthorizationContext, Rule } from '../type';
 
@@ -16,14 +17,27 @@ export class CourseRule implements Rule<CourseEntity | Course> {
 
 	public hasPermission(user: User, object: CourseEntity | Course, context: AuthorizationContext): boolean {
 		const { action, requiredPermissions } = context;
-		const hasPermission =
-			this.authorizationHelper.hasAllPermissions(user, requiredPermissions) &&
-			this.authorizationHelper.hasAccessToEntity(
-				user,
-				object,
-				action === Action.read ? ['teachers', 'substitutionTeachers', 'students'] : ['teachers', 'substitutionTeachers']
-			);
-
-		return hasPermission;
+
+		const hasRequiredPermission = this.authorizationHelper.hasAllPermissions(user, requiredPermissions);
+		const hasAdminPermission = this.authorizationHelper.hasAllPermissions(user, [Permission.COURSE_ADMINISTRATION]);
+
+		const hasAccessToEntity = hasAdminPermission
+			? true
+			: this.authorizationHelper.hasAccessToEntity(
+					user,
+					object,
+					this.isReadAction(action)
+						? ['teachers', 'substitutionTeachers', 'students']
+						: ['teachers', 'substitutionTeachers']
+			  );
+
+		return hasAccessToEntity && hasRequiredPermission;
+	}
+
+	isReadAction(action: Action) {
+		if (action === Action.read) {
+			return true;
+		}
+		return false;
 	}
 }

apps/server/src/modules/class/repo/classes.repo.spec.ts

@@ -177,4 +177,35 @@ describe(ClassesRepo.name, () => {
 			});
 		});
 	});
+
+	describe('findClassById', () => {
+		describe('when class is not found in classes', () => {
+			it('should return null', async () => {
+				const result = await repo.findClassById(new ObjectId().toHexString());
+
+				expect(result).toEqual(null);
+			});
+		});
+
+		describe('when class is in classes', () => {
+			const setup = async () => {
+				const class1: ClassEntity = classEntityFactory.buildWithId();
+				console.log(class1.id);
+				await em.persistAndFlush([class1]);
+				em.clear();
+
+				return {
+					class1,
+				};
+			};
+
+			it('should find class with particular classId', async () => {
+				const { class1 } = await setup();
+
+				const result = await repo.findClassById(class1.id);
+
+				expect(result?.id).toEqual(class1.id);
+			});
+		});
+	});
 });

apps/server/src/modules/class/repo/classes.repo.ts

@@ -55,4 +55,16 @@ export class ClassesRepo {
 
 		await this.em.persistAndFlush(existingEntities);
 	}
+
+	public async findClassById(id: EntityId): Promise<Class | null> {
+		const clazz = await this.em.findOne(ClassEntity, { id });
+
+		if (!clazz) {
+			return null;
+		}
+
+		const domainObject: Class = ClassMapper.mapToDO(clazz);
+
+		return domainObject;
+	}
 }

apps/server/src/modules/class/repo/mapper/class.mapper.ts

@@ -4,7 +4,7 @@ import { ClassSourceOptions } from '../../domain/class-source-options.do';
 import { ClassEntity } from '../../entity';
 
 export class ClassMapper {
-	private static mapToDO(entity: ClassEntity): Class {
+	static mapToDO(entity: ClassEntity): Class {
 		return new Class({
 			id: entity.id,
 			name: entity.name,

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

@@ -12,6 +12,7 @@ import { deletionRequestFactory } from '@modules/deletion/domain/testing';
 import { InternalServerErrorException } from '@nestjs/common';
 import { EventBus } from '@nestjs/cqrs';
 import { Test, TestingModule } from '@nestjs/testing';
+import { NotFoundLoggableException } from '@shared/common/loggable-exception';
 import { EntityId } from '@shared/domain/types';
 import { setupEntities } from '@shared/testing';
 import { Logger } from '@src/core/logger';
@@ -126,6 +127,34 @@ describe(ClassService.name, () => {
 		});
 	});
 
+	describe('findById', () => {
+		describe('when the user has classes', () => {
+			const setup = () => {
+				const clazz: Class = classFactory.build();
+
+				classesRepo.findClassById.mockResolvedValueOnce(clazz);
+
+				return {
+					clazz,
+				};
+			};
+
+			it('should return the class', async () => {
+				const { clazz } = setup();
+
+				const result: Class = await service.findById(clazz.id);
+
+				expect(result).toEqual(clazz);
+			});
+
+			it('should throw error', async () => {
+				classesRepo.findClassById.mockResolvedValueOnce(null);
+
+				await expect(service.findById('someId')).rejects.toThrowError(NotFoundLoggableException);
+			});
+		});
+	});
+
 	describe('deleteUserDataFromClasses', () => {
 		describe('when user is missing', () => {
 			const setup = () => {

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

@@ -13,6 +13,7 @@ import {
 } from '@modules/deletion';
 import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { EventBus, EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { NotFoundLoggableException } from '@shared/common/loggable-exception';
 import { EntityId } from '@shared/domain/types';
 import { Logger } from '@src/core/logger';
 import { Class } from '../domain';
@@ -100,4 +101,12 @@ export class ClassService implements DeletionService, IEventHandler<UserDeletedE
 	private getClassesId(classes: Class[]): EntityId[] {
 		return classes.map((item) => item.id);
 	}
+
+	public async findById(id: EntityId): Promise<Class> {
+		const clazz: Class | null = await this.classesRepo.findClassById(id);
+		if (!clazz) {
+			throw new NotFoundLoggableException(Class.name, { id });
+		}
+		return clazz;
+	}
 }

apps/server/src/modules/learnroom/controller/api-test/course-info.api.spec.ts

@@ -0,0 +1,178 @@
+import { EntityManager } from '@mikro-orm/mongodb';
+import { ServerTestModule } from '@modules/server/server.module';
+import { HttpStatus, INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Course as CourseEntity } from '@shared/domain/entity';
+import { Permission } from '@shared/domain/interface';
+import {
+	cleanupCollections,
+	courseFactory,
+	schoolEntityFactory,
+	TestApiClient,
+	UserAndAccountTestFactory,
+} from '@shared/testing';
+import { CourseSortQueryType, CourseStatusQueryType } from '../../domain';
+import { CourseInfoListResponse } from '../dto/response';
+
+const createStudent = () => {
+	const { studentUser, studentAccount } = UserAndAccountTestFactory.buildStudent({}, [Permission.COURSE_VIEW]);
+	return { account: studentAccount, user: studentUser };
+};
+const createTeacher = () => {
+	const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({}, [
+		Permission.COURSE_VIEW,
+		Permission.COURSE_EDIT,
+	]);
+	return { account: teacherAccount, user: teacherUser };
+};
+
+const createAdmin = () => {
+	const { adminAccount, adminUser } = UserAndAccountTestFactory.buildAdmin({}, [Permission.COURSE_ADMINISTRATION]);
+	return { account: adminAccount, user: adminUser };
+};
+
+describe('Course Info Controller (API)', () => {
+	let app: INestApplication;
+	let em: EntityManager;
+	let testApiClient: TestApiClient;
+
+	beforeAll(async () => {
+		const module: TestingModule = await Test.createTestingModule({
+			imports: [ServerTestModule],
+		}).compile();
+
+		app = module.createNestApplication();
+		await app.init();
+		em = module.get(EntityManager);
+		testApiClient = new TestApiClient(app, 'course-info');
+	});
+
+	afterAll(async () => {
+		await cleanupCollections(em);
+		await app.close();
+	});
+
+	describe('[GET] /course-info', () => {
+		describe('when logged in as admin', () => {
+			const setup = async () => {
+				const student = createStudent();
+				const teacher = createTeacher();
+				const admin = createAdmin();
+				const school = schoolEntityFactory.buildWithId({});
+
+				const currentCourses: CourseEntity[] = courseFactory.buildList(5, {
+					school,
+					untilDate: new Date('2045-07-31T23:59:59'),
+				});
+				const archivedCourses: CourseEntity[] = courseFactory.buildList(10, {
+					school,
+					untilDate: new Date('2024-07-31T23:59:59'),
+				});
+
+				admin.user.school = school;
+				await em.persistAndFlush(school);
+				await em.persistAndFlush(currentCourses);
+				await em.persistAndFlush(archivedCourses);
+				await em.persistAndFlush([admin.account, admin.user]);
+				em.clear();
+
+				return {
+					student,
+					currentCourses,
+					archivedCourses,
+					teacher,
+					admin,
+					school,
+				};
+			};
+
+			it('should return the correct response structure', async () => {
+				const { admin } = await setup();
+				const query = {};
+
+				const loggedInClient = await testApiClient.login(admin.account);
+				const response = await loggedInClient.get().query(query);
+
+				expect(response.statusCode).toBe(200);
+				expect(response.body).toHaveProperty('data');
+				expect(response.body).toHaveProperty('skip');
+				expect(response.body).toHaveProperty('limit');
+				expect(response.body).toHaveProperty('total');
+			});
+
+			it('should return archived courses in pages', async () => {
+				const { admin } = await setup();
+				const query = { skip: 0, limit: 10, sortBy: CourseSortQueryType.NAME, type: CourseStatusQueryType.ARCHIVE };
+
+				const loggedInClient = await testApiClient.login(admin.account);
+				const response = await loggedInClient.get().query(query);
+
+				const { total, skip, limit, data } = response.body as CourseInfoListResponse;
+				expect(response.statusCode).toBe(200);
+				expect(skip).toBe(0);
+				expect(limit).toBe(10);
+				expect(total).toBe(10);
+				expect(data.length).toBe(10);
+			});
+
+			it('should return current courses in pages', async () => {
+				const { admin, currentCourses } = await setup();
+				const query = { skip: 4, limit: 2, sortBy: CourseSortQueryType.NAME, type: CourseStatusQueryType.CURRENT };
+
+				const loggedInClient = await testApiClient.login(admin.account);
+				const response = await loggedInClient.get().query(query);
+
+				const { total, skip, limit, data } = response.body as CourseInfoListResponse;
+				expect(response.statusCode).toBe(200);
+				expect(skip).toBe(4);
+				expect(limit).toBe(2);
+				expect(total).toBe(5);
+				expect(data.length).toBe(1);
+				expect(data[0].id).toBe(currentCourses[4].id);
+			});
+		});
+
+		describe('when logged in not authenticated/authorized', () => {
+			const setup = async () => {
+				const teacher = createTeacher();
+
+				await em.persistAndFlush([teacher.account, teacher.user]);
+				em.clear();
+
+				return {
+					teacher,
+				};
+			};
+
+			it('should return unauthorized', async () => {
+				const query = { skip: 4, limit: 2, sortBy: CourseSortQueryType.NAME, type: CourseStatusQueryType.CURRENT };
+
+				const response = await testApiClient.get().query(query);
+
+				expect(response.status).toEqual(HttpStatus.UNAUTHORIZED);
+				expect(response.body).toEqual({
+					code: HttpStatus.UNAUTHORIZED,
+					message: 'Unauthorized',
+					title: 'Unauthorized',
+					type: 'UNAUTHORIZED',
+				});
+			});
+
+			it('should return forbidden', async () => {
+				const { teacher } = await setup();
+				const query = { skip: 4, limit: 2, sortBy: CourseSortQueryType.NAME, type: CourseStatusQueryType.CURRENT };
+
+				const loggedInClient = await testApiClient.login(teacher.account);
+				const response = await loggedInClient.get().query(query);
+
+				expect(response.status).toEqual(HttpStatus.FORBIDDEN);
+				expect(response.body).toEqual({
+					code: HttpStatus.FORBIDDEN,
+					message: 'Forbidden',
+					title: 'Forbidden',
+					type: 'FORBIDDEN',
+				});
+			});
+		});
+	});
+});