Wikini

DiscussionsGroupesDUtilisateurs

PagePrincipale :: DerniersChangements :: DerniersCommentaires :: ParametresUtilisateur :: Vous êtes ec2-54-91-121-255.compute-1.amazonaws.com
Premier jet à compléter

L'absence de notion de groupe d'utilisateurs pose problème dans WikiNi. Les groupes permettraient idéalement de gérer des listes de personnes à des fins :

Il faut déjà s'entendre sur les processus fonctionnels :


Proposition I










Plus de questions que de réponses pour l'instant.
-- CharlesNepote avec la complicité de LordFarquaad



Solutions techniques



[22:14:36] *** wikini
[22:14:36] *** This room supports the MUC protocol.
[22:14:36] *** ChN has become available
[22:15:52] *** LordFarquaad has become available
[22:16:03] <LordFarquaad> hello[22:16:08] <ChN> 'lut
[22:16:16] <LordFarquaad> re lol
[22:16:26] *** ProgFou has become available
[22:16:33] <ChN> j'ai créé une salle pour qu'éventuellement ProgFou nous rejoigne
[22:16:37] <ProgFou> 'lut
[22:16:39] <ChN> le voilu !


[22:16:51] <ChN> [22:11:16] <lordfarquaad@jabber.org> je suis en train de regarder pour les ACLgroup
[22:11:21] <lordfarquaad@jabber.org> ça me parait aussi être pas mal :-)
[22:11:57] <lordfarquaad@jabber.org> je teste pour une application pratique, mais je modifie le code pour faire quelque chose de plus optimal
[22:13:35] <charles.nepote> En fait je pense qu'on peut faire ça assez simplement :
-- chaque utilisateur appartient au groupe qui porte son nom et dont il est l'unique membre + d'autres groupes
-- tous les tests sont effectués sur les groupes et non sur les utilisateurs
[22:13:57] <lordfarquaad@jabber.org> quite like phpBB2 :-)

[22:15:09] <lordfarquaad@jabber.org> j'imagine que tu préfère ne pas créer le table wikini_groups
[22:18:34] <ChN> LF : non  je ne suis pas complètement contre une table wikini_groups et je ne vois pas bien comment faire autrement
[22:21:31] <ChN> Pour faire sur simple sur le sujet de la table : WikiNi est un moteur léger et pas fait pour des milliers d'utilisateurs ; donc la colonne supplémentaire ne doit pas prendre beaucoup de place, non

[22:17:58] <ChN> Les groupes me paraissent vraiment un incontournable pour WikiNi
[22:18:12] <ProgFou> bah oui, c'est l'un des premiers trucs que j'ai mis en place
[22:18:26] <ProgFou> histoire d'avoir plusieurs admin fonctionnels


[22:18:55] <ChN> PF : et tu as utilisé la solution décrite sur le site ?
[22:18:58] <ProgFou> moi j'ai choisi une solution d'implementation a la "modif minimale"
[22:19:12] <ProgFou> donc pas de table en plus mais uniquement une colonne en plus[22:19:51] <ProgFou> mais c'est une reflexion que j'avais mene rapidement et pas pour prevoir le long terme
[22:20:07] <ProgFou> si ca vous interesse je vous explique mon implementation[22:20:21] <ChN> oui
[22:20:59] <ProgFou> 1. ajout d'une colonne groups text NOT NULL a la table wikini_users
[22:22:10] <ProgFou> 2. ajout d'une fonction LoadGroups a wakka.php
// load the groups the user is in or all groups if no user specified
function LoadGroups($user="") { $groups = Array(); $query = "SELECT DISTINCT groups FROM ".$this->config["table_prefix"]."users"; if ($user) $query .= " WHERE name='".mysql_escape_string($user)."'"; $result = $this->LoadAll($query);foreach ($result as $r) foreach (explode(",", $r["groups"]) as $group) if ($group) $groups[$group]++; return array_keys($groups); }
[22:23:28] <ProgFou> 3. ajout d'une fonction UserIsInGroup dns wakka.php
// returns true if logged in user is in the given group
function UserIsInGroup($group) {            // check if user is logged in
               if (!$user = $this->GetUser()) return false;

               // check if user is in the given group
               foreach (explode(",", $user["groups"]) as $g)
               {
                       if ($g == $group) return true;
               }
               return false;
       }
