Example #1
0
  @Test
  @FixFor("MODE-1401")
  public void shouldAllowRemovingFromCheckedInNodeExistingChildNodeWithOpvOfIgnore()
      throws Exception {
    registerNodeTypes(session, "cnd/versioning.cnd");

    // Set up parent node and check it in ...
    Node parent = session.getRootNode().addNode("versionableNode", "ver:versionable");
    parent.setProperty("versionProp", "v");
    parent.setProperty("copyProp", "c");
    parent.setProperty("ignoreProp", "i");

    Node child1 = parent.addNode("nonVersionedIgnoredChild", "ver:nonVersionableChild");
    child1.setProperty("copyProp", "c");
    child1.setProperty("ignoreProp", "i");

    Node child2 = parent.addNode("versionedIgnoredChild", "ver:versionableChild");
    child2.setProperty("copyProp", "c");
    child2.setProperty("ignoreProp", "i");

    session.save();
    versionManager.checkin(parent.getPath());

    // Should be able to change the properties on the ignored children
    child1.setProperty("copyProp", "c2");
    child1.setProperty("ignoreProp", "i2");
    child2.setProperty("copyProp", "c2");
    child2.setProperty("ignoreProp", "i2");
    session.save();

    // Try to remove the two child nodes that have an OPV of 'ignore' ...
    child1.remove();
    child2.remove();
    session.save();

    // Should be able to change the ignored properties on the checked-in parent ...
    parent.setProperty("ignoreProp", "i");

    // Should not be able to set any non-ignored properties on the checked in parent ...
    try {
      parent.setProperty("copyProp", "c2");
      fail("not allowed");
    } catch (VersionException e) {
      // expected
    }
    try {
      parent.setProperty("versionProp", "v2");
      fail("not allowed");
    } catch (VersionException e) {
      // expected
    }
  }
  /**
   * Remove the specified node from the workspace
   *
   * @param nodePath the path of the node to be removed
   * @throws EcmException if any error occurred
   */
  public void removeNode(String nodePath) throws EcmException {
    Node node = null;

    /** Load the node */
    node = this.getNode(nodePath);

    /** Validate if the node is exist or not */
    this.validateNodeInstance(node);

    try {
      node.remove();
      this.session.save();

    } catch (AccessDeniedException e) {
      throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_ACCESS_DENIED);

    } catch (VersionException e) {
      throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_VERSION_ERROR);

    } catch (LockException e) {
      throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_VERSION_ERROR);

    } catch (ConstraintViolationException e) {
      throw new EcmException(
          "Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_CONSTRAINT_VIOLATION);

    } catch (RepositoryException e) {
      throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_GENERIC);
    }
  }
Example #3
0
 /**
  * Test if mode <i>sync</i> is putting a binary only present in /var/dam into the workflow as
  * indicated by <i>wfModelId</i>.
  *
  * @throws Exception in case of any error
  */
 public void testAssetSync() throws Exception {
   Node aNode = getAsset(false).adaptTo(Node.class);
   aNode.remove();
   aNode.getSession().save();
   executeWorkflowProcess(getTiff().getParent().getPath(), "mode:sync,wfModelId:" + WORKFLOW_ID);
   checkCreated(getTiff().getPath());
 }
  private boolean removeNode(String path) {

    Resource templateResource = resourceResolver.getResource(path);
    if (templateResource != null) {
      Node nodeToDelete = templateResource.adaptTo(Node.class);

      if (nodeToDelete != null) {
        try {
          nodeToDelete.remove();
          TemplateUtils.saveNode(nodeToDelete);
          session.save();
          return true;
        } catch (VersionException ex) {
          java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
              .log(Level.SEVERE, null, ex);
        } catch (LockException ex) {
          java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
              .log(Level.SEVERE, null, ex);
        } catch (ConstraintViolationException ex) {
          java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
              .log(Level.SEVERE, null, ex);
        } catch (AccessDeniedException ex) {
          java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
              .log(Level.SEVERE, null, ex);
        } catch (RepositoryException ex) {
          java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
              .log(Level.SEVERE, null, ex);
        } finally {
          session.logout();
        }
      }
    }
    return false;
  }
