EnonceCreate => Add user to db when doesn't exist

ExpressAPI/src/managers/UserManager.ts

@@ -35,13 +35,13 @@ class UserManager {
         return Promise.all(ids.map(userId => this.getById(userId)));
     }
 
-    async getByGitlabId(gitlabId: number): Promise<User | undefined> {
+    async getByGitlabId(gitlabId: number): Promise<User | number> {
         const raw = await db<User>(User.tableName).where('userGitlabId', gitlabId).first();
 
-        return raw ? this.createObjectFromRawSql(raw) : undefined;
+        return raw ? this.createObjectFromRawSql(raw) : gitlabId;
     }
 
-    async getByGitlabIds(gitlabIds: Array<number>): Promise<Array<User>> {
+    async getByGitlabIds(gitlabIds: Array<number>): Promise<Array<User | number>> {
         return Promise.all(gitlabIds.map(gitlabId => this.getByGitlabId(gitlabId)));
     }
 }

ExpressAPI/src/models/User.ts

@@ -12,10 +12,10 @@ class User extends Model {
     userID: number = null;
     userFirstName: string = '';
     userLastName: string = '';
-    userMail: string = null;
-    userGitlabId: number = null;
-    userRole: string = null;
-    userDeleted: boolean = null;
+    userMail: string = '';
+    userGitlabId: number = -1;
+    userRole: string = 'student';
+    userDeleted: boolean = false;
 
     userPassword: string = null;
 
@@ -51,6 +51,7 @@ class User extends Model {
         this.userFirstName = jsonObject.firstName;
         this.userLastName = jsonObject.lastName;
         this.userMail = jsonObject.mail;
+        this.userGitlabId = jsonObject.gitlabId;
         this.userRole = jsonObject.role;
         this.userDeleted = jsonObject.deleted;
     }
@@ -75,12 +76,14 @@ class User extends Model {
             userLastName : Toolbox.capitalizeName(this.userLastName),
             userRole     : this.userRole,
             userMail     : this.userMail,
+            userGitlabId : this.userGitlabId,
             userPassword : this.userPassword
         };
     }
 
-    create(): Promise<void> {
-        return db(User.tableName).insert(this.toDb());
+    async create(): Promise<void> {
+        const id = await db(User.tableName).insert(this.toDb());
+        this.userID = id[0];
     }
 
     update(): Promise<void> {

ExpressAPI/src/routes/EnonceRoutes.ts

@@ -18,6 +18,7 @@ import User                      from '../models/User';
 import Enonce                    from '../models/Enonce';
 import EnonceStaff               from '../models/EnonceStaff';
 import { AxiosError }            from 'axios';
+import logger                    from '../shared/logging/WinstonLogger';
 
 
 class EnonceRoutes implements RoutesManager {
@@ -103,19 +104,36 @@ class EnonceRoutes implements RoutesManager {
                                                         });
             await enonce.create();
 
-            let dojoUsers: Array<User> = [ req.session.profile, ...(await UserManager.getByGitlabIds(gitlabMembers.map(member => member.id))).filter(user => user) ]; // TODO: Remplacer le filter par une map qui créer l'utilisateur inconnu.
+            let dojoUsers: Array<User> = [ req.session.profile, ...(await Promise.all((await UserManager.getByGitlabIds(gitlabMembers.map(member => member.id))).map(async (user: User | number) => {
+                if ( typeof user === 'number' ) {
+                    const gitlabUser = gitlabMembers.find(member => member.id === user);
+
+                    user = User.createFromSql({
+                                                  userFirstName: gitlabUser.name,
+                                                  userGitlabId : gitlabUser.id
+                                              });
+
+                    await user.create();
+                }
+
+                return user as User;
+            }))) ];
             dojoUsers = dojoUsers.reduce((unique, user) => (unique.findIndex(uniqueUser => uniqueUser.userID === user.userID) !== -1 ? unique : [ ...unique, user ]), Array<User>());
             await Promise.all(dojoUsers.map(async (dojoUser: User) => {
-                return EnonceStaff.createFromSql({
+                const enonceStaff = EnonceStaff.createFromSql({
                                                                   enonceID: enonce.enonceID,
                                                                   userID  : dojoUser.userID
                                                               });
+
+                await enonceStaff.create();
             }));
 
             return req.session.sendResponse(res, StatusCodes.OK, enonce.toJsonObject());
         } catch ( error ) {
             if ( error instanceof AxiosError ) {
                 return res.status(error.response.status).send();
+            } else {
+                logger.error(error);
             }
 
             return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send();