[22:24:10] <ProgFou> ensuite la gestion des droits y fait appel ; exemple avec la fonction UserIsAdmin :
function UserIsAdmin() { return $this->UserIsInGroup("admin"); }
[22:25:39] <ProgFou> pour resumer le principe de fonctionnement : une colonne "groups" dans la table "users" contient la liste des groupes dans lequel l'utilisateur se trouve, separes par des ","
[22:26:44] <ProgFou> la raison pour laquelle j'avais choisi d'associer ca a l'utilisateur etait d'une part l'implementation minimale et d'autre part la consideration du fait qu'un acces est lie a une session qui concerne un utilisateur unique
[22:27:59] <ProgFou> (fini)
[22:28:23] <ProgFou> (je detaille pas maintenant sur tout ce que j'ai fait ensuite qui utilise cela)


[22:28:40] <ChN> ok
a. j'aurrai fait UserIsInGroup($user, $group) pour plus de souplesse
b. je ne vois pas l'intérêt de UserIsAdmin
[22:28:51] <LordFarquaad> idem pour b
[22:29:01] <LordFarquaad> pour a aussi au fond
[22:29:05] <ProgFou> je l'appelle partout ou il y a un UserIsOwner
[22:29:34] <ProgFou> typiquement les acces actuels selon UserIsOwner sont remplaces par UserIsOwner || UserIsAdmin
[22:29:36] <ChN> ?
[22:29:46] <ProgFou> c'est juste pour la clarte du code ensuite, c'est pas necessaire
[22:29:47] <LordFarquaad> ok
[22:29:49] <ChN> ah ok


[22:30:00] <LordFarquaad> mais ça fait du groupe admin un groupe vraiment particulier
[22:30:17] <ProgFou> chez moi c'est le groupe des admins fonctionnels, oui
[22:30:56] <ProgFou> pour le a., pourquoi pas, mais dans la pratique j'en ai jamais eu besoin
[22:31:21] <LordFarquaad> je me demande s'il ne serait pas préférable d'utiliser un système où l'on pourrait configurer ça aussi de façon plus fine
[22:31:22] <ProgFou> car on a surtout besoin de verifier les droits par rapport a l'utilisateur qui accede
[22:31:32] <ChN> dans la méthode IsAllowedFor($action, $group) que j'envisage, il n'y a pas d'admin ; des gens peuvent être par exemple admin de la purge sans être admin de la création d'utilisateurs
[22:31:35] <LordFarquaad> par exemple on pourrait envisager un groupe de "modérateurs" qui ne s'occupent que des commentaires
[22:31:45] <LordFarquaad> voilà :-)
[22:31:48] <ChN> oui
[22:32:17] <ChN> un peu comme les groupes Unix mais sans compte root
[22:32:25] <ProgFou> ok, donc dans ce cas - gestion fine des droits - mon implementation ne suffit pas
[22:32:48] <ProgFou> moi j'avais plus besoin d'un "groupe de root"
[22:33:11] <ChN> oui parce que tu es en intranet (j'ai les même pbs)
[22:33:12] <ProgFou> j'ai quelques autres groupes a cotes, mais juste pour limiter les acces a quelques pages
[22:34:07] <ChN> Je pense que sur internet par exemple, on peut vouloir donner des droits progressivement car on ne connait pas bien ses interlocuteurs


[22:34:26] <ProgFou> dans le cas des IsAllowedFor, a-t'on vraiment besoin d'une table de groupes ?
[22:35:09] <LordFarquaad> je pense qu'il est préférable d'avoir une table séparée pour les groupes


[22:35:25] <ProgFou> j'imagine plutot ca avec des trigrammes ("IsAllowedFor",action,user)
[22:35:38] <ChN> ?
[22:35:53] <ProgFou> et des trigrammes ("Group","admin","ChN,DaD,...")
[22:35:53] <ChN> Des triplets ?
[22:36:07] <ProgFou> %s/trigrammes/triplets/g oui
[22:36:31] <ProgFou> (j'ai du mal avec le vocabulaire la : il est 4h30 du matin ici ;))
[22:36:58] <ChN> aïeaïe
[22:37:01] <LordFarquaad> lol
[22:37:28] <ProgFou> tant qu'a creer une table, autant que ce soit celle des meta-infos fourre-tout
[22:38:15] <ChN> (c'est un peu ce que je proposais mais LF est un peu réticent ; mais je le comprends)
[22:38:31] <LordFarquaad> l'avantage d'une table séparée est de permettre des requêtes plus complexe travaillant sur plusieurs tables simultanément, ça devient plus difficile quand on travaille avec des valeurs séparées par des virgules, et encore plus difficile si la table en question mélange différents types de données...
[22:38:44] <ChN> Je pense qu'il faut faire des propositions sur le wiki et voir pro/con à tête reposée


[22:39:17] <ProgFou> je suis bien d'accord pour les requetes
[22:39:41] <ProgFou> la table de meta-info serait la pour la generalisation maximale, pas pour l'optimisation des traitements
[22:40:06] <ProgFou> difficile de combiner les deux...
[22:40:09] <LordFarquaad> pour moi les triplets c'est bien pour des données assez spécifiques, mais qu'à partir du moment où on a (potentiellement) beaucoup de données du mêmes types, il vaut mieux les séparer
[22:41:09] <LordFarquaad> (ce qui permet aussi d'ailleurs d'optimiser la table en fonction du type de champs qu'elles contient: chaines, entiers etc.)
[22:41:32] <ProgFou> en relisant les premieres lignes, l'idee de ChN de ne plus tester que sur les groupes me plait assez...
[22:41:49] <LordFarquaad> ouep moi aussi, ça me parait plus simple
[22:41:52] <ChN> bin c'est comme sous Unix non ?
[22:42:00] <LordFarquaad> mais comment dire que chaque utilisateur a un groupe qui porte son nom ?
[22:42:06] <ProgFou> ChN : ca depend des Unix ;)
[22:42:28] <ChN> Il faut l'enregistrer automatiquement à la création de l'utilisateur
[22:42:32] <ProgFou> LF: on le dit pas : on l'implemente de facon transparente
[22:42:36] <ChN> ah bon?
[22:42:37] <LordFarquaad> par ailleurs: si un petit malin décide de créer un compte qui porte le même nom qu'un groupe, keskispas ?
[22:43:06] <ProgFou> LF: il faudra le refuser, comme si l'utilisateur correspondant existait
[22:43:20] <ChN> Et bien il ne peut pas parce que le nom est déjà pris...
[22:43:23] <ProgFou> le groupe devenant la cle
[22:43:35] <ChN> oui
[22:43:43] <LordFarquaad> ok
[22:44:01] <LordFarquaad> par contre ça crée aussi un nombre considérable de données répétées
[22:44:12] <ChN> PF : tous les unix ne fonctionnent pas comme ça ?
[22:44:40] <ProgFou> non : Red Hat met ca en place ainsi, mais pas franchement tous les autres
[22:44:47] <ChN> LF : oui ce qui milite pour la table à part, je te vois venir avec tes gros sabots
[22:44:47] <ProgFou> et c'est un choix d'administration
[22:45:14] <ChN> Sous Debian aussi, non ?
[22:45:40] <ProgFou> ca depend quel outil tu utilises pour creer tes comptes (useradd ou adduser ou interf. graphique)
[22:45:49] <ChN> Quand je créé le compte charles j'ai un groupe charles automatiquement créé : c'est pareil pour tous les unix non ?
[22:45:57] <ProgFou> avec useradd tous les comptes vont dans le groupe users par defaut
[22:46:09] <ChN> ah ok
[22:46:24] <ProgFou> non, c'est justement ca qui n'est pas generalise a tous les Unix
[22:46:40] <ProgFou> c'est un choix d'administration (plutot bon) mais ce n'est pas generalise a l'heure actuelle
[22:47:26] <ChN> ah ok
[22:48:49] <ProgFou> bon, faudrait trouver des cas de besoin de requete complexe avec les groupes...
[22:49:46] <ChN> bon moi je veux bien créer un table mais il faut rédiger là : comme il est tard pour PF, je veux bien faire le copier/coller de ses propositions sur le wiki  ; LF tu t'occupe de rédiger la partie avec une table
[22:49:58] <ChN> ?
[22:50:54] <ProgFou> un appel a IsAllowedFor($action,$user) (en fait $group) ne ferait finalement qu'une seule requette sur une table de meta-info
[22:51:28] <ProgFou> car on a pas besoin de savoir le contenu du groupe pour verifier le droit d'acces
[22:52:57] <ProgFou> par contre l'utilisateur pouvant etre dans plusieurs groupes... la il faudrait une requete avec des OR sur le troisieme champ... ou bien faire une requette rapprochant deux tables (les droits et les groupes)
[22:53:05] <LordFarquaad> des cas de requête complexe ? mmm... bah par exemple tester en un coup tous les acc!ès d'un utilisateur à une page
[22:53:13] <ChN> Moi j'aime aussi bien ça : je répette que WikiNi est un petit moteur de Wiki et pas un poids lourd : il va y avoir 10 groupes avec 50 utilisateurs dans les groupes à tout casser
[22:53:41] <ProgFou> euh... si tu as 50 users tu as forcement au moins 50 groupes ;)
[22:54:04] <ProgFou> mais je comprends bien ce que tu veux dire
[22:54:15] <LordFarquaad> tu ne crois pas qu'on peut envisager que dans l'avenir il y ait des utilisations de wikini à plus grande échelle ? :s
[22:54:27] <ChN> ok, mais 50 lignes dans une table MySQL c'est de la pisse de rat
[22:54:53] <ProgFou> (attention, la pisse de rat c'est parfois mortel, d'experience au VN... ;))
[22:55:01] <ChN> lol
[22:55:24] <ProgFou> bon, imaginons le cas propose par LF
[22:55:52] <ProgFou> tous les acces du user courant a la page demande
[22:56:00] <LordFarquaad> il y a déjà la proposition dans ACLgroup qui fonctionne avec une table séparée
[22:56:33] <ProgFou> j'essaye d'abord de l'envisager avec des meta-infos
[22:56:34] <ChN> Non, je ne vois pas WikiNi à grande échelle. Et s'il l'est un jour, le matériel aurra comblé ces problèmes... dans l'industrie on apprend notamment qu'il y a bien d'autres moyen de gérer les perfs que d'optimiser ; le matériel est si peu cher...
[22:57:23] <ChN> et évolue tellement vite
[22:57:34] <LordFarquaad> les logiciels open-souce sont encore moins cher 8-)
[22:57:57] <ProgFou> attention : open-source <> libre <> gratuit
[22:58:22] <ProgFou> (<> voulant dire different)
[22:59:24] <LordFarquaad> euh... oui mais bon, wikini est disponible gratuitement...
enfin pour moi l'optimisation a de l'importance
[22:59:39] <ProgFou> c'est marrant, mais en reflechissant a la requette de LF, je retombe sur le fait qu'il est plus interessant de stoquer les groupes auquel un user appartient plutot que la liste des utilisateurs d'un groupe... ;)
[23:00:11] <LordFarquaad> il ne faudrait pas que certains utilisateurs ne puissent utiiliser wikini parce que leur hébergeur mnque de puissance :s
[23:00:33] <ProgFou> j'aimerais bien avoir un exemple ou on a besoin d'avoir la liste des membres d'un groupe (pour autre chose que la gestion des groupes elle-meme)
[23:01:10] <ProgFou> LF: s'ils ont besoin de plus de 50 groupes, ils ont probablement besoin d'un gros hebegeur aussi
[23:02:43] <LordFarquaad> ce que je n'aime pas dans l'utilisation d'une seule table, dans les triplets ou même d'un champ supplémentaire dans la table des utilisateurs, c'est qu'il y a d'office une information qui se répète: le nom du groupe (pour chaque membre)... le seul moyen de contourner est une table pour les groupes et une table pour les utilisateurs... ça n'a vraiment d'intérêt qu'à grande échelle
[23:03:53] <LordFarquaad> à petite échelle la solution avec le champ supplémentaire n'est pas mauvaise, sauf que travailler sur des valeurs séparées par des virgules dans des requêtes mysql c'est compliqué (je crois qu'il n'y a pas le choix: cela implique regexp...)
[23:04:13] <ProgFou> niveau repetition il y a bien pire que ca dans wikini, ne serait-ce que le corps entier des pages d'une revision a l'autre... un nom de groupe d'environ 10 car. en moyenne c'est vraiment negligeable
[23:05:09] <ProgFou> pour les valeurs separees par des virgules, encore une fois, je n'ai jamais eu besoin d'autre chose que le chargement de la liste des groupes du user courant
[23:05:53] <ProgFou> donc la aussi, je veux bien des exemples de cas ou on a besoin de faire des requetes de recherche sur le champ groups (autre que la gestion des groupes qui sera une tache non repetitive)
[23:06:02] <ChN> LF : je te comprends sur tes réticences mais le purisme en matière de bdd n'a d'intérêt que pour les TRES gros volumes
[23:07:09] <LordFarquaad> j'aime bien de prévoir les choses à grande échelle :-)
[23:07:27] <LordFarquaad> même quand on sait qu'actuellement l'échelle est petite...
[23:08:08] <ChN> On pourra toujours changer d'ici là...
[23:08:09] <ProgFou> pour ma part je deduis de toute cette discussion qu'il nous faut d'abord determiner une information essentielle : a quoi vont servir les groupes ; si c'est que pour la gestion des droits, il me semble que les meta-infos ou la colonne de plus suffisent
[23:09:44] <LordFarquaad> (l'avantage de prévoir large est que cela pourrait attirer plus de monde, plus de contributeurs et donc augmenter l'intérêt du public pour le projet, ainsi que sa vitesse de discussions, améliorations, développement...)
[23:10:03] <LordFarquaad> je pense que les groupes vont servir principalement à deux choses: les droits des pages et les droits des modules
[23:10:06] <ChN> Pour moi les groupes servent :
-- à la gestion des droits d'accès aux **pages** (lecture, écriture, commentaire)
-- à la gestion des droits d'accès aux **actions** et **handler**
[23:10:12] <LordFarquaad> :-)
[23:10:17] <ChN> lol
[23:10:39] <LordFarquaad> mais je pense que cela pourrait aussi servir simplement en tant que groupe: un simple ensemble de personnes
[23:10:51] <ChN> Intérêt ?
[23:10:53] <ProgFou> dans tous les cas on parle des droits de **l'utilisateur courant**
[23:11:10] <LordFarquaad> par exemple "les personnes à contacter en cas de problème avec ceci", "les personnes qui travaillent sur le projet x" etc.
[23:11:39] <ChN> (hmmmm des triplets tout ça ;)))


