diff --git a/src/graphql/connectors/connection.ts b/src/graphql/connectors/connection.ts
deleted file mode 100644
index 9c99cbab0546f0b46db19c7a731d32e8aa07be9a..0000000000000000000000000000000000000000
--- a/src/graphql/connectors/connection.ts
+++ /dev/null
@@ -1,610 +0,0 @@
-/**
- * @file Fonctions pour interagir avec la BDD sigma et le LDAP.
- * @author akka vodol
- */
-import knex from '../../../db/knex_router';
-
-import {Group as groupLdap, groupData} from '../../ldap/export/group';
-import {User as userLdap, userData} from '../../ldap/export/user';
-import { isExportNamedDeclaration } from 'babel-types';
-
-import {GroupSet} from './authorisation';
-
-export class Group{
- gid : string;
- type : string; // simple or meta - not to be confused with category
- name? : string;
- category? : string;
- members? : string[];
- admins? : string[];
- description? : string;
- website?: string;
- createdAt?: string;
- UpdatedAt?: string;
-
- constructor(obj){
- this.gid = obj.uid; // until the database is mutated, the gid is called uid in the database
- this.type = obj.type;
- this.description = obj.description;
- this.website = obj.website;
- this.createdAt = obj.createdAt;
- this.UpdatedAt = obj.updatedAt;
- }
-
- /**
- * @summary effectue une requête au ldap pour avoir les donnees du groupe.
- */
- async fetchData() : Promise<void>{
- const data : groupData = await groupLdap.peek(this.gid);
- this.name = data.name;
- this.category = data.type; // this fields needs to be renamed in groupData
- this.members = data.members;
- this.admins = data.admins;
- this.description = data.description || this.description;
- }
-}
-
-export class User{
- uid : string;
-
- constructor(obj){
- this.uid = obj.uid;
- }
-
- async fetchData() : Promise<void>{
- const data : userData = await userLdap.peek(this.uid);
- for(const field in data){
- this[field] = data[field];
- }
- }
-}
-
-class QUser{
- uid: string;
- password : string;
-}
-
-/*
- Le tag @rights est la gestion des autorisations.
-
- Le système GraphQL est pensé comme l'interface par laquelle les utilisateurs
- intéragissent avec sigma, les graphismes en moins.
- Le client peut envoyer tout type de requête. C'est au niveau des resolvers
- que les permissions sont gérées. D'où le @rights
-
- Commençons par un rappel sur le fonctionnement des droits.
- Chaque utilisateur a un certain niveau de droit sur chaque groupe. Ce niveau de droit indique
- ce qu'il a le droit de savoir et de faire. Chaque niveau est inclus dans les niveaus supérieur.
- Les différents niveaux sont :
- none - aucun droit
- viewer : l'utilisateur a visibilité sur le groupe. Il sait que le groupe existe, et a accès à un certain nombre d'infos.
- member : l'utilisateur est membre du groupe
- speaker : l'utilisateur peut parler au nom du groupe. Il a le droit de publier des annonces et d'organiser des évènements
- admin : l'utilisateur a tous les droits sur le groupe
-
- Certaines fonctions de connectors effectuent des vérifications d'authorisations avant
- de renvoyer une réponse, d'autres non. Pour être sur qu'on ne renvoie jamais de réponse
- sans avoir au préalable éffectué les bonnes vérifications, chaque fonction possède dans sa
- description un attribut droit, qui décrit les droits que fournit cette fonction.
-
- La valeur de @rights peut être :
- super - la fonction n'effectue aucune véri-fication, et renvoie le resultat demandé
- admin( groupUID ) - la fonction ne fait que ce qu'un admin du groupe indiqué aurait le droit de faire
- speaker( groupUID ), member( groupUID ), veiwer( groupUID ) - même chose
- user - la fonction ne fait que ce que l'utiliateur a le droit de faire (vérifications via l'argument user)
-
- La procédure a suivre est la suivante : quand une fonction possède un certain niveau de droit,
- elle ne peut appeler une fonction possédant un niveau de droit plus large que si
- 1 ) on a au préalable vérifié que l'utilisateur possédait effectivement ces droits.
- ou
- 2 ) on s'est assuré que l'opération effectuée par cet appel particulier de la fonction était dans les droits
- de l'utilisateur
-
- Les resolvers de base de mutation et query ont des droits user.
-
- Les fonctions qui ne modifient pas la BDD et ne renvoient pas de données sur la BDD n'ont pas de rights.
-*/
-
-export function rasifyGID(uid){ //hawkspar->akka ; je plussoie le nom mais pas très lisible
- return String(uid).replace(' ', '_').replace(/\W/g, '').toLowerCase();
-}
-
-/**
- * @summary Renvoie tous les groupes simples dont les id sont dans groupSet
- */
-export async function getSimpleGroups(groupSet : GroupSet) : Promise<Group[]>{
- const res = await knex.select().from('simple_groups').whereIn('uid', groupSet.entries());
- return res.map( (data) => new Group(data) );
-}
-
-/**
- * @summary Renvoie tous les groupes simples dont les id sont dans groupSet
- */
-export async function getMetaGroups(groupSet : GroupSet) : Promise<Group[]>{
- const res = await knex.select().from('meta_groups').whereIn('uid', groupSet.entries());
- return res.map( (data) => new Group(data) );
-}
-
-/**
- * @summary Renvoie tous les groupes simples dont les id sont dans groupSet
- */
-export async function getGroups(groupSet : GroupSet) : Promise<Group[]>{
- const res = await knex.select().from('groups').whereIn('uid', groupSet.entries());
- return res.map( (data) => new Group(data) );
-}
-
-/**
- * @summary Attribue un GID qui n'a pas encore été utilisé à un groupe
- * @desc RASifie le string initialUID si necessaire (ramené à de l'ASCCI sans espace), puis si l'uid est deja pris rajoute un n a la fin et reteste
- * @arg {String} uid - L'uid du groupe dont on veut les administrateurs.
- * @return {Promise} Retour de requête knex. Promise qui renvera une liste de tous les utilisateurs ayant droit d'admin sur le groupe
- * @rights user
- * remarque : n'importe qui peut tester si un groupe existe en demandant a créer un groupe avec ce nom la et en regardant si
- * son GID a été modifié. Je ne vois pas comment contourner ce problème, c'est donc une faille permanente (mineure) de sigma.
- */
-export async function getAvailableGID(initialGID : string) : Promise<string>{
- let rasGID = rasifyGID(initialGID);
- const res = knex.from('groups').where('uid', rasGID)
- if (res.length == 0) {
- return (rasGID);
- } else {
- return (getAvailableGID(rasGID + 'n'));
- }
-}
-
-/**
- * @summary Créé un groupe si les arguments sont tous valides
- * @desc Les arguments doivent être valides, sauf pour uid. Une clé uid valide sera générée dans tous les cas.
- * Les authorisations de l'utilisateur ne sont pas vérifiées
- * On teste si l'utilisateur qui envoie la requête a des droits d'admin sur le parent du groupe qui doit être créé, avec la fonction
- * `getUsersWithAdminRights`.
- * Si un argument est invalide ou si l'utilisateur n'a pas les droits, la fonction renvoie une erreur
- * @arg {Object} user - L'utilisateur qui effectue la requête.
- * @arg {Object} args - Les arguments envoyés à la mutation. Cf le schéma GraphQL
- * @return {Promise} Retour de requête knex. Le groupe qui vient d'être créé. En cas d'echec, renvoie une erreur.
- * @rights admin (args.parent_uid)
- */
-export async function createSubgroup(quser : QUser, group : Group, args) : Promise<Group>{
-
- // TODO : finish
-
- if (typeof args.parent_uid != 'string')
- throw "Illegal argument : parent_uid must be a non null string";
- if (typeof args.name != 'string')
- throw "Illegal argument : name must be a non null string";
-
- let rasGID = await getAvailableGID(args.uid);
-
- // TODO : appeller une fonction de LDAPUser pour y créer un groupe.
- await knex('simple_groups').insert({
- uid: rasGID,
- parent_uid: args.parent_uid,
- createdAt: knex.fn.now(),
- updatedAt: this.createdAt,
- name: args.name,
- website: args.website,
- description: args.description,
- school: args.school,
- type : "simple"
- });
-
- return getGroup(rasGID);
-}
-
-export async function getUser(uid : string){
- return new User(uid);
-}
-
-export async function searchUsers(args: searchTOLArgs): Promise<User[]>{
- const searchData: userData = {
- givenName: args.givenName,
- lastName: args.lastName,
- nickname: args.nickname,
- nationality: args.nationality,
- promotion: args.promotion,
- groups: args.groups,
- sport: args.sport,
- phone: args.phone,
- mail: args.mail,
- address: args.addresses,
- ips: args.ips
- }
- const userList = await userLdap.search(searchData);
- return userList.map( (uid) => new User(uid) );
-}
-
-/**
- * @summary Renvoie toues les requêtes de type UserJoinGroup
- * @desc Une requête UserJoinGroup est envoyée par un utilisateur à un groupe,
- * pour demander à rejoindre ce groupe
- */
-export async function getUserJoinGroupRequests(recipient : Group){
- let result = knex.select('id', 'useruid', 'message').from('user_join_group')
- .where('recipient', recipient.gid);
- return result.map( obj => {
- obj.type = "UserJoinGroup";
- return obj;
- });
-}
-
-/**
- * @summary Renvoie toues les requêtes de type GroupJoinEvent
- * @desc Une requête UserJoinGroup est envoyée par un groupe à un évènement (donc aux administrateurs de l'évènement),
- * pour demander à rejoindre cet évènement.
- * Remarque : toutes les requêtes ont pour le moment un attribut recipient,
- * mais ici il ne sera a terme pas utilisé.
- */
-export async function getGroupJoinEventRequests(quser : QUser, recipient : Group){
- let result = await knex.select('id', 'senderuid', 'eventuid', 'message').from('group_join_event')
- .where('recipient', recipient.gid);
- return result.map( obj => {
- obj.type = "GroupJoinEvent";
- return obj;
- });
-}
-
-/**
- * @summary Renvoie toues les requêtes de type GroupHostEvent
- * @desc Une requête UserJoinGroup est envoyée par un groupe à un évènement (donc aux administrateurs de l'évènement),
- * pour demander à rejoindre cet évènement.
- * Remarque : toutes les requêtes ont pour le moment un attribut recipient,
- * mais ici il ne sera a terme pas utilisé.
- */
-export async function getYourGroupHostEventRequests(quser : QUser, recipient : Group){
- let result = await knex.select('id', 'senderuid', 'eventuid', 'message').from('your_group_host_event')
- .where('recipient', recipient.gid);
- return result.map( obj => {
- obj.type = "YourGroupHostEvent";
- return obj;
- });
-}
-
-
-// All these messages are returned if they are visible
-
-// TODO : figure out which announcements are visible
-
-export async function getAnnouncement(messageID){
- let res = await knex.select().from('announcements').where('id', messageID);
- if(res[0]){
- res[0].type = 'Announcement';
- return res[0];
- }
- res = await knex.select().from('events').where('id', messageID);
- if(res[0]){
- res[0].type = 'Announcement';
- return res[0];
- }
- return undefined;
-}
-
-export async function getEvent(messageID){
- let res = await knex.select().from('events').where('id', messageID);
- if(res[0]){
- res[0].type = 'Event';
- return res[0];
- }
- return undefined;
-}
-
-export async function getPrivatePost(messageID){
- let res = await knex.select().from('private_posts').where('id', messageID);
- if(res[0]){
- res[0].type = 'PrivatePost';
- return res[0];
- }
- return undefined;
-}
-
-export async function getQuestion(messageID){
- let res = await knex.select().from('questions').where('id', messageID);
- if(res[0]){
- res[0].type = 'Question';
- return res[0];
- }
- return undefined;
-}
-
-export async function getAnswer(messageID){
- let res = await knex.select().from('answers').where('id', messageID);
- if(res[0]){
- res[0].type = 'Answer';
- return res[0];
- }
- return undefined;
-}
-
-/**
- *
- * @param groupSet The set of all groups who's events we want to see.
- */
-export async function allEvents(groupSet : GroupSet){
- let selection = [];
- throw new Error('Not implemented');
- let result = await knex.select().from('events').whereIn('id', selection);
- for(let r of result){
- r.type = 'Announcement';
- }
- return result;
-}
-
-export async function allAnnouncements(groupSet : GroupSet){
- let selection = [];
- throw new Error('Not implemented');
- let result = await knex.select().from('announcements').whereIn('id', selection);
- result = result.concat(
- await knex.select().from('events').whereIn('id', selection)
- );
- for(let r of result){
- r.type = 'Announcement';
- }
- return result;
-}
-
-export async function receivedPrivatePosts(group : Group){
- let selection = [];
- throw new Error('Not implemented');
- // let result = await knex('private_posts').select().whereIn('id', received_messages);
- // for(let entry of result){
- // entry.type = "PrivatePost";
- // }
- // return result;
-}
-
-export async function receivedQuestions(group : Group){
- let selection = [];
- throw new Error('Not implemented');
- // let result = await knex('questions').select().whereIn('id', received_messages);
- // for(let entry of result){
- // entry.type = "Question";
- // }
- // return result;
-}
-
-export async function receivedAnswers(group : Group){
- let selection = [];
- throw new Error('Not implemented');
- // let received_messages = await selectors.recievedMessages(user, groupUID);
- // let result = await knex('answers').select().whereIn('id', received_messages);
- // for(let entry of result){
- // entry.type = "Answer";
- // }
- // return result;
-}
-
-
-export async function visibleMessages(user, messageID){
-
-}
-
-export async function getMessageGroupAuthors(user, messageID){
- return knex.select({uid: 'group'}).from('group_message_relationships')
- .where('message', messageID).whereIn('status', ['host', 'publish']);
-
-}
-
-export async function getMessageGroupRecipients(user, messageID){
- return knex.select({uid: 'group'}).from('group_message_relationships')
- .where('message', messageID).where('status', 'recieve');
-}
-
-/**
- * @summary Renvoie simplement un groupe en fonction de son identifiant.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} groupUID - Identifiant unique du groupe.
- * @author manifold
- * @rights super
- */
-export async function getGroup(gid : string) : Promise<Group>{
- // Une sélection sur une table renvoie un tableau.
- // Knex renvoie une promesse, qui se résout en le tableau sélectionné.
- // On récupère son unique valeur, puisqu'on filtre sur l'identifiant unique.
- return knex.select().from('groups').where('uid',gid).then(results => results[0]);
-};
-
-/**
- * @summary Renvoie simplement un groupe simple en fonction de son identifiant.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} groupUID - Identifiant unique du groupe.
- * @author manifold
- * @rights super
- */
-export async function getSimpleGroup(gid : string) : Promise<Group>{
- return knex.select().from('simple_groups').where('uid', gid).then(results => results [0]);
-};
-
-/**
- * @summary Renvoie simplement un meta groupe en fonction de son identifiant.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} groupUID - Identifiant unique du groupe.
- * @author manifold
- * @rights super
- */
-export async function getMetaGroup(gid : string) : Promise<Group>{
- return knex.select().from('meta_groups').where('uid', gid).then(results => results [0]);
-};
-
-/**
- * @summary Refuse une requête d'un groupe voulant rejoindre un évènement
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {Int} requestID - L'id de la requête à refuser.
- * @return {Promise(Boolean)} Vrai si l'opération a réussie;
- * @rights admin(request.recipient)
- */
-export async function denyGroupJoinEventRequest(requestID){
- await knex('group_join_event').where('id', requestID).del();
- return true;
-}
-
-/**
- * @summary Refuse une requête d'un groupe voulant rejoindre un évènement
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {Int} requestID - L'id de la requête à refuser.
- * @return {Promise(Boolean)} Vrai si l'opération a réussie;
- * @rights admin(request.recipient)
- */
-export async function acceptGroupJoinEventRequest(user, requestID){
- let request = await knex('group_join_event').select().where('id', requestID);
- if( !request)
- return false;
- await knex('group_join_event').where('id', requestID).del();
- let group = request[0].senderuid;
- let event = request[0].eventuid;
- await knex('group_participation').insert({
- group : group,
- message : event,
- status : "join"
- });
- return;
-
-}
-
-
-/**
- * @summary Refuse une requête d'un groupe voulant rejoindre un évènement
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {Int} requestID - L'id de la requête à refuser.
- * @return {Promise(Boolean)} Vrai si l'opération a réussie;
- * @rights admin(request.recipient)
- */
-export async function denyYourGroupHostEventRequest(requestID : string) : Promise<boolean>{
- await knex('your_group_host_event').where('id', requestID).del();
- throw new Error('Not implemented');
-}
-
-/**
- * @summary Refuse une requête d'un groupe voulant rejoindre un évènement
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {Int} requestID - L'id de la requête à refuser.
- * @return {Promise(Boolean)} Vrai si l'opération a réussie;
- * @rights admin(request.recipient)
- */
-export async function acceptYourGroupHostEventRequest(requestID : string) : Promise<Boolean>{
- let request = await knex('your_group_host_event').select().where('id', requestID);
- if( !request)
- return false;
- await knex('group_join_event').where('id', requestID).del();
- let group = request[0].recipient;
- let event = request[0].eventuid;
- await knex('group_message_relationships').insert({
- group : group,
- message : event,
- status : "host"
- });
- return;
-
-}
-
-export async function takeAdminRights(user, groupUID, justification) : Promise<boolean>{
- await knex('taken_rights').insert({
- user_uid : user.uid,
- group_uid : groupUID,
- justification : justification
- });
- return true;
-}
-
-
-export function releaseAdminRights(user, groupUID){
- return knex('taken_rights').del().where('user_uid', user.uid).where('group_uid', groupUID);
-}
-
-/**
- * @summary Renvoie les membres d'un groupe quelquonque.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} metaGroupUID - Identifiant unique du groupe.
- * @return {Promise(List)} Une liste des uid de tous les membres du groupe
- * @author akka vodol
- * @rights member(metaGroupUID)
- */
-export async function getGroupMemberUsers(quser : QUser, group : Group) : Promise<User[]>{
- const memberSet = await getGroupMemberUsersSet(quser, group);
- return Array.from(memberSet.values()).map( uid => new User(uid) );
-}
-
-async function getGroupMemberUsersSet(quser : QUser, group : Group) : Promise<Set<string>>{
- switch( group.type ){
- case "simple":
- if(!group.members){
- await group.fetchData();
- }
- return new Set(group.members);
- case "meta":
- let member_group_list = await knex.distinct().select().from('groups')
- .innerJoin('meta_group_membership', 'groups.uid', 'meta_group_membership.member_uid')
- .where('meta_group_membership.union_uid', '=', group.gid);
- let members = new Set;
- for(const memberGroup of member_group_list){
- let res = await getGroupMemberUsers(quser, new Group(memberGroup));
- for(const member of res.values()){
- members.add(member);
- }
- }
- return members;
- default:
- return undefined;
- }
-}
-
-
-/**
- * @summary Renvoie les membres d'un groupe quelquonque.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} metaGroupUID - Identifiant unique du groupe.
- * @return {Promise(List)} Une liste des uid de tous les membres du groupe
- * @author akka vodol
- * @rights member(metaGroupUID)
- */
-export async function getGroupAdminUsers(quser : QUser, group : Group) : Promise<User[]>{
- const memberSet = await getGroupAdminUsersSet(quser, group);
- return Array.from(memberSet.values()).map( uid => new User(uid) );
-}
-
-async function getGroupAdminUsersSet(quser : QUser, group : Group) : Promise<Set<string>>{
- switch( group.type ){
- case "simple":
- if(!group.members){
- await group.fetchData();
- }
- return new Set(group.admins);
- case "meta":
- // TODO : Meta group administration not yet implemented
- return new Set([]);
- default:
- return undefined;
- }
-}
-
-/*
- * réflexion sur une façon possible de gérer les utilisateurs sans en demander trop à LDAP
- * Sans utilité pour le moment, ne faites pas attention
- */
-
-/*
-function smartUserObject(user, uid){
- this.user = user;
- this.uid = uid;
-
- this.resolution = {};
- let resolutionAlias = this.resolution;
-
- let attributeDictionnary = {
- givenName : "givenName"
- };
-
- for(let attribute in attributeDictionnary){
- this[attribute] = function(){
- return new Promise((resolve, reject) => {
- resolutionAlias[attributeDictionnary[attribute]] = resolve;
- });
- };
- }
-
- this.resolve = async function(){
- let userObject = await renseignerSurUtilisateur(this.user, this.uid);
- for(let attribute in this.resolution){
- this.resolution[attribute](userObject.attribute);
- }
- };
-}
-*/
\ No newline at end of file
diff --git a/src/graphql/connectors/groupModel.ts b/src/graphql/connectors/groupModel.ts
index 91b4f49268f650dbc22585bee7f9121529f50823..67b0852c1c1e03e82aecdf75345efc1589e86d53 100644
--- a/src/graphql/connectors/groupModel.ts
+++ b/src/graphql/connectors/groupModel.ts
@@ -8,7 +8,7 @@ import { Group, SimpleGroup, MetaGroup } from "../resolvers/groups";
import { Request } from "../resolvers/requests";
import { User } from "../resolvers/users";
import knex from "../../../db/knex_router"
-import { GroupCollection, GroupSet } from "./tools";
+import { GroupCollection, GroupSet, Tools } from "./tools";
import { createSubgroupArgs, editGroupArgs } from "../typeDefs/queries";
export class GroupModel {
@@ -225,6 +225,29 @@ export class GroupModel {
return getGroup(rasGID);*/
}
+ /**
+ * @memberof GraphQL.GroupModel#
+ * @function getAvailableGID
+ * @summary Attribue un GID qui n'a pas encore été utilisé à un groupe
+ * @desc Escape le string initialGID si necessaire (ramené à de l'ASCII sans espace), puis si le gid est deja pris rajoute un n a la fin et reteste
+ * @arg {string} initialGID - Le gid initial du groupe, qu'il faut tester pour l'unicité.
+ * @return {Promise(string)} Renvoie le gid unique pour ce groupe.
+ * @rights authentified
+ * remarque : n'importe qui peut tester si un groupe existe en demandant a créer un groupe avec ce nom la et en regardant si
+ * son GID a été modifié. Je ne vois pas comment contourner ce problème, c'est donc une faille permanente (mineure) de sigma.
+ * // ofacklam -> savoir qu'un groupe existe est autorisé pour toute personne connectée ou on-platal et il faut etre connecté pour
+ * // utiliser cette fonction-ci donc il n'y a pas de probleme.
+ */
+ async getAvailableGID(initialGID: string): Promise<string> {
+ let rasGID = Tools.escapeID(initialGID);
+ const res = knex.from('groups').where('gid', rasGID)
+ if (res.length == 0) {
+ return (rasGID);
+ } else {
+ return (this.getAvailableGID(rasGID + 'n'));
+ }
+ }
+
/**
* @memberof GraphQL.GroupModel#
* @function makeAdmin
@@ -325,6 +348,13 @@ export class GroupModel {
*/
async takeAdminRights(gid: string, uid: string): Promise<boolean> {
throw "Not implemented";
+
+ /*await knex('taken_rights').insert({
+ user_uid: user.uid,
+ group_uid: groupUID,
+ justification: justification
+ });
+ return true;*/
}
/**
@@ -340,6 +370,8 @@ export class GroupModel {
async releaseAdminRights(gid: string, uid: string): Promise<boolean> {
//TODO : relacher récursivement
throw "Not implemented";
+
+ /*return knex('taken_rights').del().where('user_uid', user.uid).where('group_uid', groupUID);*/
}
}
\ No newline at end of file
diff --git a/src/graphql/connectors/messageModel.ts b/src/graphql/connectors/messageModel.ts
index 6fdbbf1da9a0eb0a9c2d694a1254cfd7b76194ef..bfb9070ba7931ac8b75414461dd260d1fa2b9f74 100644
--- a/src/graphql/connectors/messageModel.ts
+++ b/src/graphql/connectors/messageModel.ts
@@ -112,6 +112,15 @@ export class MessageModel {
*/
async getAllAnnouncements(groups: GroupCollection): Promise<Announcement[]> {
throw "Not implemented";
+
+ /*let result = await knex.select().from('announcements').whereIn('id', selection);
+ result = result.concat(
+ await knex.select().from('events').whereIn('id', selection)
+ );
+ for (let r of result) {
+ r.type = 'Announcement';
+ }
+ return result;*/
}
/**
@@ -125,6 +134,12 @@ export class MessageModel {
*/
async getAllEvents(groups: GroupCollection): Promise<Event[]> {
throw "Not implemented";
+
+ /*let result = await knex.select().from('events').whereIn('id', selection);
+ for (let r of result) {
+ r.type = 'Announcement';
+ }
+ return result;*/
}
/**
@@ -138,6 +153,12 @@ export class MessageModel {
*/
async getAllPrivatePosts(groups: GroupCollection): Promise<PrivatePost[]> {
throw "Not implemented";
+
+ // let result = await knex('private_posts').select().whereIn('id', received_messages);
+ // for(let entry of result){
+ // entry.type = "PrivatePost";
+ // }
+ // return result;
}
/**
diff --git a/src/graphql/connectors/requestModel.ts b/src/graphql/connectors/requestModel.ts
index 101513015e5dee061238c7ad02e6e5c0d6bac793..5435ae0584afc1891826edd600b52a0801ec1d91 100644
--- a/src/graphql/connectors/requestModel.ts
+++ b/src/graphql/connectors/requestModel.ts
@@ -94,6 +94,14 @@ export class RequestModel {
*/
async getUserJoinGroupRequestsToGroup(gid: string): Promise<UserJoinGroup[]> {
throw "Not implemented";
+
+ // CODE A MODIFIER
+ /*let result = knex.select('id', 'useruid', 'message').from('user_join_group')
+ .where('recipient', recipient.gid);
+ return result.map(obj => {
+ obj.type = "UserJoinGroup";
+ return obj;
+ });*/
}
/**
@@ -120,6 +128,21 @@ export class RequestModel {
*/
async getGroupCoauthorEventRequestsToGroup(gid: string): Promise<GroupCoauthorEvent[]> {
throw "Not implemented";
+
+ //CODE A MODIFIER
+ /*let result = await knex.select('id', 'senderuid', 'eventuid', 'message').from('group_join_event')
+ .where('recipient', recipient.gid);
+ return result.map(obj => {
+ obj.type = "GroupJoinEvent";
+ return obj;
+ });*/
+
+ /*let result = await knex.select('id', 'senderuid', 'eventuid', 'message').from('your_group_host_event')
+ .where('recipient', recipient.gid);
+ return result.map(obj => {
+ obj.type = "YourGroupHostEvent";
+ return obj;
+ });*/
}
/**
@@ -236,6 +259,20 @@ export class RequestModel {
*/
async acceptGroupCoauthorEventRequest(req: GroupCoauthorEvent, comment: string): Promise<boolean> {
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;*/
}
/**
@@ -250,6 +287,10 @@ export class RequestModel {
*/
async refuseGroupCoauthorEventRequest(req: GroupCoauthorEvent, comment: string): Promise<boolean> {
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;*/
}
}
\ No newline at end of file
diff --git a/src/graphql/resolvers/groups.ts b/src/graphql/resolvers/groups.ts
index f500264edd717d880e2650cdb37a5729f6bef4cd..ad4287b083ee71c8c8e65e93660ace153d33d7a7 100644
--- a/src/graphql/resolvers/groups.ts
+++ b/src/graphql/resolvers/groups.ts
@@ -206,6 +206,12 @@ export abstract class Group {
async questions(args, context: Context, info): Promise<Question[]> {
if (context.models.auth.isViewer(this.gid)) {
throw "Not implemented"
+
+ // let result = await knex('questions').select().whereIn('id', received_messages);
+ // for(let entry of result){
+ // entry.type = "Question";
+ // }
+ // return result;
}
throw new AuthenticationError("Not a viewer");
}
@@ -221,6 +227,13 @@ export abstract class Group {
async answers(args, context: Context, info): Promise<Answer[]> {
if (context.models.auth.isViewer(this.gid)) {
throw "Not implemented"
+
+ // let received_messages = await selectors.recievedMessages(user, groupUID);
+ // let result = await knex('answers').select().whereIn('id', received_messages);
+ // for(let entry of result){
+ // entry.type = "Answer";
+ // }
+ // return result;
}
throw new AuthenticationError("Not a viewer");
}
@@ -681,6 +694,18 @@ export class MetaGroup extends Group {
async members(args, context: Context, info): Promise<SimpleGroup[]> {
if (context.models.auth.isViewer(this.gid)) {
throw "Not implemented"
+
+ /*let member_group_list = await knex.distinct().select().from('groups')
+ .innerJoin('meta_group_membership', 'groups.uid', 'meta_group_membership.member_uid')
+ .where('meta_group_membership.union_uid', '=', group.gid);
+ let members = new Set;
+ for (const memberGroup of member_group_list) {
+ let res = await getGroupMemberUsers(quser, new Group(memberGroup));
+ for (const member of res.values()) {
+ members.add(member);
+ }
+ }
+ return members;*/
}
throw new AuthenticationError("Not a viewer");
}
diff --git a/src/graphql/resolvers/messages.ts b/src/graphql/resolvers/messages.ts
index fcbe3c03df21d51bff097cc89255e52264d653ba..8e9a6c49b889db14756c831bbac6b88215b94326 100644
--- a/src/graphql/resolvers/messages.ts
+++ b/src/graphql/resolvers/messages.ts
@@ -234,6 +234,9 @@ export class Announcement extends Message {
*/
async authors(args, context: Context, info): Promise<Group[]> {
throw "Not implemented";
+
+ /*return knex.select({ uid: 'group' }).from('group_message_relationships')
+ .where('message', messageID).whereIn('status', ['host', 'publish']);*/
}
/**
@@ -246,6 +249,9 @@ export class Announcement extends Message {
*/
async recipients(args, context: Context, info): Promise<Group[]> {
throw "Not implemented";
+
+ /*return knex.select({ uid: 'group' }).from('group_message_relationships')
+ .where('message', messageID).where('status', 'recieve');*/
}
/**
@@ -392,6 +398,9 @@ export class Event extends Message {
*/
async authors(args, context: Context, info): Promise<Group[]> {
throw "Not implemented";
+
+ /*return knex.select({ uid: 'group' }).from('group_message_relationships')
+ .where('message', messageID).whereIn('status', ['host', 'publish']);*/
}
/**
@@ -404,6 +413,9 @@ export class Event extends Message {
*/
async recipients(args, context: Context, info): Promise<Group[]> {
throw "Not implemented";
+
+ /*return knex.select({ uid: 'group' }).from('group_message_relationships')
+ .where('message', messageID).where('status', 'recieve');*/
}
/**