[REMANIEMENT][AIDANTS] Expose la nouvelle route pour valider les CGU

Author: bbougon

mon-aide-cyber-api/src/api/hateoas/contextesUtilisateur.ts

@@ -1,6 +1,7 @@
 import { Options } from './hateoas';
 
 type ClefContexte =
+  | 'aidant'
   | 'demande-devenir-aidant'
   | 'demande-etre-aide'
   | 'solliciter-aide'

mon-aide-cyber-api/src/api/routesAPIUtilisateur.ts

@@ -3,7 +3,11 @@ import express, { Request, Response } from 'express';
 import { RequeteUtilisateur } from './routesAPI';
 import * as core from 'express-serve-static-core';
 import { NextFunction } from 'express-serve-static-core';
-import { constructeurActionsHATEOAS, ReponseHATEOAS } from './hateoas/hateoas';
+import {
+  constructeurActionsHATEOAS,
+  ReponseHATEOAS,
+  ReponseHATEOASEnErreur,
+} from './hateoas/hateoas';
 import { ErreurMAC } from '../domaine/erreurMAC';
 import { ServiceUtilisateur } from '../authentification/ServiceUtilisateur';
 import { validateursDeCreationDeMotDePasse } from './validateurs/motDePasse';
@@ -12,12 +16,14 @@ import {
   FieldValidationError,
   Meta,
   Result,
+  body,
   validationResult,
 } from 'express-validator';
 import { EntrepotUtilisateur } from '../authentification/Utilisateur';
 import { ServiceDeChiffrement } from '../securite/ServiceDeChiffrement';
 import { CommandeReinitialisationMotDePasse } from '../authentification/reinitialisation-mot-de-passe/CapteurCommandeReinitialisationMotDePasse';
 import { adaptateurConfigurationLimiteurTraffic } from './adaptateurLimiteurTraffic';
+import { unServiceAidant } from '../espace-aidant/ServiceAidantMAC';
 
 type CorpsRequeteReinitialiserMotDePasse = core.ParamsDictionary & {
   token: string;
@@ -160,5 +166,41 @@ export const routesAPIUtilisateur = (configuration: ConfigurationServeur) => {
     }
   );
 
+  routes.post(
+    '/valider-signature-cgu',
+    session.verifie('Valide les CGU'),
+    express.json(),
+    body('cguValidees')
+      .custom((value: boolean) => value)
+      .withMessage('Veuillez valider les CGU'),
+    async (
+      requete: RequeteUtilisateur,
+      reponse: Response<ReponseHATEOAS | ReponseHATEOASEnErreur>
+    ) => {
+      const resultatsValidation: Result<FieldValidationError> =
+        validationResult(requete) as Result<FieldValidationError>;
+      if (!resultatsValidation.isEmpty()) {
+        return reponse.status(422).json({
+          message: resultatsValidation
+            .array()
+            .map((resultatValidation) => resultatValidation.msg)
+            .join(', '),
+          ...constructeurActionsHATEOAS()
+            .pour({ contexte: 'valider-signature-cgu' })
+            .construis(),
+        });
+      }
+      return unServiceAidant(entrepots.aidants())
+        .valideLesCGU(requete.identifiantUtilisateurCourant!)
+        .then(() =>
+          reponse.status(200).json({
+            ...constructeurActionsHATEOAS()
+              .pour({ contexte: 'aidant:acceder-au-profil' })
+              .construis(),
+          })
+        );
+    }
+  );
+
   return routes;
 };

mon-aide-cyber-api/src/domaine/erreurMAC.ts

@@ -19,7 +19,8 @@ export type Contexte =
   | 'Modifie le profil Aidant'
   | 'Modifie les préférences de l’Aidant'
   | "Recherche d'un Aidé"