[23:12:27] <LordFarquaad> ça donne quoi comme genre de triplets ça ?
[23:12:46] <ChN> Si WikiNi doit devenir un annuaire ouvert à des tas de propriétés, autant utiliser des triplets avec des vocabulaires qui existent déjà (FOAF par exemple)
[23:14:22] <ChN> Exemple en N3 ==> :CharlesNepote foafJabberID "charles.nepote@jabber.org"
[23:16:04] <ChN> Il devient alors très facile de lister les gens qui ont un identifiant jabber
[23:16:27] <ChN> Autre exemple de propriété : http://xmlns.com/foaf/0.1/#term_currentProject
[23:17:48] <ChN> D'ailleurs FOAF prévoit les groupes : http://xmlns.com/foaf/0.1/#term_Group
[23:17:56] <ProgFou> :CharlesNepote wikiniGroups "admin,manage_comment,manage_groups,..."
:CharlesNepote develGroups "WikiNi,projetX,..."
[23:18:36] <ProgFou> on pourrait meme charger toutes les meta-infos associees a un user un une seule requette
[23:19:42] <ProgFou> par contre je me suis tjs pose la question du triplet ou du quadruplet... je pense qu'il manque la notion de contexte/namespace...
[23:20:10] <ChN> Ce qui permet d'envisager par exemple des wikis qui se partagent les droits d'un utilisateur sur plusieurs wikis
[23:20:33] <ProgFou> par exemple je prefixerait bien avec un namespace http://www.wikini.net/wikiniUsers
[23:20:57] <ChN> La notion de contexte est contenu dans chaque item (sujet, propriété ou valeur)
[23:21:30] <ProgFou> ok, mais faudra bien definir le vocabulaire
[23:22:18] <LordFarquaad> n'est-ce pas plus simple pour un utilisateur novice de comprendre de quadruplets (avec contexte) plutôt que des triplets ?
[23:22:36] <ChN> Par exemple, la notation la plus explicite pour cela est Ntriples :
<http://wikini.net/CharlesNepote> <http://wikini.net/vocabulaire/AppartientA> <http://wikini.net/Groups/GroupeX>
[23:23:03] <ProgFou> ok
[23:23:16] <ProgFou> LF: l'utilisateur ne devrait rien voir de tout cela
[23:23:29] <LordFarquaad> oui enfin plutôt le développeur novice
[23:23:47] <ChN> <http://wikini.net/CharlesNepote> <http://xmlns.com/foaf/0.1/#term_jabberID> "charles.nepote@jabber.org"
[23:23:56] <ProgFou> LF: il ne devrait voir que des interfaces web de recherche/affichage/modification des meta-infos
[23:24:27] <ProgFou> le developpeur lui **doit** lire les docs de developpement, qui devront donc expliquer tout cela ;)
[23:24:29] <LordFarquaad> ok, tant qu'il ne veut pas bidouiller
[23:24:51] <ChN> PF : Exact : c'est ce qui est proposé à un bas niveau par RAP : http://www.wiwiss.fu-berlin.de/suhl/bizer/rdfapi/tutorial/db_utils.htm
[23:25:16] <LordFarquaad> on va supposer que tout développeur lit bien comme il se doit la docummentation avant de s'y mettre alors :-)
[23:25:37] <ChN> RAP manipule du RDF et propose une espèce de phpMyAdmin pour RDF
[23:25:51] <ChN> (cf. les copies d'écran)
[23:26:33] <ChN> Un dév est bien obligé de connaitre le modèle de données avant de programmer non ?
[23:26:40] <ProgFou> (j'ai pas pu m'empecher d'essayer de cliquer dessus... grrrr... ;))
[23:27:03] <ProgFou> (sur les copies d'ecran je veux dire... ;))
[23:27:06] <ChN> (ça s'installe en 2 minutes)
[23:27:12] <ChN> oui
[23:27:14] <LordFarquaad> (lol il me semble que moi aussi :d)
[23:29:01] <ChN> Bon, il faut synthétiser ça sur le wiki
[23:32:33] <ChN> L'avantage des triplets aussi c'est que tu peux faire évoluer simplement ton modèle en créant des équivalence avec le vocabulaire OWL : http://www.w3.org/TR/2004/REC-owl-features-20040210/#s3.2
[23:33:06] <ChN> Des modèles différents peuvent ainsi aussi se parler si besoin.
[23:35:12] <ChN> Exemple : dans mon wiki je crée une classe des gens qui bosse sur le projet XY : projectGroupXY ; la boite de PF nous rejoint mais elle a créé de son côté un nom différent : pas de problème on résoud ça par http://www.w3.org/TR/owl-guide/#owl_equivalentClass
[23:38:39] <LordFarquaad> dans le cas présent tout le monde devrait gérer ses groupes de la même façon puisque c'est nous qui définirons cela pour wikini :s
[23:40:52] <ChN> Les prorpiétés permettant de gérer groupes (classes) oui mais les noms de groupes (classes) non
[23:41:55] <ChN> Par ailleurs d'autres produits peuvent gérer des propriétés traitant de groupes que nous pourrions vouloir reprendre grâce à OWL
[23:42:38] <LordFarquaad> oui mais ça c'est pareil pour les utilisateurs par exemple[23:43:03] <ChN> ?
[23:43:05] <LordFarquaad> je n'ai pas bien compris ton message juste avant "Les propriétés..."
[23:44:11] <LordFarquaad> ben pour bien faire les utilisateurs devraient aussi être décrits par des triplets pour être replris par owl
[23:47:30] <ChN> Avec RDF (donc des triplets), si tu créés une classe d'objet (exemple la classe des gens qui bossent sur le projet XY) et bien tu peux désigner une classe équivalente grâce à une propriété du vocabulaire OWL (qui est un des vocabulaires de base du web sémantique)
[23:48:51] <ChN> Une requête sur cette classe prendra aussi en compte l'autre classe grâce aux processeurs OWL qui commencent à fleurir ou que tu peux implémenter toi-même
[00:29:39] <LordFarquaad> il n'est tout de même pas beau le HasAccess actuel :s
[00:34:39] <ChN> oui
[00:42:59] <LordFarquaad> je me demande s'il y a vraiment un intérêt à ne faire les tests que sur les groupes, quel avantage y vois-tu ?
[00:45:16] <ChN> à ne pas faire de test sur les utilisateurs ; ça simplifie le dév.
[00:46:06] <LordFarquaad> mais on a déjà le test sur les utilisateurs en fait, la technique du @ me paraît pas mal pour les groupes
[00:49:50] <ChN> J'ai plus trop les idées claire là... je vais bientôt aller me coucher...
[00:52:33] <LordFarquaad> oki
[00:53:16] <ChN> On fait les synthèses sur le wiki a+
[00:53:23] <LordFarquaad> ok bye


Question sur ACLGroup

La version actuelle de ACLGroup est-elle compatible avec la version 0.4.2 ? car actuellement on a des problèmes pour la mettre en ligne sur un Wiki. Sinon y-a-t-il quelque chose de déjà opérationnel pour gérer les groupes --JeanMichelCornu

Il n'y a pas de commentaire sur cette page. [Afficher commentaires/formulaire]