예제 #1
0
  public boolean nodeMatches(NodeRef nodeRef, Set<QName> expectedTypes, Set<QName> excludedTypes) {
    if (!nodeService.exists(nodeRef)) {
      throw new EntityNotFoundException(nodeRef.getId());
    }

    QName type = nodeService.getType(nodeRef);

    Set<QName> allExpectedTypes = new HashSet<QName>();
    if (expectedTypes != null) {
      for (QName expectedType : expectedTypes) {
        allExpectedTypes.addAll(dictionaryService.getSubTypes(expectedType, true));
      }
    }

    Set<QName> allExcludedTypes = new HashSet<QName>();
    if (excludedTypes != null) {
      for (QName excludedType : excludedTypes) {
        allExcludedTypes.addAll(dictionaryService.getSubTypes(excludedType, true));
      }
    }

    boolean inExpected = allExpectedTypes.contains(type);
    boolean excluded = allExcludedTypes.contains(type);
    return (inExpected && !excluded);
  }
예제 #2
0
  /* (non-Javadoc)
   * @see org.alfresco.service.cmr.view.Exporter#startNode(org.alfresco.service.cmr.repository.NodeRef)
   */
  public void startNode(NodeRef nodeRef) {
    try {
      AttributesImpl attrs = new AttributesImpl();

      Path path = nodeService.getPath(nodeRef);
      if (path.size() > 1) {
        // a child name does not exist for root
        Path.ChildAssocElement pathElement = (Path.ChildAssocElement) path.last();
        QName childQName = pathElement.getRef().getQName();
        attrs.addAttribute(
            NamespaceService.REPOSITORY_VIEW_1_0_URI,
            CHILDNAME_LOCALNAME,
            CHILDNAME_QNAME.toPrefixString(),
            null,
            toPrefixString(childQName));
      }

      QName type = nodeService.getType(nodeRef);
      contentHandler.startElement(
          type.getNamespaceURI(), type.getLocalName(), toPrefixString(type), attrs);
    } catch (SAXException e) {
      throw new ExporterException(
          "Failed to process start node event - node ref " + nodeRef.toString(), e);
    }
  }
  private PersonFavourite addFavouriteSite(String userName, NodeRef nodeRef) {
    PersonFavourite favourite = null;

    SiteInfo siteInfo = siteService.getSite(nodeRef);
    if (siteInfo != null) {
      favourite = getFavouriteSite(userName, siteInfo);
      if (favourite == null) {
        Map<String, Serializable> preferences = new HashMap<String, Serializable>(1);

        String siteFavouritedKey = siteFavouritedKey(siteInfo);
        preferences.put(siteFavouritedKey, Boolean.TRUE);

        // ISO8601 string format: PreferenceService works with strings only for dates it seems
        String siteCreatedAtKey = siteCreatedAtKey(siteInfo);
        Date createdAt = new Date();
        String createdAtStr = ISO8601DateFormat.format(createdAt);
        preferences.put(siteCreatedAtKey, createdAtStr);

        preferenceService.setPreferences(userName, preferences);

        favourite =
            new PersonFavourite(
                userName, siteInfo.getNodeRef(), Type.SITE, siteInfo.getTitle(), createdAt);

        QName nodeClass = nodeService.getType(nodeRef);
        OnAddFavouritePolicy policy = onAddFavouriteDelegate.get(nodeRef, nodeClass);
        policy.onAddFavourite(userName, nodeRef);
      }
    } else {
      // shouldn't happen, getType recognizes it as a site or subtype
      logger.warn("Unable to get site for " + nodeRef);
    }

    return favourite;
  }
예제 #4
0
 private Type getType(NodeRef nodeRef) {
   QName type = nodeService.getType(nodeRef);
   boolean isContainer =
       Boolean.valueOf(
           (dictionaryService.isSubClass(type, ContentModel.TYPE_FOLDER) == true
               && !dictionaryService.isSubClass(type, ContentModel.TYPE_SYSTEM_FOLDER)));
   return isContainer ? Type.FOLDER : Type.DOCUMENT;
 }
