/** * Register the {@link NodeTypeDefinition}. */ private void registerNodeType(NodeTypeManager nodeTypeManager, NodeTypeDefinition nodeTypeDefinition) throws RepositoryException { // "transforming" each definition into a template, so that nodeTypeManager.registerNodeType doesn't barf unnecessary exceptions. final NodeTypeTemplate nodeTypeTemplate = nodeTypeManager.createNodeTypeTemplate(nodeTypeDefinition); log.debug("Registering the following '{}' node type.", nodeTypeTemplate.getName()); nodeTypeManager.registerNodeType(nodeTypeTemplate, true); }
@Test public void testRegisterNodeTypeWithPrivilege() throws Exception { modify(null, JCR_NODE_TYPE_DEFINITION_MANAGEMENT.toString(), true); try { Workspace testWsp = testSession.getWorkspace(); NodeTypeManager ntm = testWsp.getNodeTypeManager(); NodeTypeTemplate ntd = ntm.createNodeTypeTemplate(); ntd.setName("testRegisterNodeTypeWithPrivilege"); ntd.setMixin(true); ntm.registerNodeType(ntd, true); NodeTypeTemplate[] ntds = new NodeTypeTemplate[2]; ntds[0] = ntd; ntds[1] = ntm.createNodeTypeTemplate(); ntds[1].setName("anotherRegisterNodeTypeWithPrivilege"); ntds[1].setDeclaredSuperTypeNames(new String[] {"nt:file"}); ntm.registerNodeTypes(ntds, true); } finally { modify(null, JCR_NODE_TYPE_DEFINITION_MANAGEMENT.toString(), false); } }
private void createNodeTypeTemplate(final Session session, final NodeTypeManager typeManager, final String baseDocPath, final String baseDocTypeName) throws RepositoryException { final Node baseDocNode = session.getNode(baseDocPath); final NodeTypeTemplate baseDocTemplate = typeManager.createNodeTypeTemplate(); baseDocTemplate.setName(baseDocTypeName); if (baseDocNode.hasNode(NODETYPE)) { Node draft = baseDocNode.getNode(NODETYPE); if (draft.hasProperty(HippoNodeType.HIPPO_SUPERTYPE)) { Value[] supers = draft.getProperty(HippoNodeType.HIPPO_SUPERTYPE).getValues(); String[] superStrings = new String[supers.length]; for (int i = 0; i < supers.length; i++) { superStrings[i] = supers[i].getString(); } baseDocTemplate.setDeclaredSuperTypeNames(superStrings); } } baseDocTemplate.setOrderableChildNodes(true); typeManager.registerNodeType(baseDocTemplate, false); } }
private void removeAllSNSFromNTD(final String nodeTypeName) throws RepositoryException { if (!dryRun) { log.info("Removing SNS from " + nodeTypeName); final NodeTypeTemplate ntt = ntm.createNodeTypeTemplate(ntm.getNodeType(nodeTypeName)); for (final Object nd : ntt.getNodeDefinitionTemplates()) { final NodeDefinitionTemplate ndt = (NodeDefinitionTemplate) nd; ndt.setSameNameSiblings(false); } ntr.ignoreNextConflictingContent(); ntm.registerNodeType(ntt, true); } }
private static void registerMixinNodeType( NodeTypeManager nodeTypeManager, String name ) throws RepositoryException { NodeTypeTemplate nodeType = nodeTypeManager.createNodeTypeTemplate(); nodeType.setMixin( true ); nodeType.setName( name ); // for now just don't re-create - but in future if we change the definition, make sure to remove first as an // upgrade path if ( !nodeTypeManager.hasNodeType( name ) ) { nodeTypeManager.registerNodeType( nodeType, false ); } }
private static void registerMixinNodeType( NodeTypeManager nodeTypeManager, String name ) throws RepositoryException { NodeTypeTemplate nodeType = nodeTypeManager.createNodeTypeTemplate(); nodeType.setMixin( true ); nodeType.setName( name ); // for now just don't re-create - but in future if we change the definition, make sure to remove first as an // upgrade path if ( !nodeTypeManager.hasNodeType( name ) ) { nodeTypeManager.registerNodeType( nodeType, false ); } }
@Before public void setup() throws RepositoryException { Session session = getAdminSession(); NodeTypeManager ntMgr = session.getWorkspace().getNodeTypeManager(); NodeTypeTemplate mixTest = ntMgr.createNodeTypeTemplate(); mixTest.setName(TEST_TYPE); mixTest.setMixin(true); ntMgr.registerNodeType(mixTest, false); Node n = session.getRootNode().addNode(TEST_NODE); n.setProperty("test_property1", 42); n.setProperty("test_property2", "forty_two"); n.addMixin(TEST_TYPE); Node refNode = n.addNode(REFERENCEABLE_NODE); refNode.addMixin(JcrConstants.MIX_REFERENCEABLE); test_uuid = refNode.getProperty(JcrConstants.JCR_UUID).getString(); session.save(); observingSession = createAdminSession(); observationManager = observingSession.getWorkspace().getObservationManager(); }
@Before public void setup() throws RepositoryException { Session session = getAdminSession(); NodeTypeManager ntMgr = session.getWorkspace().getNodeTypeManager(); NodeTypeTemplate mixTest = ntMgr.createNodeTypeTemplate(); mixTest.setName(TEST_TYPE); mixTest.setMixin(true); ntMgr.registerNodeType(mixTest, false); Node n = session.getRootNode().addNode(TEST_NODE, TEST_NODE_TYPE); n.addMixin(TEST_TYPE); Node refNode = n.addNode(REFERENCEABLE_NODE); refNode.addMixin(JcrConstants.MIX_REFERENCEABLE); session.save(); Map<String,Object> attrs = new HashMap<String, Object>(); attrs.put(RepositoryImpl.REFRESH_INTERVAL, 0); observingSession = ((JackrabbitRepository) getRepository()).login(new SimpleCredentials("admin", "admin".toCharArray()), null, attrs); observationManager = observingSession.getWorkspace().getObservationManager(); }
public void testAddItemsDefinedByMixin() throws NotExecutableException, RepositoryException { // register mixin NodeTypeManager ntm = superuser.getWorkspace().getNodeTypeManager(); NodeTypeTemplate ntd = ntm.createNodeTypeTemplate(); ntd.setName("testMixin"); ntd.setMixin(true); NodeDefinitionTemplate nodeDef = ntm.createNodeDefinitionTemplate(); nodeDef.setName("child"); nodeDef.setRequiredPrimaryTypeNames(new String[] {"nt:folder"}); ntd.getNodeDefinitionTemplates().add(nodeDef); ntm.registerNodeType(ntd, true); // create node and add mixin Node node = testRootNode.addNode(nodeName1, "nt:resource"); node.setProperty("jcr:data", "abc"); node.addMixin("testMixin"); superuser.save(); // create a child node defined by the mixin node.addNode("child", "nt:folder"); node.save(); }
@SuppressWarnings( "unchecked" ) protected void registerCarCarrierNodeType( Session session ) throws RepositoryException { NodeTypeManager ntManager = session.getWorkspace().getNodeTypeManager(); try { ntManager.getNodeType(CAR_CARRIER_TYPENAME); } catch (NoSuchNodeTypeException e) { NodeTypeTemplate nt = ntManager.createNodeTypeTemplate(); nt.setName(CAR_CARRIER_TYPENAME); // Children ... NodeDefinitionTemplate carChildType = ntManager.createNodeDefinitionTemplate(); carChildType.setRequiredPrimaryTypeNames(new String[] {CAR_TYPENAME}); nt.getNodeDefinitionTemplates().add(carChildType); ntManager.registerNodeType(nt, true); } // Verify it was registered ... ntManager.getNodeType(CAR_CARRIER_TYPENAME); }
private NodeDefinitionTemplate createNodeDefinitionWithIgnoreOPVNode(String nodeTypeName) throws RepositoryException { NodeTypeManager manager = superuser.getWorkspace().getNodeTypeManager(); NodeDefinitionTemplate def = manager.createNodeDefinitionTemplate(); def.setOnParentVersion(OnParentVersionAction.IGNORE); def.setName("child"); def.setRequiredPrimaryTypeNames(new String[]{JcrConstants.NT_BASE}); NodeTypeTemplate tmpl = manager.createNodeTypeTemplate(); tmpl.setName(nodeTypeName); tmpl.setMixin(true); tmpl.getNodeDefinitionTemplates().add(def); manager.registerNodeType(tmpl, true); return def; } }
@Override protected void setUp() throws Exception { super.setUp(); vMgr = superuser.getWorkspace().getVersionManager(); NodeTypeManager ntMgr = superuser.getWorkspace().getNodeTypeManager(); NodeDefinitionTemplate def = ntMgr.createNodeDefinitionTemplate(); def.setOnParentVersion(OnParentVersionAction.ABORT); def.setName("child"); def.setRequiredPrimaryTypeNames(new String[] {NT_BASE}); NodeTypeTemplate tmpl = ntMgr.createNodeTypeTemplate(); tmpl.setName("OpvAbortTest"); tmpl.setMixin(true); tmpl.getNodeDefinitionTemplates().add(def); ntMgr.registerNodeType(tmpl, true); testRootNode.addMixin(MIX_VERSIONABLE); superuser.save(); }
@SuppressWarnings( "unchecked" ) @FixFor( "MODE-1050" ) public void testShouldSuccessfullyRegisterChildAndParentSameTypes() throws RepositoryException { Session session = getHelper().getSuperuserSession(); session.getWorkspace().getNamespaceRegistry().registerNamespace("mx", "urn:test"); final NodeTypeManager nodeTypeMgr = session.getWorkspace().getNodeTypeManager(); final NodeTypeTemplate nodeType = nodeTypeMgr.createNodeTypeTemplate(); nodeType.setName("mx:type"); nodeType.setDeclaredSuperTypeNames(new String[] {"nt:folder"}); final NodeDefinitionTemplate subTypes = nodeTypeMgr.createNodeDefinitionTemplate(); subTypes.setRequiredPrimaryTypeNames(new String[] {"mx:type"}); nodeType.getNodeDefinitionTemplates().add(subTypes); nodeTypeMgr.registerNodeType(nodeType, false); }
private NodeTypeTemplate createNodeTypeWithIgnoreOPVProperty(String propertyName) throws RepositoryException { NodeTypeManager manager = superuser.getWorkspace().getNodeTypeManager(); NodeTypeTemplate nt = manager.createNodeTypeTemplate(); nt.setName("testType"); nt.setMixin(true); PropertyDefinitionTemplate opt = manager.createPropertyDefinitionTemplate(); opt.setMandatory(false); opt.setName(propertyName); opt.setRequiredType(PropertyType.STRING); opt.setOnParentVersion(OnParentVersionAction.IGNORE); List pdt = nt.getPropertyDefinitionTemplates(); pdt.add(opt); manager.registerNodeType(nt, true); return nt; }
@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))); }
@Test public void nodeTypeRegistry() throws RepositoryException { NodeTypeManager ntMgr = getAdminSession().getWorkspace().getNodeTypeManager(); assertFalse(ntMgr.hasNodeType("foo")); NodeTypeTemplate ntd = ntMgr.createNodeTypeTemplate(); ntd.setName("foo"); ntMgr.registerNodeType(ntd, false); assertTrue(ntMgr.hasNodeType("foo")); ntMgr.unregisterNodeType("foo"); assertFalse(ntMgr.hasNodeType("foo")); }
protected void registerNodeType( String typeName, boolean queryable, boolean mixin, String...declaredSuperTypes) throws RepositoryException { NodeTypeManager mgr = session.getWorkspace().getNodeTypeManager(); // Create a template for the node type ... NodeTypeTemplate type = mgr.createNodeTypeTemplate(); type.setName(typeName); type.setDeclaredSuperTypeNames(declaredSuperTypes); type.setAbstract(false); type.setOrderableChildNodes(true); type.setMixin(mixin); type.setQueryable(queryable); mgr.registerNodeType(type, true); }
@Test public void updateFrom51UpdatesFavoriteNodeType() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(FavoriteStore.WORKSPACE_NAME); NodeTypeManager nodeTypeManager = session.getWorkspace().getNodeTypeManager(); NodeTypeTemplate template = NodeTypeTemplateUtil.createSimpleNodeType(nodeTypeManager, AdmincentralNodeTypes.Favorite.NAME, Arrays.asList(JcrConstants.NT_BASE)); nodeTypeManager.registerNodeType(template, false); assertFalse(nodeTypeManager.getNodeType(AdmincentralNodeTypes.Favorite.NAME).isNodeType(NodeTypes.Created.NAME)); // WHEN executeUpdatesAsIfTheCurrentlyInstalledVersionWas(Version.parseVersion("5.1")); // THEN assertTrue(nodeTypeManager.getNodeType(AdmincentralNodeTypes.Favorite.NAME).isNodeType(NodeTypes.Created.NAME)); assertTrue(nodeTypeManager.getNodeType(AdmincentralNodeTypes.Favorite.NAME).isNodeType(NodeTypes.LastModified.NAME)); }
private void registerNodeType( String typeName ) throws RepositoryException { NodeTypeManager nodeTypeManager = session.getWorkspace().getNodeTypeManager(); // Create a template for the node type ... NodeTypeTemplate type = nodeTypeManager.createNodeTypeTemplate(); type.setName(typeName); type.setDeclaredSuperTypeNames(new String[] {"nt:unstructured"}); type.setAbstract(false); type.setOrderableChildNodes(true); type.setMixin(false); type.setQueryable(true); nodeTypeManager.registerNodeType(type, true); }
@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))); }