Source: src/graphql/schema.js

/**
 * @file Ce fichier genere le shema utilise par Apollo. C'est ici que les requetes GraphQl sont résolues.
 * @author akka vodol
*/

import knex from '../../db/knex_router';
import { listGroups, listMembers } from '../ldap/ldap_data';
import { makeExecutableSchema } from 'graphql-tools';
import { request } from 'https';

const typeDefs = `
    type Query {
        allGroups: [Group]
        group(uid: ID) : Group
    }

    type Group {
        name: String
        uid: ID
        website: String
        updatedAt: String
        description: String
        school: String
    }
`;

<<<<<<< HEAD
const getAllVisibleGroups = (user) => {

    var group_ids =   listGroups(user.id).then(res => {
        console.log(res.concat(['kes']));
        return res.concat(['kes']);
    });
    var membered_groups = qb => qb.select().from('groups').whereIn('uid', ['faerix', 'data']);
    return knex.with('membered_groups', membered_groups).distinct('groups.*').select().from('groups').innerJoin('membered_groups', 
        function() {
            this.on('groups.uid', '=', 'membered_groups.uid').orOn('groups.parentuid', '=', 'membered_groups.uid');
        }
    );
};
    
=======
/**
 * @summary Renvoie tous les groupes visibles par l'utilisateur user
 * @desc Cette fonction effectue une requête knex. Elle gère l'arrête de parenté.
 * @arg {Object} user - Objet contenant un attribut *uid* de type *string*. User représente l'utilisateur qui a effectué la requête. 
 * @return {Promise} Retour de requête knex. Liste de tous les groupes que l'utilisateur a le droit de voire.
 */
const getAllVisibleGroups = (user) => {

    return listGroups(user.id).then(group_ids => {
        var membered_groups = qb => qb.select().from('groups').whereIn('uid', group_ids.concat(['kes'])); 
        /* membered_groups est un callback qui reçoit un argument qb représentant un objet de requête (un truc qui s'utilise comme knex())
        *  et effectue dessus la requête pour obtenir une table de tous les groupes dont user est membre
        *  with est ensuite utilisé pour donner à ce retour de requête l'alias 'membered_groups'.
        *  Cette table peut ainsi être JOIN avec la table groups. La condition de Join est donnée selon une syntaxe recopiée depuis la Doc Knex
        *  On récupère tous les groupes tels que le groupe est dans membered_groups ou le parent est dans membered_groups
        */ 
        return knex.with('membered_groups', membered_groups).distinct('groups.*').select().from('groups').innerJoin('membered_groups', 
        function() {
            this.on('groups.uid', '=', 'membered_groups.uid').orOn('groups.parentuid', '=', 'membered_groups.uid');
        }
        );
    });
};

/**
 * @summary Renvoie un unique groupe, ssi ce groupe est visible par l'utilisateur
 * @desc Actuellement, la fonction appelle *getAllVisibleGroups* et restreint au groupe demandé. Cette fonction peut être implémentée de manière plus efficace et plus chiante.
 * @arg {Object} user - Objet contenant un attribut *uid* de type *string*. User représente l'utilisateur qui a effectué la requête. 
 * @arg {String} uid - uid du groupe que l'on veut voire. 
 * @return {Promise} Retour de requête knex. Le groupe demandé, si l'utilisateur a le droit de la voire.
 */
>>>>>>> 0d37bfa57a7bad303c19ffa3b40a2120b399beea
const getGroupIfVisible = (user, uid) => {
    return getAllVisibleGroups(user).where('groups.uid', uid).then(res => {
        return res[0];
    });
};

const resolvers = {
    Query: {
        allGroups: (obj, args, context) => {
            return getAllVisibleGroups(context.user);
        },
        group: (obj, args, context) => {
            return getGroupIfVisible(context.user, args.uid);
        }
    }
};

const schema = makeExecutableSchema({
    typeDefs,
    resolvers
});

export default schema;