View Javadoc

1   package org.apache.turbine.modules.screens;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.commons.lang.StringUtils;
23  import org.apache.commons.lang.exception.ExceptionUtils;
24  import org.apache.ecs.ConcreteElement;
25  import org.apache.ecs.StringElement;
26  import org.apache.turbine.Turbine;
27  import org.apache.turbine.TurbineConstants;
28  import org.apache.turbine.pipeline.PipelineData;
29  import org.apache.turbine.services.template.TurbineTemplate;
30  import org.apache.turbine.services.velocity.TurbineVelocity;
31  import org.apache.turbine.util.RunData;
32  import org.apache.velocity.context.Context;
33  
34  /**
35   * Base Velocity Screen.  The buildTemplate() assumes the template
36   * parameter has been set in the RunData object.  This provides the
37   * ability to execute several templates from one Screen.
38   *
39   * <p>
40   *
41   * If you need more specific behavior in your application, extend this
42   * class and override the doBuildTemplate() method.
43   *
44   * @author <a href="mailto:mbryson@mont.mindspring.com">Dave Bryson</a>
45   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
46   * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
47   * @version $Id: VelocityScreen.java 1078552 2011-03-06 19:58:46Z tv $
48   */
49  public class VelocityScreen
50      extends TemplateScreen
51  {
52      /** The prefix for lookup up screen pages */
53      private final String prefix = getPrefix() + "/";
54  
55      /**
56       * Velocity Screens extending this class should overide this
57       * method to perform any particular business logic and add
58       * information to the context.
59       *
60       * @deprecated Use PipelineData version instead.
61       * @param data Turbine information.
62       * @param context Context for web pages.
63       * @exception Exception, a generic exception.
64       */
65      @Deprecated
66      protected void doBuildTemplate(RunData data,
67                                     Context context)
68              throws Exception
69      {
70          // empty
71      }
72  
73      /**
74       * Velocity Screens extending this class should overide this
75       * method to perform any particular business logic and add
76       * information to the context.
77       *
78       * @param pipelineData Turbine information.
79       * @param context Context for web pages.
80       * @exception Exception, a generic exception.
81       */
82      protected void doBuildTemplate(PipelineData pipelineData,
83                                     Context context)
84              throws Exception
85      {
86          // empty
87      }
88  
89  
90      /**
91       * Needs to be implemented to make TemplateScreen like us.  The
92       * actual method that you should override is the one with the
93       * context in the parameter list.
94       *
95       * @deprecated Use PipelineData version instead.
96       * @param data Turbine information.
97       * @exception Exception, a generic exception.
98       */
99      @Deprecated
100     @Override
101     protected void doBuildTemplate(RunData data)
102             throws Exception
103     {
104         doBuildTemplate(data, TurbineVelocity.getContext(data));
105     }
106 
107     /**
108      * Needs to be implemented to make TemplateScreen like us.  The
109      * actual method that you should override is the one with the
110      * context in the parameter list.
111      *
112      * @param data Turbine information.
113      * @exception Exception, a generic exception.
114      */
115     @Override
116     protected void doBuildTemplate(PipelineData pipelineData)
117             throws Exception
118     {
119         doBuildTemplate(pipelineData, TurbineVelocity.getContext(pipelineData));
120     }
121 
122 
123 
124     /**
125      * This builds the Velocity template.
126      *
127      * @deprecated Use PipelineData version instead.
128      * @param data Turbine information.
129      * @return A ConcreteElement.
130      * @exception Exception, a generic exception.
131      */
132     @Deprecated
133     @Override
134     public ConcreteElement buildTemplate(RunData data)
135         throws Exception
136     {
137         String screenData = null;
138 
139         Context context = TurbineVelocity.getContext(data);
140 
141         String screenTemplate = data.getTemplateInfo().getScreenTemplate();
142         String templateName
143             = TurbineTemplate.getScreenTemplateName(screenTemplate);
144 
145         // The Template Service could not find the Screen
146         if (StringUtils.isEmpty(templateName))
147         {
148             log.error("Screen " + screenTemplate + " not found!");
149             throw new Exception("Could not find screen for " + screenTemplate);
150         }
151 
152         try
153         {
154             // if a layout has been defined return the results, otherwise
155             // send the results directly to the output stream.
156             if (getLayout(data) == null)
157             {
158                 TurbineVelocity.handleRequest(context,
159                         prefix + templateName,
160                         data.getResponse().getOutputStream());
161             }
162             else
163             {
164                 screenData = TurbineVelocity
165                         .handleRequest(context, prefix + templateName);
166             }
167         }
168         catch (Exception e)
169         {
170             // If there is an error, build a $processingException and
171             // attempt to call the error.vm template in the screens
172             // directory.
173             context.put (TurbineConstants.PROCESSING_EXCEPTION_PLACEHOLDER, e.toString());
174             context.put (TurbineConstants.STACK_TRACE_PLACEHOLDER, ExceptionUtils.getStackTrace(e));
175 
176             templateName = Turbine.getConfiguration()
177                 .getString(TurbineConstants.TEMPLATE_ERROR_KEY,
178                            TurbineConstants.TEMPLATE_ERROR_VM);
179 
180             screenData = TurbineVelocity.handleRequest(
181                 context, prefix + templateName);
182         }
183 
184         // package the response in an ECS element
185         StringElement output = new StringElement();
186         output.setFilterState(false);
187 
188         if (screenData != null)
189         {
190             output.addElement(screenData);
191         }
192         return output;
193     }
194 
195     /**
196      * This builds the Velocity template.
197      *
198      * @param data Turbine information.
199      * @return A ConcreteElement.
200      * @exception Exception, a generic exception.
201      */
202     @Override
203     public ConcreteElement buildTemplate(PipelineData pipelineData)
204         throws Exception
205     {
206         RunData data = getRunData(pipelineData);
207         String screenData = null;
208 
209         Context context = TurbineVelocity.getContext(pipelineData);
210 
211         String screenTemplate = data.getTemplateInfo().getScreenTemplate();
212         String templateName
213             = TurbineTemplate.getScreenTemplateName(screenTemplate);
214 
215         // The Template Service could not find the Screen
216         if (StringUtils.isEmpty(templateName))
217         {
218             log.error("Screen " + screenTemplate + " not found!");
219             throw new Exception("Could not find screen for " + screenTemplate);
220         }
221 
222         try
223         {
224             // if a layout has been defined return the results, otherwise
225             // send the results directly to the output stream.
226             if (getLayout(pipelineData) == null)
227             {
228                 TurbineVelocity.handleRequest(context,
229                         prefix + templateName,
230                         data.getResponse().getOutputStream());
231             }
232             else
233             {
234                 screenData = TurbineVelocity
235                         .handleRequest(context, prefix + templateName);
236             }
237         }
238         catch (Exception e)
239         {
240             // If there is an error, build a $processingException and
241             // attempt to call the error.vm template in the screens
242             // directory.
243             context.put (TurbineConstants.PROCESSING_EXCEPTION_PLACEHOLDER, e.toString());
244             context.put (TurbineConstants.STACK_TRACE_PLACEHOLDER, ExceptionUtils.getStackTrace(e));
245 
246             templateName = Turbine.getConfiguration()
247                 .getString(TurbineConstants.TEMPLATE_ERROR_KEY,
248                            TurbineConstants.TEMPLATE_ERROR_VM);
249 
250             screenData = TurbineVelocity.handleRequest(
251                 context, prefix + templateName);
252         }
253 
254         // package the response in an ECS element
255         StringElement output = new StringElement();
256         output.setFilterState(false);
257 
258         if (screenData != null)
259         {
260             output.addElement(screenData);
261         }
262         return output;
263     }
264 
265 
266     /**
267      * Return the Context needed by Velocity.
268      *
269      * @param data Turbine information.
270      * @return A Context.
271      *
272      * @deprecated Use TurbineVelocity.getContext(data)
273      */
274     @Deprecated
275     public static Context getContext(RunData data)
276     {
277         return TurbineVelocity.getContext(data);
278     }
279 
280     /**
281      * Return the Context needed by Velocity.
282      *
283      * @param data Turbine information.
284      * @return A Context.
285      *
286      * @deprecated Use TurbineVelocity.getContext(pipelineData)
287      */
288     @Deprecated
289     public static Context getContext(PipelineData pipelineData)
290     {
291         return TurbineVelocity.getContext(pipelineData);
292     }
293 
294 }