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.rest.delivery.jcr.decorator;
35
36 import info.magnolia.jcr.util.NodeUtil;
37 import info.magnolia.jcr.wrapper.DelegateNodeWrapper;
38
39 import java.util.ArrayList;
40 import java.util.Collection;
41 import java.util.Collections;
42 import java.util.Iterator;
43 import java.util.List;
44 import java.util.stream.Collectors;
45
46 import javax.jcr.Item;
47 import javax.jcr.Node;
48 import javax.jcr.NodeIterator;
49 import javax.jcr.Property;
50 import javax.jcr.PropertyIterator;
51 import javax.jcr.RepositoryException;
52
53 import org.apache.jackrabbit.commons.ItemNameMatcher;
54 import org.apache.jackrabbit.commons.iterator.NodeIteratorAdapter;
55 import org.apache.jackrabbit.commons.iterator.PropertyIteratorAdapter;
56 import org.apache.jackrabbit.spi.commons.iterator.Iterators;
57 import org.slf4j.Logger;
58 import org.slf4j.LoggerFactory;
59
60 import com.google.common.collect.Lists;
61
62
63
64
65 public class AdditionNodeWrapper extends DelegateNodeWrapper {
66 private static final Logger log = LoggerFactory.getLogger(AdditionNodeWrapper.class);
67
68 private final String placeholderName;
69 private final List<Item> additionItems;
70
71 public AdditionNodeWrapper(Node node, String placeholderName, List<Item> additionItems) {
72 super(node);
73 this.placeholderName = placeholderName;
74 this.additionItems = additionItems;
75 }
76
77 public AdditionNodeWrapper(Node node, String placeholderName) {
78 this(node, placeholderName, Collections.emptyList());
79 }
80
81 public AdditionNodeWrapper(Node node, List<Item> additionItems) {
82 this(node, null, additionItems);
83 }
84
85 protected List<Item> getAdditionItems() {
86 return additionItems;
87 }
88
89 @Override
90 public String getName() throws RepositoryException {
91 return placeholderName == null ? super.getName() : placeholderName;
92 }
93
94 @Override
95 public PropertyIterator getProperties() throws RepositoryException {
96 return getProperties("*");
97 }
98
99 @Override
100 public PropertyIterator getProperties(String namePattern) throws RepositoryException {
101 return getProperties(new String[] { namePattern });
102 }
103
104 @Override
105 public PropertyIterator getProperties(String[] nameGlobs) throws RepositoryException {
106 Iterator<Property> properties = Iterators.properties(super.getProperties(nameGlobs));
107
108 List<Property> merged = Lists.newArrayList(properties);
109 List<Property> resolvedProperties = getAdditionItems().stream()
110 .filter(item -> {
111 try {
112 return !item.isNode() && ItemNameMatcher.matches(item.getName(), nameGlobs);
113 } catch (RepositoryException e) {
114 log.warn("Cannot get name of item {}:", item, e);
115 }
116
117 return false;
118 })
119 .map(item -> (Property) item)
120 .collect(Collectors.toList());
121 merged.addAll(resolvedProperties);
122
123 return new PropertyIteratorAdapter(merged);
124 }
125
126 @Override
127 public boolean hasNodes() throws RepositoryException {
128 boolean hasNodes = getAdditionItems().stream().anyMatch(Item::isNode);
129 return hasNodes || super.hasNodes();
130 }
131
132 @Override
133 public boolean hasProperties() throws RepositoryException {
134 boolean hasProperties = getAdditionItems().stream().anyMatch(item -> !item.isNode());
135 return hasProperties || super.hasProperties();
136 }
137
138 @Override
139 public NodeIterator getNodes() throws RepositoryException {
140 return getNodes("*");
141 }
142
143 @Override
144 public NodeIterator getNodes(String namePattern) throws RepositoryException {
145 return getNodes(new String[] { namePattern });
146 }
147
148 @Override
149 public NodeIterator getNodes(String[] nameGlobs) throws RepositoryException {
150 Collection<Node> children = NodeUtil.getCollectionFromNodeIterator(getWrappedNode().getNodes(nameGlobs));
151
152 List<Node> merged = new ArrayList<>(children);
153 List<Node> resolvedNodes = getAdditionItems().stream()
154 .filter(item -> {
155 try {
156 return item.isNode() && ItemNameMatcher.matches(item.getName(), nameGlobs);
157 } catch (RepositoryException e) {
158 log.warn("Cannot get name of item {}:", item, e);
159 }
160
161 return false;
162 })
163 .map(item -> (Node) item)
164 .collect(Collectors.toList());
165 merged.addAll(resolvedNodes);
166
167 return new NodeIteratorAdapter(merged);
168 }
169 }