Premier commit

bin/auth.js

@@ -0,0 +1,113 @@
+const { LogType } = require("loguix")
+const fs = require("fs")
+const path = require("path")
+const { __glob } = require("./global-variables")
+const alog = new LogType("Authentification")
+const keygen = require("./keygen")
+const users = require("./users")
+
+/**
+ * Vérifie si le token est présent et appartient à un utilisateur
+ * @param {string} token 
+ */
+
+module.exports.check = function(token) {
+    var isApproved = false;
+    var username = null
+    users.fetchUsers().forEach((fetchUser) => {
+        if(fetchUser.tokens.includes(token)) {
+            isApproved = true
+            username = fetchUser.username
+        }
+
+    })
+
+    if(isApproved) {
+        return true
+    } else {
+        if(token) {
+
+            alog.warn("Erreur d'authentification - Token n'existe pas : " + token)
+        }
+        return false
+    }
+} 
+
+/**
+ * Permet de se connecter à Inventory
+ * @param {object} data 
+ * @returns Token or AUTH_FAILED
+ */
+module.exports.login = function(data) {
+    var username = data.username
+    var password = data.password
+
+    if(users.fetchUsers().has(username)) {
+        const user = users.fetchUsers().get(username)
+        if(password == user.getPassword()) {
+            const token = user.generateToken()
+            alog.log("Connexion approuvé de l'utilisateur : " + username)
+            return token
+        } else {
+            alog.warn("Echec de connexion de l'utilisateur : " + username + " - Mot de passe incorrect")
+            return "AUTH_FAILED"
+        }
+
+    } else {
+        alog.warn("Echec de connexion de l'utilisateur : " + username + " - Utilisateur non-inscrit dans la base de donnée")
+        return "AUTH_FAILED"
+    }
+}   
+
+/**
+ * Remove the token
+ * @param {string} token 
+ * @returns 
+ */
+module.exports.signout = function(token) {
+    var isDone = false;
+    var username = null
+    users.fetchUsers().forEach((fetchUser) => {
+        if(fetchUser.tokens.includes(token)) {
+            isDone = true
+            username = fetchUser.username
+            fetchUser.removeToken(token)
+        }
+
+    })
+
+    if(isDone) {
+        alog.log("Suppression du Token '"  + token + "' de l'utilisateur : " + username)
+        return true
+    } else {
+        if(token) {
+
+            alog.warn("Erreur d'opération lors de la déconnexion - Token n'existe pas : " + token)
+        }
+        return false
+    }
+
+}
+
+module.exports.getUserByToken = function(token) {
+    var isApproved = false;
+    var userGetted = null
+    users.fetchUsers().forEach((fetchUser) => {
+        if(fetchUser.tokens.includes(token)) {
+            userGetted = fetchUser
+        }
+
+    })
+
+    if(userGetted) {
+        return userGetted
+
+    } else {
+        if(token) {
+
+            alog.warn("Erreur d'authentification - Token n'existe pas : " + token)
+        }
+        return false
+    }
+
+}

bin/config.js

@@ -0,0 +1,43 @@
+const { LogType } = require("loguix")
+const fs = require("fs")
+const path = require("path")
+const { __glob } = require("./global-variables")
+const clog = new LogType("Configuration")
+
+setup()
+
+function setup() {
+    if(!fs.existsSync(__glob.CONFIG)) {
+        clog.log("Création du fichier de configuration dans : " + __glob.CONFIG)
+        fs.writeFileSync(__glob.CONFIG, JSON.stringify({
+            ENCRYPTION_KEY: "1",
+        }, null, 2))
+    }
+}
+
+/**
+ * 
+ * @returns Config File
+ */
+module.exports.getFile = function () {
+    const file = JSON.parse(fs.readFileSync(__glob.CONFIG))
+    return file
+}
+
+/**
+ * Update le fichier configuration avec un object
+ * @param {Array} file 
+ */
+module.exports.updateFile = function (file) {
+    if(fs.existsSync(__glob.CONFIG)) {
+        clog.log("Mise à jour du fichier configuration dans : " + __glob.CONFIG)
+        fs.writeFileSync(__glob.CONFIG, JSON.stringify(file, null, 2))
+    }
+}
+
+module.exports.saveSettings = function (settings) {
+    const file = this.getFile()
+    file.JENKINS_TOKEN = settings.jenkins_token
+    file.OMEGA_KEY = settings.omega_token
+    this.updateFile(file)
+}

