diff --git a/README.md b/README.md
index a0c3b75e2b17660278364408c01cdc893391e2b0..005b55dd0f8ee8a69c0845945c0ab061ed6eb3c9 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
[](https://gitlab.binets.fr/br/sigma-backend/commits/master)
-# Introduction
+## Introduction
Ce dépôt contient le _backend_ de Sigma, le successeur de Frankiz, un site étudiant permettant de gérer les groupes et les étudiants du plateau de Saclay.
diff --git a/src/graphql/schema.js b/src/graphql/schema.js
index 3ec8bdb31ac2ceac7d1d1131f46f8a66a4ca32ec..47e31154f702c11c426cfeaf69315ca747c48d15 100644
--- a/src/graphql/schema.js
+++ b/src/graphql/schema.js
@@ -3,7 +3,7 @@
* @author akka vodol
*/
import knex from '../../db/knex_router';
-import { rens, idTOL, listGroups, listMembers, listAdmins } from '../ldap/ldap_data';
+import { renseignerSurUtilisateur, repliquerTOLdesIds, listerGroupes, listerMembres, listerAdministrateurs } from '../ldap/ldap_data';
import { makeExecutableSchema } from 'graphql-tools';
import { request } from 'https';
import { assertBinaryExpression } from 'babel-types';
@@ -74,7 +74,7 @@ const typeDefs = `
* @return {Promise} Retour de requête knex. Promise qui renvera une liste de tous les utilisateurs ayant droit d'admin sur le groupe
*/
const getUsersWithAdminRights = (user, groupUID) => {
- return listAdmins(user, groupUID).then(adminList => {
+ return listerAdministrateurs(user, groupUID).then(adminList => {
if(typeof adminList == "undefined")
return undefined;
else
@@ -109,7 +109,7 @@ const hasAdminRights = (user, groupuid) => {
*/
const getAllVisibleGroups = (user) => {
- return listGroups(user, user.uid).then(group_ids => {
+ return listerGroupes(user, user.uid).then(group_ids => {
if(typeof group_ids == "undefined")
throw "invalid user";
var membered_groups = qb => qb.select().from('groups').whereIn('uid', group_ids.concat(['kes']));
@@ -222,7 +222,7 @@ const resolvers = {
console.log("Logged in as:",context.user);
- const result = rens(context.user, args.uid).then(res => {
+ const result = renseignerSurUtilisateur(context.user, args.uid).then(res => {
const output = res.map(entry => refactorer(entry));
return output;
});
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index f82fb7b7ac28bb1d96e533ee5fc7084131ce7438..501d511edc1823bb8ff560cf1ebf12cf66e503f1 100644
--- a/src/ldap/ldap_data.js
+++ b/src/ldap/ldap_data.js
@@ -1,5 +1,5 @@
/**
- * @file Ce fichier gère les requêtes LDAP de type données ; liste des groupe d'un individu, liste des membres d'un groupe... A ne pas confondre avec ldap_auth qui lui gère l'authentification. Il est à lire conjointement avec config.json qui détaille les pats et champs spécifique à un LDAP.
+ * @file Ce fichier gère les requêtes LDAP de type données ; liste des groupe d'un individu, liste des membres d'un groupe... A ne pas confondre avec ldap_auth qui lui gère l'authentification. Il est à lire conjointement avec config.json qui détaille les paxs et champs spécifique à un LDAP. Il est fortement conseillé d'utiliser [`JXplorer`](http://jxplorer.org/) pour baviguer sur le LDAP en parallèle du dévelopement.
* @author hawkspar
*/
@@ -32,30 +32,30 @@ 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. Renvoit rien.
* @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[uid] - User identifier
* @arg {string} user[password] - Mot de passe
*/
-function bind(user) {
+function connecterLDAP(user) {
// TBM utiliser user
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 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).
+ * @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 `rechercherLDAP(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} base - DN de l'emplacement de la requête
* @arg {string} filter - Filtre logique de la recherche (format [`RFC2254`](https://tools.ietf.org/search/rfc2254)) déjà passé au ldapEscape
* @arg {string} filter_dic[key] - Vraie valeur pertinente de la recherche
* @arg {string[]} attributes - Liste des attributs qui figureront dans le résultat final
- * @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)
+ * @return {Promise(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, attributes) {
+function rechercherLDAP(user, base, filter, attributes) {
return new Promise(function(resolve, reject) {
- bind(user);
+ connecterLDAP(user);
//Debug
/*console.log(base);
console.log(filter);
@@ -101,11 +101,11 @@ function rechercheLDAP(user, base, filter, attributes) {
* @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
+ * @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
function modifierLDAP(user, name, op, mod) {
return new Promise(function(resolve, reject) {
- bind(user);
+ connecterLDAP(user);
// Modification LDAP selon configuration en argument (pourrait prendre une liste de Changes)
client.modify(name, new ldap.Change({
operation: op,
@@ -125,11 +125,11 @@ function modifierLDAP(user, name, op, mod) {
* @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
+ * @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
-function ajoutLDAP(user, dn, vals) {
+function ajouterLDAP(user, dn, vals) {
return new Promise(function(resolve, reject) {
- bind(user);
+ connecterLDAP(user);
// Ajout LDAP selon la configuration en argument
client.add(config.key_id+"="+vals["uid"]+","+dn, vals, function(err) {
reject(err);
@@ -145,78 +145,78 @@ function ajoutLDAP(user, dn, vals) {
/**
* @summary Fonction qui interroge le LDAP et retrouve les groupes dont un individu est membre.
- * @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 });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @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
+ * @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
-function listGroups(user, uid) {
+function listerGroupes(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user,config.dn_users, ldapEscape.filter(config.filter_id, { id : uid }), config.attributes_lg).then(res => resolve(res[0]));
+ rechercherLDAP(user,config.dn_users, ldapEscape.filter(config.filter_id, { id : uid }), config.attributes_lg).then(res => resolve(res[0]));
});
}
/**
* @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 {@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 });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listGroups2(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @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
+ * @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
-function listGroups2(user, uid) {
+function listerGroupes2(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.dn_groups, ldapEscape.filter(config.filter_lg, { id : uid }), config.attributes_id).then(res => resolve(res));
+ rechercherLDAP(user, config.dn_groups, ldapEscape.filter(config.filter_lg, { id : uid }), config.attributes_id).then(res => resolve(res));
});
}
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des membres d'un groupe.
- * @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 });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listMembers(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
* @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)
- * @return {string} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
+ * @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
-function listMembers(user, gid) {
+function listerMembres(user, gid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.filter_id, { id: gid }), config.attributes_lm).then(res => resolve(res[0]));
+ rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.filter_id, { id: gid }), config.attributes_lm).then(res => resolve(res[0]));
});
}
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des admins d'un groupe.
- * @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 });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listAdmins(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
* @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)
- * @return {string} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
+ * @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
-function listAdmins(user, gid) {
+function listerAdministrateurs(user, gid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.filter_id, { id: gid }), config.attributes_al).then(res => resolve(res[0]));
+ rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.filter_id, { id: gid }), config.attributes_al).then(res => resolve(res[0]));
});
}
/**
* @summary Fonction qui interroge le LDAP au sujet d'un uid particulier et qui renvoit toutes ses infos.
- * @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 });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `rens(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} uid - Identifiant de l'utilisateur
- * @return {Object} Informations recueillies ; renvoie une liste de dictionnaire avec les mêmes clés que dans le TOL, voir config.json.
+ * @return {Promise(Object[])} Informations recueillies ; renvoie une liste de dictionnaire avec les mêmes clés que dans le TOL, voir config.json.
*/
-function rens(user, uid) {
+function renseignerSurUtilisateur(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.dn_users, ldapEscape.filter(config.filter_id, { id: uid }), config.attributes_all).then(res => resolve(res));
+ rechercherLDAP(user, config.dn_users, ldapEscape.filter(config.filter_id, { id: uid }), config.attributes_all).then(res => resolve(res));
});
}
/**
- * @summary Fonction qui interroge le LDAP et retrouve les binets qui ressemblent à l'inpu. Etape 0 vers un vrai TOL (Trombino On Line).
- * @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 `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve les groupes (voir LDAP) qui ressemblent à l'input. Etape 0 vers un vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link rechercherLDAP} 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 `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} input - String entré par l'utilisateur.
- * @return {string[]} Liste des uid de groupes dont le nom ressemble à l'input
+ * @return {Promise(string[])} Liste des uid de groupes dont le nom ressemble à l'input
*/
function trouverGroupes(user, input) {
return new Promise(function(resolve, reject) {
@@ -230,13 +230,38 @@ function trouverGroupes(user, input) {
"("+config.key_id+"="+str+"*))))"; // La valeur du début avec des trucs après
// Appel rechercheLDAP avec filtre de l'espace
- rechercheLDAP(user, config.dn_groups, filter, config.attributes_id).then(res => resolve(res));
+ rechercherLDAP(user, config.dn_groups, filter, config.attributes_id).then(res => resolve(res));
+ });
+}
+
+/**
+ * @summary Fonction qui interroge le LDAP et retrouve le groupe qui ressemblent à l'input et qui correspond. Etape 0 vers un vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link rechercherLDAP} 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 `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise LDAPEscape pour éviter les injections.
+ * @arg {Object} user - Utilisateur de la forme nécessaire au bind
+ * @arg {string} user[key] - uid et password
+ * @arg {string} input - String entré par l'utilisateur.
+ * @arg {string} input - String entré par l'utilisateur.
+ * @return {Promise(string[])} Liste des uid de groupes dont le nom ressemble à l'input
+*/
+function trouverGroupesParTypes(user, input, typer) {
+ return new Promise(function(resolve, reject) {
+ // Escape de l'input utilisateur par sécurité
+ let str=ldapEscape.filter("${txt}", { txt: input});
+
+ // Construction du filtre custom
+ let filter= "(|("+config.key_id+"="+str+")"+ // On cherche la valeur exacte
+ "(|("+config.key_id+"=*"+str+")"+ // La valeur finale avec des trucs avant ; wildcard *
+ "(|("+config.key_id+"=*"+str+"*)"+ // La valeur du milieu avec des trucs avant et après
+ "("+config.key_id+"="+str+"*))))"; // La valeur du début avec des trucs après
+
+ // Appel rechercheLDAP avec filtre de l'espace
+ rechercherLDAP(user, config.dn_groups, filter, config.attributes_id).then(res => resolve(res));
});
}
/**
* @summary Fonction qui interroge le LDAP et retrouve certains attributs des paxs validant les critères de recherche. Première étape vers vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link rechercheLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs 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 });`.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. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs 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 });`.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. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {Object} data - Dictionnaire contenant les données nécessaires à la recherche avec des champs lisibles (voir config).
@@ -245,7 +270,7 @@ function trouverGroupes(user, input) {
* @arg {string[]} return_values - Liste d'attributs à renvoyer
* @return {string[]} Attributs des profils qui "match" les critères proposés.
*/
-function TOLmodulable(user, data, return_values) {
+function repliquerTOLModulable(user, data, return_values) {
return new Promise(function(resolve, reject) {
let filter="";
// Iteration pour chaque champ, alourdissement du filtre selon des trucs prédéfini dans config.json encore
@@ -266,13 +291,13 @@ function TOLmodulable(user, data, return_values) {
}
});
// Appel rechercheLDAP avec filtre de l'espace
- rechercheLDAP(user, config.dn_users, filter, config.attributes_id).then(res => resolve(res));
+ rechercherLDAP(user, config.dn_users, filter, config.attributes_id).then(res => resolve(res));
});
}
/**
* @summary Fonction qui interroge le LDAP et retrouve les uid des paxs validant les critères de recherche. Première étape vers vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link rechercheLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs 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 });`.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. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link repliquerTOLModulable} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs 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 });`.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. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {Object} data - Dictionnaire contenant les données nécessaires à la recherche avec des champs lisibles (voir config).
@@ -281,15 +306,15 @@ function TOLmodulable(user, data, return_values) {
* @arg {string[]} return_values - Liste d'attributs à renvoyer
* @return {string[]} uids des profils qui "match" les critères proposés.
*/
-function idTOL(user, data) {
+function repliquerTOLdesIds(user, data) {
return new Promise( function(resolve, reject) {
- TOLmodulable(user, data, config.attributes_id).then(res => resolve(res));
+ repliquerTOLModulable(user, data, config.attributes_id).then(res => resolve(res));
});
}
/**
* @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 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. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link repliquerTOLModulable} 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. Elle utilise LDAPEscape pour éviter les injections.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} c0 - Prénom
@@ -307,9 +332,9 @@ function idTOL(user, data) {
* @arg {string} c12 - Adresse ip
* @return {string[]} Informations recueillies ; voir config.json.
*/
-function TOL(user, data) {
+function repliquerTOL(user, data) {
return new Promise( function(resolve, reject) {
- TOLmodulable(user, data, config.attributes_all).then(res => resolve(res));
+ repliquerTOLModulable(user, data, config.attributes_all).then(res => resolve(res));
});
}
@@ -354,10 +379,10 @@ function creerGroupeLDAP(user, gid, nom, status, admins, members) {
}
//TOL({},{"groups": ["br","faerix"]}).then(res => console.log(res));
-//rechercheLDAP({},"ou=groups,dc=frankiz,dc=net","(cn=f*)",["uid"]).then(res => console.log(res));
-//trouverGroupes({},"fa").then(res => console.log(res));
+//rechercherLDAP({},"ou=groups,dc=frankiz,dc=net","(cn=f*)",["uid"]).then(res => console.log(res));
+//listeAdmins({},"zqfnsflswndf").then(res => console.log(res));
/* Partage pour le reste du monde ; même remarque synthaxe que pour l'import
-export { listGroups, listMembers, listAdmins, rens, trouverGroupes, idTOL, TOL }; */
+export { listeGroupes, listeMembres, listeAdministrateurs, renseignementsSurUtilisateur, trouverGroupes, repliquerTOLdesIds, repliquerTOL }; */
-/**/module.exports ={ listGroups, listMembers, listAdmins, rens, idTOL, TOL };
+/**/module.exports ={ listerGroupes, listerMembres, listerAdministrateurs, renseignerSurUtilisateur, trouverGroupes, repliquerTOLdesIds, repliquerTOL };