Merge branch 'main' into SPSH-88-add-sessions-to-bff

src/modules/person/api/finde-persondatensatz-dto.ts → src/modules/person/api/find-personendatensatz.dto.ts

@@ -1,6 +1,7 @@
 import { AutoMap } from '@automapper/classes';
+import { SichtfreigabeType } from './personen-query.param.js';
 
-export class FindPersonDatensatzDTO {
+export class FindPersonendatensatzDto {
     @AutoMap()
     public referrer?: string;
 
@@ -9,4 +10,7 @@ export class FindPersonDatensatzDTO {
 
     @AutoMap()
     public vorname?: string;
+
+    @AutoMap()
+    public sichtfreigabe!: SichtfreigabeType;
 }

src/modules/person/api/find-personenkontext.dto.ts

@@ -0,0 +1,20 @@
+import { AutoMap } from '@automapper/classes';
+import { Rolle, Personenstatus } from '../domain/personenkontext.enums.js';
+import { SichtfreigabeType } from './personen-query.param.js';
+
+export class FindPersonenkontextDto {
+    @AutoMap()
+    public personId!: string;
+
+    @AutoMap()
+    public readonly referrer?: string;
+
+    @AutoMap()
+    public readonly rolle?: Rolle;
+
+    @AutoMap()
+    public readonly personenstatus?: Personenstatus;
+
+    @AutoMap()
+    public readonly sichtfreigabe: SichtfreigabeType = SichtfreigabeType.NEIN;
+}

src/modules/person/api/person-api.mapper.profile.spec.ts

@@ -22,6 +22,8 @@ import { Jahrgangsstufe, Personenstatus, Rolle } from '../domain/personenkontext
 import { PersonenkontextDo } from '../domain/personenkontext.do.js';
 import { CreatedPersonenkontextDto } from './created-personenkontext.dto.js';
 import { PersonenkontextResponse } from './personenkontext.response.js';
+import { PersonenkontextQueryParams } from './personenkontext-query.params.js';
+import { FindPersonenkontextDto } from './find-personenkontext.dto.js';
 
 describe('PersonApiMapperProfile', () => {
     let module: TestingModule;
@@ -166,8 +168,8 @@ describe('PersonApiMapperProfile', () => {
         });
 
         it('should map PersonenkontextDo to CreatedPersonenkontextDto', () => {
-            const personDo: PersonenkontextDo<true> = DoFactory.createPersonenkontext(true);
-            expect(() => sut.map(personDo, PersonenkontextDo, CreatedPersonenkontextDto)).not.toThrowError(
+            const personenkontextDo: PersonenkontextDo<true> = DoFactory.createPersonenkontext(true);
+            expect(() => sut.map(personenkontextDo, PersonenkontextDo, CreatedPersonenkontextDto)).not.toThrowError(
                 MappingError,
             );
         });
@@ -189,5 +191,35 @@ describe('PersonApiMapperProfile', () => {
                 MappingError,
             );
         });
+
+        it('should map PersonenkontextQueryParams to FindePersonenkontextDto', () => {
+            const params: PersonenkontextQueryParams = {
+                sichtfreigabe: SichtfreigabeType.JA,
+                personenstatus: Personenstatus.AKTIV,
+                referrer: 'referrer',
+                rolle: Rolle.LERNENDER,
+            };
+            expect(() => sut.map(params, PersonenkontextQueryParams, FindPersonenkontextDto)).not.toThrowError(
+                MappingError,
+            );
+        });
+
+        it('should map FindePersonenkontextDto to PersonenkontextDo', () => {
+            const dto: FindPersonenkontextDto = {
+                personId: faker.string.uuid(),
+                sichtfreigabe: SichtfreigabeType.JA,
+                personenstatus: Personenstatus.AKTIV,
+                referrer: 'referrer',
+                rolle: Rolle.LERNENDER,
+            };
+            expect(() => sut.map(dto, FindPersonenkontextDto, PersonenkontextDo)).not.toThrowError(MappingError);
+        });
+
+        it('should map PersonenkontextDo to PersonenkontextResponse', () => {
+            const personenkontextDo: PersonenkontextDo<true> = DoFactory.createPersonenkontext(true);
+            expect(() => sut.map(personenkontextDo, PersonenkontextDo, PersonenkontextResponse)).not.toThrowError(
+                MappingError,
+            );
+        });
     });
 });

src/modules/person/api/person-api.mapper.profile.ts

