cancel
Showing results for 
Search instead for 
Did you mean: 

Permissions...

st
Champ in-the-making
Champ in-the-making
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 dossier.

y'a -til moyen donc de changer les droits directement dans le javascript pour permettre au reviewer de déplacer le fichier(c'est à dire les droits de deletion et d'écriture…), ou doit -on obligatoirement passer par alfresco et ajouter des droits contributor ou autres aux personnes? (ce qui serait embetant en fait car les dossiers ou les docs st déplacés, seraient en fait créés directement dans le workflow…)

Suis-je assez claire pour une fois dans l'expression de mon besoin?

j'espère que quelqu'un pourra me soulager vite de cette question!

Merci 😃
17 REPLIES 17

st
Champ in-the-making
Champ in-the-making
quel est le logiciel avec lequel on peut visualiser le bytecode d'une classe!

merci pour ces infos par ailleurs!Smiley Happy

rguinot
Confirmed Champ
Confirmed Champ
Euh….. Dans quel but ?

Follow the white rabbit and take the red pill when offered Smiley Happy

st
Champ in-the-making
Champ in-the-making
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…

st
Champ in-the-making
Champ in-the-making
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!

@+

greg_shogun_852
Champ in-the-making
Champ in-the-making
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.

st
Champ in-the-making
Champ in-the-making
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!

😃

greg_shogun_852
Champ in-the-making
Champ in-the-making
Salut Saralfresca,
    Désolé, j'ai pas vu que tu avais répondu…

    Voilà un exemple:

    Dans l'espace des users j'ai créé un espace propre à chaque service:

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

    Et dans chaque espace j'ai créé un sous-espace:

    <Boite reception workflows>
    et aussi les espaces user <DupondR> <…>

    Sur le sous-espace de réception j'ai distribué les rôles de la manière suivante:

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



    De cette façon tout le monde y trouve son compte.

    Si toi tu veux mettre en place un chemin de validation entre 2 personnes et que ça doit rester
    confidentiel tu peux associer cette stratégie de path en restreignant les droits d'accès à l'espace
    de réception.
    (Voir ici: http://forum.alfresco-fr.org/viewtopic.php?f=11&t=1500&p=6928&hilit=stranger#p6928
    où rguinot m'avait donné la solution)

    J'espère que j'ai répondu à ta question.
PS: Pour la demande en mariage non je ne l'ai pas encore faite. (Private joke  :wink: )

huberd
Champ in-the-making
Champ in-the-making
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 : pour donner ou retirer des droits de lecture a l'acteur ou groupe d'acteurs
    - setEditor, unsetEditor : pour donner ou retirer des droits d'édition a l'acteur ou le groupe d'acteurs
    - remove : supprime tous les droits sur le document par desactivation
    - restore : réactive les droits d'origines sur le document par réactivation
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.