topic Re: Permissions... in Alfresco Archive

Permissions...

st — Tue, 04 Mar 2008 14:37:04 GMT

Coucou! j'ai une question toute simple, rapide à répondre, mais qui m'aiderait à avancer dans ma réflexion : Dans un workflow par exemple Review and Approve, il y a deux acteurs principaux : le reviewer et le submitter du doc.quand le reviewer approve, le fichier doit se déplacer dans un autre dossi

Re: Permissions...

st — Tue, 04 Mar 2008 17:18:53 GMT

J'ai trouvé dans le forum anglophone une once de solution (qui aurait pu etre LA solution) :

http://issues.alfresco.com/browse/AR-1911 : ce lien parle d'une implémentation de "<runas>".

Cependant quand je mets ça dans mon code :

<transition name="reject" to="S Revision">
      <action class="org.alfresco.repo.workflow.jbpm.AlfrescoJavaScript">
      <runas>admin</runas>
          <script>
         <!–Find the Acceptance folder–>
         var workingFolder = companyhome.childByNamePath("Working");

etc etc ‍‍‍‍‍‍‍‍

j'obtiens l'erreur suivante :

ERROR [org.jbpm.instantiation.FieldInstantiator] couldn't parse set field 'runas' to value '<runas xmlns="urn:jbpm.org:jpdl-3.1">admin</runas>'
java.lang.NullPointerException‍‍

J'ai pourtant la version 'alfresco-community-2.1.0' le dernière dispo sur alfresco…

Quelqu'un pourrait-il me dire rapidement si possible, si c'est normal que j'obtienne cette erreur?

Auquel cas, comment faire pour disposer de cet attribut?

Merci d'avance de votre aide… J'en ai vraiment besoin :? …

Re: Permissions...

rguinot — Tue, 04 Mar 2008 17:44:58 GMT

Il semble que la balise runas ne soit dispo que dans la 2.9 et supérieures (voir fix version) comme indiqué sur l'issue JIRA que tu mentionnes.
En revanche tu peux donner des droits de contributeur sur le repertoire qui contiendra le contenu à ton reviewer mais inutile de le donner au submitter .

En gros tu peux avoir qqch de ce style :

Repertoire initial : reviewer et submitter sont coordinator ou moins
Repertoire de transition ( approval ) : submitter est contributor, reviewer coordinator par exemple
Repertoire d'approbation : submitter est guest, reviewer est contributor par exemple.

Cela répond il à ton besoin ?

Re: Permissions...

st — Tue, 04 Mar 2008 21:22:40 GMT

Merci de nouveau rguiniot pour ta réponse!

En fait non ça ne répond pas à ma problématique.

Je m'explique un peu mieux : j'ai besoin que :

- le reviewer n'aie seulement qu'à approuver ou rejeter le document que le submitter lui propose
- le reviewer n'ait aucun droit de toucher à quoique ce soit dans ces trois dossiers que tu mentionnes : ni création, ni deletion
- le répertoire initial d'ou le doc est soumis à révision soit totalement privé au submitter et que le reviewer ne le voie pas ni ne peut le consulter
- le contenu du repertoire d'approbation (qui contient tous les documents approuvés) ne puisse être touché ni par le reviewer ni par le submitter( personne a part l'admin n'a le droit de modifier son contenu)

C'est pour cela que le "runas" correspond tout à fait à mon besoin.

