LDAPManager/routes/entity.ts

/*
 * GET users listing.
 */
import express = require('express');
const router = express.Router();
import Security from '../src/Security';
import { ILDAPManager } from '../src/ldapInterface';
import { LDAPSchemaObjectClass } from '../src/LDAPSchema';

function LDAPEntryToAttributes(entry: Map<string, Array<string>>): any {
    let result: any = [];
    for (let [key, val] of entry)
        val.forEach(v => result.push({ key: key, val: v }));
    return result;
}

class AttributesByClasses {
    public constructor(entry: Map<string, string[]>, classes: Map<string, LDAPSchemaObjectClass>) {
        let oClasses: LDAPSchemaObjectClass[] = new Array();

        for (let eClass of entry.get("objectClass") || []) {
            this.fEntries.set(eClass, new Map());
            let cl = classes.get(eClass);
            cl && oClasses.push(cl);
		}
        for (let [i, j] of entry) {
            let found = false;
            for (let oc of oClasses) {
                if (oc.HasAttribute(i)) {
                    this.fEntries.get(oc.GetName())?.set(i, j);
                    found = true;
                    break;
				}
            }
            if (!found)
                this.fUnmapped.set(i, j);
        }
        for (let klass of oClasses) {
            let className = klass.GetName();
            let classContent = this.fEntries.get(className);

            if (!classContent) {
                classContent = new Map<string, string[]>();
                this.fEntries.set(className, classContent);
            }
            for (let attr of klass.ListAttributes())
                !classContent.has(attr) && classContent.set(attr, new Array());
            this.fEntries.set(className, classContent);
		}
    }

    public ToMap(): any {
        let result: any = {};
        for (let [ocKey, vals] of this.fEntries) {
            let classContent: any = {};
            for (let [i, j] of vals) {
                classContent[i] = j.length ? j : [""];
            }
            result[ocKey] = classContent;
        }
        return result;
    }

    public GetObjectClasses(): any {
        let result: any = [];
        for (let [ocKey, val] of this.fEntries)
            result.push(ocKey);
        result.sort();
        return result;
	}

    private fEntries: Map<string, Map<string, string[]>> = new Map();
    private fUnmapped: Map<string, string[]> = new Map();
}

router.get('/:dn', (req: express.Request, res: express.Response) => {
    if (!Security.requireLoggedUser(req, res))
        return;
    let ldapManager: ILDAPManager;
    let entry: Map<string, string[]>;
    req.ldapManager.GetInstance()
        .then(_ldapManager => { ldapManager = _ldapManager; return ldapManager.GetEntry(req.params.dn) })
        .then(_entry => { entry = _entry; return ldapManager.GetSchema() }).then(schema => {
            let classes: AttributesByClasses = new AttributesByClasses(entry, schema);
            let dn = (entry.get("dn") || [])[0];

            res.render('entity', {
                dn: dn || req.params.dn,
                attributes: classes.ToMap(),
                classes: classes.GetObjectClasses()
            });
    });
});

router.delete('/', (req: express.Request, res: express.Response) => {
    const session = Security.GetSession(req);
    if (!req.query["csrf"] || !req.query["dn"] || Array.isArray(req.query["csrf"]) || Array.isArray(req.query["dn"])) {
        res.sendStatus(400);
        return;
	}
    if (!session || !req.query["csrf"] || req.query["csrf"] !== session.GetCSRFToken()) {
        res.sendStatus(403);
        return;
    }
    req.ldapManager.GetInstance().then((ldap: ILDAPManager): void => {
        ldap.Remove(req.query["dn"]?.toString() || "")
            .then(() => {
                res.sendStatus(203);
            })
            .catch(err => {
                res.statusCode = 500;
                res.statusMessage = err;
                res.send();
            });
    });
});

export default router;