545 lines
15 KiB
JavaScript
545 lines
15 KiB
JavaScript
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,
|
|
permission: userFetched.permission,
|
|
tokens: userFetched.tokens,
|
|
lastLogin: userFetched.lastLogin,
|
|
picture: userFetched.picture
|
|
|
|
})
|
|
|
|
usersList.set(user.username, user)
|
|
}
|
|
|
|
if(usersList.size == 0) {
|
|
const adminUser = new this.User({
|
|
"username": "admin",
|
|
"password": "neutral",
|
|
"display_name": "Administrateur",
|
|
"permission": [
|
|
"FILES_EXPLORER",
|
|
"SERVICES",
|
|
"SERVERS",
|
|
"PIPELINES",
|
|
"METRICS",
|
|
"USERS",
|
|
"LINKS",
|
|
"SETTINGS"
|
|
],
|
|
"tokens": [],
|
|
"lastLogin": "DEFAULT ACCOUNT",
|
|
"picture": "/images/default.jpg"
|
|
})
|
|
|
|
|
|
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, permission...
|
|
*/
|
|
module.exports.User = class {
|
|
username = null
|
|
password = null;
|
|
display_name = null
|
|
permission = []
|
|
tokens = []
|
|
lastLogin = new Date()
|
|
picture = "/images/default.jpg"
|
|
|
|
constructor(properties) {
|
|
|
|
if(properties) {
|
|
|
|
this.username = properties.username
|
|
this.password = keygen.encrypt(properties.password)
|
|
this.display_name = properties.display_name
|
|
this.permission = properties.permission
|
|
this.tokens = properties.tokens
|
|
this.lastLogin = properties.lastLogin
|
|
this.picture = properties.picture
|
|
|
|
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.permission = userFetched.permission
|
|
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.permission == null) {
|
|
ulog.warn("'" + this.username + "' has no longer permission !")
|
|
|
|
}
|
|
if(this.tokens == null) {
|
|
this.tokens = []
|
|
}
|
|
if(this.permission == null) {
|
|
this.permission = []
|
|
}
|
|
if(this.lastLogin == null) {
|
|
this.lastLogin = new Date()
|
|
}
|
|
if(this.picture == null) {
|
|
this.picture = "/images/default.jpg"
|
|
}
|
|
|
|
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
checkPermission(name) {
|
|
this.#sync()
|
|
if(this.permission.includes(name)) {
|
|
return true
|
|
} else {
|
|
|
|
return false
|
|
}
|
|
|
|
}
|
|
|
|
addPermission(name) {
|
|
this.#sync()
|
|
for(var perms of this.permission) {
|
|
if(name == perms) {
|
|
ulog.warn("'" + this.username + "' a déjà la permission : " + name)
|
|
return false
|
|
}
|
|
}
|
|
this.permission.push(name)
|
|
this.register()
|
|
}
|
|
|
|
removePermission(name) {
|
|
this.#sync()
|
|
var havePermission = false
|
|
for(var perms of this.permission) {
|
|
if(name == perms) {
|
|
havePermission = true
|
|
}
|
|
}
|
|
if(havePermission) {
|
|
this.permission.splice(this.permission.indexOf(name), 1)
|
|
this.register()
|
|
} else {
|
|
|
|
ulog.warn("'" + this.username + "' n'a pas la permission : " + name)
|
|
return false
|
|
}
|
|
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
}
|
|
|
|
setPicture(text) {
|
|
this.#sync()
|
|
this.picture = text
|
|
this.register()
|
|
ulog.log("La photo de l'utilisateur a été modifié : " + this.username)
|
|
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
setPicture(file) {
|
|
this.#sync()
|
|
var pictureDir = __glob.USERS_IMAGES + path.sep + uuid.v4().toString() + ".png"
|
|
if(!fs.existsSync(__glob.USERS_IMAGES)) {
|
|
fs.mkdirSync(__glob.USERS_IMAGES)
|
|
}
|
|
fs.writeFileSync(pictureDir, file)
|
|
|
|
this.picture = pictureDir.replace(__glob.USERS_IMAGES + path.sep, "/users/")
|
|
this.register()
|
|
}
|
|
|
|
setPermissions(permissions) {
|
|
this.#sync()
|
|
this.permission = permissions
|
|
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.permission = userFetched.permission
|
|
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)
|
|
var pictureDir = null
|
|
|
|
|
|
if(settings.picture == null) {
|
|
pictureDir = "/images/default.jpg"
|
|
} else {
|
|
pictureDir = __glob.USERS_IMAGES + path.sep + uuid.v4().toString() + ".png"
|
|
fs.writeFileSync(pictureDir, settings.picture)
|
|
|
|
|
|
}
|
|
|
|
const user = new this.User({
|
|
username: settings.username,
|
|
display_name: settings.display_name,
|
|
permission: settings.permissions,
|
|
picture: pictureDir.replace(__glob.USERS_IMAGES + path.sep, "/images/users/")
|
|
|
|
})
|
|
|
|
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)
|
|
}
|
|
|
|
if(settings.picture) {
|
|
user.setPicture(settings.picture)
|
|
}
|
|
if(settings.permissions) {
|
|
|
|
user.setPermissions(settings.permissions)
|
|
}
|
|
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)
|
|
}
|
|
|
|
if(settings.picture) {
|
|
user.setPicture(settings.picture)
|
|
}
|
|
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))
|
|
}
|
|
}
|
|
|