@SuppressWarnings("unchecked")
@Test
public void shouldAllowUnregisteringUnusedTypesWithMutualDependencies() throws Exception {
ntTemplate.setName(TEST_TYPE_NAME);
JcrNodeDefinitionTemplate childNode = new JcrNodeDefinitionTemplate(this.context);
childNode.setDefaultPrimaryTypeName(TEST_TYPE_NAME2);
ntTemplate.getNodeDefinitionTemplates().add(childNode);
NodeTypeTemplate ntTemplate2 = new JcrNodeTypeTemplate(this.context);
ntTemplate2.setName(TEST_TYPE_NAME2);
JcrNodeDefinitionTemplate childNode2 = new JcrNodeDefinitionTemplate(this.context);
childNode2.setDefaultPrimaryTypeName(TEST_TYPE_NAME);
ntTemplate2.getNodeDefinitionTemplates().add(childNode2);
try {
repoTypeManager.registerNodeTypes(
Arrays.asList(new NodeTypeDefinition[] {ntTemplate, ntTemplate2}));
} catch (Exception ex) {
fail(ex.getMessage());
}
Name typeNameAsName = nameFactory.create(TEST_TYPE_NAME);
Name type2NameAsName = nameFactory.create(TEST_TYPE_NAME2);
int nodeTypeCount = nodeTypes().getAllNodeTypes().size();
repoTypeManager.unregisterNodeType(
Arrays.asList(new Name[] {typeNameAsName, type2NameAsName}), true);
assertThat(nodeTypes().getAllNodeTypes().size(), is(nodeTypeCount - 2));
assertThat(nodeTypes().getNodeType(typeNameAsName), is(nullValue()));
assertThat(nodeTypes().getNodeType(type2NameAsName), is(nullValue()));
}
/**
* Returns a {@code NodeTypeTemplate} based on the definition given in {@code ntd}. This template
* can then be used to define a node type and passed to {@link
* JcrNodeTypeManager#registerNodeType(NodeTypeDefinition, boolean)}
*
* @param ntd an existing node type definition; null values will be ignored
* @return an empty {@code NodeTypeTemplate} which can then be used to define a node type and
* passed to {@link JcrNodeTypeManager#registerNodeType(NodeTypeDefinition, boolean)}.
* @throws RepositoryException if another error occurs
*/
@Override
@SuppressWarnings("unchecked")
public NodeTypeTemplate createNodeTypeTemplate(NodeTypeDefinition ntd)
throws RepositoryException {
NodeTypeTemplate ntt = new JcrNodeTypeTemplate(context(), true);
if (ntd != null) {
ntt.setName(ntd.getName());
ntt.setAbstract(ntd.isAbstract());
ntt.setDeclaredSuperTypeNames(ntd.getDeclaredSupertypeNames());
ntt.setMixin(ntd.isMixin());
ntt.setOrderableChildNodes(ntd.hasOrderableChildNodes());
ntt.setPrimaryItemName(ntd.getPrimaryItemName());
ntt.setQueryable(ntd.isQueryable());
// copy child nodes and props
for (NodeDefinition nodeDefinition : ntd.getDeclaredChildNodeDefinitions()) {
JcrNodeDefinitionTemplate ndt = new JcrNodeDefinitionTemplate(context());
ndt.setAutoCreated(nodeDefinition.isAutoCreated());
ndt.setDefaultPrimaryTypeName(nodeDefinition.getDefaultPrimaryTypeName());
ndt.setMandatory(nodeDefinition.isMandatory());
if (nodeDefinition.getName() != null) {
ndt.setName(nodeDefinition.getName());
}
ndt.setOnParentVersion(nodeDefinition.getOnParentVersion());
ndt.setProtected(nodeDefinition.isProtected());
ndt.setRequiredPrimaryTypeNames(nodeDefinition.getRequiredPrimaryTypeNames());
ndt.setSameNameSiblings(nodeDefinition.allowsSameNameSiblings());
ntt.getNodeDefinitionTemplates().add(ndt);
}
for (PropertyDefinition propertyDefinition : ntd.getDeclaredPropertyDefinitions()) {
JcrPropertyDefinitionTemplate pdt = new JcrPropertyDefinitionTemplate(context());
pdt.setAutoCreated(propertyDefinition.isAutoCreated());
pdt.setAvailableQueryOperators(propertyDefinition.getAvailableQueryOperators());
pdt.setDefaultValues(propertyDefinition.getDefaultValues());
pdt.setFullTextSearchable(propertyDefinition.isFullTextSearchable());
pdt.setMandatory(propertyDefinition.isMandatory());
pdt.setMultiple(propertyDefinition.isMultiple());
if (propertyDefinition.getName() != null) {
pdt.setName(propertyDefinition.getName());
}
pdt.setOnParentVersion(propertyDefinition.getOnParentVersion());
pdt.setProtected(propertyDefinition.isProtected());
pdt.setQueryOrderable(propertyDefinition.isQueryOrderable());
pdt.setRequiredType(propertyDefinition.getRequiredType());
pdt.setValueConstraints(propertyDefinition.getValueConstraints());
ntt.getPropertyDefinitionTemplates().add(pdt);
}
}
return ntt;
}
/**
* 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;
}