@@ -15,17 +15,19 @@ import { CreatePersonDto } from '../domain/create-person.dto.js';
 import { PersonDo } from '../domain/person.do.js';
 import { Gender, TrustLevel } from '../domain/person.enums.js';
 import { CreatePersonBodyParams } from './create-person.body.params.js';
-import { FindPersonDatensatzDTO } from './finde-persondatensatz-dto.js';
+import { FindPersonendatensatzDto } from './find-personendatensatz.dto.js';
 import { PersonGender, PersonTrustLevel } from './person.enums.js';
 import { PersonenQueryParam, SichtfreigabeType } from './personen-query.param.js';
-import { PersonenDatensatz } from './personendatensatz.js';
+import { PersonendatensatzResponse } from './personendatensatz.response.js';
 import { CreatePersonenkontextBodyParams } from './create-personenkontext.body.params.js';
 import { CreatePersonenkontextDto } from './create-personenkontext.dto.js';
 import { PersonenkontextDo } from '../domain/personenkontext.do.js';
 import { CreatedPersonenkontextDto } from './created-personenkontext.dto.js';
 import { PersonenkontextResponse } from './personenkontext.response.js';
 import { OrganisationDo } from '../../organisation/domain/organisation.do.js';
 import { CreatedPersonenkontextOrganisationDto } from './created-personenkontext-organisation.dto.js';
