/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.sling.ide.impl.vlt;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.jcr.PropertyType;
import javax.jcr.nodetype.NodeDefinition;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.PropertyDefinition;
import org.apache.sling.ide.transport.RepositoryException;
import org.apache.sling.ide.transport.ResourceProxy;
import org.apache.sling.ide.transport.Result;
import org.apache.sling.ide.util.PathUtil;
public class VltNodeTypeFactory {
private Map<String,VltNodeType> nodeTypes = new HashMap<String, VltNodeType>();
Map<String, VltNodeType> getNodeTypes() {
return nodeTypes;
}
public VltNodeType getNodeType(String name) {
return nodeTypes.get(name);
}
void init(VltRepository repository) throws RepositoryException {
Result<ResourceProxy> jcrSystem = repository.newListTreeNodeCommand("/jcr:system/jcr:nodeTypes", 3).execute();
// phase 1: create all node types
for (ResourceProxy child : jcrSystem.get().getChildren()) {
VltNodeType nt = createNodeType(child);
nodeTypes.put(nt.getName(), nt);
}
// phase 2: init declared fields
for (Iterator<VltNodeType> it = nodeTypes.values().iterator(); it.hasNext();) {
VltNodeType nt = it.next();
initDeclaredFields(nt);
}
// at this stage all declared fields are initialized, we can now calculate
// the rest
// phase 2: initialize the dependency tree (eg superTypes)
// - this is a separate phase to make sure, all VltNodeType objects have been created (above)
// hence initTypeDependencyTree can assume all nodetypes exist
for (Iterator<VltNodeType> it = nodeTypes.values().iterator(); it.hasNext();) {
VltNodeType nt = it.next();
initTypeDependencyTree(nt);
}
// phase 3: init property definitions
for (Iterator<VltNodeType> it = nodeTypes.values().iterator(); it.hasNext();) {
VltNodeType nt = it.next();
final ResourceProxy child = nt.getResourceProxy();
initPropertyDefinitions(nt);
initProperties(nt, child);
}
// phase 4: initialize the allowed primary childnodetypes
for (Iterator<VltNodeType> it = nodeTypes.values().iterator(); it.hasNext();) {
VltNodeType nt = it.next();
initAllowedPrimaryChildNodeTypes(nt);
}
}
private void initDeclaredFields(VltNodeType nt) {
final ResourceProxy child = nt.getResourceProxy();
String[] superTypeNamess = (String[]) child.getProperties()
.get("jcr:supertypes");
nt.setDeclaredSupertypeNames(superTypeNamess);
if (superTypeNamess!=null) {
NodeType[] superTypes = new NodeType[superTypeNamess.length];
for (int i = 0; i < superTypeNamess.length; i++) {
superTypes[i] = getNodeType(superTypeNamess[i]);
}
nt.setDeclaredSupertypes(superTypes);
}
Set<VltNodeDefinition> nds = new HashSet<VltNodeDefinition>();
for (Iterator<ResourceProxy> it = child.getChildren().iterator(); it
.hasNext();) {
ResourceProxy ntChild = it.next();
String ntChildName = PathUtil.getName(ntChild.getPath());
if (ntChildName.startsWith("jcr:childNodeDefinition")) {
VltNodeDefinition nd = handleChildNodeDefinition(ntChild);
nds.add(nd);
} else if (ntChildName.startsWith("rep:residualChildNodeDefinitions")) {
// go through children
List<ResourceProxy> residualChildren = ntChild.getChildren();
for (Iterator it2 = residualChildren.iterator(); it2
.hasNext();) {
ResourceProxy residualChild = (ResourceProxy) it2
.next();
VltNodeDefinition nd = handleChildNodeDefinition(residualChild);
nds.add(nd);
}
}
}
nt.setDeclaredChildNodeDefinitions(nds.toArray(new NodeDefinition[0]));
initDeclaredPropertyDefinitions(nt, child);
}
private VltNodeType createNodeType(ResourceProxy child) {
final VltNodeType nt = new VltNodeType(child);
final String name = PathUtil.getName(child.getPath());
nt.setName(name);
return nt;
}
private void initDeclaredPropertyDefinitions(VltNodeType nt, ResourceProxy child) {
Map<String,VltPropertyDefinition> pds = new HashMap<String,VltPropertyDefinition>();
// load propertyDefinition children
for (Iterator<ResourceProxy> it = child.getChildren().iterator(); it.hasNext();) {
ResourceProxy aChild = it.next();
String childName = PathUtil.getName(aChild.getPath());
if (childName.startsWith("jcr:propertyDefinition")) {
String jcrName = (String)aChild.getProperties().get("jcr:name");
if (jcrName!=null) {
VltPropertyDefinition pd = new VltPropertyDefinition();
pd.setName(jcrName);
Boolean autoCreated = (Boolean)aChild.getProperties().get("jcr:autoCreated");
if (autoCreated!=null) {
pd.setAutoCreated(autoCreated);
}
Boolean multiple = (Boolean)aChild.getProperties().get("jcr:multiple");
if (multiple!=null) {
pd.setMultiple(multiple);
}
Boolean mandatory = (Boolean)aChild.getProperties().get("jcr:mandatory");
if (mandatory!=null) {
pd.setMandatory(mandatory);
}
Boolean isProtected = (Boolean)aChild.getProperties().get("jcr:protected");
if (isProtected!=null) {
pd.setProtected(isProtected);
}
final Object object = aChild.getProperties().get("jcr:requiredType");
if (object!=null) {
String requiredType = (String)object;
if (requiredType!=null) {
pd.setRequiredType(propertyTypeFromName(requiredType));
}
}
pds.put(jcrName, pd);
}
}
}
// load mandatory
String[] mandatoryProperties = (String[]) child.getProperties().get("rep:mandatoryProperties");
if (mandatoryProperties!=null) {
for (int i = 0; i < mandatoryProperties.length; i++) {
String aMandatoryProperty = mandatoryProperties[i];
VltPropertyDefinition vpd = pds.get(aMandatoryProperty);
if (vpd==null) {
vpd = new VltPropertyDefinition();
vpd.setName(aMandatoryProperty);
pds.put(aMandatoryProperty, vpd);
}
vpd.setMandatory(true);
}
}
// load protected
String[] protectedProperties = (String[]) child.getProperties().get("rep:protectedProperties");
if (protectedProperties!=null) {
for (int i = 0; i < protectedProperties.length; i++) {
String aProtectedProperties = protectedProperties[i];
VltPropertyDefinition vpd = pds.get(aProtectedProperties);
if (vpd==null) {
vpd = new VltPropertyDefinition();
vpd.setName(aProtectedProperties);
pds.put(aProtectedProperties, vpd);
}
vpd.setProtected(true);
}
}
nt.setDeclaredPropertyDefinitions(pds.values().toArray(new VltPropertyDefinition[pds.size()]));
}
private int propertyTypeFromName(String name) {
if (name.equalsIgnoreCase(PropertyType.TYPENAME_STRING)) {
return PropertyType.STRING;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_BINARY)) {
return PropertyType.BINARY;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_BOOLEAN)) {
return PropertyType.BOOLEAN;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_LONG)) {
return PropertyType.LONG;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_DOUBLE)) {
return PropertyType.DOUBLE;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_DECIMAL)) {
return PropertyType.DECIMAL;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_DATE)) {
return PropertyType.DATE;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_NAME)) {
return PropertyType.NAME;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_PATH)) {
return PropertyType.PATH;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_REFERENCE)) {
return PropertyType.REFERENCE;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_WEAKREFERENCE)) {
return PropertyType.WEAKREFERENCE;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_URI)) {
return PropertyType.URI;
} else if (name.equalsIgnoreCase(PropertyType.TYPENAME_UNDEFINED)) {
return PropertyType.UNDEFINED;
} else {
throw new IllegalArgumentException("unknown type: " + name);
}
}
private void initPropertyDefinitions(VltNodeType nt) {
Map<String,VltPropertyDefinition> pds = new HashMap<String,VltPropertyDefinition>();
PropertyDefinition[] declaredPds = nt.getDeclaredPropertyDefinitions();
if (declaredPds!=null) {
for (int i = 0; i < declaredPds.length; i++) {
PropertyDefinition pd = declaredPds[i];
pds.put(pd.getName(), (VltPropertyDefinition) pd);
}
}
NodeType[] superTypes = nt.getSupertypes();
if (superTypes!=null) {
for (int i = 0; i < superTypes.length; i++) {
VltNodeType aSuperType = (VltNodeType) superTypes[i];
VltPropertyDefinition[] superTypePds = (VltPropertyDefinition[])aSuperType.getPropertyDefinitions();
for (int j = 0; j < superTypePds.length; j++) {
VltPropertyDefinition pd = superTypePds[j];
VltPropertyDefinition existingPd = pds.get(pd.getName());
if (existingPd!=null) {
// merge the two
existingPd.mergeFrom(pd);
} else {
pds.put(pd.getName(), pd);
}
}
}
}
nt.setPropertyDefinitions(pds.values().toArray(new VltPropertyDefinition[pds.size()]));
}
private void initProperties(VltNodeType nt, ResourceProxy child) {
Boolean isMixin = (Boolean) child.getProperties().get("jcr:isMixin");
if (isMixin==null) {
nt.setMixin(false);
} else {
nt.setMixin(isMixin);
}
}
private VltNodeDefinition handleChildNodeDefinition(ResourceProxy child) {
VltNodeDefinition nd = new VltNodeDefinition();
nd.setName((String) child.getProperties().get("jcr:name"));
String[] requiredPrimaryTypes = (String[]) child.getProperties().get(
"jcr:requiredPrimaryTypes");
nd.setRequiredPrimaryTypeNames(requiredPrimaryTypes);
if (requiredPrimaryTypes != null && requiredPrimaryTypes.length!=0) {
NodeType[] nts = new NodeType[requiredPrimaryTypes.length];
for (int i = 0; i < requiredPrimaryTypes.length; i++) {
String pt = requiredPrimaryTypes[i];
VltNodeType nt = getNodeType(pt);
nts[i] = nt;
}
nd.setRequiredPrimaryTypes(nts);
}
// String[] defaultPrimaryTypes = (String[])
// child.getProperties().get("jcr:defaultPrimaryTypes");
return nd;
}
private void initTypeDependencyTree(VltNodeType nt) {
final String[] superTypeNames = nt.getDeclaredSupertypeNames();
if (superTypeNames == null) {
return;
}
// collect all the supertype names
Set<NodeType> allSuperTypes = new HashSet<NodeType>();
initSuperTypes(allSuperTypes, nt);
nt.setSupertypes(allSuperTypes.toArray(new NodeType[0]));
}
private void initSuperTypes(Set<NodeType> allSuperTypes, VltNodeType nt) {
final NodeType[] declaredSupertypes = nt.getDeclaredSupertypes();
if (declaredSupertypes==null) {
return;
}
for (int i = 0; i < declaredSupertypes.length; i++) {
VltNodeType superType = (VltNodeType) declaredSupertypes[i];
allSuperTypes.add(superType);
nt.addSuperType(superType);
initSuperTypes(allSuperTypes, (VltNodeType) superType);
}
}
private void initAllowedPrimaryChildNodeTypes(VltNodeType nt0) throws RepositoryException {
NodeDefinition[] declaredCihldNodeDefinitions = nt0.getDeclaredChildNodeDefinitions();
Set<String> allowedChildNodeTypes = new HashSet<String>();
if (declaredCihldNodeDefinitions!=null) {
for (int i = 0; i < declaredCihldNodeDefinitions.length; i++) {
NodeDefinition nodeDefinition = declaredCihldNodeDefinitions[i];
NodeType[] requiredPrimaryTypes = nodeDefinition.getRequiredPrimaryTypes();
if (requiredPrimaryTypes!=null) {
for (int j = 0; j < requiredPrimaryTypes.length; j++) {
VltNodeType aRequiredPrimaryType = (VltNodeType) requiredPrimaryTypes[j];
if (aRequiredPrimaryType==null) {
System.out.println("this can not be");
}
Set<VltNodeType> allKnownChildTypes = aRequiredPrimaryType.getAllKnownChildTypes();
for (Iterator<VltNodeType> it = allKnownChildTypes.iterator(); it.hasNext();) {
VltNodeType aChildType = it.next();
VltNodeType nt2 = getNodeType(aChildType.getName());
if (!nt2.isMixin()) {
// mixins cannot be primary node types!
allowedChildNodeTypes.add(nt2.getName());
}
}
}
}
}
}
nt0.setAllowedPrimaryChildNodeTypes(allowedChildNodeTypes);
}
}