[FEATURE] Implémenter la double écriture des CGU dans l'API acceptLegalDocumenByUserId (PIX-22581). #16386

pix-service-auto-merge · web-flow · commit eb8f5dad1750 · 2026-06-10T14:26:33.000+02:00
diff --git a/api/src/identity-access-management/application/user/user.controller.js b/api/src/identity-access-management/application/user/user.controller.js
@@ -23,27 +23,21 @@ const acceptPixCertifTermsOfService = async function (request, h) {
 /**
  * @param request
  * @param h
- * @param {{
- *   userSerializer: UserSerializer
- * }} dependencies
  * @return {Promise<*>}
  */
-const acceptPixLastTermsOfService = async function (request, h, dependencies = { userSerializer }) {
+const acceptPixAppTermsOfService = async function (request, h) {
   const authenticatedUserId = request.auth.credentials.userId;
 
-  const updatedUser = await usecases.acceptPixLastTermsOfService({
+  await usecases.acceptPixAppTermsOfService({
     userId: authenticatedUserId,
   });
 
-  return dependencies.userSerializer.serialize(updatedUser);
+  return h.response().code(204);
 };
 
 /**
  * @param request
  * @param h
- * @param {{
- *   userSerializer: UserSerializer
- * }} dependencies
  * @return {Promise<*>}
  */
 const acceptPixOrgaTermsOfService = async function (request, h) {
@@ -289,7 +283,7 @@ const upgradeToRealUser = async function (request, h, dependencies = { userSeria
 
 export const userController = {
   acceptPixCertifTermsOfService,
-  acceptPixLastTermsOfService,
+  acceptPixAppTermsOfService,
   acceptPixOrgaTermsOfService,
   changeUserLocale,
   getCertificationPointOfContact,
diff --git a/api/src/identity-access-management/application/user/user.route.js b/api/src/identity-access-management/application/user/user.route.js
@@ -258,7 +258,7 @@ export const userRoutes = [
           id: identifiersType.userId,
         }),
       },
-      handler: (request, h) => userController.acceptPixLastTermsOfService(request, h),
+      handler: (request, h) => userController.acceptPixAppTermsOfService(request, h),
       notes: [
         '- **Cette route est restreinte aux utilisateurs authentifiés**\n' +
           "- Sauvegarde le fait que l'utilisateur a accepté les dernières Conditions Générales d'Utilisation de Pix App\n" +
diff --git a/api/src/identity-access-management/domain/usecases/accept-pix-app-terms-of-service.usecase.js b/api/src/identity-access-management/domain/usecases/accept-pix-app-terms-of-service.usecase.js
@@ -0,0 +1,10 @@
+/**
+ * @param {{
+ *   userId: string,
+ *   userRepository: UserRepository
+ * }} params
+ * @return {Promise<void>}
+ */
+export const acceptPixAppTermsOfService = async function ({ userId, legalDocumentApiRepository }) {
+  await legalDocumentApiRepository.acceptPixAppTos({ userId });
+};
diff --git a/api/src/identity-access-management/domain/usecases/accept-pix-last-terms-of-service.usecase.js b/api/src/identity-access-management/domain/usecases/accept-pix-last-terms-of-service.usecase.js
diff --git a/api/src/identity-access-management/domain/usecases/index.js b/api/src/identity-access-management/domain/usecases/index.js
@@ -110,8 +110,8 @@ const utils = {
 
 const dependencies = Object.assign({ config, codeUtils }, repositories, services, validators, utils);
 
+import { acceptPixAppTermsOfService } from './accept-pix-app-terms-of-service.usecase.js';
 import { acceptPixCertifTermsOfService } from './accept-pix-certif-terms-of-service.usecase.js';
-import { acceptPixLastTermsOfService } from './accept-pix-last-terms-of-service.usecase.js';
 import { acceptPixOrgaTermsOfService } from './accept-pix-orga-terms-of-service.usecase.js';
 import { addOidcProvider } from './add-oidc-provider.js';
 import { addPixAuthenticationMethod } from './add-pix-authentication-method.usecase.js';
@@ -173,7 +173,7 @@ import { validateUserAccountEmail } from './validate-user-account-email.usecase.
 
 const usecasesWithoutInjectedDependencies = {
   acceptPixCertifTermsOfService,
-  acceptPixLastTermsOfService,
+  acceptPixAppTermsOfService,
   acceptPixOrgaTermsOfService,
   addOidcProvider,
   addPixAuthenticationMethod,
diff --git a/api/src/identity-access-management/infrastructure/repositories/legal-document-api.repository.js b/api/src/identity-access-management/infrastructure/repositories/legal-document-api.repository.js
@@ -4,6 +4,10 @@ const acceptPixOrgaTos = async ({ userId, dependencies = { legalDocumentApi } })
   return dependencies.legalDocumentApi.acceptLegalDocumentByUserId({ userId, service: 'pix-orga', type: 'TOS' });
 };
 
-const legalDocumentApiRepository = { acceptPixOrgaTos };
+const acceptPixAppTos = async ({ userId, dependencies = { legalDocumentApi } }) => {
+  return dependencies.legalDocumentApi.acceptLegalDocumentByUserId({ userId, service: 'pix-app', type: 'TOS' });
+};
+
+const legalDocumentApiRepository = { acceptPixAppTos, acceptPixOrgaTos };
 
 export { legalDocumentApiRepository };
diff --git a/api/src/identity-access-management/infrastructure/repositories/user.repository.js b/api/src/identity-access-management/infrastructure/repositories/user.repository.js
@@ -342,16 +342,6 @@ const updateHasSeenChallengeTooltip = async function ({ userId, challengeType })
   return new User(user);
 };
 
-const acceptPixLastTermsOfService = async function (id) {
-  const knexConn = DomainTransaction.getConnection();
-  const [user] = await knexConn('users')
-    .where({ id })
-    .update({ lastTermsOfServiceValidatedAt: new Date(), mustValidateTermsOfService: false, updatedAt: new Date() })
-    .returning('*');
-
-  return new User(user);
-};
-
 const updatePixCertifTermsOfServiceAcceptedToTrue = async function (id) {
   const knexConn = DomainTransaction.getConnection();
   const now = new Date();
@@ -443,7 +433,6 @@ const updateLastDataProtectionPolicySeenAt = async function ({ userId }) {
 
 /**
  * @typedef {Object} UserRepository
- * @property {function} acceptPixLastTermsOfService
  * @property {function} checkIfEmailIsAvailable
  * @property {function} findAnotherUserByEmail
  * @property {function} findAnotherUserByUsername
@@ -476,7 +465,6 @@ const updateLastDataProtectionPolicySeenAt = async function ({ userId }) {
  */
 
 export {
-  acceptPixLastTermsOfService,
   checkIfEmailIsAvailable,
   findAnotherUserByEmail,
   findAnotherUserByUsername,
diff --git a/api/src/legal-documents/domain/usecases/accept-legal-document-by-user-id.usecase.js b/api/src/legal-documents/domain/usecases/accept-legal-document-by-user-id.usecase.js
@@ -2,6 +2,9 @@ import { withTransaction } from '../../../shared/domain/DomainTransaction.js';
 import { LegalDocumentService } from '../models/LegalDocumentService.js';
 import { LegalDocumentType } from '../models/LegalDocumentType.js';
 
+const { TOS } = LegalDocumentType.VALUES;
+const { PIX_APP } = LegalDocumentService.VALUES;
+
 /**
  * Accepts a legal document by user ID.
  *
@@ -12,10 +15,15 @@ import { LegalDocumentType } from '../models/LegalDocumentType.js';
  * @returns {Promise<void>} A promise that resolves when the operation is complete.
  */
 const acceptLegalDocumentByUserId = withTransaction(
-  async ({ userId, service, type, legalDocumentRepository, userAcceptanceRepository, logger }) => {
+  async ({ userId, service, type, legalDocumentRepository, userAcceptanceRepository, userRepository, logger }) => {
     LegalDocumentType.assert(type);
     LegalDocumentService.assert(service);
 
+    // legacy document acceptance
+    if (type === TOS && service === PIX_APP) {
+      await userRepository.acceptLegacyPixAppTermsOfService(userId);
+    }
+
     const legalDocument = await legalDocumentRepository.findLastVersionByTypeAndService({ service, type });
     if (!legalDocument) {
       logger.warn(`No legal document found for service: ${service} and type: ${type}`);
diff --git a/api/src/legal-documents/infrastructure/repositories/user.repository.js b/api/src/legal-documents/infrastructure/repositories/user.repository.js
@@ -11,4 +11,14 @@ const getPixAppLegacyCguByUserId = async (userId) => {
   return user;
 };
 
-export { getPixAppLegacyCguByUserId };
+const acceptLegacyPixAppTermsOfService = async function (id) {
+  const knexConn = DomainTransaction.getConnection();
+  await knexConn('users').where({ id }).update({
+    lastTermsOfServiceValidatedAt: new Date(),
+    mustValidateTermsOfService: false,
+    updatedAt: new Date(),
+    cgu: true,
+  });
+};
+
+export { acceptLegacyPixAppTermsOfService, getPixAppLegacyCguByUserId };
diff --git a/api/tests/identity-access-management/acceptance/application/user/user.route.test.js b/api/tests/identity-access-management/acceptance/application/user/user.route.test.js
@@ -7,6 +7,8 @@ import * as authenticationMethodRepository from '../../../../../src/identity-acc
 import { emailValidationDemandRepository } from '../../../../../src/identity-access-management/infrastructure/repositories/email-validation-demand.repository.js';
 import * as userRepository from '../../../../../src/identity-access-management/infrastructure/repositories/user.repository.js';
 import { userEmailRepository } from '../../../../../src/identity-access-management/infrastructure/repositories/user-email.repository.js';
+import { LegalDocumentService } from '../../../../../src/legal-documents/domain/models/LegalDocumentService.js';
+import { LegalDocumentType } from '../../../../../src/legal-documents/domain/models/LegalDocumentType.js';
 import { constants } from '../../../../../src/shared/domain/constants.js';
 import { Assessment } from '../../../../../src/shared/domain/models/Assessment.js';
 import { featureToggles } from '../../../../../src/shared/infrastructure/feature-toggles/index.js';
@@ -19,6 +21,8 @@ import {
 } from '../../../../tooling/test-utils/http-server.js';
 
 const { pick } = lodash;
+const { PIX_APP } = LegalDocumentService.VALUES;
+const { TOS } = LegalDocumentType.VALUES;
 
 describe('Acceptance | Identity Access Management | Application | Route | User', function () {
   let server;
@@ -492,14 +496,16 @@ describe('Acceptance | Identity Access Management | Application | Route | User',
     });
 
     describe('Success case', function () {
-      it('returns the user with pixTermsOfServiceAccepted', async function () {
+      it('replies with 204 status code', async function () {
+        // given
+        databaseBuilder.factory.buildLegalDocumentVersion({ service: PIX_APP, type: TOS });
+        databaseBuilder.commit();
+
         // when
         const response = await server.inject(options);
 
         // then
-        expect(response.statusCode).to.equal(200);
-        expect(response.result.data.attributes['must-validate-terms-of-service']).to.be.false;
-        expect(response.result.data.attributes['last-terms-of-service-validated-at']).to.exist;
+        expect(response.statusCode).to.equal(204);
       });
     });
   });
diff --git a/api/tests/identity-access-management/integration/domain/usecases/accept-pix-app-terms-of-service.usecase.test.js b/api/tests/identity-access-management/integration/domain/usecases/accept-pix-app-terms-of-service.usecase.test.js
@@ -0,0 +1,36 @@
+import { usecases } from '../../../../../src/identity-access-management/domain/usecases/index.js';
+import { LegalDocumentService } from '../../../../../src/legal-documents/domain/models/LegalDocumentService.js';
+import { LegalDocumentType } from '../../../../../src/legal-documents/domain/models/LegalDocumentType.js';
+import { expect } from '../../../../test-helper.js';
+import { databaseBuilder, knex } from '../../../../tooling/databases.js';
+
+const { PIX_APP } = LegalDocumentService.VALUES;
+const { TOS } = LegalDocumentType.VALUES;
+
+describe('Integration | Identity Access Management | Domain | UseCase | accept-pix-app-terms-of-service', function () {
+  it('accepts Pix App terms of service and writes information at 2 places, legacy and new', async function () {
+    // given
+    const legalDocumentVersionId = databaseBuilder.factory.buildLegalDocumentVersion({
+      service: PIX_APP,
+      type: TOS,
+    }).id;
+    const userId = databaseBuilder.factory.buildUser({ mustValidateTermsOfService: true }).id;
+    await databaseBuilder.commit();
+
+    // when
+    await usecases.acceptPixAppTermsOfService({ userId });
+
+    // then
+
+    // Legacy information writing
+    const user = await knex('users').select().where({ id: userId }).first();
+    expect(user.mustValidateTermsOfService).to.be.false;
+
+    // New information writing
+    const legalDocumentVersionUserAcceptance = await knex('legal-document-version-user-acceptances')
+      .select()
+      .where({ legalDocumentVersionId, userId })
+      .first();
+    expect(legalDocumentVersionUserAcceptance).to.exist;
+  });
+});
diff --git a/api/tests/identity-access-management/integration/infrastructure/repositories/user.repository.test.js b/api/tests/identity-access-management/integration/infrastructure/repositories/user.repository.test.js
@@ -1832,26 +1832,6 @@ describe('Integration | Identity Access Management | Infrastructure | Repository
     });
   });
 
-  describe('#acceptPixLastTermsOfService', function () {
-    it('validates the last terms of service and save the date of acceptance ', async function () {
-      // given
-      const userId = databaseBuilder.factory.buildUser({
-        mustValidateTermsOfService: true,
-        lastTermsOfServiceValidatedAt: null,
-      }).id;
-      await databaseBuilder.commit();
-
-      // when
-      const actualUser = await userRepository.acceptPixLastTermsOfService(userId);
-
-      // then
-      expect(actualUser.lastTermsOfServiceValidatedAt).to.be.exist;
-      expect(actualUser.lastTermsOfServiceValidatedAt).to.be.a('Date');
-      expect(actualUser.mustValidateTermsOfService).to.be.false;
-      expect(actualUser.updatedAt).to.deep.equal(now);
-    });
-  });
-
   describe('#isUsernameAvailable', function () {
     const username = 'abc.def0101';
 
diff --git a/api/tests/identity-access-management/unit/domain/usecases/accept-pix-terms-of-service.usecase.test.js b/api/tests/identity-access-management/unit/domain/usecases/accept-pix-terms-of-service.usecase.test.js
diff --git a/api/tests/legal-documents/integration/domain/usecases/accept-legal-document-by-user-id.usecase.test.js b/api/tests/legal-documents/integration/domain/usecases/accept-legal-document-by-user-id.usecase.test.js
@@ -6,7 +6,7 @@ import { usecases } from '../../../../../src/legal-documents/domain/usecases/ind
 import { expect } from '../../../../test-helper.js';
 import { databaseBuilder, knex } from '../../../../tooling/databases.js';
 
-const { PIX_ORGA } = LegalDocumentService.VALUES;
+const { PIX_ORGA, PIX_APP } = LegalDocumentService.VALUES;
 const { TOS } = LegalDocumentType.VALUES;
 
 describe('Integration | Legal documents | Domain | Use case | accept-legal-document-by-user-id', function () {
@@ -105,4 +105,30 @@ describe('Integration | Legal documents | Domain | Use case | accept-legal-docum
       );
     });
   });
+
+  context('when accepting TOS for PIX_APP service (legacy)', function () {
+    it('updates the user table with acceptPixAppTermsOfService and creates legal document acceptance', async function () {
+      // given
+      const user = databaseBuilder.factory.buildUser({ lastTermsOfServiceValidatedAt: null, cgu: false });
+      const document = databaseBuilder.factory.buildLegalDocumentVersion({ service: PIX_APP, type: TOS });
+      await databaseBuilder.commit();
+
+      // when
+      await usecases.acceptLegalDocumentByUserId({ userId: user.id, service: PIX_APP, type: TOS });
+
+      // then
+      // Verify the user table was updated (legacy behavior)
+      const updatedUser = await knex('users').where({ id: user.id }).first();
+      expect(updatedUser.lastTermsOfServiceValidatedAt).to.exist;
+      expect(updatedUser.cgu).to.be.true;
+      expect(updatedUser.mustValidateTermsOfService).to.be.false;
+
+      // Verify the legal document acceptance was created
+      const userAcceptance = await knex('legal-document-version-user-acceptances')
+        .where('userId', user.id)
+        .where('legalDocumentVersionId', document.id)
+        .first();
+      expect(userAcceptance).to.exist;
+    });
+  });
 });
diff --git a/api/tests/legal-documents/integration/infrastructure/repositories/user.repository.test.js b/api/tests/legal-documents/integration/infrastructure/repositories/user.repository.test.js
@@ -1,9 +1,16 @@
+import sinon from 'sinon';
+
+import { LegalDocumentService } from '../../../../../src/legal-documents/domain/models/LegalDocumentService.js';
+import { LegalDocumentType } from '../../../../../src/legal-documents/domain/models/LegalDocumentType.js';
 import * as userRepository from '../../../../../src/legal-documents/infrastructure/repositories/user.repository.js';
 import { UserNotFoundError } from '../../../../../src/shared/domain/errors.js';
 import { expect } from '../../../../test-helper.js';
-import { databaseBuilder } from '../../../../tooling/databases.js';
+import { databaseBuilder, knex } from '../../../../tooling/databases.js';
 import { catchErr } from '../../../../tooling/test-utils/error.js';
 
+const { PIX_APP } = LegalDocumentService.VALUES;
+const { TOS } = LegalDocumentType.VALUES;
+
 describe('Integration | Legal documents | Infrastructure | Repository | UserRepository', function () {
   describe('#getPixAppLegacyCguByUserId', function () {
     it('returns the legacy CGU data for a user', async function () {
@@ -51,4 +58,29 @@ describe('Integration | Legal documents | Infrastructure | Repository | UserRepo
       expect(error).to.be.instanceof(UserNotFoundError);
     });
   });
+
+  describe('#acceptLegacyPixAppTermsOfService', function () {
+    it('validates the last terms of service and save the date of acceptance ', async function () {
+      // given
+      const now = new Date('2022-12-24');
+      sinon.useFakeTimers({ now, toFake: ['Date'] });
+      const userId = databaseBuilder.factory.buildUser({
+        mustValidateTermsOfService: true,
+        lastTermsOfServiceValidatedAt: null,
+      }).id;
+      databaseBuilder.factory.buildLegalDocumentVersion({ service: PIX_APP, type: TOS });
+      await databaseBuilder.commit();
+
+      // when
+      await userRepository.acceptLegacyPixAppTermsOfService(userId);
+      const actualUser = await knex('users').where({ id: userId }).first();
+
+      // then
+      expect(actualUser.lastTermsOfServiceValidatedAt).to.be.exist;
+      expect(actualUser.lastTermsOfServiceValidatedAt).to.be.a('Date');
+      expect(actualUser.mustValidateTermsOfService).to.be.false;
+      expect(actualUser.cgu).to.be.true;
+      expect(actualUser.updatedAt).to.deep.equal(now);
+    });
+  });
 });
diff --git a/mon-pix/app/controllers/terms-of-service.js b/mon-pix/app/controllers/terms-of-service.js