Example #5
0
  @Test
  @FixFor("MODE-1976")
  public void shouldCopyFromFederatedSourceToNonFederatedTargetSameWs() throws Exception {
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "fed1");
    Node federated1 = jcrSession().getNode("/testRoot/fed1").addNode("federated1");
    federated1.setProperty("prop", "value");
    jcrSession().getRootNode().addNode("testRoot2");
    jcrSession().save();

    jcrSession().getWorkspace().copy("/testRoot/fed1", "/testRoot2/fed1");
    assertNodeFound("/testRoot2/fed1");
    Node federated1Copy = assertNodeFound("/testRoot2/fed1/federated1");
    federated1Copy.remove();
    jcrSession().save();

    assertNodeFound("/testRoot/fed1/federated1");

    jcrSession().getRootNode().addNode("testRoot3");
    jcrSession().save();
    jcrSession().getWorkspace().copy("/testRoot/fed1/federated1", "/testRoot3");

    federated1Copy = assertNodeFound("/testRoot3[2]");
    assertNotNull(federated1Copy.getProperty("prop"));
  }
Example #6
0
  @Override
  public void deleteDirectory(long companyId, long repositoryId, String dirName)
      throws PortalException {

    Session session = null;

    try {
      session = JCRFactoryUtil.createSession();

      Node rootNode = getRootNode(session, companyId);

      Node repositoryNode = getFolderNode(rootNode, repositoryId);

      Node dirNode = repositoryNode.getNode(dirName);

      dirNode.remove();

      session.save();
    } catch (PathNotFoundException pnfe) {
      throw new NoSuchDirectoryException(dirName);
    } catch (RepositoryException re) {
      String message = GetterUtil.getString(re.getMessage());

      if (message.contains("failed to resolve path")) {
        throw new NoSuchDirectoryException(dirName);
      } else {
        throw new PortalException(re);
      }
    } finally {
      JCRFactoryUtil.closeSession(session);
    }
  }
  public void testRestoreSNS() throws RepositoryException {
    Session session = getHelper().getSuperuserSession();

    // - Create a node 'a' with nodetype nt:unstructured
    // (defining it's childnodes to show OPV Version behaviour)
    Node node = session.getRootNode().addNode("RestoreSameNameSiblingTest");
    try {
      // - Create a child node 'b'
      node.addNode("test");
      // - Make 'a' versionable (add mixin mix:versionable)
      node.addMixin(mixVersionable);
      session.save();

      // - Checkin/Checkout 'a'
      Version version = node.checkin();
      node.checkout();
      assertEquals(1, node.getNodes("test").getSize());

      // - Restore any version of 'a'
      node.restore(version, true);
      assertEquals(1, node.getNodes("test").getSize());
    } finally {
      node.remove();
      session.save();
      session.logout();
    }
  }
Example #8
0
  @Test
  public void removingInternalNodeShouldNotRemoveExternalNodes() throws Exception {
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2");

    Node internalNode1 = testRoot.addNode("internalNode1");
    session.save();
    federationManager.createProjection(
        "/testRoot/internalNode1", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2");

    // remove the federated node directly
    assertNodeFound("/testRoot/internalNode1/federated2/federated3");
    internalNode1.remove();
    session.save();
    // check external nodes are still there
    assertNodeFound("/testRoot/federated2/federated3");

    testRoot.addNode("internalNode2").addNode("internalNode2_1");
    session.save();
    federationManager.createProjection(
        "/testRoot/internalNode2/internalNode2_1",
        SOURCE_NAME,
        MockConnector.DOC2_LOCATION,
        "federated2");
    // remove an ancestor of the federated node
    assertNodeFound("/testRoot/internalNode2/internalNode2_1/federated2/federated3");
    ((Node) session.getNode("/testRoot/internalNode2")).remove();
    session.save();

    // check external nodes are still there
    assertNodeFound("/testRoot/federated2/federated3");
  }
Example #9
0
  /**
   * test method addFavourite. Input: /testAddFavourite node tested action: add favorite for 3 users
   * 'root', 'demo', 'james' to the node above. Expected value : 1 for favorite node list size of
   * each user /testAddFavourite node)
   *
   * @throws Exception
   */
  public void testAddFavorite() throws Exception {
    Node rootNode = session.getRootNode();
    Node testAddFavouriteNode = rootNode.addNode("testAddFavorite");
    session.save();
    favoriteService.addFavorite(testAddFavouriteNode, "root");
    favoriteService.addFavorite(testAddFavouriteNode, "demo");
    favoriteService.addFavorite(testAddFavouriteNode, "james");

    int rootFav =
        favoriteService
            .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "root")
            .size();
    int demoFav =
        favoriteService
            .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "demo")
            .size();
    int jamesFav =
        favoriteService
            .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "james")
            .size();

    assertEquals("testAddFavorite failed!", 1, rootFav);
    assertEquals("testAddFavorite failed!", 1, demoFav);
    assertEquals("testAddFavorite failed!", 1, jamesFav);

    testAddFavouriteNode.remove();
    session.save();
  }