-  | 'Réinitialisation mot de passe';
+  | 'Réinitialisation mot de passe'
+  | 'Valide les CGU';
 
 export class ErreurMAC<T extends Error> extends Error {
   private constructor(

mon-aide-cyber-api/src/espace-aidant/ServiceAidant.ts

@@ -12,4 +12,6 @@ export interface ServiceAidant {
   rechercheParMail(mailAidant: string): Promise<AidantDTO | undefined>;
 
   parIdentifiant(identifiant: crypto.UUID): Promise<AidantDTO | undefined>;
+
+  valideLesCGU(identifiantAidant: crypto.UUID): Promise<void>;
 }

mon-aide-cyber-api/src/espace-aidant/ServiceAidantMAC.ts

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import { EntrepotAidant } from './Aidant';
 import { AidantDTO, ServiceAidant } from './ServiceAidant';
+import { FournisseurHorloge } from '../infrastructure/horloge/FournisseurHorloge';
 
 class ServiceAidantMAC implements ServiceAidant {
   constructor(private readonly entrepotAidant: EntrepotAidant) {}
@@ -31,6 +32,13 @@ class ServiceAidantMAC implements ServiceAidant {
       .catch(() => undefined);
   }
 
+  valideLesCGU(identifiantAidant: crypto.UUID): Promise<void> {
+    return this.entrepotAidant.lis(identifiantAidant).then(async (aidant) => {
+      aidant.dateSignatureCGU = FournisseurHorloge.maintenant();
+      return await this.entrepotAidant.persiste(aidant);
+    });
+  }
+
   private formateLeNom(nomPrenom: string): string {
     const [prenom, nom] = nomPrenom.split(' ');
     return `${prenom} ${nom ? `${nom[0]}.` : ''}`.trim();

mon-aide-cyber-api/test/api/routesAPIUtilisateur.spec.ts

@@ -5,7 +5,11 @@ import { executeRequete } from './executeurRequete';
 import { AdaptateurDeVerificationDeSessionAvecContexteDeTest } from '../adaptateurs/AdaptateurDeVerificationDeSessionAvecContexteDeTest';
 import { AdaptateurDeVerificationDeSessionDeTest } from '../adaptateurs/AdaptateurDeVerificationDeSessionDeTest';
 
-import { unUtilisateur } from '../constructeurs/constructeursAidantUtilisateur';
+import {
+  unAidant,
+  unCompteAidantRelieAUnCompteUtilisateur,
+  unUtilisateur,
+} from '../constructeurs/constructeursAidantUtilisateur';
 import {
   CorpsReponseReinitialiserMotDePasseEnErreur,
   ReponseReinitialisationMotDePasseEnErreur,
@@ -16,6 +20,7 @@ import { FournisseurHorlogeDeTest } from '../infrastructure/horloge/FournisseurH
 import { add } from 'date-fns';
 import { AdaptateurGestionnaireErreursMemoire } from '../../src/infrastructure/adaptateurs/AdaptateurGestionnaireErreursMemoire';
 import { liensPublicsAttendus } from './hateoas/liensAttendus';
+import { ReponseHATEOASEnErreur } from '../../src/api/hateoas/hateoas';
 
 describe('le serveur MAC sur les routes /api/utilisateur', () => {
   const testeurMAC = testeurIntegration();
@@ -33,6 +38,7 @@ describe('le serveur MAC sur les routes /api/utilisateur', () => {
   });
 
   describe('quand une requête GET est reçue sur /', () => {
+    beforeEach(() => adaptateurDeVerificationDeSession.reinitialise());
     it("retourne l'utilisateur connecté", async () => {
       const utilisateur = unUtilisateur().construis();
       await testeurMAC.entrepots.utilisateurs().persiste(utilisateur);
@@ -318,4 +324,130 @@ describe('le serveur MAC sur les routes /api/utilisateur', () => {
       });
     });
   });
+
+  describe("Lorsqu'une requête POST est reçue sur /utilisateur/valider-signature-cgu", () => {
+    const testeurMAC = testeurIntegration();
+    let donneesServeur: { portEcoute: number; app: Express };
+    beforeEach(() => {
+      testeurMAC.adaptateurDeVerificationDeSession =
+        new AdaptateurDeVerificationDeSessionDeTest();
+      donneesServeur = testeurMAC.initialise();
+    });
+
+    afterEach(() => {
+      testeurMAC.arrete();
+    });
+
+    it('Ajoute la date de signature des CGU', async () => {
+      FournisseurHorlogeDeTest.initialise(new Date());
+      const { utilisateur } = await unCompteAidantRelieAUnCompteUtilisateur({
+        entrepotUtilisateur: testeurMAC.entrepots.utilisateurs(),
+        constructeurAidant: unAidant().sansCGUSignees(),
+        entrepotAidant: testeurMAC.entrepots.aidants(),
+        constructeurUtilisateur: unUtilisateur(),
+      });
+      testeurMAC.adaptateurDeVerificationDeSession.utilisateurConnecte(
+        utilisateur
+      );
+
+      const reponse = await executeRequete(
+        donneesServeur.app,
+        'POST',
+        `/api/utilisateur/valider-signature-cgu`,
+        donneesServeur.portEcoute,
+        {
+          cguValidees: true,
+        }
+      );
+
+      expect(reponse.statusCode).toBe(200);
+      const aidantModifie = await testeurMAC.entrepots
+        .aidants()
+        .lis(utilisateur.identifiant);
+      expect(aidantModifie.dateSignatureCGU).toStrictEqual(
+        FournisseurHorloge.maintenant()
+      );
+    });
+
+    it("Accepte la requête et renvoie les actions possibles pour l'Aidant", async () => {
+      const { utilisateur } = await unCompteAidantRelieAUnCompteUtilisateur({
+        entrepotUtilisateur: testeurMAC.entrepots.utilisateurs(),
+        constructeurAidant: unAidant().sansCGUSignees(),
+        entrepotAidant: testeurMAC.entrepots.aidants(),
+        constructeurUtilisateur: unUtilisateur(),
+      });
+      testeurMAC.adaptateurDeVerificationDeSession.utilisateurConnecte(
+        utilisateur
+      );
+
+      const reponse = await executeRequete(
+        donneesServeur.app,
+        'POST',
+        `/api/utilisateur/valider-signature-cgu`,
+        donneesServeur.portEcoute,
+        {
+          cguValidees: true,
+        }
+      );
+
+      expect(await reponse.json()).toStrictEqual({
+        liens: {
+          'afficher-tableau-de-bord': {
+            methode: 'GET',
+            url: '/api/espace-aidant/tableau-de-bord',
+          },
+          'lancer-diagnostic': {
+            methode: 'POST',
+            url: '/api/diagnostic',
+          },
+          'modifier-mot-de-passe': {
+            methode: 'POST',
+            url: '/api/profil/modifier-mot-de-passe',
+          },
+          'modifier-profil': {
+            methode: 'PATCH',
+            url: '/api/profil',
+          },
+          'se-deconnecter': {
+            methode: 'DELETE',
+            url: '/api/token',
+          },
+        },
+      });
+    });
+
+    it('Vérifie la présence de la date de signature des CGU', async () => {
+      FournisseurHorlogeDeTest.initialise(new Date());
+      const { utilisateur } = await unCompteAidantRelieAUnCompteUtilisateur({
+        entrepotUtilisateur: testeurMAC.entrepots.utilisateurs(),
+        constructeurAidant: unAidant().sansCGUSignees(),
+        entrepotAidant: testeurMAC.entrepots.aidants(),
+        constructeurUtilisateur: unUtilisateur(),
+      });
+      testeurMAC.adaptateurDeVerificationDeSession.utilisateurConnecte(
+        utilisateur
+      );
+
+      const reponse = await executeRequete(
+        donneesServeur.app,
+        'POST',
+        `/api/utilisateur/valider-signature-cgu`,
+        donneesServeur.portEcoute,
+        {
+          cguValidees: false,
+        }
+      );
+
+      expect(reponse.statusCode).toBe(422);
+      expect(await reponse.json()).toStrictEqual<ReponseHATEOASEnErreur>({
+        message: 'Veuillez valider les CGU',
+        liens: {
+          'valider-signature-cgu': {
+            url: '/api/utilisateur/valider-signature-cgu',
+            methode: 'POST',
+          },
+        },
+      });
+    });
+  });
 });