예제 #5
0
 /* (non-Javadoc)
  * @see org.alfresco.service.cmr.view.Exporter#endNode(org.alfresco.service.cmr.repository.NodeRef)
  */
 public void endNode(NodeRef nodeRef) {
   try {
     QName type = nodeService.getType(nodeRef);
     contentHandler.endElement(type.getNamespaceURI(), type.getLocalName(), toPrefixString(type));
   } catch (SAXException e) {
     throw new ExporterException(
         "Failed to process end node event - node ref " + nodeRef.toString(), e);
   }
 }
 /**
  * Returns all the classes of a node, including its type and aspects.
  *
  * @param nodeRef node reference
  * @return List<QName> list of classes
  */
 private List<QName> getInvokeClasses(NodeRef nodeRef) {
   List<QName> result = new ArrayList<QName>(10);
   result.add(nodeService.getType(nodeRef));
   Set<QName> aspects = nodeService.getAspects(nodeRef);
   for (QName aspect : aspects) {
     result.add(aspect);
   }
   return result;
 }
 @Override
 public Set<NodeRef> findFrom(NodeRef thisNode) {
   Set<NodeRef> result = Collections.emptySet();
   if (nodeService.exists(thisNode)
       && (WebSiteModel.TYPE_INDEX_PAGE.equals(nodeService.getType(thisNode)))) {
     result = new HashSet<NodeRef>();
     result.add(nodeService.getPrimaryParent(thisNode).getParentRef());
   }
   return result;
 }
예제 #8
0
 /**
  * @param nodeRef
  * @return Returns true if the node is a subtype of {@link ContentModel#TYPE_FOLDER folder}
  * @throws AlfrescoRuntimeException if the type is neither related to a folder or content
  */
 public boolean isDirectory(NodeRef nodeRef) {
   QName nodeTypeQName = nodeService.getType(nodeRef);
   if (dictionaryService.isSubClass(nodeTypeQName, ContentModel.TYPE_FOLDER)) {
     return true;
   } else if (dictionaryService.isSubClass(nodeTypeQName, ContentModel.TYPE_CONTENT)) {
     return false;
   } else {
     // it is not a directory, but what is it?
     return false;
   }
 }