bin/global-variables.js

@@ -0,0 +1,17 @@
+const path = require("path");
+const root = path.resolve(__dirname, '../')
+
+const __glob = {
+    ROUTES: root + path.sep + "routes" + path.sep,
+    ROOT: root,
+    LOGS: root + path.sep + "logs",
+    DATA: root + path.sep + "data",
+    USERS: root + path.sep + "data" + path.sep + "users.json",
+    CONFIG: root + path.sep + "data" + path.sep + "config.json",
+    PACKAGE_JSON: root + path.sep + "package.json",
+};
+
+
+
+module.exports = { __glob };
+

bin/keygen.js

@@ -0,0 +1,29 @@
+const { LogType } = require("loguix")
+const fs = require("fs")
+const path = require("path")
+var CryptoJS = require("crypto-js")
+const { __glob } = require("./global-variables")
+const clog = new LogType("KeyGen")
+const config = require("./config")
+
+const keypass = config.getFile().ENCRYPTION_KEY
+
+setup()
+
+function setup() {
+    if(keypass) {  
+        clog.log("Clé de chiffrement trouvé et importé")
+    } else {   
+        clog.error("Clé de chiffrement inconnu : Passage en mode par défaut")
+    }
+}
+
+module.exports.encrypt = function (text) {
+    let encryptedText = CryptoJS.AES.encrypt(text, keypass).toString();
+    return encryptedText;
+  }
+
+module.exports.decrypt = function(text) {
+    let decryptedText = CryptoJS.AES.decrypt(text, keypass).toString(CryptoJS.enc.Utf8);
+    return decryptedText;
+  }

bin/users.js

