N21-1941 Bulk import for external tools

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

@@ -29,7 +29,10 @@ import { SchoolExternalToolEntity } from '../../../school-external-tool/entity';
 import { ExternalToolEntity } from '../../entity';
 import { externalToolEntityFactory, externalToolFactory } from '../../testing';
 import {
+	ExternalToolBulkCreateParams,
 	ExternalToolCreateParams,
+	ExternalToolImportResultListResponse,
+	ExternalToolImportResultResponse,
 	ExternalToolMetadataResponse,
 	ExternalToolResponse,
 	ExternalToolSearchListResponse,
@@ -221,6 +224,108 @@ describe('ToolController (API)', () => {
 		});
 	});
 
+	describe('[POST] tools/external-tools', () => {
+		const logoUrl = 'https://link.to-my-logo.com';
+		const postParams: ExternalToolCreateParams = {
+			name: 'Tool 1',
+			parameters: [
+				{
+					name: 'key',
+					description: 'This is a parameter.',
+					displayName: 'User Friendly Name',
+					defaultValue: 'abc',
+					isOptional: false,
+					isProtected: false,
+					type: CustomParameterTypeParams.STRING,
+					regex: 'abc',
+					regexComment: 'Regex accepts "abc" as value.',
+					location: CustomParameterLocationParams.PATH,
+					scope: CustomParameterScopeTypeParams.GLOBAL,
+				},
+			],
+			config: {
+				type: ToolConfigType.BASIC,
+				baseUrl: 'https://link.to-my-tool.com/:key',
+			},
+			isHidden: false,
+			isDeactivated: false,
+			logoUrl,
+			url: 'https://link.to-my-tool.com',
+			openNewTab: true,
+			medium: {
+				mediumId: 'medium:1',
+				mediaSourceId: 'source:1',
+			},
+		};
+
+		describe('when valid data is given', () => {
+			const setup = async () => {
+				const params: ExternalToolBulkCreateParams = { data: [{ ...postParams }] };
+
+				const { adminUser, adminAccount } = UserAndAccountTestFactory.buildAdmin({}, [Permission.TOOL_ADMIN]);
+				await em.persistAndFlush([adminAccount, adminUser]);
+				em.clear();
+
+				const base64Logo: string = externalToolFactory.withBase64Logo().build().logo as string;
+				const logoBuffer: Buffer = Buffer.from(base64Logo, 'base64');
+				axiosMock.onGet(logoUrl).reply(HttpStatus.OK, logoBuffer);
+
+				const loggedInClient: TestApiClient = await testApiClient.login(adminAccount);
+
+				return {
+					loggedInClient,
+					params,
+				};
+			};
+
+			it('should create a tool', async () => {
+				const { loggedInClient, params } = await setup();
+
+				const response: Response = await loggedInClient.post('/import', params);
+				const body: ExternalToolImportResultListResponse = response.body as ExternalToolImportResultListResponse;
+
+				expect(body.results[0]?.toolId).toBeDefined();
+				const loaded: Loaded<ExternalToolEntity> = await em.findOneOrFail(ExternalToolEntity, {
+					id: body.results[0].toolId,
+				});
+				expect(loaded).toBeDefined();
+			});
+
+			it('should return the created tool', async () => {
+				const { loggedInClient, params } = await setup();
+
+				const response: Response = await loggedInClient.post('/import', params);
+				const body: ExternalToolImportResultListResponse = response.body as ExternalToolImportResultListResponse;
+
+				expect(response.statusCode).toEqual(HttpStatus.CREATED);
+				expect(body.results[0]).toBeDefined();
+				expect(body.results[0]).toEqual<ExternalToolImportResultResponse>({
+					toolId: expect.any(String),
+					mediumId: postParams.medium?.mediumId,
+					mediumSourceId: postParams.medium?.mediaSourceId,
+					toolName: postParams.name,
+					error: undefined,
+				});
+			});
+		});
+
+		describe('when user is not authenticated', () => {
+			const setup = () => {
+				const params: ExternalToolBulkCreateParams = { data: [{ ...postParams }] };
+
+				return { params };
+			};
+
+			it('should return unauthorized', async () => {
+				const { params } = setup();
+
+				const response: Response = await testApiClient.post('/import', params);
+
+				expect(response.statusCode).toEqual(HttpStatus.UNAUTHORIZED);
+			});
+		});
+	});
+
 	describe('[GET] tools/external-tools', () => {
 		describe('when requesting tools', () => {
 			const setup = async () => {

apps/server/src/modules/tool/external-tool/controller/dto/request/external-tool-bulk-create.params.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { ValidateNested } from 'class-validator';
+import { ExternalToolCreateParams } from './external-tool-create.params';
+
+export class ExternalToolBulkCreateParams {
+	@ValidateNested()
+	@Type(() => ExternalToolCreateParams)
+	@ApiProperty({ type: [ExternalToolCreateParams], description: 'List of external tools' })
+	data!: ExternalToolCreateParams[];
+}

apps/server/src/modules/tool/external-tool/controller/dto/request/index.ts

@@ -10,3 +10,4 @@ export * from './context-ref.params';
 export * from './school-external-tool-id.params';
 export * from './context-external-tool-id.params';
 export { ExternalToolMediumParams } from './external-tool-medium.params';
+export { ExternalToolBulkCreateParams } from './external-tool-bulk-create.params';

apps/server/src/modules/tool/external-tool/controller/dto/response/external-tool-import-result-response.ts

@@ -0,0 +1,38 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ExternalToolImportResultResponse {
+	@ApiProperty({ description: 'Name of the external tool' })
+	toolName: string;
+
+	@ApiProperty({ description: 'Medium id of the external tool' })
+	mediumId?: string;
+
+	@ApiProperty({ description: 'Medium source of the external tool' })
+	mediumSourceId?: string;
+
+	@ApiProperty({ description: 'ObjectId of the created external tool' })
+	toolId?: string;
+
+	@ApiProperty({ description: 'Status message of the error that occurred' })
+	error?: string;
+
+	constructor(props: ExternalToolImportResultResponse) {
+		this.toolName = props.toolName;
+		this.mediumId = props.mediumId;
+		this.mediumSourceId = props.mediumSourceId;
+		this.toolId = props.toolId;
+		this.error = props.error;
+	}
+}
+
+export class ExternalToolImportResultListResponse {
+	@ApiProperty({
+		type: [ExternalToolImportResultResponse],
+		description: 'List of operation results for the provided external tools',
+	})
+	results: ExternalToolImportResultResponse[];
+
+	constructor(props: ExternalToolImportResultListResponse) {
+		this.results = props.results;
+	}
+}

apps/server/src/modules/tool/external-tool/controller/dto/response/index.ts

@@ -9,3 +9,7 @@ export * from './school-external-tool-configuration-template-list.response';
 export * from './external-tool-metadata.response';
 export * from './tool-context-types-list.response';
 export { ExternalToolMediumResponse } from './external-tool-medium.response';
+export {
+	ExternalToolImportResultListResponse,
+	ExternalToolImportResultResponse,
+} from './external-tool-import-result-response';

apps/server/src/modules/tool/external-tool/controller/tool.controller.ts

@@ -13,6 +13,7 @@ import {
 	StreamableFile,
 } from '@nestjs/common';
 import {
+	ApiBadRequestResponse,
 	ApiCreatedResponse,
 	ApiForbiddenResponse,
 	ApiFoundResponse,
@@ -36,10 +37,12 @@ import { ExternalToolLogo } from '../domain/external-tool-logo';
 
 import { ExternalToolMetadataMapper, ExternalToolRequestMapper, ExternalToolResponseMapper } from '../mapper';
 import { ExternalToolLogoService } from '../service';
-import { ExternalToolCreate, ExternalToolUc, ExternalToolUpdate } from '../uc';
+import { ExternalToolCreate, ExternalToolImportResult, ExternalToolUc, ExternalToolUpdate } from '../uc';
 import {
+	ExternalToolBulkCreateParams,
 	ExternalToolCreateParams,
 	ExternalToolIdParams,
+	ExternalToolImportResultListResponse,
 	ExternalToolMetadataResponse,
 	ExternalToolResponse,
 	ExternalToolSearchListResponse,
@@ -81,6 +84,28 @@ export class ToolController {
 		return mapped;
 	}
 
+	@Post('/import')
+	@ApiCreatedResponse({ description: 'The Tool has been successfully created.', type: ExternalToolResponse })
+	@ApiForbiddenResponse({ description: 'User is not allowed to access this resource.' })
+	@ApiUnauthorizedResponse({ description: 'User is not logged in.' })
+	@ApiBadRequestResponse({ description: 'Request data has invalid format.' })
+	@ApiOperation({ summary: 'Creates multiple ExternalTools at the same time.' })
+	async importExternalTools(
+		@CurrentUser() currentUser: ICurrentUser,
+		@Body() externalToolBulkParams: ExternalToolBulkCreateParams
+	): Promise<ExternalToolImportResultListResponse> {
+		const externalTools: ExternalToolCreate[] = this.externalToolDOMapper.mapBulkCreateRequest(externalToolBulkParams);
+
+		const results: ExternalToolImportResult[] = await this.externalToolUc.importExternalTools(
+			currentUser.userId,
+			externalTools
+		);
+
+		const response: ExternalToolImportResultListResponse = ExternalToolResponseMapper.mapToImportResponse(results);
+
+		return response;
+	}
+
 	@Get()
 	@ApiFoundResponse({ description: 'Tools has been found.', type: ExternalToolSearchListResponse })
 	@ApiUnauthorizedResponse()

apps/server/src/modules/tool/external-tool/mapper/external-tool-request.mapper.ts

@@ -22,6 +22,7 @@ import {
 	Oauth2ToolConfigUpdateParams,
 	SortExternalToolParams,
 } from '../controller/dto';
+import { ExternalToolBulkCreateParams } from '../controller/dto/request/external-tool-bulk-create.params';
 import { ExternalTool } from '../domain';
 import {
 	BasicToolConfigDto,
@@ -119,6 +120,14 @@ export class ExternalToolRequestMapper {
 		};
 	}
 
+	public mapBulkCreateRequest(externalToolCreateParams: ExternalToolBulkCreateParams): ExternalToolCreate[] {
+		const toolList: ExternalToolCreate[] = externalToolCreateParams.data.map(
+			(createParams: ExternalToolCreateParams): ExternalToolCreate => this.mapCreateRequest(createParams)
+		);
+
+		return toolList;
+	}
+
 	private mapRequestToExternalToolMedium(
 		externalToolMediumParams: ExternalToolMediumParams | undefined
 	): ExternalToolMediumDto | undefined {

apps/server/src/modules/tool/external-tool/mapper/external-tool-response.mapper.ts

@@ -11,12 +11,15 @@ import {
 import {
 	BasicToolConfigResponse,
 	CustomParameterResponse,
+	ExternalToolImportResultListResponse,
+	ExternalToolImportResultResponse,
 	ExternalToolMediumResponse,
 	ExternalToolResponse,
 	Lti11ToolConfigResponse,
 	Oauth2ToolConfigResponse,
 } from '../controller/dto';
 import { BasicToolConfig, ExternalTool, ExternalToolMedium, Lti11ToolConfig, Oauth2ToolConfig } from '../domain';
+import { ExternalToolImportResult } from '../uc';
 
 const scopeMapping: Record<CustomParameterScope, CustomParameterScopeTypeParams> = {
 	[CustomParameterScope.GLOBAL]: CustomParameterScopeTypeParams.GLOBAL,
@@ -110,4 +113,15 @@ export class ExternalToolResponseMapper {
 			};
 		});
 	}
+
+	static mapToImportResponse(results: ExternalToolImportResult[]): ExternalToolImportResultListResponse {
+		const response: ExternalToolImportResultListResponse = new ExternalToolImportResultListResponse({
+			results: results.map(
+				(result: ExternalToolImportResult): ExternalToolImportResultResponse =>
+					new ExternalToolImportResultResponse(result)
+			),
+		});
+
+		return response;
+	}
 }

apps/server/src/modules/tool/external-tool/uc/dto/external-tool-import-result.ts

@@ -0,0 +1,19 @@
+export class ExternalToolImportResult {
+	toolName: string;
+
+	mediumId?: string;
+
+	mediumSourceId?: string;
+
+	toolId?: string;
+
+	error?: string;
+
+	constructor(props: ExternalToolImportResult) {
+		this.toolName = props.toolName;
+		this.mediumId = props.mediumId;
+		this.mediumSourceId = props.mediumSourceId;
+		this.toolId = props.toolId;
+		this.error = props.error;
+	}
+}

apps/server/src/modules/tool/external-tool/uc/dto/index.ts

@@ -1,2 +1,3 @@
 export * from './external-tool.types';
 export * from './external-tool-configuration.types';
+export { ExternalToolImportResult } from './external-tool-import-result';