001    /**
002     * Copyright (c) 2000-2012 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.portlet;
016    
017    import com.liferay.portal.kernel.template.Template;
018    import com.liferay.portal.kernel.template.TemplateConstants;
019    import com.liferay.portal.kernel.template.TemplateContextType;
020    import com.liferay.portal.kernel.template.TemplateManagerUtil;
021    import com.liferay.portal.kernel.template.TemplateResource;
022    import com.liferay.portal.kernel.template.TemplateResourceLoaderUtil;
023    import com.liferay.portal.kernel.util.StringBundler;
024    import com.liferay.portal.kernel.util.UnsyncPrintWriterPool;
025    import com.liferay.portal.kernel.util.Validator;
026    import com.liferay.portal.struts.StrutsUtil;
027    
028    import java.io.IOException;
029    import java.io.PrintWriter;
030    
031    import javax.portlet.ActionRequest;
032    import javax.portlet.ActionResponse;
033    import javax.portlet.GenericPortlet;
034    import javax.portlet.MimeResponse;
035    import javax.portlet.PortletConfig;
036    import javax.portlet.PortletContext;
037    import javax.portlet.PortletException;
038    import javax.portlet.PortletRequest;
039    import javax.portlet.PortletResponse;
040    import javax.portlet.RenderRequest;
041    import javax.portlet.RenderResponse;
042    import javax.portlet.ResourceRequest;
043    import javax.portlet.ResourceResponse;
044    
045    import org.apache.velocity.io.VelocityWriter;
046    import org.apache.velocity.util.SimplePool;
047    
048    /**
049     * @author Brian Wing Shun Chan
050     * @author Steven P. Goldsmith
051     * @author Raymond Augé
052     */
053    public class VelocityPortlet extends GenericPortlet {
054    
055            @Override
056            public void doEdit(
057                            RenderRequest renderRequest, RenderResponse renderResponse)
058                    throws IOException, PortletException {
059    
060                    if (renderRequest.getPreferences() == null) {
061                            super.doEdit(renderRequest, renderResponse);
062    
063                            return;
064                    }
065    
066                    try {
067                            mergeTemplate(_editTemplateId, renderRequest, renderResponse);
068                    }
069                    catch (Exception e) {
070                            throw new PortletException(e);
071                    }
072            }
073    
074            @Override
075            public void doHelp(
076                            RenderRequest renderRequest, RenderResponse renderResponse)
077                    throws PortletException {
078    
079                    try {
080                            mergeTemplate(_helpTemplateId, renderRequest, renderResponse);
081                    }
082                    catch (Exception e) {
083                            throw new PortletException(e);
084                    }
085            }
086    
087            @Override
088            public void doView(
089                            RenderRequest renderRequest, RenderResponse renderResponse)
090                    throws PortletException {
091    
092                    try {
093                            mergeTemplate(_viewTemplateId, renderRequest, renderResponse);
094                    }
095                    catch (Exception e) {
096                            throw new PortletException(e);
097                    }
098            }
099    
100            @Override
101            public void init(PortletConfig portletConfig) throws PortletException {
102                    super.init(portletConfig);
103    
104                    PortletContext portletContext = portletConfig.getPortletContext();
105    
106                    _portletContextName = portletContext.getPortletContextName();
107    
108                    _actionTemplateId = getTemplateId(getInitParameter("action-template"));
109                    _editTemplateId = getTemplateId(getInitParameter("edit-template"));
110                    _helpTemplateId = getTemplateId(getInitParameter("help-template"));
111                    _resourceTemplateId = getTemplateId(
112                            getInitParameter("resource-template"));
113                    _viewTemplateId = getTemplateId(getInitParameter("view-template"));
114            }
115    
116            @Override
117            public void processAction(
118                            ActionRequest actionRequest, ActionResponse actionResponse)
119                    throws PortletException {
120    
121                    if (Validator.isNull(_actionTemplateId)) {
122                            return;
123                    }
124    
125                    try {
126                            mergeTemplate(_actionTemplateId, actionRequest, actionResponse);
127                    }
128                    catch (Exception e) {
129                            throw new PortletException(e);
130                    }
131            }
132    
133            @Override
134            public void serveResource(
135                            ResourceRequest resourceRequest, ResourceResponse resourceResponse)
136                    throws IOException, PortletException {
137    
138                    if (Validator.isNull(_resourceTemplateId)) {
139                            super.serveResource(resourceRequest, resourceResponse);
140    
141                            return;
142                    }
143    
144                    try {
145                            mergeTemplate(
146                                    _resourceTemplateId, resourceRequest, resourceResponse);
147                    }
148                    catch (Exception e) {
149                            throw new PortletException(e);
150                    }
151            }
152    
153            protected String getTemplateId(String name) {
154                    if (Validator.isNull(name)) {
155                            return name;
156                    }
157    
158                    StringBundler sb = new StringBundler(4);
159    
160                    sb.append(_portletContextName);
161                    sb.append(TemplateConstants.SERVLET_SEPARATOR);
162                    sb.append(StrutsUtil.TEXT_HTML_DIR);
163                    sb.append(name);
164    
165                    return sb.toString();
166            }
167    
168            protected void mergeTemplate(
169                            String templateId, PortletRequest portletRequest,
170                            PortletResponse portletResponse)
171                    throws Exception {
172    
173                    TemplateResource templateResource =
174                            TemplateResourceLoaderUtil.getTemplateResource(
175                                    TemplateConstants.LANG_TYPE_VM, templateId);
176    
177                    if (templateResource == null) {
178                            throw new Exception(
179                                    "Unable to load template resource " + templateId);
180                    }
181    
182                    Template template = TemplateManagerUtil.getTemplate(
183                            TemplateConstants.LANG_TYPE_VM, templateResource,
184                            TemplateContextType.STANDARD);
185    
186                    prepareTemplate(template, portletRequest, portletResponse);
187    
188                    mergeTemplate(templateId, template, portletRequest, portletResponse);
189            }
190    
191            protected void mergeTemplate(
192                            String templateId, Template template, PortletRequest portletRequest,
193                            PortletResponse portletResponse)
194                    throws Exception {
195    
196                    if (portletResponse instanceof MimeResponse) {
197                            MimeResponse mimeResponse = (MimeResponse)portletResponse;
198    
199                            mimeResponse.setContentType(
200                                    portletRequest.getResponseContentType());
201                    }
202    
203                    VelocityWriter velocityWriter = null;
204    
205                    try {
206                            velocityWriter = (VelocityWriter)_writerPool.get();
207    
208                            PrintWriter output = null;
209    
210                            if (portletResponse instanceof MimeResponse) {
211                                    MimeResponse mimeResponse = (MimeResponse)portletResponse;
212    
213                                    output = mimeResponse.getWriter();
214                            }
215                            else {
216                                    output = UnsyncPrintWriterPool.borrow(System.out);
217                            }
218    
219                            if (velocityWriter == null) {
220                                    velocityWriter = new VelocityWriter(output, 4 * 1024, true);
221                            }
222                            else {
223                                    velocityWriter.recycle(output);
224                            }
225    
226                            template.processTemplate(velocityWriter);
227                    }
228                    finally {
229                            try {
230                                    if (velocityWriter != null) {
231                                            velocityWriter.flush();
232                                            velocityWriter.recycle(null);
233    
234                                            _writerPool.put(velocityWriter);
235                                    }
236                            }
237                            catch (Exception e) {
238                            }
239                    }
240            }
241    
242            protected void prepareTemplate(
243                    Template template, PortletRequest portletRequest,
244                    PortletResponse portletResponse) {
245    
246                    template.put("portletConfig", getPortletConfig());
247                    template.put("portletContext", getPortletContext());
248                    template.put("preferences", portletRequest.getPreferences());
249                    template.put(
250                            "userInfo", portletRequest.getAttribute(PortletRequest.USER_INFO));
251    
252                    template.put("portletRequest", portletRequest);
253    
254                    if (portletRequest instanceof ActionRequest) {
255                            template.put("actionRequest", portletRequest);
256                    }
257                    else if (portletRequest instanceof RenderRequest) {
258                            template.put("renderRequest", portletRequest);
259                    }
260                    else {
261                            template.put("resourceRequest", portletRequest);
262                    }
263    
264                    template.put("portletResponse", portletResponse);
265    
266                    if (portletResponse instanceof ActionResponse) {
267                            template.put("actionResponse", portletResponse);
268                    }
269                    else if (portletRequest instanceof RenderResponse) {
270                            template.put("renderResponse", portletResponse);
271                    }
272                    else {
273                            template.put("resourceResponse", portletResponse);
274                    }
275            }
276    
277            private static SimplePool _writerPool = new SimplePool(40);
278    
279            private String _actionTemplateId;
280            private String _editTemplateId;
281            private String _helpTemplateId;
282            private String _portletContextName;
283            private String _resourceTemplateId;
284            private String _viewTemplateId;
285    
286    }