/**
   * Actualitza el tamany de la sèrie.
   *
   * @param nodeRef
   * @param parentNodeRef
   */
  private void updateSerie(NodeService nodeService, NodeRef nodeRef, NodeRef serieNodeRef) {
    System.out.println(
        DateFormat.getInstance().format(new Date()) + " START: Recalcular tamany sèrie.");
    int tamany = 0;
    List<ChildAssociationRef> children = nodeService.getChildAssocs(serieNodeRef);

    for (ChildAssociationRef childAssoc : children) {
      NodeRef childNodeRef = childAssoc.getChildRef();

      if (nodeService.hasAspect(childNodeRef, expedientRM)) {
        Serializable tamanySerial = nodeService.getProperty(childNodeRef, tamanyExpedientRM);

        if (tamanySerial != null) {
          tamany = tamany + (Integer.parseInt((String) tamanySerial));
        }

      } else if (nodeService.hasAspect(childNodeRef, agregacioRM)) {
        Serializable tamanySerial = nodeService.getProperty(childNodeRef, tamanyAgregacioRM);

        if (tamanySerial != null) {
          tamany = tamany + (Integer.parseInt((String) tamanySerial));
        }
      }
    }

    nodeService.setProperty(serieNodeRef, tamanySerieRM, String.valueOf(tamany));
    Date now = new Date();
    System.out.println(
        DateFormat.getInstance().format(now) + " Update tamany sèrie: " + serieNodeRef);
    System.out.println(DateFormat.getInstance().format(now) + " END: Recalcular tamany sèrie.");
  }
  /**
   * Helper to convert a path into an indexed path which uniquely identifies a node
   *
   * @param nodeRef
   * @param path
   * @return
   */
  private Path createIndexedPath(NodeRef nodeRef, Path path) {
    // Add indexes for same name siblings
    // TODO: Look at more efficient approach
    for (int i = path.size() - 1; i >= 0; i--) {
      Path.Element pathElement = path.get(i);
      if (i > 0 && pathElement instanceof Path.ChildAssocElement) {
        int index = 1; // for xpath index compatibility
        String searchPath = path.subPath(i).toPrefixString(namespaceService);
        List<NodeRef> siblings =
            searchService.selectNodes(nodeRef, searchPath, null, namespaceService, false);
        if (siblings.size() > 1) {
          ChildAssociationRef childAssoc = ((Path.ChildAssocElement) pathElement).getRef();
          NodeRef childRef = childAssoc.getChildRef();
          for (NodeRef sibling : siblings) {
            if (sibling.equals(childRef)) {
              childAssoc.setNthSibling(index);
              break;
            }
            index++;
          }
        }
      }
    }

    return path;
  }
  @Override
  protected String finishImpl(FacesContext context, String outcome) throws Exception {
    // find out what the parent type of the node being deleted
    Node node = this.browseBean.getActionSpace();
    NodeRef parent = null;
    ChildAssociationRef assoc = this.getNodeService().getPrimaryParent(node.getNodeRef());
    if (assoc != null) {
      // get the parent node
      parent = assoc.getParentRef();

      // if the parent type is a forum space then we need the dialog to go
      // back to the forums view otherwise it will use the default of 'browse',
      // this happens when a forum being used to discuss a node is deleted.
      QName parentType = this.getNodeService().getType(parent);
      if (parentType.equals(ForumModel.TYPE_FORUMS)) {
        this.reDisplayForums = true;
      }
    }

    // delete the forum itself
    outcome = super.finishImpl(context, outcome);

    // remove the discussable aspect if appropriate
    if (assoc != null && parent != null) {
      // get the association type
      QName type = assoc.getTypeQName();
      if (type.equals(ForumModel.ASSOC_DISCUSSION)) {
        // if the association type is the 'discussion' association we
        // need to remove the discussable aspect from the parent node
        this.getNodeService().removeAspect(parent, ForumModel.ASPECT_DISCUSSABLE);
      }
    }

    return outcome;
  }
