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';
import ConfigManager from '../src/ConfigLoader';

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;
}

function getType(schema: Map<string, LDAPSchemaObjectClass>, 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";
}

function StructifySchema(schema: Map<string, LDAPSchemaObjectClass>): any {
    let result: any = {};
    for (let [key, oc] of schema) {
        if (oc.GetType() === ClassType.eAbstract)
            continue;
        let description: any = {};
        for (let [key, val] of oc.ListDescriptions())
            description[key] = val;
        let obj = {
            may: oc.ListMayAttributes().filter(i => i.toLowerCase() !== 'objectclass'),
            must: oc.ListMustAttributes().filter(i => i.toLowerCase() !== 'objectclass'),
            structural: oc.GetType() === ClassType.eStructural,
            auxiliary: oc.GetType() === ClassType.eAuxiliary,
            descriptions: description,
            type: getType(schema, key)
        };
        result[key] = obj;
    }
    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) {
            if (i.toLowerCase() == 'objectclass')
                continue;
            let found = false;
            for (let oc of this.fObjectClasses) {
                if (oc.HasAttribute(i)) {
                    this.fEntries.get(oc.GetName())?.set(i, j);
                    found = true;
                }
            }
            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 = {};
        let classContent: any = {};

        result.members = { memberOf: this.fUnmapped?.get("memberOf") || [] };
        if (!result.members.memberOf.length)
            result = {};
        for (let [ocKey, vals] of this.fEntries) {
            classContent = {};
            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, _] of this.fEntries)
            result.push(ocKey);
        result.sort();
        if (this.fUnmapped?.has("memberOf"))
            result.unshift('members');
        return result;
    }

    public ClassExists(className: string): boolean {
        return this.fEntries.has(className);
    }

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

function StructifyEditLinks(input:Map<string, Array<string>>):any {
    const result:any = {};
    for (let i of input.keys())
        result[i] = input.get(i);
    return result;
}

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) => getType(schema, klass),
                isMandatory: (attr: string): boolean => classes.IsMandatoryAttr(attr),
                schema: StructifySchema(schema),
                editLinks: StructifyEditLinks(ConfigManager.GetInstance().GetLDAPEditLinks()),
                getUnusedClass: (): string[] => {
                    let result = [];
                    for (let [key, klass] of schema) {
                        if (!classes.ClassExists(key) && klass.GetType() !== ClassType.eAbstract)
                            result.push({ key: key, klass: klass });
                    }
                    return result.sort((a, b) => {
                        if (a.klass.GetType() === ClassType.eStructural && b.klass.GetType() === ClassType.eAuxiliary)
                            return -1;
                        if (a.klass.GetType() === ClassType.eAuxiliary && b.klass.GetType() === ClassType.eStructural)
                            return 1;
                        return a.key.localeCompare(b.key);
                    }).map(a => a.key);
                }
            });
    });
});

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;