merge

ldap_config.json

@@ -11,7 +11,6 @@
 		"group":"ou=groups,dc=frankiz,dc=net",
 		"user": "ou=eleves,dc=frankiz,dc=net"
 	},
-	"key_id": "uid",
 	
 	"comment_3": "Placeholders et indications de contenu de certains champs du LDAP généré par frankiz pour les utilisateurs",
 	"user": {
@@ -35,7 +34,7 @@
 	},
 	"comment_4": "Placeholders et indications de contenu de certains champs du LDAP généré par frankiz pour les groupes",
 	"group": {
-		"gid": "uid",
+		"gid": "cn",
 		"name": "sn",
 		"site": "website",
 		"description": "description",

src/graphql/models/authorization.ts

@@ -70,7 +70,7 @@ export class AuthorizationModel {
         console.log("calling UT.peek from ldap connector (User Tool)...")
         let data = await UT.peek(this.uid);
         console.log("UT.peek returned with data:");
-        console.log(data);
+        //console.log(data);
 
         this.viewerOf = await Tools.viewerOf(data);
         this.memberOf = await Tools.memberOf(data);

src/ldap/export/user.ts

@@ -6,6 +6,7 @@
 import {ldapConfig, userData, categories} from '../internal/config';
 import {Basics} from '../internal/basics';
 import {Tools} from '../internal/tools';
+import ldapEscape from 'ldap-escape';
 
 //------------------------------------------------------------------------------------------------------------------------
 // Classes à exporter TBT
@@ -34,7 +35,12 @@ export class User {
     static async peek(uid: string) : Promise<userData> {
         try { 
             let data : userData = await Tools.peek<userData>("user", uid, userData);
-            for (let cat in categories) { data[cat] = await Basics.searchSingle("group", ldapConfig.group.key_id, "*", ldapConfig.group[cat]+"="+uid); }
+            for (let cat of categories) { 
+                let dn = ldapConfig.user.uid + "=" + ldapEscape.filter("${txt}", { txt: uid }) + "," + ldapConfig.dn.user;
+                console.log(ldapConfig.group[cat] + "=" + dn);
+                data[cat] = await Basics.searchSingle("group", ldapConfig.group.gid, null, ldapConfig.group[cat] + "=" + dn);
+                console.log(data[cat]);
+            }
             return data;
         }
         catch(err) {

src/ldap/internal/basics.ts

@@ -101,7 +101,11 @@ export class Basics {
     static search(domain: 'group'|'user', attributes: string[], id: string, filter: string, handler : (entry: any) => void) : Promise<void> {
         Basics.adminBind();
         let dn ="";
-        if (id != null)     { dn+=ldapConfig.key_id+'='+ ldapEscape.dn("${txt}", { txt: id}) +','; }
+        if (id != null)     {
+            if (domain == "group")  { dn+=ldapConfig.group.gid; }
+            else                    { dn += ldapConfig.user.uid; }
+            dn += '=' + ldapEscape.dn("${txt}", { txt: id }) + ',';
+        }
         dn+=ldapConfig.dn[domain];
         // Interrogation LDAP selon filter
         let promise = new Promise<void>(function(resolve, reject) {
@@ -144,6 +148,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(entry.object)
             vals.push(entry.object[attribute]);
         });
         return vals;

src/ldap/internal/tools.ts

@@ -34,20 +34,17 @@ export class Tools {
      * @async
      */
     static async peek<T>(domain: 'user'|'group', id: string, type: new () => T) : Promise<T> {
-        var dirtyKeys = ldapConfig[domain];
-        let cleanData : T = new type();
-        let attr = Object.keys(dirtyKeys).map(key => dirtyKeys[key]);
-        //console.log(attr);
-        let dirtyData = (await Basics.searchMultiple(domain, attr, id))[0];
-        console.log(dirtyData);
-        console.log(cleanData);
+        let map = ldapConfig[domain];
+        let cleanKeys = Object.keys(map);
+        let dirtyKeys = cleanKeys.map(key => map[key]);
+
+        let cleanData: T = new type();
+        let dirtyData = (await Basics.searchMultiple(domain, dirtyKeys, id))[0];
         // Rename output
-        for (let uncleanKey in dirtyData) {
-            for (let cleanKey of Object.keys(cleanData)) {
-                console.log(cleanKey);
-                if (uncleanKey==dirtyKeys[cleanKey]) { cleanData[cleanKey] = dirtyData[uncleanKey]; }
-            }
+        for(let cleanKey of cleanKeys) {
+            cleanData[cleanKey] = dirtyData[map[cleanKey]];
         }
+        //console.log(cleanData);
         return cleanData;
     }