View Javadoc

1   /*
2    * Copyright 2001-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.portletbridge.portlet;
17  
18  import java.io.IOException;
19  import java.io.PrintWriter;
20  import java.io.Reader;
21  import java.net.URI;
22  import java.util.HashMap;
23  import java.util.Map;
24  
25  import javax.portlet.PortletPreferences;
26  import javax.portlet.RenderRequest;
27  import javax.portlet.RenderResponse;
28  import javax.xml.transform.Templates;
29  import javax.xml.transform.TransformerConfigurationException;
30  
31  import org.apache.xml.serialize.OutputFormat;
32  import org.apache.xml.serialize.Serializer;
33  import org.apache.xml.serialize.SerializerFactory;
34  import org.portletbridge.ResourceException;
35  import org.portletbridge.xsl.XslFilter;
36  import org.xml.sax.InputSource;
37  import org.xml.sax.SAXException;
38  import org.xml.sax.XMLReader;
39  
40  /***
41   * The default bridge transformer. Uses XSLT to transform the downstream 
42   * site into portlet content.
43   * 
44   * @author JMcCrindle
45   */
46  public class DefaultBridgeTransformer implements
47          BridgeTransformer {
48  
49      private TemplateFactory templateFactory = null;
50      private XMLReader parser;
51      private String servletName;
52      private final BridgeFunctionsFactory bridgeFunctionsFactory;
53  
54      /***
55       * Create a new transformer
56       */
57      public DefaultBridgeTransformer(BridgeFunctionsFactory bridgeFunctionsFactory, TemplateFactory templateFactory, XMLReader parser, String servletName) {
58          this.bridgeFunctionsFactory = bridgeFunctionsFactory;
59          this.templateFactory = templateFactory;
60          this.parser = parser;
61          this.servletName = servletName;
62      }
63  
64      /***
65       * Transforms the HTML from a downstream site using a configured XSL
66       * stylesheet.
67       * 
68       * @param request
69       *            the render request
70       * @param response
71       *            the render response
72       * @param in
73       *            the http result from calling the downstream site.
74       * @throws ResourceException
75       *             if there was a problem doing the transform (e.g. if the
76       *             stylesheet throws an error).
77       */
78      public void transform(PortletBridgeMemento memento, PerPortletMemento perPortletMemento, URI currentUrl,
79              RenderRequest request, RenderResponse response,
80              Reader in) throws ResourceException {
81          try {
82              PortletPreferences preferences = request.getPreferences();
83              String stylesheet = preferences.getValue("stylesheet", null);
84              String stylesheetUrl = preferences.getValue("stylesheetUrl", null);
85              Templates templates = null;
86              if(stylesheetUrl != null) {
87                  templates = templateFactory.getTemplatesFromUrl(stylesheetUrl);
88              } else {
89                  templates = templateFactory.getTemplatesFromString(stylesheet);
90              }
91              SerializerFactory factory = SerializerFactory
92                      .getSerializerFactory("html");
93              OutputFormat outputFormat = new OutputFormat();
94              outputFormat.setPreserveSpace(true);
95              outputFormat.setOmitDocumentType(true);
96              outputFormat.setOmitXMLDeclaration(true);
97              Serializer writer = factory.makeSerializer(outputFormat);
98              PrintWriter responseWriter = response.getWriter();
99              writer.setOutputCharStream(responseWriter);
100             XslFilter filter = new XslFilter(templates);
101             Map context = new HashMap();
102             context.put("bridge", bridgeFunctionsFactory.createBridgeFunctions(memento, perPortletMemento, servletName,
103                     currentUrl, request, response));
104             filter.setContext(context);
105             filter.setParent(parser);
106             filter.setContentHandler(writer.asContentHandler());
107             InputSource inputSource = new InputSource(in);
108             filter.parse(inputSource);
109         } catch (TransformerConfigurationException e) {
110             throw new ResourceException("error.transformer", e
111                     .getLocalizedMessage(), e);
112         } catch (SAXException e) {
113             throw new ResourceException("error.filter.sax", e
114                     .getLocalizedMessage(), e);
115         } catch (IOException e) {
116             throw new ResourceException("error.filter.io", e
117                     .getLocalizedMessage(), e);
118         }
119 
120     }
121 
122     public void setTemplateFactory(TemplateFactory templateFactory) {
123         this.templateFactory = templateFactory;
124     }
125 }