@Override protected void doFinish() throws RepositoryException { currentNodeType.setDeclaredSuperTypeNames(getStringValues()); } }
@Override protected void doFinish() throws RepositoryException { currentNodeType.setDeclaredSuperTypeNames(getStringValues()); } }
private void buildSupertypes(OMElement omElement) throws ConstraintViolationException { Iterator supertypeIt = omElement.getChildrenWithLocalName("supertypes"); while (supertypeIt.hasNext()) { //one time process OMElement supertypes = (OMElement) supertypeIt.next(); Iterator it1 = supertypes.getChildrenWithLocalName("supertype"); List<String> superTypeList = new ArrayList<String>(); while (it1.hasNext()) { superTypeList.add(((OMElement) it1.next()).getText()); //super types } nodeTypeTemplate.setDeclaredSuperTypeNames(superTypeList.toArray(new String[0])); } }
@Override public NodeTypeTemplate build() throws ConstraintViolationException { template.setMixin(super.isMixin); template.setOrderableChildNodes(super.isOrderable); template.setAbstract(super.isAbstract); template.setQueryable(super.queryable); template.setDeclaredSuperTypeNames(supertypes.toArray(new String[supertypes.size()])); return template; }
@Override public NodeTypeTemplate build() throws ConstraintViolationException { template.setMixin(super.isMixin); template.setOrderableChildNodes(super.isOrderable); template.setAbstract(super.isAbstract); template.setQueryable(super.queryable); template.setDeclaredSuperTypeNames(supertypes.toArray(new String[supertypes.size()])); return template; }
@Override public NodeTypeTemplate build() throws ConstraintViolationException { template.setMixin(super.isMixin); template.setOrderableChildNodes(super.isOrderable); template.setAbstract(super.isAbstract); template.setQueryable(super.queryable); template.setDeclaredSuperTypeNames(supertypes.toArray(new String[supertypes.size()])); return template; }
@SuppressWarnings( "unchecked" ) @Override public NodeTypeDefinition getNodeTypeDefinition( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeTypeTemplate t = ntMgr.createNodeTypeTemplate(); t.setName( PHO_NT + "pentahoFolder" ); //$NON-NLS-1$ t.setDeclaredSuperTypeNames( new String[] { NT + "folder", PHO_NT + "pentahoHierarchyNode" } ); //$NON-NLS-1$ //$NON-NLS-2$ t.getNodeDefinitionTemplates().add( getInternalFolderNode( ntMgr, vFac ) ); return t; }
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); } }
@SuppressWarnings( "unchecked" ) @Override public NodeTypeDefinition getNodeTypeDefinition( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeTypeTemplate t = ntMgr.createNodeTypeTemplate(); t.setName( PHO_NT + "pentahoFile" ); //$NON-NLS-1$ t.setDeclaredSuperTypeNames( new String[] { NT + "file", PHO_NT + "pentahoHierarchyNode" } ); //$NON-NLS-1$ //$NON-NLS-2$ t.getPropertyDefinitionTemplates().add( getLastModifiedProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getContentTypeProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getFileSizeProperty( ntMgr, vFac ) ); return t; }
@SuppressWarnings( "unchecked" ) @Override public NodeTypeDefinition getNodeTypeDefinition( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeTypeTemplate t = ntMgr.createNodeTypeTemplate(); t.setName( PHO_MIX + "pentahoVersionable" ); //$NON-NLS-1$ t.setMixin( true ); t.setDeclaredSuperTypeNames( new String[] { MIX + "simpleVersionable" } ); //$NON-NLS-1$ t.getPropertyDefinitionTemplates().add( getAuthorProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getMessageProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getAclOnlyChangeProperty( ntMgr, vFac ) ); return t; }
@SuppressWarnings( "unchecked" ) @Override public NodeTypeDefinition getNodeTypeDefinition( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeTypeTemplate t = ntMgr.createNodeTypeTemplate(); t.setName( PHO_NT + "pentahoHierarchyNode" ); //$NON-NLS-1$ t.setDeclaredSuperTypeNames( new String[] { NT + "hierarchyNode", MIX + "referenceable" } ); //$NON-NLS-1$//$NON-NLS-2$ t.getNodeDefinitionTemplates().add( getTitleNode( ntMgr ) ); t.getNodeDefinitionTemplates().add( getDescriptionNode( ntMgr ) ); t.getNodeDefinitionTemplates().add( getMetadataNode( ntMgr ) ); t.getNodeDefinitionTemplates().add( getLocaleNode( ntMgr ) ); t.getPropertyDefinitionTemplates().add( getHiddenProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getAclNodeProperty( ntMgr, vFac ) ); return t; }
/** * 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; } }
/** * Create a {@link NodeTypeTemplate} used a NodeType definition. */ public static NodeTypeTemplate createNodeType(NodeTypeManager nodeTypeManager, String name, String[] superTypeNames, boolean isMixin, boolean isOrderableChildNodes, String primaryItemName, boolean isQueryable) throws RepositoryException { // Create node definition NodeTypeTemplate nodeType = nodeTypeManager.createNodeTypeTemplate(); nodeType.setName(name); nodeType.setDeclaredSuperTypeNames(superTypeNames); nodeType.setMixin(isMixin); nodeType.setOrderableChildNodes(isOrderableChildNodes); nodeType.setPrimaryItemName(primaryItemName); nodeType.setQueryable(isQueryable); return nodeType; }
private void registerMixin( String name, String... declaredSuperTypes ) throws RepositoryException { NodeTypeTemplate nodeTypeTemplate = nodeTypeMgr.createNodeTypeTemplate(); nodeTypeTemplate.setMixin(true); nodeTypeTemplate.setName(name); nodeTypeTemplate.setQueryable(true); if (declaredSuperTypes.length > 0) { nodeTypeTemplate.setDeclaredSuperTypeNames(declaredSuperTypes); } nodeTypeMgr.registerNodeType(nodeTypeTemplate, true); } }
@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); }
@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); } }
@Override protected void setUp() throws Exception { super.setUp(); NodeTypeManager ntMgr = superuser.getWorkspace().getNodeTypeManager(); NodeTypeTemplate template = ntMgr.createNodeTypeTemplate(); template.setName(NT_NAME); template.setDeclaredSuperTypeNames(new String[] {JcrConstants.NT_BASE}); template.setMixin(false); PropertyDefinitionTemplate pdt = ntMgr.createPropertyDefinitionTemplate(); pdt.setName(BOOLEAN_PROP_NAME); pdt.setRequiredType(PropertyType.BOOLEAN); template.getPropertyDefinitionTemplates().add(pdt); pdt = ntMgr.createPropertyDefinitionTemplate(); pdt.setName(LONG_PROP_NAME); pdt.setRequiredType(PropertyType.LONG); template.getPropertyDefinitionTemplates().add(pdt); ntMgr.registerNodeType(template, true); node = testRootNode.addNode(nodeName2, NT_NAME); assertEquals(NT_NAME, node.getPrimaryNodeType().getName()); }
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); }
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); }
@Override protected NodeTypeTemplate configureNodeType() throws RepositoryException { NodeDefinitionTemplate ndt = getNodeTypeManager().createNodeDefinitionTemplate(); ndt.setAutoCreated(true); ndt.setDefaultPrimaryTypeName("mgnl:metaData"); ndt.setMandatory(true); ndt.setName("MetaData"); ndt.setOnParentVersion(OnParentVersionAction.COPY); ndt.setProtected(false); ndt.setSameNameSiblings(false); ndt.setRequiredPrimaryTypeNames(new String[] { "mgnl:metaData" }); NodeTypeTemplate ntt = getNodeTypeManager().createNodeTypeTemplate(); ntt.setName(getOriginalNodeType().getName()); ntt.setMixin(getOriginalNodeType().isMixin()); ntt.setOrderableChildNodes(getOriginalNodeType().hasOrderableChildNodes()); ntt.setDeclaredSuperTypeNames(getOriginalNodeType().getDeclaredSupertypeNames()); ntt.getNodeDefinitionTemplates().add(ndt); return ntt; }