@@ -0,0 +1,430 @@
+const { LogType } = require("loguix")
+const fs = require("fs")
+const path = require("path")
+const { __glob } = require("./global-variables")
+const ulog = new LogType("Users")
+const keygen = require("./keygen")
+const uuid = require("uuid")
+
+var usersList = new Map()
+
+setup()
+
+function setup() {
+
+    if(!fs.existsSync(__glob.USERS)) {
+        ulog.log("Création du fichier utilisateur dans : " + __glob.USERS)
+        fs.writeFileSync(__glob.USERS, JSON.stringify([], null, 2))
+    }
+}
+
+module.exports.getAllUsers = async function() {
+    return new Promise(async (resolve, reject) => {
+        const users = await this.fetchUsers()
+
+        // Remove for every people the password & the tokens
+
+        for(var user of users) {
+            user = user[1]
+            user.password = null
+            user.tokens = null
+        }
+        
+
+        resolve(JSON.stringify(Array.from(users)))
+    })
+   
+    
+}
+
+/**
+ * Get all users from Users Data Base
+ */
+module.exports.fetchUsers = function () {
+    
+    ulog.step.init("fetch_user", "Récupération de tous les utilisateurs inscrit dans la base de donnée")
+    const userFile = getFile()
+    usersList = new Map()
+    for(var userFetched of userFile) {
+        const user = new this.User({
+            username: userFetched.username,
+            password: userFetched.password,
+            display_name: userFetched.display_name,
+            tokens: userFetched.tokens,
+            lastLogin: userFetched.lastLogin,
+
+        })
+
+        usersList.set(user.username, user)    
+    }
+
+    if(usersList.size == 0) {
+        const adminUser = new this.User({
+            "username": "admin",
+            "password": "inventory",
+            "display_name": "Administrateur",
+            "tokens": [],
+            "lastLogin": "DEFAULT ACCOUNT",
+          })
+    
+    
+          adminUser.register()
+      
+
+    }
+
+    
+    ulog.step.end("fetch_user")
+
+    return usersList
+}
+
+/**
+ * User Class is used to access to default user's properties and methods
+ * @param {object} properties User properties with : username, password, display_name
+ */
+module.exports.User =  class {
+    username = null
+    password = null;
+    display_name = null
+    tokens = [] 
+    lastLogin = new Date()
+    
+    constructor(properties) {
+
+        if(properties) {
+
+            this.username = properties.username
+            this.password = keygen.encrypt(properties.password)
+            this.display_name = properties.display_name
+            this.tokens = properties.tokens
+            this.lastLogin = properties.lastLogin
+
+            const userFile = getFile()
+        
+            for(var userFetched of userFile) {
+                if(properties.username == userFetched.username) { 
+                    ulog.log("Récupération dans la base de donnée, de l'utilisateur : " + userFetched.username)
+                    this.username = userFetched.username
+                    this.password = userFetched.password
+                    this.display_name = userFetched.display_name
+                    this.tokens = userFetched.tokens
+                    this.lastLogin = userFetched.lastLogin
+                }
+            }
+            
+           
+
+           
+      
+        }
+
+     
+        if(this.username == null) {
+            ulog.error("One of user is without username ! [IMPORANT_FIELD_IS_MISSING]")
+            this.username = Math.random()
+        }
+        if(this.password == null) {
+            ulog.error("'" + this.username + "' is without password ! Password reset to 'default' [IMPORANT_FIELD_IS_MISSING]")
+            this.password = keygen.encrypt("default")
+        }
+        if(this.display_name == null) {
+            ulog.warn("'" + this.username + "' is without display name !")
+            this.display_name = this.username
+        }
+        
+        if(this.tokens == null) {
+            this.tokens = [] 
+        }
+        if(this.lastLogin == null) {
+            this.lastLogin = new Date()
+        }
+    
+       
+     
+    }
+    
+    register() {
+         
+        var alreadyExist = false
+        const userFile = getFile()
+        
+        for(var userFetched of userFile) {
+            if(userFetched.username == this.username) { 
+                userFile.splice(userFile.indexOf(userFetched), 1)
+                ulog.log("Mise à jour dans la base de donnée, de l'utilisateur : " + this.username)
+                alreadyExist = true
+            }
+        }
+        if(!alreadyExist) {
+            ulog.log("Création dans la base de donnée de l'utilisateur : " + this.username)
+        }
+        userFile.push(this)
+        updateFile(userFile)
+    
+        usersList.set(this.username, this)
+    }
+
+    unregister() {
+ 
+        var alreadyExist = false
+        const userFile = getFile()
+        
+        for(var userFetched of userFile) {
+            if(userFetched.username == this.username) { 
+                userFile.splice(userFile.indexOf(userFetched), 1)
+                ulog.log("Mise à jour dans la base de donnée, de l'utilisateur : " + this.username)
+                alreadyExist = true
+            }
+        }
+        if(!alreadyExist) {
+            ulog.log("L'utilisateur n'est pas enregistré dans la base de donnée : " + this.username)
+        }
+
+        updateFile(userFile)
+        usersList.delete(this.username)
+    }
+
+
+
+    setPassword(newPassword) {
+        this.#sync()
+        this.password = keygen.encrypt(newPassword)
+        this.register()
+        ulog.log("Le mot de passe de l'utilisateur a été modifié : " + this.username) 
+
+    }
+    getPassword() {
+        this.#sync()
+        return keygen.decrypt(this.password)
+    }   
+
+    generateToken() {
+        this.#sync()
+        const gToken = uuid.v4().toString()
+        this.tokens.push(gToken)
+        this.register()
+        return gToken
+
+    }
+
+    removeToken(token) {
+        this.#sync()
+        var haveToken = false
+        for(var aToken of this.tokens) {
+            if(token == aToken) {
+                haveToken = true
+            }
+        }
+        if(haveToken) {
+            this.tokens.splice(this.tokens.indexOf(token), 1)
+            this.register()
+        } else {
+
+            ulog.warn("'" + this.username + "' n'a pas le token : " + token)
+            return false
+        }
+
+    }
+
+    setDisplayName(text) {
+        this.#sync()
+        this.display_name = text
+        this.register()
+        ulog.log("Le nom d'affichage de l'utilisateur a été modifié : " + this.username) 
+
+    }
+
+    setNewUsername(text) {
+        this.#sync()
+        module.exports.deleteUser(this.username)
+        this.username = text
+        this.register()
+
+        ulog.log("Le nom d'utilisateur de l'utilisateur a été modifié : " + this.username) 
+
+    }
+
+    setLastLogin(text) {
+        this.#sync()
+        this.lastLogin = text
+        this.register()
+    }
+
+    clearTokens() {
+        this.#sync()
+        this.tokens = []
+        this.register()
+    }
+
+    #sync() {
+
+        for(var userGet of usersList.keys()) {
+            const userFetched = usersList.get(userGet)
+            if(this.username == userFetched.username) { 
+                this.username = userFetched.username
+                this.password = userFetched.password
+                this.display_name = userFetched.display_name
+                this.tokens = userFetched.tokens
+                this.lastLogin = userFetched.lastLogin
+            }
+        }
+            
+    }
+}
+
+module.exports.addUser = function(settings) {
+
+   if(settings.username == '') {
+       ulog.error("Le nom d'utilisateur est manquant")
+       return "USERNAME_MISSING"
+   } else if(settings.password == '') {
+         ulog.error("Le mot de passe est manquant")
+            return "PASSWORD_MISSING"
+    } else if(settings.display_name == '') {
+        ulog.error("Le nom d'affichage est manquant")
+        return "DISPLAY_NAME_MISSING"
+    } else if(this.getUser(settings.username)) {
+       ulog.error("L'utilisateur existe déjà : " + settings.username)
+       return "ALREADY_EXIST"
+    } else {
+        ulog.step.init("add_user", "Ajout d'un utilisateur dans la base de donnée : " + settings.username)
+    
+        const user = new this.User({
+            username: settings.username,
+            display_name: settings.display_name
+    
+        })
+    
+        user.setPassword(settings.password)
+        user.register()
+        ulog.step.end("add_user")
+    }
+   
+}
+
+module.exports.deleteUser = function(username) {
+    ulog.step.init("delete_user", "Suppression d'un utilisateur dans la base de donnée : " + username)
+    const user = this.getUser(username)
+    user.unregister()
+    ulog.step.end("delete_user")
+    return "OK"
+}
+
+
+module.exports.getUser = function(username) {
+    return usersList.get(username)
+}
+
+module.exports.editUser = function(settings) {
+    if(settings.username == '') {
+        ulog.error("Le nom d'utilisateur est manquant")
+        return "USERNAME_MISSING"
+    } else if(settings.display_name == '') {
+         ulog.error("Le nom d'affichage est manquant")
+         return "DISPLAY_NAME_MISSING"
+     } else {
+        ulog.step.init("edit_user", "Modification d'un utilisateur dans la base de donnée : " + settings.username)
+        const user = this.fetchUsers().get(settings.username)
+        if(user) {
+      
+            if(settings.newusername && settings.newusername != settings.username) {
+                if(this.getUser(settings.newusername)) {
+                    ulog.error("L'utilisateur existe déjà : " + settings.username)
+                    return "ALREADY_EXIST"
+                } else {
+
+                    user.setNewUsername(settings.newusername)
+                }
+            }
+            if(settings.display_name) {
+                user.setDisplayName(settings.display_name)
+            }
+         
+            if(settings.password) {
+                user.setPassword(settings.password)
+            }
+            
+          
+          
+            ulog.step.end("edit_user")
+            return "OK"
+        } else {
+            ulog.step.end("edit_user")
+            return "NOT_EXIST"
+        }
+
+    }
+}
+
+module.exports.editMySelf = function (settings, user) {
+    if(user.username == settings.username) {
+        if(settings.username == '') {
+            ulog.error("Le nom d'utilisateur est manquant")
+            return "USERNAME_MISSING"
+        } else if(settings.display_name == '') {
+            ulog.error("Le nom d'affichage est manquant")
+            return "DISPLAY_NAME_MISSING"
+        } else {
+            ulog.step.init("edit_user", "Modification d'un utilisateur dans la base de donnée : " + settings.username)
+            const user = this.fetchUsers().get(settings.username)
+            if(user) {
+                console.log(settings)
+                if(settings.newusername && settings.newusername != settings.username) {
+                    if(this.getUser(settings.newusername)) {
+                        ulog.error("L'utilisateur existe déjà : " + settings.username)
+                        return "ALREADY_EXIST"
+                    } else {
+
+                        user.setNewUsername(settings.newusername)
+                    }
+                }
+                if(settings.display_name) {
+                    user.setDisplayName(settings.display_name)
+                }
+            
+                if(settings.password) {
+                    user.setPassword(settings.password)
+                }
+             
+                ulog.step.end("edit_user")
+                return "OK"
+            } else {
+                ulog.step.end("edit_user")
+                return "NOT_EXIST"
+            }
+
+        }
+    } else {
+        ulog.error("Vous ne pouvez pas modifier les informations d'un autre utilisateur !")
+        return "NOT_ALLOWED"
+    }
+}
+
+module.exports.clearTokens = function(username) {
+   
+    const user = this.fetchUsers().get(username)
+    user.clearTokens()
+}
+
+
+/**
+ * 
+ * @returns User File
+ */
+function getFile() {
+    const file = JSON.parse(fs.readFileSync(__glob.USERS))
+    return file
+}
+
+/**
+ * Update le fichier utilisateur avec un object
+ * @param {Array} file 
+ */
+function updateFile(file) {
+    if(fs.existsSync(__glob.USERS)) {
+        ulog.log("Mise à jour du fichier utilisateur dans : " + __glob.USERS)
+        fs.writeFileSync(__glob.USERS, JSON.stringify(file, null, 2))
+    }
+}
+