Exemple #4
0
  @Override
  public IAfSysObject moveTo(String specific, String newName) throws AfException {

    if (isNew()) {
      throw new AfException("this object is new, you can not move it");
    }

    NodeService nodeService = ServiceHelper.getNodeService(afSession);

    NodeRef newParent = getSpecifiedNode(specific);
    if (newParent == null || !(nodeService.exists(newParent))) {
      throw new AfException("the folder " + specific + " you specified does not exist");
    }

    IAfType folderType = AFCHelper.getNodeType(afSession, newParent);
    if (!(folderType.isSubTypeOf("cm:folder") || folderType.getName().equals("cm:folder"))) {
      // parent is a doc
      throw new AfException("you can not move object into a document");
    }

    String objName = (newName == null) ? getObjectName() : newName;
    QName nodeName = QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, objName);
    ChildAssociationRef child = nodeService.moveNode(nodeRef, newParent, getAssType(), nodeName);

    IAfSysObject doc = (IAfSysObject) afSession.getObject(new AfID(child.getChildRef().getId()));

    doc.setObjectName(objName);
    doc.save();

    return doc;
  }
  private static NodeRef followAssociations(
      ServiceRegistry services,
      ChildAssociationRef association,
      QName qnameType,
      String[] navigation,
      int indexNavigation)
      throws InvalidAssociationException, InvalidContentException {
    NodeRef finalTarget = null;
    String uri = qnameType.getNamespaceURI();
    if (association.getQName().toString().contains(uri)
        && association.getQName().toString().contains(navigation[indexNavigation])) {
      NodeRef target = association.getChildRef();
      if (target != null) {
        if (indexNavigation < navigation.length - 2) {
          QName targetType = services.getNodeService().getType(target);
          List<ChildAssociationRef> nextAssociations =
              services.getNodeService().getChildAssocs(target);
          for (ChildAssociationRef nextAssociation : nextAssociations) {
            followAssociations(
                services, nextAssociation, targetType, navigation, indexNavigation++);
          }
        } else {
          finalTarget = target;
        }
      } else {
        throw new InvalidContentException(InvalidContentException.DOES_NOT_EXISTS);
      }
    } else {
      throw new InvalidAssociationException(InvalidAssociationException.DOES_NOT_EXISTS);
    }

    return finalTarget;
  }
 /**
  * Support to build node lists from category service API calls.
  *
  * @param childRefs Collection<ChildAssociationRef>
  * @return List of TemplateNode
  */
 private List<TemplateNode> buildTemplateNodeList(Collection<ChildAssociationRef> childRefs) {
   List<TemplateNode> answer = new ArrayList<TemplateNode>(childRefs.size());
   for (ChildAssociationRef ref : childRefs) {
     // create our Node representation from the NodeRef
     TemplateNode child = new TemplateNode(ref.getChildRef(), this.services, this.imageResolver);
     answer.add(child);
   }
   return answer;
 }
  /**
   * Gets the primary parent association
   *
   * @param node the node to process
   * @return the primary parent association or null if this is a root node
   */
  public static ChildAssociationRef getPrimaryParentAssoc(TransferManifestNormalNode node) {
    List<ChildAssociationRef> assocs = node.getParentAssocs();

    for (ChildAssociationRef assoc : assocs) {
      if (assoc.isPrimary()) {
        return assoc;
      }
    }
    return null;
  }
  /**
   * @see
   *     org.alfresco.service.cmr.coci.CheckOutCheckInService#checkout(org.alfresco.service.cmr.repository.NodeRef)
   */
  public NodeRef checkout(NodeRef nodeRef) {
    // Find the primary parent in order to determine where to put the copy
    ChildAssociationRef childAssocRef = this.nodeService.getPrimaryParent(nodeRef);

    // Checkout the working copy to the same destination
    return checkout(
        nodeRef,
        childAssocRef.getParentRef(),
        childAssocRef.getTypeQName(),
        childAssocRef.getQName());
  }
  /**
   * Create the specified home space if it does not exist, and return the ID
   *
   * @param locationId Parent location
   * @param spaceName Home space to create, can be null to simply return the parent
   * @param oldHomeFolderRef the previous home space, for the case where the the user is being
   *     updated. It may not have changed.
   * @param error True to throw an error if the space already exists, else ignore and return
   * @return ID of the home space
   */
  protected NodeRef createHomeSpace(
      String locationId, String spaceName, NodeRef oldHomeFolderRef, boolean error) {
    NodeRef homeSpaceNodeRef = null;
    if (spaceName != null && spaceName.length() != 0) {
      NodeRef parentRef = new NodeRef(Repository.getStoreRef(), locationId);

      // check for existence of home space with same name - return immediately
      // if it exists or throw an exception an give user chance to enter another name
      NodeRef childRef =
          this.getNodeService().getChildByName(parentRef, ContentModel.ASSOC_CONTAINS, spaceName);
      if (childRef != null) {
        if (childRef.equals(oldHomeFolderRef)) {
          return oldHomeFolderRef;
        }
        if (error) {
          throw new AlfrescoRuntimeException("A Home Space with the same name already exists.");
        } else {
          return childRef;
        }
      }

      // space does not exist already, create a new Space under it with
      // the specified name
      String qname = QName.createValidLocalName(spaceName);
      ChildAssociationRef assocRef =
          this.getNodeService()
              .createNode(
                  parentRef,
                  ContentModel.ASSOC_CONTAINS,
                  QName.createQName(NamespaceService.SYSTEM_MODEL_1_0_URI, qname),
                  ContentModel.TYPE_FOLDER);

      NodeRef nodeRef = assocRef.getChildRef();

      // set the name property on the node
      this.getNodeService().setProperty(nodeRef, ContentModel.PROP_NAME, spaceName);

      if (logger.isDebugEnabled()) logger.debug("Created Home Space for with name: " + spaceName);

      // apply the uifacets aspect - icon, title and description props
      Map<QName, Serializable> uiFacetsProps = new HashMap<QName, Serializable>(3);
      uiFacetsProps.put(ApplicationModel.PROP_ICON, CreateSpaceWizard.DEFAULT_SPACE_ICON_NAME);
      uiFacetsProps.put(ContentModel.PROP_TITLE, spaceName);
      this.getNodeService().addAspect(nodeRef, ApplicationModel.ASPECT_UIFACETS, uiFacetsProps);

      setupHomeSpacePermissions(nodeRef);

      // return the ID of the created space
      homeSpaceNodeRef = nodeRef;
    }

    return homeSpaceNodeRef;
  }
