Skip to content
Snippets Groups Projects
Commit 9d13e505 authored by Wilson JALLET's avatar Wilson JALLET :money_with_wings:
Browse files

Corrections diverses.

parent 45bf67a7
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/graphql/connectors/authentifiers.js
+ 9
− 9
View file @ 9d13e505
......@@ -7,8 +7,8 @@ import knex from '../../../db/knex_router';
import * as connectors from './connectors.js';
import * as selectors from './selectors';
import * as list_selectors from './list_selectors';
import { utilisateurAnonyme, utilisateurConnecte,
administrateurConnecte, superAdministrateurConnecte
import { UtilisateurAnonyme, UtilisateurConnecte,
AdministrateurConnecte, SuperAdministrateurConnecte
} from '../../ldap/ldap_data';
......@@ -25,8 +25,8 @@ function user_object(user, ldap_access){
* @return {Promise(Boolean)} L'utilisateur possède-t-il les droits indiqués ici ?
* @rights user
*/
export async function anonymous(user){
return new user_object(user, new utilisateurAnonyme());
export function anonymous(user){
return new user_object(user, new UtilisateurAnonyme());
}
/**
......@@ -35,8 +35,8 @@ export async function anonymous(user){
* @return {Promise(Boolean)} L'utilisateur possède-t-il les droits indiqués ici ?
* @rights user
*/
export async function loggedIn(user, groupUID){
return new user_object(user, new utilisateurConnecte(user));
export function loggedIn(user, groupUID){
return new user_object(user, new UtilisateurConnecte(user));
}
/**
......@@ -45,7 +45,7 @@ export async function loggedIn(user, groupUID){
* @return {Promise(Boolean)} L'utilisateur possède-t-il les droits indiqués ici ?
* @rights user
*/
export async function viewer(user, groupUID){
export function viewer(user, groupUID){
return null;
}
......@@ -59,7 +59,7 @@ 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_object(user, new utilisateurConnecte(user));
return new user_object(user, new UtilisateurConnecte(user));
return admin(user, groupUID);
}
......@@ -69,7 +69,7 @@ export async function member(user, groupUID){
* @return {Promise(Boolean)} L'utilisateur possède-t-il les droits indiqués ici ?
* @rights user
*/
export async function speaker(user, groupUID){
export function speaker(user, groupUID){
return admin(user, groupUID);
}
......
src/graphql/connectors/connectors.js
+ 11
− 5
View file @ 9d13e505
......@@ -10,8 +10,14 @@ import ldap from '../../ldap/ldap_data';
// dn et mot de passe du bind user du LDAP
import ldap_bind_user from '../../../ldap_connexion_config.json';
const utilisateur = ldap.UtilisateurAnonyme();
utilisateur.repliquerTOLdesIds();
const utilisateur = new ldap.UtilisateurAnonyme();
let result = utilisateur.listMembers("br").then(res => {
console.log("Got it");
return res;
});
export { utilisateur };
/*
Le tag @rights est la gestion des autorisations.
......@@ -23,7 +29,7 @@ utilisateur.repliquerTOLdesIds();
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 inclu dans les niveaus supérieur.
ce qu'il a le droit de savoir et de faire. Chaque niveau est inclus dans les niveaus supérieur.
Les différends 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.
......@@ -328,7 +334,7 @@ export const getUser = (user, userUID) => {
};
};
const result = utilisateur.renseignerSurUtilisateur(user, userUID).then(res => {
const result = utilisateur.getUser(user, userUID).then(res => {
console.log(res[0]);
return refactorer(res[0]);
});
......@@ -531,7 +537,7 @@ export async function getGroupMemberUsers(user, GroupUID){
let type = await list_selectors.getGroupType(user, GroupUID);
switch( type ){
case "SimpleGroup":
return user.ldap_access.listerMembres(GroupUID);
return utilisateur.listMembers(GroupUID);
// return ["anatole.romon"];
case "MetaGroup":
return getMetaGroupMemberUsers(user, GroupUID);
......
src/graphql/resolvers.js
+ 2
− 3
View file @ 9d13e505
......@@ -7,10 +7,9 @@ import _ from 'lodash';
import { assertBinaryExpression } from 'babel-types';
import knex from '../../db/knex_router';
import * as connectors from './connectors/connectors.js';
import * as connectors from './connectors/connectors';
import * as list_selectors from './connectors/list_selectors';
import * as authenthifiers from './connectors/authentifiers';
import { connect } from 'http2';
/**
* @description Résolveurs des différentes requêtes GraphQL
......@@ -246,7 +245,7 @@ export const resolvers = {
// @rights viewer(obj.uid)
SimpleGroup: {
members: (obj, args, context) => {
return connectors.listerMembres(context.user,obj.uid);
return connectors.utilisateur.listMembers(context.user,obj.uid);
}
},
......
src/ldap/ldap_data.js
+ 90
− 91
View file @ 9d13e505
......@@ -59,22 +59,23 @@ function connecterLDAP(bind_user) { client.bind(bind_user.dn, bind_user.passwd,
function rechercherLDAP(base, attributes, filter="(objectClass=*)") {
return new Promise((resolve, reject) => {
let vals=[];
// Interrogation LDAP selon configuration fournie en argument
// Interrogation LDAP selon la configuration fournie en argument
client.search(base, {
"scope": "sub",
"filter": filter,
"attributes": attributes
}, function(err, res) {
},
function(err, res) {
// Gestion erreur
if (err) {
reject(err);
} else {
// Dès que la recherche renvoit une entrée, on stocke les attributs qui nous intéresse
// Dès que la recherche renvoie une entrée, on stocke les attributs qui nous intéressent
res.on('searchEntry', function(entry) {
// Cas un seul attribut où le résultat est une liste directement
if (!Array.isArray(attributes)) { vals.push(entry.object[attributes]); }
else if (attributes.length == 1) { vals.push(entry.object[attributes[0]]); }
// Cas plusieurs attributs donc résultat dictionnaire
// Plusieurs attributs: le résultat est un dictionnaire
else {
vals.push({});
attributes.forEach((attribute) => {
......@@ -82,7 +83,7 @@ function rechercherLDAP(base, attributes, filter="(objectClass=*)") {
});
}
});
// Si la recherche est finie on se déconnecte et on renvoit la liste
// Si la recherche est finie on se déconnecte et on renvoie la liste
res.on('end', function(res) { resolve(vals); });
}
});
......@@ -261,48 +262,6 @@ function repliquerTOL(data) {
});
}
//------------------------------------------------------------------------------------------------------------------------
// Fonctions intermédiaires TBT
//------------------------------------------------------------------------------------------------------------------------
/**
* @summary Cette fonction teste si un utilisateur est membre d'un groupe.
* @desc Au passage on appelle {@link ajouterMembreGroupe} au cas où il ne soit pas membre.
* @param {string} uid - Identifiant de l'utilisateur à tester
* @param {string} gid - Identification du groupe à
* @param {Object} utilisateur - Objet utilisateur à passer
* @returns {Promise(boolean)} True si l'utilisateur est membre
*/
function etreMembreGroupe(uid, gid) {
return new Promise((resolve, reject) => {
UtilisateurAnonyme.listerGroupes(uid).then(lg => {
UtilisateurAnonyme.listerMembres(gid).then(lm => {
if (lg.includes(gid) | lm.includes(uid)) {
resolve(true);
}
});
});
});
}
/**
* @summary Cette fonction teste si un utilisateur est admin d'un groupe.
* @desc Au passage on appelle {@link ajouterAdministrateurGroupe} au cas où il ne soit pas membre.
* @param {string} uid - Identifiant de l'utilisateur à tester
* @param {string} gid - Identification du groupe à tester
* @param {Object} utilisateur - Objet utilisateur pour l'authentification.
* @returns {Promise(boolean)} True si l'utilisateur est administrateur
*/
function etreAdministrateurGroupe(user, uid, gid) {
return new Promise((resolve, reject) => {
user.listerAdministrateurs(gid).then(la => {
if (la.includes(uid)) {
resolve(true);
}
});
});
}
/**
* @summary Cette fonction teste une valeur d'un attribut (typiquement un identifiant) et le fait évoluer jusqu'à ce qu'il soit unique.
* @desc Librement adapté de Stack Overflow. Appelle {@link rechercherLDAP} pour vérifier
......@@ -395,10 +354,50 @@ class UtilisateurAnonyme {
//------------------------------------------------------------------------------------------------------------------------
// Fonctions de lecture
//------------------------------------------------------------------------------------------------------------------------
constructor() {
//------------------------------------------------------------------------------------------------------------------------
// Fonctions intermédiaires TBT
//------------------------------------------------------------------------------------------------------------------------
/**
* @summary Cette fonction teste si un utilisateur est membre d'un groupe.
* @desc Au passage on appelle {@link ajouterMembreGroupe} au cas où il ne soit pas membre.
* @param {string} uid - Identifiant de l'utilisateur à tester
* @param {string} gid - Identification du groupe à
* @param {Object} utilisateur - Objet utilisateur à passer
* @returns {Promise(boolean)} True si l'utilisateur est membre
*/
isGroupMember(uid, gid) {
return new Promise((resolve, reject) => {
this.listGroups(uid).then(lg => {
this.listMembers(gid).then(lm => {
if (lg.includes(gid) | lm.includes(uid)) {
resolve(true);
}
});
});
});
}
/**
* @summary Cette fonction teste si un utilisateur est admin d'un groupe.
* @desc Au passage on appelle {@link ajouterAdministrateurGroupe} au cas où il ne soit pas membre.
* @param {string} uid - Identifiant de l'utilisateur à tester
* @param {string} gid - Identification du groupe à tester
* @param {Object} utilisateur - Objet utilisateur pour l'authentification.
* @returns {Promise(boolean)} True si l'utilisateur est administrateur
*/
isGroupAdmin(user, uid, gid) {
return new Promise((resolve, reject) => {
this.listAdmins(gid).then(la => {
if (la.includes(uid)) {
resolve(true);
}
});
});
}
/**
* @summary Fonction qui retrouve les groupes dont un individu est membre.
* @desc Cette fonction utilise {@link rechercherLDAP} va directement à la feuille de l'utilisateur et n'a donc pas de filtre. Elle utilise ldapEscape pour éviter
......@@ -406,22 +405,24 @@ class UtilisateurAnonyme {
* @arg {string} uid - Identifiant de l'individu à interroger (le plus souvent prenom.nom, parfois l'année, supposé valide)
* @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
listerGroupes(uid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(config.key_id+"=${id},"+config.dn_users, {id : uid}), config.user.groups).then(res => resolve(res[0]));
});
listGroups(uid) {
let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_users, { id: uid });
console.log(filtered_request);
return rechercherLDAP(filtered_request, config.user.groups)
.then(res => res[0]);
}
/**
* @summary Fonction qui retrouve la liste des membres d'un groupe.
* @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Elle utilise LDAPEscape pour éviter les injections.
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
* @arg {string} uid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
* @return {Promise(String[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
listerMembres(gid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(config.key_id+"=${id},"+config.dn_users, {id : gid}), config.group.member).then(res => resolve(res[0]));
});
listMembers(uid) {
let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_groups, { id: uid });
console.log(filtered_request);
return rechercherLDAP(filtered_request, config.group.member)
.then(res => res);
}
/**
......@@ -430,7 +431,7 @@ class UtilisateurAnonyme {
* @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
* @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
listerAdministrateurs(gid) {
listAdmins(gid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(
config.key_id+"=${id},"+config.dn_users, {id : gid}), config.group.admin).then(res => resolve(res[0])
......@@ -445,7 +446,7 @@ class UtilisateurAnonyme {
* @return {Promise(Object[])} Informations recueillies ; renvoie une liste de dictionnaire avec le profil complet de l'utilisateur ;
* voir `ldap_config.json`(..\..\ldap_config.json) pour les clés exactes.
*/
renseignerSurUtilisateur(uid) {
getUser(uid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(config.key_id+"=${id},"+config.dn_users, {id : uid}), config.user.profil).then(res => resolve(res));
});
......@@ -456,12 +457,12 @@ class UtilisateurAnonyme {
* @desc Cette fonction utilise {@link rechercherLDAP} avec des attributs prédéfinis. Elle utilise LDAPEscape pour éviter les injections.
* @arg {string} gid - Identifiant du groupe
* @return {Promise(Object[])} Informations recueillies ; renvoie une liste de dictionnaire avec le profil complet du groupe ;
* voir `ldap_config.json`(..\..\ldap_config.json) pour les clés exactes.
* voir `ldap_config.json`(../../ldap_config.json) pour les clés exactes.
*/
renseignerSurGroupe(gid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(config.key_id+"=${id},"+config.dn_groups, {id : gid}), config.group.profil).then(res => resolve(res));
});
getGroup(gid) {
let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_groups, { id: gid });
console.log(filtered_request);
return rechercherLDAP(filtered_request, config.group.profil).then(res => res);
}
//------------------------------------------------------------------------------------------------------------------------
......@@ -533,7 +534,7 @@ class UtilisateurConnecte extends UtilisateurAnonyme {
* @arg {string[]} data[admins] - Liste des admins du groupe ; supposée être une sous-liste de la précédente
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
creerGroupe(user, data) {
createGroup(user, data) {
return new Promise((resolve, reject) => {
// Calcul d'un dictionnaire d'ajout
let vals = {};
......@@ -614,7 +615,7 @@ class UtilisateurConnecte extends UtilisateurAnonyme {
editerUtilisateur(user, uid, data) {
return new Promise((resolve, reject) => {
// Récupération des anciennes données
this.renseignerSurUtilisateur(user, uid).then(profil => {
this.getUser(user, uid).then(profil => {
// Reecriture de profil avec les bons champs
Object.keys(profil).forEach(keyLDAP => {
Object.keys(config.user).forEach(keyAlias => {
......@@ -623,10 +624,10 @@ class UtilisateurConnecte extends UtilisateurAnonyme {
});
});
// Régénération du champ manquant dans profil
this.listerGroupes(user, uid).then(lg => {
this.listGroups(user, uid).then(lg => {
profil['groupsIsAdmin']=[];
lg.forEach(gid =>{
etreAdministrateurGroupe(this, uid, gid).then(res =>{
this.isGroupAdmin(this, uid, gid).then(res =>{
if (res) { profil['groupsIsAdmin'].push(gid); }
}).then(res => {
// Surcharge des champs à modifier selon data
......@@ -676,7 +677,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
ajouterMembreGroupe(user, uid, gid) {
return new Promise((resolve, reject) => {
// Vérifie que l'utilisateur est pas déjà membre pour groupes
this.listerMembres(user,gid).then(lm => {
this.listMembers(user,gid).then(lm => {
if (!lm.includes(uid)) {
let vals = {};
vals[config.groups.member] = uid;
......@@ -686,7 +687,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
});
}
// Vérifie que l'utilisateur est pas déjà membre pour users
}).then(res => this.listerGroupes(user,uid)).then( lg => {
}).then(res => this.listGroups(user,uid)).then( lg => {
if (!lg.includes(gid)) {
let vals2 = {};
vals2[config.users.groups] = gid;
......@@ -708,10 +709,10 @@ class AdministrateurConnecte extends UtilisateurConnecte {
* @arg {string} gid - Identifiant du groupe
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
supprimerMembreGroupe(user, uid, gid) {
removeGroupMember(user, uid, gid) {
return new Promise((resolve, reject) => {
// Vérifie que l'utilisateur est pas déjà viré pour groupes
this.listerMembres(user,gid).then(lm => {
this.listMembers(user,gid).then(lm => {
if (lm.includes(uid)) {
// Supprime tous les utilisateurs
modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "del", config.group.member).then(res => {
......@@ -721,7 +722,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
});
});
}
}).then(res => this.listerGroupes(user,uid)).then(lg => {
}).then(res => this.listGroups(user,uid)).then(lg => {
// Vérifie que l'utilisateur est pas déjà viré pour users
if (lg.includes(gid)) {
// Supprime tous les groupes
......@@ -750,7 +751,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
return new Promise((resolve, reject) => {
// ajouter
this.ajouterMembreGroupe(user,uid,gid).then(res => {
this.listerAdministrateurs(user,gid).includes(uid).then(la => {
this.listAdmins(user,gid).includes(uid).then(la => {
if (!la.includes(uid)) {
// Finalement modification, uniquement dans groups
let vals = {};
......@@ -777,9 +778,9 @@ class AdministrateurConnecte extends UtilisateurConnecte {
supprimerAdministrateurGroupe(user, uid, gid) {
return new Promise((resolve, reject) => {
// Peut paraître absurde mais permet de s'assurer que le membre est bien présent et que ses champs sont comme il faut
this.supprimerMembreGroupe(user, uid, gid).then( res => { this.ajouterMembreGroupe(user,uid,gid); });
this.removeGroupMember(user, uid, gid).then( res => { this.ajouterMembreGroupe(user,uid,gid); });
// Vérifie que l'utilisateur est bien admins (comme dans supprimerMembreGroupe)
this.listerAdministrateurs(user,gid).then(la => {
this.listAdmins(user,gid).then(la => {
if (la.includes(uid)) {
// Supprime tous les administrateurs
modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "del", config.group.admin).then(res => {
......@@ -805,10 +806,10 @@ class AdministrateurConnecte extends UtilisateurConnecte {
* @arg {Object} data - Dictionnaire des informations utilisateurs au même format que pour {@link creerGroupe} avec tous les champs optionnels.
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
editerGroupe(user, gid, data) {
editGroup(user, gid, data) {
return new Promise((resolve, reject) => {
// Récupération des anciennes données
this.renseignerSurGroupe(user, gid).then(profil => {
this.getGroup(user, gid).then(profil => {
// Reecriture de profil avec les bons champs
Object.keys(profil).forEach(keyLDAP => {
Object.keys(config.group).forEach(keyAlias => {
......@@ -821,8 +822,8 @@ class AdministrateurConnecte extends UtilisateurConnecte {
profil[key]=data[key];
});
// Modification propre
this.supprimerGroupe(user, gid).then(r => {
this.creerGroupe(user, profil).then(res => { if (!res) { reject(false); }});
this.deleteGroup(user, gid).then(r => {
this.createGroup(user, profil).then(res => { if (!res) { reject(false); }});
}).then(res => { resolve(true); });
});
});
......@@ -840,13 +841,13 @@ class AdministrateurConnecte extends UtilisateurConnecte {
* @arg {string} gid - gid de la victime
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
*/
supprimerGroupe(user, gid) {
deleteGroup(user, gid) {
return new Promise(function(resolve, reject) {
// Gestion des membres et administrateurs d'abord
this.renseignerSurGroupe(user, gid).then(profil => {
this.getGroup(user, gid).then(profil => {
// Ordre important
profil[config.group['admin']].forEach(id => { this.supprimerAdministrateurGroupe(user, id, gid); });
profil[config.group['member']].forEach(id => { this.supprimerMembreGroupe(user, id, gid); });
profil[config.group['admin']].forEach(id => { this.removeGroupAdmin(user, id, gid); });
profil[config.group['member']].forEach(id => { this.removeGroupMember(user, id, gid); });
// Elimination
}).then(res => {
supprimerLDAP(user, config.key_id+"="+gid+","+config.dn_groups);
......@@ -987,11 +988,11 @@ class SuperAdministrateurConnecte extends AdministrateurConnecte {
supprimerUtilisateur(user, uid) {
return new Promise((resolve, reject) => {
// Gestion des groupes d'abord
this.renseignerSurUtilisateur(user, uid).then(profil => {
this.getUser(user, uid).then(profil => {
profil[config.user['groups']].forEach(gid => {
etreAdministrateurGroupe(user, uid, gid).then(res => {
this.isGroupAdmin(user, uid, gid).then(res => {
if (this.la.includes(res)) { this.supprimerAdministrateurGroupe(user, uid, gid); }
}).then(res => { this.supprimerMembreGroupe(user, uid, gid); });
}).then(res => { this.removeGroupMember(user, uid, gid); });
});
// Elimination
}).then(res => { supprimerLDAP(user, config.key_id+"="+uid+","+config.dn_users); });
......@@ -1010,7 +1011,5 @@ module.exports = {
UtilisateurAnonyme,
UtilisateurConnecte,
AdministrateurConnecte,
SuperAdministrateurConnecte,
etreAdministrateurGroupe,
etreMembreGroupe
SuperAdministrateurConnecte
};
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment