1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.jcr.util;
35
36 import java.util.HashMap;
37 import java.util.List;
38 import java.util.Map.Entry;
39
40 import javax.jcr.PropertyType;
41 import javax.jcr.RepositoryException;
42 import javax.jcr.Value;
43 import javax.jcr.nodetype.NodeDefinitionTemplate;
44 import javax.jcr.nodetype.NodeTypeManager;
45 import javax.jcr.nodetype.NodeTypeTemplate;
46 import javax.jcr.nodetype.PropertyDefinitionTemplate;
47 import javax.jcr.version.OnParentVersionAction;
48
49 import org.apache.commons.lang.StringUtils;
50 import org.slf4j.Logger;
51 import org.slf4j.LoggerFactory;
52
53
54
55
56
57
58
59 public class NodeTypeTemplateUtil {
60 private static final Logger log = LoggerFactory.getLogger(NodeTypeTemplateUtil.class);
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79 public static NodeTypeTemplate createSimpleMixinNodeType(NodeTypeManager nodeTypeManager, String name, String superType, HashMap<String, Integer> propertyNameTypeMap) throws RepositoryException {
80 NodeTypeTemplate nodeType = null;
81 nodeType = createNodeType(nodeTypeManager, name, new String[] { superType }, true, false, null, false);
82 if (propertyNameTypeMap != null && !propertyNameTypeMap.isEmpty()) {
83 for (Entry<String, Integer> entry : propertyNameTypeMap.entrySet()) {
84 PropertyDefinitionTemplate propertyDefinition = createPropertyDefinition(nodeTypeManager, entry.getKey(), false, true, false, false, false, false, OnParentVersionAction.COPY, entry.getValue(), null, null, null);
85 nodeType.getPropertyDefinitionTemplates().add(propertyDefinition);
86 }
87 }
88 return nodeType;
89 }
90
91
92
93
94 public static NodeTypeTemplate createSimpleNodeType(NodeTypeManager nodeTypeManager, String name, List<String> supertype) throws RepositoryException {
95 NodeTypeTemplate nodeType = null;
96
97 nodeType = createNodeType(nodeTypeManager, name, supertype.toArray(new String[supertype.size()]), false, true, null, true);
98
99 NodeDefinitionTemplate child = createChildNodeDefinition(nodeTypeManager, false, false, false, true, null, null, OnParentVersionAction.COPY, new String[] { "nt:base" });
100 nodeType.getNodeDefinitionTemplates().add(child);
101
102 PropertyDefinitionTemplate propertyDefinitionNotMultiple = createPropertyDefinition(nodeTypeManager, null, false, true, false, false, false, true, OnParentVersionAction.COPY, PropertyType.UNDEFINED, null, null, null);
103 nodeType.getPropertyDefinitionTemplates().add(propertyDefinitionNotMultiple);
104 PropertyDefinitionTemplate propertyDefinitionMultiple = createPropertyDefinition(nodeTypeManager, null, false, true, false, true, false, true, OnParentVersionAction.COPY, PropertyType.UNDEFINED, null, null, null);
105 nodeType.getPropertyDefinitionTemplates().add(propertyDefinitionMultiple);
106
107 return nodeType;
108 }
109
110
111
112
113 public static NodeTypeTemplate createNodeType(NodeTypeManager nodeTypeManager, String name, String[] superTypeNames, boolean isMixin, boolean isOrderableChildNodes, String primaryItemName, boolean isQueryable) throws RepositoryException {
114
115 NodeTypeTemplate nodeType = nodeTypeManager.createNodeTypeTemplate();
116 nodeType.setName(name);
117 nodeType.setDeclaredSuperTypeNames(superTypeNames);
118 nodeType.setMixin(isMixin);
119 nodeType.setOrderableChildNodes(isOrderableChildNodes);
120 nodeType.setPrimaryItemName(primaryItemName);
121 nodeType.setQueryable(isQueryable);
122
123 return nodeType;
124 }
125
126
127
128
129
130
131
132 public static NodeDefinitionTemplate createChildNodeDefinition(NodeTypeManager nodeTypeManager, boolean isAutoCreated, boolean isMandatory, boolean isProtected, boolean allowSameNameSiblings, String defaultPrimaryTypeName, String name, int onParentVersion, String[] requiredPrimaryTypeNames) throws RepositoryException {
133
134 NodeDefinitionTemplate childNodeType = nodeTypeManager.createNodeDefinitionTemplate();
135
136 if (StringUtils.isNotBlank(defaultPrimaryTypeName)) {
137 childNodeType.setDefaultPrimaryTypeName(defaultPrimaryTypeName);
138 }
139
140 childNodeType.setName(StringUtils.isBlank(name) ? "*" : name);
141
142 childNodeType.setMandatory(isMandatory);
143 childNodeType.setSameNameSiblings(allowSameNameSiblings);
144 childNodeType.setAutoCreated(isAutoCreated);
145 childNodeType.setProtected(isProtected);
146
147
148 try {
149 OnParentVersionAction.nameFromValue(onParentVersion);
150 } catch (IllegalArgumentException ie) {
151 log.warn("OnParentVersionAction constant definition '{}' is not valid. IGNORE will be set", onParentVersion);
152 onParentVersion = OnParentVersionAction.IGNORE;
153 }
154 childNodeType.setOnParentVersion(onParentVersion);
155
156 childNodeType.setRequiredPrimaryTypeNames(requiredPrimaryTypeNames);
157
158 return childNodeType;
159 }
160
161
162
163
164
165
166
167
168
169
170
171 public static PropertyDefinitionTemplate createPropertyDefinition(NodeTypeManager nodeTypeManager, String name, boolean isAutoCreated, boolean isFullTextSearchable, boolean isMandatory, boolean isMultiple, boolean hasProtectedStatus, boolean isQueryOrderable, int onParentVersion, int requiredType, String[] availableQueryOperators, String[] valueConstraints, Value[] defaultValues) throws RepositoryException {
172 PropertyDefinitionTemplate propertyDefinition = nodeTypeManager.createPropertyDefinitionTemplate();
173
174 propertyDefinition.setAutoCreated(isAutoCreated);
175 propertyDefinition.setFullTextSearchable(isFullTextSearchable);
176 propertyDefinition.setMandatory(isMandatory);
177 propertyDefinition.setMultiple(isMultiple);
178 propertyDefinition.setProtected(hasProtectedStatus);
179 propertyDefinition.setQueryOrderable(isQueryOrderable);
180
181 if (availableQueryOperators != null && availableQueryOperators.length > 0) {
182 propertyDefinition.setAvailableQueryOperators(availableQueryOperators);
183 }
184 if (defaultValues != null && defaultValues.length > 0) {
185 propertyDefinition.setDefaultValues(defaultValues);
186 }
187 if (valueConstraints != null && valueConstraints.length > 0) {
188 propertyDefinition.setValueConstraints(valueConstraints);
189 }
190
191 propertyDefinition.setName(StringUtils.isBlank(name) ? "*" : name);
192
193 try {
194 OnParentVersionAction.nameFromValue(onParentVersion);
195 } catch (IllegalArgumentException ie) {
196 log.warn("OnParentVersionAction constant definition '{}' is not valid. IGNORE will be set", onParentVersion);
197 onParentVersion = OnParentVersionAction.IGNORE;
198 }
199 propertyDefinition.setOnParentVersion(onParentVersion);
200
201
202 try {
203 PropertyType.nameFromValue(requiredType);
204 } catch (IllegalArgumentException ie) {
205 log.warn("PropertyType constant definition '{}' is not valid. STRING will be set", requiredType);
206 requiredType = PropertyType.STRING;
207 }
208 propertyDefinition.setRequiredType(requiredType);
209
210 return propertyDefinition;
211 }
212 }