N21-1285 User launches a CTL tool from a board card

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-context-id.strategy.spec.ts

@@ -0,0 +1,56 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { contextExternalToolFactory, schoolExternalToolFactory } from '@shared/testing';
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+import { AutoContextIdStrategy } from './auto-context-id.strategy';
+
+describe(AutoContextIdStrategy.name, () => {
+	let module: TestingModule;
+	let strategy: AutoContextIdStrategy;
+
+	beforeAll(async () => {
+		module = await Test.createTestingModule({
+			providers: [AutoContextIdStrategy],
+		}).compile();
+
+		strategy = module.get(AutoContextIdStrategy);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('getValue', () => {
+		const setup = () => {
+			const contextId = 'contextId';
+
+			const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.buildWithId();
+			const contextExternalTool: ContextExternalTool = contextExternalToolFactory.buildWithId({
+				schoolToolRef: {
+					schoolToolId: schoolExternalTool.id as string,
+				},
+				contextRef: {
+					id: contextId,
+				},
+			});
+
+			return {
+				contextId,
+				schoolExternalTool,
+				contextExternalTool,
+			};
+		};
+
+		it('should return the context id', () => {
+			const { contextId, schoolExternalTool, contextExternalTool } = setup();
+
+			const result: string | undefined = strategy.getValue(schoolExternalTool, contextExternalTool);
+
+			expect(result).toEqual(contextId);
+		});
+	});
+});

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-context-id.strategy.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@nestjs/common';
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+import { AutoParameterStrategy } from './auto-parameter.strategy';
+
+@Injectable()
+export class AutoContextIdStrategy implements AutoParameterStrategy {
+	getValue(schoolExternalTool: SchoolExternalTool, contextExternalTool: ContextExternalTool): string | undefined {
+		return contextExternalTool.contextRef.id;
+	}
+}

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-context-name.strategy.spec.ts

@@ -0,0 +1,194 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { ObjectId } from '@mikro-orm/mongodb';
+import { ColumnBoardService } from '@modules/board';
+import { CourseService } from '@modules/learnroom';
+import { Test, TestingModule } from '@nestjs/testing';
+import { BoardExternalReferenceType, ColumnBoard, Course } from '@shared/domain';
+import {
+	columnBoardFactory,
+	contextExternalToolFactory,
+	courseFactory,
+	schoolExternalToolFactory,
+	setupEntities,
+} from '@shared/testing';
+import { ToolContextType } from '../../../common/enum';
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+import { ParameterTypeNotImplementedLoggableException } from '../../error';
+import { AutoContextNameStrategy } from './auto-context-name.strategy';
+
+describe(AutoContextNameStrategy.name, () => {
+	let module: TestingModule;
+	let strategy: AutoContextNameStrategy;
+
+	let courseService: DeepMocked<CourseService>;
+	let columnBoardService: DeepMocked<ColumnBoardService>;
+
+	beforeAll(async () => {
+		await setupEntities();
+
+		module = await Test.createTestingModule({
+			providers: [
+				AutoContextNameStrategy,
+				{
+					provide: CourseService,
+					useValue: createMock<CourseService>(),
+				},
+				{
+					provide: ColumnBoardService,
+					useValue: createMock<ColumnBoardService>(),
+				},
+			],
+		}).compile();
+
+		strategy = module.get(AutoContextNameStrategy);
+		courseService = module.get(CourseService);
+		columnBoardService = module.get(ColumnBoardService);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('getValue', () => {
+		describe('when the tool context is "course"', () => {
+			const setup = () => {
+				const courseId = new ObjectId().toHexString();
+				const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.build();
+				const contextExternalTool: ContextExternalTool = contextExternalToolFactory.build({
+					contextRef: {
+						id: courseId,
+						type: ToolContextType.COURSE,
+					},
+				});
+
+				const course: Course = courseFactory.buildWithId(
+					{
+						name: 'testName',
+					},
+					courseId
+				);
+
+				courseService.findById.mockResolvedValue(course);
+
+				return {
+					schoolExternalTool,
+					contextExternalTool,
+					course,
+				};
+			};
+
+			it('should return the course name', async () => {
+				const { schoolExternalTool, contextExternalTool, course } = setup();
+
+				const result: string | undefined = await strategy.getValue(schoolExternalTool, contextExternalTool);
+
+				expect(result).toEqual(course.name);
+			});
+		});
+
+		describe('when the tool context is "board element" and the board context is "course"', () => {
+			const setup = () => {
+				const boardElementId = new ObjectId().toHexString();
+				const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.build();
+				const contextExternalTool: ContextExternalTool = contextExternalToolFactory.build({
+					contextRef: {
+						id: boardElementId,
+						type: ToolContextType.BOARD_ELEMENT,
+					},
+				});
+
+				const course: Course = courseFactory.buildWithId({
+					name: 'testName',
+				});
+
+				const columnBoard: ColumnBoard = columnBoardFactory.build({
+					context: {
+						id: course.id,
+						type: BoardExternalReferenceType.Course,
+					},
+				});
+
+				courseService.findById.mockResolvedValue(course);
+				columnBoardService.findById.mockResolvedValue(columnBoard);
+
+				return {
+					schoolExternalTool,
+					contextExternalTool,
+					course,
+				};
+			};
+
+			it('should return the course name', async () => {
+				const { schoolExternalTool, contextExternalTool, course } = setup();
+
+				const result: string | undefined = await strategy.getValue(schoolExternalTool, contextExternalTool);
+
+				expect(result).toEqual(course.name);
+			});
+		});
+
+		describe('when the tool context is "board element" and the board context is unknown', () => {
+			const setup = () => {
+				const boardElementId = new ObjectId().toHexString();
+				const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.build();
+				const contextExternalTool: ContextExternalTool = contextExternalToolFactory.build({
+					contextRef: {
+						id: boardElementId,
+						type: ToolContextType.BOARD_ELEMENT,
+					},
+				});
+
+				const columnBoard: ColumnBoard = columnBoardFactory.build({
+					context: {
+						id: new ObjectId().toHexString(),
+						type: 'unknown' as unknown as BoardExternalReferenceType,
+					},
+				});
+
+				columnBoardService.findById.mockResolvedValue(columnBoard);
+
+				return {
+					schoolExternalTool,
+					contextExternalTool,
+				};
+			};
+
+			it('should return undefined', async () => {
+				const { schoolExternalTool, contextExternalTool } = setup();
+
+				const result: string | undefined = await strategy.getValue(schoolExternalTool, contextExternalTool);
+
+				expect(result).toBeUndefined();
+			});
+		});
+
+		describe('when a lookup for a context name is not implemented', () => {
+			const setup = () => {
+				const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.build();
+				const contextExternalTool: ContextExternalTool = contextExternalToolFactory.build({
+					contextRef: {
+						type: 'unknownContext' as unknown as ToolContextType,
+					},
+				});
+
+				return {
+					schoolExternalTool,
+					contextExternalTool,
+				};
+			};
+
+			it('should throw a ParameterNotImplementedLoggableException', async () => {
+				const { schoolExternalTool, contextExternalTool } = setup();
+
+				await expect(strategy.getValue(schoolExternalTool, contextExternalTool)).rejects.toThrow(
+					ParameterTypeNotImplementedLoggableException
+				);
+			});
+		});
+	});
+});

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-context-name.strategy.ts

@@ -0,0 +1,55 @@
+import { ColumnBoardService } from '@modules/board';
+import { CourseService } from '@modules/learnroom';
+import { Injectable } from '@nestjs/common';
+import { BoardExternalReferenceType, ColumnBoard, Course, EntityId } from '@shared/domain';
+import { CustomParameterType, ToolContextType } from '../../../common/enum';
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+import { ParameterTypeNotImplementedLoggableException } from '../../error';
+import { AutoParameterStrategy } from './auto-parameter.strategy';
+
+@Injectable()
+export class AutoContextNameStrategy implements AutoParameterStrategy {
+	constructor(private readonly courseService: CourseService, private readonly columnBoardService: ColumnBoardService) {}
+
+	async getValue(
+		schoolExternalTool: SchoolExternalTool,
+		contextExternalTool: ContextExternalTool
+	): Promise<string | undefined> {
+		switch (contextExternalTool.contextRef.type) {
+			case ToolContextType.COURSE: {
+				const courseValue: string = await this.getCourseValue(contextExternalTool.contextRef.id);
+
+				return courseValue;
+			}
+			case ToolContextType.BOARD_ELEMENT: {
+				const boardValue: string | undefined = await this.getBoardValue(contextExternalTool.contextRef.id);
+
+				return boardValue;
+			}
+			default: {
+				throw new ParameterTypeNotImplementedLoggableException(
+					`${CustomParameterType.AUTO_CONTEXTNAME}/${contextExternalTool.contextRef.type as string}`
+				);
+			}
+		}
+	}
+
+	private async getCourseValue(courseId: EntityId): Promise<string> {
+		const course: Course = await this.courseService.findById(courseId);
+
+		return course.name;
+	}
+
+	private async getBoardValue(boardId: EntityId): Promise<string | undefined> {
+		const board: ColumnBoard = await this.columnBoardService.findById(boardId);
+
+		if (board.context.type === BoardExternalReferenceType.Course) {
+			const courseName: string = await this.getCourseValue(board.context.id);
+
+			return courseName;
+		}
+
+		return undefined;
+	}
+}

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-parameter.strategy.ts

@@ -0,0 +1,9 @@
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+
+export interface AutoParameterStrategy {
+	getValue(
+		schoolExternalTool: SchoolExternalTool,
+		contextExternalTool: ContextExternalTool
+	): string | Promise<string | undefined> | undefined;
+}

apps/server/src/modules/tool/tool-launch/service/auto-parameter-strategy/auto-school-id.strategy.spec.ts

@@ -0,0 +1,56 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { contextExternalToolFactory, schoolExternalToolFactory } from '@shared/testing';
+import { ContextExternalTool } from '../../../context-external-tool/domain';
+import { SchoolExternalTool } from '../../../school-external-tool/domain';
+import { AutoSchoolIdStrategy } from './auto-school-id.strategy';
+
+describe(AutoSchoolIdStrategy.name, () => {
+	let module: TestingModule;
+	let strategy: AutoSchoolIdStrategy;
+
+	beforeAll(async () => {
+		module = await Test.createTestingModule({
+			providers: [AutoSchoolIdStrategy],
+		}).compile();
+
+		strategy = module.get(AutoSchoolIdStrategy);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('getValue', () => {
+		const setup = () => {
+			const schoolId = 'schoolId';
+
+			const schoolExternalTool: SchoolExternalTool = schoolExternalToolFactory.buildWithId({
+				schoolId,
+			});
+			const contextExternalTool: ContextExternalTool = contextExternalToolFactory.buildWithId({
+				schoolToolRef: {
+					schoolToolId: schoolExternalTool.id as string,
+					schoolId,
+				},
+			});
+
+			return {
+				schoolId,
+				schoolExternalTool,
+				contextExternalTool,
+			};
+		};
+
+		it('should return the context id', () => {
+			const { schoolId, schoolExternalTool, contextExternalTool } = setup();
+
+			const result: string | undefined = strategy.getValue(schoolExternalTool, contextExternalTool);
+
+			expect(result).toEqual(schoolId);
+		});
+	});
+});