@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; }
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 + "pentahoInternalFolder" ); //$NON-NLS-1$ t.setOrderableChildNodes( true ); t.getPropertyDefinitionTemplates().add( getWildcardMultipleProperty( ntMgr, vFac ) ); t.getPropertyDefinitionTemplates().add( getWildcardProperty( ntMgr, vFac ) ); t.getNodeDefinitionTemplates().add( getWildcardNode( ntMgr, vFac ) ); return t; }
void commit() throws RepositoryException { if (draft != null) { if (current != null) { current.remove(); } // register node type NodeTypeManager ntMgr = subject.getSession().getWorkspace().getNodeTypeManager(); if (!ntMgr.hasNodeType(prefix + ":" + name)) { NodeTypeTemplate ntTpl = ntMgr.createNodeTypeTemplate(); ntTpl.setName(prefix + ":" + name); 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(); } ntTpl.setDeclaredSuperTypeNames(superStrings); } ntTpl.setOrderableChildNodes(true); ntMgr.registerNodeType(ntTpl, false); } draft.addMixin(HippoNodeType.NT_REMODEL); draft.setProperty(HippoNodeType.HIPPO_URI, uri); current = draft; draft = null; } }
/** * 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; } }
public NodeTypeTemplate buildNodeType(OMElement omElement) throws JaxenException, RepositoryException { nodeTypeTemplate = nodeTypeManager.createNodeTypeTemplate(); nodeTypeTemplate.setName(getAttrValue("name", omElement)); nodeTypeTemplate.setMixin(Boolean.valueOf(getAttrValue("isMixin", omElement))); nodeTypeTemplate.setOrderableChildNodes(Boolean.valueOf(getAttrValue("hasOrderableChildNodes", omElement))); nodeTypeTemplate.setAbstract(Boolean.valueOf(getAttrValue("isAbstract", omElement))); nodeTypeTemplate.setQueryable(Boolean.valueOf(getAttrValue("isQueryable", omElement))); nodeTypeTemplate.setPrimaryItemName(getAttrValue("primaryItemName", omElement)); buildSupertypes(omElement); buildChildNodeDefs(omElement); buildPropertyDefs(omElement); // System.out.println(omElement.toString()); return nodeTypeTemplate; }
/** * 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; }
public static void registerDocumentType( final PluginContext context, final String prefix, final String name, final boolean orderable, final boolean mixin, final String... superTypes) throws RepositoryException { final Session session = context.createSession(); try { final Workspace workspace = session.getWorkspace(); final NodeTypeManager manager = workspace.getNodeTypeManager(); final NodeTypeTemplate template = manager.createNodeTypeTemplate(); template.setName(prefix + ':' + name); template.setOrderableChildNodes(orderable); template.setMixin(mixin); if (superTypes.length > 0) { template.setDeclaredSuperTypeNames(superTypes); } manager.registerNodeType(template, false); } finally { GlobalUtils.cleanupSession(session); } }
public static void registerDocumentType( final PluginContext context, final String prefix, final String name, final boolean orderable, final boolean mixin, final String... superTypes) throws RepositoryException { final Session session = context.createSession(); try { final Workspace workspace = session.getWorkspace(); final NodeTypeManager manager = workspace.getNodeTypeManager(); final NodeTypeTemplate template = manager.createNodeTypeTemplate(); template.setName(prefix + ':' + name); template.setOrderableChildNodes(orderable); template.setMixin(mixin); if (superTypes.length > 0) { template.setDeclaredSuperTypeNames(superTypes); } manager.registerNodeType(template, false); } finally { GlobalUtils.cleanupSession(session); } }
tmpl.setAbstract(def.isAbstract()); tmpl.setMixin(def.isMixin()); tmpl.setOrderableChildNodes(def.hasOrderableChildNodes()); tmpl.setQueryable(def.isQueryable());
tmpl.setAbstract(def.isAbstract()); tmpl.setMixin(def.isMixin()); tmpl.setOrderableChildNodes(def.hasOrderableChildNodes()); tmpl.setQueryable(def.isQueryable());
public void testRegisterNodeType() throws Exception { NodeTypeTemplate ntt = ntm.createNodeTypeTemplate(); ntt.setName("mix:foo"); ntt.setAbstract(false); ntt.setMixin(true); ntt.setOrderableChildNodes(false); ntt.setQueryable(false); PropertyDefinitionTemplate pdt = ntm.createPropertyDefinitionTemplate(); pdt.setAutoCreated(false); pdt.setName("foo"); pdt.setMultiple(false); pdt.setRequiredType(PropertyType.STRING); List pdefs = ntt.getPropertyDefinitionTemplates(); pdefs.add(pdt); ntm.registerNodeType(ntt, true); try { ntm.registerNodeType(ntt, false); fail("NodeTypeExistsException expected."); } catch (NodeTypeExistsException e) { // success } }
public void testRegisterNodeTypes() throws Exception { NodeTypeDefinition[] defs = new NodeTypeDefinition[5]; for (int i = 0; i < defs.length; i++) { NodeTypeTemplate ntt = ntm.createNodeTypeTemplate(); ntt.setName("mix:foo" + i); ntt.setAbstract(false); ntt.setMixin(true); ntt.setOrderableChildNodes(false); ntt.setQueryable(false); PropertyDefinitionTemplate pdt = ntm.createPropertyDefinitionTemplate(); pdt.setAutoCreated(false); pdt.setName("foo" + i); pdt.setMultiple(false); pdt.setRequiredType(PropertyType.STRING); List pdefs = ntt.getPropertyDefinitionTemplates(); pdefs.add(pdt); defs[i] = ntt; } ntm.registerNodeTypes(defs, true); try { ntm.registerNodeTypes(defs, false); fail("NodeTypeExistsException expected."); } catch (NodeTypeExistsException e) { // success } }
/** * Create a new JCR node type definition from the given * <code>QNodeTypeDefinition</code>. * * @param qNtd A SPI node type definition. * @return the corresponding JCR node type definition. * @throws RepositoryException if an error occurs. */ @SuppressWarnings("unchecked") public NodeTypeDefinition create(QNodeTypeDefinition qNtd) throws RepositoryException { NodeTypeTemplate nt = ntMgr.createNodeTypeTemplate(); nt.setName(getJCRName(qNtd.getName())); nt.setDeclaredSuperTypeNames(getJCRNames(qNtd.getSupertypes())); nt.setAbstract(qNtd.isAbstract()); nt.setMixin(qNtd.isMixin()); nt.setOrderableChildNodes(qNtd.hasOrderableChildNodes()); nt.setPrimaryItemName(getJCRName(qNtd.getPrimaryItemName())); nt.setQueryable(qNtd.isQueryable()); List nodeDefs = nt.getNodeDefinitionTemplates(); for (QNodeDefinition qNd: qNtd.getChildNodeDefs()) { nodeDefs.add(create(qNd)); } List propDefs = nt.getPropertyDefinitionTemplates(); for (QPropertyDefinition qPd: qNtd.getPropertyDefs()) { propDefs.add(create(qPd)); } return nt; }
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; }
public void testRegisterNodeTypes() throws RepositoryException { NodeTypeTemplate test = ntMgr.createNodeTypeTemplate(); test.setName("testNodeType"); ntMgr.registerNodeType(test, true); NodeType nt = ntMgr.getNodeType("testNodeType"); assertNotNull(nt); assertEquals("testNodeType", nt.getName()); test.setOrderableChildNodes(true); ntMgr.registerNodeType(test, true); nt = ntMgr.getNodeType("testNodeType"); assertNotNull(nt); assertEquals("testNodeType", nt.getName()); assertEquals(test.hasOrderableChildNodes(), nt.hasOrderableChildNodes()); test.setDeclaredSuperTypeNames(new String[] {"nt:unstructured"}); try { ntMgr.registerNodeType(test, false); fail("NodeTypeExistsException expected"); } catch (NodeTypeExistsException e) { // success } }