Example #10
0
  /**
   * test method getAllFavouriteNodesByUser. Input: /node0 /node1 /node2 /node3 /node3/node4. Tested
   * action: add favorite for 'root' to node0, node2, node4; add favorite for 'demo' to property of
   * node1,
   *
   * <p>expectedValue : 4 ( number of favorite nodes by 'root')
   *
   * @throws Exception
   */
  public void testGetAllFavouriteNodesByUser() throws Exception {
    Node rootNode = session.getRootNode();
    Node testNode = rootNode.addNode("testNode");
    session.save();

    Node node0 = testNode.addNode("node0");
    Node node1 = testNode.addNode("node1");
    Node node2 = testNode.addNode("node2");
    Node node3 = testNode.addNode("node3");
    Node node4 = node3.addNode("node4");

    favoriteService.addFavorite(node0, "root");
    favoriteService.addFavorite(node1, "demo");
    favoriteService.addFavorite(node2, "root");
    favoriteService.addFavorite(node3, "root");
    favoriteService.addFavorite(node4, "root");

    assertEquals(
        "testGetAllFavouriteNodesByUser failed!",
        4,
        favoriteService
            .getAllFavoriteNodesByUser(
                rootNode.getSession().getWorkspace().getName(), "repository", "root")
            .size());
    testNode.remove();
    session.save();
  }
Example #11
0
  @Test
  /**
   * Name of a versioned node is available in the parent history. Translator takes care of this when
   * hippo:paths is present on the node, with the parent as one of its values.
   */
  public void testVersionedNode() throws Exception {
    Node parent = session.getRootNode().addNode("test", "nt:unstructured");
    parent.addMixin("mix:versionable");
    Node child = parent.addNode("child", "nt:unstructured");
    child.addMixin("mix:versionable");
    child.setProperty("hippo:paths", new String[] {child.getUUID(), parent.getUUID()});
    session.save();
    child.checkin();
    parent.checkin();

    VersionHistory vh = child.getVersionHistory();

    parent.checkout();
    child.remove();
    session.save();
    parent.checkin();

    VersionIterator versionIter = vh.getAllVersions();
    versionIter.nextVersion(); // ignore root
    Version version = versionIter.nextVersion();

    NodeTranslator nt = new NodeTranslator(new JcrNodeModel(version.getNode("jcr:frozenNode")));
    assertEquals("child", nt.getNodeName().getObject());
    assertTrue(version.getNode("jcr:frozenNode").isNodeType("mix:referenceable"));
  }
Example #12
0
  @Override
  protected void tearDown() throws Exception {
    testRoot.remove();
    root.save();

    super.tearDown();
  }
