BC-5522-Implementation of an API for deleting data

apps/server/src/apps/helpers/admin-api-setup-helper.ts

@@ -0,0 +1,28 @@
+import express from 'express';
+import { Configuration } from '@hpi-schul-cloud/commons/lib';
+import { Logger } from '@src/core/logger';
+import { AdminApiServerModule } from '@src/modules/server/admin-api.server.module';
+import { ExpressAdapter } from '@nestjs/platform-express';
+import { NestFactory } from '@nestjs/core';
+import { AppStartLoggable } from './app-start-loggable';
+
+export const createAndStartAdminApiServer = async (logger: Logger) => {
+	const nestAdminServerExpress = express();
+	const nestAdminServerExpressAdapter = new ExpressAdapter(nestAdminServerExpress);
+	const nestAdminServerApp = await NestFactory.create(AdminApiServerModule, nestAdminServerExpressAdapter);
+
+	nestAdminServerApp.setGlobalPrefix('/admin/api/v1');
+	await nestAdminServerApp.init();
+
+	const adminApiServerPort = Configuration.get('ADMIN_API__PORT') as number;
+
+	nestAdminServerExpress.listen(adminApiServerPort, () => {
+		logger.info(
+			new AppStartLoggable({
+				appName: 'Admin Api server app',
+				port: adminApiServerPort,
+				mountsDescription: `/admin/api/v1 --> Admin Api Server`,
+			})
+		);
+	});
+};

apps/server/src/apps/server.app.ts

@@ -21,13 +21,15 @@ import { join } from 'path';
 // register source-map-support for debugging
 import { install as sourceMapInstall } from 'source-map-support';
 import { FeathersRosterService } from '@modules/pseudonym';
+import { Configuration } from '@hpi-schul-cloud/commons/lib';
 import legacyAppPromise = require('../../../../src/app');
 
 import { AppStartLoggable } from './helpers/app-start-loggable';
 import {
 	addPrometheusMetricsMiddlewaresIfEnabled,
 	createAndStartPrometheusMetricsAppIfEnabled,
 } from './helpers/prometheus-metrics';
+import { createAndStartAdminApiServer } from './helpers/admin-api-setup-helper';
 
 async function bootstrap() {
 	sourceMapInstall();
@@ -127,6 +129,10 @@ async function bootstrap() {
 		createAndStartPrometheusMetricsAppIfEnabled(logger);
 	});
 
+	if (Configuration.get('ADMIN_API__ENABLED') === true) {
+		await createAndStartAdminApiServer(logger);
+	}
+
 	console.log('#################################');
 	console.log(`### Start Server              ###`);
 	console.log(`### Port: ${port}                ###`);

apps/server/src/modules/authentication/authentication.module.ts

@@ -18,6 +18,7 @@ import { JwtStrategy } from './strategy/jwt.strategy';
 import { LdapStrategy } from './strategy/ldap.strategy';
 import { LocalStrategy } from './strategy/local.strategy';
 import { Oauth2Strategy } from './strategy/oauth2.strategy';
+import { XApiKeyStrategy } from './strategy/x-api-key.strategy';
 
 // values copied from Algorithm definition. Type does not exist at runtime and can't be checked anymore otherwise
 const algorithms = [
@@ -76,6 +77,7 @@ const jwtModuleOptions: JwtModuleOptions = {
 		LdapService,
 		LdapStrategy,
 		Oauth2Strategy,
+		XApiKeyStrategy,
 	],
 	exports: [AuthenticationService],
 })

apps/server/src/modules/authentication/config/x-api-key.config.ts

@@ -0,0 +1,3 @@
+export interface IXApiKeyConfig {
+	ADMIN_API__ALLOWED_API_KEYS: string[];
+}

apps/server/src/modules/authentication/strategy/x-api-key.strategy.ts

