/** {@inheritDoc} */ public String getPrimaryItemName() throws RemoteException { return type.getPrimaryItemName(); }
private Item getPrimaryItem(final Node node) throws RepositoryException { String name = node.getPrimaryNodeType().getPrimaryItemName(); if (name == null) { return null; } if (node.hasProperty(name)) { return node.getProperty(name); } else if (node.hasNode(name)) { return node.getNode(name); } else { return null; } }
private String getPrimaryItemName(final Node document) throws RepositoryException { NodeType primaryType = document.getPrimaryNodeType(); String primaryItemName = primaryType.getPrimaryItemName(); while (primaryItemName == null && !NT_BASE.equals(primaryType.getName())) { for (NodeType nt : primaryType.getSupertypes()) { if (nt.getPrimaryItemName() != null) { primaryItemName = nt.getPrimaryItemName(); break; } if (nt.isNodeType(NT_BASE)) { primaryType = nt; } } } return primaryItemName; }
/** * Returns the first descendant of <code>node</code> which does not define a * primary item. * * @param node <code>Node</code> to start traversal. * @return first node without a primary item */ private Node locateNodeWithoutPrimaryItem(Node node) throws RepositoryException { if (node.getPrimaryNodeType().getPrimaryItemName() == null) { return node; } NodeIterator nodes = node.getNodes(); while (nodes.hasNext()) { Node n = locateNodeWithoutPrimaryItem(nodes.nextNode()); if (n != null) { return n; } } return null; }
/** * Returns the first descendant of <code>node</code> which defines a primary * item. * * @param node <code>Node</code> to start traversal. * @return first node with a primary item */ private Node locateNodeWithPrimaryItem(Node node) throws RepositoryException { if (node.getPrimaryNodeType().getPrimaryItemName() != null) { return node; } NodeIterator nodes = node.getNodes(); while (nodes.hasNext()) { Node returnedNode = locateNodeWithPrimaryItem(nodes.nextNode()); if (returnedNode != null) { return returnedNode; } } return null; }
private boolean hasPrimaryItem() { try { return exists() && ((Node) item).getPrimaryNodeType().getPrimaryItemName() != null; } catch (RepositoryException e) { log.warn(e.getMessage()); } return false; }
private Item getPrimaryItem(Node node) throws Exception { NodeType primaryType = node.getPrimaryNodeType(); String primaryItemName = primaryType.getPrimaryItemName(); while (primaryItemName == null && !"nt:base".equals(primaryType.getName())) { for (NodeType nt : primaryType.getSupertypes()) { if (nt.getPrimaryItemName() != null) { primaryItemName = nt.getPrimaryItemName(); break; } if (nt.isNodeType("nt:base")) { primaryType = nt; } } } if (primaryItemName == null) { throw new ItemNotFoundException("No primary item definition found in type hierarchy"); } return node.getSession().getItem(node.getPath() + "/" + primaryItemName); }
protected void addDefinition(String prefix, ItemDefinition definition) throws StoreException { BuiltinFieldDescriptor field = new BuiltinFieldDescriptor(prefix, definition, locator, this); if (definition.getDeclaringNodeType().equals(nt)) { declaredFields.put(field.getName(), field); } if ("nt:base".equals(definition.getDeclaringNodeType().getName())) { return; } fields.put(field.getName(), field); String primaryItemName = definition.getDeclaringNodeType().getPrimaryItemName(); if (primaryItemName != null && primaryItemName.equals(definition.getName())) { field.setPrimary(true); } }
/** * Test if node.getPrimaryItemName() returns null if no primary item is * defined */ public void testGetPrimaryItemNameNotExisting() throws NotExecutableException, RepositoryException { Node node = locateNodeWithoutPrimaryItem(rootNode); if (node == null) { throw new NotExecutableException("Workspace does not contain a node without primary item defined"); } NodeType type = node.getPrimaryNodeType(); assertNull("getPrimaryItemName() must return null if NodeType " + "does not define a primary item", type.getPrimaryItemName()); }
/** * Create a new {@link NodeTypeTemplate} copy of the 'nodeType', but without <br> * metaData defined as 'childNodeDefinition'. */ private NodeTypeTemplate createNodeTypeWithoutMetaData(NodeTypeManager nodeTypeManager, NodeType nodeType, NodeDefinition metaDataNode) throws RepositoryException { NodeTypeTemplate ntt = nodeTypeManager.createNodeTypeTemplate(); ntt.setDeclaredSuperTypeNames(nodeType.getDeclaredSupertypeNames()); ntt.setMixin(nodeType.isMixin()); ntt.setName(nodeType.getName()); ntt.setOrderableChildNodes(nodeType.hasOrderableChildNodes()); ntt.setPrimaryItemName(nodeType.getPrimaryItemName()); ntt.setQueryable(nodeType.isQueryable()); ntt.getPropertyDefinitionTemplates().addAll(Arrays.asList(nodeType.getDeclaredPropertyDefinitions())); List<NodeDefinition> childNodeDefinition = new ArrayList<NodeDefinition>(); childNodeDefinition.addAll(Arrays.asList(nodeType.getDeclaredChildNodeDefinitions())); childNodeDefinition.remove(metaDataNode); ntt.getNodeDefinitionTemplates().addAll(childNodeDefinition); return ntt; } }
@Test public void shouldVerifyNtFileHasPrimaryItem() throws Exception { NodeType ntFile = nodeTypeMgr.getNodeType(NT_FILE_NODE_TYPE); assertThat(ntFile.getPrimaryItemName(), is("jcr:content")); }
@NotNull @Override public Item perform() throws RepositoryException { // TODO: avoid nested calls String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException( "No primary item present on node " + NodeImpl.this); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException( "Primary item " + name + " does not exist on node " + NodeImpl.this); } } });
@NotNull @Override public Item perform() throws RepositoryException { // TODO: avoid nested calls String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException( "No primary item present on node " + NodeImpl.this); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException( "Primary item " + name + " does not exist on node " + NodeImpl.this); } } });
@Nonnull @Override public Item perform() throws RepositoryException { // TODO: avoid nested calls String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException( "No primary item present on node " + NodeImpl.this); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException( "Primary item " + name + " does not exist on node " + NodeImpl.this); } } });
/** * Test if node.getPrimaryItemName() returns the same name as * node.getPrimaryItem().getName() */ public void testGetPrimaryItemName() throws NotExecutableException, RepositoryException { Node node = locateNodeWithPrimaryItem(rootNode); if (node == null) { throw new NotExecutableException("Workspace does not contain a node with primary item defined"); } String name = node.getPrimaryItem().getName(); NodeType type = node.getPrimaryNodeType(); assertEquals("node.getPrimaryNodeType().getPrimaryItemName() " + "must return the same name as " + "node.getPrimaryItem().getName()", name, type.getPrimaryItemName()); }
private EffectiveNodeTypeImpl loadEffectiveNodeType(NodeType nodeType) throws RepositoryException { EffectiveNodeTypeImpl ent = types.get(nodeType.getName()); if (ent == null) { ent = new EffectiveNodeTypeImpl(nodeType.getName(), version); ent.setMixin(nodeType.isMixin()); ent.setAbstract(nodeType.isAbstract()); ent.setOrdered(nodeType.hasOrderableChildNodes()); ent.setPrimaryItemName(nodeType.getPrimaryItemName()); types.put(ent.getName(), ent); // ensure all super types are also loaded for (NodeType superType : nodeType.getSupertypes()) { ent.getSuperTypes().add(loadEffectiveNodeType(superType).getName()); } loadChildNodeDefinitions(nodeType, ent); loadPropertyDefinitions(nodeType, ent); } return ent; }
/** * {@inheritDoc} */ public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException { // check state of this instance sanityCheck(); String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException(); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException(); } }
/** * {@inheritDoc} */ public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException { // check state of this instance sanityCheck(); String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException(); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException(); } }
/** * @see Node#getPrimaryItem() */ public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException { checkStatus(); String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException("No primary item present on Node " + safeGetJCRPath()); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException("Primary item " + name + " does not exist on Node " + safeGetJCRPath()); } }
/** * @see Node#getPrimaryItem() */ public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException { checkStatus(); String name = getPrimaryNodeType().getPrimaryItemName(); if (name == null) { throw new ItemNotFoundException("No primary item present on Node " + safeGetJCRPath()); } if (hasProperty(name)) { return getProperty(name); } else if (hasNode(name)) { return getNode(name); } else { throw new ItemNotFoundException("Primary item " + name + " does not exist on Node " + safeGetJCRPath()); } }