From e3299a373faf201925fbcd6039f93daf82399660 Mon Sep 17 00:00:00 2001
From: Quentin CHEVALIER <quentin.chevalier@polytechnique.edu>
Date: Mon, 9 Jul 2018 20:46:29 +0200
Subject: [PATCH] Ajout massif de try / catch
---
src/graphql/connectors/selectors.js | 2 +-
src/ldap/admins.js | 265 +++++++++++++++++-----------
src/ldap/basics.js | 2 +-
src/ldap/users.js | 156 +++++++++++-----
src/ldap/utilities.js | 82 ++++++---
5 files changed, 329 insertions(+), 178 deletions(-)
diff --git a/src/graphql/connectors/selectors.js b/src/graphql/connectors/selectors.js
index 5e4720d..1a0cf1b 100644
--- a/src/graphql/connectors/selectors.js
+++ b/src/graphql/connectors/selectors.js
@@ -1,5 +1,5 @@
/**
- * @file Des callbacks qui sélectionnent un sous-ensemble de groupes.
+ * @file Des callbacks qui sélectionnent un sous-ensemble de groupes. IN PROGRESS
* @author akka vodol
*/
diff --git a/src/ldap/admins.js b/src/ldap/admins.js
index 2da5cd4..f3badd0 100644
--- a/src/ldap/admins.js
+++ b/src/ldap/admins.js
@@ -5,7 +5,7 @@
*/
import LDAP from './basics';
-import {SmartSearch, Tests} from './utilities';
+import Tests from './utilities';
import User from './users';
// Essentiels pour le fichier de config
import path from 'path';
@@ -38,27 +38,37 @@ class Admin extends User {
* @async
*/
async addGroupMember(uid, gid) {
- // Vérifie que l'utilisateur est pas déjà membre pour groupes
- let lm = await this.getMembers(gid);
- if (!lm.includes(uid)) {
- let vals = {};
- vals[config.groups.member] = uid;
- // Erreur si pb lors de la modification
- if (!await LDAP.change(config.key_id+gid+config.dn_groups, "add", vals)) {
- throw "Erreur lors de la modification dans l'arbre des groupes";
+ try {
+ // Vérifie que l'utilisateur est pas déjà membre pour groupes
+ let lm = await this.getMembers(gid);
+ if (!lm.includes(uid)) {
+ let vals = {};
+ vals[config.groups.member] = uid;
+ // Erreur si pb lors de la modification
+ if (!await LDAP.change(config.key_id+gid+config.dn_groups, "add", vals)) {
+ throw "Erreur lors de la modification dans l'arbre des groupes pour ajouter un membre.";
+ }
}
}
- // Vérifie que l'utilisateur est pas déjà membre pour users
- let lg = await this.getGroups(uid);
- if (!lg.includes(gid)) {
- let vals2 = {};
- vals2[config.users.groups] = gid;
- // Erreur si pb lors de la modification
- if (!await LDAP.change(config.key_id+uid+config.dn_users, "add", vals2)) {
- throw "Erreur lors de la modification dans l'arbre des utilisateurs";
+ catch {
+ throw "Erreur lors de la recherche de la liste des membres pour ajouter un membre.";
+ }
+ try {
+ // Vérifie que l'utilisateur est pas déjà membre pour users
+ let lg = await this.getGroups(uid);
+ if (!lg.includes(gid)) {
+ let vals2 = {};
+ vals2[config.users.groups] = gid;
+ // Erreur si pb lors de la modification
+ if (!await LDAP.change(config.key_id+uid+config.dn_users, "add", vals2)) {
+ throw "Erreur lors de la modification dans l'arbre des utilisateurs pour ajouter un membre.";
+ }
}
+ return true;
+ }
+ catch {
+ throw "Erreur lors de la recherche de la liste des membres pour ajouter un membre.";
}
- return true;
}
/**
@@ -70,39 +80,49 @@ class Admin extends User {
* @async
*/
async delGroupMember(uid, gid) {
- // Vérifie que l'utilisateur est pas déjà viré pour groupes
- let lm = await this.getMembers(gid);
- if (lm.includes(uid)) {
- // Supprime tous les utilisateurs
- if (!await LDAP.change(config.key_id+gid+config.dn_groups, "del", config.group.member)) {
- throw "Erreur lors de la suppression de tous les membres du groupe.";
- }
- // Les rajoute un par un, sauf pour le supprimé
- lm.forEach(id => {
- if (id!=uid) {
- this.addGroupMember(id, gid).then(res => {
- if (!res) { throw "Erreur lors du ré-ajout des autres membres"; }
- });
+ try {
+ // Vérifie que l'utilisateur est pas déjà viré pour groupes
+ let lm = await this.getMembers(gid);
+ if (lm.includes(uid)) {
+ // Supprime tous les utilisateurs
+ if (!await LDAP.change(config.key_id+gid+config.dn_groups, "del", config.group.member)) {
+ throw "Erreur lors de la suppression de tous les membres du groupe.";
}
- });
- }
- let lg = await this.getGroups(uid);
- // Vérifie que l'utilisateur est pas déjà viré pour users
- if (lg.includes(gid)) {
- // Supprime tous les groupes
- if (!await LDAP.change(config.key_id+uid+config.dn_users, "del", config.member.groups)) {
- throw "Erreur lors de la suppression de tous les groupes du membre.";
+ // Les rajoute un par un, sauf pour le supprimé
+ lm.forEach(id => {
+ if (id!=uid) {
+ this.addGroupMember(id, gid).then(res => {
+ if (!res) { throw "Erreur lors du ré-ajout des autres membres"; }
+ });
+ }
+ });
}
- // Les rajoute un par un, sauf pour le supprimé
- lg.forEach(id => {
- if (id!=gid) {
- this.addGroupMember(uid, id).then(res => {
- if (!res) { throw "Erreur lors du ré-ajout des autres groupes"; }
- });
+ }
+ catch {
+ throw "Erreur pour obtenir une liste de membres d'un groupe pour supprimer un membre du groupe.";
+ }
+ try {
+ let lg = await this.getGroups(uid);
+ // Vérifie que l'utilisateur est pas déjà viré pour users
+ if (lg.includes(gid)) {
+ // Supprime tous les groupes
+ if (!await LDAP.change(config.key_id+uid+config.dn_users, "del", config.member.groups)) {
+ throw "Erreur lors de la suppression de tous les groupes du membre.";
}
- });
+ // Les rajoute un par un, sauf pour le supprimé
+ lg.forEach(id => {
+ if (id!=gid) {
+ this.addGroupMember(uid, id).then(res => {
+ if (!res) { throw "Erreur lors du ré-ajout des autres groupes"; }
+ });
+ }
+ });
+ }
+ return true;
+ }
+ catch {
+ throw "Erreur pour obtenir une liste de groupes d'un membres pour le supprimer du groupe.";
}
- return true;
}
/**
@@ -117,16 +137,21 @@ class Admin extends User {
async addGroupAdmin(uid, gid){
// Ajoute le membre au groupe avant d'en faire un admin
if (!await this.addGroupMember(uid,gid)) { throw "Erreur lors de l'ajout du futur admin en tant que membre."; }
- let la = await this.getAdmins(gid);
- if (!la.includes(uid)) {
- // Finalement modification, uniquement dans groups
- let vals = {};
- vals[config.groups.admin] = uid;
- if (!await LDAP.change(config.key_id+gid+config.dn_groups, "add", vals)) {
- throw "Erreur lors de l'ajout de l'admin dans l'arbre des groupes";
+ try {
+ let la = await this.getAdmins(gid);
+ if (!la.includes(uid)) {
+ // Finalement modification, uniquement dans groups
+ let vals = {};
+ vals[config.groups.admin] = uid;
+ if (!await LDAP.change(config.key_id+gid+config.dn_groups, "add", vals)) {
+ throw "Erreur lors de l'ajout de l'admin dans l'arbre des groupes.";
+ }
}
+ return true;
+ }
+ catch {
+ throw "Erreur lors de l'obtention de la liste des administrateurs d'un groupe.";
}
- return true;
}
/**
@@ -140,19 +165,24 @@ class Admin extends User {
async delGroupAdmin(uid, gid) {
// Peut paraître absurde mais permet de s'assurer que le membre est bien présent et que ses champs sont comme il faut
if (!(await this.delGroupMember(uid, gid)&&this.addGroupMember(uid,gid))) { throw "Erreur dans l'éjection/réadmission du futur admin."; }
- // Vérifie que l'utilisateur est bien admin (comme dans delGroupMember)
- let la = await this.getAdmins(gid);
- if (la.includes(uid)) {
- // Supprime tous les administrateurs
- if (!await LDAP.change(config.key_id+gid+config.dn_groups, "del", config.group.admin)) { throw "Erreur dans la suppression de tous les admins."; }
- // Les rajoute un par un, sauf pour le supprimé
- la.forEach(id => {
- if (id!=uid) { this.addGroupAdmin(id, gid).then(res => {
- if (!res) { throw "Erreur dans le réajout d'un des autres admins."; }
- }); }
- });
+ try {
+ // Vérifie que l'utilisateur est bien admin (comme dans delGroupMember)
+ let la = await this.getAdmins(gid);
+ if (la.includes(uid)) {
+ // Supprime tous les administrateurs
+ if (!await LDAP.change(config.key_id+gid+config.dn_groups, "del", config.group.admin)) { throw "Erreur dans la suppression de tous les admins pour en supprimer un."; }
+ // Les rajoute un par un, sauf pour le supprimé
+ la.forEach(id => {
+ if (id!=uid) { this.addGroupAdmin(id, gid).then(res => {
+ if (!res) { throw "Erreur dans le réajout d'un des autres admins."; }
+ }); }
+ });
+ }
+ return true;
+ }
+ catch {
+ throw "Erreur lors de l'obtention de la liste des administrateurs d'un groupe.";
}
- return true;
}
//------------------------------------------------------------------------------------------------------------------------
@@ -168,22 +198,27 @@ class Admin extends User {
* @async
*/
async editGroup(gid, data) {
- // Récupération des anciennes données
- let profil = await this.peekGroup(gid);
- // Reecriture de profil avec les bons champs
- Object.keys(profil).forEach(keyLDAP => {
- Object.keys(config.group).forEach(keyAlias => {
- config.group[keyAlias]=keyLDAP;
- profil[keyAlias]=profil[keyLDAP];
+ try {
+ // Récupération des anciennes données
+ let profil = await this.peekGroup(gid);
+ // Reecriture de profil avec les bons champs
+ Object.keys(profil).forEach(keyLDAP => {
+ Object.keys(config.group).forEach(keyAlias => {
+ config.group[keyAlias]=keyLDAP;
+ profil[keyAlias]=profil[keyLDAP];
+ });
});
- });
- // Surcharge des champs à modifier selon data
- Object.keys(data).forEach(key => {
- profil[key]=data[key];
- });
- // Modification propre
- if (!await this.delGroup(gid)&&await this.addGroup(profil)) { throw "Erreur de la destruction/recréation du groupe."; }
- return true;
+ // Surcharge des champs à modifier selon data
+ Object.keys(data).forEach(key => {
+ profil[key]=data[key];
+ });
+ // Modification propre
+ if (!await this.delGroup(gid)&&await this.addGroup(profil)) { throw "Erreur de la destruction/recréation du groupe pour le modifier."; }
+ return true;
+ }
+ catch {
+ throw "Erreur lors de l'obtention du profil d'un groupe pour le modifier.";
+ }
}
//------------------------------------------------------------------------------------------------------------------------
@@ -199,18 +234,23 @@ class Admin extends User {
* @async
*/
async delGroup(gid) {
- // Gestion des membres et administrateurs d'abord
- let profil = await this.constructor.peekGroup(gid);
- // Ordre important
- profil[config.group['admin']].forEach( id => {
- this.delGroupAdmin( id, gid).then(res => { if (!res) { throw "Erreur lors de la suppression d'un admin."; } });
- });
- profil[config.group['member']].forEach(id => {
- this.delGroupMember(id, gid).then(res => { if (!res) { throw "Erreur lors de la suppression d'un membre."; } });
- });
- // Elimination
- if (!await LDAP.clear(config.key_id+"="+gid+","+config.dn_groups)) { throw "Erreur lors de la suppression de la feuille dans l'arbre des groupes."; }
- return true;
+ try {
+ // Gestion des membres et administrateurs d'abord
+ let profil = await this.constructor.peekGroup(gid);
+ // Ordre important
+ profil[config.group['admin']].forEach( id => {
+ this.delGroupAdmin( id, gid).then(res => { if (!res) { throw "Erreur lors de la suppression d'un admin d'un groupe en cours de suppression."; } });
+ });
+ profil[config.group['member']].forEach(id => {
+ this.delGroupMember(id, gid).then(res => { if (!res) { throw "Erreur lors de la suppression d'un membre."; } });
+ });
+ // Elimination
+ if (!await LDAP.clear(config.key_id+"="+gid+","+config.dn_groups)) { throw "Erreur lors de la suppression de la feuille dans l'arbre des groupes."; }
+ return true;
+ }
+ catch {
+ throw "Erreur lors de l'obtention du profil d'un groupe pour le supprimer.";
+ }
}
}
@@ -256,7 +296,12 @@ class SuperAdmin extends Admin {
// uid de base généré à partir de nom et prénom, plus potentiellement promo et un offset
// MEF mélange de Promise et de fonction standard
- Tests.generateUid(data['givenName'],data['lastName'],data['promotion']).then(id => { vals[config.key_id]=id; } );
+ try {
+ Tests.generateUid(data['givenName'],data['lastName'],data['promotion']).then(id => { vals[config.key_id]=id; } );
+ }
+ catch {
+ throw "Erreur lors de la génération d'un hruid pour un nouvel utilisateur.";
+ }
// Ecriture de toutes les valeurs directement inscrites dans le LDAP (in pour input)
// Génère une erreur si un champ n'est pas rempli
@@ -292,8 +337,13 @@ class SuperAdmin extends Admin {
if ((data['nickname']!=undefined)&&(data['nickname']!='')) {
vals3[config.user['nickname']]=data['nickname'];
}
- // Génération id aléatoire unique
- vals3[config.user['id']]= await Tests.generateId(config.user['id'], config.dn_users);
+ try {
+ // Génération id aléatoire unique
+ vals3[config.user['id']]= await Tests.generateId(config.user['id'], config.dn_users);
+ }
+ catch {
+ throw "Erreur lors de la génération d'un id numérique pour un nouvel utilisateur.";
+ }
// Stockage machine ; dépend du prénom
vals3[config.user['directory']] = '/hosting/users/' + data['givenName'][0];
@@ -355,14 +405,19 @@ class SuperAdmin extends Admin {
* @async
*/
async delUser(uid) {
- // Gestion des groupes d'abord
- let profil = await this.peekUser(uid);
- profil[config.user['groups']].forEach(gid => {
- if (this.isGroupAdmin(gid)) {
- if (!this.delGroupAdmin(uid, gid)) { throw "Erreur lors de la suppression des droits d'admin de l'utilisateur."; }
- }
- if (!this.delGroupMember(uid, gid)) { throw "Erreur lors de la suppression de l'appartenace à un groupe de l'utilisateur."; }
- });
+ try {
+ // Gestion des groupes d'abord
+ let profil = await this.peekUser(uid);
+ profil[config.user['groups']].forEach(gid => {
+ if (this.isGroupAdmin(gid)) {
+ if (!this.delGroupAdmin(uid, gid)) { throw "Erreur lors de la suppression des droits d'admin de l'utilisateur."; }
+ }
+ if (!this.delGroupMember(uid, gid)) { throw "Erreur lors de la suppression de l'appartenace à un groupe de l'utilisateur."; }
+ });
+ }
+ catch {
+ throw "Erreur lors de l'obtention des informations de l'utilisateur à supprimer.";
+ }
// Elimination
if (!this.LDAP.clear(config.key_id+"="+uid+","+config.dn_users)) { throw "Erreur lors de la suppression de l'utilisateur."; }
}
diff --git a/src/ldap/basics.js b/src/ldap/basics.js
index 5ec3415..35c7cd0 100644
--- a/src/ldap/basics.js
+++ b/src/ldap/basics.js
@@ -91,7 +91,7 @@ class LDAP {
"filter": ldapEscape.filter("${txt}", { txt: filter}),
"attributes": attributes
}, (err, res) => {
- // Gestion erreur
+ // Gestion erreur ; pb car pas simple true / autre en sortie
if (err) {
reject(err);
throw "Erreur lors de la recherche sur le LDAP.";
diff --git a/src/ldap/users.js b/src/ldap/users.js
index 8fd2f2e..bc17727 100644
--- a/src/ldap/users.js
+++ b/src/ldap/users.js
@@ -24,7 +24,7 @@ class Open {
* @class Cette classe est la classe exportable de base permettant à un utilisateur non connecté de faire des petites recherches simples.
* @summary Constructeur vide.
*/
- constructor(config) {}
+ constructor() {}
//------------------------------------------------------------------------------------------------------------------------
// Fonctions de lecture
@@ -37,7 +37,12 @@ class Open {
* @static @async
*/
static async getGroups(uid) {
- return LDAP.search(config.key_id+uid+config.dn_users, config.user.groups)[0];
+ try {
+ return LDAP.search(config.key_id+uid+config.dn_users, config.user.groups)[0];
+ }
+ catch {
+ throw "Erreur lors de la recherche des groupes d'un individu.";
+ }
}
/**
@@ -48,7 +53,12 @@ class Open {
* @static @async
*/
static async getMembers(gid) {
- return LDAP.search(config.key_id+gid+config.dn_users, config.group.member)[0];
+ try {
+ return LDAP.search(config.key_id+gid+config.dn_users, config.group.member)[0];
+ }
+ catch {
+ throw "Erreur lors de la recherche des membres d'un groupe.";
+ }
}
/**
@@ -59,7 +69,12 @@ class Open {
* @static @async
*/
static async getAdmins(gid) {
- return LDAP.search(config.key_id+gid+config.dn_users, config.group.admin)[0];
+ try {
+ return LDAP.search(config.key_id+gid+config.dn_users, config.group.admin)[0];
+ }
+ catch {
+ throw "Erreur lors de la recherche des admins d'un groupe.";
+ }
}
/**
@@ -71,13 +86,15 @@ class Open {
* @static @async
*/
static async isGroupMember(uid, gid) {
- let lg = await this.getGroups(uid);
- let lm = await this.getMembers(gid);
- if (lg.includes(gid) && lm.includes(uid)) {
- return true;
+ try {
+ let lg = await this.getGroups(uid);
+ let lm = await this.getMembers(gid);
+ if (lg.includes(gid) && lm.includes(uid)) {
+ return true;
+ }
}
- else {
- return false;
+ catch {
+ throw "Erreur lors du test d'appartenance à un groupe.";
}
}
@@ -90,12 +107,14 @@ class Open {
* @static @async
*/
static async isGroupAdmin(uid, gid) {
- let la = await this.getAdmins(gid);
- if (la.includes(uid)) {
- return true;
+ try {
+ let la = await this.getAdmins(gid);
+ if (la.includes(uid)) {
+ return true;
+ }
}
- else {
- return false;
+ catch {
+ throw "Erreur lors du test d'appartenance au bureau d'administration un groupe.";
}
}
@@ -108,7 +127,12 @@ class Open {
* @static
*/
static peekUser(uid) {
- return LDAP.search(config.key_id+uid+config.dn_users, config.user.profil);
+ try {
+ return LDAP.search(config.key_id+uid+config.dn_users, config.user.profil);
+ }
+ catch {
+ throw "Erreur lors d'une recherche d'informations sur un individu.";
+ }
}
/**
@@ -120,7 +144,12 @@ class Open {
* @static
*/
static peekGroup(gid) {
- return LDAP.search(config.key_id+gid+config.dn_groups, config.group.profil);
+ try {
+ return LDAP.search(config.key_id+gid+config.dn_groups, config.group.profil);
+ }
+ catch {
+ throw "Erreur lors d'une recherche d'informations sur un groupe.";
+ }
}
//------------------------------------------------------------------------------------------------------------------------
@@ -131,19 +160,25 @@ class Open {
* @summary Fonction qui retrouve le groupe qui ressemblent à l'input et qui correspond au type fourni. Etape 0 vers un vrai TOL (Trombino On Line).
* @desc Cette fonction utilise {@link SmartSearch.groups}.
* @arg {string} input - String entré par l'utilisateur qui ressemble au nom du groupe.
- * @arg {string} type - String aux valeurs prédéfinies dans ldap_config.
* @return {Promise(string[])} Liste des gid dont le nom ressemble à l'input.
* @static @async
*/
- static async findGroups(input, type) {
- // Trucs intelligents faits dans ./utilities
- let gList = await SmartSearch.groups(input, [config.key_id, config.group.type]);
+ static async findGroups(input) {
+ try {
+ // Trucs intelligents faits dans ./utilities
+ return SmartSearch.groups(input, [config.key_id, config.group.type]);
+ }
+ catch {
+ throw "Erreur lors de la recherche approximative d'un groupe.";
+ }
+ /**
let gidtyList = [];
gList.forEach(g => {
// Si le groupe est du bon type on rajoute son gid
if (g[config.group.type]==type) { gidtyList.push(g[config.key_id]); }
});
return gidtyList;
+ */
}
/**
@@ -155,7 +190,12 @@ class Open {
* @static @async
*/
static async findUsers(data) {
- return SmartSearch.users(data, config.key_id);
+ try {
+ return SmartSearch.users(data, config.key_id);
+ }
+ catch {
+ throw "Erreur lors de la recherche approximative d'un utilisateur.";
+ }
}
}
@@ -170,7 +210,12 @@ class User extends Open {
*/
constructor(user) {
super();
- LDAP.bind(user);
+ try {
+ LDAP.bind(user);
+ }
+ catch {
+ throw "Erreur lors de la connexion à un compte utilisateur.";
+ }
}
//------------------------------------------------------------------------------------------------------------------------
@@ -195,7 +240,12 @@ class User extends Open {
let vals = {};
// uid de base généré à partir du nom standardisé
- Tests.generateReadableId(data['name']).then(id => { vals[config.group['name']]=id; });
+ try {
+ Tests.generateReadableId(data['name']).then(id => { vals[config.group['name']]=id; });
+ }
+ catch {
+ throw "Erreur lors de la génération d'un hruid pour créer un nouveau groupe.";
+ }
// Ecriture de toutes les valeurs directement inscrites dans le LDAP (in pour input)
config.group.direct_input.forEach(key_att => vals[config.group[key_att]]=data[key_att]);
@@ -214,7 +264,12 @@ class User extends Open {
vals2[config.user['password']] = '';
// Génération id aléatoire et test contre le LDAP
- Tests.generateId(config.groups["idNumber"], config.dn_groups).then(id => { vals2[config.group['idNumber']]=id; });
+ try {
+ Tests.generateId(config.groups["idNumber"], config.dn_groups).then(id => { vals2[config.group['idNumber']]=id; });
+ }
+ catch {
+ throw "Erreur lors de la génération d'un id numérique pour créer un nouveau groupe.";
+ }
// FOIREUX : Hypothèse sur la structure du reste des données mais évite un test.assurerUnicite à deux variables
vals2[config.group['idNumber2']]=vals2[config.group['idNumber']];
@@ -245,8 +300,16 @@ class User extends Open {
});
// Utilisation des fonctions adaptées pour assurer la cohérence de l'ensemble
- data['members'].forEach(uid => { Admin.addGroupMember(uid, vals[config.key_att]); });
- data['admins'].forEach(uid => { Admin.addGroupAdmin( uid, vals[config.key_att]); });
+ data['members'].forEach(uid => {
+ Admin.addGroupMember(uid, vals[config.key_att]).then(res => {
+ if (!res) { throw "Erreur de l'ajout d'un membre au groupe."; }
+ });
+ });
+ data['admins'].forEach(uid => {
+ Admin.addGroupAdmin( uid, vals[config.key_att]).then(res => {
+ if (!res) { throw "Erreur de l'ajout d'un admin au groupe."; }
+ });
+ });
return true;
}
@@ -277,24 +340,29 @@ class User extends Open {
});
});
// Régénération du champ manquant dans profil
- let lg = await this.getGroups(uid);
- profil['groupsIsAdmin']=[];
- lg.forEach(gid => {
- this.isGroupAdmin(uid, gid).then(res => {
- if (res) { profil['groupsIsAdmin'].push(gid); }
+ try {
+ let lg = await this.getGroups(uid);
+ profil['groupsIsAdmin']=[];
+ lg.forEach(gid => {
+ this.isGroupAdmin(uid, gid).then(res => {
+ if (res) { profil['groupsIsAdmin'].push(gid); }
+ });
});
- });
- // Surcharge des champs à modifier selon data
- Object.keys(data).forEach(key => {
- profil[key]=data[key];
- });
- // Passage en godmode
- var god = SuperAdmin({"uid":"", "password":""});
- // Modification propre par effet de bord
- if (!(await god.delUser(uid)&&await god.createUser(profil))) {
- throw "Erreur dans la destruction/création du compte.";
- } else {
- return true;
+ // Surcharge des champs à modifier selon data
+ Object.keys(data).forEach(key => {
+ profil[key]=data[key];
+ });
+ // Passage en godmode
+ var god = SuperAdmin({"uid":"", "password":""});
+ // Modification propre par effet de bord
+ if (!(await god.delUser(uid) && await god.createUser(profil))) {
+ throw "Erreur dans la destruction/création du compte.";
+ } else {
+ return true;
+ }
+ }
+ catch {
+ throw "Erreur lors de la modification des groupes où un utilisateur est admin.";
}
}
diff --git a/src/ldap/utilities.js b/src/ldap/utilities.js
index 2a18ceb..61d23c0 100644
--- a/src/ldap/utilities.js
+++ b/src/ldap/utilities.js
@@ -46,7 +46,12 @@ class SmartSearch {
"("+ config.key_id+"="+ input+"*))))"; // La valeur du début avec des trucs après
// Appel rechercheLDAP avec filtre de l'espace
- return LDAP.search(config.dn_groups, return_attributes, filter);
+ try {
+ return LDAP.search(config.dn_groups, return_attributes, filter);
+ }
+ catch {
+ throw "Erreur lors de la recherche intelligente d'un groupe.";
+ }
}
/**
@@ -84,15 +89,20 @@ class SmartSearch {
// Traduction en language LDAP
let attribute = config.user[key];
// Creation du filtre étape par étape
- filter="(&"+filter+ "(|("+attribute+"="+val+")"+ // On cherche la valeur exacte
+ filter="(&"+filter+ "(|("+attribute+"="+ val+")"+ // On cherche la valeur exacte
"(|("+attribute+"=*"+val+")"+ // La valeur finale avec des trucs avant ; wildcard * (MEF la wildcart ne marche pas pour tous les attributs)
"(|("+attribute+"=*"+val+"*)"+ // La valeur du milieu avec des trucs avant et après
- "("+attribute+"="+val+"*)))))"; // La valeur du début avec des trucs après
+ "("+ attribute+"="+ val+"*)))))"; // La valeur du début avec des trucs après
});
}
}
// Appel rechercheLDAP avec filtre de l'espace
- return LDAP.search(config.dn_users, return_attributes, filter);
+ try {
+ return LDAP.search(config.dn_users, return_attributes, filter);
+ }
+ catch {
+ throw "Erreur lors de la recherche intelligente d'un utilisateur.";
+ }
}
}
@@ -115,17 +125,20 @@ class Tests {
* @return {Promise(string)} Valeur unique dans le domaine spécifié de l'attribut spécifié
* @static @async
*/
- // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- // TBM PB DE THROW ; PB ABSENCE TOTAL DE DEBUG
- // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
static async ensureUnique(value, attribute, dn, changeValue, n=0) {
// Recherche d'autres occurences de l'id
- return LDAP.search(dn, config.key_id, "("+attribute+"="+value+")").then(matches => {
- // On renvoit la valeur si elle est bien unique
- if (matches.length==0) { return value; }
- // Sinon, on tente de nouveau notre chance avec la valeur suivante
- else { return this.ensureUnique(changeValue(value, n+1), dn, changeValue, n+1); }
- });
+ try {
+ return LDAP.search(dn, config.key_id, "("+attribute+"="+value+")").then(matches => {
+ if (!matches) { throw ""; }
+ // On renvoit la valeur si elle est bien unique
+ else if (matches.length==0) { return value; }
+ // Sinon, on tente de nouveau notre chance avec la valeur suivante
+ else { return this.ensureUnique(changeValue(value, n+1), dn, changeValue, n+1); }
+ });
+ }
+ catch {
+ throw "Erreur lors de la recherche d'une valeur pour assurer son unicité.";
+ }
}
/**
@@ -138,13 +151,18 @@ class Tests {
* @static @async
*/
static async generateUid(givenName, lastName, promotion) {
- // normalize et lowerCase standardisent le format
- return this.ensureUnique((givenName+'.'+lastName).toLowerCase().normalize('UFD'), config.key_id, config.dn_users, (id,n) => {
- if (n==1) { id+='.'+promotion; } // Si prénom.nom existe déjà , on rajoute la promo
- else if (n==2) { id+='.'+n-1; } // Puis si prénom.nom.promo existe déjà on passe à nom.prenom.promo .1
- else if (n>2) { id+=n; } // Ensuite on continue .23, .234, etc...
- return id;
- });
+ try {
+ // normalize et lowerCase standardisent le format
+ return this.ensureUnique((givenName+'.'+lastName).toLowerCase().normalize('UFD'), config.key_id, config.dn_users, (id,n) => {
+ if (n==1) { id+='.'+promotion; } // Si prénom.nom existe déjà , on rajoute la promo
+ else if (n==2) { id+='.'+n-1; } // Puis si prénom.nom.promo existe déjà on passe à nom.prenom.promo .1
+ else if (n>2) { id+=n; } // Ensuite on continue .123, .1234, etc...
+ return id;
+ });
+ }
+ catch {
+ throw "Erreur lors de l'assurance de l'unicité d'un human readable unique identifier (hruid).";
+ }
}
/**
@@ -155,12 +173,17 @@ class Tests {
* @static @async
*/
static async generateReadableId(name) {
- // normalize et lowerCase standardisent le format
- return this.ensureUnique(name.toLowerCase().normalize('UFD'), config.key_id, config.dn_groups, (id,n) => {
- if (n==1) { id+='.'+n; } // Si nom existe déjà , on essaie nom.1
- else if (n>1) { id+=+n; } // Ensuite on continue .12, .123, etc...
- return id;
- });
+ try {
+ // normalize et lowerCase standardisent le format
+ return this.ensureUnique(name.toLowerCase().normalize('UFD'), config.key_id, config.dn_groups, (id,n) => {
+ if (n==1) { id+='.'+n; } // Si nom existe déjà , on essaie nom.1
+ else if (n>1) { id+=n; } // Ensuite on continue .12, .123, etc...
+ return id;
+ });
+ }
+ catch {
+ throw "Erreur lors de l'assurance de l'unicité d'un human readable unique identifier (hruid).";
+ }
}
/**
@@ -172,7 +195,12 @@ class Tests {
* @static @async
*/
static async generateId(attribut, dn) {
- return this.ensureUnique("0", attribut, dn, (id,n) => { Math.floor((Math.random() * 100000) + 1).toString(); });
+ try {
+ return this.ensureUnique("0", attribut, dn, (id,n) => { Math.floor((Math.random() * 100000) + 1).toString(); });
+ }
+ catch {
+ throw "Erreur lors de l'assurance de l'unicité d'un unique identifier numérique.";
+ }
}
}
--
GitLab