requestModel.ts

/**
 * @file Fonctions qui implémentent les requetes relatives aux requetes
 * @author ofacklam
 * @memberof GraphQL
 */

import { Group } from "../object_resolvers/groups/groups";
import { SimpleGroup } from "../object_resolvers/groups/simpleGroups";
import { MetaGroup } from "../object_resolvers/groups/metaGroups";

import { Request } from "../object_resolvers/requests/requests";
import { UserJoinGroup } from '../object_resolvers/requests/userJoinGroup';
import { GroupJoinMetagroup } from '../object_resolvers/requests/groupJoinMetagroup';
import { GroupCoauthorEvent } from '../object_resolvers/requests/groupCoauthorEvent';

import { User } from "../object_resolvers/users";

import knex from "../../../db/knex_router"
import { GroupCollection, GroupSet } from "../../utils/tools";
import { createSubgroupArgs, editGroupArgs } from "../typeDefs/queries";
import { InvalidGraphQLRequestError } from "apollo-server-core";

export class RequestModel {

    /**
     * @memberof GraphQL
     * @class RequestModel
     * @summary Requetes relatives aux requetes.
     * @classdesc Cette classe contient les méthodes implémentant les requetes relatives aux requetes.
     * @arg {string} contextUser - L'identifiant de l'utilisateur du 'context'
     */
    constructor(contextUser: string) {
        this.contextUser = contextUser;
    }

    protected contextUser: string;

