N21-1298 tool context restrictions

apps/server/src/modules/oauth-provider/error/id-token-creation-exception.loggable.spec.ts

@@ -1,23 +1,6 @@
 import { IdTokenCreationLoggableException } from './id-token-creation-exception.loggable';
 
 describe('IdTokenCreationExceptionLoggable', () => {
-	describe('constructor', () => {
-		const setup = () => {
-			const clientId = 'clientId';
-			const userId = 'userId';
-
-			return { clientId, userId };
-		};
-
-		it('should create an instance of IdTokenCreationExceptionLoggable', () => {
-			const { clientId, userId } = setup();
-
-			const loggable = new IdTokenCreationLoggableException(clientId, userId);
-
-			expect(loggable).toBeInstanceOf(IdTokenCreationLoggableException);
-		});
-	});
-
 	describe('getLogMessage', () => {
 		const setup = () => {
 			const clientId = 'clientId';

apps/server/src/modules/provisioning/loggable/group-role-unknown.loggable.spec.ts

@@ -2,25 +2,6 @@ import { SanisGroupRole, SanisSonstigeGruppenzugehoerigeResponse } from '../stra
 import { GroupRoleUnknownLoggable } from './group-role-unknown.loggable';
 
 describe('GroupRoleUnknownLoggable', () => {
-	describe('constructor', () => {
-		const setup = () => {
-			const sanisSonstigeGruppenzugehoerigeResponse: SanisSonstigeGruppenzugehoerigeResponse = {
-				ktid: 'ktid',
-				rollen: [SanisGroupRole.TEACHER],
-			};
-
-			return { sanisSonstigeGruppenzugehoerigeResponse };
-		};
-
-		it('should create an instance of UserForGroupNotFoundLoggable', () => {
-			const { sanisSonstigeGruppenzugehoerigeResponse } = setup();
-
-			const loggable = new GroupRoleUnknownLoggable(sanisSonstigeGruppenzugehoerigeResponse);
-
-			expect(loggable).toBeInstanceOf(GroupRoleUnknownLoggable);
-		});
-	});
-
 	describe('getLogMessage', () => {
 		const setup = () => {
 			const sanisSonstigeGruppenzugehoerigeResponse: SanisSonstigeGruppenzugehoerigeResponse = {

apps/server/src/modules/provisioning/loggable/school-for-group-not-found.loggable.spec.ts

@@ -3,22 +3,6 @@ import { ExternalGroupDto } from '../dto';
 import { SchoolForGroupNotFoundLoggable } from './school-for-group-not-found.loggable';
 
 describe('SchoolForGroupNotFoundLoggable', () => {
-	describe('constructor', () => {
-		const setup = () => {
-			const externalGroupDto: ExternalGroupDto = externalGroupDtoFactory.build();
-
-			return { externalGroupDto };
-		};
-
-		it('should create an instance of UserForGroupNotFoundLoggable', () => {
-			const { externalGroupDto } = setup();
-
-			const loggable = new SchoolForGroupNotFoundLoggable(externalGroupDto);
-
-			expect(loggable).toBeInstanceOf(SchoolForGroupNotFoundLoggable);
-		});
-	});
-
 	describe('getLogMessage', () => {
 		const setup = () => {
 			const externalGroupDto: ExternalGroupDto = externalGroupDtoFactory.build();

apps/server/src/modules/provisioning/loggable/user-for-group-not-found.loggable.spec.ts

@@ -3,25 +3,6 @@ import { ExternalGroupUserDto } from '../dto';
 import { UserForGroupNotFoundLoggable } from './user-for-group-not-found.loggable';
 
 describe('UserForGroupNotFoundLoggable', () => {
-	describe('constructor', () => {
-		const setup = () => {
-			const externalGroupUserDto: ExternalGroupUserDto = new ExternalGroupUserDto({
-				externalUserId: 'externalUserId',
-				roleName: RoleName.TEACHER,
-			});
-
-			return { externalGroupUserDto };
-		};
-
-		it('should create an instance of UserForGroupNotFoundLoggable', () => {
-			const { externalGroupUserDto } = setup();
-
-			const loggable = new UserForGroupNotFoundLoggable(externalGroupUserDto);
-
-			expect(loggable).toBeInstanceOf(UserForGroupNotFoundLoggable);
-		});
-	});
-
 	describe('getLogMessage', () => {
 		const setup = () => {
 			const externalGroupUserDto: ExternalGroupUserDto = new ExternalGroupUserDto({

apps/server/src/modules/pseudonym/loggable/too-many-pseudonyms.loggable-exception.spec.ts

@@ -1,22 +1,6 @@
 import { TooManyPseudonymsLoggableException } from './too-many-pseudonyms.loggable-exception';
 
 describe('TooManyPseudonymsLoggableException', () => {
-	describe('constructor', () => {
-		const setup = () => {
-			const pseudonym = 'pseudonym';
-
-			return { pseudonym };
-		};
-
-		it('should create an instance of TooManyPseudonymsLoggableException', () => {
-			const { pseudonym } = setup();
-
-			const loggable = new TooManyPseudonymsLoggableException(pseudonym);
-
-			expect(loggable).toBeInstanceOf(TooManyPseudonymsLoggableException);
-		});
-	});
-
 	describe('getLogMessage', () => {
 		const setup = () => {
 			const pseudonym = 'pseudonym';

apps/server/src/modules/tool/common/service/common-tool.service.spec.ts

@@ -3,7 +3,7 @@ import { contextExternalToolFactory, externalToolFactory, schoolExternalToolFact
 import { CommonToolService } from './common-tool.service';
 import { ExternalTool } from '../../external-tool/domain';
 import { SchoolExternalTool } from '../../school-external-tool/domain';
-import { ToolConfigurationStatus } from '../enum';
+import { ToolConfigurationStatus, ToolContextType } from '../enum';
 import { ContextExternalTool } from '../../context-external-tool/domain';
 
 describe('CommonToolService', () => {
@@ -205,4 +205,78 @@ describe('CommonToolService', () => {
 			});
 		});
 	});
+
+	describe('isContextRestricted', () => {
+		describe('when tool is not restricted to context', () => {
+			const setup = () => {
+				const externalTool: ExternalTool = externalToolFactory.build({ restrictToContexts: [] });
+				const context: ToolContextType = ToolContextType.COURSE;
+
+				return { externalTool, context };
+			};
+
+			it('should return false', () => {
+				const { externalTool, context } = setup();
+
+				const result = service.isContextRestricted(externalTool, context);
+
+				expect(result).toBe(false);
+			});
+		});
+
+		describe('when tool is restricted to all contexts', () => {
+			const setup = () => {
+				const externalTool: ExternalTool = externalToolFactory.build({
+					restrictToContexts: [ToolContextType.COURSE, ToolContextType.BOARD_ELEMENT],
+				});
+				const context: ToolContextType = ToolContextType.COURSE;
+
+				return { externalTool, context };
+			};
+
+			it('should return false', () => {
+				const { externalTool, context } = setup();
+
+				const result = service.isContextRestricted(externalTool, context);
+
+				expect(result).toBe(false);
+			});
+		});
+
+		describe('when tool is restricted to correct context', () => {
+			const setup = () => {
+				const externalTool: ExternalTool = externalToolFactory.build({ restrictToContexts: [ToolContextType.COURSE] });
+				const context: ToolContextType = ToolContextType.COURSE;
+
+				return { externalTool, context };
+			};
+
+			it('should return false', () => {
+				const { externalTool, context } = setup();
+
+				const result = service.isContextRestricted(externalTool, context);
+
+				expect(result).toBe(false);
+			});
+		});
+
+		describe('when tool is restricted to wrong context', () => {
+			const setup = () => {
+				const externalTool: ExternalTool = externalToolFactory.build({
+					restrictToContexts: [ToolContextType.BOARD_ELEMENT],
+				});
+				const context: ToolContextType = ToolContextType.COURSE;
+
+				return { externalTool, context };
+			};
+
+			it('should return true', () => {
+				const { externalTool, context } = setup();
+
+				const result = service.isContextRestricted(externalTool, context);
+
+				expect(result).toBe(true);
+			});
+		});
+	});
 });

apps/server/src/modules/tool/common/service/common-tool.service.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { ExternalTool } from '../../external-tool/domain';
 import { SchoolExternalTool } from '../../school-external-tool/domain';
 import { ContextExternalTool } from '../../context-external-tool/domain';
-import { ToolConfigurationStatus } from '../enum';
+import { ToolConfigurationStatus, ToolContextType } from '../enum';
 import { ToolVersion } from '../interface';
 
 // TODO N21-1337 remove class when tool versioning is removed
@@ -11,7 +11,7 @@ export class CommonToolService {
 	/**
 	 * @deprecated use ToolVersionService
 	 */
-	determineToolConfigurationStatus(
+	public determineToolConfigurationStatus(
 		externalTool: ExternalTool,
 		schoolExternalTool: SchoolExternalTool,
 		contextExternalTool: ContextExternalTool
@@ -30,4 +30,11 @@ export class CommonToolService {
 	private isLatest(tool1: ToolVersion, tool2: ToolVersion): boolean {
 		return tool1.getVersion() >= tool2.getVersion();
 	}
+
+	public isContextRestricted(externalTool: ExternalTool, context: ToolContextType): boolean {
+		if (externalTool.restrictToContexts?.length && !externalTool.restrictToContexts.includes(context)) {
+			return true;
+		}
+		return false;
+	}
 }

apps/server/src/modules/tool/context-external-tool/controller/api-test/tool-context.api.spec.ts

@@ -81,6 +81,7 @@ describe('ToolContextController (API)', () => {
 							isOptional: true,
 						}),
 					],
+					restrictToContexts: [ToolContextType.COURSE],
 					version: 1,
 				});
 				const schoolExternalToolEntity: SchoolExternalToolEntity = schoolExternalToolEntityFactory.buildWithId({
@@ -174,6 +175,115 @@ describe('ToolContextController (API)', () => {
 				// expected body is missed
 			});
 		});
+
+		describe('when external tool has no restrictions ', () => {
+			const setup = async () => {
+				const school: SchoolEntity = schoolFactory.buildWithId();
+				const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({ school }, [
+					Permission.CONTEXT_TOOL_ADMIN,
+				]);
+
+				const course: Course = courseFactory.buildWithId({ teachers: [teacherUser], school });
+
+				const externalToolEntity: ExternalToolEntity = externalToolEntityFactory.buildWithId({
+					parameters: [],
+					restrictToContexts: [],
+					version: 1,
+				});
+				const schoolExternalToolEntity: SchoolExternalToolEntity = schoolExternalToolEntityFactory.buildWithId({
+					tool: externalToolEntity,
+					school,
+					schoolParameters: [],
+					toolVersion: 1,
+				});
+
+				const postParams: ContextExternalToolPostParams = {
+					schoolToolId: schoolExternalToolEntity.id,
+					contextId: course.id,
+					displayName: course.name,
+					contextType: ToolContextType.COURSE,
+					parameters: [],
+					toolVersion: 1,
+				};
+
+				await em.persistAndFlush([teacherUser, teacherAccount, course, school, schoolExternalToolEntity]);
+				em.clear();
+
+				const loggedInClient: TestApiClient = await testApiClient.login(teacherAccount);
+
+				return {
+					loggedInClient,
+					postParams,
+				};
+			};
+
+			it('should create tool', async () => {
+				const { postParams, loggedInClient } = await setup();
+
+				const response = await loggedInClient.post().send(postParams);
+
+				expect(response.statusCode).toEqual(HttpStatus.CREATED);
+				expect(response.body).toEqual<ContextExternalToolResponse>({
+					id: expect.any(String),
+					schoolToolId: postParams.schoolToolId,
+					contextId: postParams.contextId,
+					displayName: postParams.displayName,
+					contextType: postParams.contextType,
+					parameters: [],
+					toolVersion: postParams.toolVersion,
+				});
+			});
+		});
+
+		describe('when external tool restricts to wrong context ', () => {
+			const setup = async () => {
+				const school: SchoolEntity = schoolFactory.buildWithId();
+				const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({ school }, [
+					Permission.CONTEXT_TOOL_ADMIN,
+				]);
+
+				const course: Course = courseFactory.buildWithId({ teachers: [teacherUser], school });
+
+				const externalToolEntity: ExternalToolEntity = externalToolEntityFactory.buildWithId({
+					parameters: [],
+					restrictToContexts: [ToolContextType.BOARD_ELEMENT],
+					version: 1,
+				});
+				const schoolExternalToolEntity: SchoolExternalToolEntity = schoolExternalToolEntityFactory.buildWithId({
+					tool: externalToolEntity,
+					school,
+					schoolParameters: [],
+					toolVersion: 1,
+				});
+
+				const postParams: ContextExternalToolPostParams = {
+					schoolToolId: schoolExternalToolEntity.id,
+					contextId: course.id,
+					displayName: course.name,
+					contextType: ToolContextType.COURSE,
+					parameters: [],
+					toolVersion: 1,
+				};
+
+				await em.persistAndFlush([teacherUser, teacherAccount, course, school, schoolExternalToolEntity]);
+				em.clear();
+
+				const loggedInClient: TestApiClient = await testApiClient.login(teacherAccount);
+
+				return {
+					loggedInClient,
+					postParams,
+				};
+			};
+
+			it('should return unprocessable entity', async () => {
+				const { postParams, loggedInClient } = await setup();
+
+				const response = await loggedInClient.post().send(postParams);
+
+				expect(response.statusCode).toEqual(HttpStatus.UNPROCESSABLE_ENTITY);
+			});
+		});
 	});
 
 	describe('[DELETE] tools/context-external-tools/:contextExternalToolId', () => {