N21-1630 populate sanis user import

apps/server/src/infra/schulconnex-client/index.ts

@@ -0,0 +1,20 @@
+export { SchulconnexRestClientOptions } from './schulconnex-rest-client-options';
+export { SchulconnexClientModule } from './schulconnex-client.module';
+export { SchulconnexRestClient } from './schulconnex-rest-client';
+export {
+	SanisResponse,
+	SanisRole,
+	SanisGroupRole,
+	SanisGroupType,
+	SanisGruppenResponse,
+	SanisResponseValidationGroups,
+	SanisPersonResponse,
+	SanisAnschriftResponse,
+	SanisGruppenzugehoerigkeitResponse,
+	SanisGruppeResponse,
+	SanisNameResponse,
+	SanisOrganisationResponse,
+	SanisPersonenkontextResponse,
+	SanisSonstigeGruppenzugehoerigeResponse,
+} from './response';
+export { schulconnexResponseFactory } from './testing/schulconnex-response-factory';

apps/server/src/infra/schulconnex-client/request/index.ts

@@ -0,0 +1 @@
+export { SchulconnexPersonenInfoParams } from './schulconnex-personen-info-params';

apps/server/src/infra/schulconnex-client/request/schulconnex-personen-info-params.ts

@@ -0,0 +1,13 @@
+export type SchulconnexPropertyContext = 'personen' | 'personenkontexte' | 'organisationen' | 'gruppen' | 'beziehungen';
+
+export interface SchulconnexPersonenInfoParams {
+	vollstaendig?: SchulconnexPropertyContext[];
+
+	pid?: string;
+
+	'personenkontext.id'?: string;
+
+	'organisation.id'?: string;
+
+	'gruppe.id'?: string;
+}

apps/server/src/infra/schulconnex-client/schulconnex-api.interface.ts

@@ -0,0 +1,8 @@
+import { SchulconnexPersonenInfoParams } from './request';
+import { SanisResponse } from './response';
+
+export interface SchulconnexApiInterface {
+	getPersonInfo(accessToken: string, options?: { overrideUrl: string }): Promise<SanisResponse>;
+
+	getPersonenInfo(params: SchulconnexPersonenInfoParams): Promise<SanisResponse[]>;
+}

apps/server/src/infra/schulconnex-client/schulconnex-client.module.ts

@@ -0,0 +1,29 @@
+import { OauthAdapterService, OauthModule } from '@modules/oauth';
+import { HttpModule, HttpService } from '@nestjs/axios';
+import { DynamicModule, Global, Module } from '@nestjs/common';
+import { SchulconnexRestClient } from './schulconnex-rest-client';
+import { SchulconnexRestClientOptions } from './schulconnex-rest-client-options';
+
+@Global()
+/**
+ * @Global is used here to make sure that the module is only instantiated once, with the configuration and can be used in every module.
+ * Otherwise, you need to import the module with configuration in every module where you want to use it.
+ */
+@Module({})
+export class SchulconnexClientModule {
+	static register(options: SchulconnexRestClientOptions): DynamicModule {
+		return {
+			imports: [HttpModule, OauthModule],
+			module: SchulconnexClientModule,
+			providers: [
+				{
+					provide: SchulconnexRestClient,
+					useFactory: (httpService: HttpService, oauthAdapterService: OauthAdapterService) =>
+						new SchulconnexRestClient(options, httpService, oauthAdapterService),
+					inject: [HttpService, OauthAdapterService],
+				},
+			],
+			exports: [SchulconnexRestClient],
+		};
+	}
+}

apps/server/src/infra/schulconnex-client/schulconnex-rest-client-options.ts

@@ -0,0 +1,9 @@
+export interface SchulconnexRestClientOptions {
+	apiUrl: string;
+
+	tokenEndpoint: string;
+
+	clientId: string;
+
+	clientSecret: string;
+}

