selectors.js

/**
 * @file Des callbacks qui sélectionnent un sous-ensemble de groupes.
 * @author akka vodol
 */

import { renseignerSurUtilisateur, repliquerTOLdesIds, 
    listerGroupes, listerMembres, listerAdministrateurs 
} from '../../ldap/ldap_data';

/**
 * @summary 2Renvoie une liste des id de tous les groupes visibles par l'utilisateur
 * @desc Cette fonction génère un callback qui créé une table contenant les uid de tous les groupes visibles
 * @arg {Object} user - Objet contenant un attribut `uid` de type `string`. 
 * User représente l'utilisateur qui a effectué la requête. 
 * @return {Promise(Callback)} callback contruisant une requête knex pour une table de tous les id visibles.
 * @rights user
 */
export async function  visibleGroups(user){
    //let group_ids = await listerGroupes(user, user.uid);
    let group_ids = ["br, kes, faerix"];
    console.log("we got this far");
    return function (global_query_builder){
        if (typeof group_ids == "undefined")
            throw "invalid user";
        var membered_groups = qb => qb.select('simple_groups.uid').from('simple_groups').whereIn('uid', group_ids.concat(['kes']));
        var directly_visible_simple_groups = qb =>  qb.with('membered_groups', membered_groups)
            .select('simple_groups.uid').from('simple_groups').distinct()
            .innerJoin('membered_groups',
                function () {
                    this.on('simple_groups.uid', '=', 'membered_groups.uid')
                        .orOn('simple_groups.parentuid', '=', 'membered_groups.uid');
                }
            );
        return directly_visible_simple_groups(global_query_builder);
    };
}

export async function visibleAnnouncements(user){
    return query_builder => {
        return query_builder;
    };
}

export async function visibleEvents(user){
    return query_builder => {
        return query_builder;
    };
}

export async function messageHosts(user, messageID){
    return function(query_builder){
        return query_builder.select('group').as('uid').from('group_message_relationships')
            .where('message', messageID);
    };
}

/**
 * @summary Renvoie un callback qui génère tous les membres d'un meta-groupe.
 * @param {Object} user - Utilisateur effectuant la requête.
 * @param {String} metaGroupUID - Identifiant unique du groupe.
 * @return {Promise(callback(groups))} a callback to build a query for the members of a group
 * It doesn't need to be a promise, but I figure having all of my functions return promises is 
 * easier than keeping track of which functions do and do not return promises.
 * @author akka vodol 
 * @rights member(metaGroupUID)
 */
export async function metaGroupMembers(user, metaGroupUID){
    return function(query_builder){
        return query_builder.distinct().select().from('groups')
            .innerJoin('meta_group_membership', 'groups.uid', 'meta_group_membership.member_uid')