authorization.ts

/**
 * @file Fonctions qui gerent l'autorisation des utilisateurs
 * @author ofacklam
 * @memberof GraphQL
 */

import { DataLoader } from '../../utils/dataLoader';
import { Tools, GroupSet, GroupCollection } from "../../utils/tools";
import { User as UT, userData } from '../../ldap/export/user'

/*
 * There are 6 levels of authorization
 *  none : doesn't know the group / the user exists
 *  connectedOrOnplatal : knows the group exists, can use TOL
 *  viewer : can see the group
 *  member : part of the group
 *  speaker : allowed to speak for the group
 *  admin : admin of the group
 */

export class AuthorizationModel {
    
    /**
     * @memberof GraphQL
     * @class AuthorizationModel
     * @summary Autorisation des utilisateurs.
     * @classdesc Cette classe contient les méthodes d'autorisation de l'utilisateur dans le 'context'.
     * @arg {string} uid - L'identifiant de l'utilisateur.
     */
    constructor(uid: string) {
        this.uid = uid;
        this.m_loader = new DataLoader(this.fetchData.bind(this));
    }

    /**
     * @memberof GraphQL
     * @summary Fonction qui crée une nouvelle instance de AuthorizationModel et charge les données
     * @arg {string} uid - Identifiant de l'utilisateur.
     * @returns {Promise(AuthorizationModel)} Renvoie un nouveau AuthorizationModel avec cet utilisateur
     * @async
     * @static
     * @deprecated
     */
    static async create(uid: string): Promise<AuthorizationModel> {
        let model = new AuthorizationModel(uid);
        console.log("constructing AuthorizationModel...");
        if(model.isAuthenticated()) {
            console.log("model is authenticated. fetching data...");
            await model.fetchData();
        }
        console.log("finished constructing AuthorizationModel");
        return model;
    }

    protected m_loader: DataLoader;

    protected uid: string;
    protected viewerOf: GroupCollection;
    protected memberOf: GroupCollection;
    protected speakerOf: GroupCollection;
    protected adminOf: GroupCollection;

    static PUBLICUSER = "public_user";
    static ONPLATALUSER = "public_onplatal_user";

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function fetchData
     * @summary Fonction qui recupere toutes les données pour populer les champs a partir de l'uid.
     * @async
     */
    async fetchData(): Promise<void> {
        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);

        this.memberOf = await Tools.memberOf(data);
        this.speakerOf = await Tools.speakerOf(data);
        this.adminOf = await Tools.adminOf(data);
        this.viewerOf = await Tools.viewerOf(this.memberOf);
        //console.log(this.viewerOf);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function getUid
     * @summary Fonction qui renvoit l'identifiant de l'utilisateur
     * @return {string} Renvoie l'uid de l'utilisateur du 'context'
     */
    getUid(): string {
        return this.uid;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isConnectedOrOnplatal
     * @summary Fonction qui renvoit si l'utilisateur est connecté ou on-platal
     * @return {boolean} Renvoie true si l'utilisateur est connecté ou on-platal
     */
    isConnectedOrOnplatal(): boolean {
        return (this.uid != AuthorizationModel.PUBLICUSER);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isAuthenticated
     * @summary Fonction qui renvoit si l'utilisateur est authentifié
     * @return {boolean} Renvoie true si l'utilisateur est authentifié
     */
    isAuthenticated(): boolean {
        console.log("running model.isAuthenticated...");
        return (this.uid != AuthorizationModel.PUBLICUSER && this.uid != AuthorizationModel.ONPLATALUSER);
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isViewer
     * @summary Fonction qui renvoit si l'utilisateur est viewer du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(boolean)} Renvoie true si l'utilisateur est viewer du groupe.
     * @async
     */
    async isViewer(gid: string): Promise<boolean> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            let groups = this.viewerOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsViewer
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est viewer.
     * @return {Promise(GroupCollection)} Renvoie la collection de groupes dont l'utilisateur est viewer.
     * @async
     */
    async groupsViewer(): Promise<GroupCollection> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            return this.viewerOf;
        }
        return new GroupCollection;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isMember
     * @summary Fonction qui renvoit si l'utilisateur est membre du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(boolean)} Renvoie true si l'utilisateur est membre du groupe.
     * @async
     */
    async isMember(gid: string): Promise<boolean> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            let groups = this.memberOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isMemberOr
     * @summary Fonction qui renvoit si l'utilisateur est membre d'au moins un de ces groupes.
     * @arg {GroupSet} groups - Ensemble de groupes.
     * @return {Promise(boolean)} Renvoie true si l'utilisateur est membre d'un des groupes
     * @async
     */
    async isMemberOr(groups: GroupSet): Promise<boolean> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            let member = this.memberOf;

            for (let gid of groups) {
                if (member.simpleGroups.has(gid) || member.metaGroups.has(gid)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsMember
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est member.
     * @return {Promise(GroupCollection)} Renvoie la collection de groupes dont l'utilisateur est member.
     * @async
     */
    async groupsMember(): Promise<GroupCollection> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            return this.memberOf;
        }
        return new GroupCollection;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isSpeaker
     * @summary Fonction qui renvoit si l'utilisateur est speaker du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(boolean)} Renvoie true si l'utilisateur est speaker du groupe.
     * @async
     */
    async isSpeaker(gid: string): Promise<boolean> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            let groups = this.speakerOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsSpeaker
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est speaker.
     * @return {Promise(GroupCollection)} Renvoie la collection de groupes dont l'utilisateur est speaker.
     * @async
     */
    async groupsSpeaker(): Promise<GroupCollection> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            return this.speakerOf;
        }
        return new GroupCollection;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function isAdmin
     * @summary Fonction qui renvoit si l'utilisateur est admin du groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(boolean)} Renvoie true si l'utilisateur est admin du groupe.
     * @async
     */
    async isAdmin(gid: string): Promise<boolean> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            let groups = this.adminOf;
            return (groups.simpleGroups.has(gid) || groups.metaGroups.has(gid));
        }
        return false;
    }

    /**
     * @memberof GraphQL.AuthorizationModel#
     * @function groupsAdmin
     * @summary Fonction qui renvoit les groupes dont l'utilisateur est admin.
     * @return {Promise(GroupCollection)} Renvoie la collection de groupes dont l'utilisateur est admin.
     * @async
     */
    async groupsAdmin(): Promise<GroupCollection> {
        //ensure uid is valid !!!!!!!!
        if (this.isAuthenticated()) {
            await this.m_loader.load();
            return this.adminOf;
        }
        return new GroupCollection;
    }

}