bin/www

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+var log = require("loguix")
+var {LogType} = require("loguix")
+var { __glob } = require("./global-variables")
+log.setup(__glob.LOGS, __glob.PACKAGE_JSON)
+
+const wlog = new LogType("Serveur")
+
+if(process.env.DEV ) {
+
+  wlog.log("MODE DEVELOPEMENT ACTIF")
+}
+
+wlog.step.init("start_server",  "Démarrage du serveur Express JS")
+
+var app = require('../main');
+var http = require('http');
+var config = require("./config")
+
+/**
+ * Get port from environment and store in Express.
+ */
+
+var port = normalizePort(process.env.PORT || '5005');
+app.set('port', port);
+
+/**
+ * Create HTTP server.
+ */
+
+var server = http.createServer(app);
+
+/**
+ * Listen on provided port, on all network interfaces.
+ */
+
+
+server.listen(port);
+server.on('error', onError);
+server.on('listening', onListening);
+
+/**
+ * Normalize a port into a number, string, or false.
+ */
+
+function normalizePort(val) {
+  var port = parseInt(val, 10);
+
+  if (isNaN(port)) {
+    // named pipe
+    return val;
+  }
+
+  if (port >= 0) {
+    // port number
+    return port;
+  }
+
+  return false;
+}
+
+/**
+ * Event listener for HTTP server "error" event.
+ */
+
+function onError(error) {
+  if (error.syscall !== 'listen') {
+    throw error;
+  }
+
+  var bind = typeof port === 'string'
+    ? 'Pipe ' + port
+    : 'Port ' + port;
+
+  // handle specific listen errors with friendly messages
+  switch (error.code) {
+    case 'EACCES':
+      wlog.step.error("start_server", bind + ' requires elevated privileges');
+      process.exit(1);
+      break;
+    case 'EADDRINUSE':
+      wlog.step.error("start_server" , bind + ' is already in use');
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+}
+
+/**
+ * Event listener for HTTP server "listening" event.
+ */
+
+function onListening() {
+  wlog.log("Serveur entrain d'écouter sur le port : " + server.address().port)
+  var addr = server.address();
+  var bind = typeof addr === 'string'
+    ? 'pipe ' + addr
+    : 'port ' + addr.port;
+    wlog.step.end("start_server")
+}