Exemple #10
0
  /*
   * (non-Javadoc)
   * @see org.alfresco.cmis.property.PropertyAccessor#getValue(org.alfresco.service.cmr.repository.NodeRef)
   */
  public Serializable getValue(NodeRef nodeRef) {
    if (nodeRef.equals(getServiceRegistry().getCMISService().getDefaultRootNodeRef())) {
      return null;
    }

    ChildAssociationRef car = getServiceRegistry().getNodeService().getPrimaryParent(nodeRef);
    if ((car != null) && (car.getParentRef() != null)) {
      return car.getParentRef().toString();
    } else {
      return null;
    }
  }
  /**
   * Helper method to set audited information after method invocation and to determine if auditing
   * should take place based on the method return value.
   *
   * @param auditMode
   * @param auditInfo
   * @param mi
   * @param returnObject
   * @return - the audit mode.
   */
  private AuditMode postInvocation(
      AuditMode auditMode, AuditState auditInfo, MethodInvocation mi, Object returnObject) {
    if (returnObject == null) {
      auditInfo.setReturnObject(null);
    } else if (returnObject instanceof Serializable) {
      auditInfo.setReturnObject((Serializable) returnObject);
    } else {
      auditInfo.setReturnObject(returnObject.toString());
    }

    Auditable auditable = mi.getMethod().getAnnotation(Auditable.class);
    if (auditable.key() == Auditable.Key.RETURN) {
      if (returnObject != null) {
        if (returnObject instanceof NodeRef) {
          NodeRef key = (NodeRef) returnObject;
          auditInfo.setKeyStore(key.getStoreRef());
          auditInfo.setKeyGUID(key.getId());
          RecordOptions recordOptions = auditModel.getAuditRecordOptions(mi);
          if (recordOptions != null && recordOptions.getRecordPath() == TrueFalseUnset.TRUE) {
            auditInfo.setPath(getNodePath(key));
          }
        } else if (returnObject instanceof StoreRef) {
          auditInfo.setKeyStore((StoreRef) returnObject);
        } else if (returnObject instanceof ChildAssociationRef) {
          ChildAssociationRef car = (ChildAssociationRef) returnObject;
          auditInfo.setKeyStore(car.getChildRef().getStoreRef());
          auditInfo.setKeyGUID(car.getChildRef().getId());
          RecordOptions recordOptions = auditModel.getAuditRecordOptions(mi);
          if (recordOptions != null && recordOptions.getRecordPath() == TrueFalseUnset.TRUE) {
            auditInfo.setPath(nodeService.getPath(car.getChildRef()).toString());
          }
        } else {
          logger.warn(
              "Key argument is not a node, store or child assoc ref for return object on "
                  + publicServiceIdentifier.getPublicServiceName(mi)
                  + "."
                  + mi.getMethod().getName()
                  + " it is "
                  + returnObject.getClass().getName());
        }
      }
    }

    // If the user name is not set, try and set it after the method call.
    // This covers authentication when the user is only known after the call.

    if (auditInfo.getUserIdentifier() == null) {
      auditInfo.setUserIdentifier(AuthenticationUtil.getFullyAuthenticatedUser());
    }

    return auditMode;
  }
 /**
  * Retrieves the forum node the the given discussable
  *
  * @return Returns the <b>fm:forum</b> node or <tt>null</tt>
  */
 private NodeRef getForum(NodeRef discussableNodeRef) {
   List<ChildAssociationRef> destChildren =
       nodeService.getChildAssocs(
           discussableNodeRef, ForumModel.ASSOC_DISCUSSION, RegexQNamePattern.MATCH_ALL);
   // Take the first one
   if (destChildren.size() == 0) {
     return null;
   } else {
     // We just take the first one
     ChildAssociationRef discussionAssoc = destChildren.get(0);
     return discussionAssoc.getChildRef();
   }
 }
 private List<TemplateNode> buildMixedNodeList(Collection<ChildAssociationRef> cars) {
   List<TemplateNode> nodes = new ArrayList<TemplateNode>(cars.size());
   int i = 0;
   for (ChildAssociationRef car : cars) {
     QName type = services.getNodeService().getType(car.getChildRef());
     if (services.getDictionaryService().isSubClass(type, ContentModel.TYPE_CATEGORY)) {
       nodes.add(new CategoryTemplateNode(car.getChildRef(), this.services, this.imageResolver));
     } else {
       nodes.add(new TemplateNode(car.getChildRef(), this.services, this.imageResolver));
     }
   }
   return nodes;
 }
 /**
  * Force copy recursion after copying a rules folder
  *
  * @return Returns {@link ChildAssocRecurseAction#FORCE_RECURSE} for {@link
  *     RuleModel#ASSOC_RULE_FOLDER}
  */
 @Override
 public ChildAssocRecurseAction getChildAssociationRecurseAction(
     QName classQName,
     CopyDetails copyDetails,
     CopyChildAssociationDetails childAssocCopyDetails) {
   ChildAssociationRef childAssocRef = childAssocCopyDetails.getChildAssocRef();
   if (childAssocRef.getTypeQName().equals(RuleModel.ASSOC_RULE_FOLDER)) {
     return ChildAssocRecurseAction.FORCE_RECURSE;
   } else {
     super.throwExceptionForUnexpectedBehaviour(copyDetails, childAssocCopyDetails.toString());
     return null; // Never reached
   }
 }
  /**
   * Actualitza el tamany de l'expedient.
   *
   * @param nodeRef
   * @param parentNodeRef
   */
  private void updateExpedient(NodeService nodeService, NodeRef docNodeRef, NodeRef expNodeRef) {
    System.out.println(
        DateFormat.getInstance().format(new Date()) + " START: Recalcular tamany expedient.");
    int tamany = 0;
    List<ChildAssociationRef> children = nodeService.getChildAssocs(expNodeRef);

    for (ChildAssociationRef childAssoc : children) {
      NodeRef childNodeRef = childAssoc.getChildRef();
      Serializable tamanySerial = nodeService.getProperty(childNodeRef, tamanyDocumentSimpleRM);

      if (tamanySerial != null && !"".equals(tamanySerial)) {
        tamany = tamany + (Integer.parseInt((String) tamanySerial));
      }
    }

    nodeService.setProperty(expNodeRef, tamanyExpedientRM, String.valueOf(tamany));
    Date now = new Date();
    System.out.println(
        DateFormat.getInstance().format(now) + " Update tamany expedient: " + expNodeRef);
    System.out.println(DateFormat.getInstance().format(now) + " END: Recalcular tamany expedient.");
  }
  /**
   * Actualitza el tamany del fons.
   *
   * @param nodeRef
   * @param parentNodeRef
   */
  private void updateFons(NodeService nodeService, NodeRef serieNodeRef, NodeRef fonsNodeRef) {
    System.out.println(
        DateFormat.getInstance().format(new Date()) + " START: Recalcular tamany fons.");
    int tamany = 0;
    List<ChildAssociationRef> children = nodeService.getChildAssocs(fonsNodeRef);

    for (ChildAssociationRef childAssoc : children) {
      NodeRef childNodeRef = childAssoc.getChildRef();
      Serializable tamanySerial = nodeService.getProperty(childNodeRef, tamanySerieRM);

      if (tamanySerial != null) {
        tamany = tamany + (Integer.parseInt((String) tamanySerial));
      }
    }

    nodeService.setProperty(fonsNodeRef, tamanyFonsRM, String.valueOf(tamany));
    Date now = new Date();
    System.out.println(
        DateFormat.getInstance().format(now) + " Update tamany fons: " + fonsNodeRef);
    System.out.println(DateFormat.getInstance().format(now) + " END: Recalcular tamany fons.");
  }
  @After
  public void deleteTestNodes() throws Exception {
    AuthenticationUtil.setFullyAuthenticatedUser(ADMIN_USER);

    // Find the shared system container, and zap contents
    NodeRef container =
        ((RemoteCredentialsServiceImpl) PRIVATE_REMOTE_CREDENTIALS_SERVICE)
            .getSharedContainerNodeRef(false);
    if (container != null) {
      List<NodeRef> children = new ArrayList<NodeRef>();
      for (ChildAssociationRef child : PUBLIC_NODE_SERVICE.getChildAssocs(container)) {
        children.add(child.getChildRef());
      }
      performDeletionOfNodes(children);
    }

    // Zap the users, including any credentials stored for them
    deleteUser(TEST_USER_ONE);
    deleteUser(TEST_USER_TWO);
    deleteUser(TEST_USER_THREE);
  }
  /** Ensure that the node has a <b>fm:forum</b> child node otherwise create one */
  public void onAddAspect(NodeRef discussableNodeRef, QName aspectTypeQName) {
    String name = (String) this.nodeService.getProperty(discussableNodeRef, ContentModel.PROP_NAME);
    String forumName = I18NUtil.getMessage("discussion.discussion_for", new Object[] {name});

    NodeRef forumNodeRef = getForum(discussableNodeRef);

    if (forumNodeRef == null) {
      Map<QName, Serializable> forumProps = new HashMap<QName, Serializable>(1);
      forumProps.put(ContentModel.PROP_NAME, forumName);

      ChildAssociationRef childRef =
          nodeService.createNode(
              discussableNodeRef,
              ForumModel.ASSOC_DISCUSSION,
              QName.createQName(NamespaceService.FORUMS_MODEL_1_0_URI, "discussion"),
              ForumModel.TYPE_FORUM,
              forumProps);

      forumNodeRef = childRef.getChildRef();
    } else {
      // Just adjust the name
      nodeService.setProperty(forumNodeRef, ContentModel.PROP_NAME, forumName);
    }

    // apply the uifacets aspect
    Map<QName, Serializable> uiFacetsProps = new HashMap<QName, Serializable>(5);
    uiFacetsProps.put(ApplicationModel.PROP_ICON, "forum");
    this.nodeService.addAspect(forumNodeRef, ApplicationModel.ASPECT_UIFACETS, uiFacetsProps);

    // Done
    if (logger.isDebugEnabled()) {
      logger.debug(
          "Created forum node for discussion: \n"
              + "   Discussable Node: "
              + discussableNodeRef
              + "\n"
              + "   Forum Node:       "
              + forumNodeRef);
    }
  }
