001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.templateparser;
016    
017    import com.liferay.portal.kernel.configuration.Filter;
018    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
019    import com.liferay.portal.kernel.log.Log;
020    import com.liferay.portal.kernel.log.LogFactoryUtil;
021    import com.liferay.portal.kernel.mobile.device.Device;
022    import com.liferay.portal.kernel.mobile.device.UnknownDevice;
023    import com.liferay.portal.kernel.servlet.GenericServletWrapper;
024    import com.liferay.portal.kernel.servlet.PipingServletResponse;
025    import com.liferay.portal.kernel.template.StringTemplateResource;
026    import com.liferay.portal.kernel.template.Template;
027    import com.liferay.portal.kernel.template.TemplateConstants;
028    import com.liferay.portal.kernel.template.TemplateManagerUtil;
029    import com.liferay.portal.kernel.template.TemplateResource;
030    import com.liferay.portal.kernel.template.URLTemplateResource;
031    import com.liferay.portal.kernel.templateparser.TemplateNode;
032    import com.liferay.portal.kernel.templateparser.TransformException;
033    import com.liferay.portal.kernel.templateparser.TransformerListener;
034    import com.liferay.portal.kernel.util.Constants;
035    import com.liferay.portal.kernel.util.GetterUtil;
036    import com.liferay.portal.kernel.util.InstanceFactory;
037    import com.liferay.portal.kernel.util.LocaleUtil;
038    import com.liferay.portal.kernel.util.LocalizationUtil;
039    import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
040    import com.liferay.portal.kernel.util.PropertiesUtil;
041    import com.liferay.portal.kernel.util.SetUtil;
042    import com.liferay.portal.kernel.util.StringBundler;
043    import com.liferay.portal.kernel.util.StringPool;
044    import com.liferay.portal.kernel.util.StringUtil;
045    import com.liferay.portal.kernel.util.Validator;
046    import com.liferay.portal.kernel.xml.Document;
047    import com.liferay.portal.kernel.xml.DocumentException;
048    import com.liferay.portal.kernel.xml.Element;
049    import com.liferay.portal.kernel.xml.SAXReaderUtil;
050    import com.liferay.portal.model.Company;
051    import com.liferay.portal.security.permission.PermissionThreadLocal;
052    import com.liferay.portal.service.CompanyLocalServiceUtil;
053    import com.liferay.portal.theme.ThemeDisplay;
054    import com.liferay.portal.util.PropsUtil;
055    import com.liferay.portal.xsl.XSLTemplateResource;
056    import com.liferay.portal.xsl.XSLURIResolver;
057    import com.liferay.portlet.journal.util.JournalXSLURIResolver;
058    import com.liferay.portlet.portletdisplaytemplate.util.PortletDisplayTemplateConstants;
059    import com.liferay.taglib.util.VelocityTaglib;
060    import com.liferay.taglib.util.VelocityTaglibImpl;
061    import com.liferay.util.freemarker.FreeMarkerTaglibFactoryUtil;
062    
063    import freemarker.ext.servlet.HttpRequestHashModel;
064    import freemarker.ext.servlet.ServletContextHashModel;
065    
066    import freemarker.template.ObjectWrapper;
067    import freemarker.template.TemplateHashModel;
068    
069    import java.io.IOException;
070    
071    import java.net.URL;
072    
073    import java.util.ArrayList;
074    import java.util.HashMap;
075    import java.util.HashSet;
076    import java.util.List;
077    import java.util.Locale;
078    import java.util.Map;
079    import java.util.Set;
080    
081    import javax.servlet.GenericServlet;
082    import javax.servlet.Servlet;
083    import javax.servlet.ServletContext;
084    import javax.servlet.http.HttpServletRequest;
085    import javax.servlet.http.HttpServletResponse;
086    import javax.servlet.http.HttpSession;
087    import javax.servlet.jsp.PageContext;
088    
089    /**
090     * @author Brian Wing Shun Chan
091     * @author Raymond Aug??
092     * @author Wesley Gong
093     * @author Angelo Jefferson
094     * @author Hugo Huijser
095     * @author Marcellus Tavares
096     * @author Juan Fern??ndez
097     * @author Tibor Lipusz
098     */
099    public class Transformer {
100    
101            public Transformer(String errorTemplatePropertyKey, boolean restricted) {
102                    Set<String> langTypes = TemplateManagerUtil.getSupportedLanguageTypes(
103                            errorTemplatePropertyKey);
104    
105                    for (String langType : langTypes) {
106                            String errorTemplateId = PropsUtil.get(
107                                    errorTemplatePropertyKey, new Filter(langType));
108    
109                            if (Validator.isNotNull(errorTemplateId)) {
110                                    _errorTemplateIds.put(langType, errorTemplateId);
111                            }
112                    }
113    
114                    _restricted = restricted;
115            }
116    
117            public Transformer(
118                    String transformerListenerPropertyKey, String errorTemplatePropertyKey,
119                    boolean restricted) {
120    
121                    this(errorTemplatePropertyKey, restricted);
122    
123                    _transformerListenerClassNames = SetUtil.fromArray(
124                            PropsUtil.getArray(transformerListenerPropertyKey));
125            }
126    
127            public String transform(
128                            ThemeDisplay themeDisplay, Map<String, Object> contextObjects,
129                            String script, String langType)
130                    throws Exception {
131    
132                    return transform(null, themeDisplay, contextObjects, script, langType);
133            }
134    
135            public String transform(
136                            PageContext pageContext, ThemeDisplay themeDisplay,
137                            Map<String, Object> contextObjects, String script, String langType)
138                    throws Exception {
139    
140                    if (Validator.isNull(langType)) {
141                            return null;
142                    }
143    
144                    // Taglibs
145    
146                    if (pageContext != null) {
147                            if (langType.equals(TemplateConstants.LANG_TYPE_FTL)) {
148                                    _addTaglibSupportFTL(contextObjects, pageContext);
149                            }
150                            else if (langType.equals(TemplateConstants.LANG_TYPE_VM)) {
151                                    _addTaglibSupportVM(contextObjects, pageContext);
152                            }
153                    }
154    
155                    long companyId = 0;
156                    long companyGroupId = 0;
157                    long scopeGroupId = 0;
158                    long siteGroupId = 0;
159    
160                    if (themeDisplay != null) {
161                            companyId = themeDisplay.getCompanyId();
162                            companyGroupId = themeDisplay.getCompanyGroupId();
163                            scopeGroupId = themeDisplay.getScopeGroupId();
164                            siteGroupId = themeDisplay.getSiteGroupId();
165                    }
166    
167                    String templateId = String.valueOf(contextObjects.get("template_id"));
168    
169                    templateId = getTemplateId(
170                            templateId, companyId, companyGroupId, scopeGroupId);
171    
172                    Template template = getTemplate(templateId, script, langType);
173    
174                    UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
175    
176                    try {
177                            prepareTemplate(themeDisplay, template);
178    
179                            long classNameId = 0;
180    
181                            if (contextObjects != null) {
182                                    for (String key : contextObjects.keySet()) {
183                                            template.put(key, contextObjects.get(key));
184                                    }
185    
186                                    classNameId = GetterUtil.getLong(
187                                            contextObjects.get(TemplateConstants.CLASS_NAME_ID));
188                            }
189    
190                            template.put("company", getCompany(themeDisplay, companyId));
191                            template.put("companyId", companyId);
192                            template.put("device", getDevice(themeDisplay));
193    
194                            String templatesPath = getTemplatesPath(
195                                    companyId, scopeGroupId, classNameId);
196    
197                            template.put("journalTemplatesPath", templatesPath);
198                            template.put(
199                                    "permissionChecker",
200                                    PermissionThreadLocal.getPermissionChecker());
201                            template.put(
202                                    "randomNamespace",
203                                    StringUtil.randomId() + StringPool.UNDERLINE);
204                            template.put("scopeGroupId", scopeGroupId);
205                            template.put("siteGroupId", siteGroupId);
206                            template.put("templatesPath", templatesPath);
207    
208                            // Deprecated variables
209    
210                            template.put("groupId", scopeGroupId);
211    
212                            mergeTemplate(template, unsyncStringWriter);
213                    }
214                    catch (Exception e) {
215                            throw new TransformException("Unhandled exception", e);
216                    }
217    
218                    return unsyncStringWriter.toString();
219            }
220    
221            public String transform(
222                            ThemeDisplay themeDisplay, Map<String, String> tokens,
223                            String viewMode, String languageId, String xml, String script,
224                            String langType)
225                    throws Exception {
226    
227                    // Setup listeners
228    
229                    if (_log.isDebugEnabled()) {
230                            _log.debug("Language " + languageId);
231                    }
232    
233                    if (Validator.isNull(viewMode)) {
234                            viewMode = Constants.VIEW;
235                    }
236    
237                    if (_logTokens.isDebugEnabled()) {
238                            String tokensString = PropertiesUtil.list(tokens);
239    
240                            _logTokens.debug(tokensString);
241                    }
242    
243                    if (_logTransformBefore.isDebugEnabled()) {
244                            _logTransformBefore.debug(xml);
245                    }
246    
247                    List<TransformerListener> transformerListeners =
248                            new ArrayList<TransformerListener>();
249    
250                    for (String transformerListenersClassName :
251                                    _transformerListenerClassNames) {
252    
253                            TransformerListener transformerListener = null;
254    
255                            try {
256                                    if (_log.isDebugEnabled()) {
257                                            _log.debug(
258                                                    "Instantiate listener " +
259                                                            transformerListenersClassName);
260                                    }
261    
262                                    ClassLoader classLoader =
263                                            PortalClassLoaderUtil.getClassLoader();
264    
265                                    transformerListener =
266                                            (TransformerListener)InstanceFactory.newInstance(
267                                                    classLoader, transformerListenersClassName);
268    
269                                    transformerListeners.add(transformerListener);
270                            }
271                            catch (Exception e) {
272                                    _log.error(e, e);
273                            }
274    
275                            // Modify XML
276    
277                            if (_logXmlBeforeListener.isDebugEnabled()) {
278                                    _logXmlBeforeListener.debug(xml);
279                            }
280    
281                            if (transformerListener != null) {
282                                    xml = transformerListener.onXml(xml, languageId, tokens);
283    
284                                    if (_logXmlAfterListener.isDebugEnabled()) {
285                                            _logXmlAfterListener.debug(xml);
286                                    }
287                            }
288    
289                            // Modify script
290    
291                            if (_logScriptBeforeListener.isDebugEnabled()) {
292                                    _logScriptBeforeListener.debug(script);
293                            }
294    
295                            if (transformerListener != null) {
296                                    script = transformerListener.onScript(
297                                            script, xml, languageId, tokens);
298    
299                                    if (_logScriptAfterListener.isDebugEnabled()) {
300                                            _logScriptAfterListener.debug(script);
301                                    }
302                            }
303                    }
304    
305                    // Transform
306    
307                    String output = null;
308    
309                    if (Validator.isNull(langType)) {
310                            output = LocalizationUtil.getLocalization(xml, languageId);
311                    }
312                    else {
313                            long companyId = 0;
314                            long companyGroupId = 0;
315                            long articleGroupId = 0;
316                            long classNameId = 0;
317    
318                            if (tokens != null) {
319                                    companyId = GetterUtil.getLong(tokens.get("company_id"));
320                                    companyGroupId = GetterUtil.getLong(
321                                            tokens.get("company_group_id"));
322                                    articleGroupId = GetterUtil.getLong(
323                                            tokens.get("article_group_id"));
324                                    classNameId = GetterUtil.getLong(
325                                            tokens.get(TemplateConstants.CLASS_NAME_ID));
326                            }
327    
328                            long scopeGroupId = 0;
329                            long siteGroupId = 0;
330    
331                            if (themeDisplay != null) {
332                                    companyId = themeDisplay.getCompanyId();
333                                    companyGroupId = themeDisplay.getCompanyGroupId();
334                                    scopeGroupId = themeDisplay.getScopeGroupId();
335                                    siteGroupId = themeDisplay.getSiteGroupId();
336                            }
337    
338                            String templateId = tokens.get("template_id");
339    
340                            templateId = getTemplateId(
341                                    templateId, companyId, companyGroupId, articleGroupId);
342    
343                            Template template = getTemplate(
344                                    templateId, tokens, languageId, xml, script, langType);
345    
346                            UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
347    
348                            try {
349                                    if (Validator.isNotNull(xml)) {
350                                            Document document = SAXReaderUtil.read(xml);
351    
352                                            Element rootElement = document.getRootElement();
353    
354                                            List<TemplateNode> templateNodes = getTemplateNodes(
355                                                    themeDisplay, rootElement);
356    
357                                            if (templateNodes != null) {
358                                                    for (TemplateNode templateNode : templateNodes) {
359                                                            template.put(templateNode.getName(), templateNode);
360                                                    }
361                                            }
362    
363                                            Element requestElement = rootElement.element("request");
364    
365                                            template.put(
366                                                    "request", insertRequestVariables(requestElement));
367    
368                                            template.put("xmlRequest", requestElement.asXML());
369                                    }
370    
371                                    template.put("articleGroupId", articleGroupId);
372                                    template.put("company", getCompany(themeDisplay, companyId));
373                                    template.put("companyId", companyId);
374                                    template.put("device", getDevice(themeDisplay));
375    
376                                    String templatesPath = getTemplatesPath(
377                                            companyId, articleGroupId, classNameId);
378    
379                                    template.put("journalTemplatesPath", templatesPath);
380    
381                                    Locale locale = LocaleUtil.fromLanguageId(languageId);
382    
383                                    template.put("locale", locale);
384    
385                                    template.put(
386                                            "permissionChecker",
387                                            PermissionThreadLocal.getPermissionChecker());
388                                    template.put(
389                                            "randomNamespace",
390                                            StringUtil.randomId() + StringPool.UNDERLINE);
391                                    template.put("scopeGroupId", scopeGroupId);
392                                    template.put("siteGroupId", siteGroupId);
393                                    template.put("templatesPath", templatesPath);
394                                    template.put("viewMode", viewMode);
395    
396                                    // Deprecated variables
397    
398                                    template.put("groupId", articleGroupId);
399    
400                                    mergeTemplate(template, unsyncStringWriter);
401                            }
402                            catch (Exception e) {
403                                    if (e instanceof DocumentException) {
404                                            throw new TransformException(
405                                                    "Unable to read XML document", e);
406                                    }
407                                    else if (e instanceof IOException) {
408                                            throw new TransformException("Error reading template", e);
409                                    }
410                                    else if (e instanceof TransformException) {
411                                            throw (TransformException)e;
412                                    }
413                                    else {
414                                            throw new TransformException("Unhandled exception", e);
415                                    }
416                            }
417    
418                            output = unsyncStringWriter.toString();
419                    }
420    
421                    // Postprocess output
422    
423                    for (TransformerListener transformerListener : transformerListeners) {
424    
425                            // Modify output
426    
427                            if (_logOutputBeforeListener.isDebugEnabled()) {
428                                    _logOutputBeforeListener.debug(output);
429                            }
430    
431                            output = transformerListener.onOutput(output, languageId, tokens);
432    
433                            if (_logOutputAfterListener.isDebugEnabled()) {
434                                    _logOutputAfterListener.debug(output);
435                            }
436                    }
437    
438                    if (_logTransfromAfter.isDebugEnabled()) {
439                            _logTransfromAfter.debug(output);
440                    }
441    
442                    return output;
443            }
444    
445            protected Company getCompany(ThemeDisplay themeDisplay, long companyId)
446                    throws Exception {
447    
448                    if (themeDisplay != null) {
449                            return themeDisplay.getCompany();
450                    }
451    
452                    return CompanyLocalServiceUtil.getCompany(companyId);
453            }
454    
455            protected Device getDevice(ThemeDisplay themeDisplay) {
456                    if (themeDisplay != null) {
457                            return themeDisplay.getDevice();
458                    }
459    
460                    return UnknownDevice.getInstance();
461            }
462    
463            protected TemplateResource getErrorTemplateResource(String langType) {
464                    try {
465                            Class<?> clazz = getClass();
466    
467                            ClassLoader classLoader = clazz.getClassLoader();
468    
469                            String errorTemplateId = _errorTemplateIds.get(langType);
470    
471                            URL url = classLoader.getResource(errorTemplateId);
472    
473                            return new URLTemplateResource(errorTemplateId, url);
474                    }
475                    catch (Exception e) {
476                    }
477    
478                    return null;
479            }
480    
481            protected Template getTemplate(
482                            String templateId, Map<String, String> tokens, String languageId,
483                            String xml, String script, String langType)
484                    throws Exception {
485    
486                    TemplateResource templateResource = null;
487    
488                    if (langType.equals(TemplateConstants.LANG_TYPE_XSL)) {
489                            XSLURIResolver xslURIResolver = new JournalXSLURIResolver(
490                                    tokens, languageId);
491    
492                            templateResource = new XSLTemplateResource(
493                                    templateId, script, xslURIResolver, xml);
494                    }
495                    else {
496                            templateResource = new StringTemplateResource(templateId, script);
497                    }
498    
499                    TemplateResource errorTemplateResource = getErrorTemplateResource(
500                            langType);
501    
502                    return TemplateManagerUtil.getTemplate(
503                            langType, templateResource, errorTemplateResource, _restricted);
504            }
505    
506            protected Template getTemplate(
507                            String templateId, String script, String langType)
508                    throws Exception {
509    
510                    TemplateResource templateResource = new StringTemplateResource(
511                            templateId, script);
512    
513                    TemplateResource errorTemplateResource = getErrorTemplateResource(
514                            langType);
515    
516                    return TemplateManagerUtil.getTemplate(
517                            langType, templateResource, errorTemplateResource, _restricted);
518            }
519    
520            protected String getTemplateId(
521                    String templateId, long companyId, long companyGroupId, long groupId) {
522    
523                    StringBundler sb = new StringBundler(5);
524    
525                    sb.append(companyId);
526                    sb.append(StringPool.POUND);
527    
528                    if (companyGroupId > 0) {
529                            sb.append(companyGroupId);
530                    }
531                    else {
532                            sb.append(groupId);
533                    }
534    
535                    sb.append(StringPool.POUND);
536                    sb.append(templateId);
537    
538                    return sb.toString();
539            }
540    
541            protected List<TemplateNode> getTemplateNodes(
542                            ThemeDisplay themeDisplay, Element element)
543                    throws Exception {
544    
545                    List<TemplateNode> templateNodes = new ArrayList<TemplateNode>();
546    
547                    Map<String, TemplateNode> prototypeTemplateNodes =
548                            new HashMap<String, TemplateNode>();
549    
550                    List<Element> dynamicElementElements = element.elements(
551                            "dynamic-element");
552    
553                    for (Element dynamicElementElement : dynamicElementElements) {
554                            Element dynamicContentElement = dynamicElementElement.element(
555                                    "dynamic-content");
556    
557                            String data = StringPool.BLANK;
558    
559                            if (dynamicContentElement != null) {
560                                    data = dynamicContentElement.getText();
561                            }
562    
563                            String name = dynamicElementElement.attributeValue(
564                                    "name", StringPool.BLANK);
565    
566                            if (name.length() == 0) {
567                                    throw new TransformException(
568                                            "Element missing \"name\" attribute");
569                            }
570    
571                            String type = dynamicElementElement.attributeValue(
572                                    "type", StringPool.BLANK);
573    
574                            TemplateNode templateNode = new TemplateNode(
575                                    themeDisplay, name, stripCDATA(data), type);
576    
577                            if (dynamicElementElement.element("dynamic-element") != null) {
578                                    templateNode.appendChildren(
579                                            getTemplateNodes(themeDisplay, dynamicElementElement));
580                            }
581                            else if ((dynamicContentElement != null) &&
582                                             (dynamicContentElement.element("option") != null)) {
583    
584                                    List<Element> optionElements = dynamicContentElement.elements(
585                                            "option");
586    
587                                    for (Element optionElement : optionElements) {
588                                            templateNode.appendOption(
589                                                    stripCDATA(optionElement.getText()));
590                                    }
591                            }
592    
593                            TemplateNode prototypeTemplateNode = prototypeTemplateNodes.get(
594                                    name);
595    
596                            if (prototypeTemplateNode == null) {
597                                    prototypeTemplateNode = templateNode;
598    
599                                    prototypeTemplateNodes.put(name, prototypeTemplateNode);
600    
601                                    templateNodes.add(templateNode);
602                            }
603    
604                            prototypeTemplateNode.appendSibling(templateNode);
605                    }
606    
607                    return templateNodes;
608            }
609    
610            protected String getTemplatesPath(
611                    long companyId, long groupId, long classNameId) {
612    
613                    StringBundler sb = new StringBundler(7);
614    
615                    sb.append(TemplateConstants.TEMPLATE_SEPARATOR);
616                    sb.append(StringPool.SLASH);
617                    sb.append(companyId);
618                    sb.append(StringPool.SLASH);
619                    sb.append(groupId);
620                    sb.append(StringPool.SLASH);
621                    sb.append(classNameId);
622    
623                    return sb.toString();
624            }
625    
626            protected Map<String, Object> insertRequestVariables(Element element) {
627                    Map<String, Object> map = new HashMap<String, Object>();
628    
629                    if (element == null) {
630                            return map;
631                    }
632    
633                    for (Element childElement : element.elements()) {
634                            String name = childElement.getName();
635    
636                            if (name.equals("attribute")) {
637                                    Element nameElement = childElement.element("name");
638                                    Element valueElement = childElement.element("value");
639    
640                                    map.put(nameElement.getText(), valueElement.getText());
641                            }
642                            else if (name.equals("parameter")) {
643                                    Element nameElement = childElement.element("name");
644    
645                                    List<Element> valueElements = childElement.elements("value");
646    
647                                    if (valueElements.size() == 1) {
648                                            Element valueElement = valueElements.get(0);
649    
650                                            map.put(nameElement.getText(), valueElement.getText());
651                                    }
652                                    else {
653                                            List<String> values = new ArrayList<String>();
654    
655                                            for (Element valueElement : valueElements) {
656                                                    values.add(valueElement.getText());
657                                            }
658    
659                                            map.put(nameElement.getText(), values);
660                                    }
661                            }
662                            else {
663                                    List<Element> elements = childElement.elements();
664    
665                                    if (!elements.isEmpty()) {
666                                            map.put(name, insertRequestVariables(childElement));
667                                    }
668                                    else {
669                                            map.put(name, childElement.getText());
670                                    }
671                            }
672                    }
673    
674                    return map;
675            }
676    
677            protected void mergeTemplate(
678                            Template template, UnsyncStringWriter unsyncStringWriter)
679                    throws Exception {
680    
681                    VelocityTaglib velocityTaglib = (VelocityTaglib)template.get(
682                            PortletDisplayTemplateConstants.TAGLIB_LIFERAY);
683    
684                    if (velocityTaglib != null) {
685                            velocityTaglib.setTemplate(template);
686                    }
687    
688                    template.processTemplate(unsyncStringWriter);
689            }
690    
691            protected void prepareTemplate(ThemeDisplay themeDisplay, Template template)
692                    throws Exception {
693    
694                    if (themeDisplay == null) {
695                            return;
696                    }
697    
698                    template.prepare(themeDisplay.getRequest());
699            }
700    
701            protected String stripCDATA(String s) {
702                    if (s.startsWith(StringPool.CDATA_OPEN) &&
703                            s.endsWith(StringPool.CDATA_CLOSE)) {
704    
705                            s = s.substring(
706                                    StringPool.CDATA_OPEN.length(),
707                                    s.length() - StringPool.CDATA_CLOSE.length());
708                    }
709    
710                    return s;
711            }
712    
713            private void _addTaglibSupportFTL(
714                            Map<String, Object> contextObjects, PageContext pageContext)
715                    throws Exception {
716    
717                    // FreeMarker servlet application
718    
719                    final Servlet servlet = (Servlet)pageContext.getPage();
720    
721                    GenericServlet genericServlet = null;
722    
723                    if (servlet instanceof GenericServlet) {
724                            genericServlet = (GenericServlet)servlet;
725                    }
726                    else {
727                            genericServlet = new GenericServletWrapper(servlet);
728    
729                            genericServlet.init(pageContext.getServletConfig());
730                    }
731    
732                    ServletContextHashModel servletContextHashModel =
733                            new ServletContextHashModel(
734                                    genericServlet, ObjectWrapper.DEFAULT_WRAPPER);
735    
736                    contextObjects.put(
737                            PortletDisplayTemplateConstants.FREEMARKER_SERVLET_APPLICATION,
738                            servletContextHashModel);
739    
740                    // FreeMarker servlet request
741    
742                    HttpServletRequest request =
743                            (HttpServletRequest)pageContext.getRequest();
744                    HttpServletResponse response =
745                            (HttpServletResponse)pageContext.getResponse();
746    
747                    HttpRequestHashModel requestHashModel = new HttpRequestHashModel(
748                            request, response, ObjectWrapper.DEFAULT_WRAPPER);
749    
750                    contextObjects.put(
751                            PortletDisplayTemplateConstants.FREEMARKER_SERVLET_REQUEST,
752                            requestHashModel);
753    
754                    // Taglib Liferay hash
755    
756                    TemplateHashModel taglibLiferayHash =
757                            FreeMarkerTaglibFactoryUtil.createTaglibFactory(
758                                    pageContext.getServletContext());
759    
760                    contextObjects.put(
761                            PortletDisplayTemplateConstants.TAGLIB_LIFERAY_HASH,
762                            taglibLiferayHash);
763            }
764    
765            private void _addTaglibSupportVM(
766                    Map<String, Object> contextObjects, PageContext pageContext) {
767    
768                    contextObjects.put(
769                            PortletDisplayTemplateConstants.TAGLIB_LIFERAY,
770                            _getVelocityTaglib(pageContext));
771            }
772    
773            private VelocityTaglib _getVelocityTaglib(PageContext pageContext) {
774                    HttpServletRequest request =
775                            (HttpServletRequest)pageContext.getRequest();
776    
777                    HttpSession session = request.getSession();
778    
779                    ServletContext servletContext = session.getServletContext();
780    
781                    HttpServletResponse response =
782                            (HttpServletResponse)pageContext.getResponse();
783    
784                    VelocityTaglib velocityTaglib = new VelocityTaglibImpl(
785                            servletContext, request,
786                            new PipingServletResponse(response, pageContext.getOut()),
787                            pageContext, null);
788    
789                    return velocityTaglib;
790            }
791    
792            private static Log _log = LogFactoryUtil.getLog(Transformer.class);
793    
794            private static Log _logOutputAfterListener = LogFactoryUtil.getLog(
795                    Transformer.class.getName() + ".OutputAfterListener");
796            private static Log _logOutputBeforeListener = LogFactoryUtil.getLog(
797                    Transformer.class.getName() + ".OutputBeforeListener");
798            private static Log _logScriptAfterListener = LogFactoryUtil.getLog(
799                    Transformer.class.getName() + ".ScriptAfterListener");
800            private static Log _logScriptBeforeListener = LogFactoryUtil.getLog(
801                    Transformer.class.getName() + ".ScriptBeforeListener");
802            private static Log _logTokens = LogFactoryUtil.getLog(
803                    Transformer.class.getName() + ".Tokens");
804            private static Log _logTransformBefore = LogFactoryUtil.getLog(
805                    Transformer.class.getName() + ".TransformBefore");
806            private static Log _logTransfromAfter = LogFactoryUtil.getLog(
807                    Transformer.class.getName() + ".TransformAfter");
808            private static Log _logXmlAfterListener = LogFactoryUtil.getLog(
809                    Transformer.class.getName() + ".XmlAfterListener");
810            private static Log _logXmlBeforeListener = LogFactoryUtil.getLog(
811                    Transformer.class.getName() + ".XmlBeforeListener");
812    
813            private Map<String, String> _errorTemplateIds =
814                    new HashMap<String, String>();
815            private boolean _restricted;
816            private Set<String> _transformerListenerClassNames = new HashSet<String>();
817    
818    }