feat(api): add importUserLastLoggedAt usecase

Author: P-Jeremy

api/src/identity-access-management/domain/usecases/import-user-last-logged-at.usecase.js

@@ -0,0 +1,39 @@
+import { UserLogin } from '../models/UserLogin.js';
+
+/**
+ * @typedef {function} importUserLastLoggedAt
+ * @param {Object} params
+ * @param {boolean} params.dryRun
+ * @param {string} params.userId
+ * @param {Date} params.lastActivity
+ * @param {UserRepository} params.userRepository
+ * @param {UserLoginRepository} params.userLoginRepository
+ * @return {Promise<boolean>}
+ */
+export const importUserLastLoggedAt = async function ({
+  dryRun,
+  userId,
+  lastActivity,
+  userRepository,
+  userLoginRepository,
+}) {
+  const user = await userRepository.findById(userId);
+  if (!user || user.hasBeenAnonymised) {
+    return false;
+  }
+
+  const userLogin = await userLoginRepository.findByUserId(userId);
+  if (!userLogin) {
+    const newUserLogin = new UserLogin({ userId, lastLoggedAt: lastActivity });
+    if (!dryRun) await userLoginRepository.create(newUserLogin);
+    return true;
+  }
+
+  if (userLogin.lastLoggedAt) {
+    return false;
+  }
+
+  userLogin.lastLoggedAt = lastActivity;
+  if (!dryRun) await userLoginRepository.update(userLogin, { preventUpdatedAt: true });
+  return true;
+};

api/tests/identity-access-management/integration/domain/usecases/import-user-last-logged-at.usecase.test.js

@@ -0,0 +1,164 @@
+import { usecases } from '../../../../../src/identity-access-management/domain/usecases/index.js';
+import { databaseBuilder, expect, sinon } from '../../../../test-helper.js';
+
+describe('Integration | Identity Access Management | Domain | UseCase | import user last logged at', function () {
+  let clock;
+  const now = new Date('2025-01-01');
+
+  beforeEach(function () {
+    clock = sinon.useFakeTimers({ now, toFake: ['Date'] });
+  });
+
+  afterEach(function () {
+    clock.restore();
+  });
+
+  context('when dryRun is false', function () {
+    let dryRun;
+
+    beforeEach(function () {
+      dryRun = false;
+    });
+
+    context('when the user exists', function () {
+      context('when the user has not been anonymized', function () {
+        context('when the user login has no lastloggedAt', function () {
+          it('updates the user login lastLoggedAt', async function () {
+            // given
+            const userId = databaseBuilder.factory.buildUser({
+              hasBeenAnonymised: false,
+            }).id;
+            databaseBuilder.factory.buildUserLogin({
+              userId,
+              lastLoggedAt: null,
+            });
+
+            await databaseBuilder.commit();
+
+            // when
+            await usecases.importUserLastLoggedAt({
+              dryRun,
+              userId,
+              lastActivity: new Date(),
+            });
+
+            // then
+            const userLoginUpdated = await databaseBuilder.knex('user-logins').where({ userId }).first();
+            expect(userLoginUpdated.lastLoggedAt).to.deep.equal(now);
+          });
+        });
+      });
+
+      context('when there is no user login', function () {
+        it('creates a new user login', async function () {
+          // given
+          const userId = databaseBuilder.factory.buildUser({
+            hasBeenAnonymised: false,
+          }).id;
+
+          await databaseBuilder.commit();
+
+          // when
+          await usecases.importUserLastLoggedAt({
+            dryRun,
+            userId,
+            lastActivity: new Date(),
+          });
+
+          // then
+          const userLoginCreated = await databaseBuilder.knex('user-logins').where({ userId }).first();
+          expect(userLoginCreated.lastLoggedAt).to.deep.equal(now);
+        });
+      });
+
+      context('when the user login has a lastLoggedAt', function () {
+        it('does nothing', async function () {
+          // given
+          const userId = databaseBuilder.factory.buildUser({
+            hasBeenAnonymised: false,
+          }).id;
+          databaseBuilder.factory.buildUserLogin({
+            userId,
+            lastLoggedAt: new Date('2020-01-01'),
+          });
+          await databaseBuilder.commit();
+
+          // when
+          const result = await usecases.importUserLastLoggedAt({
+            dryRun,
+            userId,
+            lastActivity: new Date(),
+          });
+
+          // then
+          const userLoginUpdated = await databaseBuilder.knex('user-logins').where({ userId }).first();
+          expect(userLoginUpdated.lastLoggedAt).to.deep.equal(new Date('2020-01-01'));
+          expect(result).to.be.false;
+        });
+      });
+    });
+
+    context('when the user has been anonymized', function () {
+      it('does nothing', async function () {
+        // given
+        const userId = databaseBuilder.factory.buildUser({
+          hasBeenAnonymised: true,
+        }).id;
+        databaseBuilder.factory.buildUserLogin({
+          userId,
+          lastLoggedAt: null,
+        });
+        await databaseBuilder.commit();
+
+        // when
+        const result = await usecases.importUserLastLoggedAt({
+          dryRun,
+          userId,
+          lastActivity: new Date(),
+        });
+
+        // then
+        const userLoginUpdated = await databaseBuilder.knex('user-logins').where({ userId }).first();
+        expect(userLoginUpdated.lastLoggedAt).to.be.null;
+        expect(result).to.be.false;
+      });
+    });
+
+    context('when the user does not exist', function () {
+      it('does nothing', async function () {
+        // when
+        const result = await usecases.importUserLastLoggedAt({
+          dryRun,
+          userId: 789,
+          lastActivity: new Date(),
+        });
+
+        // then
+        expect(result).to.be.false;
+      });
+    });
+  });
+
+  context('when dryRun is true', function () {
+    it('does nothing', async function () {
+      // given
+      const userId = databaseBuilder.factory.buildUser().id;
+      databaseBuilder.factory.buildUserLogin({
+        userId,
+        lastLoggedAt: null,
+      });
+      await databaseBuilder.commit();
+
+      // when
+      await usecases.importUserLastLoggedAt({
+        dryRun: true,
+        userId,
+        lastActivity: new Date(),
+      });
+
+      // then
+      const userLoginUpdated = await databaseBuilder.knex('user-logins').where({ userId }).first();
+      expect(userLoginUpdated.lastLoggedAt).to.be.null;
+    });
+  });
+});