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 public NodeMapWrapper(Content node, String handle) {
76 super(node);
77 this.handle = handle;
78 }
79
80 @Override
81 protected Content wrap(Content node) {
82 return new NodeMapWrapper(node, handle);
83 }
84
85
86
87
88 @Override
89 public int size() {
90 return getWrappedContent().getNodeDataCollection().size();
91 }
92
93
94
95
96 @Override
97 public boolean isEmpty() {
98 return getWrappedContent().getNodeDataCollection().isEmpty();
99 }
100
101
102
103
104 @Override
105 public boolean containsKey(Object key) {
106 return this.getWrappedContent().getNodeData((String) key).isExist() || hasProperty(key);
107 }
108
109
110
111
112 @Override
113 public boolean containsValue(Object value) {
114
115 return false;
116 }
117
118
119
120
121
122 @Override
123 public Object get(Object key) {
124 try {
125 if (!getWrappedContent().hasNodeData((String) key)) {
126
127 if ("uuid".equalsIgnoreCase((String) key)) {
128 key = "UUID";
129 }
130 if (hasProperty(key)) {
131 try {
132 return PropertyUtils.getProperty(this.getWrappedContent(), (String) key);
133 }
134 catch (Exception e) {
135 log.error("can't read property " + key + " from the node " + this.getWrappedContent(), e);
136 }
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 }
151 else if (type == PropertyType.BINARY) {
152
153 FileProperties props = new FileProperties(getWrappedContent(), (String) key);
154 value = props.getProperty(FileProperties.PATH);
155 }
156 else if (nodeData.isMultiValue() == NodeData.MULTIVALUE_TRUE) {
157
158 Value[] values = nodeData.getValues();
159
160 String[] valueStrings = new String[values.length];
161
162 for (int j = 0; j < values.length; j++) {
163 try {
164 valueStrings[j] = values[j].getString();
165 }
166 catch (RepositoryException e) {
167 log.debug(e.getMessage());
168 }
169 }
170
171 value = valueStrings;
172 }
173 else {
174 try {
175 value = info.magnolia.link.LinkUtil.convertLinksFromUUIDPattern(nodeData.getString(), LinkTransformerManager.getInstance().getBrowserLink(handle));
176 }
177 catch (LinkException e) {
178 log.warn("Failed to parse links with from " + nodeData.getName(), e);
179 value = nodeData.getString();
180 }
181 }
182 return value;
183 }
184
185 protected boolean hasProperty(Object key) {
186 try {
187 return PropertyUtils.getPropertyDescriptor(this.getWrappedContent(), (String) key) != null;
188 }
189 catch (Exception e) {
190 return false;
191 }
192 }
193
194
195
196
197 @Override
198 public Object put(Object arg0, Object arg1) {
199
200 return null;
201 }
202
203
204
205
206 @Override
207 public Object remove(Object key) {
208
209 return null;
210 }
211
212
213
214
215 @Override
216 public void putAll(Map t) {
217
218 }
219
220
221
222
223 @Override
224 public void clear() {
225
226 }
227
228
229
230
231 @Override
232 public Set<String> keySet() {
233 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
234 Set<String> keys = new HashSet<String>();
235 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext();) {
236 keys.add(iter.next().getName());
237 }
238
239 return keys;
240 }
241
242
243
244
245 @Override
246 public Collection<String> values() {
247 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
248 Collection<String> values = new ArrayList<String>();
249 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext();) {
250 values.add((iter.next()).getString());
251 }
252
253 return values;
254 }
255
256
257
258
259 @Override
260 public Set entrySet() {
261 Collection<NodeData> nodeDataCollection = getWrappedContent().getNodeDataCollection();
262 Set<Map.Entry> keys = new HashSet<Map.Entry>();
263 for (Iterator<NodeData> iter = nodeDataCollection.iterator(); iter.hasNext();) {
264 NodeData nd = iter.next();
265 final String key = nd.getName();
266 final String value = nd.getString();
267 keys.add(new Map.Entry() {
268
269 @Override
270 public Object getKey() {
271 return key;
272 }
273
274 @Override
275 public Object getValue() {
276 return value;
277 }
278
279 @Override
280 public Object setValue(Object value) {
281 return value;
282 }
283 });
284 }
285
286 return keys;
287 }
288 }