Merge branch 'main' into dependabot/npm_and_yarn/faker-js/faker-8.3.1

src/modules/frontend/api/frontend.controller.spec.ts

@@ -235,6 +235,7 @@ describe('FrontendController', () => {
                     geschlecht: Geschlecht.M,
                     lokalisierung: '',
                     vertrauensstufe: Vertrauensstufe.VOLL,
+                    revision: '1',
                 };
                 const personenKontextResponse: PersonenkontextResponse[] = [];
                 const response: PersonendatensatzResponse = {

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

@@ -97,6 +97,7 @@ export class PersonApiMapperProfile extends AutomapperProfile {
                 forMember((dest: PersonDo<boolean>) => dest.id, ignore()),
                 forMember((dest: PersonDo<boolean>) => dest.createdAt, ignore()),
                 forMember((dest: PersonDo<boolean>) => dest.updatedAt, ignore()),
+                forMember((dest: PersonDo<boolean>) => dest.revision, ignore()),
             );
             createMap(
                 mapper,
@@ -200,6 +201,7 @@ export class PersonApiMapperProfile extends AutomapperProfile {
                 forMember((dest: PersonDo<false>) => dest.lokalisierung, ignore()),
                 forMember((dest: PersonDo<false>) => dest.vertrauensstufe, ignore()),
                 forMember((dest: PersonDo<false>) => dest.auskunftssperre, ignore()),
+                forMember((dest: PersonDo<false>) => dest.revision, ignore()),
             );
 
             createMap(mapper, CreatePersonDto, UserDo);

src/modules/person/api/person.controller.spec.ts

@@ -68,7 +68,8 @@ describe('PersonController', () => {
 
     describe('when creating a person', () => {
         it('should not throw', async () => {
-            personUcMock.createPerson.mockResolvedValue();
+            const personDto: PersonDto = {} as PersonDto;
+            personUcMock.createPerson.mockResolvedValue(personDto);
             const params: CreatePersonBodyParams = {
                 username: faker.internet.userName(),
                 mandant: faker.string.uuid(),

src/modules/person/api/person.controller.ts

@@ -37,6 +37,7 @@ import { CreatedPersonenkontextDto } from './created-personenkontext.dto.js';
 import { FindPersonendatensatzDto } from './find-personendatensatz.dto.js';
 import { FindPersonenkontextDto } from './find-personenkontext.dto.js';
 import { PersonByIdParams } from './person-by-id.param.js';
+import { PersonDto } from './person.dto.js';
 import { PersonenQueryParams } from './personen-query.param.js';
 import { PersonendatensatzDto } from './personendatensatz.dto.js';
 import { PersonendatensatzResponse } from './personendatensatz.response.js';
@@ -56,14 +57,25 @@ export class PersonController {
     ) {}
 
     @Post()
+    @HttpCode(200)
     @ApiCreatedResponse({ description: 'The person was successfully created.' })
     @ApiBadRequestResponse({ description: 'The person already exists.' })
     @ApiUnauthorizedResponse({ description: 'Not authorized to create the person.' })
     @ApiForbiddenResponse({ description: 'Insufficient permissions to create the person.' })
     @ApiInternalServerErrorResponse({ description: 'Internal server error while creating the person.' })
-    public async createPerson(@Body() params: CreatePersonBodyParams): Promise<void> {
+    public async createPerson(@Body() params: CreatePersonBodyParams): Promise<PersonendatensatzResponse> {
         const dto: CreatePersonDto = this.mapper.map(params, CreatePersonBodyParams, CreatePersonDto);
-        await this.personUc.createPerson(dto);
+        const person: PersonDto = await this.personUc.createPerson(dto);
+        const personendatensatzDto: PersonendatensatzDto = {
+            person: person,
+            personenkontexte: [],
+        };
+        const personendatensatzResponse: PersonendatensatzResponse = this.mapper.map(
+            personendatensatzDto,
+            PersonendatensatzDto,
+            PersonendatensatzResponse,
+        );
+        return personendatensatzResponse;
     }
 
     @Get(':personId')

src/modules/person/api/person.dto.ts

@@ -42,4 +42,7 @@ export class PersonDto {
 
     @AutoMap()
     public auskunftssperre?: boolean;
+
+    @AutoMap()
+    public revision!: string;
 }

src/modules/person/api/person.response.spec.ts

@@ -27,6 +27,7 @@ describe('PersonResponse', () => {
         geschlecht: faker.person.gender(),
         lokalisierung: faker.location.country(),
         vertrauensstufe: Vertrauensstufe.VOLL,
+        revision: '1',
     };
 
     it('should convert plain object of person response to a class of person response', () => {
@@ -39,6 +40,7 @@ describe('PersonResponse', () => {
             geschlecht: personResponse.geschlecht,
             lokalisierung: personResponse.lokalisierung,
             vertrauensstufe: personResponse.vertrauensstufe,
+            revision: personResponse.revision,
         };
         const mappedParams: PersonResponse = plainToInstance(PersonResponse, person, {});
         expect(mappedParams).toBeInstanceOf(PersonResponse);

src/modules/person/api/person.response.ts

@@ -40,4 +40,8 @@ export class PersonResponse {
     @AutoMap(() => String)
     @ApiProperty({ enum: Vertrauensstufe })
     public vertrauensstufe!: Vertrauensstufe;
+
+    @AutoMap()
+    @ApiProperty()
+    public revision!: string;
 }

src/modules/person/api/person.uc.ts

@@ -24,7 +24,7 @@ export class PersonUc {
         @Inject(getMapperToken()) private readonly mapper: Mapper,
     ) {}
 
-    public async createPerson(personDto: CreatePersonDto): Promise<void> {
+    public async createPerson(personDto: CreatePersonDto): Promise<PersonDto> {
         // create user
         const userDo: UserDo<false> = this.mapper.map(personDto, CreatePersonDto, UserDo<false>);
         const userIdResult: Result<string> = await this.userService.create(userDo);
@@ -38,7 +38,8 @@ export class PersonUc {
 
         const result: Result<PersonDo<true>> = await this.personService.createPerson(personDo);
         if (result.ok) {
-            return;
+            const resPersonDto: PersonDto = this.mapper.map(personDo, PersonDo, PersonDto);
+            return resPersonDto;
         }
 
         // delete user if person could not be created

src/modules/person/domain/person.do.ts

@@ -77,4 +77,7 @@ export class PersonDo<WasPersisted extends boolean> implements DoBase<WasPersist
 
     @AutoMap()
     public auskunftssperre?: boolean;
+
+    @AutoMap()
+    public revision!: string;
 }

src/modules/person/domain/person.service.spec.ts

@@ -62,6 +62,7 @@ describe('PersonService', () => {
                     id: undefined,
                     createdAt: undefined,
                     updatedAt: undefined,
+                    revision: '1',
                 });
                 expect(result).toEqual<Result<PersonDo<true>>>({
                     ok: true,
@@ -83,6 +84,7 @@ describe('PersonService', () => {
                     id: undefined,
                     createdAt: undefined,
                     updatedAt: undefined,
+                    revision: '1',
                 });
                 expect(result).toEqual<Result<PersonDo<true>>>({
                     ok: false,

src/modules/person/persistence/person.entity.ts

@@ -95,4 +95,8 @@ export class PersonEntity extends TimestampedEntity<PersonEntity, 'id'> {
 
     @ManyToOne({ nullable: true })
     public dataProvider?: DataProviderEntity;
+
+    @AutoMap()
+    @Property({ nullable: false, default: '1' })
+    public revision!: string;
 }

test/utils/do-factory.ts

@@ -42,6 +42,7 @@ export class DoFactory {
             id: withId ? faker.string.uuid() : undefined,
             createdAt: withId ? faker.date.past() : undefined,
             updatedAt: withId ? faker.date.recent() : undefined,
+            revision: '1',
         };
         return Object.assign(new PersonDo<WasPersisted>(), person, props);
     }