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,
058 TemplateResource errorTemplateResource, boolean restricted)
059 throws TemplateException {
060
061 return _instance._getTemplates(
062 templateManagerName, templateResources, errorTemplateResource,
063 restricted);
064 }
065
066 public static Template getTemplate(
067 String templateManagerName, TemplateResource templateResource,
068 boolean restricted)
069 throws TemplateException {
070
071 return _instance._getTemplate(
072 templateManagerName, templateResource, restricted);
073 }
074
075 public static Template getTemplate(
076 String templateManagerName, TemplateResource templateResource,
077 TemplateResource errorTemplateResource, boolean restricted)
078 throws TemplateException {
079
080 return _instance._getTemplate(
081 templateManagerName, templateResource, errorTemplateResource,
082 restricted);
083 }
084
085 public static TemplateManager getTemplateManager(
086 String templateManagerName) {
087
088 return _instance._getTemplateManager(templateManagerName);
089 }
090
091 public static Set<String> getTemplateManagerNames() {
092 return _instance._getTemplateManagerNames();
093 }
094
095 public static Map<String, TemplateManager> getTemplateManagers() {
096 return _instance._getTemplateManagers();
097 }
098
099 public static Template getTemplates(
100 String templateManagerName,
101 List<TemplateResource> templateResources, boolean restricted)
102 throws TemplateException {
103
104 return _instance._getTemplates(
105 templateManagerName, templateResources, restricted);
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, TemplateResource templateResource,
174 boolean restricted)
175 throws TemplateException {
176
177 TemplateManager templateManager = _getTemplateManagerChecked(
178 templateManagerName);
179
180 return templateManager.getTemplate(templateResource, restricted);
181 }
182
183 private Template _getTemplate(
184 String templateManagerName, TemplateResource templateResource,
185 TemplateResource errorTemplateResource, boolean restricted)
186 throws TemplateException {
187
188 TemplateManager templateManager = _getTemplateManagerChecked(
189 templateManagerName);
190
191 return templateManager.getTemplate(
192 templateResource, errorTemplateResource, restricted);
193 }
194
195 private TemplateManager _getTemplateManager(String templateManagerName) {
196 Collection<TemplateManager> templateManagers =
197 _templateManagers.values();
198
199 for (TemplateManager templateManager : templateManagers) {
200 if (templateManagerName.equals(templateManager.getName())) {
201 return templateManager;
202 }
203 }
204
205 return null;
206 }
207
208 private TemplateManager _getTemplateManagerChecked(
209 String templateManagerName)
210 throws TemplateException {
211
212 Collection<TemplateManager> templateManagers =
213 _templateManagers.values();
214
215 for (TemplateManager templateManager : templateManagers) {
216 if (templateManagerName.equals(templateManager.getName())) {
217 return templateManager;
218 }
219 }
220
221 throw new TemplateException(
222 "Unsupported template manager " + templateManagerName);
223 }
224
225 private Set<String> _getTemplateManagerNames() {
226 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
227
228 return templateManagers.keySet();
229 }
230
231 private Map<String, TemplateManager> _getTemplateManagers() {
232 Map<String, TemplateManager> map = new HashMap<>();
233
234 Collection<TemplateManager> templateManagers =
235 _templateManagers.values();
236
237 for (TemplateManager templateManager : templateManagers) {
238 map.put(templateManager.getName(), templateManager);
239 }
240
241 return Collections.unmodifiableMap(map);
242 }
243
244 private Template _getTemplates(
245 String templateManagerName,
246 List<TemplateResource> templateResources, boolean restricted)
247 throws TemplateException {
248
249 TemplateManager templateManager = _getTemplateManagerChecked(
250 templateManagerName);
251
252 return templateManager.getTemplates(templateResources, restricted);
253 }
254
255 private Template _getTemplates(
256 String templateManagerName,
257 List<TemplateResource> templateResources,
258 TemplateResource errorTemplateResource, boolean restricted)
259 throws TemplateException {
260
261 TemplateManager templateManager = _getTemplateManagerChecked(
262 templateManagerName);
263
264 return templateManager.getTemplates(
265 templateResources, errorTemplateResource, restricted);
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 }