j'ai pu le trouver sur https://svn.alfresco.com/repos/alfresco-open-mirror/alfresco/HEAD/root/projects/repository/source/java/org/alfresco/repo/workflow/jbpm/AlfrescoJavaScript.java .
Existe-il un moyen (svn?) pour mettre à jour ma version d'alfresco community 2.1.0? (je ne comprends pas bien pourquoiil existe une version 2.9 qui n'est pas dispo directement sur le wiki??)
Si c'est par le svn qu'il faut mettre à jour (et si c'est possible aussi), y'a t-il des docs à ta connaissance qui expliquent cela? (je n'ai jamais encore fait ça, cependant je souhaite vivement apprendre, cela me parait fort intéressant!)

Merci d'avance encore à toi!

Re: Permissions...

michaelh — Tue, 04 Mar 2008 21:39:29 GMT

Hello,

La version 2.9 est pour le moment une version de développement, et pas une version utilisable. Donc il est normal qu'elle ne soit pas mise en avant particulièrement.

Tu peux essayer de suivre les indications du wiki pour recompiler entièrement Alfresco à partir des sources … ou alors récupérer une version 2.9 compilée ici. Attention par contre, c'est un "cliché" effectué chaque nuit qui comporte des portions de code non terminées, et donc :
- Il se peut qu'elle ne soit tout simplement pas fonctionnelle.
- tu risques de n'avoir de support de personne (car supporter une version de développement est souvent une perte de temps)

Autre piste : contacter l'auteur … c'est un collègue à toi

Re: Permissions...

st — Tue, 04 Mar 2008 22:10:46 GMT

Merci Michael de me répondre encore à cette heure ci!

Qui est cet auteur dont tu parles? je ne le connais pas…

De plus, n'y a t-il pas moyen de récupérer juste la partie de code dont j'ai besoin pour avoir la balise runas qui marche? :roll: C'est vraiment ce dont j'ai besoin! Prendre une version de développement serait effectivement assez risqué…

Que me conseillerais-tu de faire alors si tu étais moi?^^ :wink:

Re: Permissions...

st — Thu, 06 Mar 2008 12:41:06 GMT

J'ai une info à demander à ce propos…

J'ai récupéré la classe AlfrescoJavaScript grâce au head, avec le runas implémenté.

J'ai créé un jar avec jre1.6.0 et jre1.5.0 mais j'ai une erreur qui dit :

Caused by: java.lang.UnsupportedClassVersionError: Bad version number in .class file‍

lorsque je démarre mon workflow…

Avec quoi est compilé alfresco? Il faudrait que j'utilise le meme jre ou jdk, mais je ne sais pas comment trouver cette info. le wiki ne me donne pas la réponse.

Suivre les infos de la section "Java Code" du document : http://wiki.alfresco.com/wiki/Packaging_And_Deploying_Extensions est bien la bonne méthode n'est ce pas?

Re: Permissions...

rguinot — Thu, 06 Mar 2008 13:39:20 GMT

Habituellement il te donne un numéro de version (par exemple : 47, 48 , 49 dans ces eaux la) lorsque ce type d'erreur est généré. Cela peut te donner des indications sur la version de Java attendue.

Il faut soit compiler ton extension avec la version majeure de Java qu'Alfresco, ou bien recompiler Alfresco avec la version avec laquelle tu as compilé ton extension.
Je penche pour la première solution si cette extension n'utilise pas de nouveautés spécifiques à la 1.6.

Re: Permissions...

st — Thu, 06 Mar 2008 15:49:08 GMT

Merci!
Non je n'ai pas de numéro de version associé.

et Euhhh… Je suis vraiment désolée de ta gentillesse mais :

compiler ton extension avec la version majeure de Java qu'Alfresco

Comment je sais quelle est la version majeure d'Alfresco?
Et comment je fais ça?(j'attends pas un tutoriel, mais des grandes lignes… ) Dans ma courte vie d'informaticienne, je n'ai pas encore eu l'occasion de faire ça.. Et si ça se trouve ça en intéressera plus d'un! :wink:

PS : Je suis en train d'essayer avec les AMP, mais ta solution me parait plus facile quand même …

Merci d'avance rguinot (et non guiniot..pardon ops: lol)

Re: Permissions...

rguinot — Thu, 06 Mar 2008 16:04:56 GMT

Les 4 premiers octets sont appelés "magic number" et servent à identifier une classe valide. Je te laisse chercher sur wikipedia ou l'historique des private jokes cachées derrière ces noms.
Les 2 suivants servent à identifier le major number et le minor number.

J'ai une petite classe qui permet de déterminer automatiquement le numéro, et c'est cadeau :

import java.io.*;

public class ClassVersionChecker {
    public static void main(String[] args) throws IOException 
   {
        for (int i = 0; i < args.length; i++)
            checkClassVersion(args[i]);
    }

    private static void checkClassVersion(String filename) throws IOException
    {
        DataInputStream in = new DataInputStream
         (new FileInputStream(filename));

        int magic = in.readInt();
        if(magic != 0xcafebabe) 
        {
              System.out.println(filename + " is not a valid class!");;
        }
        int minor = in.readUnsignedShort();
        int major = in.readUnsignedShort();
        System.out.println(filename + ": " + major + " . " + minor);
        in.close();
    }
}‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Elle n'est pas de moi mais je ne sais plus ou je l'ai trouvée.
Tu peux également obtenir le même résultat avec un hexdump mais il faut parler couramment l'hexa.

Re: Permissions...

st — Thu, 06 Mar 2008 19:32:50 GMT

quel est le logiciel avec lequel on peut visualiser le bytecode d'une classe!

merci pour ces infos par ailleurs!

Re: Permissions...

rguinot — Fri, 07 Mar 2008 09:53:09 GMT

Euh….. Dans quel but ?

Follow the white rabbit and take the red pill when offered

Re: Permissions...

st — Thu, 20 Mar 2008 14:41:46 GMT

Rebonjour à tous,

J'ai essayé de régler mon problème de permissions de plusieurs manières :

j'ai tenté d'étendre la classe AlfrescoJavaScript en une classe toute simple qui permettait de faire setActorId="admin" et d'importer cette nouvelle classe dans mon workflow.
Cependant, j'ai toujours des problèmes de sécurité et ça plante.

Ensuite j'ai essayé d'aller carrément à la source de doc.move; J'ai bien trouvé ces classes (copy move etc..) cependant, je ne trouve rien qui soit en rapport avec la sécurité checking ou autre…

voilà les fichiers que j'ai trouvés :

AbstractMoveOrCopyMethod.class
DeleteMethod.class
MoveMethod.class

tous trois dans le jar : alfresco-remote-api\org\alfresco\repo\webdav

Avez vous des idées, des suggestions ou meme des solution à ce problème qu'il faut absolument que je résolve svp?

D'avance merci…

Re: Permissions...

st — Wed, 26 Mar 2008 08:51:39 GMT

Bon et bien mon problème n'a pas l'air de trop vous inspirer… Ca se conçoit! lol

Si je trouve une solution dans les prochains jours, je vous en ferai part de suite… Car ce sujet a été lu pas mal de fois et doit surement en intéresser plus d'un!

@+

Re: Permissions...

greg_shogun_852 — Thu, 27 Mar 2008 15:00:24 GMT

lol T'en fais pas Sarah…

Moi j'ai eu le même problème et je me suis retrouvé en face de plusieurs solutions:
1. Bidouiller dans le code source et me mettre du camboui jusque par dessus les coudes
tout juste pour bricoler un truc à la 6/4/2.
2. Attendre la prochaine version pour pouvoir utiliser les sacro-saintes balises runas.
3. Créer une stratégie de groupes et de paths la plus efficace possible afin de pouvoir se
passer des balises runas.

J'ai choisi la 3e solution et crois moi c'est presque transparent.
En fait j'ai créé un espace de réception de documents dans chaque espace de service.
Tous le monde à accès à cet espace…

Est-ce que tu as la possibilité de faire un truc de ce style? Si oui ça t'éviterai de te prendre
la tête.

Re: Permissions...

st — Fri, 28 Mar 2008 11:20:20 GMT

Merci pour ta réponse mon Nami alfresco!

euh, un espace publique à tous n'est pas très concevable en fait. Mais ça dépend ce que tu veux dire par là!

En fait j'ai créé un espace de réception de documents dans chaque espace de service.

Que veux tu dire par là? Je ne comprends pas bien ou tu veux en venir. Peut etre illustrer par un exemple serait le mieux.

Merci greg en tous les cas!

😃

Re: Permissions...

greg_shogun_852 — Fri, 04 Apr 2008 06:47:05 GMT

Salut Saralfresca,

<Service informatique> <Service comptabilite> <Service secretaria> <…>

<Boite reception workflows>

<DupondR> <…>

Chef du service => Coordinateur
Membres du service => Collaborateur
Autres (Différent d'invité) => Contributeur

http://forum.alfresco-fr.org/viewtopic.php?f=11&t=1500&p=6928&hilit=stranger#p6928

PS: Pour la demande en mariage non je ne l'ai pas encore faite. (Private joke :wink: )

Re: Permissions...

huberd — Fri, 11 Apr 2008 11:03:38 GMT

En ce qui me concerne, je ne sais pas si cela répondra à ton besoin, mon Workflow excecute des class Java qui utilisent un compte qui a les droits d'effectuer des copies et modifications sur les propriétés des documents soumis à validation. La classe Java créé est la suivante :

package lpr.alfresco.repo.workflow.jbpm;

import java.util.List;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;
import org.alfresco.jcr.api.JCRNodeRef;
import org.alfresco.model.ContentModel;
import org.alfresco.repo.jscript.ScriptNode;
import org.alfresco.repo.security.authority.AuthorityDAO;
import org.alfresco.repo.workflow.jbpm.AlfrescoJavaScript;
import org.alfresco.repo.workflow.jbpm.JBPMNode; 
import org.alfresco.repo.workflow.jbpm.JBPMSpringActionHandler; 
import org.alfresco.service.ServiceRegistry;
import org.alfresco.service.cmr.repository.ChildAssociationRef;
import org.alfresco.service.cmr.repository.NodeRef; 
import org.alfresco.service.cmr.repository.NodeService; 
import org.alfresco.service.cmr.security.AccessPermission;
import org.alfresco.service.cmr.security.OwnableService;
import org.alfresco.service.cmr.security.PermissionService;
import org.alfresco.service.cmr.workflow.WorkflowException;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.apache.log4j.Logger; 
import org.dom4j.Element;
import org.jbpm.graph.exe.ExecutionContext; 
import org.springframework.beans.factory.BeanFactory; 

//
//Required to change Workflow permission on web-client-config-workflow-actions.xml in WEB-INF\classes\alfresco like this
//
//<action id="start_workflow">
// <permissions>
//    <permission allow="true">Write</permission>
// </permissions>
// …
//
//and add workflow user as adminUsers in WEB-INF\classes\alfresco\authority-services-context.xml

public class SetPermissions extends JBPMSpringActionHandler { 

   private static final long serialVersionUID = 5L;

   private static final Logger logger = Logger.getLogger(SetPermissions.class); 
       
   private BeanFactory factory;
   private ServiceRegistry services;   
   private NodeService nodeService;
   private NamespaceService namespaceService;
   private AuthorityDAO authorityDAO;
   private PermissionService permissionService;
   private OwnableService ownableService; 
             
   // Property names
   public static final QName PROP_SAVE_OWNER = QName.createQName("lpr.model","SaveOwner");
   public static final String WORKFLOW_USER = "workflow";
   public static final String WORKFLOW_PASSWORD = "password";
      
   // Patameters
   private Element actor;
   private String permission;
   private String pooledactors;
         
   @Override 
   protected void initialiseHandler(BeanFactory factory) { 
      this.factory = factory; 
      services = (ServiceRegistry)this.factory.getBean(ServiceRegistry.SERVICE_REGISTRY);
      authorityDAO = (AuthorityDAO)this.factory.getBean("authorityDAO");
      nodeService = (NodeService)this.factory.getBean("nodeService");
      namespaceService = (NamespaceService)this.factory.getBean("namespaceService");
      permissionService = (PermissionService)this.factory.getBean("permissionService");
      ownableService = (OwnableService)this.factory.getBean("ownableService");
   } 

   public void execute(ExecutionContext executionContext) throws Exception {
      System.out.println("Set Permissions…");
      if (actor == null && pooledactors == null && (permission.equals("set")       || permission.equals("unset") || 
                                                 (permission.equals("setEditor") || permission.equals("unsetEditor")))) { 
         throw new WorkflowException("actor has not been provided"); 
      }
      if (permission == null) { 
         throw new WorkflowException("permission has not been provided"); 
      } 
      
      // Get the Actor ID
      String assignedActor = null;
        if (actor != null)
        {
            String actorValStr = actor.getTextTrim();
            if (actorValStr != null && actorValStr.length() > 0)
            {
                if (actorValStr.startsWith("#{"))
                {
                    String expression = actorValStr.substring(2, actorValStr.length() -1);
                    Object eval = AlfrescoJavaScript.executeScript(executionContext, services, expression, null);
                    if (eval == null) {
                       throw new WorkflowException("actor expression '" + actorValStr + "' evaluates to null");
                    }

                    String actor = null;
                    if (eval instanceof String) {
                       actor = (String)eval;
                    }
                    else if (eval instanceof JBPMNode) {
                           actor = mapAuthorityToName((JBPMNode)eval, false);
                        }
                    if (actor == null) {
                        throw new WorkflowException("actor expression must evaluate to a person");
                    }
                    assignedActor = actor;
                }
                else {
                   assignedActor = actorValStr;
                }
            }
        }
        
        if (pooledactors != null) {
           assignedActor = pooledactors; 
        }
   
      try { 
         Object res = executionContext.getContextInstance().getVariable("bpm_package");
         if(res == null) { 
            //never enters here 
            logger.fatal("bpm_package is null"); 
            return; 
         } 

         final NodeRef nodeRef = ((JBPMNode) res).getNodeRef();     
         if(nodeRef == null) { 
            //never enters here 
            logger.fatal("NodeRef is null"); 
            return; 
         }
             
         String DocPath = null;
         
         List<ChildAssociationRef> childRefs = nodeService.getChildAssocs(nodeRef);
         for (ChildAssociationRef tchildRef : childRefs) {
            final NodeRef childRef = tchildRef.getChildRef();
                DocPath = nodeService.getPath(childRef).toPrefixString(namespaceService);
         }
             
         Repository repository = (Repository)this.factory.getBean("JCR.Repository"); 
         Session session = null;
         try { 
            // Think to add workflow as administrator on the "authority-service-contxt.xml" file on "class\alfresco"
            session = repository.login(new SimpleCredentials(WORKFLOW_USER,WORKFLOW_PASSWORD.toCharArray()));

            // access the page via JCR
            Node rootNode = session.getRootNode();
            Node curentNodeRef = rootNode.getNode(DocPath);
                                                             
            // Convert the JCR Node to an Alfresco Node Reference
            NodeRef AdminNodeRef = JCRNodeRef.getNodeRef(curentNodeRef);
            
            // Change permission
            if (permission.equals("remove")) {
               removePermissions(AdminNodeRef);   
               } else if (permission.equals("restore")) {
                        restorePermissions(AdminNodeRef);
                      }  else if (permission.equals("set")) {
                               // Add CONSUMER permission for the current workflow actor
                                permissionService.setPermission(AdminNodeRef, assignedActor,PermissionService.CONSUMER,true);
                             } else if (permission.equals("unset")) {
                                      // Remove CONSUMER permission for the current workflow actor
                                    permissionService.deletePermission(AdminNodeRef, assignedActor, PermissionService.CONSUMER);       
                                   } else if (permission.equals("setEditor")) {
                                             // Add EDIOTOR permission for the current workflow actor
                                              permissionService.setPermission(AdminNodeRef, assignedActor,PermissionService.EDITOR,true);   
                                          } else if (permission.equals("unsetEditor")) {
                                                   // Remove EDITOR permission for the current workflow actor
                                                    permissionService.deletePermission(AdminNodeRef, assignedActor,PermissionService.EDITOR);   
                                                 } else {
                                                          throw new WorkflowException("permission has not been provided");   
                                                   }
            session.save();
            
               // Debug only      
            /*Collection<AccessPermission> permissions  = permissionService.getAllSetPermissions(AdminNodeRef);
            Iterator iterator = permissions.iterator();
            while (iterator.hasNext()) {
               Object element = iterator.next();
               System.out.println("——> Permissions(Result): " + element);            
            } */         
            
            // Debug Node only
            //System.out.println("Node Path: " + nodeService.getPath(nodeRef));
            /*Collection<AccessPermission> nodepermissions  = permissionService.getAllSetPermissions(nodeRef);
            Iterator nodeiterator = nodepermissions.iterator();
            while (nodeiterator.hasNext()) {
               Object nodeelement = nodeiterator.next();
               System.out.println("——> Permissions(Result): " + nodeelement);            
            } */         
         }
            
         finally { 
            session.save();
            session.logout();
         } 

      } catch (Exception e) { 
         e.printStackTrace(); 
        }
   } 
   
    private String mapAuthorityToName(ScriptNode authority, boolean allowGroup) { 
        String name = null; 
        QName type = authority.getType(); 
        if (type.equals(ContentModel.TYPE_PERSON)) { 
            name = (String)authority.getProperties().get(ContentModel.PROP_USERNAME); 
        } else  if (type.equals(ContentModel.TYPE_AUTHORITY)) { 
            name = authorityDAO.getAuthorityName(authority.getNodeRef()); 
        } else  if (allowGroup && type.equals(ContentModel.TYPE_AUTHORITY_CONTAINER)) { 
            name = authorityDAO.getAuthorityName(authority.getNodeRef()); 
        } 
        return name; 
    }    
    
    private void removePermissions(NodeRef nodeRef) {
       //System.out.println("**************** remove Permissions ****************");
       // Disabled all Permissions
      Set<AccessPermission> Permissions = permissionService.getAllSetPermissions(nodeRef);
      for (AccessPermission permission : Permissions){
         String authority = permission.getAuthority();
         String Permission = permission.getPermission();
         /*AccessStatus status = permission.getAccessStatus();
         System.out.println("——> Permissions(Name / Permission / Status): " + 
                                 authority + " / " + 
                                 Permission + " / " +
                                 status);*/
         permissionService.setPermission(nodeRef,authority,Permission,false);
      }
      
      // Save current Owner and Take Ownership
      String owner = ownableService.getOwner(nodeRef);
      nodeService.setProperty(nodeRef,PROP_SAVE_OWNER,owner);
      //System.out.println("Owner : " + owner);
      //session.save();
      ownableService.takeOwnership(nodeRef);
      
      // Add CONSUMER permission for old Owner
      permissionService.setPermission(nodeRef, owner,PermissionService.CONSUMER,true);   
    }
    
    private void restorePermissions(NodeRef nodeRef) {
       //System.out.println("**************** restore Permissions ****************");
      // Get saved Owner and set the document with this one
      String saveOwner = (String)nodeService.getProperty(nodeRef, PROP_SAVE_OWNER);
      ownableService.setOwner(nodeRef, saveOwner);
      //System.out.println("Save Owner : " + saveOwner);

      // Remove CONSUMER permission for the saved Owner 
      permissionService.deletePermission(nodeRef, saveOwner, PermissionService.CONSUMER);

      // Enabled all Permissions
      Set<AccessPermission> Permissions = permissionService.getAllSetPermissions(nodeRef);
      for (AccessPermission permission : Permissions){
         String authority = permission.getAuthority();
         String Permission = permission.getPermission();
         /*AccessStatus status = permission.getAccessStatus();
         System.out.println("——> Permissions(Name / Permission / Status): " + 
                           authority + " / " + 
                           Permission + " / " +
                           status);*/
         permissionService.setPermission(nodeRef,authority,Permission,true);
      }
   }
}‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Cette classe s'utilise dans le workflow de la manière suivante :

         <!– Set read permission for the initiator –>
         <action class="lpr.alfresco.repo.workflow.jbpm.SetPermissions">
         <actor>#{initiator}</actor>
            <permission>set</permission>
         </action>  ‍‍‍‍‍

Les paramètres utilisables sont :
* actor : acteur du workflow
* pooledactors : groupe d'acteurs du Workflow
* permission avec pour valeurs

set

unset

setEditor

unsetEditor

remove

restore

En espérant que celà réponde à ta question, où que cela te donne une idée.

Et si quelqu'un à également une idée d'amélioration ou de substitution, je suis également preneur.