Spsh-1574: Fortschrittsanzeige & Bulk-Transaktionen

migrations/Migration20241219124504-S.ts

@@ -0,0 +1,30 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20241219124504 extends Migration {
+    public async up(): Promise<void> {
+        this.addSql('alter table "importvorgang" drop column "import_by_person_id";');
+
+        this.addSql(
+            'alter table "importvorgang" add column "person_id" uuid null, add column "total_data_item_imported" int not null;',
+        );
+        this.addSql(
+            'alter table "importvorgang" add constraint "importvorgang_person_id_foreign" foreign key ("person_id") references "person" ("id") on update cascade on delete set null;',
+        );
+        this.addSql(
+            'alter table "importvorgang" add constraint "importvorgang_rolle_id_foreign" foreign key ("rolle_id") references "rolle" ("id") on update cascade on delete set null;',
+        );
+        this.addSql(
+            'alter table "importvorgang" add constraint "importvorgang_organisation_id_foreign" foreign key ("organisation_id") references "organisation" ("id") on update cascade on delete set null;',
+        );
+    }
+
+    public override async down(): Promise<void> {
+        this.addSql('alter table "importvorgang" drop constraint "importvorgang_person_id_foreign";');
+        this.addSql('alter table "importvorgang" drop constraint "importvorgang_rolle_id_foreign";');
+        this.addSql('alter table "importvorgang" drop constraint "importvorgang_organisation_id_foreign";');
+
+        this.addSql('alter table "importvorgang" drop column "person_id", drop column "total_data_item_imported";');
+
+        this.addSql('alter table "importvorgang" add column "import_by_person_id" uuid null;');
+    }
+}

src/modules/import/api/import.controller.integration-spec.ts

@@ -43,6 +43,8 @@ import { ImportStatus } from '../domain/import.enums.js';
 import { StepUpGuard } from '../../authentication/api/steup-up.guard.js';
 import { KeycloakAdministrationService } from '../../keycloak-administration/domain/keycloak-admin-client.service.js';
 import { ImportVorgangStatusResponse } from './importvorgang-status.response.js';