+import { PersonenkontextQueryParams } from './personenkontext-query.params.js';
+import { FindPersonenkontextDto } from './find-personenkontext.dto.js';
 
 export const personGenderToGenderConverter: Converter<PersonGender, Gender> = {
     convert(source: PersonGender): Gender {
@@ -146,112 +148,112 @@ export class PersonApiMapperProfile extends AutomapperProfile {
             createMap(
                 mapper,
                 PersonDo,
-                PersonenDatensatz,
+                PersonendatensatzResponse,
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.id,
+                    (dest: PersonendatensatzResponse) => dest.person.id,
                     mapFrom((src: PersonDo<true>) => src.id),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.mandant,
+                    (dest: PersonendatensatzResponse) => dest.person.mandant,
                     mapFrom((src: PersonDo<true>) => src.client),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.referrer,
+                    (dest: PersonendatensatzResponse) => dest.person.referrer,
                     mapFrom((src: PersonDo<true>) => src.referrer),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.vorname,
+                    (dest: PersonendatensatzResponse) => dest.person.name.vorname,
                     mapFrom((src: PersonDo<true>) => src.firstName),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.rufname,
+                    (dest: PersonendatensatzResponse) => dest.person.name.rufname,
                     mapFrom((src: PersonDo<true>) => src.nickName),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.familienname,
+                    (dest: PersonendatensatzResponse) => dest.person.name.familienname,
                     mapFrom((src: PersonDo<true>) => src.lastName),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.initialenvorname,
+                    (dest: PersonendatensatzResponse) => dest.person.name.initialenvorname,
                     mapFrom((src: PersonDo<true>) => src.initialsFirstName),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.initialenfamilienname,
+                    (dest: PersonendatensatzResponse) => dest.person.name.initialenfamilienname,
                     mapFrom((src: PersonDo<true>) => src.initialsLastName),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.sortierindex,
+                    (dest: PersonendatensatzResponse) => dest.person.name.sortierindex,
                     mapFrom((src: PersonDo<true>) => src.nameSortIndex),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.geburt.datum,
+                    (dest: PersonendatensatzResponse) => dest.person.geburt.datum,
                     mapFrom((src: PersonDo<true>) => src.birthDate),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.geburt.geburtsort,
+                    (dest: PersonendatensatzResponse) => dest.person.geburt.geburtsort,
                     mapFrom((src: PersonDo<true>) => src.birthPlace),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.vertrauensstufe,
+                    (dest: PersonendatensatzResponse) => dest.person.vertrauensstufe,
                     mapFrom((src: PersonDo<true>) => src.trustLevel),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.geschlecht,
+                    (dest: PersonendatensatzResponse) => dest.person.geschlecht,
                     mapFrom((src: PersonDo<true>) => src.gender),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.lokalisierung,
+                    (dest: PersonendatensatzResponse) => dest.person.lokalisierung,
                     mapFrom((src: PersonDo<true>) => src.localization),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.stammorganisation,
+                    (dest: PersonendatensatzResponse) => dest.person.stammorganisation,
                     mapFrom((src: PersonDo<true>) => src.mainOrganization),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.anrede,
+                    (dest: PersonendatensatzResponse) => dest.person.name.anrede,
                     mapFrom((src: PersonDo<true>) => src.nameSalutation),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.namenssuffix,
+                    (dest: PersonendatensatzResponse) => dest.person.name.namenssuffix,
                     mapFrom((src: PersonDo<true>) => src.nameSuffix),
                 ),
                 forMember(
-                    (dest: PersonenDatensatz) => dest.person.name.namenspraefix,
+                    (dest: PersonendatensatzResponse) => dest.person.name.namenspraefix,
                     mapFrom((src: PersonDo<true>) => src.namePrefix),
                 ),
             );
             createMap(
                 mapper,
                 PersonenQueryParam,
-                FindPersonDatensatzDTO,
+                FindPersonendatensatzDto,
                 forMember(
-                    (dest: FindPersonDatensatzDTO) => dest.vorname,
+                    (dest: FindPersonendatensatzDto) => dest.vorname,
                     mapFrom((src: PersonenQueryParam) => src.vorname),
                 ),
                 forMember(
-                    (dest: FindPersonDatensatzDTO) => dest.familienname,
+                    (dest: FindPersonendatensatzDto) => dest.familienname,
                     mapFrom((src: PersonenQueryParam) => src.familienname),
                 ),
                 forMember(
-                    (dest: FindPersonDatensatzDTO) => dest.referrer,
+                    (dest: FindPersonendatensatzDto) => dest.referrer,
                     mapFrom((src: PersonenQueryParam) => src.referrer),
                 ),
             );
             createMap(
                 mapper,
-                FindPersonDatensatzDTO,
+                FindPersonendatensatzDto,
                 PersonDo<false>,
                 forMember(
                     (dest: PersonDo<false>) => dest.lastName,
-                    mapFrom((src: FindPersonDatensatzDTO) => src.familienname),
+                    mapFrom((src: FindPersonendatensatzDto) => src.familienname),
                 ),
                 forMember(
                     (dest: PersonDo<false>) => dest.firstName,
-                    mapFrom((src: FindPersonDatensatzDTO) => src.vorname),
+                    mapFrom((src: FindPersonendatensatzDto) => src.vorname),
                 ),
                 forMember(
                     (dest: PersonDo<false>) => dest.referrer,
-                    mapFrom((src: FindPersonDatensatzDTO) => src.referrer),
+                    mapFrom((src: FindPersonendatensatzDto) => src.referrer),
                 ),
                 forMember((dest: PersonDo<false>) => dest.id, ignore()),
                 forMember((dest: PersonDo<false>) => dest.createdAt, ignore()),
@@ -303,6 +305,39 @@ export class PersonApiMapperProfile extends AutomapperProfile {
             );
             createMap(mapper, OrganisationDo, CreatedPersonenkontextOrganisationDto);
             createMap(mapper, CreatedPersonenkontextDto, PersonenkontextResponse);
+
+            createMap(
+                mapper,
+                PersonenkontextQueryParams,
+                FindPersonenkontextDto,
+                forMember((dest: FindPersonenkontextDto) => dest.personId, ignore()),
+            );
+            createMap(
+                mapper,
+                FindPersonenkontextDto,
+                PersonenkontextDo,
+                forMember((dest: PersonenkontextDo<boolean>) => dest.mandant, ignore()),
+                forMember((dest: PersonenkontextDo<boolean>) => dest.organisation, ignore()),
+                forMember((dest: PersonenkontextDo<boolean>) => dest.jahrgangsstufe, ignore()),
+                forMember((dest: PersonenkontextDo<boolean>) => dest.loeschungZeitpunkt, ignore()),
+                forMember((dest: PersonenkontextDo<boolean>) => dest.revision, ignore()),
+                forMember(
+                    (dest: PersonenkontextDo<boolean>) => dest.sichtfreigabe,
+                    convertUsing(
+                        personVisibilityToBooleanConverter,
+                        (src: FindPersonenkontextDto) => src.sichtfreigabe,
+                    ),
+                ),
+            );
+            createMap(
+                mapper,
+                PersonenkontextDo,
+                PersonenkontextResponse,
+                forMember(
+                    (dest: PersonenkontextResponse) => dest.id,
+                    mapFrom((src: PersonenkontextDo<true>) => src.id),
+                ),
+            );
         };
     }
 }