Modifs LDAP

src/ldap/export/group.ts

@@ -12,6 +12,8 @@ import ldapEscape from 'ldap-escape';
 // Classes à exporter TBT
 //------------------------------------------------------------------------------------------------------------------------
 
+export {groupData};
+
 export class Group {
     /**
      * @memberof LDAP
@@ -35,6 +37,8 @@ export class Group {
             let data = await Tools.peek<groupData>("group", gid, groupData);
             // Extraction des uid de membres
             for (let cat of categories) data[cat] = data[cat].map(dirtyUid => dirtyUid.split(',')[0].split('=')[1]);
+            data.parents = data.parents.map(dirtyGid => dirtyGid.split(',')[0].split('=')[1])
+            //console.log("Found " + data.gid);
             return data;
         }
         catch(err) {

src/ldap/export/user.ts

@@ -40,7 +40,9 @@ export class User {
                 let dn = ldapConfig.user.uid + "=" + ldapEscape.filter("${txt}", { txt: uid }) + "," + ldapConfig.dn.user;
                 let tmp = await Basics.searchSingle("group", ldapConfig.group.gid, null, ldapConfig.group[cat] + "=" + dn);
                 // Filtrage du DN LDAP
-                data[cat] = tmp.map(dirtyUid => dirtyUid.split(',')[0].split('=')[1]);
+                //data[cat] = tmp.map(dirtyUid => dirtyUid.split(',')[0].split('=')[1]);
+                // C'est déja propre car on ne demande que le CN
+                data[cat] = tmp;
             }
             return data;
         }

src/ldap/internal/basics.ts

@@ -17,7 +17,7 @@ var client = ldap.createClient({ url: ldapConfig.server});
 
 // Interface pratique pour que Typescript comprenne ce qu'est un dictionnaire simple
 interface dic {
-    [Key: string]: string;
+    [Key: string]: string | string[];
 }
 
 //------------------------------------------------------------------------------------------------------------------------
@@ -107,6 +107,7 @@ export class Basics {
             dn += '=' + ldapEscape.dn("${txt}", { txt: id }) + ',';
         }
         dn+=ldapConfig.dn[domain];
+        console.log("Searching dn= " + dn + ", filter : " + filter);
         // Interrogation LDAP selon filter
         let promise = new Promise<void>(function(resolve, reject) {
             client.search(dn, {            // Must be escaped in case of a malignious false id
@@ -148,6 +149,7 @@ export class Basics {
         let vals=[];
         await Basics.search(domain, [attribute], id, filter,  entry => {
             // Cas un seul attribut où le résultat est une liste directement
+            console.log("searchSingle found " + entry.object[(domain == 'group' ? ldapConfig['group']['gid'] : ldapConfig['user']['uid'])]);
             vals.push(entry.object[attribute]);
         });
         return vals;
@@ -172,6 +174,7 @@ export class Basics {
         await Basics.search(domain, attributes, id, filter,  entry => {
             // Cas plusieurs attributs donc résultat dictionnaire
             vals.push({});
+            console.log("searchMultiple found " + entry.object[(domain == 'group' ? ldapConfig['group']['gid'] : ldapConfig['user']['uid'])]);
             attributes.forEach(attribute => {
                 vals.slice(-1)[0][attribute]=entry.object[attribute];
             });

src/ldap/internal/config.ts

@@ -17,7 +17,7 @@ console.log(colors.red("Loading .env config file from "+path_env));
 dotenv.config({ path: path_env });
 
 // Point central ; tous les champs de la BDD sont 'cachés' dans config.json et pas visibles directement
-let path_config = path.resolve(__dirname, '..', '..', '..', '..', './ldap_config.json');
+let path_config = path.resolve(__dirname, '..', '..', '..', './ldap_config.json');
 console.log(colors.cyan("Loading LDAP config file from "+path_config));
 export const ldapConfig = JSON.parse(fs.readFileSync(path_config).toString());
 
@@ -85,8 +85,7 @@ export class userData {
  * @var {string} description - Description du groupe (script Markdown)
  * @var {string} site - Site web du groupe (URL)
  * @var {string} category - Statut du groupe ; binet, section sportive... (actuellement juste 'binet' ou 'free')
- * @var {string[]} childs - Liste des groupes enfants de première génération de celui-ci
- * @var {string[]} parents - Liste des groupes directement parents de celui-ci ; symétrique du précédent
+ * @var {string[]} parents - Liste des groupes directement parents de celui-ci
  * @var {string[]} admins - Liste des admins du groupe
  * @var {string[]} speakers - Liste des porte-parole du groupe
  * @var {string[]} members - Liste des membres du groupe
@@ -101,10 +100,9 @@ export class groupData {
     description?: string;
     site?: string;
 	category: string;
-    childs: string[];
-    parents: string[];
-    admins: string[];
-    speakers: string[];
-    members: string[];
-    followers: string[];
+    parents: string[] = [];
+    admins: string[] = [];
+    speakers: string[] = [];
+    members: string[] = [];
+    followers: string[] = [];
 }
\ No newline at end of file

src/ldap/internal/tools.ts

@@ -43,7 +43,13 @@ export class Tools {
         let cleanData: T = new type();
         let dirtyData = (await Basics.searchMultiple(domain, dirtyKeys, id))[0];
         // Renommage des clés
-        for(let cleanKey of cleanKeys) cleanData[cleanKey] = dirtyData[map[cleanKey]];
+        for(let cleanKey of cleanKeys) {
+            let val = dirtyData[map[cleanKey]];
+            if (val !== undefined) {
+                if (Array.isArray(cleanData[cleanKey]) && !Array.isArray(val)) val = [val];
+                cleanData[cleanKey] = val;
+            }
+        }
         return cleanData;
     }
 
@@ -65,7 +71,7 @@ export class Tools {
     static async search(domain: "user"|"group", data: userData|groupData) : Promise<string[]> {
         let filter="";
         // Iteration pour chaque champ, alourdissement du filtre selon des trucs prédéfinis dans ldapConfig encore
-        for (var key of ldapConfig[domain]) {
+        for (var key in ldapConfig[domain]) {
             if ((data[key]!= undefined) && (data[key] != '')) {             // Si il y a qque chose à chercher pour ce filtre
                 if (!Array.isArray(data[key])) data[key]=[data[key]];       // Génération systématique d'une liste de valeurs à rechercher
                 // Iteration pour chaque valeur fournie par l'utilisateur