Example #13
0
 /**
  * Tests if a node moved triggers the correct events when the former parent node is removed at the
  * same time.
  */
 public void testMoveWithRemove() throws RepositoryException {
   /**
    * Initial tree: + testroot + nodename1 + nodename2 + nodename3
    *
    * <p>After move and remove: + testroot + nodename3 + nodename2
    */
   Node n1 = testRootNode.addNode(nodeName1, testNodeType);
   Node n2 = n1.addNode(nodeName2, testNodeType);
   Node n3 = testRootNode.addNode(nodeName3, testNodeType);
   testRootNode.save();
   EventResult addNodeListener = new EventResult(log);
   EventResult removeNodeListener = new EventResult(log);
   EventResult moveNodeListener = new EventResult(log);
   addEventListener(addNodeListener, Event.NODE_ADDED);
   addEventListener(removeNodeListener, Event.NODE_REMOVED);
   addEventListener(moveNodeListener, Event.NODE_MOVED);
   // move n2
   superuser.move(n2.getPath(), n3.getPath() + "/" + nodeName2);
   // remove n1
   n1.remove();
   testRootNode.save();
   Event[] added = addNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT);
   Event[] removed = removeNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT);
   Event[] moved = moveNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT);
   removeEventListener(addNodeListener);
   removeEventListener(removeNodeListener);
   removeEventListener(moveNodeListener);
   checkNodeAdded(added, new String[] {nodeName3 + "/" + nodeName2}, null);
   checkNodeRemoved(removed, new String[] {nodeName1 + "/" + nodeName2, nodeName1}, null);
   checkNodeMoved(moved, nodeName1 + "/" + nodeName2, nodeName3 + "/" + nodeName2);
 }
 /** {@inheritDoc} */
 public void removeTemplate(
     String portletName, String category, String templateName, SessionProvider sessionProvider)
     throws Exception {
   Node templateNode = getTemplateByName(portletName, category, templateName, sessionProvider);
   Session session = templateNode.getSession();
   templateNode.remove();
   session.save();
 }
  @Override
  @After
  public void tearDown() throws Exception {
    super.tearDown();

    baseFolder.remove();
    session.save();
  }
  public void afterSuite() throws Exception {
    for (int i = 0; i < NODE_COUNT; i++) {
      root.getNode("node" + i).remove();
      session.save();
    }

    root.remove();
    session.save();
  }
Example #17
0
  @Test
  @FixFor("MODE-1751")
  public void shouldNotCauseReferentialIntegrityExceptionWhenSameReferrerUpdatedMultipleTimes()
      throws Exception {
    Node nodeA = session.getRootNode().addNode("nodeA");
    nodeA.addMixin("mix:referenceable");
    Node nodeB = session.getRootNode().addNode("nodeB");
    nodeB.setProperty("nodeA", session.getValueFactory().createValue(nodeA, false));
    session.save();

    nodeB.setProperty("nodeA", session.getValueFactory().createValue(nodeA, false));
    session.save();

    nodeB.remove();
    session.save();

    nodeA.remove();
    session.save();
  }
 public void removeAttachment(Node documentNode, String language) throws RepositoryException {
   String lang = language;
   if (lang == null) {
     lang = I18NHelper.defaultLanguage;
   }
   if (documentNode.hasNode(SimpleDocument.FILE_PREFIX + lang)) {
     Node attachmentNode = documentNode.getNode(SimpleDocument.FILE_PREFIX + lang);
     attachmentNode.remove();
   }
 }
Example #19
0
 @Override
 public void removeNode(String path) throws RemoteException {
   try {
     Node node = (Node) session().getItem(path);
     node.remove();
   } catch (PathNotFoundException e) {
     log.log(Level.FINER, e.getLocalizedMessage());
   } catch (RepositoryException e) {
     throw new RemoteException(e.getMessage());
   }
 }
Example #20
0
  /**
   * Given the relative path of a comment, delete the index for that comment.
   *
   * @param relPath the relative path of the comment.
   */
  public void delete(final String relPath, final ResourceResolver resolver)
      throws RepositoryException {
    final Resource folder = resolver.getResource(path + relPath);

    if (folder == null) {
      return;
    }

    final Node folderNode = folder.adaptTo(Node.class);
    folderNode.remove();
  }
 @Override
 public void afterEach() throws Exception {
   NodeIterator nodeIterator = session.getRootNode().getNodes();
   while (nodeIterator.hasNext()) {
     Node node = nodeIterator.nextNode();
     if (!JcrLexicon.SYSTEM.getString().equals(node.getName())) {
       node.remove();
     }
   }
   session.save();
   super.afterEach();
 }
 private Node prepNode(ResourceResolver resolver, String path) throws RepositoryException {
   // Get the encoding node, remove it (as a way to easily remove all the existing presets), then
   // create the node again
   //
   Session session = resolver.adaptTo(Session.class);
   Node targetNode =
       JcrResourceUtil.createPath(path, "nt:unstructured", "nt:unstructured", session, false);
   Node parent = targetNode.getParent();
   String nodeName = targetNode.getName();
   targetNode.remove();
   return parent.addNode(nodeName);
 }
