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.cms.util;
35
36 import info.magnolia.cms.beans.runtime.FileProperties;
37 import info.magnolia.cms.core.Content;
38 import info.magnolia.cms.core.NodeData;
39 import info.magnolia.link.LinkException;
40 import info.magnolia.link.LinkTransformerManager;
41
42 import java.util.ArrayList;
43 import java.util.Collection;
44 import java.util.HashSet;
45 import java.util.Iterator;
46 import java.util.Map;
47 import java.util.Set;
48
49 import javax.jcr.PropertyType;
50 import javax.jcr.RepositoryException;
51 import javax.jcr.Value;
52
53 import org.apache.commons.beanutils.PropertyUtils;
54 import org.slf4j.Logger;
55 import org.slf4j.LoggerFactory;
56
57
58
59
60
61 public class NodeMapWrapper extends ContentWrapper implements Map {
62
63 private static final Logger log = LoggerFactory.getLogger(NodeMapWrapper.class);
64
65
66
67
68 private final String handle;
69
70
71
72
73
74
75
76 public NodeMapWrapper(Content node, String handle) {
77 super(node);
78 this.handle = handle;
79 }
80
81 @Override
82 protected Content wrap(Content node) {
83 return new NodeMapWrapper(node, handle);
84 }
85
86
87
88
89 @Override
90 public int size() {
91 return getWrappedContent().getNodeDataCollection().size();
92 }
93
94
95
96
97 @Override
98 public boolean isEmpty() {
99 return getWrappedContent().getNodeDataCollection().isEmpty();
100 }
101
102
103
104
105 @Override
106 public boolean containsKey(Object key) {
107 return this.getWrappedContent().getNodeData((String) key).isExist() || hasProperty(key);
108 }
109
110
111
112
113 @Override
114 public boolean containsValue(Object value) {
115
116 return false;
117 }
118
119
120
121
122
123
124 @Override
125 public Object get(Object key) {
126 try {
127 if (!getWrappedContent().hasNodeData((String) key)) {
128
129 if ("uuid".equalsIgnoreCase((String) key)) {
130 key = "UUID";
131 }
132 if (hasProperty(key)) {
133 try {
134 return PropertyUtils.getProperty(this.getWrappedContent(), (String) key);
135 } catch (Exception e) {
136 log.error("can't read property {} from the node {}", key, this.getWrappedContent(), e);
137 }
138 }
139 }
140 } catch (RepositoryException e) {
141
142 log.error("can't check for node data {{}}", key, e);
143 }
144
145 NodeData nodeData = getWrappedContent().getNodeData((String) key);
146 Object value;
147 int type = nodeData.getType();
148 if (type == PropertyType.DATE) {
149 value = nodeData.getDate();
150 } else if (type == PropertyType.BINARY) {
151
152 FileProperties props = new FileProperties(getWrappedContent(), (String) key);
153 value = props.getProperty(FileProperties.PATH);
154 } else if (nodeData.isMultiValue() == NodeData.MULTIVALUE_TRUE) {
155
156 Value[] values = nodeData.getValues();
157
158 String[] valueStrings = new String[values.length];
159
160 for (int j = 0; j < values.length; j++) {
161 try {
162 valueStrings[j] = values[j].getString();
163 } catch (RepositoryException e) {
164 log.debug(e.getMessage());
165 }
166 }
167
168 value = valueStrings;
169 } else {
170 try {
171 value = info.magnolia.link.LinkUtil.convertLinksFromUUIDPattern(nodeData.getString(), LinkTransformerManager.getInstance().getBrowserLink(handle));
172 } catch (LinkException e) {
173 log.warn("Failed to parse links with from {}", nodeData.getName(), e);
174 value = nodeData.getString();
175 }
176 }
177 return value;
178 }
179
180 protected boolean hasProperty(Object key) {
181 try {
182 return PropertyUtils.getPropertyDescriptor(this.getWrappedContent(), (String) key) != null;
183 } catch (Exception e) {
184 return false;
185 }
186 }
187
188
189
190
191 @Override
192 public Object put(Object arg0, Object arg1) {
193
194 return null;
195 }
196
197
198
199
200 @Override
201 public Object remove(Object key) {
202
203 return null;
204 }
205
206
207
208
209 @Override
210 public void putAll(Map t) {
211
212 }
213
214
215
216
217 @Override
218 public void clear() {
219
220 }
221
222
223
224
225 @Override
226 public Set<String> keySet() {
227 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
228 Set<String> keys = new HashSet<String>();
229 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext(); ) {
230 keys.add(iter.next().getName());
231 }
232
233 return keys;
234 }
235
236
237
238
239 @Override
240 public Collection<String> values() {
241 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
242 Collection<String> values = new ArrayList<String>();
243 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext(); ) {
244 values.add((iter.next()).getString());
245 }
246
247 return values;
248 }
249
250
251
252
253 @Override
254 public Set entrySet() {
255 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
256 Set<Map.Entry> keys = new HashSet<Map.Entry>();
257 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext(); ) {
258 NodeData nd = iter.next();
259 final String key = nd.getName();
260 final String value = nd.getString();
261 keys.add(new Map.Entry() {
262
263 @Override
264 public Object getKey() {
265 return key;
266 }
267
268 @Override
269 public Object getValue() {
270 return value;
271 }
272
273 @Override
274 public Object setValue(Object value) {
275 return value;
276 }
277 });
278 }
279
280 return keys;
281 }
282 }