예제 #9
0
  /**
   * @param actionedUponNodeRef
   * @return
   */
  protected ContentReader getReader(NodeRef nodeRef) {
    // First check that the node is a sub-type of content
    QName typeQName = nodeService.getType(nodeRef);
    if (dictionaryService.isSubClass(typeQName, ContentModel.TYPE_CONTENT) == false) {
      // it is not content, so can't transform
      return null;
    }

    // Get the content reader
    ContentReader contentReader = contentService.getReader(nodeRef, ContentModel.PROP_CONTENT);

    return contentReader;
  }
  /**
   * 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;
  }
예제 #11
0
  /**
   * Finds the nodes being reference by the given directory and file paths.
   *
   * <p>Examples of the path are:
   *
   * <ul>
   *   <li>\New Folder\New Text Document.txt
   *   <li>\New Folder\Sub Folder
   * </ul>
   *
   * @param pathRootNodeRef the node from which to start the path search
   * @param path the search path to either a folder or file
   * @return Returns references to all matching nodes
   */
  public List<NodeRef> getNodeRefs(NodeRef pathRootNodeRef, String path) {
    // tokenize the path and push into a stack in reverse order so that
    // the root directory gets popped first
    StringTokenizer tokenizer = new StringTokenizer(path, FileName.DOS_SEPERATOR_STR, false);
    String[] tokens = new String[tokenizer.countTokens()];
    int count = 0;
    while (tokenizer.hasMoreTokens()) {
      tokens[count] = tokenizer.nextToken();
      count++;
    }
    Stack<String> pathElements = new Stack<String>();
    for (int i = tokens.length - 1; i >= 0; i--) {
      pathElements.push(tokens[i]);
    }

    // start with a single parent node
    List<NodeRef> pathRootNodeRefs = Collections.singletonList(pathRootNodeRef);

    // result storage
    List<NodeRef> results = new ArrayList<NodeRef>(5);
    List<NodeRef> rubeResults = new ArrayList<NodeRef>(5);

    // kick off the path walking
    addDescendents(pathRootNodeRefs, pathElements, rubeResults);

    for (NodeRef nodeRef : rubeResults) {
      QName nodeType = nodeService.getType(nodeRef);
      if (!excludedTypes.contains(nodeType)) {
        results.add(nodeRef);
      }
    }

    // done
    if (logger.isDebugEnabled()) {
      logger.debug(
          "Retrieved node references for path: \n"
              + "   path root: "
              + pathRootNodeRef
              + "\n"
              + "   path: "
              + path
              + "\n"
              + "   results: "
              + results);
    }
    return results;
  }
  private PersonFavourite addFavouriteDocumentOrFolder(
      String userName, Type type, NodeRef nodeRef) {
    Map<PersonFavouriteKey, PersonFavourite> personFavourites = getFavouriteNodes(userName, type);
    PersonFavourite personFavourite = getPersonFavourite(userName, type, nodeRef);
    if (personFavourite == null) {
      Date createdAt = new Date();
      final String name = (String) nodeService.getProperty(nodeRef, ContentModel.PROP_NAME);
      personFavourite = new PersonFavourite(userName, nodeRef, type, name, createdAt);
      personFavourites.put(personFavourite.getKey(), personFavourite);
      updateFavouriteNodes(userName, type, personFavourites);

      QName nodeClass = nodeService.getType(nodeRef);
      final String finalRef = nodeRef.getId();
      final QName nodeType = nodeClass;

      eventPublisher.publishEvent(
          new EventPreparator() {
            @Override
            public Event prepareEvent(String user, String networkId, String transactionId) {
              return new ActivityEvent(
                  "favorite.added",
                  transactionId,
                  networkId,
                  user,
                  finalRef,
                  null,
                  nodeType == null ? null : nodeType.toString(),
                  Client.asType(ClientType.script),
                  null,
                  name,
                  null,
                  0l,
                  null);
            }
          });

      OnAddFavouritePolicy policy = onAddFavouriteDelegate.get(nodeRef, nodeClass);
      policy.onAddFavourite(userName, nodeRef);
    }

    return personFavourite;
  }
  private boolean removeFavouriteNode(String userName, Type type, NodeRef nodeRef) {
    boolean exists = false;

    Map<PersonFavouriteKey, PersonFavourite> personFavourites = getFavouriteNodes(userName, type);

    PersonFavouriteKey personFavouriteKey = new PersonFavouriteKey(userName, null, type, nodeRef);
    PersonFavourite personFavourite = personFavourites.remove(personFavouriteKey);
    exists = personFavourite != null;
    updateFavouriteNodes(userName, type, personFavourites);

    QName nodeClass = nodeService.getType(nodeRef);
    final String finalRef = nodeRef.getId();
    final QName nodeType = nodeClass;

    eventPublisher.publishEvent(
        new EventPreparator() {
          @Override
          public Event prepareEvent(String user, String networkId, String transactionId) {
            return new ActivityEvent(
                "favorite.removed",
                transactionId,
                networkId,
                user,
                finalRef,
                null,
                nodeType == null ? null : nodeType.toString(),
                Client.asType(ClientType.script),
                null,
                null,
                null,
                0l,
                null);
          }
        });

    OnRemoveFavouritePolicy policy = onRemoveFavouriteDelegate.get(nodeRef, nodeClass);
    policy.onRemoveFavourite(userName, nodeRef);

    return exists;
  }
  public Type getType(NodeRef nodeRef) {
    Type favouriteType = null;

    QName type = nodeService.getType(nodeRef);
    boolean isSite = dictionaryService.isSubClass(type, SiteModel.TYPE_SITE);
    if (isSite) {
      favouriteType = Type.SITE;
    } else {
      boolean isContainer =
          (dictionaryService.isSubClass(type, ContentModel.TYPE_FOLDER)
              && !dictionaryService.isSubClass(type, ContentModel.TYPE_SYSTEM_FOLDER));
      if (isContainer) {
        favouriteType = Type.FOLDER;
      } else {
        boolean isFile = dictionaryService.isSubClass(type, ContentModel.TYPE_CONTENT);
        if (isFile) {
          favouriteType = Type.FILE;
        }
      }
    }

    return favouriteType;
  }