@@ -0,0 +1,27 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ConfigService } from '@nestjs/config';
+import Strategy from 'passport-headerapikey';
+import { IXApiKeyConfig } from '../config/x-api-key.config';
+
+@Injectable()
+export class XApiKeyStrategy extends PassportStrategy(Strategy, 'api-key') {
+	private readonly allowedApiKeys: string[];
+
+	constructor(private readonly configService: ConfigService<IXApiKeyConfig, true>) {
+		super(
+			{ header: 'X-API-KEY', prefix: '' },
+			true,
+			// eslint-disable-next-line @typescript-eslint/require-await
+			async (apiKey: string, done: (error: Error | null, data: boolean | null) => void) => this.validate(apiKey, done)
+		);
+		this.allowedApiKeys = this.configService.get<string[]>('ADMIN_API__ALLOWED_API_KEYS');
+	}
+
+	public validate = (apiKey: string, done: (error: Error | null, data: boolean | null) => void) => {
+		if (this.allowedApiKeys.includes(apiKey)) {
+			done(null, true);
+		}
+		done(new UnauthorizedException(), null);
+	};
+}

apps/server/src/modules/deletion/controller/deletion-executions.controller.ts

@@ -0,0 +1,26 @@
+import { Controller, Post, Query, UseGuards } from '@nestjs/common';
+import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { ForbiddenOperationError, ValidationError } from '@shared/common';
+import { AuthGuard } from '@nestjs/passport';
+import { DeletionRequestUc } from '../uc/deletion-request.uc';
+import { DeletionExecutionParams } from './dto';
+
+@ApiTags('DeletionExecutions')
+@UseGuards(AuthGuard('api-key'))
+@Controller('deletionExecutions')
+export class DeletionExecutionsController {
+	constructor(private readonly deletionRequestUc: DeletionRequestUc) {}
+
+	@Post()
+	@ApiOperation({
+		summary: '"Queueing" a deletion request',
+	})
+	@ApiResponse({
+		status: 204,
+	})
+	@ApiResponse({ status: 400, type: ValidationError, description: 'Request data has invalid format.' })
+	@ApiResponse({ status: 403, type: ForbiddenOperationError, description: 'User is not a superhero or administrator.' })
+	async executeDeletions(@Query() deletionExecutionQuery: DeletionExecutionParams) {
+		return this.deletionRequestUc.executeDeletionRequests(deletionExecutionQuery.limit);
+	}
+}

apps/server/src/modules/deletion/controller/deletion-requests.controller.ts

@@ -0,0 +1,60 @@
+import { Body, Controller, Delete, Get, Param, Post, UseGuards } from '@nestjs/common';
+import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { ForbiddenOperationError, ValidationError } from '@shared/common';
+import { AuthGuard } from '@nestjs/passport';
+import { DeletionRequestUc } from '../uc/deletion-request.uc';
+import { DeletionRequestResponse } from './dto/deletion-request.response';
+import { DeletionRequestBodyProps } from './dto/deletion-request.body.params';
+import { DeletionRequestLogResponse } from './dto';
+
+@ApiTags('DeletionRequests')
+@UseGuards(AuthGuard('api-key'))
+@Controller('deletionRequests')
+export class DeletionRequestsController {
+	constructor(private readonly deletionRequestUc: DeletionRequestUc) {}
+
+	@Post()
+	@ApiOperation({
+		summary: '"Queueing" a deletion request',
+	})
+	@ApiResponse({
+		status: 202,
+		type: DeletionRequestResponse,
+		description: 'Returns identifier of the deletion request and when deletion is planned at',
+	})
+	@ApiResponse({ status: 400, type: ValidationError, description: 'Request data has invalid format.' })
+	@ApiResponse({ status: 403, type: ForbiddenOperationError, description: 'User is not a superhero or administrator.' })
+	async createDeletionRequests(
+		@Body() deletionRequestBody: DeletionRequestBodyProps
+	): Promise<DeletionRequestResponse> {
+		return this.deletionRequestUc.createDeletionRequest(deletionRequestBody);
+	}
+
+	@Get(':requestId')
+	@ApiOperation({
+		summary: 'Retrieving details of performed or planned deletion',
+	})
+	@ApiResponse({
+		status: 202,
+		type: DeletionRequestLogResponse,
+		description: 'Return details of performed or planned deletion',
+	})
+	@ApiResponse({ status: 400, type: ValidationError, description: 'Request data has invalid format.' })
+	@ApiResponse({ status: 403, type: ForbiddenOperationError, description: 'User is not a superhero or administrator.' })
+	async getPerformedDeletionDetails(@Param('requestId') requestId: string): Promise<DeletionRequestLogResponse> {
+		return this.deletionRequestUc.findById(requestId);
+	}
+
+	@Delete(':requestId')
+	@ApiOperation({
+		summary: 'Canceling a deletion request',
+	})
+	@ApiResponse({
+		status: 204,
+	})
+	@ApiResponse({ status: 400, type: ValidationError, description: 'Request data has invalid format.' })
+	@ApiResponse({ status: 403, type: ForbiddenOperationError, description: 'User is not a superhero or administrator.' })
+	async cancelDeletionRequest(@Param('requestId') requestId: string) {
+		return this.deletionRequestUc.deleteDeletionRequestById(requestId);
+	}
+}