    /**
     * @memberof GraphQL.RequestModel#
     * @function getUserJoinGroupRequest
     * @summary Fonction qui renvoie une requete UserJoinGroup donnée.
     * @arg {number} rid - Identifiant demandé.
     * @return {Promise(UserJoinGroup)} Renvoie la requete dont l'identifiant est 'rid'
     * @async
     * @rights admin du groupe destinaire ou le user émetteur
     */
    async getUserJoinGroupRequest(rid: number): Promise<UserJoinGroup> {
        return UserJoinGroup.tryCreate(rid);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getGroupJoinMetagroupRequest
     * @summary Fonction qui renvoie une requete GroupJoinMetagroup donnée.
     * @arg {number} rid - Identifiant demandé.
     * @return {Promise(GroupJoinMetagroup)} Renvoie la requete dont l'identifiant est 'rid'
     * @async
     * @rights admin du groupe émetteur ou destinataire
     */
    async getGroupJoinMetagroupRequest(rid: number): Promise<GroupJoinMetagroup> {
        return GroupJoinMetagroup.tryCreate(rid);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getGroupCoauthorEventRequest
     * @summary Fonction qui renvoie une requete GroupCoauthorEvent donnée.
     * @arg {number} rid - Identifiant demandé.
     * @return {Promise(GroupCoauthorEvent)} Renvoie la requete dont l'identifiant est 'rid'
     * @async
     * @rights admin du groupe émetteur ou destinataire
     */
    async getGroupCoauthorEventRequest(rid: number): Promise<GroupCoauthorEvent> {
        return GroupCoauthorEvent.tryCreate(rid);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getRequestsToGroup
     * @summary Fonction qui renvoie toutes les requetes destinées a ce groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(Request[])} Renvoie la liste des requetes destinées a ce groupe.
     * @async
     * @rights admin du groupe
     */
    async getRequestsToGroup(gid: string): Promise<Request[]> {
        let r1 = await this.getUserJoinGroupRequestsToGroup(gid);
        let r2 = await this.getGroupJoinMetagroupRequestsToGroup(gid);
        let r3 = await this.getGroupCoauthorEventRequestsToGroup(gid);

        let r: Request[];
        return r.concat(r1, r2, r3);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getUserJoinGroupRequestsToGroup
     * @summary Fonction qui renvoie toutes les requetes UserJoinGroup destinées a ce groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(UserJoinGroup[])} Renvoie la liste des requetes destinées a ce groupe.
     * @async
     * @rights admin du groupe
     */
    async getUserJoinGroupRequestsToGroup(gid: string): Promise<UserJoinGroup[]> {
        let result = await knex.select('rid').from('requests_user_join_group').where('request_to', gid);
        return result.map(obj => new UserJoinGroup(obj.rid));
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getGroupJoinMetagroupRequestsToGroup
     * @summary Fonction qui renvoie toutes les requetes GroupJoinMetagroup destinées a ce groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(GroupJoinMetagroup[])} Renvoie la liste des requetes destinées a ce groupe.
     * @async
     * @rights admin du groupe
     */
    async getGroupJoinMetagroupRequestsToGroup(gid: string): Promise<GroupJoinMetagroup[]> {
        let result = await knex.select('rid').from('requests_group_join_metagroup').where('request_to', gid);
        return result.map(obj => new GroupJoinMetagroup(obj.rid));
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function getGroupCoauthorEventRequestsToGroup
     * @summary Fonction qui renvoie toutes les requetes GroupCoauthorEvent destinées a ce groupe.
     * @arg {string} gid - Identifiant du groupe.
     * @return {Promise(GroupCoauthorEvent[])} Renvoie la liste des requetes destinées a ce groupe.
     * @async
     * @rights admin du groupe
     */
    async getGroupCoauthorEventRequestsToGroup(gid: string): Promise<GroupCoauthorEvent[]> {
        let result = await knex.select('rid').from('requests_group_coauthor_event').where('request_to', gid);
        return result.map(obj => new GroupCoauthorEvent(obj.rid));
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function userRequestJoinGroup
     * @summary Fonction pour demander a devenir membre
     * @arg {string} gid - Identifiant du groupe.
     * @arg {string} comment - Commentaire supplémentaire
     * @return {Promise(UserJoinGroup)} Renvoie la requete créée.
     * @async
     * @rights viewer du groupe
     */
    async userRequestJoinGroup(gid: string, comment: string): Promise<UserJoinGroup> {
        let res = await knex("requests_user_join_group").insert({request_to : gid, request_from : this.contextUser, request_comment : comment}, ['rid']);
        return this.getUserJoinGroupRequest(res[0]["rid"]);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function groupRequestCoauthorEvent
     * @summary Fonction pour demander a co-organiser un évenement
     * @arg {string} from_gid - Identifiant du groupe émetteur.
     * @arg {string} to_gid - Identifiant du groupe destinataire.
     * @arg {number} event_mid - Identifiant de l'évenement considéré.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(GroupCoauthorEvent)} Renvoie la requete créée.
     * @async
     * @rights speaker du groupe émetteur
     */
    async groupRequestCoauthorEvent(from_gid: string, to_gid: string, event_mid: number, comment: string): Promise<GroupCoauthorEvent> {
        //TODO : Vérifier que l'évenement est bien organisé par le groupe destinataire (to_gid) !!! => sinon erreur
        if ((await knex.select("mid","gid").from("events_authors").where({mid : event_mid, gid: to_gid})).length >= 1) 
        {
            let res = await knex("requests_group_coauthor_event").insert({request_to : to_gid, request_from : from_gid, request_comment : comment, for_event : event_mid}, ['rid']);
            return this.getGroupCoauthorEventRequest(res[0]["rid"]);
        } else {
            throw new InvalidGraphQLRequestError("The event has not been organised by the recipient of the request")
        }
        
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function groupRequestJoinMetagroup
     * @summary Fonction pour demander a rejoindre un méta-groupe
     * @arg {string} from_gid - Identifiant du groupe émetteur.
     * @arg {string} to_gid - Identifiant du méta-groupe destinataire.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(GroupJoinMetagroup)} Renvoie la requete créée.
     * @async
     * @rights admin du groupe émetteur
     */
    async groupRequestJoinMetagroup(from_gid: string, to_gid: string, comment: string): Promise<GroupJoinMetagroup> {
        let res = await knex("requests_group_join_metagroup").insert({request_to : to_gid, request_from : from_gid, request_comment : comment}, ['rid']);
        return this.getGroupJoinMetagroupRequest(res[0]["rid"]);
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function acceptUserJoinRequest
     * @summary Fonction pour accepter une UserJoinGroup
     * @arg {UserJoinGroup} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async acceptUserJoinRequest(req: UserJoinGroup, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function refuseUserJoinRequest
     * @summary Fonction pour refuser une UserJoinGroup
     * @arg {UserJoinGroup} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async refuseUserJoinRequest(req: UserJoinGroup, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function acceptGroupJoinRequest
     * @summary Fonction pour accepter une GroupJoinMetagroup
     * @arg {GroupJoinMetagroup} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async acceptGroupJoinRequest(req: GroupJoinMetagroup, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function refuseGroupJoinRequest
     * @summary Fonction pour refuser une GroupJoinMetagroup
     * @arg {GroupJoinMetagroup} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async refuseGroupJoinRequest(req: GroupJoinMetagroup, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function acceptGroupCoauthorEventRequest
     * @summary Fonction pour accepter une GroupCoauthorEvent
     * @arg {GroupCoauthorEvent} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async acceptGroupCoauthorEventRequest(req: GroupCoauthorEvent, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";

        /*let request = await knex('group_join_event').select().where('id', requestID);
        if (!request.length)
            return false;
        
        let group = request[0].senderuid;
        let event = request[0].eventuid;
        await knex('group_participation').insert({
            group: group,
            message: event,
            status: "join"
        });
        await knex('group_join_event').where('id', requestID).del();
        return;*/
    }

    /**
     * @memberof GraphQL.RequestModel#
     * @function refuseGroupCoauthorEventRequest
     * @summary Fonction pour refuser une GroupCoauthorEvent
     * @arg {GroupCoauthorEvent} req - L'objet requete.
     * @arg {string} comment - Commentaire supplémentaire.
     * @return {Promise(boolean)} Renvoie true si modification réussie.
     * @async
     * @rights admin du groupe destinataire
     */
    async refuseGroupCoauthorEventRequest(req: GroupCoauthorEvent, comment: string): Promise<boolean> {
        //"comment" a envoyer par mail automatique
        throw "Not implemented";

        /*await knex('group_join_event').where('id', requestID).del();
        //KNEX RENVOIE LE NOMBRE DE LIGNES AFFECTÉES -> il faut l'utiliser pour la valeur de retour
        return true;*/
    }

}