/** * Create a {@link NodeDefinitionTemplate} set as 'childNodeDefinition' on a 'nodeType'.<br> * * @param name if blank, set '*' as value. * @param onParentVersion if not a valid {@link OnParentVersionAction} constant, set {@link OnParentVersionAction#IGNORE} as value. */ public static NodeDefinitionTemplate createChildNodeDefinition(NodeTypeManager nodeTypeManager, boolean isAutoCreated, boolean isMandatory, boolean isProtected, boolean allowSameNameSiblings, String defaultPrimaryTypeName, String name, int onParentVersion, String[] requiredPrimaryTypeNames) throws RepositoryException { // Create child node NodeDefinitionTemplate childNodeType = nodeTypeManager.createNodeDefinitionTemplate(); if (StringUtils.isNotBlank(defaultPrimaryTypeName)) { childNodeType.setDefaultPrimaryTypeName(defaultPrimaryTypeName); } childNodeType.setName(StringUtils.isBlank(name) ? "*" : name); childNodeType.setMandatory(isMandatory); childNodeType.setSameNameSiblings(allowSameNameSiblings); childNodeType.setAutoCreated(isAutoCreated); childNodeType.setProtected(isProtected); // Set OnParentVersionAction try { OnParentVersionAction.nameFromValue(onParentVersion); } catch (IllegalArgumentException ie) { log.warn("OnParentVersionAction constant definition '{}' is not valid. IGNORE will be set", onParentVersion); onParentVersion = OnParentVersionAction.IGNORE; } childNodeType.setOnParentVersion(onParentVersion); childNodeType.setRequiredPrimaryTypeNames(requiredPrimaryTypeNames); return childNodeType; }
private NodeDefinitionTemplate getWildcardNode( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeDefinitionTemplate t = ntMgr.createNodeDefinitionTemplate(); t.setName( "*" ); //$NON-NLS-1$ t.setRequiredPrimaryTypeNames( new String[] { NT + "base" } ); //$NON-NLS-1$ t.setDefaultPrimaryTypeName( NT + "unstructured" ); //$NON-NLS-1$ t.setOnParentVersion( OnParentVersionAction.IGNORE ); t.setSameNameSiblings( false ); return t; }
private NodeDefinitionTemplate getInternalFolderNode( final NodeTypeManager ntMgr, final ValueFactory vFac ) throws RepositoryException { NodeDefinitionTemplate t = ntMgr.createNodeDefinitionTemplate(); t.setName( "*" ); //$NON-NLS-1$ t.setRequiredPrimaryTypeNames( new String[] { PHO_NT + "pentahoInternalFolder" } ); //$NON-NLS-1$ t.setOnParentVersion( OnParentVersionAction.IGNORE ); return t; }
@Override public void build() throws ConstraintViolationException { template.setAutoCreated(super.autocreate); template.setMandatory(super.isMandatory); template.setOnParentVersion(super.onParent); template.setProtected(super.isProtected); template.setRequiredPrimaryTypeNames(requiredPrimaryTypes .toArray(new String[requiredPrimaryTypes.size()])); template.setSameNameSiblings(super.allowSns); @SuppressWarnings("unchecked") List<NodeDefinitionTemplate> templates = ntd.template.getNodeDefinitionTemplates(); templates.add(template); } }
ndt.setName(null); fail("null isn't a valid JCR name"); } catch (ConstraintViolationException e) { ndt.setName(expandedName); assertEquals(jcrName, ndt.getName()); ndt.setName(jcrName); assertEquals(jcrName, ndt.getName()); ndt.setSameNameSiblings(true); assertTrue(ndt.allowsSameNameSiblings()); ndt.setAutoCreated(true); assertTrue(ndt.isAutoCreated()); ndt.setMandatory(true); assertTrue(ndt.isMandatory()); ndt.setProtected(true); assertTrue(ndt.isProtected()); ndt.setOnParentVersion(OnParentVersionAction.VERSION); assertEquals(OnParentVersionAction.VERSION, ndt.getOnParentVersion()); ndt.setDefaultPrimaryTypeName(expandedName); assertEquals(jcrName, ndt.getDefaultPrimaryTypeName()); ndt.setDefaultPrimaryTypeName(null); assertEquals("setting null must clear the name.", null, ndt.getDefaultPrimaryTypeName());
@SuppressWarnings( {"unchecked"} ) private NodeTypeTemplate createMixinWithAutoChild( NodeTypeManager mgr ) throws RepositoryException { NodeTypeTemplate mixinTypeWithAutoChild = mgr.createNodeTypeTemplate(); mixinTypeWithAutoChild.setName("mixinTypeWithAutoCreatedChildNode"); mixinTypeWithAutoChild.setMixin(true); NodeDefinitionTemplate childNodeB = mgr.createNodeDefinitionTemplate(); childNodeB.setName(CHILD_NODE_B); childNodeB.setOnParentVersion(OnParentVersionAction.IGNORE); childNodeB.setMandatory(true); childNodeB.setAutoCreated(true); childNodeB.setDefaultPrimaryTypeName("nt:unstructured"); childNodeB.setRequiredPrimaryTypeNames(new String[] {"nt:unstructured"}); mixinTypeWithAutoChild.getNodeDefinitionTemplates().add(childNodeB); return mixinTypeWithAutoChild; }
@Test public void addNodeTest() throws RepositoryException { Session session = getAdminSession(); // node type with default child-node type of to nt:base String ntName = "test"; NodeTypeManager ntm = session.getWorkspace().getNodeTypeManager(); NodeTypeTemplate ntt = ntm.createNodeTypeTemplate(); ntt.setName(ntName); NodeDefinitionTemplate child = ntm.createNodeDefinitionTemplate(); child.setName("*"); child.setDefaultPrimaryTypeName("nt:base"); child.setRequiredPrimaryTypeNames(new String[] {"nt:base"}); List<NodeDefinition> children = ntt.getNodeDefinitionTemplates(); children.add(child); ntm.registerNodeType(ntt, true); // try to create a node with the default nt:base Node node = session.getRootNode().addNode("defaultNtBase", ntName); node.addNode("nothrow"); // See OAK-1013 try { node.addNode("throw", "nt:hierarchyNode"); fail("Abstract primary type should cause ConstraintViolationException"); } catch (ConstraintViolationException expected) { } session.save(); }
@SuppressWarnings( {"unchecked"} ) private NodeTypeTemplate createMixinProtected( NodeTypeManager mgr, boolean makeItemsProtected ) throws RepositoryException { NodeTypeTemplate mixinProtected = mgr.createNodeTypeTemplate(); mixinProtected.setName(MIXIN_PROTECTED); mixinProtected.setMixin(true); NodeDefinitionTemplate childProtected = mgr.createNodeDefinitionTemplate(); childProtected.setName(CHILD_PROTECTED); childProtected.setProtected(makeItemsProtected); childProtected.setDefaultPrimaryTypeName("nt:base"); childProtected.setOnParentVersion(OnParentVersionAction.IGNORE); mixinProtected.getNodeDefinitionTemplates().add(childProtected); PropertyDefinitionTemplate propertyProtected = mgr.createPropertyDefinitionTemplate(); propertyProtected.setProtected(makeItemsProtected); propertyProtected.setName(PROPERTY_PROTECTED); propertyProtected.setOnParentVersion(OnParentVersionAction.IGNORE); propertyProtected.setRequiredType(PropertyType.STRING); mixinProtected.getPropertyDefinitionTemplates().add(propertyProtected); return mixinProtected; }
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"} ) private NodeTypeTemplate createMixinB( NodeTypeManager mgr ) throws RepositoryException { NodeTypeTemplate mixinTypeB = mgr.createNodeTypeTemplate(); mixinTypeB.setName(MIXIN_TYPE_B); mixinTypeB.setMixin(true); NodeDefinitionTemplate childNodeB = mgr.createNodeDefinitionTemplate(); childNodeB.setName(CHILD_NODE_B); childNodeB.setDefaultPrimaryTypeName("nt:base"); childNodeB.setOnParentVersion(OnParentVersionAction.IGNORE); mixinTypeB.getNodeDefinitionTemplates().add(childNodeB); PropertyDefinitionTemplate propertyB = mgr.createPropertyDefinitionTemplate(); propertyB.setName(PROPERTY_B); propertyB.setOnParentVersion(OnParentVersionAction.IGNORE); propertyB.setRequiredType(PropertyType.BINARY); mixinTypeB.getPropertyDefinitionTemplates().add(propertyB); NodeDefinitionTemplate childNodeA = mgr.createNodeDefinitionTemplate(); childNodeA.setName(CHILD_NODE_A); childNodeA.setOnParentVersion(OnParentVersionAction.IGNORE); mixinTypeB.getNodeDefinitionTemplates().add(childNodeA); return mixinTypeB; }
template.setName("car:Owner"); NodeDefinitionTemplate childDefn = ntManager.createNodeDefinitionTemplate(); childDefn.setSameNameSiblings(false); childDefn.setName("*"); childDefn.setRequiredPrimaryTypeNames(new String[] {"car:Car"}); template.getNodeDefinitionTemplates().add(childDefn);
childDefn.setSameNameSiblings(false); childDefn.setRequiredPrimaryTypeNames(new String[] {"nt:unstructured"}); childDefn.setDefaultPrimaryTypeName("nt:unstructured"); NodeTypeTemplate nodeType = ntMgr.createNodeTypeTemplate(); nodeType.setName("noSnsChildren");
@SuppressWarnings( {"unchecked"} ) private NodeTypeTemplate createPrimaryTypeA( NodeTypeManager mgr ) throws RepositoryException { NodeTypeTemplate primaryTypeA = mgr.createNodeTypeTemplate(); primaryTypeA.setName(PRIMARY_TYPE_A); NodeDefinitionTemplate childNodeA = mgr.createNodeDefinitionTemplate(); childNodeA.setName(CHILD_NODE_A); childNodeA.setOnParentVersion(OnParentVersionAction.IGNORE); primaryTypeA.getNodeDefinitionTemplates().add(childNodeA); PropertyDefinitionTemplate propertyA = mgr.createPropertyDefinitionTemplate(); propertyA.setName(PROPERTY_A); propertyA.setOnParentVersion(OnParentVersionAction.IGNORE); propertyA.setRequiredType(PropertyType.STRING); primaryTypeA.getPropertyDefinitionTemplates().add(propertyA); return primaryTypeA; }
@Override protected void doFinish() throws RepositoryException { currentChildDefn.setRequiredPrimaryTypeNames(getStringValues()); } }
@Override public void setName(String name) throws RepositoryException { super.setName(name); template.setName(name); }
@Override public void setDefaultPrimaryType(String name) throws ConstraintViolationException { template.setDefaultPrimaryTypeName(name); }
public void testResidualNames() throws Exception { String residualName = "*"; NodeDefinitionTemplate ndt = ntm.createNodeDefinitionTemplate(); ndt.setName(residualName); assertEquals(residualName, ndt.getName()); PropertyDefinitionTemplate pdt = ntm.createPropertyDefinitionTemplate(); pdt.setName(residualName); assertEquals(residualName, pdt.getName()); }
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 NodeDefinitionTemplate getDescriptionNode( final NodeTypeManager ntMgr ) throws RepositoryException { NodeDefinitionTemplate t = ntMgr.createNodeDefinitionTemplate(); t.setName( PHO + "description" ); //$NON-NLS-1$ t.setRequiredPrimaryTypeNames( new String[] { PHO_NT + "localizedString" } ); //$NON-NLS-1$ t.setOnParentVersion( OnParentVersionAction.COPY ); t.setSameNameSiblings( false ); return t; }
@Override public void build() throws ConstraintViolationException { template.setAutoCreated(super.autocreate); template.setMandatory(super.isMandatory); template.setOnParentVersion(super.onParent); template.setProtected(super.isProtected); template.setRequiredPrimaryTypeNames(requiredPrimaryTypes .toArray(new String[requiredPrimaryTypes.size()])); template.setSameNameSiblings(super.allowSns); @SuppressWarnings("unchecked") List<NodeDefinitionTemplate> templates = ntd.template.getNodeDefinitionTemplates(); templates.add(template); } }