@Override public boolean hasNodeType(String name) throws RepositoryException { return delegate.hasNodeType(name); }
private String getUnstructuredNodeType(Session s) throws RepositoryException { NodeTypeManager ntMgr = s.getWorkspace().getNodeTypeManager(); if (ntMgr.hasNodeType("oak:Unstructured")) { return "oak:Unstructured"; } else { return "nt:unstructured"; } }
public boolean hasNodeType(String name) throws RepositoryException, RemoteException { try { return manager.hasNodeType(name); } catch (RepositoryException ex) { throw getRepositoryException(ex); } }
private boolean repositoryHasType(final Session session, final String mixinName) throws RepositoryException { return session.getWorkspace().getNodeTypeManager().hasNodeType(mixinName); }
/** * Gets the node type of the parent. * * @return the parent type * @throws RepositoryException the repository exception */ protected String getParentType() throws RepositoryException { String type = NodeTypeConstants.NT_UNSTRUCTURED; if (parent.getSession().getWorkspace().getNodeTypeManager().hasNodeType( NodeTypeConstants.NT_OAK_UNSTRUCTURED)) { type = NodeTypeConstants.NT_OAK_UNSTRUCTURED; } return type; }
/** * Un-register all nodeTypes passed as {@code nodeTypeNames}. Filter the list as the {@link NodeTypeManager#unregisterNodeTypes(String[])} * throws Exception if the nodeType is not registered. */ private void unregisterNodeTypes(final NodeTypeManager nodeTypeManager, List<String> nodeTypeNames) throws RepositoryException { Iterator<String> it = nodeTypeNames.iterator(); while (it.hasNext()) { String nodeTypeName = it.next(); if (!nodeTypeManager.hasNodeType(nodeTypeName)) { log.warn("Node type '{}' is not registered . No un-registration will be performed for this nodeType.", nodeTypeName); it.remove(); } } NodeTypeRegistry.disableCheckForReferencesInContentException = true; nodeTypeManager.unregisterNodeTypes(nodeTypeNames.toArray(new String[nodeTypeNames.size()])); log.info("Unregistered the following NodeTypes '{}'.", nodeTypeNames); NodeTypeRegistry.disableCheckForReferencesInContentException = false; }
/** * if no /hcm:hcm node exists, we can assume this workspace hasn't run a v12+ HCM-style bootstrap yet */ private boolean isFirstHcmStartup() throws RepositoryException { return !(session.getWorkspace().getNodeTypeManager().hasNodeType(NT_HCM_ROOT) && session.nodeExists(HCM_ROOT_PATH)); }
/** * Asserts that a specific node type is registered in the workspace of the session. * * @param session * the session to perform the lookup * @param nodeTypeName * the name of the nodetype that is asserted to exist * @throws RepositoryException * if an error occurs */ public static void assertNodeTypeExists(final Session session, final String nodeTypeName) throws RepositoryException { final NodeTypeManager ntm = session.getWorkspace().getNodeTypeManager(); assertTrue("NodeType " + nodeTypeName + " does not exist", ntm.hasNodeType(nodeTypeName)); } }
private void copyNodeTypes(NodeTypeManager ntMgr, ValueFactory valueFactory) throws RepositoryException { NodeTypeRegistry sourceRegistry = source.getNodeTypeRegistry(); List<NodeTypeTemplate> templates = Lists.newArrayList(); for (Name name : sourceRegistry.getRegisteredNodeTypes()) { String oakName = getOakName(name); // skip built-in nodetypes (OAK-1235) if (!ntMgr.hasNodeType(oakName)) { QNodeTypeDefinition def = sourceRegistry.getNodeTypeDef(name); templates.add(createNodeTypeTemplate(valueFactory, ntMgr, oakName, def)); } } ntMgr.registerNodeTypes(templates.toArray(new NodeTypeTemplate[templates.size()]), true); }
private void copyNodeTypes(NodeTypeManager ntMgr, ValueFactory valueFactory) throws RepositoryException { NodeTypeRegistry sourceRegistry = source.getNodeTypeRegistry(); List<NodeTypeTemplate> templates = Lists.newArrayList(); for (Name name : sourceRegistry.getRegisteredNodeTypes()) { String oakName = getOakName(name); // skip built-in nodetypes (OAK-1235) if (!ntMgr.hasNodeType(oakName)) { QNodeTypeDefinition def = sourceRegistry.getNodeTypeDef(name); templates.add(createNodeTypeTemplate(valueFactory, ntMgr, oakName, def)); } } ntMgr.registerNodeTypes(templates.toArray(new NodeTypeTemplate[templates.size()]), true); }
/** * Get original node type. * * @return original node type if exists or null */ public NodeType getOriginalNodeType() throws RepositoryException { if (this.originalNodeType == null && getNodeTypeManager().hasNodeType(this.nodeType)) { this.originalNodeType = getNodeTypeManager().getNodeType(this.nodeType); } return this.originalNodeType; }
private boolean isNotAbstractNodeType(final String type) { try { final NodeTypeManager nodeTypeManager = getSession().getJcrSession().getWorkspace().getNodeTypeManager(); if (nodeTypeManager.hasNodeType(type)) { return !nodeTypeManager.getNodeType(type).isAbstract(); } } catch (RepositoryException e) { log.error("Exception determining whether type " + type + " is abstract", e); } return true; } }
@Test public void verifyNewBuiltinNodeTypes() throws Exception { Session session = createAdminSession(); try { NodeTypeManager manager = session.getWorkspace().getNodeTypeManager(); assertTrue(manager.hasNodeType(UserConstants.NT_REP_MEMBER_REFERENCES)); assertTrue(manager.hasNodeType(IndexConstants.INDEX_DEFINITIONS_NODE_TYPE)); } finally { session.logout(); } }
@Test public void verifyNewBuiltinNodeTypes() throws Exception { Session session = createAdminSession(); try { NodeTypeManager manager = session.getWorkspace().getNodeTypeManager(); assertTrue(manager.hasNodeType(UserConstants.NT_REP_MEMBER_REFERENCES)); assertTrue(manager.hasNodeType(IndexConstants.INDEX_DEFINITIONS_NODE_TYPE)); } finally { session.logout(); } }
@Override protected void setUp() throws Exception { super.setUp(); NodeTypeManager manager = superuser.getWorkspace().getNodeTypeManager(); if (!manager.hasNodeType("test:mimeType")) { String cnd = "<test='http://www.apache.org/jackrabbit/test'>\n" + "[test:mimeType] > mix:mimeType mixin"; Reader cndReader = new InputStreamReader(new ByteArrayInputStream(cnd.getBytes())); CndImporter.registerNodeTypes(cndReader, superuser); } }
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 ); } }
@Test public void updatingNodeTypeReRegistersDependingNodeTypes() throws RepositoryException, TaskExecutionException { // GIVEN LinkedList<NodeTypeDefinition> nodeTypeToUpdate = new LinkedList<>(); NodeTypeDefinition typeDefinitionContent = NodeTypeTemplateUtil.createSimpleNodeType(nodeTypeManager, NodeTypes.Content.NAME, Arrays.asList(NodeType.NT_HIERARCHY_NODE, NodeType.MIX_REFERENCEABLE)); nodeTypeToUpdate.add(typeDefinitionContent); TestNodeTypeRegistrationTask task = new TestNodeTypeRegistrationTask("name", "description", RepositoryConstants.CONFIG, nodeTypeToUpdate, null); // WHEN task.execute(installContext); // THEN assertTrue(nodeTypeManager.hasNodeType(NodeTypes.Group.NAME)); assertTrue(nodeTypeManager.hasNodeType(NodeTypes.Role.NAME)); assertTrue(nodeTypeManager.hasNodeType(NodeTypes.User.NAME)); assertTrue(nodeTypeManager.hasNodeType(NodeTypes.Page.NAME)); assertTrue(nodeTypeManager.hasNodeType(NodeTypes.Content.NAME)); }
@Test // Regression test for OAK-299 public void importNodeType() throws RepositoryException, IOException, ParseException { Session session = getAdminSession(); NodeTypeManager manager = session.getWorkspace().getNodeTypeManager(); if (!manager.hasNodeType("myNodeType")) { StringBuilder defs = new StringBuilder(); defs.append("[\"myNodeType\"]\n"); defs.append(" - prop1\n"); defs.append(" + * (nt:base) = nt:unstructured \n"); Reader cndReader = new InputStreamReader(new ByteArrayInputStream(defs.toString().getBytes())); CndImporter.registerNodeTypes(cndReader, session); } NodeType myNodeType = manager.getNodeType("myNodeType"); assertTrue(myNodeType.isNodeType("nt:base")); }
@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")); }