From df130aedd9edb73801d832619b9ea22f0bb2a5c7 Mon Sep 17 00:00:00 2001 From: Julien Martin Date: Fri, 16 Oct 2026 15:07:14 +0000 Subject: [PATCH] =?UTF-8?q?feat(#216):=20Agenda=20B2=20=E2=80=94=20soft-ca?= =?UTF-8?q?ncel=20+=20matrice=20+=20cron?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #216 Co-authored-by: Julien Martin --- backend/package-lock.json | 49 +++ backend/package.json | 1 + backend/src/app.module.ts | 2 + backend/src/common/utils/paris-date.ts | 31 ++ .../src/modules/cards/cards.service.spec.ts | 76 ++++ backend/src/modules/cards/cards.service.ts | 50 ++- .../agenda-expiration.cron.spec.ts | 50 +++ .../agenda-expiration.cron.ts | 38 ++ .../evenements-agenda.module.ts | 13 +- .../evenements-agenda.service.spec.ts | 293 +++++++++++++ .../evenements-agenda.service.ts | 410 ++++++++++++++++-- 11 files changed, 948 insertions(+), 65 deletions(-) create mode 100644 backend/src/common/utils/paris-date.ts create mode 100644 backend/src/modules/evenements-agenda/agenda-expiration.cron.spec.ts create mode 100644 backend/src/modules/evenements-agenda/agenda-expiration.cron.ts diff --git a/backend/package-lock.json b/backend/package-lock.json index a0827ca..a8e7cef 100644 --- a/backend/package-lock.json +++ b/backend/package-lock.json @@ -15,6 +15,7 @@ "@nestjs/jwt": "^11.0.0", "@nestjs/mapped-types": "^2.1.0", "@nestjs/platform-express": "^11.0.1", + "@nestjs/schedule": "^12.0.2", "@nestjs/swagger": "^11.2.0", "@nestjs/typeorm": "^11.0.0", "@sentry/nestjs": "^10.10.0", @@ -2544,6 +2545,22 @@ "node": ">= 0.6" } }, + "node_modules/@nestjs/schedule": { + "version": "12.0.2", + "resolved": "https://registry.npmjs.org/@nestjs/schedule/-/schedule-12.0.2.tgz", + "integrity": "sha512-5iAvJEtk0njbfTrG4JQr+SXw8ZrqgDM1wJH9nUs6tVLCX5pWGd1LJ0a8b089UT1FDeDWaThRRfSLixFz9zztcA==", + "license": "MIT", + "dependencies": { + "cron": "4.4.0" + }, + "engines": { + "node": ">=20.19.0" + }, + "peerDependencies": { + "@nestjs/common": "^11.0.0 || ^12.0.0", + "@nestjs/core": "^11.0.0 || ^12.0.0" + } + }, "node_modules/@nestjs/schematics": { "version": "11.0.7", "resolved": "https://registry.npmjs.org/@nestjs/schematics/-/schematics-11.0.7.tgz", @@ -3767,6 +3784,12 @@ "@types/node": "*" } }, + "node_modules/@types/luxon": { + "version": "3.7.6", + "resolved": "https://registry.npmjs.org/@types/luxon/-/luxon-3.7.6.tgz", + "integrity": "sha512-6KSjliQAXK8ZLgFQO4B7iE4Rpf/B3rItzCFuXezBY/XIAGxOdLd7vRNK9/StRPwiS/yJsVbB7HKpW46B8tcEuQ==", + "license": "MIT" + }, "node_modules/@types/methods": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/@types/methods/-/methods-1.1.4.tgz", @@ -5856,6 +5879,23 @@ "devOptional": true, "license": "MIT" }, + "node_modules/cron": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/cron/-/cron-4.4.0.tgz", + "integrity": "sha512-fkdfq+b+AHI4cKdhZlppHveI/mgz2qpiYxcm+t5E5TsxX7QrLS1VE0+7GENEk9z0EeGPcpSciGv6ez24duWhwQ==", + "license": "MIT", + "dependencies": { + "@types/luxon": "~3.7.0", + "luxon": "~3.7.0" + }, + "engines": { + "node": ">=18.x" + }, + "funding": { + "type": "ko-fi", + "url": "https://ko-fi.com/intcreator" + } + }, "node_modules/cross-spawn": { "version": "7.0.6", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", @@ -8786,6 +8826,15 @@ "yallist": "^3.0.2" } }, + "node_modules/luxon": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.2.tgz", + "integrity": "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==", + "license": "MIT", + "engines": { + "node": ">=12" + } + }, "node_modules/magic-string": { "version": "0.30.17", "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz", diff --git a/backend/package.json b/backend/package.json index 6cdacdb..12a1d68 100644 --- a/backend/package.json +++ b/backend/package.json @@ -29,6 +29,7 @@ "@nestjs/jwt": "^11.0.0", "@nestjs/mapped-types": "^2.1.0", "@nestjs/platform-express": "^11.0.1", + "@nestjs/schedule": "^12.0.2", "@nestjs/swagger": "^11.2.0", "@nestjs/typeorm": "^11.0.0", "@sentry/nestjs": "^10.10.0", diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts index 64f08a3..055def5 100644 --- a/backend/src/app.module.ts +++ b/backend/src/app.module.ts @@ -1,5 +1,6 @@ import { Module } from '@nestjs/common'; import { ConfigModule, ConfigService } from '@nestjs/config'; +import { ScheduleModule } from '@nestjs/schedule'; import { AppController } from './app.controller'; import { AppService } from './app.service'; import appConfig from './config/app.config'; @@ -58,6 +59,7 @@ import { SuppressionsModule } from './routes/suppressions/suppressions.module'; AuthModule, AppConfigModule, DocumentsLegauxModule, + ScheduleModule.forRoot(), EvenementsAgendaModule, CardsModule, RelaisModule, diff --git a/backend/src/common/utils/paris-date.ts b/backend/src/common/utils/paris-date.ts new file mode 100644 index 0000000..d934960 --- /dev/null +++ b/backend/src/common/utils/paris-date.ts @@ -0,0 +1,31 @@ +/** Dates calendaires Europe/Paris — comparaison lexicographique YYYY-MM-DD = calendaire (DST-safe). */ + +const PARIS_YMD = new Intl.DateTimeFormat('en-CA', { + timeZone: 'Europe/Paris', + year: 'numeric', + month: '2-digit', + day: '2-digit', +}); + +/** Aujourd’hui civil à Paris (YYYY-MM-DD). */ +export function todayParis(): string { + return PARIS_YMD.format(new Date()); +} + +/** Décale une date calendaire YYYY-MM-DD de `deltaDays` (UTC, sans glissement DST). */ +export function shiftYmd(ymd: string, deltaDays: number): string { + const [y, m, d] = ymd.split('-').map(Number); + const dt = new Date(Date.UTC(y, m - 1, d + deltaDays)); + const yy = dt.getUTCFullYear(); + const mm = String(dt.getUTCMonth() + 1).padStart(2, '0'); + const dd = String(dt.getUTCDate()).padStart(2, '0'); + return `${yy}-${mm}-${dd}`; +} + +export function yesterdayParis(): string { + return shiftYmd(todayParis(), -1); +} + +/** Fenêtre temporelle exacte en ms (ex. 7×24 h = 168 h). */ +export const MS_24H = 24 * 60 * 60 * 1000; +export const MS_7X24H = 7 * MS_24H; diff --git a/backend/src/modules/cards/cards.service.spec.ts b/backend/src/modules/cards/cards.service.spec.ts index ebed7ab..67df2ff 100644 --- a/backend/src/modules/cards/cards.service.spec.ts +++ b/backend/src/modules/cards/cards.service.spec.ts @@ -373,4 +373,80 @@ describe('CardsService (#194)', () => { ]), ); }); + + describe('B2 — #216 soft-cancel + ack arrêt', () => { + it('ack arrêt maladie → pas de maj événement + carte traitée', async () => { + cardsRepo.findOne.mockResolvedValue({ + id: 'card-arret', + type_code: 'arret_maladie_am', + id_placement: 'pl-1', + id_evenement: 'ev-arret', + cree_par: 'am-1', + statut: CardInstanceStatutType.OUVERTE, + purge_at: new Date(Date.now() - 60_000), // déjà hors fil + payload: {}, + type: { + titre: 'Arrêt', + response_mode: CardResponseModeType.ACK, + retention_days: 7, + }, + responses: [], + audience: [ + { id_utilisateur: 'am-1' }, + { id_utilisateur: 'p-1' }, + ], + }); + audienceRepo.findOne.mockResolvedValue({ + id_card: 'card-arret', + id_utilisateur: 'p-1', + }); + + const res = await service.repondre('p-1', RoleType.PARENT, 'card-arret', { + action: 'ack' as never, + }); + + expect(evenementsService.maj).not.toHaveBeenCalled(); + expect(cardsRepo.update).toHaveBeenCalledWith( + { id: 'card-arret' }, + expect.objectContaining({ statut: CardInstanceStatutType.TRAITEE }), + ); + expect(res.statut).toBe(CardInstanceStatutType.TRAITEE); + }); + + it('supprimer carte → soft-cancel (update ANNULEE), pas delete', async () => { + cardsRepo.findOne.mockResolvedValue({ + id: 'card-1', + type_code: 'absence_enfant', + id_placement: 'pl-1', + id_evenement: 'ev-1', + cree_par: 'p-1', + statut: CardInstanceStatutType.OUVERTE, + cree_le: new Date(), + audience: [{ id_utilisateur: 'p-1' }, { id_utilisateur: 'am-1' }], + type: { retention_days: 14 }, + }); + evenementsService.supprimer.mockResolvedValue(undefined); + + await service.supprimer('p-1', RoleType.PARENT, 'card-1'); + + expect(cardsRepo.delete).not.toHaveBeenCalled(); + expect(evenementsService.supprimer).toHaveBeenCalledWith( + 'p-1', + RoleType.PARENT, + 'ev-1', + ); + expect(cardsRepo.update).toHaveBeenCalledWith( + { id: 'card-1' }, + expect.objectContaining({ + statut: CardInstanceStatutType.ANNULEE, + }), + ); + expect(realtime.emitToUsers).toHaveBeenCalledWith( + expect.any(Array), + 'card.deleted', + 'card-1', + expect.any(Object), + ); + }); + }); }); diff --git a/backend/src/modules/cards/cards.service.ts b/backend/src/modules/cards/cards.service.ts index 18efe6a..20e7ffb 100644 --- a/backend/src/modules/cards/cards.service.ts +++ b/backend/src/modules/cards/cards.service.ts @@ -92,11 +92,11 @@ export class CardsService { .leftJoinAndSelect('c.type', 'type') .leftJoinAndSelect('c.responses', 'responses') .where('c.purge_at > now()') - .orderBy( - `CASE c.statut WHEN 'refusee' THEN 0 WHEN 'ouverte' THEN 1 ELSE 2 END`, - 'ASC', - ) - .addOrderBy('c.modifie_le', 'DESC'); + .andWhere('c.statut != :annulee', { + annulee: CardInstanceStatutType.ANNULEE, + }) + // Tri fil : COALESCE(remonte_le, cree_le) DESC (mini-spec §10) + .orderBy('COALESCE(c.remonte_le, c.cree_le)', 'DESC'); if (placementId) { await this.assertPlacementAccess(userId, role, placementId); @@ -251,6 +251,10 @@ export class CardsService { ): Promise { const card = await this.loadCard(cardId); await this.assertInAudience(card, userId); + // Respond OK même après purge_at (sortie du fil) — AC #216 + if (card.statut === CardInstanceStatutType.ANNULEE) { + throw new BadRequestException('Cette carte est annulée'); + } if (card.statut !== CardInstanceStatutType.OUVERTE) { throw new BadRequestException('Cette carte n’est plus ouverte'); } @@ -285,8 +289,11 @@ export class CardsService { }), ); - if (card.id_evenement) { - if (dto.action === CardResponseActionType.ACCEPT || dto.action === CardResponseActionType.ACK) { + // ACK informatif (arrêt / soin) : n’écrit plus sur l’événement (#216) + if (dto.action === CardResponseActionType.ACK) { + card.statut = CardInstanceStatutType.TRAITEE; + } else if (card.id_evenement) { + if (dto.action === CardResponseActionType.ACCEPT) { await this.evenementsService.maj(userId, role, card.id_evenement, { statut: StatutEvenementAgendaType.ACCEPTE, }); @@ -298,8 +305,6 @@ export class CardsService { }); card.statut = CardInstanceStatutType.REFUSEE; } - } else if (dto.action === CardResponseActionType.ACK) { - card.statut = CardInstanceStatutType.TRAITEE; } card.purge_at = this.purgeAt(card.type.retention_days, card.statut); @@ -456,22 +461,21 @@ export class CardsService { } const audienceIds = await this.audienceUserIds(card); + // Soft-cancel événement lié (matrice temporelle côté evenements) — #216 if (card.id_evenement) { - const absStatut = - card.statut === CardInstanceStatutType.TRAITEE - ? null - : card.id_evenement; - // Supprime l’absence liée si pas encore acceptée définitivement (ou si soin_enfant dans les 24h) - if ( - card.statut === CardInstanceStatutType.OUVERTE || - card.statut === CardInstanceStatutType.REFUSEE || - card.type_code === 'soin_enfant' - ) { - await this.evenementsService.supprimer(userId, role, card.id_evenement); - } - void absStatut; + await this.evenementsService.supprimer(userId, role, card.id_evenement); } - await this.cardsRepo.delete({ id: cardId }); + // Soft-cancel carte — aucun DELETE physique applicatif (#216) + const now = new Date(); + await this.cardsRepo.update( + { id: cardId }, + { + statut: CardInstanceStatutType.ANNULEE, + annule_le: now, + annule_par: userId, + purge_at: now, + }, + ); this.realtime.emitToUsers(audienceIds, 'card.deleted', cardId, { id: cardId, }); diff --git a/backend/src/modules/evenements-agenda/agenda-expiration.cron.spec.ts b/backend/src/modules/evenements-agenda/agenda-expiration.cron.spec.ts new file mode 100644 index 0000000..9bab2e3 --- /dev/null +++ b/backend/src/modules/evenements-agenda/agenda-expiration.cron.spec.ts @@ -0,0 +1,50 @@ +jest.mock('@nestjs/schedule', () => ({ + Cron: () => () => undefined, + CronExpression: { EVERY_HOUR: '0 * * * *' }, +})); + +import { AgendaExpirationCron } from './agenda-expiration.cron'; +import { EvenementsAgendaService } from './evenements-agenda.service'; + +describe('AgendaExpirationCron (#216)', () => { + const evenements = { + autoValiderCongesExpires: jest.fn().mockResolvedValue(2), + softCancelRefusesExpires: jest.fn().mockResolvedValue(1), + }; + + beforeEach(() => jest.clearAllMocks()); + + it('runOnce agrège auto-valid + soft-cancel', async () => { + const cron = new AgendaExpirationCron( + evenements as unknown as EvenementsAgendaService, + ); + const res = await cron.runOnce(); + expect(res).toEqual({ autoValid: 2, softCancel: 1 }); + expect(evenements.autoValiderCongesExpires).toHaveBeenCalledTimes(1); + expect(evenements.softCancelRefusesExpires).toHaveBeenCalledTimes(1); + }); + + it('double appel concurrent : 2e skip (lock)', async () => { + let release!: () => void; + const gate = new Promise((r) => { + release = r; + }); + evenements.autoValiderCongesExpires.mockImplementation(async () => { + await gate; + return 1; + }); + evenements.softCancelRefusesExpires.mockResolvedValue(0); + + const cron = new AgendaExpirationCron( + evenements as unknown as EvenementsAgendaService, + ); + const p1 = cron.runOnce(); + const p2 = cron.runOnce(); + release(); + const [a, b] = await Promise.all([p1, p2]); + const skipped = [a, b].filter((x) => x.autoValid === 0 && x.softCancel === 0); + const ran = [a, b].filter((x) => x.autoValid === 1); + expect(skipped).toHaveLength(1); + expect(ran).toHaveLength(1); + }); +}); diff --git a/backend/src/modules/evenements-agenda/agenda-expiration.cron.ts b/backend/src/modules/evenements-agenda/agenda-expiration.cron.ts new file mode 100644 index 0000000..4e84697 --- /dev/null +++ b/backend/src/modules/evenements-agenda/agenda-expiration.cron.ts @@ -0,0 +1,38 @@ +import { Injectable, Logger } from '@nestjs/common'; +import { Cron, CronExpression } from '@nestjs/schedule'; +import { EvenementsAgendaService } from './evenements-agenda.service'; + +/** + * Échéances Agenda (#216) : auto-valid congés J+7, soft-cancel refusés J+7. + * Idempotent ; rattrapage au redémarrage via le prochain tick. + */ +@Injectable() +export class AgendaExpirationCron { + private readonly logger = new Logger(AgendaExpirationCron.name); + private running = false; + + constructor(private readonly evenements: EvenementsAgendaService) {} + + @Cron(CronExpression.EVERY_HOUR) + async tick(): Promise { + await this.runOnce(); + } + + /** Exposé pour tests / appel manuel (double-appel = no-op côté rows déjà traités). */ + async runOnce( + now = new Date(), + ): Promise<{ autoValid: number; softCancel: number }> { + if (this.running) { + this.logger.debug('Cron agenda déjà en cours — skip'); + return { autoValid: 0, softCancel: 0 }; + } + this.running = true; + try { + const autoValid = await this.evenements.autoValiderCongesExpires(now); + const softCancel = await this.evenements.softCancelRefusesExpires(now); + return { autoValid, softCancel }; + } finally { + this.running = false; + } + } +} diff --git a/backend/src/modules/evenements-agenda/evenements-agenda.module.ts b/backend/src/modules/evenements-agenda/evenements-agenda.module.ts index 50d8de6..680e976 100644 --- a/backend/src/modules/evenements-agenda/evenements-agenda.module.ts +++ b/backend/src/modules/evenements-agenda/evenements-agenda.module.ts @@ -3,14 +3,23 @@ import { ConfigModule, ConfigService } from '@nestjs/config'; import { JwtModule } from '@nestjs/jwt'; import { TypeOrmModule } from '@nestjs/typeorm'; import { EvenementsAgenda } from 'src/entities/evenements_agenda.entity'; +import { AgendaLots } from 'src/entities/agenda_lots.entity'; +import { CardInstance } from 'src/entities/card_instances.entity'; import { AmChildren } from 'src/entities/am_children.entity'; import { ParentsChildren } from 'src/entities/parents_children.entity'; import { EvenementsAgendaController } from './evenements-agenda.controller'; import { EvenementsAgendaService } from './evenements-agenda.service'; +import { AgendaExpirationCron } from './agenda-expiration.cron'; @Module({ imports: [ - TypeOrmModule.forFeature([EvenementsAgenda, AmChildren, ParentsChildren]), + TypeOrmModule.forFeature([ + EvenementsAgenda, + AgendaLots, + CardInstance, + AmChildren, + ParentsChildren, + ]), JwtModule.registerAsync({ imports: [ConfigModule], useFactory: (config: ConfigService) => ({ @@ -21,7 +30,7 @@ import { EvenementsAgendaService } from './evenements-agenda.service'; }), ], controllers: [EvenementsAgendaController], - providers: [EvenementsAgendaService], + providers: [EvenementsAgendaService, AgendaExpirationCron], exports: [EvenementsAgendaService], }) export class EvenementsAgendaModule {} diff --git a/backend/src/modules/evenements-agenda/evenements-agenda.service.spec.ts b/backend/src/modules/evenements-agenda/evenements-agenda.service.spec.ts index b2f4997..855445d 100644 --- a/backend/src/modules/evenements-agenda/evenements-agenda.service.spec.ts +++ b/backend/src/modules/evenements-agenda/evenements-agenda.service.spec.ts @@ -7,9 +7,22 @@ import { StatutEvenementAgendaType, TypeEvenementAgendaType, } from 'src/entities/evenements_agenda.entity'; +import { AgendaLots } from 'src/entities/agenda_lots.entity'; +import { CardInstance } from 'src/entities/card_instances.entity'; import { AmChildren } from 'src/entities/am_children.entity'; import { ParentsChildren } from 'src/entities/parents_children.entity'; import { RoleType } from 'src/entities/users.entity'; +import { todayParis, yesterdayParis } from 'src/common/utils/paris-date'; + +function qbUpdateMock() { + const chain: Record = {}; + chain.update = jest.fn().mockReturnValue(chain); + chain.set = jest.fn().mockReturnValue(chain); + chain.where = jest.fn().mockReturnValue(chain); + chain.andWhere = jest.fn().mockReturnValue(chain); + chain.execute = jest.fn().mockResolvedValue({ affected: 1 }); + return chain; +} describe('EvenementsAgendaService (#172)', () => { let service: EvenementsAgendaService; @@ -22,9 +35,19 @@ describe('EvenementsAgendaService (#172)', () => { modifie_le: new Date(), })), findOne: jest.fn(), + find: jest.fn(), + update: jest.fn(async () => ({ affected: 1 })), delete: jest.fn(), createQueryBuilder: jest.fn(), }; + const lotsRepo = { + findOne: jest.fn(), + update: jest.fn(async () => ({ affected: 1 })), + createQueryBuilder: jest.fn(() => qbUpdateMock()), + }; + const cardsRepo = { + createQueryBuilder: jest.fn(() => qbUpdateMock()), + }; const amChildrenRepo = { find: jest.fn(), findOne: jest.fn(), @@ -39,6 +62,8 @@ describe('EvenementsAgendaService (#172)', () => { providers: [ EvenementsAgendaService, { provide: getRepositoryToken(EvenementsAgenda), useValue: absencesRepo }, + { provide: getRepositoryToken(AgendaLots), useValue: lotsRepo }, + { provide: getRepositoryToken(CardInstance), useValue: cardsRepo }, { provide: getRepositoryToken(AmChildren), useValue: amChildrenRepo }, { provide: getRepositoryToken(ParentsChildren), @@ -48,6 +73,8 @@ describe('EvenementsAgendaService (#172)', () => { }).compile(); service = module.get(EvenementsAgendaService); jest.clearAllMocks(); + lotsRepo.createQueryBuilder.mockImplementation(() => qbUpdateMock()); + cardsRepo.createQueryBuilder.mockImplementation(() => qbUpdateMock()); }); it('should be defined', () => { @@ -372,4 +399,270 @@ describe('EvenementsAgendaService (#172)', () => { expect(res.statut_effectif).toBe(StatutEvenementAgendaType.REFUSE); expect(res.libelle_refus).not.toMatch(/p-2|Dupont|famille B/i); }); + + describe('B2 — #216 matrice + soft-cancel + cron', () => { + it('arrêt maladie créé → statut accepte + verrouille_le', async () => { + amChildrenRepo.findOne.mockResolvedValue({ + id: 'pl-1', + amId: 'am-1', + enfantId: 'e-1', + date_fin: null, + }); + absencesRepo.findOne.mockResolvedValue({ + id: 'abs-1', + id_placement: 'pl-1', + type: TypeEvenementAgendaType.ARRET_MALADIE_AM, + date_debut: '2026-10-01', + date_fin: '2026-10-05', + statut: StatutEvenementAgendaType.ACCEPTE, + expire_at: new Date('9999-12-31'), + verrouille_le: new Date(), + cree_le: new Date(), + modifie_le: new Date(), + placement: { + enfantId: 'e-1', + amId: 'am-1', + child: { id: 'e-1', first_name: 'Léo' }, + am: { user: { prenom: 'Marie', nom: 'AM' } }, + }, + }); + + await service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, { + id_placement: 'pl-1', + type: TypeEvenementAgendaType.ARRET_MALADIE_AM, + date_debut: '2026-10-01', + date_fin: '2026-10-05', + }); + + const saved = absencesRepo.save.mock.calls[0][0]; + expect(saved.statut).toBe(StatutEvenementAgendaType.ACCEPTE); + expect(saved.verrouille_le).toBeInstanceOf(Date); + }); + + it('parent maj statut arrêt → 400 (ack n’écrit pas sur l’événement)', async () => { + absencesRepo.findOne.mockResolvedValue({ + id: 'abs-1', + id_placement: 'pl-1', + type: TypeEvenementAgendaType.ARRET_MALADIE_AM, + date_debut: '2026-10-01', + date_fin: '2026-10-05', + statut: StatutEvenementAgendaType.ACCEPTE, + expire_at: new Date('9999-12-31'), + cree_le: new Date(), + verrouille_le: new Date(), + }); + amChildrenRepo.findOne.mockResolvedValue({ + id: 'pl-1', + amId: 'am-1', + enfantId: 'e-1', + date_fin: null, + }); + parentsChildrenRepo.findOne.mockResolvedValue({ + parentId: 'p-1', + enfantId: 'e-1', + }); + + await expect( + service.maj('p-1', RoleType.PARENT, 'abs-1', { + statut: StatutEvenementAgendaType.ACCEPTE, + }), + ).rejects.toBeInstanceOf(BadRequestException); + }); + + it('soin hors [hier, auj.] → BadRequest', async () => { + amChildrenRepo.findOne.mockResolvedValue({ + id: 'pl-1', + amId: 'am-1', + enfantId: 'e-1', + date_fin: null, + }); + await expect( + service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, { + id_placement: 'pl-1', + type: TypeEvenementAgendaType.SOIN_ENFANT, + date_debut: '2020-01-01', + date_fin: '2020-01-01', + }), + ).rejects.toBeInstanceOf(BadRequestException); + }); + + it('soin daté aujourd’hui (Paris) → OK', async () => { + const auj = todayParis(); + amChildrenRepo.findOne.mockResolvedValue({ + id: 'pl-1', + amId: 'am-1', + enfantId: 'e-1', + date_fin: null, + }); + absencesRepo.findOne.mockResolvedValue({ + id: 'abs-1', + id_placement: 'pl-1', + type: TypeEvenementAgendaType.SOIN_ENFANT, + date_debut: auj, + date_fin: auj, + statut: StatutEvenementAgendaType.ACCEPTE, + expire_at: new Date('9999-12-31'), + cree_le: new Date(), + modifie_le: new Date(), + placement: { + enfantId: 'e-1', + amId: 'am-1', + child: { id: 'e-1', first_name: 'Léo' }, + am: { user: { prenom: 'Marie', nom: 'AM' } }, + }, + }); + await expect( + service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, { + id_placement: 'pl-1', + type: TypeEvenementAgendaType.SOIN_ENFANT, + date_debut: auj, + date_fin: auj, + }), + ).resolves.toBeDefined(); + // hier aussi OK + const hier = yesterdayParis(); + absencesRepo.findOne.mockResolvedValue({ + id: 'abs-2', + id_placement: 'pl-1', + type: TypeEvenementAgendaType.SOIN_ENFANT, + date_debut: hier, + date_fin: hier, + statut: StatutEvenementAgendaType.ACCEPTE, + expire_at: new Date('9999-12-31'), + cree_le: new Date(), + modifie_le: new Date(), + placement: { + enfantId: 'e-1', + amId: 'am-1', + child: { id: 'e-1', first_name: 'Léo' }, + am: { user: { prenom: 'Marie', nom: 'AM' } }, + }, + }); + await expect( + service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, { + id_placement: 'pl-1', + type: TypeEvenementAgendaType.SOIN_ENFANT, + date_debut: hier, + date_fin: hier, + }), + ).resolves.toBeDefined(); + }); + + it('supprimer → soft-cancel (update ANNULE), pas delete physique', async () => { + absencesRepo.findOne.mockResolvedValue({ + id: 'abs-1', + id_placement: 'pl-1', + type: TypeEvenementAgendaType.ABSENCE_ENFANT, + date_debut: '2026-10-01', + date_fin: '2026-10-02', + statut: StatutEvenementAgendaType.ACCEPTE, + cree_le: new Date(), + verrouille_le: new Date(), + cree_par: 'p-1', + }); + amChildrenRepo.findOne.mockResolvedValue({ + id: 'pl-1', + amId: 'am-1', + enfantId: 'e-1', + date_fin: null, + }); + parentsChildrenRepo.findOne.mockResolvedValue({ + parentId: 'p-1', + enfantId: 'e-1', + }); + + await service.supprimer('p-1', RoleType.PARENT, 'abs-1'); + expect(absencesRepo.delete).not.toHaveBeenCalled(); + expect(absencesRepo.update).toHaveBeenCalledWith( + { id: 'abs-1' }, + expect.objectContaining({ + statut: StatutEvenementAgendaType.ANNULE, + }), + ); + }); + + it('cron auto-valid + soft-cancel refusés ; double appel idempotent', async () => { + const old = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000); + absencesRepo.find.mockResolvedValue([ + { + id: 'c1', + type: TypeEvenementAgendaType.CONGE_AM, + statut: StatutEvenementAgendaType.EN_ATTENTE, + verrouille_le: old, + }, + ]); + const legacyQb = { + where: jest.fn().mockReturnThis(), + andWhere: jest.fn().mockReturnThis(), + getMany: jest.fn().mockResolvedValue([]), + }; + const refuseQb = { + where: jest.fn().mockReturnThis(), + andWhere: jest.fn().mockReturnThis(), + getMany: jest.fn().mockResolvedValue([ + { + id: 'r1', + statut: StatutEvenementAgendaType.REFUSE, + refuse_le: old, + }, + ]), + }; + absencesRepo.createQueryBuilder + .mockReturnValueOnce(legacyQb) // autoValider legacy + .mockReturnValueOnce(refuseQb); // softCancelRefuses + absencesRepo.findOne.mockImplementation(async ({ where }) => { + if (where?.id === 'r1') { + return { + id: 'r1', + statut: StatutEvenementAgendaType.REFUSE, + refuse_le: old, + }; + } + return null; + }); + + const n1 = await service.autoValiderCongesExpires(); + expect(n1).toBe(1); + expect(absencesRepo.update).toHaveBeenCalledWith( + { id: 'c1', statut: StatutEvenementAgendaType.EN_ATTENTE }, + expect.objectContaining({ + statut: StatutEvenementAgendaType.ACCEPTE, + }), + ); + + absencesRepo.find.mockResolvedValue([]); // déjà validés + const emptyQb = { + where: jest.fn().mockReturnThis(), + andWhere: jest.fn().mockReturnThis(), + getMany: jest.fn().mockResolvedValue([]), + }; + absencesRepo.createQueryBuilder.mockReset(); + absencesRepo.createQueryBuilder.mockReturnValue(emptyQb); + const n2 = await service.autoValiderCongesExpires(); + expect(n2).toBe(0); + + // soft-cancel refusés + absencesRepo.createQueryBuilder.mockReturnValue(refuseQb); + refuseQb.getMany.mockResolvedValue([ + { id: 'r1', statut: StatutEvenementAgendaType.REFUSE, refuse_le: old }, + ]); + absencesRepo.findOne.mockResolvedValue({ + id: 'r1', + statut: StatutEvenementAgendaType.REFUSE, + refuse_le: old, + }); + const sc1 = await service.softCancelRefusesExpires(); + expect(sc1).toBe(1); + // 2e passage : déjà ANNULE → 0 + absencesRepo.findOne.mockResolvedValue({ + id: 'r1', + statut: StatutEvenementAgendaType.ANNULE, + }); + refuseQb.getMany.mockResolvedValue([ + { id: 'r1', statut: StatutEvenementAgendaType.ANNULE }, + ]); + const sc2 = await service.softCancelRefusesExpires(); + expect(sc2).toBe(0); + }); + }); }); diff --git a/backend/src/modules/evenements-agenda/evenements-agenda.service.ts b/backend/src/modules/evenements-agenda/evenements-agenda.service.ts index fbb4509..ccc6f13 100644 --- a/backend/src/modules/evenements-agenda/evenements-agenda.service.ts +++ b/backend/src/modules/evenements-agenda/evenements-agenda.service.ts @@ -2,16 +2,24 @@ import { BadRequestException, ForbiddenException, Injectable, + Logger, NotFoundException, } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; -import { In, IsNull, Repository } from 'typeorm'; +import { In, IsNull, LessThanOrEqual, Repository } from 'typeorm'; import { EvenementsAgenda, StatutEvenementAgendaType, TypeEvenementAgendaType, } from 'src/entities/evenements_agenda.entity'; -import { AgendaLotStatutType } from 'src/entities/agenda_lots.entity'; +import { + AgendaLots, + AgendaLotStatutType, +} from 'src/entities/agenda_lots.entity'; +import { + CardInstance, + CardInstanceStatutType, +} from 'src/entities/card_instances.entity'; import { AmChildren } from 'src/entities/am_children.entity'; import { ParentsChildren } from 'src/entities/parents_children.entity'; import { RoleType } from 'src/entities/users.entity'; @@ -22,17 +30,30 @@ import { ListeEvenementsAgendaDto, MajEvenementAgendaDto, } from './dto/evenements-agenda.dto'; +import { + MS_24H, + MS_7X24H, + todayParis, + yesterdayParis, +} from 'src/common/utils/paris-date'; -const TTL_EN_ATTENTE_MS = 15 * 24 * 60 * 60 * 1000; -const TTL_REFUSE_MS = 7 * 24 * 60 * 60 * 1000; +/** Auto-valid / soft-cancel refusés = 7×24 h (mini-spec §5). */ +const TTL_EN_ATTENTE_MS = MS_7X24H; +const TTL_REFUSE_MS = MS_7X24H; /** Sentinel « pas de purge » pour les périodes acceptées */ const EXPIRE_ACCEPTE = new Date('9999-12-31T23:59:59.999Z'); @Injectable() export class EvenementsAgendaService { + private readonly logger = new Logger(EvenementsAgendaService.name); + constructor( @InjectRepository(EvenementsAgenda) private readonly absencesRepo: Repository, + @InjectRepository(AgendaLots) + private readonly lotsRepo: Repository, + @InjectRepository(CardInstance) + private readonly cardsRepo: Repository, @InjectRepository(AmChildren) private readonly amChildrenRepo: Repository, @InjectRepository(ParentsChildren) @@ -113,17 +134,23 @@ export class EvenementsAgendaService { dto: CreerEvenementAgendaDto, ): Promise { this.assertDates(dto.date_debut, dto.date_fin); + this.assertCalendarDate(dto.date_debut, 'date_debut'); + this.assertCalendarDate(dto.date_fin, 'date_fin'); await this.assertCanAccessPlacement(userId, role, dto.id_placement); this.assertCanCreateType(role, dto.type); + this.assertTemporalCreate(dto.type, dto.date_debut, dto.date_fin); const statut = this.statutInitial(dto.type); + const now = new Date(); const entity = this.absencesRepo.create({ id_placement: dto.id_placement, type: dto.type, date_debut: dto.date_debut, date_fin: dto.date_fin, statut, - expire_at: this.expireAtFor(statut), + expire_at: this.expireAtFor(statut, now), + // verrouille_le à la soumission seulement — jamais en GET (#216) + verrouille_le: now, cree_par: userId, motif: dto.motif?.trim() || undefined, }); @@ -141,38 +168,76 @@ export class EvenementsAgendaService { if (!row) { throw new NotFoundException('Absence introuvable'); } + if (row.statut === StatutEvenementAgendaType.ANNULE) { + throw new BadRequestException('Événement annulé'); + } await this.assertCanAccessPlacement(userId, role, row.id_placement); + const datesChange = + (dto.date_debut !== undefined && dto.date_debut !== row.date_debut) || + (dto.date_fin !== undefined && dto.date_fin !== row.date_fin); + if (dto.date_debut !== undefined || dto.date_fin !== undefined) { const debut = dto.date_debut ?? row.date_debut; const fin = dto.date_fin ?? row.date_fin; this.assertDates(debut, fin); - // Parent : peut modifier ses absences enfant - // AM : peut modifier congé/arrêt en_attente (avant accept) ou dates si créateur + this.assertCalendarDate(debut, 'date_debut'); + this.assertCalendarDate(fin, 'date_fin'); this.assertCanEditDates(role, row); + this.assertTemporalEdit(row); row.date_debut = debut; row.date_fin = fin; - if (row.statut === StatutEvenementAgendaType.EN_ATTENTE) { - row.expire_at = this.expireAtFor(StatutEvenementAgendaType.EN_ATTENTE); + + // Toute modif de dates d’un événement soumis à validation → nouvelle revision + if (datesChange && this.needsRevalidationOnDateChange(row)) { + await this.bumpRevisionForDateChange(row, userId); + } else if (row.statut === StatutEvenementAgendaType.EN_ATTENTE) { + row.expire_at = this.expireAtFor( + StatutEvenementAgendaType.EN_ATTENTE, + row.verrouille_le ?? row.cree_le, + ); } } - if (dto.statut !== undefined && dto.statut !== row.statut) { - this.assertCanChangeStatut(role, row, dto.statut, dto.motif); + if (dto.statut !== undefined) { + // Ack arrêt = informatif carte seulement — toute maj statut parent sur arrêt → 400 if ( - dto.statut === StatutEvenementAgendaType.REFUSE && - (!dto.motif || !dto.motif.trim()) + role === RoleType.PARENT && + row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM ) { throw new BadRequestException( - 'Une motivation est obligatoire en cas de refus', + 'L’accusé de réception d’un arrêt maladie n’écrit pas sur l’événement', ); } - row.statut = dto.statut; - row.expire_at = this.expireAtFor(dto.statut); - if (dto.motif?.trim()) { - row.motif = dto.motif.trim(); + if (dto.statut !== row.statut) { + this.assertCanChangeStatut(role, row, dto.statut, dto.motif); + if ( + dto.statut === StatutEvenementAgendaType.REFUSE && + (!dto.motif || !dto.motif.trim()) + ) { + throw new BadRequestException( + 'Une motivation est obligatoire en cas de refus', + ); + } + const now = new Date(); + row.statut = dto.statut; + row.expire_at = this.expireAtFor(dto.statut, now); + if (dto.statut === StatutEvenementAgendaType.REFUSE) { + row.refuse_le = now; + } + if ( + dto.statut === StatutEvenementAgendaType.EN_ATTENTE && + datesChange + ) { + // resoumission : nouveau verrou (pas un GET) + row.verrouille_le = now; + } + if (dto.motif?.trim()) { + row.motif = dto.motif.trim(); + } } } else if (dto.motif !== undefined) { + // Motif seul ne relance pas l’unanimité row.motif = dto.motif.trim() || undefined; } @@ -180,6 +245,10 @@ export class EvenementsAgendaService { return this.getByIdForUser(id, userId, role); } + /** + * Soft-cancel applicatif — remplace tout DELETE physique événement (#216). + * Idempotent si déjà annulé. + */ async supprimer( userId: string, role: RoleType, @@ -200,7 +269,140 @@ export class EvenementsAgendaService { ); } - await this.absencesRepo.delete({ id }); + this.assertCanSoftCancel(role, row); + await this.softCancelEvent(row, userId); + } + + /** Soft-cancel sans re-check role (cron / carte liée). Idempotent. */ + async softCancelById(id: string, userId?: string | null): Promise { + const row = await this.absencesRepo.findOne({ where: { id } }); + if (!row) return false; + return this.softCancelEvent(row, userId ?? null); + } + + private async softCancelEvent( + row: EvenementsAgenda, + userId: string | null, + ): Promise { + if (row.statut === StatutEvenementAgendaType.ANNULE) { + return false; + } + const now = new Date(); + await this.absencesRepo.update( + { id: row.id }, + { + statut: StatutEvenementAgendaType.ANNULE, + annule_le: now, + annule_par: userId ?? undefined, + expire_at: now, + }, + ); + // Cartes liées : soft-cancel (pas de DELETE physique) + await this.cardsRepo + .createQueryBuilder() + .update(CardInstance) + .set({ + statut: CardInstanceStatutType.ANNULEE, + annule_le: now, + annule_par: userId ?? undefined, + purge_at: now, + }) + .where('id_evenement = :eid', { eid: row.id }) + .andWhere('statut != :annulee', { + annulee: CardInstanceStatutType.ANNULEE, + }) + .execute(); + if (row.id_lot) { + await this.lotsRepo + .createQueryBuilder() + .update(AgendaLots) + .set({ + statut: AgendaLotStatutType.ANNULE, + annule_le: now, + annule_par: userId ?? undefined, + }) + .where('id = :id', { id: row.id_lot }) + .andWhere('statut != :annule', { annule: AgendaLotStatutType.ANNULE }) + .execute(); + } + return true; + } + + /** + * Cron : auto-valide les congés encore en_attente après 7×24 h depuis verrouille_le. + * Idempotent. Retourne le nombre mis à jour. + */ + async autoValiderCongesExpires(now = new Date()): Promise { + const threshold = new Date(now.getTime() - TTL_EN_ATTENTE_MS); + const rows = await this.absencesRepo.find({ + where: { + type: TypeEvenementAgendaType.CONGE_AM, + statut: StatutEvenementAgendaType.EN_ATTENTE, + verrouille_le: LessThanOrEqual(threshold), + }, + }); + // Fallback cree_le si verrouille_le null (données pré-B2) + const legacy = await this.absencesRepo + .createQueryBuilder('ag') + .where('ag.type = :type', { type: TypeEvenementAgendaType.CONGE_AM }) + .andWhere('ag.statut = :statut', { + statut: StatutEvenementAgendaType.EN_ATTENTE, + }) + .andWhere('ag.verrouille_le IS NULL') + .andWhere('ag.cree_le <= :threshold', { threshold }) + .getMany(); + + const byId = new Map(); + for (const r of [...rows, ...legacy]) byId.set(r.id, r); + + let n = 0; + for (const row of byId.values()) { + await this.absencesRepo.update( + { id: row.id, statut: StatutEvenementAgendaType.EN_ATTENTE }, + { + statut: StatutEvenementAgendaType.ACCEPTE, + expire_at: EXPIRE_ACCEPTE, + }, + ); + if (row.id_lot) { + await this.lotsRepo.update( + { id: row.id_lot, statut: AgendaLotStatutType.EN_ATTENTE }, + { statut: AgendaLotStatutType.ACCEPTE }, + ); + } + n += 1; + } + if (n > 0) { + this.logger.log(`Cron auto-valid congés : ${n} événement(s)`); + } + return n; + } + + /** + * Cron : soft-cancel des refusés après 7×24 h (refuse_le / expire_at). + * Idempotent. + */ + async softCancelRefusesExpires(now = new Date()): Promise { + const threshold = new Date(now.getTime() - TTL_REFUSE_MS); + const rows = await this.absencesRepo + .createQueryBuilder('ag') + .where('ag.statut = :statut', { + statut: StatutEvenementAgendaType.REFUSE, + }) + .andWhere( + '(ag.refuse_le IS NOT NULL AND ag.refuse_le <= :threshold) OR (ag.refuse_le IS NULL AND ag.expire_at <= :now)', + { threshold, now }, + ) + .getMany(); + + let n = 0; + for (const row of rows) { + if (await this.softCancelEvent(row, null)) n += 1; + } + if (n > 0) { + this.logger.log(`Cron soft-cancel refusés : ${n} événement(s)`); + } + return n; } private async getByIdForUser( @@ -229,21 +431,152 @@ export class EvenementsAgendaService { } private statutInitial(type: TypeEvenementAgendaType): StatutEvenementAgendaType { - if (type === TypeEvenementAgendaType.ABSENCE_ENFANT || type === TypeEvenementAgendaType.SOIN_ENFANT) { + // Arrêt maladie : accepté dès soumission (ack parent informatif seulement) — #216 + if ( + type === TypeEvenementAgendaType.ABSENCE_ENFANT || + type === TypeEvenementAgendaType.SOIN_ENFANT || + type === TypeEvenementAgendaType.ARRET_MALADIE_AM + ) { return StatutEvenementAgendaType.ACCEPTE; } return StatutEvenementAgendaType.EN_ATTENTE; } - private expireAtFor(statut: StatutEvenementAgendaType): Date { - const now = Date.now(); - if (statut === StatutEvenementAgendaType.ACCEPTE) { - return EXPIRE_ACCEPTE; + private expireAtFor( + statut: StatutEvenementAgendaType, + from: Date = new Date(), + ): Date { + const t = from.getTime(); + if ( + statut === StatutEvenementAgendaType.ACCEPTE || + statut === StatutEvenementAgendaType.ANNULE + ) { + return statut === StatutEvenementAgendaType.ANNULE + ? from + : EXPIRE_ACCEPTE; } if (statut === StatutEvenementAgendaType.REFUSE) { - return new Date(now + TTL_REFUSE_MS); + return new Date(t + TTL_REFUSE_MS); + } + return new Date(t + TTL_EN_ATTENTE_MS); + } + + /** Soin : date ∈ [hier, aujourd’hui] Paris. Autres : passé OK. */ + private assertTemporalCreate( + type: TypeEvenementAgendaType, + debut: string, + fin: string, + ): void { + if (type !== TypeEvenementAgendaType.SOIN_ENFANT) return; + const hier = yesterdayParis(); + const auj = todayParis(); + if (debut < hier || debut > auj || fin < hier || fin > auj) { + throw new BadRequestException( + 'Un soin enfant doit être daté entre hier et aujourd’hui', + ); + } + } + + /** + * Fenêtres d’édition (#216) : + * - soin : ≤ 24 h depuis cree_le + * - congé futur accepté : libre tant que date_debut non commencé + * - sinon congé/arrêt/absence : ≤ 7×24 h depuis verrouille_le (soumission) + */ + private assertTemporalEdit(row: EvenementsAgenda): void { + const now = Date.now(); + if (row.type === TypeEvenementAgendaType.SOIN_ENFANT) { + const since = now - new Date(row.cree_le).getTime(); + if (since > MS_24H) { + throw new BadRequestException( + 'Délai de correction de 24 h dépassé pour ce soin', + ); + } + return; + } + + const today = todayParis(); + if ( + row.type === TypeEvenementAgendaType.CONGE_AM && + row.statut === StatutEvenementAgendaType.ACCEPTE && + row.date_debut > today + ) { + return; // futur validé : modifiable/annulable + } + + const anchor = row.verrouille_le ?? row.cree_le; + const since = now - new Date(anchor).getTime(); + if (since > MS_7X24H) { + throw new BadRequestException( + 'Délai d’édition de 7×24 h dépassé pour cet événement', + ); + } + } + + private assertCanSoftCancel(role: RoleType, row: EvenementsAgenda): void { + if (row.statut === StatutEvenementAgendaType.ANNULE) return; + if (row.type === TypeEvenementAgendaType.SOIN_ENFANT) { + const since = Date.now() - new Date(row.cree_le).getTime(); + if (since > MS_24H) { + throw new BadRequestException( + 'Délai de suppression de 24 h dépassé pour ce soin', + ); + } + return; + } + const today = todayParis(); + if ( + row.type === TypeEvenementAgendaType.CONGE_AM && + row.statut === StatutEvenementAgendaType.ACCEPTE && + row.date_debut > today + ) { + return; // congé futur validé annulable + } + if ( + row.statut === StatutEvenementAgendaType.EN_ATTENTE || + row.statut === StatutEvenementAgendaType.REFUSE + ) { + return; + } + // Absence / arrêt acceptés : fenêtre 7×24 h + const anchor = row.verrouille_le ?? row.cree_le; + if (Date.now() - new Date(anchor).getTime() <= MS_7X24H) { + return; + } + throw new BadRequestException('Cet événement ne peut plus être annulé'); + } + + private needsRevalidationOnDateChange(row: EvenementsAgenda): boolean { + return ( + row.type === TypeEvenementAgendaType.CONGE_AM && + row.statut !== StatutEvenementAgendaType.ANNULE + ); + } + + /** Nouvelle revision + repasse en_attente + nouveau verrouille_le. */ + private async bumpRevisionForDateChange( + row: EvenementsAgenda, + _userId: string, + ): Promise { + const now = new Date(); + row.statut = StatutEvenementAgendaType.EN_ATTENTE; + row.verrouille_le = now; + row.expire_at = this.expireAtFor(StatutEvenementAgendaType.EN_ATTENTE, now); + row.refuse_le = undefined; + if (row.id_lot) { + await this.lotsRepo + .createQueryBuilder() + .update(AgendaLots) + .set({ + revision: () => 'revision + 1', + statut: AgendaLotStatutType.EN_ATTENTE, + verrouille_le: now, + soumis_le: now, + refuse_le: () => 'NULL', + }) + .where('id = :id', { id: row.id_lot }) + .execute(); } - return new Date(now + TTL_EN_ATTENTE_MS); } private assertDates(debut: string, fin: string): void { @@ -318,6 +651,9 @@ export class EvenementsAgendaService { return; } if (role === RoleType.ASSISTANTE_MATERNELLE) { + if (row.type === TypeEvenementAgendaType.SOIN_ENFANT) { + return; // fenêtre 24 h gérée par assertTemporalEdit + } if ( row.type === TypeEvenementAgendaType.CONGE_AM || row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM @@ -329,7 +665,6 @@ export class EvenementsAgendaService { ) { throw new ForbiddenException('Statut incompatible avec une modification'); } - // Accepté : autorisé (S2b — re-validation via cartes plus tard ; API permet update dates) return; } throw new ForbiddenException('Type non modifiable par l’AM'); @@ -344,25 +679,20 @@ export class EvenementsAgendaService { _motif?: string, ): void { if (role === RoleType.PARENT) { - // Accept / refuse congé ; ack arrêt (accepte) - if ( - row.type === TypeEvenementAgendaType.CONGE_AM || - row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM - ) { + // Arrêt : déjà accepté à la soumission — ack carte n’écrit plus ici (#216) + if (row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM) { + throw new BadRequestException( + 'L’accusé de réception d’un arrêt maladie n’écrit pas sur l’événement', + ); + } + // Accept / refuse congé uniquement + if (row.type === TypeEvenementAgendaType.CONGE_AM) { if ( next !== StatutEvenementAgendaType.ACCEPTE && next !== StatutEvenementAgendaType.REFUSE ) { throw new BadRequestException('Transition de statut invalide'); } - if ( - row.type === TypeEvenementAgendaType.ARRET_MALADIE_AM && - next === StatutEvenementAgendaType.REFUSE - ) { - throw new BadRequestException( - 'Un arrêt maladie ne se refuse pas (accusé seulement)', - ); - } if (row.statut !== StatutEvenementAgendaType.EN_ATTENTE) { throw new BadRequestException('Cette demande n’est plus en attente'); }