Exemple #19
0
  @Override
  public void unLink(String specific) throws AfException {

    if (isNew()) {
      throw new AfException("this object is new, you can not unlink it");
    }

    NodeService nodeService = ServiceHelper.getNodeService(afSession);

    NodeRef parent = getSpecifiedNode(specific);
    if (parent == null || !(nodeService.exists(parent))) {
      return;
    }

    List<ChildAssociationRef> parents = nodeService.getParentAssocs(nodeRef);

    for (ChildAssociationRef ref : parents) {

      if (ref.getParentRef().getId().equals(parent.getId())) {

        if (!ref.isPrimary()) {
          // not primary,delete
          nodeService.removeChildAssociation(ref);
          return;
        } else {
          // primary, it's not a good coding.f**k it!
          String rootId = AFCHelper.getNodeRefByPath(afSession, "/").getId();
          if (parents.size() <= 1) {
            if (rootId.equals(ref.getParentRef().getId())) {
              return;
            } else {
              moveTo("/", null);
              nodeService.removeChildAssociation(ref);
              return;
            }

          } else {
            // set the 2nd as the primary.moveTo
            for (ChildAssociationRef anotherP : parents) {
              if (!anotherP.equals(ref)) {
                String scndPId = anotherP.getParentRef().getId();

                nodeService.removeChildAssociation(anotherP);

                moveTo(scndPId, null);
                nodeService.removeChildAssociation(ref);
                return;
              }
            }
          }
        }
      }
    }
  }
