private boolean resolveNext() { NodeType[] superTypes = this.current.getDeclaredSupertypes(); if (superTypes != null && superTypes.length != 0) { queue.addAll(asList(superTypes)); } if (!queue.isEmpty()) { this.next = this.queue.poll(); } return this.next != null; }
/** {@inheritDoc} */ public RemoteNodeType[] getDeclaredSupertypes() throws RemoteException { return getRemoteNodeTypeArray(type.getDeclaredSupertypes()); }
public static boolean isLockable(Node node) { try { return Arrays.stream(node.getPrimaryNodeType().getDeclaredSupertypes()) .filter(type -> type.isNodeType("mix:lockable")) .findAny() .isPresent(); } catch (RepositoryException e) { throw new MetadataRepositoryException("Could not determine node types of " + node, e); } }
mixinTypes.stream().map(mixin -> orderedBy(BY_NAME).add(mixin.getDeclaredSupertypes()).build()) .forEach(nodeTypesB::addAll);
public Iterator<ITypeDescriptor> find(Map<String, Object> criteria) throws StoreException { List<ITypeDescriptor> result = new LinkedList<ITypeDescriptor>(); if (criteria.containsKey("namespace")) { return getTypes((String) criteria.get("namespace")).iterator(); } if (criteria.containsKey("supertype")) { Set<String> types = new HashSet<String>((List<String>) criteria.get("supertype")); try { Session session = UserSession.get().getJcrSession(); NodeTypeManager ntMgr = session.getWorkspace().getNodeTypeManager(); NodeTypeIterator ntIter = ntMgr.getAllNodeTypes(); while (ntIter.hasNext()) { NodeType nt = ntIter.nextNodeType(); for (NodeType superType : nt.getDeclaredSupertypes()) { String name = superType.getName(); if (types.contains(name)) { result.add(locator.locate(nt.getName())); break; } } } } catch (RepositoryException e) { throw new StoreException("Could not find supertypes", e); } } return result.iterator(); }
/** * Test if all node types returned by getDeclaredSupertypes() are also * returned by getSupertypes(). All existing node types are tested. */ public void testGetDeclaredSupertypes() throws RepositoryException { for (NodeTypeIterator types = manager.getAllNodeTypes(); types.hasNext(); ) { NodeType type = types.nextNodeType(); Set<String> declaredSupertypeNames = asSetOfNames(type.getDeclaredSupertypes()); Set<String> supertypeNames = asSetOfNames(type.getSupertypes()); assertTrue("all declared supertypes must be supertypes: " + (new HashSet<String>(declaredSupertypeNames).removeAll(supertypeNames)), supertypeNames.containsAll(declaredSupertypeNames)); assertEquals("getDeclaredSuperTypes and getDeclaredSuperTypeNames must be consistent", declaredSupertypeNames, new HashSet<String>(Arrays.asList(type.getDeclaredSupertypeNames()))); } }
@Override public ExtensibleType getSupertype() { try { for (NodeType parent : this.nodeType.getDeclaredSupertypes()) { if (parent.isNodeType(ExtensionsConstants.EXTENSIBLE_ENTITY_TYPE) && !parent.getName().equals(ExtensionsConstants.EXTENSIBLE_ENTITY_TYPE)) { Node supertypeNode = this.typeNode.getParent().getNode(parent.getName()); return new JcrExtensibleType(supertypeNode, parent); } } } catch (RepositoryException e) { throw new MetadataRepositoryException("Unable to get parent type for type: " + this.nodeType.getName(), e); } return null; }
Set<String> declaredSupertypeNames = asSetOfNames(subtype.getDeclaredSupertypes()); assertTrue(name + " should occur in set of declared super types: " + declaredSupertypeNames, declaredSupertypeNames.contains(name));
for (NodeType snt : nt.getDeclaredSupertypes()) { DomUtil.addChildElement(supertypes, SUPERTYPE_ELEMENT, null, snt.getName());
NodeType[] supers = nt.getDeclaredSupertypes(); List<String> superTypes = new LinkedList<String>(); for (NodeType superType : supers) {
while (primarySuperType != null && !primarySuperType.getName().equals("nt:base")) { NodeType newSuper = null; for (NodeType superType : primarySuperType.getDeclaredSupertypes()) { if (superType.isMixin()) { draft.addMixin(superType.getName());
/** * Creates a new rest node type. * * @param nodeType the {@code non-null} JCR {@link NodeType}. * @param baseUrl the {@code non-null} root url, which is used to construct urls to the children and properties of the node type */ public RestNodeType( NodeType nodeType, String baseUrl ) { this.name = nodeType.getName(); this.isMixin = nodeType.isMixin(); this.isAbstract = nodeType.isAbstract(); this.isQueryable = nodeType.isQueryable(); this.hasOrderableChildNodes = nodeType.hasOrderableChildNodes(); this.superTypesLinks = new TreeSet<String>(); for (NodeType superType : nodeType.getDeclaredSupertypes()) { String superTypeLink = RestHelper.urlFrom(baseUrl, RestHelper.NODE_TYPES_METHOD_NAME, RestHelper.URL_ENCODER.encode(superType.getName())); this.superTypesLinks.add(superTypeLink); } this.subTypesLinks = new TreeSet<String>(); for (NodeTypeIterator subTypeIterator = nodeType.getDeclaredSubtypes(); subTypeIterator.hasNext(); ) { String subTypeLink = RestHelper.urlFrom(baseUrl, RestHelper.NODE_TYPES_METHOD_NAME, RestHelper.URL_ENCODER.encode(subTypeIterator.nextNodeType().getName())); this.subTypesLinks.add(subTypeLink); } this.propertyTypes = new ArrayList<RestPropertyType>(); for (PropertyDefinition propertyDefinition : nodeType.getDeclaredPropertyDefinitions()) { this.propertyTypes.add(new RestPropertyType(propertyDefinition)); } }
@Test public void addMgnlActivatableMixinForMgnlResource() throws RepositoryException, TaskExecutionException { // GIVEN AddActivatableMixinForMgnlResourceTask task = new AddActivatableMixinForMgnlResourceTask("name", "description", RepositoryConstants.WEBSITE); // WHEN task.execute(installContext); // THEN NodeType nt = nodeTypeManager.getNodeType(NodeTypes.Resource.NAME); assertThat(nt.getDeclaredSupertypes().length, is(4)); assertTrue(containsAllSupertypes(nt, Arrays.asList(JcrConstants.NT_RESOURCE, NodeTypes.Activatable.NAME, NodeTypes.Created.NAME, NodeTypes.LastModified.NAME))); } }
@Test public void addLockableMixinToVersionableMixin() throws Exception { // GIVEN AddLockableMixinToVersionableMixinTask task = new AddLockableMixinToVersionableMixinTask("", "", RepositoryConstants.WEBSITE); // WHEN task.execute(installContext); // THEN NodeType versionableNodeType = nodeTypeManager.getNodeType(NodeTypes.Versionable.NAME); assertThat(versionableNodeType.getDeclaredSupertypes(), arrayWithSize(1)); assertTrue(containsAllSupertypes(versionableNodeType, Arrays.asList(JcrConstants.MIX_LOCKABLE))); } }
@Test public void addLockableMixinToVersionableMixin() throws Exception { // GIVEN AddLockableMixinToActivatableMixinTask task = new AddLockableMixinToActivatableMixinTask("", "", RepositoryConstants.WEBSITE); // WHEN task.execute(installContext); // THEN NodeType activatableNodeType = nodeTypeManager.getNodeType(NodeTypes.Activatable.NAME); assertThat(activatableNodeType.getDeclaredSupertypes(), arrayWithSize(1)); assertTrue(containsAllSupertypes(activatableNodeType, Arrays.asList(JcrConstants.MIX_LOCKABLE))); } }
@FixFor( "MODE-1767" ) @Test public void shouldAutomaticallyAddMimeTypePropertyToNtResourceSubtypeUponSave() throws Exception { // Start the repository ... startRepositoryWithConfigurationFrom("config/simple-repo-config.json"); // Register a new node type that is a subtype of 'nt:resource' NodeTypeManager ntMgr = session.getWorkspace().getNodeTypeManager(); NodeTypeTemplate template = ntMgr.createNodeTypeTemplate(); template.setDeclaredSuperTypeNames(new String[] {"nt:resource"}); template.setName("customResourceType"); NodeType ntResourceSubtype = ntMgr.registerNodeType(template, false); assertThat(ntResourceSubtype.getDeclaredSupertypes()[0].getName(), is("nt:resource")); // Add a node under which we'll do our work ... Node node1 = session.getRootNode().addNode("node1"); session.save(); // Upload a file JcrTools tools = new JcrTools(); tools.uploadFile(session, "/node1/simple.json", getResourceFile("data/simple.json")); Node fileNode = node1.getNode("simple.json"); Node contentNode = fileNode.getNode("jcr:content"); contentNode.setPrimaryType(ntResourceSubtype.getName()); assertThat(contentNode.getPrimaryNodeType().getName(), is(ntResourceSubtype.getName())); assertThat(contentNode.hasProperty("jcr:mimeType"), is(false)); assertThat(contentNode.hasProperty("jcr:data"), is(true)); // Save the session, and verify that the "jcr:mimeType" property is added ... session.save(); assertThat(contentNode.hasProperty("jcr:data"), is(true)); assertThat(contentNode.hasProperty("jcr:mimeType"), is(true)); assertThat(contentNode.getProperty("jcr:mimeType").getString(), is("application/json")); }
@Test public void shouldRegisterValidTypesFromCndFile() throws Exception { nodeTypeManager.registerNodeTypes(resourceAsUrl("cnd/validType.cnd"), true); NodeType nodeType = assertNodeType("modetest:testType"); assertThat(nodeType, is(notNullValue())); assertThat(nodeType.isMixin(), is(true)); assertThat(nodeType.hasOrderableChildNodes(), is(true)); assertThat(nodeType.getDeclaredSupertypes().length, is(2)); assertThat(nodeType.getDeclaredChildNodeDefinitions().length, is(1)); JcrNodeDefinition childNode = (JcrNodeDefinition)nodeType.getDeclaredChildNodeDefinitions()[0]; assertThat(childNode.getName(), is("modetest:namespace")); assertThat(childNode.getDefaultPrimaryType().getName(), is("mode:namespace")); assertThat(childNode.getRequiredPrimaryTypes().length, is(1)); assertThat(childNode.getRequiredPrimaryTypes()[0].getName(), is("mode:namespace")); assertThat(childNode.allowsSameNameSiblings(), is(false)); assertThat(childNode.isMandatory(), is(false)); assertThat(nodeType.getDeclaredPropertyDefinitions().length, is(1)); JcrPropertyDefinition property = (JcrPropertyDefinition)nodeType.getDeclaredPropertyDefinitions()[0]; assertThat(property.getName(), is("*")); assertThat(property.getRequiredType(), is(PropertyType.STRING)); assertThat(property.getValueConstraints().length, is(3)); assertThat(property.getValueConstraints()[0], is("foo")); assertThat(property.getValueConstraints()[1], is("bar")); assertThat(property.getValueConstraints()[2], is("baz")); assertThat(property.getDefaultValues().length, is(1)); assertThat(property.getDefaultValues()[0].getString(), is("foo")); }
@Override @Before public void setUp() throws Exception { super.setUp(); final ModuleRegistryImpl moduleRegistry = new ModuleRegistryImpl(); installContext = new InstallContextImpl(moduleRegistry); Session configSession = MgnlContext.getJCRSession(RepositoryConstants.CONFIG); nodeTypeManager = configSession.getWorkspace().getNodeTypeManager(); // register node type mgnl:resource without activatable mixin NodeTypeDefinition ntd = NodeTypeTemplateUtil.createSimpleNodeType(nodeTypeManager, NodeTypes.Resource.NAME, Arrays.asList(NodeType.NT_RESOURCE, NodeTypes.LastModified.NAME, NodeTypes.Created.NAME)); NodeTypeRegistry.disableCheckForReferencesInContentException = true; nodeTypeManager.unregisterNodeType(NodeTypes.Resource.NAME); nodeTypeManager.registerNodeType(ntd, true); NodeTypeRegistry.disableCheckForReferencesInContentException = false; // check that we really have nt:resource, mgnl:created and mgnl:lastModified supertypes NodeType nodeTypeMgnlResource = nodeTypeManager.getNodeType(NodeTypes.Resource.NAME); assertNotNull(nodeTypeMgnlResource); assertEquals(3, nodeTypeMgnlResource.getDeclaredSupertypes().length); assertTrue(containsAllSupertypes(nodeTypeMgnlResource, Arrays.asList(JcrConstants.NT_RESOURCE, NodeTypes.Created.NAME, NodeTypes.LastModified.NAME))); }
@Override @Before public void setUp() throws Exception { super.setUp(); final ModuleRegistryImpl moduleRegistry = new ModuleRegistryImpl(); installContext = new InstallContextImpl(moduleRegistry); Session configSession = MgnlContext.getJCRSession(RepositoryConstants.CONFIG); nodeTypeManager = configSession.getWorkspace().getNodeTypeManager(); // register node type mgnl:versionable without lockable mixin NodeTypeDefinition ntd = NodeTypeTemplateUtil.createSimpleNodeType(nodeTypeManager, NodeTypes.Versionable.NAME, Arrays.asList()); NodeTypeRegistry.disableCheckForReferencesInContentException = true; nodeTypeManager.unregisterNodeType(NodeTypes.Role.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.User.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Group.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Page.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Content.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Deleted.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Versionable.NAME); nodeTypeManager.registerNodeType(ntd, true); NodeTypeRegistry.disableCheckForReferencesInContentException = false; NodeType versionableNodeType = nodeTypeManager.getNodeType(NodeTypes.Versionable.NAME); assertThat(versionableNodeType.getDeclaredSupertypes(), not(arrayContaining(JcrConstants.MIX_LOCKABLE))); }
@Override @Before public void setUp() throws Exception { super.setUp(); final ModuleRegistryImpl moduleRegistry = new ModuleRegistryImpl(); installContext = new InstallContextImpl(moduleRegistry); Session configSession = MgnlContext.getJCRSession(RepositoryConstants.CONFIG); nodeTypeManager = configSession.getWorkspace().getNodeTypeManager(); // register node type mgnl:versionable without lockable mixin NodeTypeDefinition ntd = NodeTypeTemplateUtil.createSimpleNodeType(nodeTypeManager, NodeTypes.Activatable.NAME, Arrays.asList()); NodeTypeRegistry.disableCheckForReferencesInContentException = true; nodeTypeManager.unregisterNodeType(NodeTypes.Area.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Component.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Folder.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Role.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.User.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Group.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Page.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Content.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.ContentNode.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Resource.NAME); nodeTypeManager.unregisterNodeType(NodeTypes.Activatable.NAME); nodeTypeManager.registerNodeType(ntd, true); NodeTypeRegistry.disableCheckForReferencesInContentException = false; NodeType activatableNodeType = nodeTypeManager.getNodeType(NodeTypes.Activatable.NAME); assertThat(activatableNodeType.getDeclaredSupertypes(), not(arrayContaining(JcrConstants.MIX_LOCKABLE))); }