apps/server/src/modules/deletion/controller/dto/deletion-execution.params.ts

@@ -0,0 +1,9 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsInt, Min } from 'class-validator';
+
+export class DeletionExecutionParams {
+	@IsInt()
+	@Min(0)
+	@ApiPropertyOptional({ description: 'Page limit, defaults to 100.', minimum: 0 })
+	limit?: number = 100;
+}

apps/server/src/modules/deletion/controller/dto/deletion-request-log.response.ts

@@ -0,0 +1,21 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsOptional } from 'class-validator';
+import { DeletionLogStatistic, DeletionTargetRef } from '../../uc/interface';
+
+export class DeletionRequestLogResponse {
+	@ApiProperty()
+	targetRef: DeletionTargetRef;
+
+	@ApiProperty()
+	deletionPlannedAt: Date;
+
+	@ApiProperty()
+	@IsOptional()
+	statistics?: DeletionLogStatistic[];
+
+	constructor(response: DeletionRequestLogResponse) {
+		this.targetRef = response.targetRef;
+		this.deletionPlannedAt = response.deletionPlannedAt;
+		this.statistics = response.statistics;
+	}
+}

apps/server/src/modules/deletion/controller/dto/deletion-request.body.params.ts

@@ -0,0 +1,19 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumber } from 'class-validator';
+import { EntityId } from '@shared/domain';
+import { DeletionDomainModel } from '../../domain/types/deletion-domain-model.enum';
+
+export class DeletionRequestBodyProps {
+	@ApiProperty({
+		required: true,
+		nullable: false,
+	})
+	targetRef!: { targetRefDomain: DeletionDomainModel; targetRefId: EntityId };
+
+	@IsNumber()
+	@ApiProperty({
+		required: true,
+		nullable: false,
+	})
+	deleteInMinutes?: number;
+}

apps/server/src/modules/deletion/controller/dto/deletion-request.response.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class DeletionRequestResponse {
+	@ApiProperty()
+	requestId: string;
+
+	@ApiProperty()
+	deletionPlannedAt: Date;
+
+	constructor(response: DeletionRequestResponse) {
+		this.requestId = response.requestId;
+		this.deletionPlannedAt = response.deletionPlannedAt;
+	}
+}

apps/server/src/modules/deletion/controller/dto/index.ts

@@ -0,0 +1,4 @@
+export * from './deletion-request.response';
+export * from './deletion-request.body.params';
+export * from './deletion-request-log.response';
+export * from './deletion-execution.params';

apps/server/src/modules/deletion/deletion.module.ts

@@ -1,11 +1,65 @@
 import { Module } from '@nestjs/common';
 import { LoggerModule } from '@src/core/logger';
+import { ConfigService } from '@nestjs/config';
+import { CourseGroupRepo } from '@shared/repo';
+import { Configuration } from '@hpi-schul-cloud/commons';
 import { DeletionRequestService } from './services/deletion-request.service';
 import { DeletionRequestRepo } from './repo/deletion-request.repo';