Exemple #20
0
 /**
  * {@inheritDoc}
  *
  * <p>This method is thread-safe and lazily creates the required references, if required.
  */
 public ChildAssociationRef getChildAssocRef(QNameDAO qnameDAO) {
   boolean trashReference = false;
   // first check if it is available
   refReadLock.lock();
   try {
     if (childAssocRef != null) {
       // double check that the parent and child node references match those of our reference
       if (childAssocRef.getParentRef() != parent.getNodeRef()
           || childAssocRef.getChildRef() != child.getNodeRef()) {
         trashReference = true;
       } else {
         // we are sure that the reference is correct
         return childAssocRef;
       }
     }
   } finally {
     refReadLock.unlock();
   }
   // get write lock
   refWriteLock.lock();
   try {
     // double check
     if (childAssocRef == null || trashReference) {
       if (typeQName == null) {
         typeQName = qnameDAO.getQName(this.typeQNameId).getSecond();
       }
       if (qname == null) {
         String qnameNamespace = qnameDAO.getNamespace(qnameNamespaceId).getSecond();
         qname = QName.createQName(qnameNamespace, qnameLocalName);
       }
       childAssocRef =
           new ChildAssociationRef(
               typeQName, parent.getNodeRef(), qname, child.getNodeRef(), this.isPrimary, index);
     }
     return childAssocRef;
   } finally {
     refWriteLock.unlock();
   }
 }
  /**
   * This method sets the node(s) to publish or unpublish on the supplied publishing details. If the
   * actionedUponNode is a folder then it will include all content nodes within that folder.
   *
   * @param actionedUponNodeRef
   * @param unpublish
   * @param details
   */
  private List<NodeRef> setNodes(
      NodeRef actionedUponNodeRef, boolean unpublish, PublishingDetails details) {
    List<NodeRef> nodes = new ArrayList<NodeRef>();
    QName nodeType = nodeService.getType(actionedUponNodeRef);
    if (dictionaryService.isSubClass(nodeType, ContentModel.TYPE_FOLDER)) {
      List<ChildAssociationRef> children = nodeService.getChildAssocs(actionedUponNodeRef);
      for (ChildAssociationRef childRef : children) {
        NodeRef child = childRef.getChildRef();
        if (dictionaryService.isSubClass(nodeService.getType(child), ContentModel.TYPE_CONTENT)) {
          nodes.add(child);
        }
      }
    } else {
      nodes.add(actionedUponNodeRef);
    }

    if (unpublish) {
      details.addNodesToUnpublish(nodes);
    } else {
      details.addNodesToPublish(nodes);
    }
    return nodes;
  }
  public NodeRef createDownloadNode(boolean recursive) {
    NodeRef downloadsContainer = getOrCreateDowloadContainer();

    Map<QName, Serializable> downloadProperties = new HashMap<QName, Serializable>();
    downloadProperties.put(DownloadModel.PROP_RECURSIVE, recursive);

    ChildAssociationRef newChildAssoc =
        nodeService.createNode(
            downloadsContainer,
            ContentModel.ASSOC_CHILDREN,
            ContentModel.ASSOC_CHILDREN,
            DownloadModel.TYPE_DOWNLOAD,
            downloadProperties);

    final NodeRef downloadNodeRef = newChildAssoc.getChildRef();

    if (log.isDebugEnabled()) {
      StringBuilder msg = new StringBuilder();
      msg.append("Created Download. ").append("', Download-NodeRef=");
      log.debug(msg.toString());
    }
    return downloadNodeRef;
  }
  protected List<NodeRef> getNodes(
      StoreRef storeRef, RepositoryLocation repositoryLocation, QName nodeType) {
    List<NodeRef> nodeRefs = new ArrayList<NodeRef>();

    NodeRef rootNodeRef = nodeService.getRootNode(storeRef);
    if (nodeService.exists(rootNodeRef) == false) {
      // Tenant is deleted. But cache refresh was called to inform another cluster nodes
      // Should be reworked when MNT-11638 will be implemented
      return nodeRefs;
    }

    if (repositoryLocation instanceof DynamicCreateRepositoryLocation) {
      ((DynamicCreateRepositoryLocation) repositoryLocation).checkAndCreate(rootNodeRef);
    }

    String[] pathElements = repositoryLocation.getPathElements();

    NodeRef folderNodeRef = rootNodeRef;
    if (pathElements.length > 0) {
      folderNodeRef = resolveQNamePath(rootNodeRef, pathElements);
    }

    if (folderNodeRef != null) {
      Set<QName> types = new HashSet<QName>(1);
      types.add(nodeType);
      List<ChildAssociationRef> childAssocRefs = nodeService.getChildAssocs(folderNodeRef, types);

      if (childAssocRefs.size() > 0) {
        nodeRefs = new ArrayList<NodeRef>(childAssocRefs.size());
        for (ChildAssociationRef childAssocRef : childAssocRefs) {
          nodeRefs.add(childAssocRef.getChildRef());
        }
      }
    }

    return nodeRefs;
  }
 @Override
 public void onCreateNode(ChildAssociationRef childAssociationRef) {
   NodeRef nodeRef = childAssociationRef.getChildRef();
   // Bind the listener to the transaction
   AlfrescoTransactionSupport.bindListener(transactionListener);
   // Get the set of nodes written
   @SuppressWarnings("unchecked")
   Set<NodeRef> updatedNodes =
       (Set<NodeRef>) AlfrescoTransactionSupport.getResource(KEY_UPDATED_NODES);
   if (updatedNodes == null) {
     updatedNodes = new HashSet<NodeRef>(5);
     AlfrescoTransactionSupport.bindResource(KEY_UPDATED_NODES, updatedNodes);
   }
   updatedNodes.add(nodeRef);
 }
  /** Test when the aspect is not set when check-in is performed */
  public void testVersionAspectNotSetOnCheckIn() {
    // Create a bag of props
    Map<QName, Serializable> bagOfProps = createTypePropertyBag();
    bagOfProps.put(
        ContentModel.PROP_CONTENT,
        new ContentData(null, MimetypeMap.MIMETYPE_TEXT_PLAIN, 0L, "UTF-8"));

    // Create a new node
    ChildAssociationRef childAssocRef =
        nodeService.createNode(
            rootNodeRef,
            ContentModel.ASSOC_CHILDREN,
            QName.createQName("test"),
            ContentModel.TYPE_CONTENT,
            bagOfProps);
    NodeRef noVersionNodeRef = childAssocRef.getChildRef();

    // Check out and check in
    NodeRef workingCopy = cociService.checkout(noVersionNodeRef);
    cociService.checkin(workingCopy, new HashMap<String, Serializable>());

    // Check that the origional node has no version history dispite sending verion props
    assertNull(this.versionService.getVersionHistory(noVersionNodeRef));
  }
  /* (non-Javadoc)
   * @see org.alfresco.repo.tenant.TenantService#getBaseName(org.alfresco.service.cmr.repository.ChildAssociationRef)
   */
  public ChildAssociationRef getBaseName(ChildAssociationRef childAssocRef) {
    if (childAssocRef == null) {
      return null;
    }

    return new ChildAssociationRef(
        childAssocRef.getTypeQName(),
        getBaseName(childAssocRef.getParentRef()),
        childAssocRef.getQName(),
        getBaseName(childAssocRef.getChildRef()),
        childAssocRef.isPrimary(),
        childAssocRef.getNthSibling());
  }
 /** {@inheritDoc} */
 @Override
 public void onCreateNode(ChildAssociationRef childAssocRef) {
   this.auditComponent.recordAuditValues(
       CREATE_RATING_ROOT_PATH,
       Collections.<String, Serializable>singletonMap(KEY_NODE_REF, childAssocRef.getChildRef()));
 }
  /**
   * Write exception transfer report
   *
   * @return NodeRef the node ref of the new transfer report
   */
  public NodeRef createTransferReport(
      Exception e,
      TransferTarget target,
      TransferDefinition definition,
      List<TransferEvent> events,
      File snapshotFile) {
    Map<QName, Serializable> properties = new HashMap<QName, Serializable>();

    SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmmssSSSZ");
    String timeNow = format.format(new Date());

    String title = "Transfer report, error,  " + timeNow;
    String description = "Transfer error report";
    String name = "Transfer error report, " + timeNow;

    properties.put(ContentModel.PROP_NAME, name);
    properties.put(ContentModel.PROP_TITLE, title);
    properties.put(ContentModel.PROP_DESCRIPTION, description);
    ChildAssociationRef ref =
        nodeService.createNode(
            target.getNodeRef(),
            ContentModel.ASSOC_CONTAINS,
            QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, name),
            TransferModel.TYPE_TRANSFER_REPORT,
            properties);
    ContentWriter writer =
        contentService.getWriter(ref.getChildRef(), ContentModel.PROP_CONTENT, true);
    writer.setLocale(Locale.getDefault());
    writer.setMimetype(MimetypeMap.MIMETYPE_XML);
    writer.setEncoding(DEFAULT_ENCODING);

    //
    XMLTransferReportWriter reportWriter = new XMLTransferReportWriter();

    BufferedWriter bufferedWriter =
        new BufferedWriter(new OutputStreamWriter(writer.getContentOutputStream()));

    try {
      reportWriter.startTransferReport(DEFAULT_ENCODING, bufferedWriter);

      // Header
      reportWriter.writeTarget(target);

      reportWriter.writeDefinition(definition);

      reportWriter.writeException(e);

      // Detail
      reportWriter.writeTransferEvents(events);

      reportWriter.endTransferReport();

      return ref.getChildRef();
    } catch (SAXException se) {
      return null;
    } finally {
      try {
        bufferedWriter.close();
      } catch (IOException error) {
        error.printStackTrace();
      }
    }
  }
  /**
   * Create a new transfer report of success
   *
   * @return NodeRef the node ref of the new transfer report
   */
  public NodeRef createTransferReport(
      Transfer transfer,
      TransferTarget target,
      TransferDefinition definition,
      List<TransferEvent> events,
      File snapshotFile) {
    Map<QName, Serializable> properties = new HashMap<QName, Serializable>();

    SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmmssSSSZ");
    String timeNow = format.format(new Date());

    String title = "Transfer report, " + timeNow + "success";
    String description = "Transfer report success targetName : " + target.getName();
    String name = "Transfer report, " + timeNow;

    properties.put(ContentModel.PROP_NAME, name);
    properties.put(ContentModel.PROP_TITLE, title);
    properties.put(ContentModel.PROP_DESCRIPTION, description);
    ChildAssociationRef ref =
        nodeService.createNode(
            target.getNodeRef(),
            ContentModel.ASSOC_CONTAINS,
            QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, name),
            TransferModel.TYPE_TRANSFER_REPORT,
            properties);
    ContentWriter writer =
        contentService.getWriter(ref.getChildRef(), ContentModel.PROP_CONTENT, true);
    writer.setLocale(Locale.getDefault());
    writer.setMimetype(MimetypeMap.MIMETYPE_XML);
    writer.setEncoding(DEFAULT_ENCODING);

    //
    final XMLTransferReportWriter reportWriter = new XMLTransferReportWriter();

    BufferedWriter bufferedWriter =
        new BufferedWriter(new OutputStreamWriter(writer.getContentOutputStream()));

    try {
      reportWriter.startTransferReport(DEFAULT_ENCODING, bufferedWriter);

      // Header
      reportWriter.writeTarget(target);

      reportWriter.writeDefinition(definition);

      /** Write the node summary details to the transfer report */
      TransferManifestProcessor processor =
          new TransferManifestProcessor() {
            public void processTransferManifestNode(TransferManifestNormalNode node) {

              try {
                reportWriter.writeNodeSummary(node);
              } catch (SAXException error) {
                error.printStackTrace();
              }
            }

            public void processTransferManifestNode(TransferManifestDeletedNode node) {
              try {
                reportWriter.writeNodeSummary(node);
              } catch (SAXException error) {
                error.printStackTrace();
              }
            }

            public void processTransferManifiestHeader(TransferManifestHeader header) {
              /* NO-OP */
            }

            public void startTransferManifest() {
              /* NO-OP */
            }

            public void endTransferManifest() {
              /* NO-OP */
            }
          };

      /** Step 3: wire up the manifest reader to a manifest processor */
      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
      SAXParser parser;
      parser = saxParserFactory.newSAXParser();
      XMLTransferManifestReader reader = new XMLTransferManifestReader(processor);

      /** Step 4: start the magic Give the manifest file to the manifest reader */
      try {
        parser.parse(snapshotFile, reader);
      } catch (IOException error) {
        // TODO temp code
        error.printStackTrace();
        return null;
      }

      // Detail Events
      reportWriter.writeTransferEvents(events);

      reportWriter.endTransferReport();

      return ref.getChildRef();
    } catch (SAXException se) {
      // TODO Temp code
      return null;
    } catch (ParserConfigurationException error) {
      // TODO temp code
      error.printStackTrace();
      return null;
    } finally {
      try {
        bufferedWriter.close();
      } catch (IOException error) {
        error.printStackTrace();
      }
    }
  }
  /**
   * Set auditable information and determine if auditing is required before method invocation. This
   * would normally be based on the method arguments.
   *
   * @param auditMode
   * @param auditInfo
   * @param mi
   * @return - the audit mode.
   */
  private AuditMode beforeInvocation(
      AuditMode auditMode, AuditState auditInfo, MethodInvocation mi) {
    AuditMode effectiveAuditMode = auditModel.beforeExecution(auditMode, mi);

    if (auditMode != AuditMode.NONE) {
      String methodName = mi.getMethod().getName();
      String serviceName = publicServiceIdentifier.getPublicServiceName(mi);
      auditInfo.setAuditApplication(SYSTEM_APPLICATION);
      auditInfo.setAuditConfiguration(auditConfiguration);
      auditInfo.setAuditMethod(methodName);
      auditInfo.setAuditService(serviceName);
      auditInfo.setClientAddress(null);
      auditInfo.setDate(new Date());
      auditInfo.setFail(false);
      auditInfo.setFiltered(false);
      auditInfo.setHostAddress(auditHost);

      auditInfo.setPath(null);

      Auditable auditable = mi.getMethod().getAnnotation(Auditable.class);
      Object key = null;
      switch (auditable.key()) {
        case ARG_0:
          checkArgLength(mi, methodName, serviceName, 0);
          key = mi.getArguments()[0];
          break;
        case ARG_1:
          checkArgLength(mi, methodName, serviceName, 1);
          key = mi.getArguments()[1];
          break;
        case ARG_2:
          checkArgLength(mi, methodName, serviceName, 2);
          key = mi.getArguments()[2];
          break;
        case ARG_3:
          checkArgLength(mi, methodName, serviceName, 3);
          key = mi.getArguments()[3];
          break;
        case ARG_4:
          checkArgLength(mi, methodName, serviceName, 4);
          key = mi.getArguments()[4];
          break;
        case ARG_5:
          checkArgLength(mi, methodName, serviceName, 5);
          key = mi.getArguments()[5];
          break;
        case ARG_6:
          checkArgLength(mi, methodName, serviceName, 6);
          key = mi.getArguments()[6];
          break;
        case ARG_7:
          checkArgLength(mi, methodName, serviceName, 7);
          key = mi.getArguments()[7];
          break;
        case ARG_8:
          checkArgLength(mi, methodName, serviceName, 8);
          key = mi.getArguments()[8];
          break;
        case ARG_9:
          checkArgLength(mi, methodName, serviceName, 9);
          key = mi.getArguments()[9];
          break;
        case NO_KEY:
        default:
          break;
      }
      if (key != null) {
        RecordOptions recordOptions = auditModel.getAuditRecordOptions(mi);
        if (key instanceof NodeRef) {
          auditInfo.setKeyStore(((NodeRef) key).getStoreRef());
          auditInfo.setKeyGUID(((NodeRef) key).getId());
          if (recordOptions != null && recordOptions.getRecordPath() == TrueFalseUnset.TRUE) {
            auditInfo.setPath(getNodePath((NodeRef) key));
          }
        } else if (key instanceof StoreRef) {
          auditInfo.setKeyStore((StoreRef) key);
        } else if (key instanceof ChildAssociationRef) {
          ChildAssociationRef car = (ChildAssociationRef) key;
          auditInfo.setKeyStore(car.getParentRef().getStoreRef());
          auditInfo.setKeyGUID(car.getParentRef().getId());
          if (recordOptions != null && recordOptions.getRecordPath() == TrueFalseUnset.TRUE) {
            auditInfo.setPath(getNodePath(car.getParentRef()));
          }
        } else if (key instanceof SearchParameters) {
          SearchParameters sp = (SearchParameters) key;
          if (sp.getStores().size() > 0) {
            auditInfo.setKeyStore(sp.getStores().get(0));
          }
        } else {
          logger.warn(
              "Key argument is not a node, store or child assoc reference or search parameters on "
                  + serviceName
                  + "."
                  + methodName
                  + " it is "
                  + key.getClass().getName());
        }
      }
      auditInfo.setKeyPropertiesAfter(null);
      auditInfo.setKeyPropertiesBefore(null);
      auditInfo.setMessage(null);
      if (mi.getArguments() != null) {
        Serializable[] serArgs = new Serializable[mi.getArguments().length];
        for (int i = 0; i < mi.getArguments().length; i++) {
          if ((auditable.recordable() == null)
              || (auditable.recordable().length <= i)
              || auditable.recordable()[i]) {
            if (mi.getArguments()[i] == null) {
              serArgs[i] = null;
            } else if (mi.getArguments()[i] instanceof Serializable) {
              serArgs[i] = (Serializable) mi.getArguments()[i];
            } else {
              serArgs[i] = mi.getArguments()[i].toString();
            }
          } else {
            serArgs[i] = "********";
          }
        }
        auditInfo.setMethodArguments(serArgs);
      }
      auditInfo.setReturnObject(null);
      auditInfo.setSessionId(null);
      auditInfo.setThrowable(null);
      auditInfo.setTxId(AlfrescoTransactionSupport.getTransactionId());
      auditInfo.setUserIdentifier(AuthenticationUtil.getFullyAuthenticatedUser());
    }

    return effectiveAuditMode;
  }