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.core.AbstractContent;
37 import info.magnolia.cms.core.Content;
38 import info.magnolia.cms.core.DefaultNodeData;
39 import info.magnolia.cms.core.NodeData;
40
41 import java.util.Collection;
42 import java.util.Comparator;
43 import java.util.LinkedHashMap;
44 import java.util.SortedMap;
45 import java.util.TreeMap;
46
47 import javax.jcr.RepositoryException;
48
49 import org.apache.commons.lang3.StringUtils;
50 import org.slf4j.Logger;
51 import org.slf4j.LoggerFactory;
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73 @Deprecated
74 public class ExtendingContentWrapper extends ContentWrapper {
75
76 protected static final String EXTENDING_NODE_DATA = "extends";
77 protected static final String EXTENDING_NODE_DATA_OVERRIDE = "override";
78
79 private boolean extending;
80
81 private Content extendedContent;
82
83 private static final Logger log = LoggerFactory.getLogger(ExtendingContentWrapper.class);
84
85
86 ExtendingContentWrapper(Content wrappedContent, boolean failOnError) {
87
88 super(wrappedContent);
89 try {
90 extending = getWrappedContent().hasNodeData(EXTENDING_NODE_DATA);
91 if (extending) {
92 NodeData extendingNodeData = getWrappedContent().getNodeData(EXTENDING_NODE_DATA);
93
94
95 String extendedNode = extendingNodeData.getString();
96
97 Content parent = extendingNodeData.getParent();
98
99 if (StringUtils.isBlank(extendedNode)) {
100
101 extending = false;
102 } else if (EXTENDING_NODE_DATA_OVERRIDE.equals(extendedNode)) {
103 extending = false;
104 }
105 if (extending) {
106 if (isExists(extendedNode, parent)) {
107
108 extendedContent = wrapIfNeeded(extendingNodeData.getReferencedContent());
109 } else {
110 String message = "Can't find referenced node for value: " + wrappedContent;
111 log.error(message);
112 extending = false;
113 if (failOnError) {
114 throw new RuntimeException(message);
115 }
116 }
117
118 }
119
120 }
121 } catch (RepositoryException e) {
122 throw new RuntimeException("Can't wrap node [" + wrappedContent + "]", e);
123 }
124 }
125
126 public ExtendingContentWrapper(Content wrappedContent) {
127 this(wrappedContent, false);
128 }
129
130
131
132
133
134 protected ExtendingContentWrapper(Content./../info/magnolia/cms/core/Content.html#Content">Content wrappedContent, Content extendedContent) {
135 super(wrapIfNeeded(wrappedContent));
136 extending = true;
137 try {
138 if (getWrappedContent().hasNodeData(EXTENDING_NODE_DATA)) {
139 NodeData extendingNodeData = getWrappedContent().getNodeData(EXTENDING_NODE_DATA);
140
141
142 extending = !EXTENDING_NODE_DATA_OVERRIDE.equals(extendingNodeData.getString());
143 }
144 } catch (RepositoryException e) {
145 throw new RuntimeException("Can't determine extends point for node [" + wrappedContent + "]", e);
146 }
147
148 this.extendedContent = wrapIfNeeded(extendedContent);
149 }
150
151 private boolean isExists(String extendedNode, Content parent) throws RepositoryException {
152 if (extendedNode.startsWith("/")) {
153 return getWrappedContent().getHierarchyManager().isExist(extendedNode);
154 }
155 return parent.hasContent(extendedNode);
156 }
157
158 private static Content./../../info/magnolia/cms/core/Content.html#Content">Content wrapIfNeeded(Content content) {
159 if (content instanceof ExtendingContentWrapper) {
160 return content;
161 }
162 return new ExtendingContentWrapper(content);
163 }
164
165 public boolean isExtending() {
166 return this.extending;
167 }
168
169 @Override
170 public Content getWrappedContent() {
171 Content wrapped = super.getWrappedContent();
172 if (wrapped instanceof ExtendingContentWrapper) {
173 ExtendingContentWrapperolia/cms/util/ExtendingContentWrapper.html#ExtendingContentWrapper">ExtendingContentWrapper wrappedECW = (ExtendingContentWrapper) wrapped;
174 if (!wrappedECW.extending) {
175
176 return ((ExtendingContentWrapper) wrapped).getWrappedContent();
177 }
178 }
179 return super.getWrappedContent();
180 }
181
182 @Override
183 public boolean hasContent(String name) throws RepositoryException {
184 if (getWrappedContent().hasContent(name)) {
185 return true;
186 } else if (extending && extendedContent.hasContent(name)) {
187 return true;
188 }
189 return false;
190 }
191
192 @Override
193 public Content getContent(String name) throws RepositoryException {
194 Content content;
195 if (getWrappedContent().hasContent(name)) {
196 content = getWrappedContent().getContent(name);
197 } else if (extending && extendedContent.hasContent(name)) {
198 content = extendedContent.getContent(name);
199 } else {
200
201 content = getWrappedContent().getContent(name);
202 }
203 return wrap(content);
204 }
205
206 @Override
207 public Collection<Content> getChildren(ContentFilter filter, String namePattern, Comparator<Content> orderCriteria) {
208 Collection<Content> directChildren = ((AbstractContent) getWrappedContent()).getChildren(filter, namePattern, orderCriteria);
209 if (extending) {
210 Collection<Content> inheritedChildren = ((AbstractContent) extendedContent).getChildren(filter, namePattern, orderCriteria);
211
212 LinkedHashMap<String, Content> merged = new LinkedHashMap<String, Content>();
213 for (Content content : inheritedChildren) {
214 merged.put(content.getName(), content);
215 }
216 for (Content content : directChildren) {
217 merged.put(content.getName(), content);
218 }
219 return wrapContentNodes(merged.values());
220 }
221 return wrapContentNodes(directChildren);
222 }
223
224 @Override
225 public NodeData getNodeData(String name) {
226 if (EXTENDING_NODE_DATA.equals(name)) {
227 return new DefaultNodeData(extendedContent, name) {
228 @Override
229 public boolean isExist() {
230 return false;
231 }
232
233 @Override
234 public void save() throws RepositoryException {
235
236 }
237 };
238 }
239 try {
240 if (getWrappedContent().hasNodeData(name)) {
241 return wrap(getWrappedContent().getNodeData(name));
242 } else if (extending && extendedContent.hasNodeData(name)) {
243 return wrap(extendedContent.getNodeData(name));
244 } else {
245 return wrap(getWrappedContent().getNodeData(name));
246 }
247 } catch (RepositoryException e) {
248 throw new RuntimeException("Can't read nodedata from extended node [" + extendedContent + "]", e);
249 }
250 }
251
252 @Override
253 public boolean hasNodeData(String name) throws RepositoryException {
254 if (EXTENDING_NODE_DATA.equals(name)) {
255 return false;
256 }
257 return super.hasNodeData(name);
258 }
259
260 @Override
261 public Collection<NodeData> getNodeDataCollection() {
262 final Content wrapped = getWrappedContent();
263 Collection<NodeData> directChildren = wrapped.getNodeDataCollection();
264 try {
265 if (wrapped.hasNodeData(EXTENDING_NODE_DATA)) {
266 for (NodeData child : directChildren) {
267 if (EXTENDING_NODE_DATA.equals(child.getName())) {
268 directChildren.remove(child);
269 break;
270 }
271 }
272 }
273 } catch (RepositoryException e) {
274 throw new RuntimeException("Can't read nodedata collection from node [" + wrapped.getHandle() + "]", e);
275 }
276 if (extending) {
277 Collection<NodeData> inheritedChildren = extendedContent.getNodeDataCollection();
278
279 SortedMap<String, NodeData> merged = new TreeMap<String, NodeData>();
280 for (NodeData nodeData : inheritedChildren) {
281 merged.put(nodeData.getName(), nodeData);
282 }
283 for (NodeData nodeData : directChildren) {
284 merged.put(nodeData.getName(), nodeData);
285 }
286 return wrapNodeDatas(merged.values());
287 }
288 return wrapNodeDatas(directChildren);
289 }
290
291 @Override
292 protected Contentef="../../../../info/magnolia/cms/core/Content.html#Content">Content wrap(Content node) {
293
294 try {
295 if (extending && extendedContent.hasContent(node.getName())) {
296
297 Content extendedSubContent = extendedContent.getContent(node.getName());
298 return new ExtendingContentWrapper(node, extendedSubContent);
299 }
300 } catch (RepositoryException e) {
301 throw new RuntimeException("Can't wrap " + node, e);
302 }
303 return wrapIfNeeded(node);
304 }
305
306 }