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.rendering.renderer.registry;
35
36 import info.magnolia.cms.util.ModuleConfigurationObservingManager;
37 import info.magnolia.jcr.predicate.AbstractPredicate;
38 import info.magnolia.jcr.predicate.NodeTypePredicate;
39 import info.magnolia.jcr.util.NodeTypes;
40 import info.magnolia.jcr.util.NodeUtil;
41 import info.magnolia.jcr.util.NodeVisitor;
42 import info.magnolia.module.ModuleRegistry;
43
44 import java.util.ArrayList;
45 import java.util.HashSet;
46 import java.util.List;
47 import java.util.Set;
48
49 import javax.inject.Inject;
50 import javax.inject.Singleton;
51 import javax.jcr.Node;
52 import javax.jcr.RepositoryException;
53
54 import org.apache.commons.lang.StringUtils;
55 import org.slf4j.Logger;
56 import org.slf4j.LoggerFactory;
57
58
59
60
61 @Singleton
62 public class ConfiguredRendererManager extends ModuleConfigurationObservingManager {
63
64 protected final Logger log = LoggerFactory.getLogger(getClass());
65
66 public static final String LISTENERS_NODE_NAME = "listeners";
67 public static final String RENDER_EMPTY_AREAS_PROPERTY = "renderEmptyAreas";
68 public static final String AUTO_POPULATE_PROPERTY = "autoPopulateFromRequest";
69
70 private Set<String> registeredIds = new HashSet<String>();
71 private final RendererRegistry registry;
72
73 @Inject
74 public ConfiguredRendererManager(ModuleRegistry moduleRegistry, RendererRegistry registry) {
75 super("renderers", moduleRegistry);
76 this.registry = registry;
77 }
78
79 @Override
80 protected void reload(List<Node> nodes) throws RepositoryException {
81
82 final List<RendererProvider> providers = new ArrayList<RendererProvider>();
83
84 for (Node node : nodes) {
85
86 NodeUtil.visit(node, new NodeVisitor() {
87
88 @Override
89 public void visit(Node parent) throws RepositoryException {
90 for (Node configNode : NodeUtil.getNodes(parent, LISTENERS_FILTER)) {
91 RendererProvider provider = readProvider(configNode);
92 if (provider != null) {
93 providers.add(provider);
94 }
95 }
96 }
97 }, new NodeTypePredicate(NodeTypes.Content.NAME, false));
98
99 readListeners(node);
100 }
101
102 this.registeredIds = registry.unregisterAndRegister(registeredIds, providers);
103 }
104
105 protected RendererProvider readProvider(Node rendererNode) throws RepositoryException {
106 final String id = createId(rendererNode);
107
108 try {
109 return new ConfiguredRendererProvider(id, rendererNode);
110 } catch (Exception e) {
111 log.error("Unable to create provider renderer [" + id + "]", e);
112 return null;
113 }
114 }
115
116 private String createId(Node rendererNode) throws RepositoryException {
117 return rendererNode.getName();
118 }
119
120 private void readListeners(Node configNode) throws RepositoryException {
121 if (!configNode.hasNode(LISTENERS_NODE_NAME)) {
122 return;
123 }
124 for (Node node : NodeUtil.getNodes(configNode.getNode("listeners"), NodeTypes.ContentNode.NAME)) {
125 if (!node.hasProperty("class") || StringUtils.isEmpty(node.getProperty("class").getString())) {
126 continue;
127 }
128 final String className = node.getProperty("class").getString();
129 registry.registerListener(className);
130 }
131 }
132
133 private final AbstractPredicate<Node> LISTENERS_FILTER = new AbstractPredicate<Node>() {
134
135 @Override
136 public boolean evaluateTyped(Node node) {
137
138 try {
139 String nodeTypeName = node.getPrimaryNodeType().getName();
140 return nodeTypeName.equals(NodeTypes.ContentNode.NAME) && !LISTENERS_NODE_NAME.equals(node.getName());
141 } catch (RepositoryException e) {
142 log.error("Unable to read nodeType for node {}", node);
143 }
144 return false;
145 }
146 };
147 }