[1084] add getOrCreate function to UserService (#1294)

* feat: add getorcreate function in UserService

* test: add tests for get or create user

* refactor: create or update user service

* test: update tests with new create or update service

* fix: file paths create or update user

* refactor: delete unused old usecase for users

* fix: update user test broken

* refactor: add update chech + code improvement

* test: add test case for not updating user

* refactor: implement comments on PR

* refactor: move one time used code in create user

Author: CollinPoetoehena

lib/server/WebUiServer.js

@@ -16,13 +16,9 @@ const { OpenIdConfig, JwtConfig } = require('../config');
 const { HttpServer } = require('@aliceo2/web-ui');
 const path = require('path');
 const buildEndpoints = require('./routers');
-const {
-    user: {
-        CreateOrUpdateUser,
-    },
-} = require('../usecases');
 const { BkpRoles } = require('../domain/enums/BkpRoles.js');
 const { isInTestMode } = require('../utilities/env-utils');
+const { createOrUpdateUser } = require('./services/user/createOrUpdateUser.js');
 
 /**
  * WebUI implementation of the Server.
@@ -61,7 +57,14 @@ class WebUiServer {
                     return;
                 }
 
-                const user = await new CreateOrUpdateUser().execute(request.session);
+                const user = await createOrUpdateUser(request.session);
+                if (request.session.access) {
+                    user.access = request.session.access;
+                }
+                if (request.session.username) {
+                    user.username = request.session.username;
+                }
+
                 if (isInTestMode() && request.query?.token) {
                     user.access = user.access ?? request.query.token === 'admin' ? [BkpRoles.ADMIN] : [BkpRoles.GUEST];
                 }

lib/server/services/user/UserService.js

@@ -11,8 +11,41 @@
  * or submit itself to any jurisdiction.
  */
 
+const { userAdapter } = require('../../../database/adapters/index.js');
+const { createOrUpdateUser } = require('./createOrUpdateUser.js');
+const { getUser } = require('./getUser.js');
+
 /**
  * @typedef UserIdentifier object to uniquely identify a user
  * @property {number} [userId] the id of the user in the application's context
  * @property {number} [externalUserId] the CERN user's id
  */
+
+/**
+ * Global service to handle user instances
+ */
+class UserService {
+    /**
+     * Find a user from the database or create it as a new user if it does not exist yet.
+     *
+     * @param {UserIdentifier} identifier the identifier of the user to find
+     * @param {string|null} name - username of the user
+     * @returns {User} - found user | newly created user
+     */
+    async getOrCreate(identifier, name) {
+        const foundUser = await getUser(identifier);
+
+        // If the user does not exist, create it as a new user
+        if (!foundUser) {
+            const { externalUserId } = identifier;
+            const user = await createOrUpdateUser({ personid: externalUserId, name });
+            return user ? userAdapter.toEntity(user) : null;
+        }
+
+        return userAdapter.toEntity(foundUser);
+    }
+}
+
+exports.UserService = UserService;
+
+exports.userService = new UserService();

lib/server/services/user/createOrUpdateUser.js

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright CERN and copyright holders of ALICE O2. This software is
+ * distributed under the terms of the GNU General Public License v3 (GPL
+ * Version 3), copied verbatim in the file "COPYING".
+ *
+ * See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ * In applying this license CERN does not waive the privileges and immunities
+ * granted to it by virtue of its status as an Intergovernmental Organization
+ * or submit itself to any jusdiction.
+ */
+
+const { getUser } = require('./getUser.js');
+const { BadParameterError } = require('../../errors/BadParameterError.js');
+const UserRepository = require('../../../database/repositories/UserRepository.js');
+
+/**
+ * Creates or updates a user in the database and returns the user object
+ *
+ * @param {Object} newUser the user to create
+ * @param {number} [newUser.personid] the CERN user's id, used as externalUserId
+ * @param {string|null} [newUser.name] username for in bookkeeping db
+ * @return {Promise<SequelizeUser>} resolve once the creation is done providing the user that has been (or will be) created
+ */
+exports.createOrUpdateUser = async (newUser) => {
+    const { personid, name } = newUser;
+
+    // Check null OR undefined because !personid returns true with personid == 0
+    if (personid === null || personid === undefined) {
+        throw new BadParameterError('Cannot create without personid');
+    }
+
+    // GetUser expects an identifier with two options, so surround it with {}
+    let user = await getUser({ externalUserId: personid });
+    if (user) {
+        if (user.name !== name) {
+            user = await UserRepository.update(user, { name });
+        }
+    } else {
+        user = await UserRepository.insert({ externalId: personid, name });
+    }
+
+    return user;
+};

lib/usecases/index.js

@@ -22,7 +22,6 @@ const server = require('./server');
 const status = require('./status');
 const subsystem = require('./subsystem');
 const tag = require('./tag');
-const user = require('./user');
 
 module.exports = {
     attachment,
@@ -36,5 +35,4 @@ module.exports = {
     status,
     subsystem,
     tag,
-    user,
 };

lib/usecases/user/CreateOrUpdateUser.js

@@ -24,6 +24,7 @@ const RunTypeSuite = require('./runType/index.js');
 const ShiftSuite = require('./shift/index.js');
 const StatisticsSuite = require('./statistics/index.js');
 const LhcPeriodSuite = require('./lhcPeriod');
+const UserSuite = require('./user/index.js');
 const { resetDatabaseContent } = require('../../../utilities/resetDatabaseContent.js');
 
 module.exports = () => {
@@ -44,4 +45,5 @@ module.exports = () => {
     describe('Shift', ShiftSuite);
     describe('Statistics', StatisticsSuite);
     describe('LhcPeriod', LhcPeriodSuite);
+    describe('User', UserSuite);
 };

test/lib/server/services/index.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright CERN and copyright holders of ALICE O2. This software is
+ * distributed under the terms of the GNU General Public License v3 (GPL
+ * Version 3), copied verbatim in the file "COPYING".
+ *
+ * See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ * In applying this license CERN does not waive the privileges and immunities
+ * granted to it by virtue of its status as an Intergovernmental Organization
+ * or submit itself to any jurisdiction.
+ */
+
+const { expect } = require('chai');
+const { userService } = require('../../../../../lib/server/services/user/UserService.js');
+const { getUser } = require('../../../../../lib/server/services/user/getUser.js');
+const { createOrUpdateUser } = require('../../../../../lib/server/services/user/createOrUpdateUser.js');
+
+module.exports = () => {
+    it('should successfully get the existing user with getOrCreate function', async () => {
+        const externalId = 1001;
+        const name = 'testUser';
+
+        // Create user in db
+        await createOrUpdateUser({ personid: externalId, name });
+
+        const user = await userService.getOrCreate({ externalUserId: externalId }, name);
+
+        // User should exist now
+        expect(user).not.to.be.null;
+        // Id should be filled automatically
+        expect(user.id).not.to.be.null;
+        // ExternalId and name should be equal
+        expect(user.externalId).to.equal(externalId);
+        expect(user.name).to.equal(name);
+    });
+
+    it('should successfully create the non-existing user with getOrCreate function', async () => {
+        const externalId = 1002;
+        const name = 'testUser';
+
+        // Before creation it should be null
+        const nullUser = await getUser({ externalUserId: externalId });
+        expect(nullUser).to.be.null;
+
+        // Create the user using the getOrCreate function
+        await userService.getOrCreate({ externalUserId: externalId }, name);
+        const user = await getUser({ externalUserId: externalId });
+
+        // User should exist now
+        expect(user).not.to.be.null;
+        // Id should be filled automatically
+        expect(user.id).not.to.be.null;
+        // ExternalId and name should be equal
+        expect(user.externalId).to.equal(externalId);
+        expect(user.name).to.equal(name);
+    });
+};

test/lib/server/services/user/UserService.test.js

@@ -0,0 +1,77 @@
+/**
+ *  @license
+ *  Copyright CERN and copyright holders of ALICE O2. This software is
+ *  distributed under the terms of the GNU General Public License v3 (GPL
+ *  Version 3), copied verbatim in the file "COPYING".
+ *
+ *  See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ *  In applying this license CERN does not waive the privileges and immunities
+ *  granted to it by virtue of its status as an Intergovernmental Organization
+ *  or submit itself to any jurisdiction.
+ */
+
+const { expect } = require('chai');
+const { createOrUpdateUser } = require('../../../../../lib/server/services/user/createOrUpdateUser');
+
+module.exports = () => {
+    it('should successfully create the user', async () => {
+        const externalId = 1000;
+        const name = 'testUser';
+
+        const user = await createOrUpdateUser({ personid: externalId, name });
+
+        // User should exist now
+        expect(user).not.to.be.null;
+        // Id should be filled automatically
+        expect(user.id).not.to.be.null;
+        // ExternalId and name should be equal
+        expect(user.externalId).to.equal(externalId);
+        expect(user.name).to.equal(name);
+    });
+
+    it('should successfully update the user', async () => {
+        const externalId = 1001;
+        const name = 'testUser';
+        const updatedName = 'testUserUpdated';
+
+        // Create user
+        const user = await createOrUpdateUser({ personid: externalId, name });
+
+        // Update user
+        const updatedUser = await createOrUpdateUser({ personid: externalId, name: updatedName });
+
+        // Users should exist now
+        expect(user).not.to.be.null;
+        expect(updatedUser).not.to.be.null;
+        // Id should be filled automatically
+        expect(user.id).not.to.be.null;
+        // Id of user and updatedUser should be the same because it is updated
+        expect(user.id).to.equal(updatedUser.id);
+        // ExternalId should be equal
+        expect(user.externalId).to.equal(updatedUser.externalId);
+        // Name should be updated
+        expect(updatedUser.name).to.equal(updatedName);
+    });
+
+    it('should not update the user but still return the same user', async () => {
+        const externalId = 1001;
+        const name = 'testUser';
+
+        // Create user
+        const user = await createOrUpdateUser({ personid: externalId, name });
+
+        // Update user with the same variables (should stay the same)
+        const sameUser = await createOrUpdateUser({ personid: externalId, name });
+
+        // Users should exist now
+        expect(user).not.to.be.null;
+        expect(sameUser).not.to.be.null;
+        // Id should be filled automatically
+        expect(sameUser.id).not.to.be.null;
+        // Id, externalId and name should be the same
+        expect(user.id).to.equal(sameUser.id);
+        expect(user.externalId).to.equal(sameUser.externalId);
+        expect(user.name).to.equal(sameUser.name);
+    });
+};

test/lib/server/services/user/createOrUpdateUser.test.js

@@ -11,8 +11,10 @@
  * or submit itself to any jurisdiction.
  */
 
-const CreateOrUpdateUser = require('./CreateOrUpdateUser');
+const UserServiceTest = require('./UserService.test.js');
+const createOrUpdateUserTest = require('./createOrUpdateUser.test.js');
 
-module.exports = {
-    CreateOrUpdateUser,
+module.exports = () => {
+    describe('createOrUpdateUser', createOrUpdateUserTest);
+    describe('UserService', UserServiceTest);
 };