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.core;
35
36 import info.magnolia.cms.i18n.I18nContentSupportFactory;
37 import info.magnolia.cms.security.AccessDeniedException;
38 import info.magnolia.cms.security.PermissionUtil;
39 import info.magnolia.cms.util.NodeDataUtil;
40 import info.magnolia.cms.util.NodeTypeFilter;
41 import info.magnolia.context.MgnlContext;
42
43 import java.io.InputStream;
44 import java.util.ArrayList;
45 import java.util.Calendar;
46 import java.util.Collection;
47 import java.util.Comparator;
48
49 import javax.jcr.PathNotFoundException;
50 import javax.jcr.PropertyType;
51 import javax.jcr.RepositoryException;
52 import javax.jcr.Value;
53 import javax.jcr.Workspace;
54
55 import org.apache.commons.lang3.StringUtils;
56
57
58
59
60
61
62
63 public abstract class AbstractContent extends ContentHandler implements Content {
64 private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(AbstractContent.class);
65
66 @Override
67 public Content createContent(String name) throws PathNotFoundException, RepositoryException, AccessDeniedException {
68 return createContent(name, ItemType.CONTENT);
69 }
70
71 @Override
72 public Content createContent(String name, ItemType contentType) throws PathNotFoundException, RepositoryException, AccessDeniedException {
73 return createContent(name, contentType.getSystemName());
74 }
75
76 @Override
77 public NodeData createNodeData(String name) throws PathNotFoundException, RepositoryException, AccessDeniedException {
78 return setNodeData(name, "");
79 }
80
81 @Override
82 public NodeData createNodeData(String name, Value value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
83 return setNodeData(name, value);
84 }
85
86
87
88
89 @Override
90 @Deprecated
91 public NodeData createNodeData(String name, Value[] value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
92 return setNodeData(name, value);
93 }
94
95
96
97
98 @Override
99 @Deprecated
100 public NodeData createNodeData(String name, int type) throws PathNotFoundException, RepositoryException, AccessDeniedException {
101
102 switch (type) {
103 case PropertyType.STRING:
104 return setNodeData(name, StringUtils.EMPTY);
105 case PropertyType.BOOLEAN:
106 return setNodeData(name, Boolean.FALSE);
107 case PropertyType.DATE:
108 return setNodeData(name, Calendar.getInstance());
109 case PropertyType.LONG:
110 return setNodeData(name, Long.valueOf(0));
111 case PropertyType.DOUBLE:
112 return setNodeData(name, Double.valueOf(0.0));
113 default:
114 return newNodeDataInstance(name, type, true);
115 }
116 }
117
118
119
120
121 @Override
122 @Deprecated
123 public NodeData createNodeData(String name, Object valueObj) throws RepositoryException {
124 return setNodeData(name, valueObj);
125 }
126
127
128
129
130
131 @Override
132 public NodeData getNodeData(String name) {
133 try {
134
135 return newNodeDataInstance(name, PropertyType.UNDEFINED, false);
136 } catch (RepositoryException e) {
137 throw new IllegalStateException("Can't instantiate node data " + name + " on node " + toString(), e);
138 }
139 }
140
141
142
143
144
145
146 abstract public NodeData newNodeDataInstance(String name, int type, boolean createIfNotExisting) throws AccessDeniedException, RepositoryException;
147
148
149
150
151 @Override
152 public boolean hasNodeData(String name) throws RepositoryException {
153 return getNodeData(name).isExist();
154 }
155
156 @Override
157 public NodeData setNodeData(String name, Value value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
158 NodeData nodeData = newNodeDataInstance(name, value.getType(), true);
159 nodeData.setValue(value);
160 return nodeData;
161 }
162
163 @Override
164 public NodeData setNodeData(String name, Value[] value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
165 if (value.length == 0) {
166 throw new IllegalArgumentException("Value array can't be empty");
167 }
168 NodeData nodeData = newNodeDataInstance(name, value[0].getType(), true);
169 nodeData.setValue(value);
170 return nodeData;
171 }
172
173 @Override
174 public NodeData setNodeData(String name, boolean value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
175 NodeData nodeData = newNodeDataInstance(name, PropertyType.BOOLEAN, true);
176 nodeData.setValue(value);
177 return nodeData;
178 }
179
180 @Override
181 public NodeData setNodeData(String name, long value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
182 NodeData nodeData = newNodeDataInstance(name, PropertyType.LONG, true);
183 nodeData.setValue(value);
184 return nodeData;
185 }
186
187 @Override
188 public NodeData setNodeData(String name, double value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
189 NodeData nodeData = newNodeDataInstance(name, PropertyType.DOUBLE, true);
190 nodeData.setValue(value);
191 return nodeData;
192 }
193
194 @Override
195 public NodeData setNodeData(String name, String value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
196 NodeData nodeData = newNodeDataInstance(name, PropertyType.STRING, true);
197 nodeData.setValue(value);
198 return nodeData;
199 }
200
201 @Override
202 public NodeData setNodeData(String name, InputStream value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
203 NodeData nodeData = newNodeDataInstance(name, PropertyType.BINARY, true);
204 nodeData.setValue(value);
205 return nodeData;
206 }
207
208 @Override
209 public NodeData setNodeData(String name, Calendar value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
210 NodeData nodeData = newNodeDataInstance(name, PropertyType.DATE, true);
211 nodeData.setValue(value);
212 return nodeData;
213 }
214
215 @Override
216 public NodeData setNodeData(String name, Content value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
217 NodeData nodeData = newNodeDataInstance(name, PropertyType.REFERENCE, true);
218 nodeData.setValue(value);
219 return nodeData;
220 }
221
222
223
224
225 @Override
226 public NodeData setNodeData(String name, Object value) throws PathNotFoundException, RepositoryException, AccessDeniedException {
227 NodeData nodeData = newNodeDataInstance(name, NodeDataUtil.getJCRPropertyType(value), true);
228 NodeDataUtil.setValue(nodeData, value);
229 return nodeData;
230 }
231
232 @Override
233 public void deleteNodeData(String name) throws PathNotFoundException, RepositoryException {
234 getNodeData(name).delete();
235 }
236
237
238
239
240
241 @Override
242 public Collection<Content> getChildren() {
243 String type = null;
244
245 try {
246 type = this.getNodeTypeName();
247 } catch (RepositoryException re) {
248 throw new RuntimeException("Can't read type of node [" + toString() + "]", re);
249
250 }
251
252 if ("rep:root".equalsIgnoreCase(type)) {
253 type = ItemType.CONTENT.getSystemName();
254 }
255
256 return this.getChildren(type);
257 }
258
259
260
261
262
263 @Override
264 public Collection<Content> getChildren(ContentFilter filter) {
265 return getChildren(filter, null);
266 }
267
268
269
270
271
272 @Override
273 public Collection<Content> getChildren(ItemType itemType) {
274 return getChildren(new NodeTypeFilter(itemType), null);
275 }
276
277
278
279
280
281 @Override
282 public Collection<Content> getChildren(String contentType) {
283 return getChildren(new NodeTypeFilter(contentType), null);
284 }
285
286
287
288
289
290 @Override
291 public Collection<Content> getChildren(final String contentType, final String namePattern) {
292 return getChildren(new NodeTypeFilter(contentType), namePattern, null);
293 }
294
295
296
297
298
299 @Override
300 public Collection<Content> getChildren(ContentFilter filter, Comparator<Content> orderCriteria) {
301 return getChildren(filter, null, orderCriteria);
302 }
303
304
305
306
307 abstract public Collection<Content> getChildren(ContentFilter filter, String namePattern, Comparator<Content> orderCriteria);
308
309
310
311
312 @Override
313 @Deprecated
314 public Content getChildByName(String namePattern) {
315 Collection<Content> children = getChildren("nt:base", namePattern);
316 if (!children.isEmpty()) {
317 return children.iterator().next();
318 }
319 return null;
320 }
321
322 @Override
323 public Collection<NodeData> getNodeDataCollection() {
324 return getNodeDataCollection(null);
325 }
326
327 protected Collection<NodeData> getBinaryNodeDatas(String namePattern) throws RepositoryException {
328 Collection<NodeData> nodeDatas = new ArrayList<NodeData>();
329 Collection<Content> binaryNodes = getChildren(ItemType.NT_RESOURCE, namePattern);
330 for (Content binaryNode : binaryNodes) {
331 nodeDatas.add(newNodeDataInstance(binaryNode.getName(), PropertyType.BINARY, false));
332 }
333 return nodeDatas;
334 }
335
336
337 @Override
338 public boolean hasChildren() {
339 return (this.getChildren().size() > 0);
340 }
341
342 @Override
343 public boolean hasChildren(String contentType) {
344 return (this.getChildren(contentType).size() > 0);
345 }
346
347 @Override
348 public void delete(String path) throws RepositoryException {
349 if (isNodeData(path)) {
350 deleteNodeData(path);
351 } else {
352 getContent(path).delete();
353 }
354 }
355
356 @Override
357 public boolean isNodeData(String path) throws AccessDeniedException, RepositoryException {
358 return hasNodeData(path);
359 }
360
361 @Override
362 public String getTemplate() {
363 return this.getMetaData().getTemplate();
364 }
365
366 @Override
367 public String getTitle() {
368 return I18nContentSupportFactory.getI18nSupport().getNodeData(this, "title").getString();
369 }
370
371 @Override
372 public void updateMetaData() throws RepositoryException, AccessDeniedException {
373 MetaData md = this.getMetaData();
374 md.setModificationDate();
375 md.setAuthorId(MgnlContext.getUser().getName());
376 }
377
378 @Override
379 public boolean isGranted(long permissions) {
380
381 final String handle = getHandle();
382 try {
383 return PermissionUtil.isGranted(this.getJCRNode().getSession(), handle, permissions);
384 } catch (RepositoryException e) {
385 log.error("An error occurred while trying to access path {} with permissions {}", handle, permissions, e);
386 return false;
387 }
388 }
389
390 @Override
391 public Workspace getWorkspace() throws RepositoryException {
392 return getJCRNode().getSession().getWorkspace();
393 }
394
395 @Override
396 public String toString() {
397 String type = "";
398 String workspaceName = "";
399
400 try {
401 workspaceName = getWorkspace() == null ? "null" : getWorkspace().getName();
402 type = getItemType().getSystemName();
403 } catch (RepositoryException e) {
404
405 }
406 StringBuilder builder = new StringBuilder();
407 builder.append(workspaceName);
408 builder.append(':').append(getHandle());
409 builder.append('[');
410 builder.append(type);
411 builder.append(']');
412
413 return builder.toString();
414 }
415
416
417 }