+import { PersonEntity } from '../../person/persistence/person.entity.js';
+import { mapAggregateToData } from '../../person/persistence/person.repository.js';
 
 describe('Import API', () => {
     let app: INestApplication;
@@ -546,8 +548,16 @@ describe('Import API', () => {
             );
             if (sus instanceof DomainError) throw sus;
 
+            const person: PersonEntity = em.create(PersonEntity, mapAggregateToData(DoFactory.createPerson(false)));
+            await em.persistAndFlush(person);
+            await em.findOneOrFail(PersonEntity, { id: person.id });
+
             const importVorgang: ImportVorgang<true> = await importVorgangRepository.save(
-                DoFactory.createImportVorgang(false, { organisationId: schule.id, rolleId: sus.id }),
+                DoFactory.createImportVorgang(false, {
+                    organisationId: schule.id,
+                    rolleId: sus.id,
+                    importByPersonId: person.id,
+                }),
             );
             await importDataRepository.save(
                 DoFactory.createImportDataItem(false, {
@@ -581,8 +591,19 @@ describe('Import API', () => {
         });
 
         it('should return 500 if the import vorgang has no organisation ID', async () => {
+            const sus: Rolle<true> | DomainError = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    rollenart: RollenArt.LERN,
+                    merkmale: [],
+                }),
+            );
+            if (sus instanceof DomainError) throw sus;
             const importVorgang: ImportVorgang<true> = await importVorgangRepository.save(
-                DoFactory.createImportVorgang(false, { organisationId: undefined, rolleId: faker.string.uuid() }),
+                DoFactory.createImportVorgang(false, {
+                    organisationId: undefined,
+                    rolleId: sus.id,
+                    importByPersonId: undefined,
+                }),
             );
             const params: ImportvorgangByIdBodyParams = {
                 importvorgangId: importVorgang.id,
@@ -625,6 +646,7 @@ describe('Import API', () => {
                 DoFactory.createImportVorgang(false, {
                     organisationId: schule.id,
                     rolleId: sus.id,
+                    importByPersonId: undefined,
                     status: ImportStatus.FINISHED,
                 }),
             );
@@ -665,7 +687,11 @@ describe('Import API', () => {
     describe('/DELETE deleteImportTransaction', () => {
         it('should return 204', async () => {
             const importVorgang: ImportVorgang<true> = await importVorgangRepository.save(
-                DoFactory.createImportVorgang(false),
+                DoFactory.createImportVorgang(false, {
+                    importByPersonId: undefined,
+                    rolleId: undefined,
+                    organisationId: undefined,
+                }),
             );
             await importDataRepository.save(
                 DoFactory.createImportDataItem(false, {
@@ -684,21 +710,48 @@ describe('Import API', () => {
     });
 
     describe('/GET history', () => {
-        const rolleId: string = faker.string.uuid();
-        const orgaId1: string = faker.string.uuid();
-        const orgaId2: string = faker.string.uuid();
+        let rolleId: string = faker.string.uuid();
+        let orgaId1: string = faker.string.uuid();
+        let orgaId2: string = faker.string.uuid();
 
         beforeEach(async () => {
+            const schule: OrganisationEntity = new OrganisationEntity();
+            schule.typ = OrganisationsTyp.SCHULE;
+            schule.name = 'Import Schule';
+            await em.persistAndFlush(schule);
+            await em.findOneOrFail(OrganisationEntity, { id: schule.id });
+            orgaId1 = schule.id;
+
+            const schule2: OrganisationEntity = new OrganisationEntity();
+            schule2.typ = OrganisationsTyp.SCHULE;
+            await em.persistAndFlush(schule2);
+            await em.findOneOrFail(OrganisationEntity, { id: schule2.id });
+            orgaId2 = schule2.id;
+
+            const sus: Rolle<true> | DomainError = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    rollenart: RollenArt.LERN,
+                    administeredBySchulstrukturknoten: schule.id,
+                    merkmale: [],
+                }),
+            );
+            if (sus instanceof DomainError) throw sus;
+
+            rolleId = sus.id;
+
             await Promise.all([
                 importVorgangRepository.save(
                     DoFactory.createImportVorgang(false, {
                         organisationId: orgaId1,
+                        importByPersonId: undefined,
+                        rolleId: undefined,
                     }),
                 ),
                 importVorgangRepository.save(
                     DoFactory.createImportVorgang(false, {
                         rolleId: rolleId,
                         organisationId: orgaId2,
+                        importByPersonId: undefined,
                     }),
                 ),
             ]);
@@ -765,7 +818,11 @@ describe('Import API', () => {
         it('should return import history when search by status', async () => {
             personPermissionsMock.hasSystemrechteAtRootOrganisation.mockResolvedValue(true);
             const startedImport: ImportVorgang<true> = await importVorgangRepository.save(
-                DoFactory.createImportVorgang(false),
+                DoFactory.createImportVorgang(false, {
+                    importByPersonId: undefined,
+                    rolleId: undefined,
+                    organisationId: undefined,
+                }),
             );
             startedImport.status = ImportStatus.COMPLETED;
             await importVorgangRepository.save(startedImport);
@@ -784,17 +841,28 @@ describe('Import API', () => {
     });
 
     describe('/GET importstatus by id', () => {
-        it('should return 200 OK with import ststus', async () => {
+        it('should return 200 OK with import status', async () => {
             const importVorgang: ImportVorgang<true> = await importVorgangRepository.save(
-                DoFactory.createImportVorgang(false, { status: ImportStatus.COMPLETED }),
+                DoFactory.createImportVorgang(false, {
+                    status: ImportStatus.COMPLETED,
+                    totalDataItemImported: 100,
+                    importByPersonId: undefined,
+                    rolleId: undefined,
+                    organisationId: undefined,
+                }),
             );
 
             const response: Response = await request(app.getHttpServer() as App)
                 .get(`/import/${importVorgang.id}/status`)
                 .send();
 
             expect(response.status).toBe(200);
-            expect(response.body).toEqual({ status: ImportStatus.COMPLETED } as ImportVorgangStatusResponse);
+            expect(response.body).toBeInstanceOf(Object);
+            expect(response.body).toEqual({
+                dataItemCount: 100,
+                status: ImportStatus.COMPLETED,
+                totalDataItemImported: 100,
+            } as ImportVorgangStatusResponse);
         });
 
         it('should return 404 if importvorgang does not exist', async () => {

src/modules/import/api/importvorgang-status.response.ts

@@ -3,10 +3,18 @@ import { ImportStatus, ImportStatusName } from '../domain/import.enums.js';
 import { ImportVorgang } from '../domain/import-vorgang.js';
 
 export class ImportVorgangStatusResponse {
+    @ApiProperty()
+    public dataItemCount: number;
+
     @ApiProperty({ enum: ImportStatus, enumName: ImportStatusName })
     public status: ImportStatus;
 
+    @ApiProperty()
+    public totalDataItemImported: number;
+
     public constructor(importVorgang: ImportVorgang<true>) {
+        this.dataItemCount = importVorgang.dataItemCount;
         this.status = importVorgang.status;
+        this.totalDataItemImported = importVorgang.totalDataItemImported;
     }
 }

src/modules/import/domain/import-event-handler.spec.ts

@@ -23,6 +23,8 @@ import { ClassLogger } from '../../../core/logging/class-logger.js';
 import { ImportExecutedEvent } from '../../../shared/events/import-executed.event.js';
 import { RolleNurAnPassendeOrganisationError } from '../../personenkontext/specification/error/rolle-nur-an-passende-organisation.js';
 import { ImportPasswordEncryptor } from './import-password-encryptor.js';
+import { ImportDomainError } from './import-domain.error.js';
+import { ImportStatus } from './import.enums.js';
 
 describe('ImportEventHandler', () => {
     let module: TestingModule;
@@ -167,13 +169,21 @@ describe('ImportEventHandler', () => {
             personenkontextCreationServiceMock.createPersonWithPersonenkontexte.mockResolvedValueOnce(error);
             organisationRepoMock.findById.mockResolvedValueOnce(schule);
 
-            await sut.handleExecuteImport(event);
+            const importDomainError: DomainError = new ImportDomainError(
+                `The creation of person with personenkontexte for the import transaction:${importvorgang.id} failed`,
+                importvorgang.id,
+            );
+
+            await expect(sut.handleExecuteImport(event)).rejects.toThrowError(importDomainError);
 
             expect(loggerMock.error).toHaveBeenCalledWith(
                 `System hat versucht einen neuen Benutzer für ${importDataItem.vorname} ${importDataItem.nachname} anzulegen. Fehler: ${error.message}`,
             );
             expect(importDataRepositoryMock.save).not.toHaveBeenCalled();
-            expect(importVorgangRepositoryMock.save).not.toHaveBeenCalled();
+            expect(importVorgangRepositoryMock.save).toHaveBeenCalledWith({
+                ...importvorgang,
+                status: ImportStatus.FAILED,
+            });
         });
 
         it('should log error if the person has no start password', async () => {
@@ -206,12 +216,20 @@ describe('ImportEventHandler', () => {
             personenkontextCreationServiceMock.createPersonWithPersonenkontexte.mockResolvedValueOnce(pks);
             organisationRepoMock.findById.mockResolvedValueOnce(schule);
 
-            await sut.handleExecuteImport(event);
+            const error: DomainError = new ImportDomainError(
+                `The creation for a password for the person with ID ${person.id} for the import transaction:${importvorgang.id} has failed`,
+                importvorgang.id,
+            );
+
+            await expect(sut.handleExecuteImport(event)).rejects.toThrowError(error);
 
             expect(person.newPassword).toBeUndefined();
             expect(loggerMock.error).toHaveBeenCalledWith(`Person with ID ${person.id} has no start password!`);
             expect(importDataRepositoryMock.save).not.toHaveBeenCalled();
-            expect(importVorgangRepositoryMock.save).not.toHaveBeenCalled();
+            expect(importVorgangRepositoryMock.save).toHaveBeenCalledWith({
+                ...importvorgang,
+                status: ImportStatus.FAILED,
+            });
         });
 
         it('should log info if the person and PKs were saved successfully', async () => {
@@ -258,8 +276,8 @@ describe('ImportEventHandler', () => {
             expect(loggerMock.info).toHaveBeenCalledWith(
                 `System hat einen neuen Benutzer ${person.referrer} (${person.id}) angelegt.`,
             );
-            expect(importDataRepositoryMock.save).toHaveBeenCalled();
-            expect(importVorgangRepositoryMock.save).toHaveBeenCalledTimes(1);
+            expect(importDataRepositoryMock.replaceAll).toHaveBeenCalled();
+            expect(importVorgangRepositoryMock.save).toHaveBeenCalledTimes(2);
         });
     });
 });