diff --git a/src/config_passport.js b/src/config_passport.js
index 050b5e932fae24ff015f06de14786806c0ac855e..33a86aac56a7afc9dd535b33959f27e80600fade 100644
--- a/src/config_passport.js
+++ b/src/config_passport.js
@@ -32,7 +32,7 @@
*/
import passport from 'passport';
import LdapStrategy from 'passport-ldapauth';
-import { ldapConfig } from './ldap/config';
+import { ldapConfig } from './ldap/internal/config';
// specifies options for 'ldapauth' strategy, to customize the behaviour of subsequent passport.authenticate('ldapauth') calls
passport.use(new LdapStrategy({
diff --git a/src/graphql/connectors/authentifiers.ts b/src/graphql/connectors/authentifiers.ts
deleted file mode 100644
index b453c639f0dfb280f9e50fbb833c093350ae57fe..0000000000000000000000000000000000000000
--- a/src/graphql/connectors/authentifiers.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-/**
- * @file Fonctions d'authentification
- * @author akka vodol
- */
-
-import knex from '../../../db/knex_router.js';
-import * as connectors from './connectors.js';
-import * as selectors from './selectors.js';
-import * as list_selectors from './list_selectors.js';
-
-/**
- * @summary Place-holder permettant de concaténer utilisateur et permissions dans un seul objet
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @return {Object} Prototype de la fonction contenant la concaténation des deux arguments.
- */
-// function OldUser(user, ldap_access){ //hawkspar->akka ; ceci pourrait avantageusement être une classe
-// this.anonymous = Boolean(user.anonymous),
-// this.uid = user.uid,
-// this.password = user.password,
-// this.ldap_access = ldap_access;
-// }
-
-/**
- * @summary un objet typé pour représenter la personne effectuant la requête. A ne pas confondre avec l'objet représentant un utilisateur
- */
-class QUser{
- anonymous : boolean;
- uid : string;
- constructor(auth, uid){
- this.anonymous = !auth;
- this.uid = uid;
- }
-}
-
-/**
- * @summary Authentifie un utilisateur anonyme en appelant {@link User} et {@link LDAPOpen}
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {Promise(Object)} Un objet user si l'utilisateur possède les droits indiqués,
- * null sinon
- * @rights user
- */
-export function anonymous(user){
- return new QUser(true, null);
-}
-
-/**
- * @summary Authentifie un utilisateur comme authentifié
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {Promise(Object)} Un objet user si l'utilisateur possède les droits indiqués,
- * null sinon
- * @rights user
- */
-export function loggedIn(user){ //hawkspar: WTF ? Pq garder son groupUID ?
- return new QUser(false, user.uid);
-}
-
-/**
- * @summary Authentifie un utilisateur comme viewer(groupUID)
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {null}
- * @rights user
- */
-export function viewer(user, groupUID){
- return null; // Du coup useless non ?
-}
-
-/**
- * @summary Authentifie un utilisateur anonyme en appelant {@link User} et {@link LDAPUser}
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {Promise(Object)} Un objet user si l'utilisateur possède les droits indiqués,
- * null sinon
- * @rights user
- */
-export async function member(user, groupUID){
- let group_list = await selectors.groupsWithMember(user);
- let test = await knex.with('group_list', group_list).select().from('group_list').where('uid', groupUID);
- if(test[0])
- return new User(user, new LDAPUser(user));
- return await admin(user, groupUID);
-}
-
-/**
- * @summary Authentifie un utilisateur comme viewer(groupUID) en appelant {@link admin}
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {Promise(Object)} Un objet user si l'utilisateur possède les droits indiqués,
- * null sinon
- * @rights user
- */
-export async function speaker(user, groupUID){
- return await admin(user, groupUID);
-}
-
-/**
- * @summary Authentifie un utilisateur anonyme eneffectuant une requête knex {@link list_selectors.usersWithAdminRights} et en appelant {@link User} et {@link LDAPAdmin}
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * * @return {Promise(Object)} Un objet user si l'utilisateur possède les droits indiqués,
- * null sinon
- * @rights user
- */
-export async function admin(user, groupUID){
- let adminList = await list_selectors.usersWithAdminRights(user, groupUID);
- if (typeof adminList != "undefined" && adminList.indexOf(user.uid) != -1)
- return new User(user, new LDAPAdmin(user));
-}
-
-/**
- * @summary Authentifie un utilisateur comme viewer(groupUID) Ã l'aide de {@link User} et {@link LDAPSupervisor}
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @return {Promise(uid)} L'utilisateur possède-t-il les droits de superviseur ?
- * Si oui, renvoie la justification. Sinon, renvoie false.
- * Attention : renvoie true si l'utilisateur a les droits mais sans justification.
- * @rights user
- */
-export async function superviser(user, groupUID){
- let supervised_groups = await list_selectors.supervisedGroups(user);
- console.log(supervised_groups);
- for(let i = 0; i < supervised_groups.length; i++){
- if(supervised_groups[i].uid == groupUID){
- let user_obj = new User(user, new LDAPSupervisor(user));
- user_obj.justification = (supervised_groups.justification && supervised_groups.justification[i]);
- return user_obj;
- }
- }
- return false;
-}
\ No newline at end of file
diff --git a/src/graphql/connectors/connectors.ts b/src/graphql/connectors/connectors.ts
deleted file mode 100644
index 2e2aaba74cd7b687581635cb7c36301f563a2676..0000000000000000000000000000000000000000
--- a/src/graphql/connectors/connectors.ts
+++ /dev/null
@@ -1,766 +0,0 @@
-/**
- * @file Fonctions pour interagir avec la BDD sigma et le LDAP.
- * @author akka vodol
- */
-import knex from '../../../db/knex_router';
-import * as selectors from './selectors';
-import * as list_selectors from './list_selectors';
-
-import {Group as groupLdap, groupData} from '../../ldap/export/group';
-import {User as userLdap, userData} from '../../ldap/export/user';
-import { isExportNamedDeclaration } from 'babel-types';
-import { admin } from './authentifiers';
-
-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;
- }
-}
-
-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.
-*/
-
-/**
- * @summary Génère une promise.
- * @function
- * @desc Les fonctions ici sont toutes supposées renvoyer une promise.
- * Si on veut renvoyer une valeur directement, cette fonction permet de construire
- * une Promise qui renvoie cette valeur facilement.
- * @arg {Object} val - La valeur qu'on veut renvoyer.
- * @return {Promise(Object)} Une promise qui renvoi val
- */
-const quickPromise = (val) => { //hawkspar->akka ; selon VSCode pas utilisé donc useless
- return new Promise( (resolve, reject) => {
- resolve(val);
- });
-};
-
-/**
- * @summary Renvoie le nom de la table dans laquelle il faut chercher en fonction de ce qu'on veut
- * @desc Ceci est obsolète, et devra être supprimé quand le code sera RAS
- * @arg {String} wantedType - Un string indiquant le type de groupe qu'on veut. Peut être `"simple"`, `"meta"` ou `"all"`.
- * @return {String} Le nom de la table dans laquelle la requète doit être effectuée.
- */
-function getGroupTableName(wantedType){
- switch(wantedType){
- case "simple":
- return "simple_groups";
- case "SimpleGroup":
- return "simple_groups";
- case "meta":
- return "meta_groups";
- case "MetaGroup":
- return "meta_groups";
- case "all":
- return "groups";
- default:
- throw "invalid type request : " + wantedType + "is not a valid group type";
- }
-}
-
-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 un unique groupe, ssi ce groupe est visible par l'utilisateur
- * @desc Pour l'instant, la fonction effectue la même requête que `getAllVisibleGroups`
- * et restreint au groupe demandé. Cette fonction peut être implémentée de manière
- * plus efficace et plus chiante.
- * @arg {String} gid - Identifiant du groupe voulu.
- * @arg {String} type - Type de groupe voulu. `"simple"`, `"meta"` ou `"all"`.
- * @return {Promise(group)} Retour de requête knex. Le groupe demandé, si l'utilisateur a le droit de la voire.
- * @rights user
- */
-export async function getGroupIfVisible(quser : QUser, gid, type="all") : Promise<Group>{
- let group_table_name = getGroupTableName(type);
- let visible_groups = await selectors.visibleGroups(quser);
- const res = await knex.with('visible_groups', visible_groups).select()
- .from(group_table_name).innerJoin('visible_groups', function (){
- this.on('visible_groups.uid', '=', group_table_name + '.uid');
- }).where(group_table_name + '.uid', gid);
- return res[0];
-}
-
-export const getSimpleGroupIfVisible = (user, groupUID) => getGroupIfVisible(user, groupUID, "simple");
-export const getMetaGroupIfVisible = (user, groupUID) => getGroupIfVisible(user, groupUID, "meta");
-
-/**
- * @summary Renvoie tous les groupes simples visibles par l'utilisateur user
- * @desc Cette fonction effectue une requête knex.
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {String} wantedType - Type de groupe voulu : `"simple"`, `"meta"` ou `"all"`.
- * @return {Promise} Retour de requête knex. Liste de tous les groupes que l'utilisateur a le droit de voire.
- * @rights user
- */
-export async function getAllVisibleSimpleGroups(quser : QUser) : Promise<Group[]>{
- let visible_groups = await selectors.visibleGroups(quser);
- return getSimpleGroupsFromCallbacks(quser, visible_groups);
-}
-
-/**
- * @summary Renvoie tous les meta groupes visibles par l'utilisateur user
- * @desc Cette fonction effectue une requête knex.
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {String} wantedType - Type de groupe voulu : `"simple"`, `"meta"` ou `"all"`.
- * @return {Promise} Retour de requête knex. Liste de tous les groupes que l'utilisateur a le droit de voire.
- * @rights user
- */
-export async function getAllVisibleMetaGroups(quser : QUser) : Promise<Group[]>{
- let visible_groups = await selectors.visibleGroups(quser);
- return getMetaGroupsFromCallbacks(quser, visible_groups);
-}
-
-/**
- * @summary Renvoie tous les groupes visibles par l'utilisateur user
- * @desc Cette fonction effectue une requête knex. Elle gère l'arête de parenté.
- * @arg {String} wantedType - Type de groupe voulu : `"simple"`, `"meta"` ou `"all"`.
- * @return {Promise} Retour de requête knex. Liste de tous les groupes que l'utilisateur a le droit de voire.
- * @rights user
- */
-export async function getAllVisibleGroups(quser : QUser) : Promise<Group[]>{
- let visible_groups = await selectors.visibleGroups(quser);
- return getGroupsFromCallbacks(quser, visible_groups);
-}
-
-/**
- * @summary Teste si un utilisateur est membre d'un groupe
- * @return {Promise(Boolean)} Boolean indiquant si l'utilisateur est membre du groupe.
- * @rights user
- */
-export async function isMember(quser : QUser, group : Group) : Promise<boolean>{
- let member_set = await getGroupMemberUsersSet(quser, group);
- if( member_set && member_set.has(quser.uid) ){
- return true;
- }else{
- return isSpeaker(quser, group);
- }
-}
-
-export async function isSpeaker(quser : QUser, group : Group) : Promise<boolean>{
- return isAdmin(quser, group);
-}
-
-export async function isAdmin(quser : QUser, group : Group) : Promise<boolean>{
- let admin_set = await getGroupAdminUsersSet(quser, group);
- if( admin_set && admin_set.has(quser.uid) ){
- return true;
- }else{
- return isSupervisor(quser, group);
- }
-}
-
-export async function isSupervisor(quser : QUser, group : Group) : Promise<boolean>{
- // TODO : implement
- return true;
-}
-
-/**
- * @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 rasUID = await getAvailableGID(args.uid);
-
- // TODO : appeller une fonction de LDAPUser pour y créer un groupe.
- await knex('simple_groups').insert({
- uid: rasUID,
- 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 getGroupIfVisible(quser, rasUID);
-}
-
-/**
- * @summary Créé un groupe si les arguments sont tous valides et l'utilisateur est authorisé
- * @desc Les arguments doivent être valides, sauf pour uid. Une clé uid valide sera générée dans tous les cas.
- * 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 user
- */
-export async function createGroupIfLegal(quser : QUser, group : Group, args) : Promise<Group>{
- if( await isAdmin(quser, group) ){
- return createSubgroup(quser, group, args);
- }else{
- throw "illegal request : you must have admin rights over a group to create a subgroup of that group";
- }
-}
-
-/**
- * @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
- * @arg {Object} user - L'utilisateur qui effectue la requête.
- * @arg {String} args - L'identifiant du groupe qui reçoit la requête.
- * @return {Promise(Object)} Retour de requête knex. Toutes les requêtes destinées au groupe.
- * @rights admin(recipientUID)
- */
-export async function getUserJoinGroupRequests(quser : QUser, recipient : Group) : Promise<Object>{
- 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é.
- * @arg {Object} user - L'utilisateur qui effectue la requête.
- * @arg {String} args - L'identifiant du groupe qui reçoit la requête.
- * @return {Promise(Object)} Retour de requête knex. Toutes les requêtes destinées au groupe.
- * @rights speaker(recipientUID)
- */
-export async function getGroupJoinEventRequests(quser : QUser, recipient : Group) : Promise<Object>{
- 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é.
- * @arg {Object} user - L'utilisateur qui effectue la requête.
- * @arg {String} args - L'identifiant du groupe qui reçoit la requête.
- * @return {Promise(Object)} Retour de requête knex. Toutes les requêtes destinées au groupe.
- * @rights speaker(recipientUID)
- */
-export async function getYourGroupHostEventRequests(quser : QUser, recipient : Group) : Promise<Object>{
- 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
-
-export async function getAnnouncement(user, messageID){
- let res = await knex.select().from('announcements').where('id', messageID)
- .whereIn('id', await selectors.visibleAnnouncements(user));
- if(res[0]){
- res[0].type = 'Announcement';
- return res[0];
- }
- res = await knex.select().from('events').where('id', messageID)
- .whereIn('id', await selectors.visibleEvents(user));
- if(res[0]){
- res[0].type = 'Announcement';
- return res[0];
- }
- return undefined;
-}
-
-export async function getEvent(user, messageID){
- let res = await knex.select().from('events').where('id', messageID)
- .whereIn('id', await selectors.visibleEvents(user));
- if(res[0]){
- res[0].type = 'Event';
- return res[0];
- }
- return undefined;
-}
-
-export async function getPrivatePost(user, messageID){
- let res = await knex.select().from('private_posts').where('id', messageID)
- .whereIn('id', await selectors.visiblePrivatePosts(user));
- if(res[0]){
- res[0].type = 'PrivatePost';
- return res[0];
- }
- return undefined;
-}
-
-export async function getQuestion(user, messageID){
- let res = await knex.select().from('questions').where('id', messageID)
- .whereIn('id', await selectors.visibleQuestions(user));
- if(res[0]){
- res[0].type = 'Question';
- return res[0];
- }
- return undefined;
-}
-
-export async function getAnswer(user, messageID){
- let res = await knex.select().from('answers').where('id', messageID)
- .whereIn('id', await selectors.visibleAnswers(user));
- if(res[0]){
- res[0].type = 'Answer';
- return res[0];
- }
- return undefined;
-}
-
-/**
- * @summary Renvoie un message en fonction de son identifiant.
- * @param {*} user - Utilisateur effectuant la requête.
- * @param {*} eventID - Identifiant unique de l'événement.
- * @rights super
- */
-export async function getMessage(user, messageID) : Promise<any>{
- return getEvent(user, messageID) |
- getAnnouncement(user, messageID) |
- getPrivatePost(user, messageID) |
- getQuestion(user, messageID) |
- getAnswer(user, messageID);
-}
-
-export async function allVisibleEvents(user){
- let selection = await selectors.visibleEvents(user);
- let result = await knex.select().from('events').whereIn('id', selection);
- for(let r of result){
- r.type = 'Announcement';
- }
- return result;
-}
-
-export async function allVisibleAnnouncements(user){
- let selection = await selectors.visibleAnnouncements(user);
- 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(user, groupUID){
- let received_messages = await selectors.recievedMessages(user, groupUID);
- 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(user, groupUID){
- let received_messages = await selectors.recievedMessages(user, groupUID);
- let result = await knex('questions').select().whereIn('id', received_messages);
- for(let entry of result){
- entry.type = "Question";
- }
- return result;
-}
-
-export async function receivedAnswers(user, groupUID){
- 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 getGroupsFromCallbacks(user, qb => {
- return qb.select({uid: 'group'}).from('group_message_relationships')
- .where('message', messageID).whereIn('status', ['host', 'publish']);
- });
-}
-
-export async function getMessageGroupRecipients(user, messageID){
- return getGroupsFromCallbacks(user, qb => {
- return qb.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 const getGroup = (user, groupUID) => {
- // 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',groupUID).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 const getSimpleGroup = (user, groupUID) => {
- return knex.select().from('simple_groups').where('uid',groupUID).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 const getMetaGroup = (user, groupUID) => {
- return knex.select().from('meta_groups').where('uid',groupUID).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(user, 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(user, requestID){
- await knex('your_group_host_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 acceptYourGroupHostEventRequest(user, requestID){
- 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 function takeAdminRights(user, groupUID, justification){
- return knex('taken_rights').insert({
- user_uid : user.uid,
- group_uid : groupUID,
- justification : justification
- });
-}
-
-
-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 selectors.metaGroupMembers(quser, group).then(cb => cb(knex));
- 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;
- }
-}
-
-async function getSimpleGroupsFromCallbacks (user, selection){
- return knex.with('selection', selection).select("simple_groups.*").from("simple_groups")
- .innerJoin('selection', function (){
- this.on('selection.uid', '=', 'simple_groups.uid');
- });
-}
-
-async function getMetaGroupsFromCallbacks (user, selection){
- return knex.with('selection', selection).select().from("meta_groups")
- .innerJoin('selection', function (){
- this.on('selection.uid', '=', 'meta_groups.uid');
- });
-}
-
-/**
- * @summary Renvoie tous les groupes dans l'intersection définie par les callbacks
- * @desc Cette fonction effectue une requête knex. Elle gère l'arête de parenté.
- * @arg {Object} user - Représente l'utilisateur qui a effectué la requête.
- * @arg {String} wantedType - Type de groupe voulu : `"simple"`, `"meta"` ou `"all"`.
- * @return {Promise} Retour de requête knex. Liste de tous les groupes que l'utilisateur a le droit de voire.
- * @rights user
- */
-async function getGroupsFromCallbacks(user, cbList){
- // console.log(cbList);
- let all_simple_groups = await getSimpleGroupsFromCallbacks(user, cbList);
- let all_meta_groups = await getMetaGroupsFromCallbacks(user, cbList);
- return all_simple_groups.concat(all_meta_groups);
-}
-
-/*
- * 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/list_selectors.js b/src/graphql/connectors/list_selectors.js
deleted file mode 100644
index fdabecfe8823845c8d0233b13839021719575d32..0000000000000000000000000000000000000000
--- a/src/graphql/connectors/list_selectors.js
+++ /dev/null
@@ -1,87 +0,0 @@
-import knex from '../../../db/knex_router';
-import * as selectors from './selectors';
-
-/**
- * @summary Renvoie le type d'un groupe.
- * @function
- * @desc Parcours les BDD pour savoir dans laquelle se trouve le groupe ayant l'UID donné.
- * Cette opération nécéssite un parcours de base de donnée, et il est préférable de ne pas
- * sans servir si on a un autre moyend de connaitre le typed d'un groupe
- * (Par exemple, si on dispose d'un retour de BDD pour ce groupe. Le champ 'type' indique alors son type.)
- * @arg {Object} user - Objet contenant un attribut `uid` de type `string`.
- * User représente l'utilisateur qui a effectué la requête.
- * @arg {Object} groupUID - L'id du groupe dont on veut connaître le type.
- * @return {Promise(String)} Un string représentant le type du groupe.
- * Peut être "SimpleGroup" ou "MetaGroup". Renvoie `Undefined` si le groupe n'existe pas
- * @rights super
- */
-export const getGroupType = (user, groupUID) => {
- return knex('simple_groups').select('uid').where('uid', groupUID).then( sg_res => {
- if(sg_res)
- return "SimpleGroup";
- return knex('meta_groups').select('uid').where('uid', groupUID).then(mg_res => {
- if(mg_res)
- return "MetaGroup";
- return undefined;
- });
- });
-};
-
-/**
- * @summary renvoie tous les groupes sur lesquels un utilisateur a des droits de supervision
- * @desc Cette fonction effectue des requêtes knex. Elle parcoure recursivement l'arbre de parenté,
- * Et cela aurait été trop lourd de la faire renvoyer un callback définissant une requête.
- * @arg {Object} user - Objet contenant un attribut `uid` de type `string`.
- * User représente l'utilisateur qui a effectué la requête.
- * @return {Promise(array)} Une liste des uid de tous les groupes que user supervise.
- * @rights user
- */
-export async function supervisedGroups(user){
- function difference(arr1, arr2){
- return arr1.filter( e => (arr2.indexOf(e) < 0));
- }
- async function recursive_explorer(visited_groups, start_groups){
- let child_simple_groups = await knex.select('uid').distinct().from('simple_groups')
- .whereIn('parent_uid', start_groups);
- let child_meta_groups = await knex.select('union_uid').as('uid').distinct()
- .from('meta_group_membership').where('status', 'admin')
- .whereIn('member_uid', child_simple_groups);
- let new_start_groups = difference(child_simple_groups.concat(child_meta_groups), visited_groups);
- let new_visited_groups = visited_groups.concat(new_start_groups);
- if(new_start_groups.length > 0)
- return recursive_explorer(new_visited_groups, new_start_groups);
- else
- return new_visited_groups;
-
- }
- let groups_with_admin = (await selectors.groupsWithAdmin(user))(knex);
- return recursive_explorer([], groups_with_admin);
-}
-
-/**
- * @summary Renvoie tous les utilisateurs ayant des droits d'administrateur sur un groupe.
- * @function
- * @desc Les utilisateurs qui ont un droit d'administrateur sur un groupe simple sont ses administrateurs
- * et les utilisateurs ayant droit d'admin sur son parent.
- * Les utilisateurs ayant droit d'admin sur un meta-groupe sont les utilisateurs
- * ayant droit d'admin sur un des groupes membres
- * @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 member(groupUID)
- */
-export async function usersWithAdminRights(user, groupUID){
- let group_type = await getGroupType(user, groupUID);
- if(group_type == "SimpleGroup"){
- let added_admins = await knex.select('user_uid').from('taken_rights').where('group_uid', groupUID);
- let admin_list = ["wilson.jallet", "louis.vanneau"]; // await listerAdministrateurs(user, groupUID);
- return admin_list.concat( added_admins.map( o => o.user_uid) );
- }else{
- let mg_members = await selectors.metaGroupAdminMembers(user, groupUID)(knex);
- let admin_users = [];
- while(mg_members){
- admin_users = admin_users.concat(await usersWithAdminRights(mg_members.pop()));
- }
- return admin_users;
- }
-}
diff --git a/src/graphql/connectors/selectors.js b/src/graphql/connectors/selectors.js
deleted file mode 100644
index 3458d89d53517cd58e1390660e10681c2f278e1c..0000000000000000000000000000000000000000
--- a/src/graphql/connectors/selectors.js
+++ /dev/null
@@ -1,143 +0,0 @@
-/**
- * @file Des callbacks qui sélectionnent un sous-ensemble de groupes. IN PROGRESS la doc aussi, ça se voit ^^
- * @author akka vodol
- */
-
-//hawkspar->akka grosses redondance avec le travail fait dans ldap/users.js, classe Open.
-// Pas envisageable de redoubler le LDAP sur une BDD extérieure
-
-/**
- * @summary Renvoie 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 user.ldap_access.listGroups(user.uid);
- return function (global_query_builder){
- if (typeof group_ids == "undefined")
- throw "invalid user";
- var membered_groups = qb => qb.select('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.parent_uid', '=', 'membered_groups.uid');
- }
- );
- return directly_visible_simple_groups(global_query_builder);
- };
-}
-
-export async function groupsWithMember(user){
- return null;
-}
-
-export async function groupsWithSpeaker(user){
- return function (query_builder){
- return groupsWithAdmin(user);
- };
-}
-
-export async function groupsWithAdmin(user){
- return function (query_builder){
- return ["kes"];
- };
-}
-
-
-// Give a user, get the messages linked to that user
-
-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({uid : 'group'}).from('group_message_relationships')
- .where('message', messageID).where('status', 'host');
- };
-}
-
-/**
- * @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')
- .where('meta_group_membership.union_uid', '=', metaGroupUID);
- };
-}
-
-/**
- * @summary Renvoie un callback qui génère tous les membres admin d'un meta-groupe.
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} metaGroupUID - Identifiant unique du groupe.
- * @return {Promise(callback)} a callback to build a query for the admin members of a group
- * @author akka vodol
- * @rights member(metaGroupUID)
- */
-export async function metaGroupAdminMembers(user, metaGroupUID){
- return function(query_builder){
- return query_builder.distinct().select().from('groups')
- .innerJoin('meta_group_membership', 'groups.uid', 'meta_group_membership.member_uid')
- .where('meta_group_membership.union_uid', '=', metaGroupUID)
- .where('meta_group_membership.status', '=', 'admin');
- };
-}
-
-/**
- * @summary Renvoie un callback de tous les messages reçus par le groupe
- * @param {Object} user - Utilisateur effectuant la requête.
- * @param {String} groupUID - Identifiant du groupe.
- * @return {Promise(callback)} a callback to build a query for the admin members of a group
- * @author akka vodol
- * @rights admin(groupUID)
- */
-export async function recievedMessages(user, groupUID){
- return function(qb){
- return qb.column({id : 'message'}).select().from('group_message_relationships').where('group', groupUID).where('status', 'receive');
- };
-}
-
-export async function callbackIntersection(callbackList){
- return function(query_builder){
- let cb = callbackList.pop();
- if(callbackList){
- let intersection = callbackIntersection(callbackList);
- return function(query_builder){
- return query_builder.with('callback_set', cb)
- .with('intersection', intersection)
- .select('intersection.uid').from('intersection')
- .innerJoin('callback_set', function(){
- this.on('callback_set.uid', '=', 'intersection.uid');
- });
- };
- }else{
- return cb;
- }
- };
-}
-
-export async function callbackUnion(callbackList){
- return null;
-}
\ No newline at end of file
diff --git a/src/graphql/new_connectors/authorisation.ts b/src/graphql/new_connectors/authorisation.ts
index c8b47227275ea5f0134f7c0565e59b407fc0480a..9eaccb163b954565f975ee21a9a263fd3f944e62 100644
--- a/src/graphql/new_connectors/authorisation.ts
+++ b/src/graphql/new_connectors/authorisation.ts
@@ -20,7 +20,7 @@ export type GroupSet = Set<string>;
* Levels 0 and 5 are a bit special. For levels 1 - 4, the functions are as follows
*/
-// These functions return the list of all groups that the query user (quser) has corresponding priviledge for
+// These functions return the list of all groups that the query user (quser) has corresponding privilege for
export async function forViewer(quser : QUser) : Promise<GroupSet>{
throw new Error("Not implemented");
@@ -38,7 +38,7 @@ export async function forAdmin(quser : QUser) : Promise<GroupSet>{
throw new Error("Not implemented");
}
-// These functions test if the quser has corresponding priviledges for the given group
+// These functions test if the quser has corresponding privileges for the given group
export async function isViewer(quser : QUser, gid : string) : Promise<boolean>{
let groupSet = await forViewer(quser);
diff --git a/src/graphql/new_connectors/connection.ts b/src/graphql/new_connectors/connection.ts
index ea207de1b2c27c68d7396de48c86508b72f015f6..f30eeb0da18d65c9e995ac7e2fd8ddc106f6af08 100644
--- a/src/graphql/new_connectors/connection.ts
+++ b/src/graphql/new_connectors/connection.ts
@@ -195,21 +195,19 @@ export async function getUser(uid : string){
return new User(uid);
}
-export async function searchUsers(args){
- const searchData = {
+export async function searchUsers(args: searchTOLArgs): Promise<User[]>{
+ const searchData: userData = {
givenName: args.givenName,
lastName: args.lastName,
nickname: args.nickname,
nationality: args.nationality,
- school: args.school,
promotion: args.promotion,
groups: args.groups,
- studies: args.studies,
sport: args.sport,
phone: args.phone,
mail: args.mail,
- adress: args.adress,
- ip: args.ip
+ address: args.address,
+ ips: args.ip
}
const userList = await userLdap.search(searchData);
return userList.map( (uid) => new User(uid) );
diff --git a/src/graphql/resolvers.ts b/src/graphql/resolvers.ts
index 9256a5377aa7f9501ae4a5b2d1933612c1c0b9d9..0fe71e78fec4874817658e7be3c0b3cd6ef3448d 100644
--- a/src/graphql/resolvers.ts
+++ b/src/graphql/resolvers.ts
@@ -95,11 +95,11 @@ export const resolvers = {
// user queries
- user: async function(root, args, context){
+ user: async function(root, args, context): Promise<conn.User> {
return conn.getUser(args.uid);
},
- searchTOL: (root, args, context) => {
+ searchTOL: (root, args, context): Promise<conn.User[]> => {
// TODO : filter
return conn.searchUsers(args);
},
diff --git a/src/graphql/resolvers/groups.ts b/src/graphql/resolvers/groups.ts
index c3795475507c8fc6011448878bad1412737f1519..ee23194d82393cb034fccfd9549d3d8a147be592 100644
--- a/src/graphql/resolvers/groups.ts
+++ b/src/graphql/resolvers/groups.ts
@@ -3,8 +3,8 @@
* @author ?
*/
-import * as connectors from '../connectors/connectors';
-import * as authentifiers from '../connectors/authentifiers';
+import * as conn from '../new_connectors/connection';
+import * as authentifiers from '../new_connectors/authorisation';
//hawkspar->akka ; doc ?
const GroupResolvers = {
// @rights viewer(obj.uid)
@@ -35,22 +35,22 @@ const GroupResolvers = {
},
async likers(obj, args, context) {
- return connectors.utilisateur.listMembers(context.user, obj.uid);
+ return conn.utilisateur.listMembers(context.user, obj.uid);
},
async privatePosts(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedPrivatePosts(user, obj.uid);
+ return user && conn.receivedPrivatePosts(user, obj.uid);
},
async questions(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedQuestions(user, obj.uid);
+ return user && conn.receivedQuestions(user, obj.uid);
},
async answers(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedAnswers(user, obj.uid);
+ return user && conn.receivedAnswers(user, obj.uid);
}
},
@@ -61,17 +61,17 @@ const GroupResolvers = {
async privatePosts(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedPrivatePosts(user, obj.uid);
+ return user && conn.receivedPrivatePosts(user, obj.uid);
},
async questions(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedQuestions(user, obj.uid);
+ return user && conn.receivedQuestions(user, obj.uid);
},
async answers(obj, args, context) {
let user = await authentifiers.member(context.user, obj.uid);
- return user && connectors.receivedAnswers(user, obj.uid);
+ return user && conn.receivedAnswers(user, obj.uid);
}
}
};
diff --git a/src/graphql/typeDefs/actions.graphql b/src/graphql/typeDefs/actions.graphql
index 136919d6fa02e1666af2e55bcd9b67a2bafa50fe..238677bb970b51016207d07d41091f9511d72c55 100644
--- a/src/graphql/typeDefs/actions.graphql
+++ b/src/graphql/typeDefs/actions.graphql
@@ -82,14 +82,13 @@ type Mutation {
answerEventRequest(from : String, request: ID, accept : Boolean): Request
- # Log user into the API
+ # Log user into the API, replies with a token.
login(username: String!, password: String!): String!
# Log user out of the API
logout(username: String!): Boolean
leave(from : String!) : Boolean
# Viewer mutations
-
requestJoin(from : String!) : Boolean
}
diff --git a/src/graphql/typeDefs/actions_wish_list.graphql b/src/graphql/typeDefs/actions_wish_list.graphql
index 4fc70a09f220bc25a1201df8d8e60ce49772039d..a4e77d792ae45eab6ee3382143762268b4a72147 100644
--- a/src/graphql/typeDefs/actions_wish_list.graphql
+++ b/src/graphql/typeDefs/actions_wish_list.graphql
@@ -53,13 +53,13 @@ type Query {
nationality: String,
school: String,
promotion: String,
- groups: String,
+ groups: [String],
studies: String,
sport: String,
phone: String,
mail: String,
address: String,
- ip: String
+ ip: [String]
): [User!]
}
@@ -263,4 +263,10 @@ type Mutation {
censorEvent(eventToCensor: ID!): Boolean
censorAnswer(answerToCensor: ID!): Boolean
+ # Log user into the API, replies with a token.
+ login(username: String!, password: String!): String!
+ # Log user out of the API
+ logout(username: String!): Boolean
+ leave(from : String!) : Boolean
+
}
diff --git a/src/graphql/typeDefs/queries.d.ts b/src/graphql/typeDefs/queries.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a66b57b88e349e0500ba9668821fe37f5e19d849
--- /dev/null
+++ b/src/graphql/typeDefs/queries.d.ts
@@ -0,0 +1,15 @@
+interface searchTOLArgs {
+ givenName: string,
+ lastName: string,
+ nickname: string,
+ nationality: string,
+ school: string,
+ promotion: string,
+ groups: string[],
+ studies: string,
+ sport: string,
+ phone: string,
+ mail: string,
+ address: string,
+ ip: string[]
+}
\ No newline at end of file
diff --git a/src/ldap/export/user.ts b/src/ldap/export/user.ts
index cac82805916a4a067dd7141aa3e593b6af625a83..5d9131a01d5d2c00addad8447f710c9c5cdbd19f 100644
--- a/src/ldap/export/user.ts
+++ b/src/ldap/export/user.ts
@@ -21,8 +21,8 @@ import {Group} from './group';
* TBA @var {string} nationality - Nationalité d'origine
* @var {string} promotion - Année(s) de promo
* @var {string} phone - Numéro(s) de téléphone
- * @var {string[]} adresses - Adresse(s)
- * @var {string[]} mails - Adresse(s) courriel
+ * @var {string[]} address - Adresse(s)
+ * @var {string[]} mail - Adresse(s) courriel
* @var {string[]} groups - Un ou plusieurs groupes dont l'utilisateur est membre (inclus section sportive, binet, PA...)
* @var {string} password - Mot de passe généré en amont
* @var {string[]} ips - Adresse(s) ip
@@ -35,26 +35,27 @@ import {Group} from './group';
* TBA @var {string[]} likes - Liste des gid dont l'utilisateur est sympathisant
*/
export interface userData {
- "uid": string,
- "groups": string[],
- "groupsIsAdmin": string[],
- "password"?: string,
- "givenName"?: string,
- "lastName"?: string,
- "nickname"?: string,
- "promotion"?: string,
- "photo"?: string,
- "birthdate"?: string,
- //"nationality"?: string,
- "phone"?: string,
- "adress"?: string,
- "mail"?: string,
- "ips"?: string[],
- "directory"?: string,
- "login"?: string,
- "readPerm"?: string,
- "writePerm"?: string,
- "forlifes"?: string[]
+ uid?: string,
+ groups?: string[],
+ groupsIsAdmin?: string[],
+ password?: string,
+ givenName?: string,
+ lastName?: string,
+ nickname?: string,
+ promotion?: string,
+ photo?: string,
+ birthdate?: string,
+ nationality?: string,
+ phone?: string,
+ address?: string,
+ mail?: string,
+ ips?: string[],
+ directory?: string,
+ login?: string,
+ readPerm?: string,
+ writePerm?: string,
+ forlifes?: string[],
+ sport?: string
//"likes"?: string[]
}
diff --git a/src/ldap/internal/config.ts b/src/ldap/internal/config.ts
index d1922ecca2eea3d5f4c8c3e4b92d4921908528dd..473abac4c305bf4b31612f0d56b7f6f4ce8b08cd 100644
--- a/src/ldap/internal/config.ts
+++ b/src/ldap/internal/config.ts
@@ -7,13 +7,13 @@ import fs from 'fs';
import path from 'path';
import colors from 'colors';
// Point central ; tous les champs de la BDD sont 'cachés' dans config.json et pas visibles directement
-let path_config = path.resolve(__dirname,'..','ldap_config.json');
+let path_config = path.resolve(__dirname,'..', '..','ldap_config.json');
console.log(colors.cyan("Loading LDAP config file from "+path_config));
export const ldapConfig = JSON.parse(fs.readFileSync(path_config).toString());
-let path_credentials = path.resolve(__dirname,'..','ldap_credentials.json')
+let path_credentials = path.resolve(__dirname,'..', '..','ldap_credentials.json')
console.log(colors.cyan("Loading LDAP credentials from "+path_credentials));
export const credentialsLdapConfig = JSON.parse(fs.readFileSync(path_credentials).toString());
// Override config server from environment
if (process.env.LDAP_URI != null) {
- ldapConfig.ldap.server = process.env.LDAP_URI;
+ ldapConfig.server = process.env.LDAP_URI;
}
\ No newline at end of file