Spsh 1327

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

@@ -26,6 +26,8 @@ import { RolleRepo } from '../../rolle/repo/rolle.repo.js';
 import { OrganisationRepository } from '../../organisation/persistence/organisation.repository.js';
 import { KeycloakConfig } from '../../../shared/config/keycloak.config.js';
 import { KeycloakUserService } from '../../keycloak-administration/index.js';
+import { TimeLimitOccasion } from '../../person/domain/time-limit-occasion.enums.js';
+import PersonTimeLimitService from '../../person/domain/person-time-limit-info.service.js';
 
 describe('AuthenticationController', () => {
     let module: TestingModule;
@@ -38,7 +40,7 @@ describe('AuthenticationController', () => {
     let rolleRepoMock: DeepMocked<RolleRepo>;
     const keycloakUserServiceMock: DeepMocked<KeycloakUserService> = createMock<KeycloakUserService>();
     let keyCloakConfig: KeycloakConfig;
-
+    let personTimeLimitServiceMock: DeepMocked<PersonTimeLimitService>;
     beforeAll(async () => {
         module = await Test.createTestingModule({
             imports: [
@@ -76,6 +78,10 @@ describe('AuthenticationController', () => {
                     provide: KeycloakUserService,
                     useValue: keycloakUserServiceMock,
                 },
+                {
+                    provide: PersonTimeLimitService,
+                    useValue: createMock<PersonTimeLimitService>(),
+                },
             ],
         }).compile();
 
@@ -89,6 +95,7 @@ describe('AuthenticationController', () => {
         dbiamPersonenkontextRepoMock = module.get(DBiamPersonenkontextRepo);
         organisationRepoMock = module.get(OrganisationRepository);
         rolleRepoMock = module.get(RolleRepo);
+        personTimeLimitServiceMock = module.get(PersonTimeLimitService);
     });
 
     afterEach(() => {
@@ -275,6 +282,13 @@ describe('AuthenticationController', () => {
                 value: person.updatedAt,
             });
 
+            personTimeLimitServiceMock.getPersonTimeLimitInfo.mockResolvedValueOnce([
+                {
+                    occasion: TimeLimitOccasion.KOPERS,
+                    deadline: faker.date.future(),
+                },
+            ]);
+
             const requestMock: Request = setupRequest();
             const result: UserinfoResponse = await authController.info(permissions, requestMock);
 

src/modules/authentication/api/authentication.controller.ts

@@ -31,6 +31,9 @@ import { AuthenticationExceptionFilter } from './authentication-exception-filter
 import { KeycloakUserService } from '../../keycloak-administration/index.js';
 import { DomainError } from '../../../shared/error/domain.error.js';
 import { getLowestStepUpLevel } from '../passport/oidc.strategy.js';
+import { PersonTimeLimitInfo } from '../../person/domain/person-time-limit-info.js';
+import { PersonTimeLimitInfoResponse } from './person-time-limit-info.reponse.js';
+import PersonTimeLimitService from '../../person/domain/person-time-limit-info.service.js';
 
 @UseFilters(new AuthenticationExceptionFilter())
 @ApiTags('auth')
@@ -47,6 +50,7 @@ export class AuthenticationController {
         @Inject(OIDC_CLIENT) private client: Client,
         private readonly logger: ClassLogger,
         private keycloakUserService: KeycloakUserService,
+        private personTimeLimitService: PersonTimeLimitService,
     ) {
         const frontendConfig: FrontendConfig = configService.getOrThrow<FrontendConfig>('FRONTEND');
         const keycloakConfig: KeycloakConfig = configService.getOrThrow<KeycloakConfig>('KEYCLOAK');
@@ -132,10 +136,18 @@ export class AuthenticationController {
             if (lastPasswordChange.ok) userinfoExtension.password_updated_at = lastPasswordChange.value;
         }
 
+        const timeLimitInfos: PersonTimeLimitInfo[] = await this.personTimeLimitService.getPersonTimeLimitInfo(
+            permissions.personFields.id,
+        );
+        const timeLimitInfosResponse: PersonTimeLimitInfoResponse[] = timeLimitInfos.map(
+            (info: PersonTimeLimitInfo) => new PersonTimeLimitInfoResponse(info.occasion, info.deadline),
+        );
+
         return new UserinfoResponse(
             permissions,
             rolleFieldsResponse,
             req.passportUser?.stepUpLevel ?? getLowestStepUpLevel(),
+            timeLimitInfosResponse,
             userinfoExtension,
         );
     }

src/modules/authentication/api/person-time-limit-info.reponse.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { TimeLimitOccasion } from '../../person/domain/time-limit-occasion.enums.js';
+
+export class PersonTimeLimitInfoResponse {
+    @ApiProperty({ nullable: true })
+    public occasion: TimeLimitOccasion;
+
+    @ApiProperty({ nullable: true })
+    public deadline: string;
+
+    public constructor(occasion: TimeLimitOccasion, deadline: Date) {
+        this.occasion = occasion;
+        this.deadline = deadline?.toISOString();
+    }
+}

src/modules/authentication/api/userinfo.response.spec.ts

@@ -9,6 +9,8 @@ import { RolleRepo } from '../../rolle/repo/rolle.repo.js';
 import { PersonenkontextRolleFieldsResponse } from './personen-kontext-rolle-fields.response.js';
 import { createMock } from '@golevelup/ts-jest';
 import { StepUpLevel } from '../passport/oidc.strategy.js';
+import { PersonTimeLimitInfoResponse } from './person-time-limit-info.reponse.js';
+import { TimeLimitOccasion } from '../../person/domain/time-limit-occasion.enums.js';
 
 describe('UserinfoResponse', () => {
     const permissions: PersonPermissions = new PersonPermissions(
@@ -22,8 +24,15 @@ describe('UserinfoResponse', () => {
         rolle: { systemrechte: [faker.string.alpha()], serviceProviderIds: [faker.string.uuid()] },
     };
 
+    const personTimeLimtit: PersonTimeLimitInfoResponse = {
+        occasion: TimeLimitOccasion.KOPERS,
+        deadline: faker.date.future().toISOString(),
+    };
+
     it('constructs the object without optional extension', () => {
-        const userinfoResponse: UserinfoResponse = new UserinfoResponse(permissions, [pk], StepUpLevel.SILVER);
+        const userinfoResponse: UserinfoResponse = new UserinfoResponse(permissions, [pk], StepUpLevel.SILVER, [
+            personTimeLimtit,
+        ]);
         expect(userinfoResponse).toBeDefined();
         expect(userinfoResponse.password_updated_at).toBeUndefined();
     });
@@ -34,6 +43,7 @@ describe('UserinfoResponse', () => {
             permissions,
             [pk],
             StepUpLevel.SILVER,
+            [personTimeLimtit],
             extension,
         );
         expect(userinfoResponse).toBeDefined();

src/modules/authentication/api/userinfo.response.ts

@@ -2,6 +2,7 @@ import { ApiProperty } from '@nestjs/swagger';
 import { PersonPermissions } from '../domain/person-permissions.js';
 import { PersonenkontextRolleFieldsResponse } from './personen-kontext-rolle-fields.response.js';
 import { StepUpLevel } from '../passport/oidc.strategy.js';
+import { PersonTimeLimitInfoResponse } from './person-time-limit-info.reponse.js';
 
 export type UserinfoExtension = {
     password_updated_at?: Date;
@@ -74,10 +75,14 @@ export class UserinfoResponse {
     @ApiProperty({ nullable: false })
     public acr: StepUpLevel;
 
+    @ApiProperty({ type: PersonTimeLimitInfoResponse, isArray: true })
+    public timeLimits: PersonTimeLimitInfoResponse[];
+
     public constructor(
         info: PersonPermissions,
         personenkontexte: PersonenkontextRolleFieldsResponse[],
         acr: StepUpLevel,
+        timeLimits: PersonTimeLimitInfoResponse[],
         extension?: UserinfoExtension,
     ) {
         this.sub = info.personFields.keycloakUserId!;
@@ -93,5 +98,6 @@ export class UserinfoResponse {
         this.personenkontexte = personenkontexte;
         this.password_updated_at = extension?.password_updated_at?.toISOString();
         this.acr = acr;
+        this.timeLimits = timeLimits;
     }
 }

src/modules/authentication/authentication-api.module.ts

@@ -13,6 +13,7 @@ import { JwtStrategy } from './passport/jwt.strategy.js';
 import { OrganisationModule } from '../organisation/organisation.module.js';
 import { RolleModule } from '../rolle/rolle.module.js';
 import { KeycloakAdministrationModule } from '../keycloak-administration/keycloak-administration.module.js';
+import PersonTimeLimitService from '../person/domain/person-time-limit-info.service.js';
 
 @Module({
     imports: [
@@ -31,6 +32,7 @@ import { KeycloakAdministrationModule } from '../keycloak-administration/keycloa
         OIDCClientProvider,
         PersonPermissionsRepo,
         SessionAccessTokenMiddleware,
+        PersonTimeLimitService,
     ],
     controllers: [AuthenticationController],
     exports: [OIDCClientProvider, PersonPermissionsRepo],

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

@@ -78,6 +78,7 @@ import { PersonEmailResponse } from './person-email-response.js';
 import { UserLock } from '../../keycloak-administration/domain/user-lock.js';
 import { StepUpGuard } from '../../authentication/api/steup-up.guard.js';
 import { PersonLockOccasion } from '../domain/person.enums.js';
+import { KOPERS_DEADLINE_IN_DAYS } from '../domain/person-time-limit.js';
 
 @UseFilters(SchulConnexValidationErrorFilter, new AuthenticationExceptionFilter(), new PersonExceptionFilter())
 @ApiTags('personen')
@@ -207,6 +208,20 @@ export class PersonController {
         const personEmailResponse: Option<PersonEmailResponse> = await this.emailRepo.getEmailAddressAndStatusForPerson(
             personResult.value,
         );
+
+        if (
+            !personResult.value.personalnummer &&
+            (await this.dBiamPersonenkontextService.isPersonalnummerRequiredForAnyPersonenkontextForPerson(
+                personResult.value.id,
+            ))
+        ) {
+            const kopersKontext: Personenkontext<true> | undefined =
+                await this.dBiamPersonenkontextService.getKopersPersonenkontext(personResult.value.id);
+            if (kopersKontext) {
+                const koperslockDate: Date = new Date(kopersKontext.createdAt);
+                koperslockDate.setDate(koperslockDate.getDate() + KOPERS_DEADLINE_IN_DAYS);
+            }
+        }
         const response: PersonendatensatzResponse = new PersonendatensatzResponse(
             personResult.value,
             false,

src/modules/person/domain/person-time-limit-info.service.spec.ts

@@ -0,0 +1,82 @@
+import { DeepMocked, createMock } from '@golevelup/ts-jest';
+import { TestingModule, Test } from '@nestjs/testing';
+import { PersonRepository } from '../../person/persistence/person.repository.js';
+import PersonTimeLimitService from './person-time-limit-info.service.js';
+import { DBiamPersonenkontextService } from '../../personenkontext/domain/dbiam-personenkontext.service.js';
+import { Person } from '../../person/domain/person.js';
+import { DoFactory } from '../../../../test/utils/do-factory.js';
+import { TimeLimitOccasion } from '../domain/time-limit-occasion.enums.js';
+import { Personenkontext } from '../../personenkontext/domain/personenkontext.js';
+import { PersonTimeLimitInfo } from './person-time-limit-info.js';
+import { KOPERS_DEADLINE_IN_DAYS } from './person-time-limit.js';
+
+describe('PersonTimeLimitService', () => {
+    let module: TestingModule;
+    let sut: PersonTimeLimitService;
+    let personRepoMock: DeepMocked<PersonRepository>;
+    let dBiamPersonenkontextServiceMock: DeepMocked<DBiamPersonenkontextService>;
+
+    beforeAll(async () => {
+        module = await Test.createTestingModule({
+            providers: [
+                PersonTimeLimitService,
+                {
+                    provide: PersonRepository,
+                    useValue: createMock<PersonRepository>(),
+                },
+                {
+                    provide: DBiamPersonenkontextService,
+                    useValue: createMock<DBiamPersonenkontextService>(),
+                },
+            ],
+        }).compile();
+        sut = module.get(PersonTimeLimitService);
+        personRepoMock = module.get(PersonRepository);
+        dBiamPersonenkontextServiceMock = module.get(DBiamPersonenkontextService);
+    });
+
+    afterAll(async () => {
+        await module.close();
+    });
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    it('should be defined', () => {
+        expect(sut).toBeDefined();
+    });
+
+    describe('getPersonTimeLimitInfo', () => {
+        it('should return PersonTimeLimitInfo array', async () => {
+            const person: Person<true> = DoFactory.createPerson(true);
+            person.personalnummer = undefined;
+            personRepoMock.findById.mockResolvedValue(person);
+
+            dBiamPersonenkontextServiceMock.isPersonalnummerRequiredForAnyPersonenkontextForPerson.mockResolvedValue(
+                true,
+            );
+            const pesonenkontext: Personenkontext<true> = DoFactory.createPersonenkontext(true);
+            dBiamPersonenkontextServiceMock.getKopersPersonenkontext.mockResolvedValue(pesonenkontext);
+
+            const result: PersonTimeLimitInfo[] = await sut.getPersonTimeLimitInfo(person.id);
+
+            const expectedDeadline: Date = new Date(pesonenkontext.createdAt);
+            expectedDeadline.setDate(expectedDeadline.getDate() + KOPERS_DEADLINE_IN_DAYS);
+
+            expect(result).toEqual<PersonTimeLimitInfo[]>([
+                {
+                    occasion: TimeLimitOccasion.KOPERS,
+                    deadline: expectedDeadline,
+                },
+            ]);
+        });
+
+        it('should return empty array when person isnt found ', async () => {
+            personRepoMock.findById.mockResolvedValue(null);
+            const result: PersonTimeLimitInfo[] = await sut.getPersonTimeLimitInfo('');
+
+            expect(result).toEqual<PersonTimeLimitInfo[]>([]);
+        });
+    });
+});

src/modules/person/domain/person-time-limit-info.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@nestjs/common';
+import { Personenkontext } from '../../personenkontext/domain/personenkontext.js';
+import { DBiamPersonenkontextService } from '../../personenkontext/domain/dbiam-personenkontext.service.js';
+import { PersonRepository } from '../../person/persistence/person.repository.js';
+import { Person } from '../../person/domain/person.js';
+import { PersonTimeLimitInfo } from './person-time-limit-info.js';
+import { TimeLimitOccasion } from './time-limit-occasion.enums.js';
+import { KOPERS_DEADLINE_IN_DAYS } from './person-time-limit.js';
+
+@Injectable()
+export default class PersonTimeLimitService {
+    public constructor(
+        private readonly personRepository: PersonRepository,
+        private readonly dBiamPersonenkontextService: DBiamPersonenkontextService,
+    ) {}
+
+    public async getPersonTimeLimitInfo(personId: string): Promise<PersonTimeLimitInfo[]> {
+        const person: Option<Person<true>> = await this.personRepository.findById(personId);
+        if (!person) {
+            return [];
+        }
+        const lockInfos: PersonTimeLimitInfo[] = [];
+        if (
+            !person.personalnummer &&
+            (await this.dBiamPersonenkontextService.isPersonalnummerRequiredForAnyPersonenkontextForPerson(person.id))
+        ) {
+            const kopersKontext: Personenkontext<true> | undefined =
+                await this.dBiamPersonenkontextService.getKopersPersonenkontext(person.id);
+            if (kopersKontext) {
+                const kopersdeadline: Date = new Date(kopersKontext.createdAt);
+                kopersdeadline.setDate(kopersdeadline.getDate() + KOPERS_DEADLINE_IN_DAYS);
+                lockInfos.push(new PersonTimeLimitInfo(TimeLimitOccasion.KOPERS, kopersdeadline));
+            }
+        }
+
+        return lockInfos;
+    }
+}

src/modules/person/domain/person-time-limit-info.ts

@@ -0,0 +1,8 @@
+import { TimeLimitOccasion } from './time-limit-occasion.enums.js';
+
+export class PersonTimeLimitInfo {
+    public constructor(
+        public readonly occasion: TimeLimitOccasion,
+        public readonly deadline: Date,
+    ) {}
+}

src/modules/person/domain/person-time-limit.ts

@@ -0,0 +1 @@
+export const KOPERS_DEADLINE_IN_DAYS: number = 56;

src/modules/person/domain/time-limit-occasion.enums.ts

@@ -0,0 +1,3 @@
+export enum TimeLimitOccasion {
+    KOPERS = 'KOPERS',
+}

src/modules/person/persistence/person.repository.ts

@@ -38,6 +38,7 @@ import { PersonalNummerForPersonWithTrailingSpaceError } from '../domain/persona
 import { VornameForPersonWithTrailingSpaceError } from '../domain/vorname-with-trailing-space.error.js';
 import { SystemConfig } from '../../../shared/config/system.config.js';
 import { UserLock } from '../../keycloak-administration/domain/user-lock.js';
+import { KOPERS_DEADLINE_IN_DAYS } from '../domain/person-time-limit.js';
 
 /**
  * Return email-address for person, if an enabled email-address exists, return it.
@@ -762,15 +763,15 @@ export class PersonRepository {
 
     public async getKoPersUserLockList(): Promise<[PersonID, string][]> {
         const daysAgo: Date = new Date();
-        daysAgo.setDate(daysAgo.getDate() - 56);
+        daysAgo.setDate(daysAgo.getDate() - KOPERS_DEADLINE_IN_DAYS);
 
         const filters: QBFilterQuery<PersonEntity> = {
             $and: [
                 { personalnummer: { $eq: null } },
                 {
                     personenKontexte: {
                         $some: {
-                            createdAt: { $lte: daysAgo }, // Check that createdAt is older than 56 days
+                            createdAt: { $lte: daysAgo }, // Check that createdAt is older than KOPERS_DEADLINE_IN_DAYS
                             rolleId: {
                                 merkmale: { merkmal: RollenMerkmal.KOPERS_PFLICHT },
                             },