@Override public void setDefaultPrimaryType(String name) throws ConstraintViolationException { template.setDefaultPrimaryTypeName(name); }
@Override public void setDefaultPrimaryType(String name) throws ConstraintViolationException { template.setDefaultPrimaryTypeName(name); }
@Override public void setDefaultPrimaryType(String name) throws ConstraintViolationException { template.setDefaultPrimaryTypeName(name); }
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; }
/** * Creates the node definition template. * * @param ntm the ntm * @param types the types * @return the node definition template * @throws RepositoryException the repository exception */ private static NodeDefinitionTemplate createNodeDefTemplate(NodeTypeManager ntm, String[] types) throws RepositoryException { NodeDefinitionTemplate ndt = ntm.createNodeDefinitionTemplate(); ndt.setOnParentVersion(OnParentVersionAction.IGNORE); ndt.setRequiredPrimaryTypeNames(types); ndt.setDefaultPrimaryTypeName(types[0]); ndt.setName("*"); return ndt; } }
private void buildChildNodeDefs(OMElement omElement) throws RepositoryException { Iterator cndIt = omElement.getChildrenWithLocalName("childNodeDefinition"); while (cndIt.hasNext()) { NodeDefinitionTemplate nodeDefinitionTemplate = nodeTypeManager.createNodeDefinitionTemplate(); OMElement childDefs = (OMElement) cndIt.next(); nodeDefinitionTemplate.setName(getAttrValue("name", childDefs)); // TODO should validate * nodeDefinitionTemplate.setAutoCreated(Boolean.valueOf(getAttrValue("autoCreated", childDefs))); nodeDefinitionTemplate.setMandatory(Boolean.valueOf(getAttrValue("mandatory", childDefs))); nodeDefinitionTemplate.setProtected(Boolean.valueOf(getAttrValue("protected", childDefs))); nodeDefinitionTemplate.setOnParentVersion(OnParentVersionAction.valueFromName(getAttrValue("onParentVersion", childDefs))); nodeDefinitionTemplate.setSameNameSiblings(Boolean.valueOf(getAttrValue("sameNameSiblings", childDefs))); String dpt = getAttrValue("defaultPrimaryType", childDefs); // check value length >0 if (dpt != null && dpt.length() > 0) { nodeDefinitionTemplate.setDefaultPrimaryTypeName(dpt); } Iterator reqPriTypesIt = childDefs.getChildrenWithLocalName("requiredPrimaryTypes"); while (reqPriTypesIt.hasNext()) { //one time OMElement supertypes = (OMElement) reqPriTypesIt.next(); Iterator supertype = supertypes.getChildrenWithLocalName("requiredPrimaryType"); List<String> rptList = new ArrayList<String>(); while (supertype.hasNext()) { rptList.add(((OMElement) supertype.next()).getText()); // requiredPrimaryType } nodeDefinitionTemplate.setRequiredPrimaryTypeNames(rptList.toArray(new String[0])); } ((RegistryNodeDefinitionTemplate) nodeDefinitionTemplate). setDeclaringNodeTypeName(nodeTypeTemplate.getName()); nodeTypeTemplate.getNodeDefinitionTemplates().add(nodeDefinitionTemplate); } }
/** * 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 createNodeDefinitionTemplate(NodeTypeManager ntMgr, QNodeDefinition def) throws RepositoryException { NodeDefinitionTemplate tmpl = ntMgr.createNodeDefinitionTemplate(); Name name = def.getName(); if (name != null) { tmpl.setName(getOakName(name)); } tmpl.setAutoCreated(def.isAutoCreated()); tmpl.setMandatory(def.isMandatory()); tmpl.setOnParentVersion(def.getOnParentVersion()); tmpl.setProtected(def.isProtected()); tmpl.setSameNameSiblings(def.allowsSameNameSiblings()); List<String> names = newArrayListWithCapacity(def.getRequiredPrimaryTypes().length); for (Name type : def.getRequiredPrimaryTypes()) { names.add(getOakName(type)); } tmpl.setRequiredPrimaryTypeNames(names.toArray(new String[names.size()])); Name type = def.getDefaultPrimaryType(); if (type != null) { tmpl.setDefaultPrimaryTypeName(getOakName(type)); } return tmpl; }
private NodeDefinitionTemplate createNodeDefinitionTemplate(NodeTypeManager ntMgr, QNodeDefinition def) throws RepositoryException { NodeDefinitionTemplate tmpl = ntMgr.createNodeDefinitionTemplate(); Name name = def.getName(); if (name != null) { tmpl.setName(getOakName(name)); } tmpl.setAutoCreated(def.isAutoCreated()); tmpl.setMandatory(def.isMandatory()); tmpl.setOnParentVersion(def.getOnParentVersion()); tmpl.setProtected(def.isProtected()); tmpl.setSameNameSiblings(def.allowsSameNameSiblings()); List<String> names = newArrayListWithCapacity(def.getRequiredPrimaryTypes().length); for (Name type : def.getRequiredPrimaryTypes()) { names.add(getOakName(type)); } tmpl.setRequiredPrimaryTypeNames(names.toArray(new String[names.size()])); Name type = def.getDefaultPrimaryType(); if (type != null) { tmpl.setDefaultPrimaryTypeName(getOakName(type)); } return tmpl; }
@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(); }
public void testAddItemsDefinedByMixin3() 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"}); nodeDef.setDefaultPrimaryTypeName("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 without specifying the // node type -> must succeed since default primary type is specified // in the child node def Node c = node.addNode("child"); assertEquals("nt:folder", c.getPrimaryNodeType().getName()); superuser.save(); } }
@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; }
@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; }
@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; }
private NodeDefinitionTemplate getNodeDefinition(final javax.jcr.nodetype.NodeTypeManager ntm, final ValueFactory valueFactory, final ChildNodeDefDescriptor field) throws RepositoryException { final NodeDefinitionTemplate ndt = ntm.createNodeDefinitionTemplate(); if (field.getJcrName() != null) { ndt.setName(field.getJcrName()); } else { ndt.setName("*"); } int onParentVersion = OnParentVersionAction.IGNORE; if (field.getJcrOnParentVersion() != null && field.getJcrOnParentVersion().length() > 0) { onParentVersion = OnParentVersionAction.valueFromName(field.getJcrOnParentVersion()); } ndt.setOnParentVersion(onParentVersion); ndt.setSameNameSiblings(field.isJcrSameNameSiblings()); ndt.setAutoCreated(field.isJcrAutoCreated()); ndt.setDefaultPrimaryTypeName(field.getDefaultPrimaryType()); ndt.setMandatory(field.isJcrMandatory()); ndt.setProtected(field.isJcrProtected()); ndt.setRequiredPrimaryTypeNames(getJcrSuperTypes(field.getJcrType())); return ndt; }
@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; }
/** * Create a new JCR node definition from the given <code>QNodeDefinition</code>. * * @param qNd A node definition. * @return The corresponding JCR node definition. * @throws RepositoryException if an error occurs. */ public NodeDefinition create(QNodeDefinition qNd) throws RepositoryException { NodeDefinitionTemplate nt = ntMgr.createNodeDefinitionTemplate(); nt.setName(getJCRName(qNd.getName())); nt.setAutoCreated(qNd.isAutoCreated()); nt.setMandatory(qNd.isMandatory()); nt.setOnParentVersion(qNd.getOnParentVersion()); nt.setProtected(qNd.isProtected()); nt.setSameNameSiblings(qNd.allowsSameNameSiblings()); nt.setDefaultPrimaryTypeName(getJCRName(qNd.getDefaultPrimaryType())); nt.setRequiredPrimaryTypeNames(getJCRNames(qNd.getRequiredPrimaryTypes())); return nt; }
/** * Create a new JCR node definition from the given <code>QNodeDefinition</code>. * * @param qNd A node definition. * @return The corresponding JCR node definition. * @throws RepositoryException if an error occurs. */ public NodeDefinition create(QNodeDefinition qNd) throws RepositoryException { NodeDefinitionTemplate nt = ntMgr.createNodeDefinitionTemplate(); nt.setName(getJCRName(qNd.getName())); nt.setAutoCreated(qNd.isAutoCreated()); nt.setMandatory(qNd.isMandatory()); nt.setOnParentVersion(qNd.getOnParentVersion()); nt.setProtected(qNd.isProtected()); nt.setSameNameSiblings(qNd.allowsSameNameSiblings()); nt.setDefaultPrimaryTypeName(getJCRName(qNd.getDefaultPrimaryType())); nt.setRequiredPrimaryTypeNames(getJCRNames(qNd.getRequiredPrimaryTypes())); return nt; }
protected NodeDefinition readChildNodeDefinition( CachedNode childDefn ) throws ConstraintViolationException { NodeDefinitionTemplate defn = new JcrNodeDefinitionTemplate(context()); defn.setName(strings.create(first(childDefn, JcrLexicon.NAME, JcrNodeType.RESIDUAL_ITEM_NAME))); defn.setAutoCreated(booleans.create(first(childDefn, JcrLexicon.AUTO_CREATED))); defn.setMandatory(booleans.create(first(childDefn, JcrLexicon.MANDATORY))); defn.setSameNameSiblings(booleans.create(first(childDefn, JcrLexicon.SAME_NAME_SIBLINGS))); defn.setProtected(booleans.create(first(childDefn, JcrLexicon.PROTECTED))); defn.setOnParentVersion(OnParentVersionAction.valueFromName(strings.create(first(childDefn, JcrLexicon.ON_PARENT_VERSION)))); String defaultPrimaryType = strings.create(first(childDefn, JcrLexicon.DEFAULT_PRIMARY_TYPE)); if (defaultPrimaryType != null) defn.setDefaultPrimaryTypeName(defaultPrimaryType); Property requiredPrimaryTypes = childDefn.getProperty(JcrLexicon.REQUIRED_PRIMARY_TYPES, system); if (requiredPrimaryTypes != null && !requiredPrimaryTypes.isEmpty()) { String[] values = new String[requiredPrimaryTypes.size()]; int i = 0; for (Object op : requiredPrimaryTypes) { values[i++] = strings.create(op); } defn.setRequiredPrimaryTypeNames(values); } return defn; }
protected NodeDefinition readChildNodeDefinition( CachedNode childDefn ) throws ConstraintViolationException { NodeDefinitionTemplate defn = new JcrNodeDefinitionTemplate(context()); defn.setName(strings.create(first(childDefn, JcrLexicon.NAME, JcrNodeType.RESIDUAL_ITEM_NAME))); defn.setAutoCreated(booleans.create(first(childDefn, JcrLexicon.AUTO_CREATED))); defn.setMandatory(booleans.create(first(childDefn, JcrLexicon.MANDATORY))); defn.setSameNameSiblings(booleans.create(first(childDefn, JcrLexicon.SAME_NAME_SIBLINGS))); defn.setProtected(booleans.create(first(childDefn, JcrLexicon.PROTECTED))); defn.setOnParentVersion(OnParentVersionAction.valueFromName(strings.create(first(childDefn, JcrLexicon.ON_PARENT_VERSION)))); String defaultPrimaryType = strings.create(first(childDefn, JcrLexicon.DEFAULT_PRIMARY_TYPE)); if (defaultPrimaryType != null) defn.setDefaultPrimaryTypeName(defaultPrimaryType); Property requiredPrimaryTypes = childDefn.getProperty(JcrLexicon.REQUIRED_PRIMARY_TYPES, system); if (requiredPrimaryTypes != null && !requiredPrimaryTypes.isEmpty()) { String[] values = new String[requiredPrimaryTypes.size()]; int i = 0; for (Object op : requiredPrimaryTypes) { values[i++] = strings.create(op); } defn.setRequiredPrimaryTypeNames(values); } return defn; }