apps/server/src/infra/schulconnex-client/schulconnex-rest-client.spec.ts

@@ -0,0 +1,144 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { OauthAdapterService, OAuthTokenDto } from '@modules/oauth';
+import { HttpService } from '@nestjs/axios';
+import { TestingModule } from '@nestjs/testing';
+import { axiosResponseFactory } from '@shared/testing';
+import { of } from 'rxjs';
+import { SanisResponse } from './response';
+import { SchulconnexRestClient } from './schulconnex-rest-client';
+import { SchulconnexRestClientOptions } from './schulconnex-rest-client-options';
+import { schulconnexResponseFactory } from './testing';
+
+describe(SchulconnexRestClient.name, () => {
+	let module: TestingModule;
+	let client: SchulconnexRestClient;
+
+	let httpService: DeepMocked<HttpService>;
+	let oauthAdapterService: DeepMocked<OauthAdapterService>;
+	const options: SchulconnexRestClientOptions = {
+		apiUrl: 'https://schulconnex.url/api',
+		clientId: 'clientId',
+		clientSecret: 'clientSecret',
+		tokenEndpoint: 'https://schulconnex.url/token',
+	};
+
+	beforeAll(() => {
+		httpService = createMock<HttpService>();
+		oauthAdapterService = createMock<OauthAdapterService>();
+
+		client = new SchulconnexRestClient(options, httpService, oauthAdapterService);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('getPersonInfo', () => {
+		describe('when requesting person-info', () => {
+			const setup = () => {
+				const accessToken = 'accessToken';
+				const response: SanisResponse = schulconnexResponseFactory.build();
+
+				httpService.get.mockReturnValueOnce(of(axiosResponseFactory.build({ data: response })));
+
+				return {
+					accessToken,
+					response,
+				};
+			};
+
+			it('should make a request to a SchulConneX-API', async () => {
+				const { accessToken } = setup();
+
+				await client.getPersonInfo(accessToken);
+
+				expect(httpService.get).toHaveBeenCalledWith(`${options.apiUrl}/person-info`, {
+					headers: {
+						Authorization: `Bearer ${accessToken}`,
+						'Accept-Encoding': 'gzip',
+					},
+				});
+			});
+
+			it('should return the response', async () => {
+				const { accessToken, response } = setup();
+
+				const result: SanisResponse = await client.getPersonInfo(accessToken);
+
+				expect(result).toEqual(response);
+			});
+		});
+
+		describe('when overriding the url', () => {
+			const setup = () => {
+				const accessToken = 'accessToken';
+				const customUrl = 'https://override.url/person-info';
+				const response: SanisResponse = schulconnexResponseFactory.build();
+
+				httpService.get.mockReturnValueOnce(of(axiosResponseFactory.build({ data: response })));
+
+				return {
+					accessToken,
+					customUrl,
+				};
+			};
+
+			it('should make a request to a SchulConneX-API', async () => {
+				const { accessToken, customUrl } = setup();
+
+				await client.getPersonInfo(accessToken, { overrideUrl: customUrl });
+
+				expect(httpService.get).toHaveBeenCalledWith(customUrl, expect.anything());
+			});
+		});
+	});
+
+	describe('getPersonenInfo', () => {
+		describe('when requesting personen-info', () => {
+			const setup = () => {
+				const tokens: OAuthTokenDto = new OAuthTokenDto({
+					idToken: 'id_token',
+					accessToken: 'access_token',
+					refreshToken: 'refresh_token',
+				});
+				const response: SanisResponse[] = schulconnexResponseFactory.buildList(2);
+
+				oauthAdapterService.sendTokenRequest.mockResolvedValueOnce(tokens);
+				httpService.get.mockReturnValueOnce(of(axiosResponseFactory.build({ data: response })));
+
+				return {
+					tokens,
+					response,
+				};
+			};
+
+			it('should make a request to a SchulConneX-API', async () => {
+				const { tokens } = setup();
+
+				await client.getPersonenInfo({ 'organisation.id': '1234', vollstaendig: ['personen', 'organisationen'] });
+
+				expect(httpService.get).toHaveBeenCalledWith(
+					`${options.apiUrl}/personen-info?organisation.id=1234&vollstaendig=personen%2Corganisationen`,
+					{
+						headers: {
+							Authorization: `Bearer ${tokens.accessToken}`,
+							'Accept-Encoding': 'gzip',
+						},
+					}
+				);
+			});
+
+			it('should return the response', async () => {
+				const { response } = setup();
+
+				const result: SanisResponse[] = await client.getPersonenInfo({ 'organisation.id': '1234' });
+
+				expect(result).toEqual(response);
+			});
+		});
+	});
+});

apps/server/src/infra/schulconnex-client/schulconnex-rest-client.ts

@@ -0,0 +1,70 @@
+import { OauthAdapterService, OAuthTokenDto } from '@modules/oauth';
+import { OAuthGrantType } from '@modules/oauth/interface/oauth-grant-type.enum';
+import { ClientCredentialsGrantTokenRequest } from '@modules/oauth/service/dto';
+import { HttpService } from '@nestjs/axios';
+import { AxiosResponse } from 'axios';
+import QueryString from 'qs';
+import { lastValueFrom, Observable } from 'rxjs';
+import { SchulconnexPersonenInfoParams } from './request';
+import { SanisResponse } from './response';
+import { SchulconnexApiInterface } from './schulconnex-api.interface';
+import { SchulconnexRestClientOptions } from './schulconnex-rest-client-options';
+
+export class SchulconnexRestClient implements SchulconnexApiInterface {
+	private readonly API_BASE_URL: string;
+
+	constructor(
+		private readonly options: SchulconnexRestClientOptions,
+		private readonly httpService: HttpService,
+		private readonly oauthAdapterService: OauthAdapterService
+	) {
+		this.API_BASE_URL = options.apiUrl;
+	}
+
+	// TODO: N21-1678 use this in provisioning module
+	public async getPersonInfo(accessToken: string, options?: { overrideUrl: string }): Promise<SanisResponse> {
+		const url: URL = new URL(options?.overrideUrl ?? `${this.API_BASE_URL}/person-info`);
+
+		const response: Promise<SanisResponse> = this.getRequest<SanisResponse>(url, accessToken);
+
+		return response;
+	}
+
+	public async getPersonenInfo(params: SchulconnexPersonenInfoParams): Promise<SanisResponse[]> {
+		const token: OAuthTokenDto = await this.requestClientCredentialToken();
+
+		const url: URL = new URL(`${this.API_BASE_URL}/personen-info`);
+		url.search = QueryString.stringify(params, { arrayFormat: 'comma' });
+
+		const response: Promise<SanisResponse[]> = this.getRequest<SanisResponse[]>(url, token.accessToken);
+
+		return response;
+	}
+
+	private async getRequest<T>(url: URL, accessToken: string): Promise<T> {
+		const observable: Observable<AxiosResponse<T>> = this.httpService.get(url.toString(), {
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				'Accept-Encoding': 'gzip',
+			},
+		});
+
+		const responseToken: AxiosResponse<T> = await lastValueFrom(observable);
+
+		return responseToken.data;
+	}
+
+	private async requestClientCredentialToken(): Promise<OAuthTokenDto> {
+		const { tokenEndpoint, clientId, clientSecret } = this.options;
+
+		const payload: ClientCredentialsGrantTokenRequest = new ClientCredentialsGrantTokenRequest({
+			client_id: clientId,
+			client_secret: clientSecret,
+			grant_type: OAuthGrantType.CLIENT_CREDENTIALS_GRANT,
+		});
+
+		const tokenDto: OAuthTokenDto = await this.oauthAdapterService.sendTokenRequest(tokenEndpoint, payload);
+
+		return tokenDto;
+	}
+}

apps/server/src/infra/schulconnex-client/testing/index.ts

@@ -0,0 +1 @@
+export { schulconnexResponseFactory } from './schulconnex-response-factory';

apps/server/src/infra/schulconnex-client/testing/schulconnex-response-factory.ts

@@ -0,0 +1,50 @@
+import { UUID } from 'bson';
+import { Factory } from 'fishery';
+import { SanisGroupRole, SanisGroupType, SanisResponse, SanisRole } from '../response';
+
+export const schulconnexResponseFactory = Factory.define<SanisResponse>(() => {
+	return {
+		pid: 'aef1f4fd-c323-466e-962b-a84354c0e713',
+		person: {
+			name: {
+				vorname: 'Hans',
+				familienname: 'Peter',
+			},
+			geburt: {
+				datum: '2023-11-17',
+			},
+		},
+		personenkontexte: [
+			{
+				id: new UUID().toString(),
+				rolle: SanisRole.LEIT,
+				organisation: {
+					id: new UUID('df66c8e6-cfac-40f7-b35b-0da5d8ee680e').toString(),
+					name: 'schoolName',
+					kennung: 'Kennung',
+					anschrift: {
+						ort: 'Hannover',
+					},
+				},
+				gruppen: [
+					{
+						gruppe: {
+							id: new UUID().toString(),
+							bezeichnung: 'bezeichnung',
+							typ: SanisGroupType.CLASS,
+						},
+						gruppenzugehoerigkeit: {
+							rollen: [SanisGroupRole.TEACHER],
+						},
+						sonstige_gruppenzugehoerige: [
+							{
+								rollen: [SanisGroupRole.STUDENT],
+								ktid: 'ktid',
+							},
+						],
+					},
+				],
+			},
+		],
+	};
+});

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

@@ -3,7 +3,7 @@ import { ExecutionContext, INestApplication } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { Account, User } from '@shared/domain/entity';
 import { Permission, RoleName } from '@shared/domain/interface';
-import { accountFactory, mapUserToCurrentUser, roleFactory, schoolFactory, userFactory } from '@shared/testing';
+import { accountFactory, mapUserToCurrentUser, roleFactory, schoolEntityFactory, userFactory } from '@shared/testing';
 import {
 	AccountByIdBodyParams,
 	AccountSearchQueryParams,
@@ -39,7 +39,7 @@ describe('Account Controller (API)', () => {
 	const defaultPasswordHash = '$2a$10$/DsztV5o6P5piW2eWJsxw.4nHovmJGBA.QNwiTmuZ/uvUc40b.Uhu';
 
 	const setup = async () => {
-		const school = schoolFactory.buildWithId();
+		const school = schoolEntityFactory.buildWithId();
 
 		const adminRoles = roleFactory.build({
 			name: RoleName.ADMINISTRATOR,

apps/server/src/modules/account/services/account-db.service.spec.ts

@@ -11,7 +11,7 @@ import { Account, Role, SchoolEntity, User } from '@shared/domain/entity';
 
 import { Permission, RoleName } from '@shared/domain/interface';
 import { EntityId } from '@shared/domain/types';
-import { accountFactory, schoolFactory, setupEntities, userFactory } from '@shared/testing';
+import { accountFactory, schoolEntityFactory, setupEntities, userFactory } from '@shared/testing';
 import bcrypt from 'bcryptjs';
 import { LegacyLogger } from '../../../core/logger';
 import { AccountRepo } from '../repo/account.repo';
@@ -149,7 +149,7 @@ describe('AccountDbService', () => {
 		jest.useFakeTimers();
 		jest.setSystemTime(new Date(2020, 1, 1));
 
-		mockSchool = schoolFactory.buildWithId();
+		mockSchool = schoolEntityFactory.buildWithId();
 
 		mockTeacherUser = userFactory.buildWithId({
 			school: mockSchool,