/** {@inheritDoc} */ public RemoteNodeDefinition[] getChildNodeDefs() throws RemoteException { return getRemoteNodeDefArray(type.getChildNodeDefinitions()); }
/** * Returns a name that is not defined by the nodeType's child node def */ public static String getUndefinedChildNodeName(NodeType nodeType) { NodeDefinition nodeDefs[] = nodeType.getChildNodeDefinitions(); StringBuffer s = new StringBuffer("X"); for (int i = 0; i < nodeDefs.length; i++) { s.append(nodeDefs[i].getName()); } String undefinedName = s.toString(); undefinedName = undefinedName.replaceAll("\\*", ""); undefinedName = undefinedName.replaceAll(":", ""); return undefinedName; }
private static NodeDefinition[] getAggregatedNodeDefinitions(Node node) throws RepositoryException { Set<NodeDefinition> cDefs = newHashSet(); NodeDefinition[] nd = node.getPrimaryNodeType().getChildNodeDefinitions(); cDefs.addAll(Arrays.asList(nd)); NodeType[] mixins = node.getMixinNodeTypes(); for (NodeType mixin : mixins) { nd = mixin.getChildNodeDefinitions(); cDefs.addAll(Arrays.asList(nd)); } return cDefs.toArray(new NodeDefinition[cDefs.size()]); }
private static boolean isAutoCreatedNode(final String childName, Node parent) throws RepositoryException { for (NodeDefinition nodeDefinition : parent.getPrimaryNodeType().getChildNodeDefinitions()) { if (childName.equals(nodeDefinition.getName())) { if (nodeDefinition.isAutoCreated()) { return true; } } } for (NodeType nodeType : parent.getMixinNodeTypes()) { for (NodeDefinition nodeDefinition : nodeType.getChildNodeDefinitions()) { if (childName.equals(nodeDefinition.getName())) { if (nodeDefinition.isAutoCreated()) { return true; } } } } return false; }
/** * Checks if mandatory node definitions are respected. */ private void checkMandatoryConstraint(Node node, NodeType type) throws RepositoryException { // test if node contains all mandatory nodes of current type NodeDefinition nodeDefs[] = type.getChildNodeDefinitions(); for (int i = 0; i < nodeDefs.length; i++) { NodeDefinition nodeDef = nodeDefs[i]; if (nodeDef.isMandatory()) { foundMandatoryNode = true; try { node.getNode(nodeDef.getName()); } catch (PathNotFoundException e) { fail("Mandatory child " + nodeDef.getName() + " for " + node.getPath() + " does not exist."); } } } }
/** * {@inheritDoc} * * Returns {@code true} if the item is a node of type nt:hierarchyNode * that has or defines a 'jcr:content' child node. */ public boolean matches(Item item) throws RepositoryException { if (item.isNode()) { Node node = (Node) item; if (node.isNodeType(JcrConstants.NT_HIERARCHYNODE)) { if (node.hasNode(JcrConstants.JCR_CONTENT)) { return true; } else { for (NodeDefinition pd: node.getPrimaryNodeType().getChildNodeDefinitions()) { if (pd.getName().equals(JcrConstants.JCR_CONTENT)) { return true; } } } } } return false; }
/** * Tests that the information from getRequiredPrimaryTypeNames() * matches getRequiredPrimaryTypes(). * * @since JCR 2.0 */ public void testGetRequiredPrimaryTypeNames() throws RepositoryException { // loop all node types for (NodeTypeIterator types = manager.getAllNodeTypes(); types.hasNext(); ) { NodeType type = types.nextNodeType(); NodeDefinition defs[] = type.getChildNodeDefinitions(); for (int i = 0; i < defs.length; i++) { NodeType requiredPrimaryTypes[] = defs[i].getRequiredPrimaryTypes(); Set<String> rptnames = new HashSet<String>(); for (int j = 0; j < requiredPrimaryTypes.length; j++) { rptnames.add(requiredPrimaryTypes[j].getName()); } Set<String> rptnames2 = new HashSet<String>(Arrays.asList(defs[i].getRequiredPrimaryTypeNames())); assertEquals("names returned from getRequiredPrimaryTypeNames should match types returned from getRequiredPrimaryTypes", rptnames, rptnames2); } } }
@Test public void returnTrueWhenAllDefinitionsOK() throws Exception { // WHEN when(nodeType.getChildNodeDefinitions()).thenReturn(notAllowing); // THEN assertTrue("NoSameNameSiblingsCondition should return true when the sameNameSinglings are not allowed.", condition.check(ctx)); }
@Test public void returnFalseWhenSameNameSiblingsAllowed() throws Exception { // WHEN when(nodeType.getChildNodeDefinitions()).thenReturn(allowing); // THEN assertFalse("NoSameNameSiblingsCondition should return false when the sameNameSinglings are allowed.", condition.check(ctx)); }
private void visit(String namespacePrefix, NodeType nt, HashSet<String> visited, LinkedHashSet<QNodeTypeDefinition> result) { if (visited.contains(nt.getName())) { return; } visited.add(nt.getName()); for (NodeType superType : nt.getSupertypes()) { visit(namespacePrefix, superType, visited, result); } for (NodeDefinition nd : nt.getChildNodeDefinitions()) { for (NodeType childType : nd.getRequiredPrimaryTypes()) { visit(namespacePrefix, childType, visited, result); } NodeType defaultPriType = nd.getDefaultPrimaryType(); if (defaultPriType != null) { visit(namespacePrefix, defaultPriType, visited, result); } } if (nt.getName().startsWith(namespacePrefix + ":")) { result.add(((AbstractNodeType)nt).getDefinition()); } }
/** * Tests if auto create nodes are not a residual set definition (getName() * does not return "*") */ public void testIsAutoCreate() throws RepositoryException { NodeTypeIterator types = manager.getAllNodeTypes(); // loop all node types while (types.hasNext()) { NodeType type = types.nextNodeType(); NodeDefinition defs[] = type.getChildNodeDefinitions(); for (int i = 0; i < defs.length; i++) { if (defs[i].isAutoCreated()) { assertFalse("An auto create node must not be a " + "residual set definition.", defs[i].getName().equals("*")); } } } }
/** * Tests if getRequiredPrimaryTypes() does not return an empty array. Test * runs for all existing node types. */ public void testGetRequiredPrimaryTypes() throws RepositoryException { // loop all node types for (NodeTypeIterator types = manager.getAllNodeTypes(); types.hasNext(); ) { NodeType type = types.nextNodeType(); NodeDefinition defs[] = type.getChildNodeDefinitions(); for (int i = 0; i < defs.length; i++) { assertTrue("getRequiredPrimaryTypes() must never return an " + "empty array.", defs[i].getRequiredPrimaryTypes().length > 0); } } }
private void writeNodeType(NodeType nt, CNDWriter w, Set<String> written) throws IOException, RepositoryException { if (nt != null && !written.contains(nt.getName())) { written.add(nt.getName()); w.write(nt); for (NodeType s: nt.getSupertypes()) { writeNodeType(s, w, written); } for (NodeDefinition n: nt.getChildNodeDefinitions()) { writeNodeType(n.getDefaultPrimaryType(), w, written); if (n.getRequiredPrimaryTypes() != null) { for (NodeType r: n.getRequiredPrimaryTypes()) { writeNodeType(r, w, written); } } } } }
private void importTestNodeTypes() throws IOException, InvalidNodeTypeDefException, RepositoryException { // import some test node types that contain a node def with sameNameSiblings="false" InputStream xml = getClass().getClassLoader().getResourceAsStream(TEST_NODETYPES); QNodeTypeDefinition[] ntDefs = NodeTypeReader.read(xml); NodeTypeRegistry ntReg = ((SessionImpl) superuser).getNodeTypeManager().getNodeTypeRegistry(); if (!ntReg.isRegistered(ntDefs[0].getName())) { ntReg.registerNodeTypes(Arrays.asList(ntDefs)); } // make sure the node def is there as required for our test NodeTypeManager ntm = superuser.getWorkspace().getNodeTypeManager(); NodeType nodeType = ntm.getNodeType("test:childNodeType"); NodeDefinition[] childNodeDefinitions = nodeType.getChildNodeDefinitions(); boolean foundRequiredDef = false; for (NodeDefinition nodeDefinition : childNodeDefinitions) { String nodeDefName = nodeDefinition.getName(); if (nodeDefName.equals("test:defaultTypeNode") && !nodeDefinition.allowsSameNameSiblings()) { foundRequiredDef = true; break; } } assertTrue(TEST_NODETYPES + " has changed? Expected child node def 'test:defaultTypeNode' with sameNameSiblings=false", foundRequiredDef); } }
@Override public void checkMandatoryItems(Tree tree) throws ConstraintViolationException { for (NodeType nodeType : nodeTypes.values()) { for (PropertyDefinition pd : nodeType.getPropertyDefinitions()) { String name = pd.getName(); if (pd.isMandatory() && !pd.isProtected() && tree.getProperty(name) == null) { throw new ConstraintViolationException( "Property '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } for (NodeDefinition nd : nodeType.getChildNodeDefinitions()) { String name = nd.getName(); if (nd.isMandatory() && !nd.isProtected() && !tree.hasChild(name)) { throw new ConstraintViolationException( "Node '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } } }
private static void assertAutoCreatedItems(@NotNull Tree authorizableTree, @NotNull String ntName, @NotNull Root root) throws Exception { NodeType repUser = ReadOnlyNodeTypeManager.getInstance(root, NamePathMapper.DEFAULT).getNodeType(ntName); for (NodeDefinition cnd : repUser.getChildNodeDefinitions()) { if (cnd.isAutoCreated()) { assertTrue(authorizableTree.hasChild(cnd.getName())); } } for (PropertyDefinition pd : repUser.getPropertyDefinitions()) { if (pd.isAutoCreated()) { assertTrue(authorizableTree.hasProperty(pd.getName())); } } } }
@Override public void checkMandatoryItems(Tree tree) throws ConstraintViolationException { for (NodeType nodeType : nodeTypes.values()) { for (PropertyDefinition pd : nodeType.getPropertyDefinitions()) { String name = pd.getName(); if (pd.isMandatory() && !pd.isProtected() && tree.getProperty(name) == null) { throw new ConstraintViolationException( "Property '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } for (NodeDefinition nd : nodeType.getChildNodeDefinitions()) { String name = nd.getName(); if (nd.isMandatory() && !nd.isProtected() && !tree.hasChild(name)) { throw new ConstraintViolationException( "Node '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } } }
@Override public void checkMandatoryItems(Tree tree) throws ConstraintViolationException { for (NodeType nodeType : nodeTypes.values()) { for (PropertyDefinition pd : nodeType.getPropertyDefinitions()) { String name = pd.getName(); if (pd.isMandatory() && !pd.isProtected() && tree.getProperty(name) == null) { throw new ConstraintViolationException( "Property '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } for (NodeDefinition nd : nodeType.getChildNodeDefinitions()) { String name = nd.getName(); if (nd.isMandatory() && !nd.isProtected() && !tree.hasChild(name)) { throw new ConstraintViolationException( "Node '" + name + "' in '" + nodeType.getName() + "' is mandatory"); } } } }
@Override protected void setUp() throws Exception { super.setUp(); NodeType nt = superuser.getWorkspace().getNodeTypeManager().getNodeType(testNodeType); NodeDefinition[] ndefs = nt.getChildNodeDefinitions(); for (int i = 0; i < ndefs.length; i++) { if (ndefs[i].isMandatory() && !ndefs[i].isProtected() && !ndefs[i].isAutoCreated()) { childNodeDef = ndefs[i]; break; } } PropertyDefinition[] pdefs = nt.getPropertyDefinitions(); for (int i = 0; i < pdefs.length; i++) { if (pdefs[i].isMandatory() && !pdefs[i].isProtected() && !pdefs[i].isAutoCreated()) { childPropDef = pdefs[i]; break; } } if (childPropDef == null && childNodeDef == null) { cleanUp(); throw new NotExecutableException(); } }
@Test public void customNodeTypesAreRegistered() throws RepositoryException { final JackrabbitSession adminSession = createAdminSession(); final NodeTypeManager nodeTypeManager = adminSession.getWorkspace().getNodeTypeManager(); final NodeType testFolderNodeType = nodeTypeManager.getNodeType("test:Folder"); final NodeDefinition[] cnd = testFolderNodeType.getChildNodeDefinitions(); final PropertyDefinition[] pd = testFolderNodeType.getPropertyDefinitions(); assertEquals("More than one child node definition", 1, cnd.length); assertEquals("Incorrect default primary type", "test:Folder", cnd[0].getDefaultPrimaryTypeName()); assertEquals("More than two property definitions", 4, pd.length); adminSession.logout(); } }