001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
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    /**
038     * @author Tina Tian
039     * @author Raymond Aug??
040     */
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    }