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 private Set<String> registeredIds = new HashSet<String>();
67 private final RendererRegistry registry;
68
69 public static final String LISTENERS_NODE_NAME = "listeners";
70 public static final String RENDER_EMPTY_AREAS_PROPERTY = "renderEmptyAreas";
71
72 @Inject
73 public ConfiguredRendererManager(ModuleRegistry moduleRegistry, RendererRegistry registry) {
74 super("renderers", moduleRegistry);
75 this.registry = registry;
76 }
77
78 @Override
79 protected void reload(List<Node> nodes) throws RepositoryException {
80
81 final List<RendererProvider> providers = new ArrayList<RendererProvider>();
82
83 for (Node node : nodes) {
84
85 NodeUtil.visit(node, new NodeVisitor() {
86
87 @Override
88 public void visit(Node parent) throws RepositoryException {
89 for (Node configNode : NodeUtil.getNodes(parent, LISTENERS_FILTER)) {
90 RendererProvider provider = readProvider(configNode);
91 if (provider != null) {
92 providers.add(provider);
93 }
94 }
95 }
96 }, new NodeTypePredicate(NodeTypes.Content.NAME, false));
97
98 readListeners(node);
99 }
100
101 this.registeredIds = registry.unregisterAndRegister(registeredIds, providers);
102 }
103
104 protected RendererProvider readProvider(Node rendererNode) throws RepositoryException {
105 final String id = createId(rendererNode);
106
107 try {
108 return new ConfiguredRendererProvider(id, rendererNode);
109 } catch (Exception e) {
110 log.error("Unable to create provider renderer [" + id + "]", e);
111 return null;
112 }
113 }
114
115 private String createId(Node rendererNode) throws RepositoryException {
116 return rendererNode.getName();
117 }
118
119 private void readListeners(Node configNode) throws RepositoryException {
120 if (!configNode.hasNode(LISTENERS_NODE_NAME)) {
121 return;
122 }
123 for (Node node : NodeUtil.getNodes(configNode.getNode("listeners"), NodeTypes.ContentNode.NAME)) {
124 if (!node.hasProperty("class") || StringUtils.isEmpty(node.getProperty("class").getString())) {
125 continue;
126 }
127 final String className = node.getProperty("class").getString();
128 registry.registerListener(className);
129 }
130 }
131
132 private final AbstractPredicate<Node> LISTENERS_FILTER = new AbstractPredicate<Node>() {
133
134 @Override
135 public boolean evaluateTyped(Node node) {
136
137 try {
138 String nodeTypeName = node.getPrimaryNodeType().getName();
139 return nodeTypeName.equals(NodeTypes.ContentNode.NAME) && !LISTENERS_NODE_NAME.equals(node.getName());
140 } catch (RepositoryException e) {
141 log.error("Unable to read nodeType for node {}", node);
142 }
143 return false;
144 }
145 };
146 }