예제 #15
0
  @Override
  protected void executeImpl(Action action, NodeRef actionedUponNodeRef) {
    if (tracer.isDebugEnabled()) tracer.debug("DocumentAcquiring action, execution init");

    // the document has already the documentAcquiring aspect? if yes, nothing to do
    if (nodeService.hasAspect(actionedUponNodeRef, SinekartaModel.ASPECT_QNAME_DOCUMENT_ACQUIRING))
      return;

    // the document has the timestamp mark aspect? if yes, nothing to do
    if (nodeService.hasAspect(actionedUponNodeRef, SinekartaModel.ASPECT_QNAME_TIMESTAMP_MARK))
      return;

    // the node to add is an archive, we don't need any acquire processing
    if (nodeService.getType(actionedUponNodeRef).equals(SinekartaModel.TYPE_QNAME_ARCHIVE)) return;

    // Someone is rendering the document (by ie in share), the document must not be acquired
    // if the document is a child of an acquired document and is not to render, it's a working copy
    // for displaying
    if (nodeService.hasAspect(
        nodeService.getPrimaryParent(actionedUponNodeRef).getParentRef(),
        SinekartaModel.ASPECT_QNAME_DOCUMENT_ACQUIRING)) return; // &&
    // nodeService.hasAspect(actionedUponNodeRef,
    // org.alfresco.model.RenditionModel.ASPECT_HIDDEN_RENDITION))

    Integer documentTypeId = (Integer) action.getParameterValue(PARAM_DOCUMENT_TYPE);
    DocumentType documentType = null;
    if (documentTypeId != null) {
      try {
        documentType = sinekartaDao.getDocumentType(documentTypeId);
      } catch (Exception e) {
        tracer.error("wrong documentType for mark folder prepare.", e);
        throw new DocumentAcquiringException("wrong documentType for mark folder prepare.", e);
      }
    }

    Date documentDate = (Date) action.getParameterValue(PARAM_DOCUMENT_DATE);

    String documentLanguage = (String) action.getParameterValue(PARAM_DOCUMENT_LANGUAGE);

    // getting sinekarta admin user
    String sinekartaAdminUserId =
        NodeTools.getSinekartaAdminUserId(nodeService, searchService, companyHomePath);

    DocumentAcquiringWorker execAsSinekartaAdmin =
        new DocumentAcquiringWorker(
            nodeService,
            contentService,
            actionedUponNodeRef,
            actionService,
            documentType,
            documentDate,
            documentLanguage);

    // running core of action as sinekarta admin
    Boolean result = AuthenticationUtil.runAs(execAsSinekartaAdmin, sinekartaAdminUserId);
    if (!result) {
      tracer.error(
          "document acquiring failed, please verify if the document already exists on archive : "
              + execAsSinekartaAdmin.getKoReason());
      throw new DocumentAcquiringException(
          "document acquiring failed, please verify if the document already exists on archive : "
              + execAsSinekartaAdmin.getKoReason());
    }

    if (tracer.isDebugEnabled()) tracer.debug("DocumentAcquiring action, execution end");
  }
예제 #16
0
 private void validateNode(NodeRef downloadNodeRef) {
   if (nodeService.getType(downloadNodeRef).equals(DownloadModel.TYPE_DOWNLOAD) == false) {
     throw new IllegalArgumentException("Invlaid node type for nodeRef:-" + downloadNodeRef);
   }
 }