diff --git a/ldap_config.json b/ldap_config.json
index 03abfc7b618e5ef134de06f7b64d75ffdeb164fc..3ff21641bb99b9d55f8bb1f62ef24989b8e7aea2 100644
--- a/ldap_config.json
+++ b/ldap_config.json
@@ -8,7 +8,6 @@
"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"],
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index c1ba16e68bd0fcafd1df47b6592bb80ab6e6056d..c200eae358a29feb90890bd2c032a3a8c0af38d4 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;
@@ -48,25 +48,24 @@ function bind(user) {
* @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} 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
+ * @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)
*/
-function rechercheLDAP(user, base, filter, filter_dic, attributes) {
+function rechercheLDAP(user, base, filter, attributes) {
return new Promise(function(resolve, reject) {
bind(user);
- console.log(base);
+ //Debug
+ /*console.log(base);
console.log(filter);
- console.log(filter_dic);
- console.log(attributes);
+ console.log(attributes);*/
let vals=[];
// Interrogation LDAP selon configuration fournie en argument
client.search(base, {
"scope": "sub",
- "filter": ldapEscape.filter(filter, filter_dic),
+ "filter": filter,
"attributes": attributes
}, function(err, res) {
// Gestion erreur
@@ -146,33 +145,33 @@ 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 })`;
+ * @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.
* @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
*/
function listGroups(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user,config.dn_users, config.filter_id, { id : uid }, config.attributes_lg).then(res => resolve(res[0]));
+ rechercheLDAP(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 });`
+ * @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.
* @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
*/
function listGroups2(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.dn_groups, config.filter_lg, { id : uid }, config.attributes_id).then(res => resolve(res));
+ rechercheLDAP(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 });`
+ * @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.
* @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)
@@ -180,13 +179,13 @@ function listGroups2(user, uid) {
*/
function listMembers(user, gid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.key_id+"="+gid+","+config.dn_groups, config.filter_id, { id: gid }, config.attributes_lm).then(res => resolve(res[0]));
+ rechercheLDAP(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 });`
+ * @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.
* @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)
@@ -194,61 +193,103 @@ function listMembers(user, gid) {
*/
function listAdmins(user, gid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.key_id+"="+gid+","+config.dn_groups, config.filter_id, { id: gid }, config.attributes_al).then(res => resolve(res[0]));
+ rechercheLDAP(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 });`
+ * @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.
* @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.
*/
function rens(user, uid) {
return new Promise(function(resolve, reject) {
- rechercheLDAP(user, config.dn_users, config.filter_id, { id: uid }, config.attributes_all).then(res => resolve(res));
+ rechercheLDAP(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 juste 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 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.
+ * @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.
+ * @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
+*/
+function trouverGroupes(user, input) {
+ 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
+ rechercheLDAP(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.
* @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).
* @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.
+ * @arg {string[]} return_values - Liste d'attributs à renvoyer
+ * @return {string[]} Attributs des profils qui "match" les critères proposés.
*/
-function idTOL(user, data) {
+function TOLmodulable(user, data, return_values) {
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((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
+ 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
+ // Iteration pour chaque valeur fournie par l'utilisateur
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;
+ // Escape de l'input utilisateur
+ let str=ldapEscape.filter("${input}", { input: val});
+
+ filter="(&"+filter+ "(|("+attribute+"="+str+")"+ // On cherche la valeur exacte
+ "(|("+attribute+"=*"+str+")"+ // La valeur finale avec des trucs avant ; wildcard * (MEF la wildcart ne marche pas pour tous les attributs)
+ "(|("+attribute+"=*"+str+"*)"+ // La valeur du milieu avec des trucs avant et après
+ "("+attribute+"="+str+"*)))))"; // La valeur du début avec des trucs après
});
}
});
// Appel rechercheLDAP avec filtre de l'espace
- rechercheLDAP(user, config.dn_users, filter, filter_dic, config.attributes_id).then(res => resolve(res));
+ rechercheLDAP(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.
+ * @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).
+ * @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.
+ * @arg {string[]} return_values - Liste d'attributs à renvoyer
+ * @return {string[]} uids des profils qui "match" les critères proposés.
+ */
+function idTOL(user, data) {
+ return new Promise( function(resolve, reject) {
+ TOLmodulable(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.
+ * @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.
* @arg {Object} user - Utilisateur de la forme nécessaire au bind
* @arg {string} user[key] - uid et password
* @arg {string} c0 - Prénom
@@ -266,25 +307,9 @@ function idTOL(user, data) {
* @arg {string} c12 - Adresse ip
* @return {string[]} Informations recueillies ; voir config.json.
*/
-function TOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8="", c9="", c10="", c11="", c12="") {
- return new Promise(function(resolve, reject) {
- 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((attribute, index, list) => {
- if (eval("c"+index.toString()) != '') { // Si il y a qque chose à chercher pour ce filtre
- 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_"+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));
+function TOL(user, data) {
+ return new Promise( function(resolve, reject) {
+ TOLmodulable(user, data, config.attributes_all).then(res => resolve(res));
});
}
@@ -293,7 +318,7 @@ function TOL(user, c0="", c1="", c2="", c3="", c4="", c5="", c6="", c7="", c8=""
//------------------------------------------------------------------------------------------------------------------------
/**
- * @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
+ * @summary TBC 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 {Object} data - Dictionnaire des informations utilisateurs (voir détail des champs dans config.json)
@@ -307,7 +332,7 @@ function creerUtilisateurLDAP(user, data) {
}
/**
- * @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
+ * @summary TBC 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
@@ -328,10 +353,11 @@ function creerGroupeLDAP(user, gid, nom, status, admins, members) {
});
}
-//idTOL({},{"group": "br"}).then(res => console.log(res));
-rechercheLDAP({},"ou=eleves,dc=frankiz,dc=net","(brMemberOf=${gr}*)",{gr: "faer"},["uid"]);
+//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));
-/* 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, trouverGroupes, idTOL, TOL };
-module.exports ={ listGroups, listMembers, listAdmins, rens, idTOL, TOL }; /**/
+/*module.exports ={ listGroups, listMembers, listAdmins, rens, idTOL, TOL }; */