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,
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    }