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