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.module.groovy.support.nodes;
35
36 import groovy.lang.DelegatingMetaClass;
37 import groovy.lang.GroovySystem;
38 import groovy.lang.MetaClass;
39
40 import info.magnolia.cms.security.AccessDeniedException;
41 import info.magnolia.jcr.RuntimeRepositoryException;
42 import info.magnolia.jcr.iterator.DelegatingNodeIterator;
43 import info.magnolia.jcr.util.MetaDataUtil;
44 import info.magnolia.jcr.util.NodeTypes;
45 import info.magnolia.jcr.util.NodeUtil;
46 import info.magnolia.jcr.util.PropertyUtil;
47 import info.magnolia.jcr.wrapper.DelegateNodeWrapper;
48
49 import java.math.BigDecimal;
50 import java.util.ArrayList;
51 import java.util.List;
52
53 import javax.jcr.Node;
54 import javax.jcr.NodeIterator;
55 import javax.jcr.PathNotFoundException;
56 import javax.jcr.Property;
57 import javax.jcr.PropertyIterator;
58 import javax.jcr.PropertyType;
59 import javax.jcr.RepositoryException;
60 import javax.jcr.Value;
61 import javax.jcr.ValueFormatException;
62
63 import org.apache.commons.lang3.StringUtils;
64 import org.apache.jackrabbit.commons.iterator.NodeIteratorAdapter;
65 import org.slf4j.Logger;
66 import org.slf4j.LoggerFactory;
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119 public class MgnlGroovyJCRNode extends DelegateNodeWrapper {
120
121 static {
122
123 setMetaClass(GroovySystem.getMetaClassRegistry().getMetaClass(MgnlGroovyJCRNode.class), MgnlGroovyJCRNode.class);
124 }
125
126 protected static final Logger log = LoggerFactory.getLogger(MgnlGroovyJCRNode.class);
127
128 private String name;
129
130 public MgnlGroovyJCRNode(Node node) {
131 super(node);
132 try {
133 this.name = "/".equals(node.getPath()) ? "/root" : getName();
134 } catch (RepositoryException e) {
135 throw new RuntimeRepositoryException(e);
136 }
137 }
138
139 protected static void setMetaClass(final MetaClass metaClass, Class nodeClass) {
140 final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) {
141
142 @Override
143 public Object getAttribute(final Object object, final String attribute) {
144 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
145 try {
146 return n.get("@" + attribute);
147 } catch (ValueFormatException e) {
148 log.error(e.getMessage());
149 } catch (RepositoryException e) {
150 log.error(e.getMessage());
151 }
152 return null;
153 }
154
155 @Override
156 public void setAttribute(final Object object, final String attribute, final Object newValue) {
157 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
158 try {
159 PropertyUtil.setProperty(n, attribute, newValue);
160 }
161 catch (AccessDeniedException e) {
162 log.error(e.getMessage());
163 }
164 catch (PathNotFoundException e) {
165 log.error(e.getMessage());
166 }
167 catch (RepositoryException e) {
168 log.error(e.getMessage());
169 }
170 }
171
172 @Override
173 public Object getProperty(Object object, String property) {
174 if (object instanceof MgnlGroovyJCRNode) {
175 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
176 try {
177 return n.get(property);
178 } catch (ValueFormatException e) {
179 log.error(e.getMessage());
180 } catch (RepositoryException e) {
181 log.error(e.getMessage());
182 }
183 return null;
184 }
185 return super.getProperty(object, property);
186 }
187
188 @Override
189 public void setProperty(Object object, String property, Object newValue) {
190 String attribute = null;
191 if (property.startsWith("@")) {
192 attribute = property.substring(1);
193 } else {
194 attribute = property;
195 }
196 MgnlGroovyJCRNode n = (MgnlGroovyJCRNode) object;
197 try {
198
199 if (newValue instanceof Integer) {
200 newValue = ((Integer) newValue).longValue();
201 }
202 PropertyUtil.setProperty(n, attribute, newValue);
203 }
204 catch (AccessDeniedException e) {
205 log.error(e.getMessage());
206 }
207 catch (PathNotFoundException e) {
208 log.error(e.getMessage());
209 }
210 catch (RepositoryException e) {
211 log.error(e.getMessage());
212 }
213 }
214 };
215
216 GroovySystem.getMetaClassRegistry().setMetaClass(nodeClass, newMetaClass);
217 }
218
219 public String name() {
220 return name;
221 }
222
223
224
225
226
227
228
229
230
231 public Object get(String key) throws ValueFormatException, RepositoryException {
232 if (key != null && key.charAt(0) == '@') {
233 String attributeName = key.substring(1);
234 Property property = PropertyUtil.getPropertyOrNull(getWrappedNode(), attributeName);
235 return getPropertyValue(property);
236 }
237 try {
238 if ("parent".equals(key)) {
239 return getParent();
240 }
241 if ("children".equals(key) || "nodes".equals(key)) {
242 Iterable<Node> iterable = NodeUtil.getNodes(getWrappedNode());
243 return new MgnlGroovyWrappingNodeIterator(new NodeIteratorAdapter(iterable.iterator()));
244 }
245 if ("metaData".equals(key)) {
246 return MetaDataUtil.getMetaData(getWrappedNode());
247 }
248 if ("properties".equals(key)) {
249 return getProperties();
250 }
251 if ("name".equals(key)) {
252 return name;
253 }
254 return new MgnlGroovyJCRNode(getNode(key));
255
256 } catch (RepositoryException e) {
257 log.info(e.getMessage());
258 }
259
260
261 Property property = PropertyUtil.getPropertyOrNull(getWrappedNode(), key);
262 return getPropertyValue(property);
263 }
264
265
266
267
268
269
270
271
272
273
274
275
276
277 protected Object getPropertyValue(Property property) throws RepositoryException, ValueFormatException {
278 if (property == null) {
279 return "unknown property";
280 }
281 if (property.isMultiple()) {
282 List<Object> values = new ArrayList<Object>();
283 for (Value value : property.getValues()) {
284 values.add(getPropertyValueInternal(value));
285 }
286 return values;
287 } else {
288 return getPropertyValueInternal(property.getValue());
289 }
290
291 }
292
293 public String print() {
294 StringBuilder retVal = new StringBuilder();
295 try {
296 Iterable<Node> nodes = NodeUtil.getNodes(getWrappedNode());
297 retVal.append("(+) " + name + "\n");
298 for (Node node : nodes) {
299 if (!showNode(node)) {
300 continue;
301 }
302 if ((NodeUtil.getNodes(node).iterator().hasNext())) {
303 retVal.append("\t(+) ");
304 } else {
305 retVal.append("\t(-) ");
306 }
307 retVal.append(node.getName() + "\n");
308 }
309
310 if (getProperties().getSize() > 0) {
311 PropertyIterator it = super.getProperties();
312 while (it.hasNext()) {
313 Property property = it.nextProperty();
314 if (!showProperty(property)) {
315 continue;
316 }
317 String name = property.getName();
318
319 retVal.append("\t\t* " + name + ": ["
320 + StringUtils.abbreviate(getPropertyValue(property).toString(), 80)
321 + "]\n");
322
323 }
324
325 }
326 } catch (ValueFormatException e) {
327 e.printStackTrace();
328 } catch (RepositoryException e) {
329 e.printStackTrace();
330 }
331
332 return retVal.toString();
333 }
334
335 @Override
336 public int hashCode() {
337 final int prime = 31;
338 int result = 1;
339 result = prime * result + ((name == null) ? 0 : name.hashCode());
340 return result;
341 }
342
343 @Override
344 public boolean equals(Object obj) {
345 if (this == obj)
346 return true;
347 if (obj == null)
348 return false;
349 if (getClass() != obj.getClass())
350 return false;
351 MgnlGroovyJCRNode other = (MgnlGroovyJCRNode) obj;
352 if (name == null) {
353 if (other.name != null)
354 return false;
355 } else
356 try {
357 if (!getIdentifier().equals(other.getIdentifier()))
358 return false;
359 } catch (RepositoryException e) {
360 return false;
361 }
362 return true;
363 }
364
365
366
367
368 protected class MgnlGroovyWrappingNodeIterator extends DelegatingNodeIterator {
369 public MgnlGroovyWrappingNodeIterator(NodeIterator iterator) {
370 super(iterator);
371 }
372
373 @Override
374 public Node nextNode() {
375 return new MgnlGroovyJCRNode(super.nextNode());
376 }
377
378 @Override
379 public Object next() {
380 return new MgnlGroovyJCRNode((Node) super.next());
381 }
382 }
383
384 protected boolean showNode(Node node) {
385 try {
386 if (NodeTypes.MetaData.NAME.equals(node.getPrimaryNodeType().getName())
387 || node.getName().startsWith("jcr:")
388 || node.getName().startsWith("rep:")) {
389 return false;
390 }
391 } catch (RepositoryException e) {
392 log.error(e.getMessage());
393 return false;
394 }
395 return true;
396 }
397
398 protected boolean showProperty(Property property) {
399 try {
400 if (property.getName().startsWith("jcr:")) {
401 return false;
402 }
403 } catch (RepositoryException e) {
404 log.error(e.getMessage());
405 return false;
406 }
407 return true;
408 }
409
410 private Object getPropertyValueInternal(Value property) throws RepositoryException {
411 switch (property.getType()) {
412 case PropertyType.STRING:
413 return property.getString();
414 case PropertyType.BOOLEAN:
415 return property.getBoolean();
416 case PropertyType.BINARY:
417 return property.getBinary().getStream();
418 case PropertyType.DATE:
419 return property.getDate();
420 case PropertyType.DECIMAL:
421 return property.getDecimal();
422 case PropertyType.DOUBLE:
423 return BigDecimal.valueOf(property.getDouble());
424 case PropertyType.LONG:
425 return BigDecimal.valueOf(property.getLong());
426 default:
427 return property.getString();
428 }
429 }
430
431 }