Example #23
0
  /**
   * Test if in mode <i>sync</i>, if it prevents to remove a binary if this binary is currently a
   * payload in Workflow
   *
   * @throws Exception in case of any error
   */
  public void testSkipSameWorkflowFolder() throws Exception {
    Node aNode = getAsset(false).adaptTo(Node.class);
    aNode.remove();
    aNode.getSession().save();
    startWorkflow(WORKFLOW_ID, getTiff().getPath());
    executeWorkflowProcess(getTiff().getParent().getPath(), "mode:sync,wfModelId:" + WORKFLOW_ID);

    // thats a little wrong, as the wf was not startate by the process but
    // by this test. still one workflow for the payload witht the id must
    // exist
    checkCreated(getTiff().getPath());
  }
Example #24
0
 /** delete all of book in workspace */
 public void deleteAll() {
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   try {
     Node parentNode = getNodeByPath(DEFAULT_PARENT_PATH, sProvider);
     parentNode.remove();
     parentNode.getSession().save();
   } catch (RepositoryException e) {
     log.error("Failed to delete all book", e);
   } finally {
     sProvider.close();
   }
 }
Example #25
0
 /**
  * delete a book by book id
  *
  * @param id The id of book
  * @throws BookNotFoundException
  */
 public void deleteBook(String id) throws BookNotFoundException {
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   try {
     Node node = getNodeByPath(DEFAULT_PARENT_PATH + "/" + id, sProvider);
     node.remove();
     node.getSession().save();
   } catch (RepositoryException re) {
     log.error("Failed to delete book by id", re);
   } finally {
     sProvider.close();
   }
 }
Example #26
0
  @Test
  public void shouldHavePath() throws Exception {
    assertThat(altima.getPath(), is("/Cars/Hybrid/Nissan Altima"));

    javax.jcr.Node altima2 = hybrid.addNode("Nissan Altima");
    try {
      assertThat(altima2, is(notNullValue()));
      assertThat(altima2.getPath(), is("/Cars/Hybrid/Nissan Altima[2]"));
    } finally {
      altima2.remove(); // remove the node we added in this test to not interfere with other tests
    }
  }
Example #27
0
  @Test
  public void shouldHaveSameNameSiblingIndex() throws Exception {
    assertThat(altima.getIndex(), is(1));

    javax.jcr.Node altima2 = hybrid.addNode("Nissan Altima");
    try {
      assertThat(altima2, is(notNullValue()));
      assertThat(altima2.getIndex(), is(2));
    } finally {
      altima2.remove(); // remove the node we added in this test to not interfere with other tests
    }
  }
Example #28
0
  /**
   * Deletes the subgraph at the node with the specified id, including all descendants.
   *
   * @param request the servlet request; may not be null or unauthenticated
   * @param rawRepositoryName the URL-encoded repository name
   * @param rawWorkspaceName the URL-encoded workspace name
   * @param id the node identifier
   * @throws NotFoundException if no item exists at {@code path}
   * @throws javax.ws.rs.NotAuthorizedException if the user does not have the access required to
   *     delete the node with this id.
   * @throws RepositoryException if any other error occurs
   */
  public void deleteNodeWithId(
      HttpServletRequest request, String rawRepositoryName, String rawWorkspaceName, String id)
      throws NotFoundException, NotAuthorizedException, RepositoryException {

    assert rawRepositoryName != null;
    assert rawWorkspaceName != null;
    assert id != null;

    Session session = getSession(request, rawRepositoryName, rawWorkspaceName);
    Node node = nodeWithId(id, session);
    node.remove();
    session.save();
  }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.DeleteBranchRequest)
  */
 @Override
 public void process(DeleteBranchRequest request) {
   if (request == null) return;
   try {
     Workspace workspace = workspaceFor(request.inWorkspace());
     Node node = workspace.node(request.at());
     Location actual = workspace.locationFor(node);
     node.remove();
     request.setActualLocationOfNode(actual);
   } catch (Throwable e) {
     request.setError(e);
   }
 }
Example #30
0
  @Test
  public void removingProjectionViaNodeRemoveShouldDeleteExternalNodes() throws Exception {
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "projection1");
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "projection2");

    Node projection1 = assertNodeFound("/testRoot/projection1/federated3");
    assertNodeFound("/testRoot/projection2/federated3");

    projection1.remove();
    session.save();
    assertNodeNotFound("/testRoot/projection2/federated3");
  }