001    /**
002     * Copyright (c) 2000-2013 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.template;
016    
017    import com.liferay.portal.kernel.security.pacl.NotPrivileged;
018    import com.liferay.portal.kernel.template.Template;
019    import com.liferay.portal.kernel.template.TemplateManager;
020    import com.liferay.portal.kernel.template.TemplateResource;
021    
022    import java.security.AccessControlContext;
023    import java.security.AccessController;
024    import java.security.PrivilegedAction;
025    
026    import java.util.Map;
027    
028    /**
029     * @author Raymond Aug??
030     */
031    public abstract class BaseTemplateManager implements TemplateManager {
032    
033            @NotPrivileged
034            @Override
035            public Template getTemplate(
036                    TemplateResource templateResource, boolean restricted) {
037    
038                    return getTemplate(templateResource, null, restricted);
039            }
040    
041            @NotPrivileged
042            @Override
043            public Template getTemplate(
044                    TemplateResource templateResource,
045                    TemplateResource errorTemplateResource, boolean restricted) {
046    
047                    TemplateControlContext templateControlContext =
048                            templateContextHelper.getTemplateControlContext();
049    
050                    AccessControlContext accessControlContext =
051                            templateControlContext.getAccessControlContext();
052    
053                    ClassLoader classLoader = templateControlContext.getClassLoader();
054    
055                    if (accessControlContext == null) {
056                            Map<String, Object> helperUtilities =
057                                    templateContextHelper.getHelperUtilities(
058                                            classLoader, restricted);
059    
060                            return doGetTemplate(
061                                    templateResource, errorTemplateResource, restricted,
062                                    helperUtilities, false);
063                    }
064    
065                    Map<String, Object> helperUtilities = AccessController.doPrivileged(
066                            new DoGetHelperUtilitiesPrivilegedAction(
067                                    templateContextHelper, classLoader, restricted),
068                            accessControlContext);
069    
070                    Template template = AccessController.doPrivileged(
071                            new DoGetTemplatePrivilegedAction(
072                                    templateResource, errorTemplateResource, restricted,
073                                    helperUtilities));
074    
075                    return new PrivilegedTemplateWrapper(accessControlContext, template);
076            }
077    
078            public void setTemplateContextHelper(
079                    TemplateContextHelper templateContextHelper) {
080    
081                    this.templateContextHelper = templateContextHelper;
082            }
083    
084            protected abstract Template doGetTemplate(
085                    TemplateResource templateResource,
086                    TemplateResource errorTemplateResource, boolean restricted,
087                    Map<String, Object> helperUtilities, boolean privileged);
088    
089            protected TemplateContextHelper templateContextHelper;
090    
091            private class DoGetHelperUtilitiesPrivilegedAction
092                    implements PrivilegedAction<Map<String, Object>> {
093    
094                    public DoGetHelperUtilitiesPrivilegedAction(
095                            TemplateContextHelper templateContextHelper,
096                            ClassLoader classLoader, boolean restricted) {
097    
098                            _templateContextHelper = templateContextHelper;
099                            _classLoader = classLoader;
100                            _restricted = restricted;
101                    }
102    
103                    @Override
104                    public Map<String, Object> run() {
105                            return _templateContextHelper.getHelperUtilities(
106                                    _classLoader, _restricted);
107                    }
108    
109                    private ClassLoader _classLoader;
110                    private boolean _restricted;
111                    private TemplateContextHelper _templateContextHelper;
112    
113            }
114    
115            private class DoGetTemplatePrivilegedAction
116                    implements PrivilegedAction<Template> {
117    
118                    public DoGetTemplatePrivilegedAction(
119                            TemplateResource templateResource,
120                            TemplateResource errorTemplateResource, boolean restricted,
121                            Map<String, Object> helperUtilities) {
122    
123                            _templateResource = templateResource;
124                            _errorTemplateResource = errorTemplateResource;
125                            _restricted = restricted;
126                            _helperUtilities = helperUtilities;
127                    }
128    
129                    @Override
130                    public Template run() {
131                            return doGetTemplate(
132                                    _templateResource, _errorTemplateResource, _restricted,
133                                    _helperUtilities, true);
134                    }
135    
136                    private TemplateResource _errorTemplateResource;
137                    private Map<String, Object> _helperUtilities;
138                    private boolean _restricted;
139                    private TemplateResource _templateResource;
140    
141            }
142    
143    }