LDAPManager/routes/entity.ts

/*
 * GET users listing.
 */
import express = require('express');
const router = express.Router();
import Security from '../src/Security';
import RouterUtils from '../src/RouterUtils';
import { ILDAPManager } from '../src/ldapInterface';
import { LDAPSchemaObjectClass, ClassType } 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>) {
        for (let eClass of entry.get("objectClass") || []) {
            this.fEntries.set(eClass, new Map());
            let cl = classes.get(eClass);
            cl && this.fObjectClasses.push(cl);
		}
        for (let [i, j] of entry) {
            let found = false;
            for (let oc of this.fObjectClasses) {
                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 this.fObjectClasses) {
            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) && !entry.has(attr) && classContent.set(attr, new Array());
            this.fEntries.set(className, classContent);
		}
    }

    public IsMandatoryAttr(attr: string): boolean {
        for (let klass of this.fObjectClasses)
            if (klass.HasMust(attr))
                return true;
        return false;
	}

    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 fObjectClasses: LDAPSchemaObjectClass[] = new Array();
    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 (!req.isUserLogged)
        return RouterUtils.Redirect(res, "/login");
    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(),
                getType: (klass: string): string => {
                    switch (schema.get(klass)?.GetType()) {
                        case ClassType.eAbstract:
                            return "abstract";
                        case ClassType.eAuxiliary:
                            return "auxiliary";
                        case ClassType.eStructural:
                            return "structural";
                    }
                    return "Unknown";
                },
                isMandatory: (attr: string): boolean => classes.IsMandatoryAttr(attr)
            });
    });
});

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;