diff --git a/charts/dbildungs-iam-server/config/config.json b/charts/dbildungs-iam-server/config/config.json index 11310e644..b5a1e29e9 100644 --- a/charts/dbildungs-iam-server/config/config.json +++ b/charts/dbildungs-iam-server/config/config.json @@ -81,5 +81,13 @@ "RENAME_WAITING_TIME_IN_SECONDS": 3, "STEP_UP_TIMEOUT_ENABLED": "true", "STEP_UP_TIMEOUT_IN_SECONDS": 10 + }, + "VIDIS": { + "BASE_URL": "https://service-stage.vidis.schule", + "USERNAME": "", + "PASSWORD": "", + "REGION_NAME": "test-region", + "KEYCLOAK_GROUP": "VIDIS-service", + "KEYCLOAK_ROLE": "VIDIS-user" } } diff --git a/charts/dbildungs-iam-server/templates/_dbildungs-iam-server-envs.tpl b/charts/dbildungs-iam-server/templates/_dbildungs-iam-server-envs.tpl index e22a1bd7e..c741cc95d 100644 --- a/charts/dbildungs-iam-server/templates/_dbildungs-iam-server-envs.tpl +++ b/charts/dbildungs-iam-server/templates/_dbildungs-iam-server-envs.tpl @@ -106,4 +106,34 @@ secretKeyRef: name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} key: redis-password + - name: VIDIS_BASE_URL + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-base-url + - name: VIDIS_USERNAME + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-username + - name: VIDIS_PASSWORD + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-password + - name: VIDIS_REGION_NAME + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-region-name + - name: VIDIS_KEYCLOAK_GROUP + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-keycloak-group + - name: VIDIS_KEYCLOAK_ROLE + valueFrom: + secretKeyRef: + name: {{ default .Values.auth.existingSecret .Values.auth.secretName }} + key: vidis-keycloak-role {{- end}} diff --git a/charts/dbildungs-iam-server/templates/secret.yaml b/charts/dbildungs-iam-server/templates/secret.yaml index d87bfe75d..4890a5bac 100644 --- a/charts/dbildungs-iam-server/templates/secret.yaml +++ b/charts/dbildungs-iam-server/templates/secret.yaml @@ -27,4 +27,10 @@ data: system-step-up-enabled: {{ .Values.auth.system_step_up_enabled }} secrets-json: {{ .Values.auth.secrets_json }} redis-password: {{ .Values.auth.redis_password }} + vidis-base-url: {{ .Values.auth.vidis_base_url }} + vidis-username: {{ .Values.auth.vidis_username }} + vidis-password: {{ .Values.auth.vidis_password }} + vidis-region-name: {{ .Values.auth.vidis_region_name }} + vidis-keycloak-group: {{ .Values.auth.vidis_keycloak_group }} + vidis-keycloak-role: {{ .Values.auth.vidis_keycloak_role }} {{- end }} diff --git a/charts/dbildungs-iam-server/values.yaml b/charts/dbildungs-iam-server/values.yaml index 9ef83effd..b2ff1515d 100644 --- a/charts/dbildungs-iam-server/values.yaml +++ b/charts/dbildungs-iam-server/values.yaml @@ -54,6 +54,12 @@ auth: system_step_up_timeout_in_seconds: '' system_step_up_timeout_enabled: '' redis_password: '' + vidis_base_url: '' + vidis_username: '' + vidis_password: '' + vidis_region_name: '' + vidis_keycloak_group: '' + vidis_keycloak_role: '' backend: replicaCount: 1 diff --git a/config/config.json b/config/config.json index 75096e5ed..95f2330ad 100644 --- a/config/config.json +++ b/config/config.json @@ -86,6 +86,14 @@ "USER_RESOLVER": "mariadb_resolver", "REALM": "defrealm" }, + "VIDIS": { + "BASE_URL": "https://service-stage.vidis.schule", + "USERNAME": "username", + "PASSWORD": "password", + "REGION_NAME": "test-region", + "KEYCLOAK_GROUP": "VIDIS-service", + "KEYCLOAK_ROLE": "VIDIS-user" + }, "IMPORT": { "IMPORT_FILE_MAXGROESSE_IN_MB": 10 }, diff --git a/migrations/.snapshot-dbildungs-iam-server.json b/migrations/.snapshot-dbildungs-iam-server.json index 0cce5b68e..89d8aa8d7 100644 --- a/migrations/.snapshot-dbildungs-iam-server.json +++ b/migrations/.snapshot-dbildungs-iam-server.json @@ -4523,6 +4523,236 @@ } } }, + { + "columns": { + "organisation_id": { + "name": "organisation_id", + "type": "uuid", + "unsigned": false, + "autoincrement": false, + "primary": false, + "nullable": false, + "mappedType": "uuid" + }, + "service_provider_id": { + "name": "service_provider_id", + "type": "uuid", + "unsigned": false, + "autoincrement": false, + "primary": false, + "nullable": false, + "mappedType": "uuid" + } + }, + "name": "organisation_service_provider", + "schema": "public", + "indexes": [ + { + "keyName": "organisation_service_provider_pkey", + "columnNames": [ + "organisation_id", + "service_provider_id" + ], + "composite": true, + "constraint": true, + "primary": true, + "unique": true + } + ], + "checks": [], + "foreignKeys": { + "organisation_service_provider_organisation_id_foreign": { + "constraintName": "organisation_service_provider_organisation_id_foreign", + "columnNames": [ + "organisation_id" + ], + "localTableName": "public.organisation_service_provider", + "referencedColumnNames": [ + "id" + ], + "referencedTableName": "public.organisation", + "updateRule": "cascade" + }, + "organisation_service_provider_service_provider_id_foreign": { + "constraintName": "organisation_service_provider_service_provider_id_foreign", + "columnNames": [ + "service_provider_id" + ], + "localTableName": "public.organisation_service_provider", + "referencedColumnNames": [ + "id" + ], + "referencedTableName": "public.service_provider", + "updateRule": "cascade" + } + }, + "nativeEnums": { + "db_seed_status_enum": { + "name": "db_seed_status_enum", + "schema": "public", + "items": [ + "STARTED", + "DONE", + "FAILED" + ] + }, + "referenced_entity_type_enum": { + "name": "referenced_entity_type_enum", + "schema": "public", + "items": [ + "PERSON", + "ORGANISATION", + "ROLLE", + "SERVICE_PROVIDER" + ] + }, + "organisations_typ_enum": { + "name": "organisations_typ_enum", + "schema": "public", + "items": [ + "ROOT", + "LAND", + "TRAEGER", + "SCHULE", + "KLASSE", + "ANBIETER", + "SONSTIGE ORGANISATION / EINRICHTUNG", + "UNBESTAETIGT" + ] + }, + "traegerschaft_enum": { + "name": "traegerschaft_enum", + "schema": "public", + "items": [ + "01", + "02", + "03", + "04", + "05", + "06" + ] + }, + "geschlecht_enum": { + "name": "geschlecht_enum", + "schema": "public", + "items": [ + "m", + "w", + "d", + "x" + ] + }, + "vertrauensstufe_enum": { + "name": "vertrauensstufe_enum", + "schema": "public", + "items": [ + "KEIN", + "UNBE", + "TEIL", + "VOLL" + ] + }, + "email_address_status_enum": { + "name": "email_address_status_enum", + "schema": "public", + "items": [ + "ENABLED", + "DISABLED", + "REQUESTED", + "FAILED" + ] + }, + "rollen_art_enum": { + "name": "rollen_art_enum", + "schema": "public", + "items": [ + "LERN", + "LEHR", + "EXTERN", + "ORGADMIN", + "LEIT", + "SYSADMIN" + ] + }, + "personenstatus_enum": { + "name": "personenstatus_enum", + "schema": "public", + "items": [ + "AKTIV" + ] + }, + "jahrgangsstufe_enum": { + "name": "jahrgangsstufe_enum", + "schema": "public", + "items": [ + "01", + "02", + "03", + "04", + "05", + "06", + "07", + "08", + "09", + "10" + ] + }, + "rollen_merkmal_enum": { + "name": "rollen_merkmal_enum", + "schema": "public", + "items": [ + "BEFRISTUNG_PFLICHT", + "KOPERS_PFLICHT" + ] + }, + "rollen_system_recht_enum": { + "name": "rollen_system_recht_enum", + "schema": "public", + "items": [ + "ROLLEN_VERWALTEN", + "PERSONEN_SOFORT_LOESCHEN", + "PERSONEN_VERWALTEN", + "SCHULEN_VERWALTEN", + "KLASSEN_VERWALTEN", + "SCHULTRAEGER_VERWALTEN", + "MIGRATION_DURCHFUEHREN", + "PERSON_SYNCHRONISIEREN", + "CRON_DURCHFUEHREN", + "PERSONEN_ANLEGEN", + "IMPORT_DURCHFUEHREN" + ] + }, + "service_provider_target_enum": { + "name": "service_provider_target_enum", + "schema": "public", + "items": [ + "URL", + "EMAIL", + "SCHULPORTAL_ADMINISTRATION" + ] + }, + "service_provider_kategorie_enum": { + "name": "service_provider_kategorie_enum", + "schema": "public", + "items": [ + "EMAIL", + "UNTERRICHT", + "VERWALTUNG", + "HINWEISE", + "ANGEBOTE" + ] + }, + "service_provider_system_enum": { + "name": "service_provider_system_enum", + "schema": "public", + "items": [ + "NONE", + "EMAIL", + "ITSLEARNING" + ] + } + } + }, { "columns": { "id": { diff --git a/migrations/Migration20241115133701-S.ts b/migrations/Migration20241115133701-S.ts new file mode 100644 index 000000000..11fa57bee --- /dev/null +++ b/migrations/Migration20241115133701-S.ts @@ -0,0 +1,20 @@ +import { Migration } from '@mikro-orm/migrations'; + +export class Migration20241115133701 extends Migration { + async up(): Promise { + this.addSql( + 'create table "organisation_service_provider" ("organisation_id" uuid not null, "service_provider_id" uuid not null, constraint "organisation_service_provider_pkey" primary key ("organisation_id", "service_provider_id"));', + ); + + this.addSql( + 'alter table "organisation_service_provider" add constraint "organisation_service_provider_organisation_id_foreign" foreign key ("organisation_id") references "organisation" ("id") on update cascade;', + ); + this.addSql( + 'alter table "organisation_service_provider" add constraint "organisation_service_provider_service_provider_id_foreign" foreign key ("service_provider_id") references "service_provider" ("id") on update cascade;', + ); + } + + override async down(): Promise { + this.addSql('drop table if exists "organisation_service_provider" cascade;'); + } +} diff --git a/src/modules/cron/cron.controller.spec.ts b/src/modules/cron/cron.controller.spec.ts index ab86befcd..449b03753 100644 --- a/src/modules/cron/cron.controller.spec.ts +++ b/src/modules/cron/cron.controller.spec.ts @@ -19,7 +19,10 @@ import { UserLock } from '../keycloak-administration/domain/user-lock.js'; import { UserLockRepository } from '../keycloak-administration/repository/user-lock.repository.js'; import { PersonLockOccasion } from '../person/domain/person.enums.js'; import { EntityNotFoundError } from '../../shared/error/entity-not-found.error.js'; -import { ClassLogger } from '../../core/logging/class-logger.js'; +import { ServiceProviderService } from '../service-provider/domain/service-provider.service.js'; +import { HttpException } from '@nestjs/common'; +import { LoggingTestModule } from '../../../test/utils/logging-test.module.js'; +import { DomainError } from '../../shared/error/domain.error.js'; describe('CronController', () => { let cronController: CronController; @@ -31,9 +34,11 @@ describe('CronController', () => { let permissionsMock: DeepMocked; let personenkontextWorkflowMock: DeepMocked; let userLockRepositoryMock: DeepMocked; + let serviceProviderServiceMock: DeepMocked; beforeAll(async () => { const module: TestingModule = await Test.createTestingModule({ + imports: [LoggingTestModule], providers: [ { provide: KeycloakUserService, @@ -64,8 +69,8 @@ describe('CronController', () => { useValue: createMock(), }, { - provide: ClassLogger, - useValue: createMock(), + provide: ServiceProviderService, + useValue: createMock(), }, ], controllers: [CronController], @@ -80,6 +85,7 @@ describe('CronController', () => { personenkontextWorkflowMock = module.get(PersonenkontextWorkflowAggregate); userLockRepositoryMock = module.get(UserLockRepository); permissionsMock = createMock(); + serviceProviderServiceMock = module.get(ServiceProviderService); }); beforeEach(() => { @@ -600,4 +606,45 @@ describe('CronController', () => { }); }); }); + + describe('/PUT cron/vidis-angebote', () => { + describe(`when is authorized user`, () => { + it(`should update ServiceProviders for VIDIS Angebote`, async () => { + permissionsMock.hasSystemrechteAtRootOrganisation.mockResolvedValue(true); + serviceProviderServiceMock.updateServiceProvidersForVidis.mockResolvedValue(); + + await cronController.updateServiceProvidersForVidisAngebote(permissionsMock); + + expect(serviceProviderServiceMock.updateServiceProvidersForVidis).toHaveBeenCalledTimes(1); + }); + }); + describe(`when is not authorized user`, () => { + it(`should not update ServiceProviders for VIDIS Angebote and throw an error`, async () => { + permissionsMock.hasSystemrechteAtRootOrganisation.mockResolvedValue(false); + serviceProviderServiceMock.updateServiceProvidersForVidis.mockResolvedValue(); + + await expect(cronController.updateServiceProvidersForVidisAngebote(permissionsMock)).rejects.toThrow( + HttpException, + ); + expect(serviceProviderServiceMock.updateServiceProvidersForVidis).toHaveBeenCalledTimes(0); + }); + }); + describe(`when is authorized user but ServiceProvider update throws an Error`, () => { + it(`should throw the error`, async () => { + permissionsMock.hasSystemrechteAtRootOrganisation.mockResolvedValue(true); + class UnknownError extends DomainError { + public constructor(message: string) { + super(message, ''); + } + } + serviceProviderServiceMock.updateServiceProvidersForVidis.mockImplementationOnce(() => { + throw new UnknownError('Internal error when trying to update ServiceProviders for VIDIS Angebote'); + }); + + await expect(cronController.updateServiceProvidersForVidisAngebote(permissionsMock)).rejects.toThrow( + 'Internal error when trying to update ServiceProviders for VIDIS Angebote', + ); + }); + }); + }); }); diff --git a/src/modules/cron/cron.controller.ts b/src/modules/cron/cron.controller.ts index 1721456d7..91534acce 100644 --- a/src/modules/cron/cron.controller.ts +++ b/src/modules/cron/cron.controller.ts @@ -32,6 +32,7 @@ import { RollenSystemRecht } from '../rolle/domain/rolle.enums.js'; import { MissingPermissionsError } from '../../shared/error/missing-permissions.error.js'; import { SchulConnexErrorMapper } from '../../shared/error/schul-connex-error.mapper.js'; import { ClassLogger } from '../../core/logging/class-logger.js'; +import { ServiceProviderService } from '../service-provider/domain/service-provider.service.js'; @Controller({ path: 'cron' }) @ApiBearerAuth() @@ -46,6 +47,7 @@ export class CronController { private readonly personenkontextWorkflowFactory: PersonenkontextWorkflowFactory, private readonly userLockRepository: UserLockRepository, private readonly logger: ClassLogger, + private readonly serviceProviderService: ServiceProviderService, ) {} @Put('kopers-lock') @@ -372,4 +374,39 @@ export class CronController { throw new Error('Failed to unlock users due to an internal server error.'); } } + + @Put('vidis-angebote') + @HttpCode(HttpStatus.OK) + @ApiCreatedResponse({ description: 'VIDIS Angebote were successfully updated.', type: Boolean }) + @ApiBadRequestResponse({ description: 'VIDIS Angebote were not successfully updated.' }) + @ApiUnauthorizedResponse({ description: 'Not authorized to update VIDIS Angebote.' }) + @ApiForbiddenResponse({ description: 'Insufficient permissions to update VIDIS Angebote.' }) + @ApiNotFoundResponse({ description: 'Insufficient permissions to update VIDIS Angebote.' }) + @ApiInternalServerErrorResponse({ + description: 'Internal server error while trying to update VIDIS Angebote.', + }) + public async updateServiceProvidersForVidisAngebote(@Permissions() permissions: PersonPermissions): Promise { + const hasCronJobPermission: boolean = await permissions.hasSystemrechteAtRootOrganisation([ + RollenSystemRecht.CRON_DURCHFUEHREN, + ]); + if (!hasCronJobPermission) { + throw SchulConnexErrorMapper.mapSchulConnexErrorToHttpException( + SchulConnexErrorMapper.mapDomainErrorToSchulConnexError( + new MissingPermissionsError('Insufficient permissions'), + ), + ); + } + try { + await this.serviceProviderService.updateServiceProvidersForVidis(); + } catch (error) { + let errorMessage: string = 'unbekannt'; + if (error instanceof DomainError) { + errorMessage = error.message; + } + this.logger.info( + `ServiceProvider für VIDIS-Angebote konnten nicht aktualisiert werden. Fehler: ${errorMessage}`, + ); + throw error; + } + } } diff --git a/src/modules/cron/cron.module.ts b/src/modules/cron/cron.module.ts index aa172c03f..4f69c69d8 100644 --- a/src/modules/cron/cron.module.ts +++ b/src/modules/cron/cron.module.ts @@ -5,6 +5,7 @@ import { PersonModule } from '../person/person.module.js'; import { PersonDeleteModule } from '../person/person-deletion/person-delete.module.js'; import { PersonenKontextModule } from '../personenkontext/personenkontext.module.js'; import { LoggerModule } from '../../core/logging/logger.module.js'; +import { ServiceProviderModule } from '../service-provider/service-provider.module.js'; @Module({ imports: [ @@ -13,6 +14,7 @@ import { LoggerModule } from '../../core/logging/logger.module.js'; KeycloakAdministrationModule, PersonDeleteModule, LoggerModule.register(CronModule.name), + ServiceProviderModule, ], controllers: [CronController], }) diff --git a/src/modules/service-provider/domain/service-provider.service.spec.ts b/src/modules/service-provider/domain/service-provider.service.spec.ts index 725fe7b15..d87aec223 100644 --- a/src/modules/service-provider/domain/service-provider.service.spec.ts +++ b/src/modules/service-provider/domain/service-provider.service.spec.ts @@ -6,6 +6,170 @@ import { RolleRepo } from '../../rolle/repo/rolle.repo.js'; import { ServiceProviderRepo } from '../repo/service-provider.repo.js'; import { ServiceProvider } from './service-provider.js'; import { ServiceProviderService } from './service-provider.service.js'; +import { OrganisationRepository } from '../../organisation/persistence/organisation.repository.js'; +import { OrganisationServiceProviderRepo } from '../repo/organisation-service-provider.repo.js'; +import { VidisService } from '../../vidis/vidis.service.js'; +import { LoggingTestModule } from '../../../../test/utils/logging-test.module.js'; +import { ServiceProviderKategorie, ServiceProviderSystem, ServiceProviderTarget } from './service-provider.enum.js'; +import { Organisation } from '../../organisation/domain/organisation.js'; +import { OrganisationsTyp } from '../../organisation/domain/organisation.enums.js'; +import { faker } from '@faker-js/faker'; +import { ConfigTestModule } from '../../../../test/utils/config-test.module.js'; +import { VidisAngebot } from '../../vidis/domain/vidis-angebot.js'; + +const mockVidisAngebote: VidisAngebot[] = [ + { + angebotVersion: 1, + angebotDescription: + 'Effiziente Organisation Ihrer Hausaufgaben mit der neuen Hausaufgaben Listen App Verlieren Sie nie wieder den Überblick über Ihre Aufgaben und Abgabefristen. Unsere Hausaufgaben Listen App bietet Ihnen eine strukturierte und benutzerfreundliche Lösung, um Ihre schulischen Verpflichtungen optimal zu verwalten. Funktionen der App: Übersichtliche Verwaltung: Behalten Sie alle Hausaufgaben, Projekte und To-Dos an einem zentralen Ort im Blick. Erinnerungsfunktion: Automatische Benachrichtigungen helfen Ihnen, keine Fristen mehr zu verpassen. Einfache Bedienung: Intuitive Benutzeroberfläche, die eine schnelle und unkomplizierte Nutzung ermöglicht. Kollaborationsmöglichkeit: Teilen Sie Aufgaben und Projekte mit Mitschülern, um effizienter zusammenzuarbeiten. Anpassbare Listen: Erstellen Sie individuelle Kategorien und Listen nach Ihren Bedürfnissen. Fortschrittsanzeige: Verfolgen Sie Ihre erledigten Aufgaben und sehen Sie Ihren Fortschritt in Echtzeit. Unsere Hausaufgaben Listen App ist kostenlos verfügbar und bietet Ihnen eine verlässliche Unterstützung bei der Organisation Ihres Schulalltags.', + angebotLink: 'https://vidis-login-example.buergercloud.de/oauth2/authorization/vidis?vidis_idp_hint=vidis-idp', + // Mocked angebotLogo is base64 encoded string for a JPEG + angebotLogo: + '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', + angebotTitle: 'Hausaufgaben-Liste', + angebotLongTitle: 'Testangebot Hausaufgaben-Liste', + educationProviderOrganizationName: 'VIDIS-Testangebot', + schoolActivations: ['DE-VIDIS-vidis_test_20202', 'DE-VIDIS-vidis_test_40404', 'DE-VIDIS-vidis_test_101010'], + }, + { + angebotVersion: 1, + angebotDescription: + 'divomath ist eine Lernumgebung für Mathematik, die insbesondere dem Prinzip der Verstehensorientierung folgt. Sie bietet Unterrichtseinheiten für die dritte bis sechste Jahrgangsstufe.', + angebotLink: 'https://login-stage.divomath.de/idp-login?idp=vidis&vidis_idp_hint=vidis-idp', + // Mocked angebotLogo is base64 encoded string for a PNG + angebotLogo: + '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', + angebotTitle: 'divomath VIDIS-Testsystem', + angebotLongTitle: 'digital und verstehensorientiert Mathematik lernen (Test)', + educationProviderOrganizationName: 'divomath VIDIS-Testsystem', + schoolActivations: ['DE-VIDIS-vidis_test_30303', 'DE-VIDIS-vidis_test_20202', 'DE-VIDIS-vidis_test_101010'], + }, + { + angebotVersion: 4, + angebotDescription: 'webtown test offer', + angebotLink: '?vidis_idp_hint=vidis-idp', + // Mocked angebotLogo is base64 encoded string for a SVG + angebotLogo: + '<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than draw.io -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="978px" height="550px" viewBox="-0.5 -0.5 978 550" content="&lt;mxfile host=&quot;Electron&quot; modified=&quot;2024-11-08T15:44:36.869Z&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/24.0.4 Chrome/120.0.6099.109 Electron/28.1.0 Safari/537.36&quot; etag=&quot;1bU9vJQ02Hx0Bjpobrxc&quot; version=&quot;24.0.4&quot; type=&quot;device&quot; scale=&quot;1&quot; border=&quot;0&quot;&gt;&#10;  &lt;diagram name=&quot;Page-1&quot; id=&quot;C2YGmvy6ddPQGe2B2IIL&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1687&quot; dy=&quot;984&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;1&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1100&quot; pageHeight=&quot;850&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;HlV_pYgNxcoBrJNlkm8d-2&quot; value=&quot;&quot; style=&quot;shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;61&quot; y=&quot;150&quot; width=&quot;977.78&quot; height=&quot;550&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;" style="background-color: rgb(255, 255, 255);"><defs><style type="text/css">@font-face { font-family: "Architects Daughter"; src: url("data:application/x-font-ttf;charset=utf-8;base64,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") format("truetype"); }&#xa;</style></defs><rect fill="#ffffff" width="100%" height="100%" x="0" y="0"/><g><g><image x="-0.5" y="-0.5" width="977.78" height="550" xlink:href="data:image/png;base64,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" preserveAspectRatio="none"/></g></g></svg>', + angebotTitle: 'webtown test offer', + angebotLongTitle: 'webtown test offer', + educationProviderOrganizationName: 'VIDIS-Testangebot', + schoolActivations: ['DE-VIDIS-vidis_test_30303', 'DE-VIDIS-vidis_test_20202'], + }, +]; + +const mockAllSchoolActivationsInVidisAngebote: string[] = mockVidisAngebote.reduce( + (acc: string[], angebot: VidisAngebot) => { + return acc.concat(angebot.schoolActivations); + }, + [] as string[], +); + +const mockExistingVidisServiceProviderContainedInVidisAngebote: ServiceProvider = { + id: 'divomath VIDIS-Testsystem-dummy-UUID', + createdAt: new Date('2024-11-04 08:46:54.147+00'), + updatedAt: new Date('2024-11-04 08:46:54.147+00'), + name: 'divomath VIDIS-Testsystem', + target: ServiceProviderTarget.URL, + url: 'https://login-stage.divomath.de/idp-login?idp=vidis&vidis_idp_hint=vidis-idp', + kategorie: ServiceProviderKategorie.ANGEBOTE, + providedOnSchulstrukturknoten: 'dummy-UUID', + logo: Buffer.from('dummy-logo-string', 'base64'), + logoMimeType: 'image/svg+xml', + keycloakGroup: 'VIDIS-service', + keycloakRole: 'VIDIS-user', + externalSystem: ServiceProviderSystem.NONE, + requires2fa: false, +}; + +const mockExistingVidisServiceProviderNotInVidisAngebote: ServiceProvider = { + id: 'dummy-VIDIS-ServiceProvider-2', + createdAt: new Date('2024-11-04 08:46:54.147+00'), + updatedAt: new Date('2024-11-04 08:46:54.147+00'), + name: 'existing-dummy-VIDIS-ServiceProvider-2', + target: ServiceProviderTarget.URL, + url: 'https://dummy-url-for-VIDIS-ServiceProvider.vidis.dummy.org', + kategorie: ServiceProviderKategorie.ANGEBOTE, + providedOnSchulstrukturknoten: 'dummy-UUID', + logo: Buffer.from('dummy-logo-string', 'base64'), + logoMimeType: 'image/svg+xml', + keycloakGroup: 'VIDIS-service', + keycloakRole: 'VIDIS-user', + externalSystem: ServiceProviderSystem.NONE, + requires2fa: false, +}; + +const mockExistingServiceProviders: ServiceProvider[] = [ + mockExistingVidisServiceProviderContainedInVidisAngebote, + mockExistingVidisServiceProviderNotInVidisAngebote, +]; + +const mockExistingSchulen: Organisation[] = [ + Organisation.construct( + faker.string.uuid(), + faker.date.past(), + faker.date.recent(), + faker.number.int(), + faker.string.uuid(), + faker.string.uuid(), + 'DE-VIDIS-vidis_test_20202', + 'vidis_test_20202', + 'Keine', + 'vidis_test_20202_kuerzel', + OrganisationsTyp.SCHULE, + undefined, + 'DE-VIDIS-vidis_test_20202.vidis-example.org', + 'dummy-school-vidis-test-20202@DE-VIDIS-vidis_test_20202.vidis-example.org', + ), + Organisation.construct( + faker.string.uuid(), + faker.date.past(), + faker.date.recent(), + faker.number.int(), + faker.string.uuid(), + faker.string.uuid(), + 'DE-VIDIS-vidis_test_30303', + 'vidis_test_30303', + 'Keine', + 'vidis_test_30303_kuerzel', + OrganisationsTyp.SCHULE, + undefined, + 'DE-VIDIS-vidis_test_30303.vidis-example.org', + 'dummy-school-vidis-test-30303@DE-VIDIS-vidis_test_30303.vidis-example.org', + ), + Organisation.construct( + faker.string.uuid(), + faker.date.past(), + faker.date.recent(), + faker.number.int(), + faker.string.uuid(), + faker.string.uuid(), + 'DE-VIDIS-vidis_test_40404', + 'vidis_test_40404', + 'Keine', + 'vidis_test_40404_kuerzel', + OrganisationsTyp.SCHULE, + undefined, + 'DE-VIDIS-vidis_test_40404.vidis-example.org', + 'dummy-school-vidis-test-40404@DE-VIDIS-vidis_test_40404.vidis-example.org', + ), + Organisation.construct( + faker.string.uuid(), + faker.date.past(), + faker.date.recent(), + faker.number.int(), + faker.string.uuid(), + faker.string.uuid(), + 'DE-VIDIS-vidis_test_101010', + 'vidis_test_101010', + 'Keine', + 'vidis_test_101010_kuerzel', + OrganisationsTyp.SCHULE, + undefined, + 'DE-VIDIS-vidis_test_101010.vidis-example.org', + 'dummy-school-vidis-test-101010@DE-VIDIS-vidis_test_101010.vidis-example.org', + ), +]; // helper to mock output of some repos function getIdMap(arr: Array): Map { @@ -20,18 +184,30 @@ describe('ServiceProviderService', () => { let service: ServiceProviderService; let rolleRepo: DeepMocked; let serviceProviderRepo: DeepMocked; + let organisationRepo: DeepMocked; + let vidisService: DeepMocked; + let organisationServiceProviderRepo: DeepMocked; beforeEach(async () => { const module: TestingModule = await Test.createTestingModule({ + imports: [LoggingTestModule, ConfigTestModule], providers: [ ServiceProviderService, { provide: RolleRepo, useValue: createMock() }, { provide: ServiceProviderRepo, useValue: createMock() }, + { provide: OrganisationRepository, useValue: createMock() }, + { provide: VidisService, useValue: createMock() }, + { provide: OrganisationServiceProviderRepo, useValue: createMock() }, ], }).compile(); service = module.get(ServiceProviderService); rolleRepo = module.get>(RolleRepo); serviceProviderRepo = module.get>(ServiceProviderRepo); + organisationRepo = module.get>(OrganisationRepository); + vidisService = module.get>(VidisService); + organisationServiceProviderRepo = module.get>( + OrganisationServiceProviderRepo, + ); }); describe('getServiceProvidersByRolleIds', () => { @@ -93,4 +269,79 @@ describe('ServiceProviderService', () => { }, ); }); + + describe('updateServiceProvidersForVidis', () => { + afterEach(() => { + jest.restoreAllMocks(); + }); + + it('should update ServiceProvider for VIDIS Angebote if ServiceProvider in VIDIS Angebot response already exists in SPSH.', async () => { + vidisService.getActivatedAngeboteByRegion.mockResolvedValue(mockVidisAngebote); + organisationServiceProviderRepo.deleteAll.mockResolvedValue(true); + serviceProviderRepo.findByName.mockResolvedValue(mockExistingVidisServiceProviderContainedInVidisAngebote); + serviceProviderRepo.save.mockResolvedValue(mockExistingVidisServiceProviderContainedInVidisAngebote); + if (mockExistingSchulen[0]) organisationRepo.findByNameOrKennung.mockResolvedValue(mockExistingSchulen); + organisationServiceProviderRepo.save.mockResolvedValue(); + + await service.updateServiceProvidersForVidis(); + + expect(vidisService.getActivatedAngeboteByRegion).toHaveBeenCalledTimes(1); + expect(organisationServiceProviderRepo.deleteAll).toHaveBeenCalledTimes(1); + expect(serviceProviderRepo.findByName).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(serviceProviderRepo.save).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(organisationRepo.findByNameOrKennung).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + expect(organisationServiceProviderRepo.save).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + }); + + it('should update ServiceProvider for VIDIS Angebote if ServiceProvider in VIDIS Angebot response does not exist in SPSH yet.', async () => { + vidisService.getActivatedAngeboteByRegion.mockResolvedValue(mockVidisAngebote); + organisationServiceProviderRepo.deleteAll.mockResolvedValue(true); + serviceProviderRepo.findByName.mockResolvedValue(null); + serviceProviderRepo.save.mockResolvedValue(mockExistingVidisServiceProviderContainedInVidisAngebote); + if (mockExistingSchulen[0]) organisationRepo.findByNameOrKennung.mockResolvedValue(mockExistingSchulen); + organisationServiceProviderRepo.save.mockResolvedValue(); + + await service.updateServiceProvidersForVidis(); + + expect(vidisService.getActivatedAngeboteByRegion).toHaveBeenCalledTimes(1); + expect(organisationServiceProviderRepo.deleteAll).toHaveBeenCalledTimes(1); + expect(serviceProviderRepo.findByName).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(serviceProviderRepo.save).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(organisationRepo.findByNameOrKennung).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + expect(organisationServiceProviderRepo.save).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + }); + + it('should delete ServiceProvider for VIDIS Angebote in SPSH if ServiceProvider is not in VIDIS Angebot response.', async () => { + vidisService.getActivatedAngeboteByRegion.mockResolvedValue(mockVidisAngebote); + organisationServiceProviderRepo.deleteAll.mockResolvedValue(true); + serviceProviderRepo.findByName.mockResolvedValue(null); + serviceProviderRepo.save.mockResolvedValue(mockExistingVidisServiceProviderContainedInVidisAngebote); + if (mockExistingSchulen[0]) organisationRepo.findByNameOrKennung.mockResolvedValue(mockExistingSchulen); + organisationServiceProviderRepo.save.mockResolvedValue(); + serviceProviderRepo.findByKeycloakGroup.mockResolvedValue(mockExistingServiceProviders); + serviceProviderRepo.deleteById.mockResolvedValue(true); + + await service.updateServiceProvidersForVidis(); + + expect(vidisService.getActivatedAngeboteByRegion).toHaveBeenCalledTimes(1); + expect(organisationServiceProviderRepo.deleteAll).toHaveBeenCalledTimes(1); + expect(serviceProviderRepo.findByName).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(serviceProviderRepo.save).toHaveBeenCalledTimes(mockVidisAngebote.length); + expect(organisationRepo.findByNameOrKennung).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + expect(organisationServiceProviderRepo.save).toHaveBeenCalledTimes( + mockAllSchoolActivationsInVidisAngebote.length, + ); + expect(serviceProviderRepo.deleteById).toHaveBeenCalledTimes(1); + }); + }); }); diff --git a/src/modules/service-provider/domain/service-provider.service.ts b/src/modules/service-provider/domain/service-provider.service.ts index d78c602f5..c4777c254 100644 --- a/src/modules/service-provider/domain/service-provider.service.ts +++ b/src/modules/service-provider/domain/service-provider.service.ts @@ -4,13 +4,32 @@ import { Rolle } from '../../rolle/domain/rolle.js'; import { RolleRepo } from '../../rolle/repo/rolle.repo.js'; import { ServiceProviderRepo } from '../repo/service-provider.repo.js'; import { ServiceProvider } from './service-provider.js'; +import { ClassLogger } from '../../../core/logging/class-logger.js'; +import { VidisService } from '../../vidis/vidis.service.js'; +import { ServiceProviderTarget, ServiceProviderKategorie, ServiceProviderSystem } from './service-provider.enum.js'; +import { OrganisationRepository } from '../../organisation/persistence/organisation.repository.js'; +import { Organisation } from '../../organisation/domain/organisation.js'; +import { OrganisationServiceProviderRepo } from '../repo/organisation-service-provider.repo.js'; +import { ConfigService } from '@nestjs/config'; +import { ServerConfig } from '../../../shared/config/server.config.js'; +import { VidisConfig } from '../../../shared/config/vidis.config.js'; +import { VidisAngebot } from '../../vidis/domain/vidis-angebot.js'; @Injectable() export class ServiceProviderService { + private readonly vidisConfig: VidisConfig; + public constructor( + private readonly logger: ClassLogger, private readonly rolleRepo: RolleRepo, private readonly serviceProviderRepo: ServiceProviderRepo, - ) {} + private readonly organisationRepo: OrganisationRepository, + private readonly vidisService: VidisService, + private readonly organisationServiceProviderRepo: OrganisationServiceProviderRepo, + configService: ConfigService, + ) { + this.vidisConfig = configService.getOrThrow('VIDIS'); + } public async getServiceProvidersByRolleIds(rolleIds: string[]): Promise[]> { const rollen: Map> = await this.rolleRepo.findByIds(rolleIds); @@ -23,4 +42,117 @@ export class ServiceProviderService { return Array.from(serviceProviders.values()); } + + public async updateServiceProvidersForVidis(): Promise { + this.logger.info('Aktualisierung der ServiceProvider für VIDIS-Angebote wurde gestartet.'); + + const vidisKeycloakGroup: string = this.vidisConfig.KEYCLOAK_GROUP; + const vidisKeycloakRole: string = this.vidisConfig.KEYCLOAK_ROLE; + const vidisRegionName: string = this.vidisConfig.REGION_NAME; + const schulstrukturknoten: string = this.organisationRepo.ROOT_ORGANISATION_ID; + + const vidisAngebote: VidisAngebot[] = await this.vidisService.getActivatedAngeboteByRegion(vidisRegionName); + + const allMappingsBeenDeleted: boolean = await this.organisationServiceProviderRepo.deleteAll(); + if (allMappingsBeenDeleted) + this.logger.info('All mappings between Organisation and ServiceProvider were deleted.'); + + await Promise.allSettled( + vidisAngebote.map(async (angebot: VidisAngebot) => { + const existingServiceProvider: Option> = + await this.serviceProviderRepo.findByName(angebot.angebotTitle); + + const angebotLogoMediaType: string = this.determineMediaTypeFor(angebot.angebotLogo); + + let serviceProvider: ServiceProvider; + if (existingServiceProvider) { + serviceProvider = ServiceProvider.construct( + existingServiceProvider.id, + existingServiceProvider.createdAt, + existingServiceProvider.updatedAt, + angebot.angebotTitle, + ServiceProviderTarget.URL, + angebot.angebotLink, + ServiceProviderKategorie.ANGEBOTE, + schulstrukturknoten, + Buffer.from(angebot.angebotLogo, 'base64'), + angebotLogoMediaType, + vidisKeycloakGroup, + vidisKeycloakRole, + ServiceProviderSystem.NONE, + false, + ); + this.logger.info(`ServiceProvider for VIDIS Angebot '${serviceProvider.name}' already exists.`); + } else { + serviceProvider = ServiceProvider.createNew( + angebot.angebotTitle, + ServiceProviderTarget.URL, + angebot.angebotLink, + ServiceProviderKategorie.ANGEBOTE, + schulstrukturknoten, + Buffer.from(angebot.angebotLogo, 'base64'), + angebotLogoMediaType, + vidisKeycloakGroup, + vidisKeycloakRole, + ServiceProviderSystem.NONE, + false, + ); + this.logger.info(`ServiceProvider for VIDIS Angebot '${serviceProvider.name}' was created.`); + } + const persistedServiceProvider: ServiceProvider = + await this.serviceProviderRepo.save(serviceProvider); + await Promise.allSettled( + angebot.schoolActivations.map(async (schoolActivation: string) => { + const orga: Organisation | undefined = ( + await this.organisationRepo.findByNameOrKennung(schoolActivation) + ).at(0); // Assumption: kennung is unique for an Organisation and is not contained in name or kennung of any other Organisation + if (orga) { + await this.organisationServiceProviderRepo.save(orga, persistedServiceProvider); + this.logger.info(`Mapping of '${serviceProvider.name}' to '${orga.name}' was saved.`); + } + }), + ); + }), + ); + + const vidisServiceProviders: ServiceProvider[] = + await this.serviceProviderRepo.findByKeycloakGroup(vidisKeycloakGroup); + const angeboteNamesInResponse: string[] = vidisAngebote.map((angebot: VidisAngebot) => angebot.angebotTitle); + await Promise.allSettled( + vidisServiceProviders.map(async (vsp: ServiceProvider) => { + if (!angeboteNamesInResponse.includes(vsp.name)) { + await this.serviceProviderRepo.deleteById(vsp.id); + this.logger.info( + `ServiceProvider '${vsp.name}' was deleted as it was not in VIDIS Angebote API response.`, + ); + } + }), + ); + + this.logger.info(`ServiceProvider für VIDIS-Angebote erfolgreich aktualisiert.`); + } + + /** + * Determines the correct media type of the given Angebot logo. + * Assumption: Expected media type is always one of the three: 'image/jpeg', 'image/png' or 'image/svg+xml'. + * @param {base64EncodedLogo} base64EncodedLogo Base64 encoded logo + */ + private determineMediaTypeFor(base64EncodedLogo: string): string { + const MEDIA_SIGNATURES: { JPG: Buffer; PNG: Buffer } = { + // JPG/JPEG file signature in hexadeciaml begins with: ff d8 ff + JPG: Buffer.from([0xff, 0xd8, 0xff]), + // PNG file signature in hexadeciaml begins with: 89 50 4e 47 0d 0a 1a 0a + PNG: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), + }; + + const logoBuffer: Buffer = Buffer.from(base64EncodedLogo, 'base64'); + + const first8Bytes: Buffer = logoBuffer.subarray(0, 8); + if (first8Bytes.equals(MEDIA_SIGNATURES.PNG)) return 'image/png'; + + const first3Bytes: Buffer = logoBuffer.subarray(0, 3); + if (first3Bytes.equals(MEDIA_SIGNATURES.JPG)) return 'image/jpeg'; + + return 'image/svg+xml'; + } } diff --git a/src/modules/service-provider/repo/organisation-service-provider.entity.ts b/src/modules/service-provider/repo/organisation-service-provider.entity.ts new file mode 100644 index 000000000..833f730c2 --- /dev/null +++ b/src/modules/service-provider/repo/organisation-service-provider.entity.ts @@ -0,0 +1,14 @@ +import { BaseEntity, Entity, ManyToOne, PrimaryKeyProp, Rel } from '@mikro-orm/core'; +import { ServiceProviderEntity } from './service-provider.entity.js'; +import { OrganisationEntity } from '../../organisation/persistence/organisation.entity.js'; + +@Entity({ tableName: 'organisation_service_provider' }) +export class OrganisationServiceProviderEntity extends BaseEntity { + @ManyToOne({ primary: true, entity: () => OrganisationEntity }) + public organisation!: Rel; + + @ManyToOne({ primary: true, entity: () => ServiceProviderEntity }) + public serviceProvider!: Rel; + + public [PrimaryKeyProp]?: ['organisation', 'serviceProvider']; +} diff --git a/src/modules/service-provider/repo/organisation-service-provider.repo.integration-spec.ts b/src/modules/service-provider/repo/organisation-service-provider.repo.integration-spec.ts new file mode 100644 index 000000000..d87a2c611 --- /dev/null +++ b/src/modules/service-provider/repo/organisation-service-provider.repo.integration-spec.ts @@ -0,0 +1,99 @@ +import { MikroORM, EntityManager } from '@mikro-orm/core'; +import { TestingModule, Test } from '@nestjs/testing'; +import { + ConfigTestModule, + DatabaseTestModule, + LoggingTestModule, + DEFAULT_TIMEOUT_FOR_TESTCONTAINERS, + DoFactory, +} from '../../../../test/utils/index.js'; +import { OrganisationServiceProviderRepo } from './organisation-service-provider.repo.js'; +import { Organisation } from '../../organisation/domain/organisation.js'; +import { ServiceProvider } from '../domain/service-provider.js'; +import { OrganisationRepository } from '../../organisation/persistence/organisation.repository.js'; +import { ServiceProviderRepo } from './service-provider.repo.js'; +import { EventService } from '../../../core/eventbus/services/event.service.js'; +import { createMock } from '@golevelup/ts-jest'; + +describe('OrganisationServiceProviderRepo', () => { + let module: TestingModule; + let sut: OrganisationServiceProviderRepo; + let organisationRepo: OrganisationRepository; + let serviceProviderRepo: ServiceProviderRepo; + + let orm: MikroORM; + let em: EntityManager; + + beforeAll(async () => { + module = await Test.createTestingModule({ + imports: [ConfigTestModule, DatabaseTestModule.forRoot({ isDatabaseRequired: true }), LoggingTestModule], + providers: [ + OrganisationServiceProviderRepo, + OrganisationRepository, + ServiceProviderRepo, + { + provide: EventService, + useValue: createMock(), + }, + ], + }).compile(); + + sut = module.get(OrganisationServiceProviderRepo); + organisationRepo = module.get(OrganisationRepository); + serviceProviderRepo = module.get(ServiceProviderRepo); + orm = module.get(MikroORM); + em = module.get(EntityManager); + + await DatabaseTestModule.setupDatabase(orm); + }, DEFAULT_TIMEOUT_FOR_TESTCONTAINERS); + + afterAll(async () => { + await orm.close(); + await module.close(); + }); + + beforeEach(async () => { + await DatabaseTestModule.clearDatabase(orm); + }); + + it('should be defined', () => { + expect(sut).toBeDefined(); + expect(organisationRepo).toBeDefined(); + expect(serviceProviderRepo).toBeDefined(); + expect(em).toBeDefined(); + }); + + describe('save', () => { + it('should save a new OrganisationServiceProvider mapping', async () => { + const organisation: Organisation = DoFactory.createOrganisation(false); + const serviceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedOrganisation: Organisation = await organisationRepo.save(organisation); + const persistedServiceProvider: ServiceProvider = await serviceProviderRepo.save(serviceProvider); + + await expect(sut.save(persistedOrganisation, persistedServiceProvider)).resolves.not.toThrow(); + }); + }); + + describe('deleteAll', () => { + it('should delete all existing OrganisationServiceProvider mappings', async () => { + const organisation: Organisation = DoFactory.createOrganisation(false); + const persistedOrganisation: Organisation = await organisationRepo.save(organisation); + const organisation2: Organisation = DoFactory.createOrganisation(false); + const persistedOrganisation2: Organisation = await organisationRepo.save(organisation2); + const serviceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedServiceProvider: ServiceProvider = await serviceProviderRepo.save(serviceProvider); + const serviceProvider2: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedServiceProvider2: ServiceProvider = await serviceProviderRepo.save(serviceProvider2); + const serviceProvider3: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedServiceProvider3: ServiceProvider = await serviceProviderRepo.save(serviceProvider3); + await sut.save(persistedOrganisation, persistedServiceProvider); + await sut.save(persistedOrganisation, persistedServiceProvider2); + await sut.save(persistedOrganisation2, persistedServiceProvider2); + await sut.save(persistedOrganisation2, persistedServiceProvider3); + + const result: boolean = await sut.deleteAll(); + + expect(result).toBeTruthy(); + }); + }); +}); diff --git a/src/modules/service-provider/repo/organisation-service-provider.repo.ts b/src/modules/service-provider/repo/organisation-service-provider.repo.ts new file mode 100644 index 000000000..f964bd806 --- /dev/null +++ b/src/modules/service-provider/repo/organisation-service-provider.repo.ts @@ -0,0 +1,33 @@ +import { Injectable } from '@nestjs/common'; +import { Organisation } from '../../organisation/domain/organisation.js'; +import { ServiceProvider } from '../domain/service-provider.js'; +import { EntityManager, RequiredEntityData } from '@mikro-orm/postgresql'; +import { OrganisationServiceProviderEntity } from './organisation-service-provider.entity.js'; + +@Injectable() +export class OrganisationServiceProviderRepo { + public constructor(private readonly em: EntityManager) {} + + public async save(organisation: Organisation, serviceProvider: ServiceProvider): Promise { + await this.create(organisation, serviceProvider); + } + + private async create(organisation: Organisation, serviceProvider: ServiceProvider): Promise { + const entityData: RequiredEntityData = { + organisation: organisation.id, + serviceProvider: serviceProvider.id, + }; + + const organisationServiceProviderEntity: OrganisationServiceProviderEntity = this.em.create( + OrganisationServiceProviderEntity, + entityData, + ); + + await this.em.persistAndFlush(organisationServiceProviderEntity); + } + + public async deleteAll(): Promise { + const deletedMappings: number = await this.em.nativeDelete(OrganisationServiceProviderEntity, {}); + return deletedMappings > 0; + } +} diff --git a/src/modules/service-provider/repo/service-provider.repo.spec.ts b/src/modules/service-provider/repo/service-provider.repo.integration-spec.ts similarity index 76% rename from src/modules/service-provider/repo/service-provider.repo.spec.ts rename to src/modules/service-provider/repo/service-provider.repo.integration-spec.ts index 935abbbf6..7134bdbe8 100644 --- a/src/modules/service-provider/repo/service-provider.repo.spec.ts +++ b/src/modules/service-provider/repo/service-provider.repo.integration-spec.ts @@ -180,6 +180,47 @@ describe('ServiceProviderRepo', () => { expect(serviceProviderMap).toBeDefined(); }); }); + + describe('findByName', () => { + it('should find a ServiceProvider by its name if a ServiceProvider with the given name exists', async () => { + const expectedServiceProvider: ServiceProvider = await sut.save( + DoFactory.createServiceProvider(false), + ); + + const actualServiceProvider: Option> = await sut.findByName( + expectedServiceProvider.name, + ); + + expect(actualServiceProvider).toEqual(expectedServiceProvider); + }); + + it('should throw an error if there are no existing ServiceProviders for the given name', async () => { + await sut.save(DoFactory.createServiceProvider(false)); + + const result: Option> = await sut.findByName('this-service-provider-does-not-exist'); + + expect(result).toBeFalsy(); + }); + }); + + describe('findByKeycloakGroup', () => { + it('should find a ServiceProvider by its Keycloak groupname', async () => { + const expectedServiceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + expectedServiceProvider.keycloakGroup = 'keycloak-group-1'; + const expectedPersistedServiceProvider: ServiceProvider = await sut.save(expectedServiceProvider); + const anotherServiceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + anotherServiceProvider.keycloakGroup = 'keycloak-group-2'; + await sut.save(anotherServiceProvider); + + let result: ServiceProvider[] = []; + if (expectedServiceProvider.keycloakGroup) { + result = await sut.findByKeycloakGroup(expectedServiceProvider.keycloakGroup); + } + + expect(result).toEqual([expectedPersistedServiceProvider]); + }); + }); + describe('fetchRolleServiceProvidersWithoutPerson', () => { it('should define serviceProviderResult', async () => { const role: RolleID = faker.string.uuid(); @@ -218,4 +259,26 @@ describe('ServiceProviderRepo', () => { ); }); }); + + describe('deleteById', () => { + it('should delete an existing ServiceProvider by its id', async () => { + const serviceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedPersistedServiceProvider: ServiceProvider = await sut.save(serviceProvider); + + const result: boolean = await sut.deleteById(persistedPersistedServiceProvider.id); + + expect(result).toBeTruthy(); + }); + }); + + describe('deleteByName', () => { + it('should delete an existing ServiceProvider by its name', async () => { + const serviceProvider: ServiceProvider = DoFactory.createServiceProvider(false); + const persistedPersistedServiceProvider: ServiceProvider = await sut.save(serviceProvider); + + const result: boolean = await sut.deleteByName(persistedPersistedServiceProvider.name); + + expect(result).toBeTruthy(); + }); + }); }); diff --git a/src/modules/service-provider/repo/service-provider.repo.ts b/src/modules/service-provider/repo/service-provider.repo.ts index bff91e3e4..90e84dfd1 100644 --- a/src/modules/service-provider/repo/service-provider.repo.ts +++ b/src/modules/service-provider/repo/service-provider.repo.ts @@ -74,6 +74,24 @@ export class ServiceProviderRepo { return serviceProvider && mapEntityToAggregate(serviceProvider); } + public async findByName(name: string): Promise>> { + const serviceProvider: Option = await this.em.findOne(ServiceProviderEntity, { + name: name, + }); + if (serviceProvider) { + return mapEntityToAggregate(serviceProvider); + } + + return null; + } + + public async findByKeycloakGroup(groupname: string): Promise[]> { + const serviceProviders: ServiceProviderEntity[] = await this.em.find(ServiceProviderEntity, { + keycloakGroup: groupname, + }); + return serviceProviders.map(mapEntityToAggregate); + } + public async find(options?: ServiceProviderFindOptions): Promise[]> { const exclude: readonly ['logo'] | undefined = options?.withLogo ? undefined : ['logo']; @@ -160,4 +178,14 @@ export class ServiceProviderRepo { return serviceProviders; } + + public async deleteById(id: string): Promise { + const deletedPersons: number = await this.em.nativeDelete(ServiceProviderEntity, { id }); + return deletedPersons > 0; + } + + public async deleteByName(name: string): Promise { + const deletedPersons: number = await this.em.nativeDelete(ServiceProviderEntity, { name: name }); + return deletedPersons > 0; + } } diff --git a/src/modules/service-provider/service-provider.module.ts b/src/modules/service-provider/service-provider.module.ts index 908368306..fe0947396 100644 --- a/src/modules/service-provider/service-provider.module.ts +++ b/src/modules/service-provider/service-provider.module.ts @@ -7,6 +7,9 @@ import { ServiceProviderFactory } from './domain/service-provider.factory.js'; import { ServiceProviderService } from './domain/service-provider.service.js'; import { CreateGroupAndRoleHandler } from './repo/service-provider-event-handler.js'; import { ServiceProviderRepo } from './repo/service-provider.repo.js'; +import { VidisModule } from '../vidis/vidis.module.js'; +import { OrganisationModule } from '../organisation/organisation.module.js'; +import { OrganisationServiceProviderRepo } from './repo/organisation-service-provider.repo.js'; @Module({ imports: [ @@ -14,8 +17,16 @@ import { ServiceProviderRepo } from './repo/service-provider.repo.js'; KeycloakAdministrationModule, EventModule, forwardRef(() => RolleModule), + VidisModule, + OrganisationModule, + ], + providers: [ + ServiceProviderRepo, + ServiceProviderFactory, + ServiceProviderService, + CreateGroupAndRoleHandler, + OrganisationServiceProviderRepo, ], - providers: [ServiceProviderRepo, ServiceProviderFactory, ServiceProviderService, CreateGroupAndRoleHandler], exports: [ServiceProviderRepo, ServiceProviderFactory, ServiceProviderService], }) export class ServiceProviderModule {} diff --git a/src/modules/vidis/api/vidis-angebote-api.types.ts b/src/modules/vidis/api/vidis-angebote-api.types.ts new file mode 100644 index 000000000..e3f8cd2ad --- /dev/null +++ b/src/modules/vidis/api/vidis-angebote-api.types.ts @@ -0,0 +1,49 @@ +export type VidisOfferCategoriesResponse = { + category: string[]; + competency: string[]; + gradeLevel: string[]; + schoolType: string[]; +}; + +export type VidisOfferResponse = { + offerId?: number; + offerVersion: number; + offerDescription: string; + offerLink: string; + offerLogo: string; + offerTitle: string; + offerLongTitle: string; + offerResourcePk?: number; + offerStatus?: string; + offerKategorien?: VidisOfferCategoriesResponse; + educationProviderOrganizationId?: number; + educationProviderOrganizationName: string; + educationProviderUserEmail?: string; + educationProviderUserId?: number; + educationProviderUserName?: string; + schoolActivations: string[]; +}; + +type ActionProperty = { + [key: string]: string; +}; + +type Actions = { + [key: string]: ActionProperty; +}; + +export type VidisResponse = { + facets: { + facetCriteria: string; + facetValues: { + numberOfOccurrences: number; + term: string; + }[]; + }[]; + lastPage: number; + totalCount: number; + pageSize: number; + actions: Actions; + page: number; + items: T[]; +}; diff --git a/src/modules/vidis/domain/vidis-angebot.ts b/src/modules/vidis/domain/vidis-angebot.ts new file mode 100644 index 000000000..4c0fe69b6 --- /dev/null +++ b/src/modules/vidis/domain/vidis-angebot.ts @@ -0,0 +1,25 @@ +export type VidisAngebotKategorie = { + category: string[]; + competency: string[]; + gradeLevel: string[]; + schoolType: string[]; +}; + +export type VidisAngebot = { + angebotId?: number; + angebotVersion: number; + angebotDescription: string; + angebotLink: string; + angebotLogo: string; + angebotTitle: string; + angebotLongTitle: string; + angebotResourcePk?: number; + angebotStatus?: string; + angebotKategorien?: VidisAngebotKategorie; + educationProviderOrganizationId?: number; + educationProviderOrganizationName: string; + educationProviderUserEmail?: string; + educationProviderUserId?: number; + educationProviderUserName?: string; + schoolActivations: string[]; +}; diff --git a/src/modules/vidis/vidis.module.ts b/src/modules/vidis/vidis.module.ts new file mode 100644 index 000000000..55dd5d4ae --- /dev/null +++ b/src/modules/vidis/vidis.module.ts @@ -0,0 +1,11 @@ +import { Module } from '@nestjs/common'; +import { VidisService } from './vidis.service.js'; +import { HttpModule } from '@nestjs/axios'; +import { LoggerModule } from '../../core/logging/logger.module.js'; + +@Module({ + imports: [LoggerModule.register(VidisModule.name), HttpModule], + providers: [VidisService], + exports: [VidisService], +}) +export class VidisModule {} diff --git a/src/modules/vidis/vidis.service.spec.ts b/src/modules/vidis/vidis.service.spec.ts new file mode 100644 index 000000000..c39910458 --- /dev/null +++ b/src/modules/vidis/vidis.service.spec.ts @@ -0,0 +1,131 @@ +import { DeepMocked, createMock } from '@golevelup/ts-jest'; +import { HttpService } from '@nestjs/axios'; +import { TestingModule, Test } from '@nestjs/testing'; +import { VidisService } from './vidis.service.js'; +import { VidisOfferResponse, VidisResponse } from './api/vidis-angebote-api.types.js'; +import { Observable, of } from 'rxjs'; +import { AxiosResponse } from 'axios'; +import { ConfigTestModule } from '../../../test/utils/config-test.module.js'; +import { VidisAngebot } from './domain/vidis-angebot.js'; +import { LoggingTestModule } from '../../../test/utils/logging-test.module.js'; + +const mockVidisRegionName: string = 'test-region'; + +const mockVidisAngebotResponses: VidisOfferResponse[] = [ + { + offerVersion: 1, + offerDescription: + 'Effiziente Organisation Ihrer Hausaufgaben mit der neuen Hausaufgaben Listen App Verlieren Sie nie wieder den Überblick über Ihre Aufgaben und Abgabefristen. Unsere Hausaufgaben Listen App bietet Ihnen eine strukturierte und benutzerfreundliche Lösung, um Ihre schulischen Verpflichtungen optimal zu verwalten. Funktionen der App: Übersichtliche Verwaltung: Behalten Sie alle Hausaufgaben, Projekte und To-Dos an einem zentralen Ort im Blick. Erinnerungsfunktion: Automatische Benachrichtigungen helfen Ihnen, keine Fristen mehr zu verpassen. Einfache Bedienung: Intuitive Benutzeroberfläche, die eine schnelle und unkomplizierte Nutzung ermöglicht. Kollaborationsmöglichkeit: Teilen Sie Aufgaben und Projekte mit Mitschülern, um effizienter zusammenzuarbeiten. Anpassbare Listen: Erstellen Sie individuelle Kategorien und Listen nach Ihren Bedürfnissen. Fortschrittsanzeige: Verfolgen Sie Ihre erledigten Aufgaben und sehen Sie Ihren Fortschritt in Echtzeit. Unsere Hausaufgaben Listen App ist kostenlos verfügbar und bietet Ihnen eine verlässliche Unterstützung bei der Organisation Ihres Schulalltags.', + offerLink: 'https://vidis-login-example.buergercloud.de/oauth2/authorization/vidis?vidis_idp_hint=vidis-idp', + offerLogo: 'dummy-string', + offerTitle: 'Hausaufgaben-Liste', + offerLongTitle: 'Testangebot Hausaufgaben-Liste', + educationProviderOrganizationName: 'VIDIS-Testangebot', + schoolActivations: ['DE-VIDIS-vidis_test_20202', 'DE-VIDIS-vidis_test_40404', 'DE-VIDIS-vidis_test_101010'], + }, + { + offerVersion: 1, + offerDescription: + 'divomath ist eine Lernumgebung für Mathematik, die insbesondere dem Prinzip der Verstehensorientierung folgt. Sie bietet Unterrichtseinheiten für die dritte bis sechste Jahrgangsstufe.', + offerLink: 'https://login-stage.divomath.de/idp-login?idp=vidis&vidis_idp_hint=vidis-idp', + offerLogo: 'dummy-string', + offerTitle: 'divomath VIDIS-Testsystem', + offerLongTitle: 'digital und verstehensorientiert Mathematik lernen (Test)', + educationProviderOrganizationName: 'divomath VIDIS-Testsystem', + schoolActivations: ['DE-VIDIS-vidis_test_30303', 'DE-VIDIS-vidis_test_20202', 'DE-VIDIS-vidis_test_101010'], + }, + { + offerVersion: 4, + offerDescription: 'webtown test offer', + offerLink: '?vidis_idp_hint=vidis-idp', + offerLogo: 'dummy-string', + offerTitle: 'webtown test offer', + offerLongTitle: 'webtown test offer', + educationProviderOrganizationName: 'VIDIS-Testangebot', + schoolActivations: ['DE-VIDIS-vidis_test_30303', 'DE-VIDIS-vidis_test_20202'], + }, +]; + +const mockVidisResponse: VidisResponse = { + facets: [ + { + facetCriteria: '', + facetValues: [ + { + numberOfOccurrences: 0, + term: '', + }, + ], + }, + ], + lastPage: 1, + totalCount: 3, + pageSize: 20, + actions: {}, + page: 1, + items: mockVidisAngebotResponses, +}; + +const mockVidisAxiosResponse = (): Observable => + of({ data: mockVidisResponse } as AxiosResponse>); + +describe(`VidisService`, () => { + let sut: VidisService; + let httpServiceMock: DeepMocked; + + beforeEach(async () => { + const module: TestingModule = await Test.createTestingModule({ + imports: [ConfigTestModule, LoggingTestModule], + providers: [VidisService, { provide: HttpService, useValue: createMock() }], + }).compile(); + + sut = module.get(VidisService); + httpServiceMock = module.get(HttpService); + }); + + describe(`getActivatedAngeboteByRegion`, () => { + it(`should get the activated VIDIS Angebote by region from the VIDIS Angebot API if no errors occur`, async () => { + httpServiceMock.get.mockReturnValueOnce(mockVidisAxiosResponse()); + const expectedVidisOfferResponse: VidisOfferResponse[] = mockVidisAngebotResponses; + const expectedVidisAngebote: VidisAngebot[] = expectedVidisOfferResponse.map( + (offer: VidisOfferResponse) => { + return { + angebotVersion: offer.offerVersion, + angebotDescription: offer.offerDescription, + angebotLink: offer.offerLink, + angebotLogo: offer.offerLogo, + angebotTitle: offer.offerTitle, + angebotLongTitle: offer.offerLongTitle, + educationProviderOrganizationName: offer.educationProviderOrganizationName, + schoolActivations: offer.schoolActivations, + }; + }, + ); + + const actualVidisAngebote: VidisAngebot[] = await sut.getActivatedAngeboteByRegion(mockVidisRegionName); + + expect(actualVidisAngebote).toEqual(expectedVidisAngebote); + }); + + it(`should throw an error if getActivatedAngeboteByRegion throws an Error object`, async () => { + httpServiceMock.get.mockImplementation(() => { + throw new Error('Error when getting VIDIS Angebote.'); + }); + + await expect(sut.getActivatedAngeboteByRegion(mockVidisRegionName)).rejects.toThrow( + `Error getting all VIDIS Angebote: Error when getting VIDIS Angebote.`, + ); + }); + + it(`should throw an error if getActivatedAngeboteByRegion throws a non-Error object`, async () => { + httpServiceMock.get.mockImplementation(() => { + // eslint-disable-next-line @typescript-eslint/no-throw-literal + throw 'This is a non-Error throw'; + }); + + await expect(sut.getActivatedAngeboteByRegion(mockVidisRegionName)).rejects.toThrow( + `Error getting all VIDIS Angebote: Unknown error occurred`, + ); + }); + }); +}); diff --git a/src/modules/vidis/vidis.service.ts b/src/modules/vidis/vidis.service.ts new file mode 100644 index 000000000..59c22a076 --- /dev/null +++ b/src/modules/vidis/vidis.service.ts @@ -0,0 +1,58 @@ +import { HttpService } from '@nestjs/axios'; +import { AxiosResponse } from 'axios'; +import { Injectable } from '@nestjs/common'; +import { VidisConfig } from '../../shared/config/vidis.config.js'; +import { firstValueFrom } from 'rxjs'; +import { VidisOfferResponse, VidisResponse } from './api/vidis-angebote-api.types.js'; +import { VidisAngebot } from './domain/vidis-angebot.js'; +import { ServerConfig } from '../../shared/config/server.config.js'; +import { ConfigService } from '@nestjs/config'; +import { ClassLogger } from '../../core/logging/class-logger.js'; + +@Injectable() +export class VidisService { + private readonly vidisConfig: VidisConfig; + + public constructor( + private readonly httpService: HttpService, + configService: ConfigService, + private readonly logger: ClassLogger, + ) { + this.vidisConfig = configService.getOrThrow('VIDIS'); + } + + public async getActivatedAngeboteByRegion(regionName: string): Promise { + const url: string = this.vidisConfig.BASE_URL + `/o/vidis-rest/v1.0/offers/activated/by-region/${regionName}`; + this.logger.info(`Fetching activated Angebote for region: ${regionName}`); + try { + const response: AxiosResponse> = await firstValueFrom( + this.httpService.get(url, { + auth: { + username: this.vidisConfig.USERNAME, + password: this.vidisConfig.PASSWORD, + }, + }), + ); + const vidisOfferResponses: VidisOfferResponse[] = response.data.items; + const vidisAngebote: VidisAngebot[] = vidisOfferResponses.map((offer: VidisOfferResponse) => { + return { + angebotVersion: offer.offerVersion, + angebotDescription: offer.offerDescription, + angebotLink: offer.offerLink, + angebotLogo: offer.offerLogo, + angebotTitle: offer.offerTitle, + angebotLongTitle: offer.offerLongTitle, + educationProviderOrganizationName: offer.educationProviderOrganizationName, + schoolActivations: offer.schoolActivations, + }; + }); + return vidisAngebote; + } catch (error) { + if (error instanceof Error) { + throw new Error(`Error getting all VIDIS Angebote: ${error.message}`); + } else { + throw new Error(`Error getting all VIDIS Angebote: Unknown error occurred`); + } + } + } +} diff --git a/src/server/server.module.spec.ts b/src/server/server.module.spec.ts index d1c0c46e8..ac62426db 100644 --- a/src/server/server.module.spec.ts +++ b/src/server/server.module.spec.ts @@ -5,7 +5,7 @@ import { OIDC_CLIENT } from '../modules/authentication/services/oidc-client.serv import { MiddlewareConsumer } from '@nestjs/common'; import { createMock } from '@golevelup/ts-jest'; import { RedisClientType } from 'redis'; -import { ConfigTestModule } from '../../test/utils/index.js'; +import { ConfigTestModule, LoggingTestModule } from '../../test/utils/index.js'; jest.mock('redis', () => ({ createClient: (): RedisClientType => createMock(), @@ -16,7 +16,7 @@ describe('ServerModule', () => { beforeAll(async () => { module = await Test.createTestingModule({ - imports: [ServerModule, ConfigTestModule], + imports: [ServerModule, ConfigTestModule, LoggingTestModule], }) .overrideProvider(OIDC_CLIENT) .useValue( diff --git a/src/server/server.module.ts b/src/server/server.module.ts index 9b38a9683..45bf7ec8b 100644 --- a/src/server/server.module.ts +++ b/src/server/server.module.ts @@ -38,6 +38,7 @@ import { KeycloakHandlerModule } from '../modules/keycloak-handler/keycloak-hand import { CronModule } from '../modules/cron/cron.module.js'; import { ImportApiModule } from '../modules/import/import-api.module.js'; import { StatusModule } from '../modules/status/status.module.js'; +import { VidisModule } from '../modules/vidis/vidis.module.js'; @Module({ imports: [ @@ -98,6 +99,7 @@ import { StatusModule } from '../modules/status/status.module.js'; CronModule, ImportApiModule, StatusModule, + VidisModule, ], providers: [ { diff --git a/src/shared/config/config.env.ts b/src/shared/config/config.env.ts index 074f295f4..28f89be36 100644 --- a/src/shared/config/config.env.ts +++ b/src/shared/config/config.env.ts @@ -8,6 +8,7 @@ import { PrivacyIdeaConfig } from './privacyidea.config.js'; import { SystemConfig } from './system.config.js'; import { OxConfig } from './ox.config.js'; import { RedisConfig } from './redis.config.js'; +import { VidisConfig } from './vidis.config.js'; export type Config = { DB: Partial; @@ -20,6 +21,7 @@ export type Config = { PRIVACYIDEA: Partial; OX: Partial; SYSTEM: Partial; + VIDIS: Partial; }; export default (): Config => ({ @@ -83,4 +85,12 @@ export default (): Config => ({ : undefined, STEP_UP_TIMEOUT_ENABLED: process.env['SYSTEM_STEP_UP_TIMEOUT_ENABLED']?.toLowerCase() as 'true' | 'false', }, + VIDIS: { + BASE_URL: process.env['VIDIS_BASE_URL'], + USERNAME: process.env['VIDIS_USERNAME'], + PASSWORD: process.env['VIDIS_PASSWORD'], + REGION_NAME: process.env['VIDIS_REGION_NAME'], + KEYCLOAK_GROUP: process.env['VIDIS_KEYCLOAK_GROUP'], + KEYCLOAK_ROLE: process.env['VIDIS_KEYCLOAK_ROLE'], + }, }); diff --git a/src/shared/config/config.loader.spec.ts b/src/shared/config/config.loader.spec.ts index 9fa1dcd1a..68bee3352 100644 --- a/src/shared/config/config.loader.spec.ts +++ b/src/shared/config/config.loader.spec.ts @@ -69,6 +69,14 @@ describe('configloader', () => { USER_RESOLVER: 'mariadb_resolver', REALM: 'defrealm', }, + VIDIS: { + BASE_URL: 'dummy-url', + USERNAME: 'dummy-username', + PASSWORD: 'dummy-password', + REGION_NAME: 'dummy-region', + KEYCLOAK_GROUP: 'VIDIS-service', + KEYCLOAK_ROLE: 'VIDIS-user', + }, OX: { ENABLED: 'true', ENDPOINT: 'https://ox_ip:ox_port/webservices/OXUserService', @@ -190,6 +198,14 @@ describe('configloader', () => { USER_RESOLVER: 'mariadb_resolver', REALM: 'defrealm', }, + VIDIS: { + BASE_URL: 'dummy-url', + USERNAME: 'dummy-username', + PASSWORD: 'dummy-password', + REGION_NAME: 'dummy-region', + KEYCLOAK_GROUP: 'VIDIS-service', + KEYCLOAK_ROLE: 'VIDIS-user', + }, OX: { ENABLED: 'true', ENDPOINT: 'https://ox_ip:ox_port/webservices/OXUserService', diff --git a/src/shared/config/index.ts b/src/shared/config/index.ts index f92064ab8..4242b501a 100644 --- a/src/shared/config/index.ts +++ b/src/shared/config/index.ts @@ -10,3 +10,4 @@ export * from './server.config.js'; export * from './itslearning.config.js'; export * from './privacyidea.config.js'; export * from './system.config.js'; +export * from './vidis.config.js'; diff --git a/src/shared/config/json.config.ts b/src/shared/config/json.config.ts index 611d825fe..7d68ec139 100644 --- a/src/shared/config/json.config.ts +++ b/src/shared/config/json.config.ts @@ -13,6 +13,7 @@ import { PrivacyIdeaConfig } from './privacyidea.config.js'; import { SystemConfig } from './system.config.js'; import { OxConfig } from './ox.config.js'; import { ImportConfig } from './import.config.js'; +import { VidisConfig } from './vidis.config.js'; export class JsonConfig { @ValidateNested() @@ -66,4 +67,8 @@ export class JsonConfig { @ValidateNested() @Type(() => SystemConfig) public readonly SYSTEM!: SystemConfig; + + @ValidateNested() + @Type(() => VidisConfig) + public readonly VIDIS!: VidisConfig; } diff --git a/src/shared/config/vidis.config.ts b/src/shared/config/vidis.config.ts new file mode 100644 index 000000000..b11342377 --- /dev/null +++ b/src/shared/config/vidis.config.ts @@ -0,0 +1,21 @@ +import { IsString } from 'class-validator'; + +export class VidisConfig { + @IsString() + public readonly BASE_URL!: string; + + @IsString() + public readonly USERNAME!: string; + + @IsString() + public readonly PASSWORD!: string; + + @IsString() + public readonly REGION_NAME!: string; + + @IsString() + public readonly KEYCLOAK_GROUP!: string; + + @IsString() + public readonly KEYCLOAK_ROLE!: string; +} diff --git a/test/config.test.json b/test/config.test.json index 5c86ca289..8d2becd54 100644 --- a/test/config.test.json +++ b/test/config.test.json @@ -64,6 +64,14 @@ "USER_RESOLVER": "mariadb_resolver", "REALM": "defrealm" }, + "VIDIS": { + "BASE_URL": "", + "USERNAME": "", + "PASSWORD": "", + "REGION_NAME": "test-region", + "KEYCLOAK_GROUP": "VIDIS-service", + "KEYCLOAK_ROLE": "VIDIS-user" + }, "OX": { "ENABLED": "false", "ENDPOINT": "https://ox_ip:ox_port/webservices/",