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.isMultiple()) {
276 List<Object> values = new ArrayList<Object>();
277 for (Value value : property.getValues()) {
278 values.add(getPropertyValueInternal(value));
279 }
280 return values;
281 } else {
282 return getPropertyValueInternal(property.getValue());
283 }
284
285 }
286
287 public String print() {
288 StringBuilder retVal = new StringBuilder();
289 try {
290 Iterable<Node> nodes = NodeUtil.getNodes(getWrappedNode());
291 retVal.append("(+) " + name + "\n");
292 for (Node node : nodes) {
293 if (!showNode(node)) {
294 continue;
295 }
296 if ((NodeUtil.getNodes(node).iterator().hasNext())) {
297 retVal.append("\t(+) ");
298 } else {
299 retVal.append("\t(-) ");
300 }
301 retVal.append(node.getName() + "\n");
302 }
303
304 if (getProperties().getSize() > 0) {
305 PropertyIterator it = super.getProperties();
306 while (it.hasNext()) {
307 Property property = it.nextProperty();
308 if (!showProperty(property)) {
309 continue;
310 }
311 String name = property.getName();
312
313 retVal.append("\t\t* " + name + ": ["
314 + StringUtils.abbreviate(getPropertyValue(property).toString(), 80)
315 + "]\n");
316
317 }
318
319 }
320 } catch (ValueFormatException e) {
321 e.printStackTrace();
322 } catch (RepositoryException e) {
323 e.printStackTrace();
324 }
325
326 return retVal.toString();
327 }
328
329 @Override
330 public int hashCode() {
331 final int prime = 31;
332 int result = 1;
333 result = prime * result + ((name == null) ? 0 : name.hashCode());
334 return result;
335 }
336
337 @Override
338 public boolean equals(Object obj) {
339 if (this == obj)
340 return true;
341 if (obj == null)
342 return false;
343 if (getClass() != obj.getClass())
344 return false;
345 MgnlGroovyJCRNode other = (MgnlGroovyJCRNode) obj;
346 if (name == null) {
347 if (other.name != null)
348 return false;
349 } else
350 try {
351 if (!getIdentifier().equals(other.getIdentifier()))
352 return false;
353 } catch (RepositoryException e) {
354 return false;
355 }
356 return true;
357 }
358
359
360
361
362 protected class MgnlGroovyWrappingNodeIterator extends DelegatingNodeIterator {
363 public MgnlGroovyWrappingNodeIterator(NodeIterator iterator) {
364 super(iterator);
365 }
366
367 @Override
368 public Node nextNode() {
369 return new MgnlGroovyJCRNode(super.nextNode());
370 }
371
372 @Override
373 public Object next() {
374 return new MgnlGroovyJCRNode((Node) super.next());
375 }
376 }
377
378 protected boolean showNode(Node node) {
379 try {
380 if (NodeTypes.MetaData.NAME.equals(node.getPrimaryNodeType().getName())
381 || node.getName().startsWith("jcr:")
382 || node.getName().startsWith("rep:")) {
383 return false;
384 }
385 } catch (RepositoryException e) {
386 log.error(e.getMessage());
387 return false;
388 }
389 return true;
390 }
391
392 protected boolean showProperty(Property property) {
393 try {
394 if (property.getName().startsWith("jcr:")) {
395 return false;
396 }
397 } catch (RepositoryException e) {
398 log.error(e.getMessage());
399 return false;
400 }
401 return true;
402 }
403
404 private Object getPropertyValueInternal(Value property) throws RepositoryException {
405 switch (property.getType()) {
406 case PropertyType.STRING:
407 return property.getString();
408 case PropertyType.BOOLEAN:
409 return property.getBoolean();
410 case PropertyType.BINARY:
411 return property.getBinary().getStream();
412 case PropertyType.DATE:
413 return property.getDate();
414 case PropertyType.DECIMAL:
415 return property.getDecimal();
416 case PropertyType.DOUBLE:
417 return BigDecimal.valueOf(property.getDouble());
418 case PropertyType.LONG:
419 return BigDecimal.valueOf(property.getLong());
420 default:
421 return property.getString();
422 }
423 }
424
425 }