private List<RepositoryFile> legacyGetDeletedFiles( final Session session, final PentahoJcrConstants pentahoJcrConstants, final String origParentFolderPath, final String filter) throws RepositoryException { List<RepositoryFile> deletedFiles = new ArrayList<RepositoryFile>(); Node trashFolderIdNode = legacyGetTrashFolderIdNode(session, pentahoJcrConstants, origParentFolderPath); if (trashFolderIdNode == null) { return Collections.emptyList(); } NodeIterator nodes = trashFolderIdNode.getNodes(); while (nodes.hasNext()) { Node trashFileIdNode = nodes.nextNode(); NodeIterator trashFileIdNodes = null; if (filter != null) { trashFileIdNodes = trashFileIdNode.getNodes(filter); } else { trashFileIdNodes = trashFileIdNode.getNodes(); } if (trashFileIdNodes.hasNext()) { deletedFiles.add( nodeToDeletedFile(session, pentahoJcrConstants, trashFileIdNodes.nextNode())); } } return deletedFiles; }
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(); } }
@Test @FixFor("MODE-1489") public void shouldAllowMultipleOrderBeforeWithoutSave() throws Exception { int childCount = 2; Node parent = session.getRootNode().addNode("parent", "nt:unstructured"); for (int i = 0; i < childCount; i++) { parent.addNode("Child " + i, "nt:unstructured"); } session.save(); long childIdx = 0; NodeIterator nodeIterator = parent.getNodes(); while (nodeIterator.hasNext()) { parent.orderBefore("Child " + childIdx, "Child 0"); childIdx++; nodeIterator.nextNode(); } session.save(); nodeIterator = parent.getNodes(); childIdx = nodeIterator.getSize() - 1; while (nodeIterator.hasNext()) { Node child = nodeIterator.nextNode(); assertEquals("Child " + childIdx, child.getName()); childIdx--; } }
@Test public void shouldCreateProjectionWithAlias() throws Exception { // add an internal node testRoot.addNode("node1"); session.save(); // link the first external document federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "federated1"); assertEquals(2, testRoot.getNodes().getSize()); Node doc1Federated = assertNodeFound("/testRoot/federated1"); assertEquals(testRoot.getIdentifier(), doc1Federated.getParent().getIdentifier()); assertEquals("a string", doc1Federated.getProperty("federated1_prop1").getString()); assertEquals(12, doc1Federated.getProperty("federated1_prop2").getLong()); // link a second external document with a sub-child federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2"); assertEquals(3, testRoot.getNodes().getSize()); Node doc2Federated = assertNodeFound("/testRoot/federated2"); assertEquals(testRoot.getIdentifier(), doc2Federated.getParent().getIdentifier()); assertEquals("another string", doc2Federated.getProperty("federated2_prop1").getString()); assertEquals(false, doc2Federated.getProperty("federated2_prop2").getBoolean()); Node doc2FederatedChild = assertNodeFound("/testRoot/federated2/federated3"); assertEquals( "yet another string", doc2FederatedChild.getProperty("federated3_prop1").getString()); }
/** {@inheritDoc} */ public List<RepositoryFile> getDeletedFiles( final Session session, final PentahoJcrConstants pentahoJcrConstants) throws RepositoryException { Node trashNode = getOrCreateTrashInternalFolderNode(session, pentahoJcrConstants); if (trashNode == null) { return Collections.emptyList(); } List<RepositoryFile> deletedFiles = new ArrayList<RepositoryFile>(); NodeIterator nodes = trashNode.getNodes(); while (nodes.hasNext()) { Node trashFileNode = nodes.nextNode(); // since the nodes returned are the trash file ID nodes, // we need to getNodes().nextNode() to get its first (and only) child if (trashFileNode != null && trashFileNode.hasProperty(pentahoJcrConstants.getPHO_DELETEDDATE())) { NodeIterator trashFileNodeIterator = trashFileNode.getNodes(); if (trashFileNodeIterator.hasNext()) { deletedFiles.add( nodeToDeletedFile(session, pentahoJcrConstants, trashFileNodeIterator.nextNode())); } } } Collections.sort(deletedFiles); return deletedFiles; }
private void nextTopNode() throws RepositoryException { topNode = nextDirNode(topIterator); if (topNode != null) { midIterator = topNode.getNodes(); midNode = nextDirNode(midIterator); if (midNode != null) { bottomIterator = midNode.getNodes(); } } }
/** * see https://issues.jboss.org/browse/MODE-1953 * * @throws Exception */ @Test public void testGetNodesMethod() throws Exception { Node jcrRootNode = ((Session) session).getRootNode(); Node rootNode = jcrRootNode.addNode("mapSuperclassTest"); Node newNode = rootNode.addNode("newNode"); NodeIterator nodeIterator = rootNode.getNodes("myMap"); assertFalse(nodeIterator.hasNext()); session.save(); nodeIterator = rootNode.getNodes("myMap"); assertFalse(nodeIterator.hasNext()); }
@Test public void shouldReturnEmptyIterator() throws RepositoryException { Node jcrRootNode = session.getRootNode(); Node rootNode = jcrRootNode.addNode("mapSuperclassTest"); // session.save(); Node newNode = rootNode.addNode("newNode"); assertNotNull(newNode); NodeIterator nodeIterator = rootNode.getNodes("myMap"); assertFalse(nodeIterator.hasNext()); session.save(); nodeIterator = rootNode.getNodes("myMap"); assertFalse(nodeIterator.hasNext()); }
/** * Get node nt:file if node support multi-language * * @param currentNode Current Node * @return Node which has type nt:file * @throws Exception */ public static Node getFileLangNode(Node currentNode) throws Exception { if (currentNode.isNodeType(NT_UNSTRUCTURED)) { if (currentNode.getNodes().getSize() > 0) { NodeIterator nodeIter = currentNode.getNodes(); while (nodeIter.hasNext()) { Node ntFile = nodeIter.nextNode(); if (ntFile.getPrimaryNodeType().getName().equals(NT_FILE)) { return ntFile; } } return currentNode; } } return currentNode; }
protected void activate(final ComponentContext ctx) { if (TMP_DIR != null) { File tmpDir = new File(TMP_DIR); fontsDir = new File(tmpDir, "fonts." + UUID.randomUUID()); fontsDir.mkdir(); fontsDir.deleteOnExit(); Session session = null; try { session = repo.loginAdministrative(repo.getDefaultWorkspace()); if (session.nodeExists(FONT_CONFIG)) { configFile = createFile(session.getNode(FONT_CONFIG)); } if (session.nodeExists(FONT_CONFIG_FONTS)) { Node fonts = session.getNode(FONT_CONFIG_FONTS); NodeIterator children = fonts.getNodes(); while (children.hasNext()) { createFile((Node) children.next()); } } } catch (RepositoryException e) { logger.error("Failed exporting FOP font data.", e); } finally { if (session != null) { session.logout(); } } } }
private static void traverseNodes(Node node, int currentLevel) throws Exception { System.out.println(node.getPath()); NodeIterator children = node.getNodes(); while (children.hasNext()) { traverseNodes(children.nextNode(), currentLevel + 1); } }
/** Recursively outputs the contents of the given node. */ private static void dump(Node node) throws RepositoryException { // First output the node path System.out.println(node.getPath()); // Skip the virtual (and large!) jcr:system subtree if (node.getName().equals("jcr:system")) { return; } // Then output the properties PropertyIterator properties = node.getProperties(); while (properties.hasNext()) { Property property = properties.nextProperty(); if (property.getDefinition().isMultiple()) { // A multi-valued property, print all values Value[] values = property.getValues(); for (int i = 0; i < values.length; i++) { System.out.println(property.getPath() + " = " + values[i].getString()); } } else { // A single-valued property System.out.println(property.getPath() + " = " + property.getString()); } } // Finally output all the child nodes recursively NodeIterator nodes = node.getNodes(); while (nodes.hasNext()) { dump(nodes.nextNode()); } }
private void checkCustomProperties(Session session) throws javax.jcr.RepositoryException { NodeTypeManager nodetypeManager = new NodeTypeManager(); // Check and create required custom properties javax.jcr.Node systemNode = JCRUtils.getSystemNode(session); if (systemNode.hasNode(JLibraryConstants.JLIBRARY_CUSTOM_PROPERTIES)) { javax.jcr.Node propertiesNode = systemNode.getNode(JLibraryConstants.JLIBRARY_CUSTOM_PROPERTIES); NodeIterator it = propertiesNode.getNodes(); while (it.hasNext()) { javax.jcr.Node propsNode = (javax.jcr.Node) it.next(); CustomPropertyDefinition propdef = new CustomPropertyDefinition(); propdef.setName( propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_NAME).getString()); propdef.setType( (int) propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_TYPE).getLong()); propdef.setMultivalued( propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_MULTIVALUED).getBoolean()); propdef.setAutocreated( propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_AUTOCREATED).getBoolean()); if (propsNode.hasProperty(JLibraryConstants.JLIBRARY_PROPERTY_DEFAULT)) { propdef.setDefaultValues( propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_DEFAULT).getValues()); } logger.info("Registering property : " + propdef); nodetypeManager.registerCustomProperty(session, propdef); } } }
public void execute(WorkItem item, WorkflowSession session, MetaDataMap args) throws WorkflowException { WorkflowData workflowData = item.getWorkflowData(); log.info("==================== <> ======================"); Iterator props = args.entrySet().iterator(); String pathToArchive = args.get("PROCESS_ARGS", String.class); if (pathToArchive != null) if (workflowData.getPayloadType().equals(TYPE_JCR_PATH)) { String path = workflowData.getPayload().toString(); try { Node node = (Node) session.getSession().getItem(path + "/jcr:content"); String orderBy = node.getProperty("orderby").getString(); log.info("----------orderby: " + orderBy); Node nodeToOrder = (Node) session.getSession().getItem(pathToArchive); Iterator<Node> iterator = nodeToOrder.getNodes(); List<Node> nodes = copyIterator(iterator); Collections.sort(nodes, new NodeComparator(orderBy)); for (Node orderNode : nodes) { session .getSession() .getWorkspace() .move( pathToArchive + "/" + orderNode.getName(), pathToArchive + "/" + orderNode.getName()); } } catch (RepositoryException e) { throw new WorkflowException(e.getMessage(), e); } } }
@Test public void ferrari_has_four_wheels() throws RepositoryException { Node ferrari = session.getNode("/cars/ferrari"); NodeIterator nodeIterator = ferrari.getNodes("catalog:wheel"); assertThat(nodeIterator.getSize(), is(4L)); }
@Test public void ferrari_has_two_doors() throws RepositoryException { Node ferrari = session.getNode("/cars/ferrari"); NodeIterator nodeIterator = ferrari.getNodes("catalog:door"); assertThat(nodeIterator.getSize(), is(2L)); }
public static NodeIterator getAuthorizedChildNodes(Node node) throws Exception { NodeIterator iter = node.getNodes(); while (iter.hasNext()) { if (!PermissionUtil.canRead(iter.nextNode())) iter.remove(); } return iter; }
public String[] getFileNames(long companyId, long repositoryId) throws SystemException { List<String> fileNames = new ArrayList<String>(); Session session = null; try { session = JCRFactoryUtil.createSession(); Node rootNode = getRootNode(session, companyId); Node repositoryNode = getFolderNode(rootNode, repositoryId); NodeIterator itr = repositoryNode.getNodes(); while (itr.hasNext()) { Node node = (Node) itr.next(); NodeType primaryNodeType = node.getPrimaryNodeType(); String primaryNodeTypeName = primaryNodeType.getName(); if (primaryNodeTypeName.equals(JCRConstants.NT_FILE)) { fileNames.add(node.getName()); } } } catch (Exception e) { throw new SystemException(e); } finally { JCRFactoryUtil.closeSession(session); } return fileNames.toArray(new String[0]); }
private void purgeHistory(Node fileNode, Session session, PentahoJcrConstants pentahoJcrConstants) throws RepositoryException { // Delete all previous versions of this node VersionManager versionManager = session.getWorkspace().getVersionManager(); if (JcrRepositoryFileUtils.isPentahoFolder(pentahoJcrConstants, fileNode)) { // go down to children NodeIterator nodes = fileNode.getNodes(); while (nodes.hasNext()) { Node next = (Node) nodes.next(); purgeHistory(next, session, pentahoJcrConstants); } } else if (JcrRepositoryFileUtils.isPentahoFile(pentahoJcrConstants, fileNode) && fileNode.isNodeType(pentahoJcrConstants.getPHO_MIX_VERSIONABLE())) { VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath()); VersionIterator allVersions = versionHistory.getAllVersions(); while (allVersions.hasNext()) { Version next = (Version) allVersions.next(); String name = next.getName(); // Root version cannot be deleted, the remove below will take care of that. if (!JCR_ROOT_VERSION.equals(name)) { versionHistory.removeVersion(name); } } } }
@Override public List<JcrNode> childNodes(String path) throws RemoteException { List<JcrNode> children = null; if (path == null || path.trim().length() == 0) { return Collections.emptyList(); } try { Node node = (Node) session().getItem(path); NodeIterator it = node.getNodes(); children = new ArrayList<JcrNode>((int) it.getSize()); while (it.hasNext()) { Node n = it.nextNode(); JcrNode childNode = new JcrNode(n.getName(), n.getPath(), n.getPrimaryNodeType().getName()); childNode.setProperties(getProperties(n)); childNode.setAcessControlList(getAccessList(session().getAccessControlManager(), node)); childNode.setMixins(mixins(n)); childNode.setPropertyDefs(propertyDefs(n)); children.add(childNode); } } catch (PathNotFoundException e) { log.log(Level.FINER, e.getLocalizedMessage()); } catch (RepositoryException e) { log.log(Level.SEVERE, "Unexpected error", e); throw new RemoteException(e.getMessage()); } return children; }
/** * {@inheritDoc} * * @see * org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.ReadAllPropertiesRequest) */ @Override public void process(ReadAllPropertiesRequest request) { if (request == null) return; try { Workspace workspace = workspaceFor(request.inWorkspace()); Node node = workspace.node(request.at()); Location actualLocation = workspace.locationFor(node); request.setActualLocationOfNode(actualLocation); // Read the properties ... for (PropertyIterator iter = node.getProperties(); iter.hasNext(); ) { request.addProperty(workspace.propertyFor(iter.nextProperty())); } // Add in the 'jcr:uuid' property ... if (actualLocation.hasIdProperties()) { request.addProperty(workspace.propertyFor(ModeShapeLexicon.UUID, actualLocation.getUuid())); } // Get the number of children ... NodeIterator childIter = node.getNodes(); int numChildren = (int) childIter.getSize(); if (numChildren == -1) { numChildren = 0; while (childIter.hasNext()) { childIter.nextNode(); ++numChildren; } } request.setNumberOfChildren(numChildren); setCacheableInfo(request); } catch (Throwable e) { request.setError(e); } }
/** * {@inheritDoc} * * @see * org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.ReadNodeRequest) */ @Override public void process(ReadNodeRequest request) { if (request == null) return; try { Workspace workspace = workspaceFor(request.inWorkspace()); Node node = workspace.node(request.at()); Location actualLocation = workspace.locationFor(node); request.setActualLocationOfNode(actualLocation); // Read the children ... for (NodeIterator iter = node.getNodes(); iter.hasNext(); ) { request.addChild(workspace.locationFor(iter.nextNode())); } // Read the properties ... for (PropertyIterator iter = node.getProperties(); iter.hasNext(); ) { request.addProperty(workspace.propertyFor(iter.nextProperty())); } // Add in the 'jcr:uuid' property ... if (actualLocation.hasIdProperties()) { request.addProperty(workspace.propertyFor(ModeShapeLexicon.UUID, actualLocation.getUuid())); } setCacheableInfo(request); } catch (Throwable e) { request.setError(e); } }
/** Dump given node in JSON, optionally recursing into its child nodes */ protected void dump(Node node, JSONWriter w, int currentRecursionLevel, int maxRecursionLevels) throws RepositoryException, JSONException { w.object(); PropertyIterator props = node.getProperties(); // the node's actual properties while (props.hasNext()) { Property prop = props.nextProperty(); if (propertyNamesToIgnore != null && propertyNamesToIgnore.contains(prop.getName())) { continue; } writeProperty(w, prop); } // the child nodes if (recursionLevelActive(currentRecursionLevel, maxRecursionLevels)) { final NodeIterator children = node.getNodes(); while (children.hasNext()) { final Node n = children.nextNode(); dumpSingleNode(n, w, currentRecursionLevel, maxRecursionLevels); } } w.endObject(); }
private void listChildren(String indent, Node node, PrintStream out) throws RepositoryException { out.println(indent + node.getName() + ""); out.println(node.getPath()); NodeIterator ni = node.getNodes(); while (ni.hasNext()) { listChildren(indent + " ", ni.nextNode(), out); } }
/* (non-Javadoc) * @see junit.framework.TestCase#tearDown() */ public void tearDown() throws Exception { super.tearDown(); Node sharedPortalNode = (Node) session.getItem("/sites content/live/shared/js"); NodeIterator nodeIterator = documentNode.getNodes(); NodeIterator sharedNode = sharedJsNode.getNodes(); NodeIterator sharedIterator = sharedPortalNode.getNodes(); while (nodeIterator.hasNext()) { nodeIterator.nextNode().remove(); } while (sharedNode.hasNext()) { sharedNode.nextNode().remove(); } while (sharedIterator.hasNext()) { sharedIterator.nextNode().remove(); } session.save(); }
public void setRoleBindings( Session session, ITenant tenant, String runtimeRoleName, List<String> logicalRoleNames) throws NamespaceException, RepositoryException { if (tenant == null) { tenant = JcrTenantUtils.getTenant(runtimeRoleName, false); runtimeRoleName = getPrincipalName(runtimeRoleName); } if (!TenantUtils.isAccessibleTenant(tenant)) { throw new NotFoundException("Tenant " + tenant.getId() + " not found"); } PentahoJcrConstants pentahoJcrConstants = new PentahoJcrConstants(session); final String phoNsPrefix = session.getNamespacePrefix(PentahoJcrConstants.PHO_NS) + ":"; // $NON-NLS-1$ final String onlyPentahoPattern = phoNsPrefix + "*"; // $NON-NLS-1$ Node runtimeRolesFolderNode = getRuntimeRolesFolderNode(session, tenant); NodeIterator runtimeRoleNodes = runtimeRolesFolderNode.getNodes(onlyPentahoPattern); int i = 0; while (runtimeRoleNodes.hasNext()) { runtimeRoleNodes.nextNode(); i++; } if (i == 0) { // no bindings setup yet; install bootstrap bindings; bootstrapRoleBindings will now no longer // be // consulted for (Map.Entry<String, List<String>> entry : bootstrapRoleBindings.entrySet()) { JcrRoleAuthorizationPolicyUtils.internalSetBindings( pentahoJcrConstants, runtimeRolesFolderNode, entry.getKey(), entry.getValue(), phoNsPrefix); } } if (!isImmutable(runtimeRoleName)) { JcrRoleAuthorizationPolicyUtils.internalSetBindings( pentahoJcrConstants, runtimeRolesFolderNode, runtimeRoleName, logicalRoleNames, phoNsPrefix); } else { throw new RuntimeException( Messages.getInstance() .getString( "JcrRoleAuthorizationPolicyRoleBindingDao.ERROR_0001_ATTEMPT_MOD_IMMUTABLE", runtimeRoleName)); //$NON-NLS-1$ } session.save(); Assert.isTrue(NodeHelper.hasNode(runtimeRolesFolderNode, phoNsPrefix, runtimeRoleName)); // update cache String roleId = tenantedRoleNameUtils.getPrincipleId(tenant, runtimeRoleName); cacheManager.putInRegionCache(LOGICAL_ROLE_BINDINGS_REGION, roleId, logicalRoleNames); }
public static List<Node> getAuthorizedChildList(Node node) throws Exception { List<Node> children = new ArrayList<Node>(); NodeIterator iter = node.getNodes(); while (iter.hasNext()) { Node child = iter.nextNode(); if (PermissionUtil.canRead(child)) children.add(child); } return children; }
@Test public void shouldCreateProjectionWithoutAlias() throws Exception { // link the first external document federationManager.createProjection("/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, null); assertEquals(1, testRoot.getNodes().getSize()); Node doc1Federated = assertNodeFound("/testRoot" + MockConnector.DOC1_LOCATION); assertEquals(testRoot.getIdentifier(), doc1Federated.getParent().getIdentifier()); assertEquals("a string", doc1Federated.getProperty("federated1_prop1").getString()); assertEquals(12, doc1Federated.getProperty("federated1_prop2").getLong()); }
private ModelEMFResource getEMFResource(ModelId modelId) { try { Node folderNode = session.getNode(modelId.getFullPath()); Node fileNode = (Node) folderNode.getNodes().next(); Node fileItem = (Node) fileNode.getPrimaryItem(); InputStream is = fileItem.getProperty("jcr:data").getBinary().getStream(); return (ModelEMFResource) ModelParserFactory.getParser(fileNode.getName()).parse(is); } catch (Exception e) { throw new FatalModelRepositoryException("Something went wrong accessing the repository", e); } }
/** {@inheritDoc} */ public List<Node> getTemplatesByCategory( String portletName, String category, SessionProvider sessionProvider) throws Exception { Node basedApplicationTemplateHome = getBasedApplicationTemplatesHome(sessionProvider); Node applicationHome = basedApplicationTemplateHome.getNode(portletName); Node categoryNode = applicationHome.getNode(category); List<Node> templateNodes = new ArrayList<Node>(); for (NodeIterator iterator = categoryNode.getNodes(); iterator.hasNext(); ) { templateNodes.add(iterator.nextNode()); } return templateNodes; }