+import { AuthenticationModule } from '../authentication';
+import { DeletionRequestsController } from './controller/deletion-requests.controller';
+import { DeletionExecutionsController } from './controller/deletion-executions.controller';
+import { IXApiKeyConfig } from '../authentication/config/x-api-key.config';
+import { DeletionRequestUc } from './uc/deletion-request.uc';
+import { DeletionLogService } from './services/deletion-log.service';
+import { AccountModule } from '../account';
+import { ClassModule } from '../class';
+import { CourseGroupService } from '../learnroom/service';
+import { LearnroomModule } from '../learnroom';
+import { FilesService } from '../files/service';
+import { LessonModule } from '../lesson';
+import { PseudonymModule } from '../pseudonym';
+import { TeamsModule } from '../teams';
+import { UserModule } from '../user';
+import { RocketChatUserService } from '../rocketchat-user';
+import { RocketChatModule } from '../rocketchat';
+import { DeletionLogRepo } from './repo';
+import { FilesRepo } from '../files/repo';
+import { RocketChatUserRepo } from '../rocketchat-user/repo';
 
 @Module({
-	imports: [LoggerModule],
-	providers: [DeletionRequestService, DeletionRequestRepo],
+	imports: [
+		LoggerModule,
+		AuthenticationModule,
+		AccountModule,
+		ClassModule,
+		LearnroomModule,
+		LessonModule,
+		PseudonymModule,
+		TeamsModule,
+		UserModule,
+		RocketChatModule.forRoot({
+			uri: Configuration.get('ROCKET_CHAT_URI') as string,
+			adminId: Configuration.get('ROCKET_CHAT_ADMIN_ID') as string,
+			adminToken: Configuration.get('ROCKET_CHAT_ADMIN_TOKEN') as string,
+			adminUser: Configuration.get('ROCKET_CHAT_ADMIN_USER') as string,
+			adminPassword: Configuration.get('ROCKET_CHAT_ADMIN_PASSWORD') as string,
+		}),
+	],
+	controllers: [DeletionRequestsController, DeletionExecutionsController],
+	providers: [
+		DeletionRequestService,
+		DeletionRequestRepo,
+		ConfigService<IXApiKeyConfig, true>,
+		DeletionRequestUc,
+		DeletionLogService,
+		CourseGroupService,
+		FilesService,
+		DeletionLogRepo,
+		CourseGroupRepo,
+		FilesRepo,
+		RocketChatUserService,
+		RocketChatUserRepo,
+	],
 	exports: [DeletionRequestService],
 })
 export class DeletionModule {}

apps/server/src/modules/deletion/uc/builder/deletion-request-log.builder.spec.ts

@@ -1,9 +1,9 @@
 import { DeletionDomainModel } from '../../domain/types/deletion-domain-model.enum';
 import { DeletionLogStatisticBuilder } from './deletion-log-statistic.builder';
-import { DeletionRequestLogBuilder } from './deletion-request-log.builder';
+import { DeletionRequestLogResponseBuilder } from './deletion-request-log.builder';
 import { DeletionTargetRefBuilder } from './deletion-target-ref.builder';
 
-describe(DeletionRequestLogBuilder.name, () => {
+describe(DeletionRequestLogResponseBuilder.name, () => {
 	afterAll(() => {
 		jest.clearAllMocks();
 	});
@@ -18,7 +18,7 @@ describe(DeletionRequestLogBuilder.name, () => {
 		const deletedCount = 2;
 		const statistics = [DeletionLogStatisticBuilder.build(targetRefDomain, modifiedCount, deletedCount)];
 
-		const result = DeletionRequestLogBuilder.build(targetRef, deletionPlannedAt, statistics);
+		const result = DeletionRequestLogResponseBuilder.build(targetRef, deletionPlannedAt, statistics);
 
 		// Assert
 		expect(result.targetRef).toEqual(targetRef);

apps/server/src/modules/deletion/uc/builder/deletion-request-log.builder.ts

@@ -1,11 +1,12 @@
-import { DeletionLogStatistic, DeletionRequestLog, DeletionTargetRef } from '../interface';
+import { DeletionRequestLogResponse } from '../../controller/dto';
+import { DeletionLogStatistic, DeletionTargetRef } from '../interface';
 
-export class DeletionRequestLogBuilder {
+export class DeletionRequestLogResponseBuilder {
 	static build(
 		targetRef: DeletionTargetRef,
 		deletionPlannedAt: Date,
 		statistics?: DeletionLogStatistic[]
-	): DeletionRequestLog {
+	): DeletionRequestLogResponse {
 		const deletionRequestLog = { targetRef, deletionPlannedAt, statistics };
 
 		return deletionRequestLog;