diff --git a/ldap_config.json b/ldap_config.json
index b6b24fa9615db7ee7aa6f09f5ff58d501d8cc5fd..1e20d240cd3d988ff22b7aae9c35a19ab8f27383 100644
--- a/ldap_config.json
+++ b/ldap_config.json
@@ -24,7 +24,8 @@
"attributs": ["jpegPhoto","givenName", "sn", "brBirthdate", "brPromo","telephoneNumber","mail","brRoom","brIP","brMemberOf"]
},
"tgty": {
- "filtre": "(brNS=${ty})"
+ "filtre": "(brNS=${ty})",
+ "types": ["binet", "free"]
},
"tolm": {
"input_names": ["givenName", "lastName", "nickname", "nationality", "promotion", "phone", "adress", "ip", "school", "groups","studies","sport","mail"],
@@ -44,28 +45,36 @@
"tol": {
"attributes": ["jpegPhoto","givenName", "sn", "brBirthdate", "brPromo","telephoneNumber","mail","brRoom","brIP","brMemberOf"]
},
- "attributes_id": ["uid"],
- "attributes_lm":["restrictedMemberUid"],
- "attributes_lg":["brMemberOf"],
- "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 {}"
+ "cru": {
+ "single_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_single_values_user": {
+ "uid": "data['hruid'];",
+ "givenName": "data['first_name'];",
+ "sn": "data['last_name'];",
+ "displayName": "data['nickname'];",
+ "brBirthdate": "data['birthdate'];",
+ "uidNumber": "(2*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": "if (data['read_perm'].length>0) { 'br.*,public.*'; } else { 'br.*,public.*,'+data['read_perm']; }",
+ "brNewsPostAccess": "if (data['write_perm'].length>0) { 'br.*,!br.blague-du-jour,public.*,!br.campagnekes'; } else { 'br.*,!br.blague-du-jour,public.*,!br.campagnekes,'+data['read_perm']; }",
+ "brAlias": "data['forlifes'].split(' ');",
+ "brIP": "data['ips'].split(',');",
+ "cn": "data['first_name']+' '+data['last_name'].toUpperCase();",
+ "gecos": "btoa(data['first_name']+' '+data['last_name'].toUpperCase());"
+ },
+ "multiple_user_infos": ["objectClass", "brMemberOf"],
+ "expr_multiple_values_user": {
+ "objectClass": "['posixAccount', 'shadowAccount', 'inetOrgPerson', 'brAccount']",
+ "brMemberOf": "data['groups']"
+ }
},
"sessionSecret":"change this"
}
\ No newline at end of file
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index fba940e01b4f6d60f91d284ca193810d8dd4d4fd..b33dff8510264e64471c5e0dc1923422f90549d9 100644
--- a/src/ldap/ldap_data.js
+++ b/src/ldap/ldap_data.js
@@ -34,7 +34,7 @@ var client = ldap.createClient({ url: config.ldap.server});
/**
* @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 {Object} user - Utilisateur de la forme suivante :
* @arg {string} user[uid] - User identifier
* @arg {string} user[password] - Mot de passe
*/
@@ -46,7 +46,7 @@ function connecterLDAP(user) {
/**
* @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 `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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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
@@ -57,9 +57,9 @@ function rechercherLDAP(user, base, filter, attributes) {
return new Promise(function(resolve, reject) {
connecterLDAP(user);
//Debug
- console.log(base);
+ /*console.log(base);
console.log(filter);
- console.log(attributes);
+ console.log(attributes);*/
let vals=[];
// Interrogation LDAP selon configuration fournie en argument
@@ -98,7 +98,7 @@ function rechercherLDAP(user, base, filter, attributes) {
/**
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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.
@@ -121,8 +121,8 @@ function modifierLDAP(user, name, op, mod) {
/**
* @summary Fonction qui permet de rajouter un élément sur le LDAP.
- * @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
+ * @desc Cette fonction appelle {@link connecterLDAP} 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 {@link connecterLDAP}
* @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
@@ -141,13 +141,13 @@ function ajouterLDAP(user, dn, vals) {
}
//------------------------------------------------------------------------------------------------------------------------
-// Fonctions de recherche
+// Fonctions de lecture
//------------------------------------------------------------------------------------------------------------------------
/**
* @summary Fonction qui interroge le LDAP et retrouve les groupes dont un individu est membre.
* @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json, entrée lg. 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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} uid - Identifiant de l'individu à interroger (le plus souvent prenom.nom, parfois l'année, supposé valide)
* @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
@@ -160,8 +160,7 @@ function listerGroupes(user, uid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des membres d'un groupe.
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
* @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
@@ -174,8 +173,7 @@ function listerMembres(user, gid) {
/**
* @summary Fonction qui interroge le LDAP et retrouve la liste des admins d'un groupe.
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
* @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
@@ -188,7 +186,7 @@ function listerAdministrateurs(user, gid) {
/**
* @summary Fonction qui interroge le LDAP au sujet d'un uid particulier et qui renvoit toutes ses infos.
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} uid - Identifiant de l'utilisateur
* @return {Promise(Object[])} Informations recueillies ; renvoie une liste de dictionnaire avec les mêmes clés que dans le TOL, voir config.json.
*/
@@ -198,11 +196,14 @@ function renseignerSurUtilisateur(user, uid) {
});
}
+//------------------------------------------------------------------------------------------------------------------------
+// Fonctions de recherche
+//------------------------------------------------------------------------------------------------------------------------
+
/**
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} input - String entré par l'utilisateur qui ressemble au nom du groupe.
* @return {Promise(string[])} Liste des uid de groupes dont le nom ressemble à l'input
*/
@@ -225,8 +226,7 @@ function trouverGroupes(user, input) {
/**
* @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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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 uid de groupes dont le nom ressemble à l'input
@@ -250,8 +250,7 @@ function trouverGroupesParTypes(user, input, type) {
/**
* @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 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} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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.
@@ -287,8 +286,7 @@ function repliquerTOLModulable(user, data, return_values) {
/**
* @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 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} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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.
@@ -304,8 +302,7 @@ function repliquerTOLdesIds(user, data) {
/**
* @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 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 {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} c0 - Prénom
* @arg {string} c1 - Nom
* @arg {string} c2 - Surnom
@@ -328,27 +325,37 @@ function repliquerTOL(user, data) {
}
//------------------------------------------------------------------------------------------------------------------------
-// Fonctions créatrices
+// Fonctions de création
//------------------------------------------------------------------------------------------------------------------------
/**
- * @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
+ * @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeurs 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 add). Il faut l'appeler suivant un schéma `creerUtilisateur(...).then((res) => { truc avec res });`. Cette fonction fait une utilisation massive d'eval pour anonymiser son code ; c'est mal et cela suppose que beaucoup de soins ont été pris lors de l'escape de ses paramètres.
+ * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @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) {
+/*function creerUtilisateur(user, data) {
return new Promise(function(resolve, reject) {
- let data = {};
+ let vals = {};
+ config.cru.single_user_infos.forEach(key => vals[key]=eval(config.cru.expr_single_values_user[key]));
+ ajouterLDAP(user, config.key_id+"="+data["uid"]+","+config.dn_users, vals).then( res => {
+ config.cru.multiple_user_infos.forEach(key => {
+ vals = {};
+ //vals[]
+ modifierLDAP(user, config.key_id+"="+data["uid"]+","+config.dn_users, ).then(res => {
+ modifierLDAP(user, ).then(res => { resolve(true); });
+ });
+ });
+ });
reject(false);
});
-}
+}*/
/**
* @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} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} gid - Identifiant du group
* @arg {string} nom - Nom commun du group
* @arg {string} status - Statut du groupe (binet, autre ?)
@@ -372,9 +379,9 @@ function creerGroupeLDAP(user, gid, nom, status, admins, members) {
//------------------------------------------------------------------------------------------------------------------------
/**
- * @summary TBC Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
+ * @summary TBC Fonction qui va modifier un certain jeu de valeur en argument dans 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 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} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
* @arg {string} gid - Identifiant du group
* @arg {string} nom - Nom commun du group
* @arg {string} status - Statut du groupe (binet, autre ?)
@@ -402,6 +409,7 @@ function rajouterLDAP(user, gid, nom, status, admins, members) {
//repliquerTOL({},{"groups": ["faerix","br"]}).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));
+//trouverGroupesParTypes({},"fe","binet").then(res => console.log(res));
/* Partage pour le reste du monde ; même remarque synthaxe que pour l'import
export { listeGroupes, listeMembres, listeAdministrateurs, renseignementsSurUtilisateur, trouverGroupes, repliquerTOLdesIds}; */