Code gérant les permissions et règles

dranakan — Wed, 01 Sep 2010 08:20:01 GMT

Hello,J'ai créé du code java permettant de créer des répertoires, effacer des permissions et règles ainsi que d'ajouter des permissions et règles.Cela fonctionne parfaitement pour créer une structure ou pour modifier un petit nombre de répertoire, mais cela se complique quand le code travaille sur u

Re: Code gérant les permissions et règles

dranakan — Tue, 07 Sep 2010 08:38:27 GMT

Si ça peut donner des idées sur la cause… voici des exemple de code :

Création des répertoires, applications règle et permissions:


/**
    * Perpare space for user in the directory Processing. This folder allow
    * file to be "Treatable" for the ERP. The permissions and rules are
    * re-setted if the space if yet created. Create a space user and apply
    * rules and permissions (reapply rules and permissions if yet created. Does
    * not delete directories) :
    * <ul>
    * <li>(noderef)</li>
    * <li>>>responsible</li>
    * <li>>>>>firm_1</li>
    * <li>>>>>>>>>invoiceCreditor …</li>
    * </ul>
    * 
    * @param user
    *            Name of the user (login)
    * @param directory
    *            The directory when the space will be create (Processing)
    * @param firms
    *            List of firms
    * @return
    */
   public boolean prepareUserInProcessing_RS_F_T(String user,
         NodeRef directory, int[] firms) {
      try {
         if (user == null || user.length() == 0) {
            logger.error("Try to create the user space but the user name is empty/null");
            return false;
         }

         logger.debug("Prepare space for : "
               + user
               + " in : "
               + nodeManager.getNameAndPathOfNodeRef(directory)
               + " (create directories, delete and add rules, delete and add permissions only on type directories.");

         /* User */
         // Create space user
         logger.debug("Prepare space for user : " + user);
         NodeRef userNodeRef = nodeManager.createDirectoryIfNotExist(user,
               directory);
         // Clear and Set rules
         nodeManager.ruleService.removeAllRules(userNodeRef);
         DefineRules
               .addRule_DefineReponsible(nodeManager, userNodeRef, user);
         

         /* Trash */
         logger.debug("Prepare space for trash : " + PATH_TRASH);
         // Add trash
         NodeRef trashNodeRef = nodeManager.createDirectoryIfNotExist(
               PATH_TRASH, userNodeRef);
         // Clear and Set rules
         nodeManager.ruleService.removeAllRules(trashNodeRef);
         DefineRules.addRule_OrganizeFileInDirectory_Simple(nodeManager,
               trashNodeRef);
         
         // Set rule (for user)
         DefineRules.addRule_MoveToTrash(nodeManager, userNodeRef, trashNodeRef);

         /* Firm and types */
         for (int firm : firms) {
            logger.debug("Prepare space for firm : " + firm);
            // Create space firm
            NodeRef firmNodeRef = nodeManager.createDirectoryIfNotExist(
                  PATH_FIRM_BEGIN_DIRECTORY_NAME + firm, userNodeRef);
            // Clear and Set rules
            nodeManager.ruleService.removeAllRules(firmNodeRef);
            DefineRules
                  .addRule_DefineFirmNb(nodeManager, firmNodeRef, firm);

            /* Add types */
            for (QName typeQName : LIST_DOCS_USED_PRODUCTION_QNAME) {

               logger.debug("Prepare space for type : "
                     + typeQName.getLocalName());

               // Create space type
               NodeRef typeNodeRef = nodeManager
                     .createDirectoryIfNotExist(
                           typeQName.getLocalName(), firmNodeRef);
               // Clear and Set rules
               nodeManager.ruleService.removeAllRules(typeNodeRef);
               DefineRules.addRule_SpecializedType(nodeManager,
                     typeNodeRef, typeQName);
               // Rule (search BVR)
               if (typeQName.equals(QNAME_SGF_INVOICE_CREDITOR)) {
                  DefineRules.addRule_ExtractAndApplyMetadata(
                        nodeManager, typeNodeRef);
               }
               // Clear and Set permission
               nodeManager.permissionService
                     .deletePermissions(typeNodeRef);
               nodeManager.permissionService.setPermission(typeNodeRef,
                     user, PermissionService.COORDINATOR, true);
            }
         }
         logger.debug("End");
         return true;

      } catch (Exception e) {
         logger.error("", e);
         return false;
      }
   }
}

‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Création répertoire (class NodeManager (perso)):


   /**
    * Create a directory if not exist
    * 
    * @param directory
    * @param parentNodeRef
    * @return (new) nodeRef
    */
   public NodeRef createDirectoryIfNotExist(String directory,
         NodeRef parentNodeRef) {

      NodeRef nodeOnDisk = nodeService.getChildByName(parentNodeRef,
            ContentModel.ASSOC_CONTAINS, directory);
      if (nodeOnDisk != null) {
         return nodeOnDisk;
      }
      FileInfo info = this.fileFolderService.create(parentNodeRef, directory,
            ContentModel.TYPE_FOLDER);
      return info.getNodeRef();
   }
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Ajout d'une règle:


   /**
    * Move the document in the trash
    * 
    * @param nodeManager
    *            .actionService
    * @param nodeManager
    *            .ruleService
    * @param nodeRef
    *            The directory where the action is enable
    * @param destination
    *            Where the noderef will move
    */
   public static void addRule_MoveToTrash(NodeManager nodeManager,
         NodeRef nodeRef, NodeRef destNodeRef) {
      try {
         Rule rule = new Rule();
         rule.setTitle(RULE_TITLE_MOVE_TO_TRASH);
         rule.setDescription(RULE_DESC_MOVE_TO_TRASH);
         rule.applyToChildren(true);
         rule.setExecuteAsynchronously(false);
         rule.setRuleDisabled(false);
         rule.setRuleType(RuleType.UPDATE);
         CompositeAction compositeAction = nodeManager.actionService
               .createCompositeAction();
         rule.setAction(compositeAction);

         // Conditions for the Rule (has aspect deletable)
         Map<String, Serializable> actionMap = new HashMap<String, Serializable>();
         actionMap.put(HasAspectEvaluator.PARAM_ASPECT,
               Document.QNAME_SG_DELETABLE);
         compositeAction.addActionCondition(nodeManager.actionService
               .createActionCondition(HasAspectEvaluator.NAME, actionMap));

         // Action
         Action action = nodeManager.actionService
               .createAction(MoveActionExecuter.NAME);
         compositeAction.addAction(action);

         // Parameters for the action
         Map<String, Serializable> actionProps = compositeAction
               .getParameterValues();
         actionProps.put(RULE_PARAM_MOVE_PROP_DESTINATION, destNodeRef);
         Map<String, Serializable> repoProps = compositeAction
               .getParameterValues();
         (new MoveHandler()).prepareForSave(actionProps, repoProps);
         action.setParameterValues(repoProps);

         // Save the rule
         nodeManager.ruleService.saveRule(nodeRef, rule);

      } catch (Exception e) {
         logger.error("", e);
      }
   }
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Merci

topic Re: Code gérant les permissions et règles in Alfresco Archive

Code gérant les permissions et règles

Re: Code gérant les permissions et règles