001
014
015 package com.liferay.portal.kernel.template;
016
017 import com.liferay.portal.kernel.configuration.Filter;
018 import com.liferay.portal.kernel.log.Log;
019 import com.liferay.portal.kernel.log.LogFactoryUtil;
020 import com.liferay.portal.kernel.util.PropsUtil;
021 import com.liferay.portal.kernel.util.Validator;
022 import com.liferay.registry.Registry;
023 import com.liferay.registry.RegistryUtil;
024 import com.liferay.registry.ServiceReference;
025 import com.liferay.registry.ServiceTracker;
026 import com.liferay.registry.ServiceTrackerCustomizer;
027
028 import java.util.Collection;
029 import java.util.Collections;
030 import java.util.HashMap;
031 import java.util.HashSet;
032 import java.util.List;
033 import java.util.Map;
034 import java.util.Set;
035 import java.util.concurrent.ConcurrentHashMap;
036
037
041 public class TemplateManagerUtil {
042
043 public static void destroy() {
044 _instance._destroy();
045 }
046
047 public static void destroy(ClassLoader classLoader) {
048 _instance._destroy(classLoader);
049 }
050
051 public static Set<String> getSupportedLanguageTypes(String propertyKey) {
052 return _instance._getSupportedLanguageTypes(propertyKey);
053 }
054
055 public static Template getTemplate(
056 String templateManagerName,
057 List<TemplateResource> templateResources, boolean restricted)
058 throws TemplateException {
059
060 return _instance._getTemplate(
061 templateManagerName, templateResources, restricted);
062 }
063
064 public static Template getTemplate(
065 String templateManagerName,
066 List<TemplateResource> templateResources,
067 TemplateResource errorTemplateResource, boolean restricted)
068 throws TemplateException {
069
070 return _instance._getTemplate(
071 templateManagerName, templateResources, errorTemplateResource,
072 restricted);
073 }
074
075 public static Template getTemplate(
076 String templateManagerName, TemplateResource templateResource,
077 boolean restricted)
078 throws TemplateException {
079
080 return _instance._getTemplate(
081 templateManagerName, templateResource, restricted);
082 }
083
084 public static Template getTemplate(
085 String templateManagerName, TemplateResource templateResource,
086 TemplateResource errorTemplateResource, boolean restricted)
087 throws TemplateException {
088
089 return _instance._getTemplate(
090 templateManagerName, templateResource, errorTemplateResource,
091 restricted);
092 }
093
094 public static TemplateManager getTemplateManager(
095 String templateManagerName) {
096
097 return _instance._getTemplateManager(templateManagerName);
098 }
099
100 public static Set<String> getTemplateManagerNames() {
101 return _instance._getTemplateManagerNames();
102 }
103
104 public static Map<String, TemplateManager> getTemplateManagers() {
105 return _instance._getTemplateManagers();
106 }
107
108 public static boolean hasTemplateManager(String templateManagerName) {
109 return _instance._hasTemplateManager(templateManagerName);
110 }
111
112 private TemplateManagerUtil() {
113 Registry registry = RegistryUtil.getRegistry();
114
115 com.liferay.registry.Filter filter = registry.getFilter(
116 "(&(language.type=*)(objectClass=" +
117 TemplateManager.class.getName() + "))");
118
119 _serviceTracker = registry.trackServices(
120 filter, new TemplateManagerServiceTrackerCustomizer());
121
122 _serviceTracker.open();
123 }
124
125 private void _destroy() {
126 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
127
128 for (TemplateManager templateManager : templateManagers.values()) {
129 templateManager.destroy();
130 }
131
132 templateManagers.clear();
133 }
134
135 private void _destroy(ClassLoader classLoader) {
136 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
137
138 for (TemplateManager templateManager : templateManagers.values()) {
139 templateManager.destroy(classLoader);
140 }
141 }
142
143 private Set<String> _getSupportedLanguageTypes(String propertyKey) {
144 Set<String> supportedLanguageTypes = _supportedLanguageTypes.get(
145 propertyKey);
146
147 if (supportedLanguageTypes != null) {
148 return supportedLanguageTypes;
149 }
150
151 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
152
153 supportedLanguageTypes = new HashSet<>();
154
155 for (String templateManagerName : templateManagers.keySet()) {
156 String content = PropsUtil.get(
157 propertyKey, new Filter(templateManagerName));
158
159 if (Validator.isNotNull(content)) {
160 supportedLanguageTypes.add(templateManagerName);
161 }
162 }
163
164 supportedLanguageTypes = Collections.unmodifiableSet(
165 supportedLanguageTypes);
166
167 _supportedLanguageTypes.put(propertyKey, supportedLanguageTypes);
168
169 return supportedLanguageTypes;
170 }
171
172 private Template _getTemplate(
173 String templateManagerName,
174 List<TemplateResource> templateResources, boolean restricted)
175 throws TemplateException {
176
177 TemplateManager templateManager = _getTemplateManagerChecked(
178 templateManagerName);
179
180 return templateManager.getTemplate(templateResources, restricted);
181 }
182
183 private Template _getTemplate(
184 String templateManagerName,
185 List<TemplateResource> templateResources,
186 TemplateResource errorTemplateResource, boolean restricted)
187 throws TemplateException {
188
189 TemplateManager templateManager = _getTemplateManagerChecked(
190 templateManagerName);
191
192 return templateManager.getTemplate(
193 templateResources, errorTemplateResource, restricted);
194 }
195
196 private Template _getTemplate(
197 String templateManagerName, TemplateResource templateResource,
198 boolean restricted)
199 throws TemplateException {
200
201 TemplateManager templateManager = _getTemplateManagerChecked(
202 templateManagerName);
203
204 return templateManager.getTemplate(templateResource, restricted);
205 }
206
207 private Template _getTemplate(
208 String templateManagerName, TemplateResource templateResource,
209 TemplateResource errorTemplateResource, boolean restricted)
210 throws TemplateException {
211
212 TemplateManager templateManager = _getTemplateManagerChecked(
213 templateManagerName);
214
215 return templateManager.getTemplate(
216 templateResource, errorTemplateResource, restricted);
217 }
218
219 private TemplateManager _getTemplateManager(String templateManagerName) {
220 Collection<TemplateManager> templateManagers =
221 _templateManagers.values();
222
223 for (TemplateManager templateManager : templateManagers) {
224 if (templateManagerName.equals(templateManager.getName())) {
225 return templateManager;
226 }
227 }
228
229 return null;
230 }
231
232 private TemplateManager _getTemplateManagerChecked(
233 String templateManagerName)
234 throws TemplateException {
235
236 Collection<TemplateManager> templateManagers =
237 _templateManagers.values();
238
239 for (TemplateManager templateManager : templateManagers) {
240 if (templateManagerName.equals(templateManager.getName())) {
241 return templateManager;
242 }
243 }
244
245 throw new TemplateException(
246 "Unsupported template manager " + templateManagerName);
247 }
248
249 private Set<String> _getTemplateManagerNames() {
250 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
251
252 return templateManagers.keySet();
253 }
254
255 private Map<String, TemplateManager> _getTemplateManagers() {
256 Map<String, TemplateManager> map = new HashMap<>();
257
258 Collection<TemplateManager> templateManagers =
259 _templateManagers.values();
260
261 for (TemplateManager templateManager : templateManagers) {
262 map.put(templateManager.getName(), templateManager);
263 }
264
265 return Collections.unmodifiableMap(map);
266 }
267
268 private boolean _hasTemplateManager(String templateManagerName) {
269 Collection<TemplateManager> templateManagers =
270 _templateManagers.values();
271
272 for (TemplateManager templateManager : templateManagers) {
273 if (templateManagerName.equals(templateManager.getName())) {
274 return true;
275 }
276 }
277
278 return false;
279 }
280
281 private static final Log _log = LogFactoryUtil.getLog(
282 TemplateManagerUtil.class);
283
284 private static final TemplateManagerUtil _instance =
285 new TemplateManagerUtil();
286
287 private final ServiceTracker<TemplateManager, TemplateManager>
288 _serviceTracker;
289 private final Map<String, Set<String>> _supportedLanguageTypes =
290 new ConcurrentHashMap<>();
291 private final Map<ServiceReference<TemplateManager>, TemplateManager>
292 _templateManagers = new ConcurrentHashMap<>();
293
294 private class TemplateManagerServiceTrackerCustomizer
295 implements ServiceTrackerCustomizer<TemplateManager, TemplateManager> {
296
297 @Override
298 public TemplateManager addingService(
299 ServiceReference<TemplateManager> serviceReference) {
300
301 Registry registry = RegistryUtil.getRegistry();
302
303 TemplateManager templateManager = registry.getService(
304 serviceReference);
305
306 String name = templateManager.getName();
307
308 try {
309 templateManager.init();
310
311 _templateManagers.put(serviceReference, templateManager);
312 }
313 catch (TemplateException te) {
314 if (_log.isWarnEnabled()) {
315 _log.warn(
316 "unable to init " + name + " Template Manager ", te);
317 }
318 }
319
320 return templateManager;
321 }
322
323 @Override
324 public void modifiedService(
325 ServiceReference<TemplateManager> serviceReference,
326 TemplateManager templateManager) {
327 }
328
329 @Override
330 public void removedService(
331 ServiceReference<TemplateManager> serviceReference,
332 TemplateManager templateManager) {
333
334 Registry registry = RegistryUtil.getRegistry();
335
336 registry.ungetService(serviceReference);
337
338 _templateManagers.remove(serviceReference);
339
340 templateManager.destroy();
341 }
342
343 }
344
345 }