From 3c01d6fa87a2c94a003e1e7105b3308d379f9286 Mon Sep 17 00:00:00 2001
From: Quentin CHEVALIER <quentin.chevalier@polytechnique.edu>
Date: Fri, 2 Mar 2018 09:25:01 +0100
Subject: [PATCH] =?UTF-8?q?S=C3=A9paration=20connect=20et=20config?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.gitignore | 2 +-
ldap_config.json | 40 +++++++++++
src/ldap/ldap_data.js | 152 ++++++++++++++++++++++--------------------
3 files changed, 119 insertions(+), 75 deletions(-)
create mode 100644 ldap_config.json
diff --git a/.gitignore b/.gitignore
index 2ff2621..88a9af3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,5 +69,5 @@ typings/
# Generated files
doc/
build/
-ldap_config.json
+ldap_connexion_config.json
sigma-back.service
\ No newline at end of file
diff --git a/ldap_config.json b/ldap_config.json
new file mode 100644
index 0000000..03abfc7
--- /dev/null
+++ b/ldap_config.json
@@ -0,0 +1,40 @@
+{
+ "ldap": {
+ "server": "ldap://frankiz.eleves.polytechnique.fr:389",
+ "searchBase": "ou=eleves,dc=frankiz,dc=net",
+ "searchFilter": "(uid={{username}})"
+ },
+ "dn_groups":"ou=groups,dc=frankiz,dc=net",
+ "dn_users": "ou=eleves,dc=frankiz,dc=net",
+ "key_id": "uid",
+ "filter_id": "(uid=${id})",
+ "filter_lg": "(restrictedMemberUid=${id})",
+ "attributes_id": ["uid"],
+ "attributes_al": ["memberUid"],
+ "attributes_lm":["restrictedMemberUid"],
+ "attributes_lg":["brMemberOf"],
+ "attributes_all": ["jpegPhoto","givenName", "sn", "brBirthdate", "brPromo","telephoneNumber","mail","brRoom","brIP","brMemberOf"],
+ "search_attributes_tol": ["givenName", "sn", "displayName", "country", "brMemberOf", "brPromo", "brMemberOf", "brMemberOf", "brMemberOf", "telephoneNumber","mail","brRoom","brIP"],
+ "input_search_names": ["givenName", "lastName", "nickname", "nationality", "school", "promotion", "groups", "studies", "sport", "phone", "mail", "adress", "ip"],
+ "user_infos": ["uid","givenName","sn","displayName", "brBirthdate", "uidNumber","gidNumber", "homeDirectory", "userPassword","brPromo","brMemberOf","loginShell","email","telephoneNumber","jpegPhoto","brRoom","brNewsReadAccess","brNewsPostAccess","brAlias","brIP","cn","gecos"],
+ "expr_values_user": {
+ "objectClass": [ "posixAccount", "shadowAccount", "inetOrgPerson", "brAccount" ],
+ "uid": "data['hruid']",
+ "givenName": "data['first_name']",
+ "sn": "data['last_name']",
+ "displayName": "data['nickname']",
+ "brBirthdate": "data['birthdate']",
+ "uidNumber": "(2*eval(data['uid'])+10000).toString()",
+ "gidNumber": "5000.toString()",
+ "homeDirectory": "'/hosting/users/' + data['hruid']",
+ "userPassword": "data['password']",
+ "brPromo": "data['promo']",
+ "loginShell":"if (data['on_platal']==true) { '/bin/bash'; } else { '/sbin/nologin'; }",
+ "email": "data['email']",
+ "telephoneNumber":"data['phone']",
+ "jpegPhoto": "data['photo']",
+ "brRoom": "data['room']",
+ "brNewsReadAccess": "'br.*,public.*'; if (data['read_perm']!=0) { 'br' } else {}"
+ },
+ "sessionSecret":"change this"
+}
\ No newline at end of file
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index 38db89d..9f744ab 100644
--- a/src/ldap/ldap_data.js
+++ b/src/ldap/ldap_data.js
@@ -3,16 +3,16 @@
* @author hawkspar
*/
-/* Ne pas hésiter à repasser en synthaxe ES5... Plus simple pour tester en solo avec node directement */
+/* Ne pas hésiter à repasser en synthaxe ES5... Plus simple pour tester en solo avec node directement
import ldap from 'ldapjs';
import fs from 'fs';
import ldapEscape from 'ldap-escape';
-import path from 'path';
+import path from 'path'; */
-/*var ldap = require('ldapjs');
+/**/var ldap = require('ldapjs');
var fs = require('fs');
var ldapEscape = require('ldap-escape');
-var path = require('path'); */
+var path = require('path');
// Important ; permet de vérifier que l'utilisateur reste connecté.
var ensureLoggedin = require('connect-ensure-login').ensureLoggedIn;
@@ -20,6 +20,9 @@ var ensureLoggedin = require('connect-ensure-login').ensureLoggedIn;
// Point central ; tous les champs de la BDD sont 'cachés' dans config.json et pas visibles directement
var configPath = path.resolve('./','ldap_config.json');
var config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+// Idem pour les ids de connexion temporaires
+var connectPath = path.resolve('./','ldap_connexion_config.json');
+var connect = JSON.parse(fs.readFileSync(connectPath, 'utf8'));
// Connection au serveur LDAP avec des temps de timeout arbitraires
var client = ldap.createClient({ url: config.ldap.server});
@@ -29,20 +32,21 @@ var client = ldap.createClient({ url: config.ldap.server});
//------------------------------------------------------------------------------------------------------------------------
/**
- * @summary Fonction qui sert à s'identifier sur le LDAP
+ * @summary Fonction qui sert à s'identifier sur le LDAP.
+ * @desc Assez important en terme de sécurité, de gestion de conflit, et de droit d'accès. Méthode ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode bind).
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
+ * @arg {string} user[uid] - User identifier
+ * @arg {string} user[password] - Mot de passe
*/
function bind(user) {
// TBM utiliser user
- client.bind(config.connexion.dn, config.connexion.passwd, (err, res) => {});
+ client.bind(connect.dn, connect.passwd, (err, res) => {});
}
/**
* @summary Fonction qui interroge le LDAP selon un protocole spécifié en argument et renvoit les valeurs trouvées.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `rechercheLDAP(user, ...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @desc Cette fonction appelle {@link bind} pour authentifier l'utilisateur pour authentifier l'utilisateur puis rompts la connexion. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `rechercheLDAP(user, ...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
* @arg {string} base - DN de l'emplacement de la requête
* @arg {string} filter - Filtre logique de la recherche (format RFC2254)
* @arg {Object} filter_dic - Dictionnaire qui associe les faux champs dans filter aux vraies valeurs pertinentes de la recherche
@@ -51,13 +55,12 @@ function bind(user) {
* @return {Object} Résultats de la recherche ; soit une liste de valeurs d'attributs, soit une liste de dictionnaires si on veut plus d'un attribut (les clés du dictionnaire sont celles du LDAP)
*/
function rechercheLDAP(user, base, filter, filter_dic, attributes) {
- // Debug
- //console.log(base);
- //console.log(filter);
- //console.log(filter_dic);
- //console.log(attributes);
return new Promise(function(resolve, reject) {
bind(user);
+ console.log(base);
+ console.log(filter);
+ console.log(filter_dic);
+ console.log(attributes);
let vals=[];
// Interrogation LDAP selon configuration fournie en argument
@@ -73,20 +76,18 @@ function rechercheLDAP(user, base, filter, filter_dic, attributes) {
// Dès que la recherche renvoit une entrée, on stocke les attributs qui nous intéresse
res.on('searchEntry', function(entry) {
// Cas un seul attribut où le résultat est une liste
- if (attributes.length == 1) { eval("vals.push(entry.object."+attributes[0]+")"); }
+ if (attributes.length == 1) { vals.push(entry.object[attributes[0]]); }
// Cas plusieurs attributs donc résultat dictionnaire
else {
vals.push({});
- attributes.forEach((element) => {
- vals.slice(-1)[0][element]=eval("entry.object."+element+";");
+ attributes.forEach((attribute) => {
+ vals.slice(-1)[0][attribute]=entry.object[attribute];
});
}
});
// Si la recherche est finie on se déconnecte et on renvoit la liste
res.on('end', function(res) {
client.bind("", "", (err, res) => {});
- // Debug
- //console.log(vals);
resolve(vals);
});
}
@@ -95,11 +96,12 @@ function rechercheLDAP(user, base, filter, filter_dic, attributes) {
}
/**
- * @summary Fonction qui permet de modifier un élément sur le LDAP.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode modify). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @summary Fonction qui permet de modifier un élément sur le LDAP. Gestion intelligente de l'appartenance à un binet.
+ * @desc Cette fonction appelle {@link bind} pour authentifier l'utilisateur pour authentifier l'utilisateur puis rompts la connexion. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode modify). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
- * @arg {Object} mod - Dictionnaire contenant les attributs à modifier et les modifications
+ * @arg {string} name - DN de l'endroit à modifier
+ * @arg {string} op - Operation à réaliser sur le LDAP. Trois opération sont possibles ; "add", qui rajoute des attributs et qui peut créer des doublons, "del" qui en supprime, et "replace" qui remplace du contenu par un autre.
+ * @arg {Object} mod - Dictionnaire contenant les attributs à modifier et les nouvelles valeurs des attributs. Une nouvelle valeur vide ("") est équivalent à la suppression de cet attribut.
* @return {boolean} `true` si la modification s'est bien déroulée, false sinon
*/
function modifierLDAP(user, name, op, mod) {
@@ -119,15 +121,14 @@ function modifierLDAP(user, name, op, mod) {
/**
* @summary Fonction qui permet de rajouter un élément sur le LDAP.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode add). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @desc Cette fonction appelle {@link bind} pour authentifier l'utilisateur puis rompts la connexion. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode add). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
* @arg {string} dn - Adresse du parent
* @arg {Object} vals - Dictionnaire contenant les valeurs à créer
* @arg {string} vals[key] - Nouvelle valeur pour le champ key
* @return {boolean} `true` si la modification s'est bien déroulée, false sinon
*/
-function addLDAP(user, dn, vals) {
+function ajoutLDAP(user, dn, vals) {
return new Promise(function(resolve, reject) {
bind(user);
// Ajout LDAP selon la configuration en argument
@@ -145,9 +146,8 @@ function addLDAP(user, dn, vals) {
/**
* @summary Fonction qui interroge le LDAP et retrouve les groupes dont un individu est membre.
- * @desc Cette fonction utilise rechercheLDAP avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups(...).then((res) => { truc avec res })`;
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups(...).then((res) => { truc avec res })`;
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
* @arg {string} uid - Identifiant de l'individu à interroger (le plus souvent prenom.nom, parfois l'année, supposé valide)
* @return {string} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
@@ -159,9 +159,8 @@ function listGroups(user, uid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve les groupes dont un individu est membre. Assez différente de la précédente en terme d'implémentation, plus lente mais renvoir moins de résultats plus pertinents, probablement plus pérenne.
- * @desc Cette fonction utilise rechercheLDAP avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups2(...).then((res) => { truc avec res });`
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups2(...).then((res) => { truc avec res });`
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
* @arg {string} uid - Identifiant de l'individu à interroger (le plus souvent prenom.nom, parfois l'année, supposé valide)
* @return {string} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
@@ -173,7 +172,7 @@ function listGroups2(user, uid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des membres d'un groupe.
- * @desc Cette fonction utilise rechercheLDAP avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listMembers(...).then((res) => { truc avec res });`
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listMembers(...).then((res) => { truc avec res });`
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
@@ -187,7 +186,7 @@ function listMembers(user, gid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des admins d'un groupe.
- * @desc Cette fonction utilise rechercheLDAP avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listAdmins(...).then((res) => { truc avec res });`
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listAdmins(...).then((res) => { truc avec res });`
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
@@ -201,9 +200,8 @@ function listAdmins(user, gid) {
/**
* @summary Fonction qui interroge le LDAP au sujet d'un uid particulier et qui renvoit toutes ses infos.
- * @desc Cette fonction utilise rechercheLDAP avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `rens(...).then((res) => { truc avec res });`
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `rens(...).then((res) => { truc avec res });`
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
* @arg {string} uid - Identifiant de l'utilisateur
* @return {Object} Informations recueillies ; rennvoit une liste de dictionnaire avec les mêmes clés que dans le TOL, voir config.json.
*/
@@ -215,40 +213,34 @@ function rens(user, uid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve juste les uid des paxs validant les critères de recherche. Première étape vers vrai TOL (Trombino On Line).
- * @desc Accepte des champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire.
+ * @desc Cette fonction utilise {@link rechercheLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
- * @arg {string} c0 [""] - Prénom
- * @arg {string} c1 [""] - Nom
- * @arg {string} c2 [""] - Surnom
- * @arg {string} c3 [""] - Nationalité
- * @arg {string} c4 [""] - Ecole ou université d'origine
- * @arg {string} c5 [""] - Promotion
- * @arg {string} c6 [""] - Groupe
- * @arg {string} c7 [""] - Cours
- * @arg {string} c8 [""] - Sport pratiqué
- * @arg {string} c9 [""] - Numéro de téléphone
- * @arg {string} c10 [""] - Adresse courriel
- * @arg {string} c11 [""] - Adresse physique
- * @arg {string} c12 [""] - Adresse ip
+ * @arg {Object} data - Dictionnaire contenant les données nécessaires à la recherche avec des champs lisibles (voir config).
+ * @arg {string} data[key] - La plupart des champs sont directement des string.
+ * @arg {string[]} data[key] - Mais certains des champs peuvent être des listes, permettant une recherche sur plusieurs valeurs du même critère.
* @return {string[]} uids des profils qui "match" les critères proposés.
*/
-function idTOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8="", c9="", c10="", c11="", c12="") {
+function idTOL(user, data) {
return new Promise(function(resolve, reject) {
let filter="";
let filter_dic={};
// Iteration pour chaque champ, alourdissement du filtre selon des trucs prédéfini dans config.json encore
- config.search_attributes_tol.forEach((element, index, list) => {
- if (eval("c"+index) != '') { // Si il y a qque chose à chercher pour ce filtre
- filter="(&"+filter+"(|("+element+"=${app_"+element+index+"})"+ // On cherche la valeur exacte
- "(|("+element+"=*${app_"+element+index+"})"+ // La valeur finale avec des trucs avant ; wildcard *
- "(|("+element+"=*${app_"+element+index+"}*)"+ // La valeur du milieu avec des trucs avant et après
- "("+element+"=${app_"+element+index+"}*)))))"; // La valeur du début avec des trucs après
- // Mise en relation de chaque valeur à la demande utilisateur dans un dico
- filter_dic["app_"+element+index]=eval("c"+index);
+ config.search_attributes_tol.forEach((attribute, index) => {
+ let offset=0;
+ let input_name=config.input_search_names[index];
+ if (data[input_name]!= undefined & data[input_name] != '') { // Si il y a qque chose à chercher pour ce filtre
+ if (!Array.isArray(data[input_name])) { data[input_name]=[data[input_name]]; } // Gestion d'une liste de valeurs à rechercher
+ data[input_name].forEach(val => {
+ filter="(&"+filter+ "(|("+attribute+"=${app_"+attribute+index+offset+"})"+ // On cherche la valeur exacte
+ "(|("+attribute+"=*${app_"+attribute+index+offset+"})"+ // La valeur finale avec des trucs avant ; wildcard *
+ "(|("+attribute+"=*${app_"+attribute+index+offset+"}*)"+ // La valeur du milieu avec des trucs avant et après
+ "("+attribute+"=${app_"+attribute+index+offset+"}*)))))"; // La valeur du début avec des trucs après
+ filter_dic["app_"+attribute+index+offset]=val;
+ offset+=1;
+ });
}
});
-
// Appel rechercheLDAP avec filtre de l'espace
rechercheLDAP(user, config.dn_users, filter, filter_dic, config.attributes_id).then(res => resolve(res));
});
@@ -256,7 +248,7 @@ function idTOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8=
/**
* @summary Fonction qui interroge le LDAP et retrouve les paxs validant les critères de recherche. Bien mais vite inutilisable car demande trop au LDAP et renvoie des erreurs de type size limit. Préférer idTOL puis stalk au cas par cas.
- * @desc Accepte des champs incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Utilise aussi requeteLDAP.
+ * @desc Cette fonction utilise {@link rechercheLDAP} avec un filtre généré à la volée. Accepte des champs incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Utilise aussi requeteLDAP.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} c0 - Prénom
@@ -279,33 +271,45 @@ function TOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8=""
let filter="";
let dic={};
// Iteration pour chaque champ, alourdissement du filtre selon des trucs prédéfini dans config.json encore
- config.search_attributes_tol.forEach((element, index, list) => {
+ config.search_attributes_tol.forEach((attribute, index, list) => {
if (eval("c"+index.toString()) != '') { // Si il y a qque chose à chercher pour ce filtre
- filter="(&"+filter+"(|("+element+"=${app_"+element+index+"})"+ // On cherche la valeur exacte
- "(|("+element+"=*${app_"+element+index+"})"+ // La valeur finale avec des trucs avant ; wildcard *
- "(|("+element+"=*${app_"+element+index+"}*)"+ // La valeur du milieu avec des trucs avant et après
- "("+element+"=${app_"+element+index+"}*)))))"; // La valeur du début avec des trucs après
+ filter="(&"+filter+"(|("+attribute+"=${app_"+attribute+index+"})"+ // On cherche la valeur exacte
+ "(|("+attribute+"=*${app_"+attribute+index+"})"+ // La valeur finale avec des trucs avant ; wildcard *
+ "(|("+attribute+"=*${app_"+attribute+index+"}*)"+ // La valeur du milieu avec des trucs avant et après
+ "("+attribute+"=${app_"+attribute+index+"}*)))))"; // La valeur du début avec des trucs après
// Mise en relation de chaque valeur à la demande utilisateur dans un dico
- dic["app_"+element+index]=eval("c"+index.toString());
+ dic["app_"+attribute+index]=eval("c"+index.toString());
}
});
// Debug
//console.log(filter);
//console.log(dic);
-
rechercheLDAP(user, config.dn_users, filter, dic, config.attributes_all).then(res => resolve(res));
});
}
//------------------------------------------------------------------------------------------------------------------------
-// Fonctions de modification
+// Fonctions créatrices
//------------------------------------------------------------------------------------------------------------------------
/**
* @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
* @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
- * @arg {string} user[key] - uid et password
+ * @arg {Object} data - Dictionnaire des informations utilisateurs (voir détail des champs dans config.json)
+ * @return {boolean} `true` si la modification s'est bien déroulée, false sinon
+ */
+function creerUtilisateurLDAP(user, data) {
+ return new Promise(function(resolve, reject) {
+ let data = {};
+ reject(false);
+ });
+}
+
+/**
+ * @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
+ * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} gid - Identifiant du group
* @arg {string} nom - Nom commun du group
* @arg {string} status - Statut du groupe (binet, autre ?)
@@ -313,7 +317,7 @@ function TOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8=""
* @arg {string[]} members - Nouvelle valeur des attributs
* @return {boolean} `true` si la modification s'est bien déroulée, false sinon
*/
-function creerGroupe(user, gid, nom, status, admins, members) {
+function creerGroupeLDAP(user, gid, nom, status, admins, members) {
return new Promise(function(resolve, reject) {
let data = {};
data["uid"] = gid;
@@ -324,10 +328,10 @@ function creerGroupe(user, gid, nom, status, admins, members) {
});
}
-//listGroups({},"anatole.romon").then(res => console.log(res));
-//TOL({},"","","","","","","absolutvodkes","","","","","","").then(res => console.log(res));
+//idTOL({},{"group": "br"}).then(res => console.log(res));
+rechercheLDAP({},"ou=eleves,dc=frankiz,dc=net","(brMemberOf=${gr}*)",{gr: "faer"},["uid"]);
-/* Partage pour le reste du monde ; même remarque synthaxe que pour l'import */
-export { listGroups, listMembers, listAdmins, rens, idTOL, TOL };
+/* Partage pour le reste du monde ; même remarque synthaxe que pour l'import
+export { listGroups, listMembers, listAdmins, rens, idTOL, TOL }; */
-/*module.exports ={ listGroups, listMembers, listAdmins, rens, idTOL, TOL }; */
+module.exports ={ listGroups, listMembers, listAdmins, rens, idTOL, TOL }; /**/
--
GitLab