View Javadoc
1   /*
2    * $Id$
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  package org.apache.struts.chain.contexts;
22  
23  import org.apache.commons.chain.Context;
24  import org.apache.struts.action.Action;
25  import org.apache.struts.action.ActionForm;
26  import org.apache.struts.action.ActionMessages;
27  import org.apache.struts.config.ActionConfig;
28  import org.apache.struts.config.ForwardConfig;
29  import org.apache.struts.config.ModuleConfig;
30  import org.apache.struts.util.MessageResources;
31  
32  import java.util.Locale;
33  import java.util.Map;
34  
35  /**
36   * <p>An ActionContext represents a view of a commons-chain
37   * <code>Context</code> which encapsulates access to request and
38   * session-scoped resources and services</p>
39   */
40  public interface ActionContext extends Context {
41      public static final String APPLICATION_SCOPE = "application";
42      public static final String SESSION_SCOPE = "session";
43      public static final String REQUEST_SCOPE = "request";
44  
45      // -------------------------------
46      // General Application Support
47      // -------------------------------
48  
49      /**
50       * Signal to the instance that it will not be used any more, so that any
51       * resources which should be cleaned up can be cleaned up.
52       */
53      void release();
54  
55      /**
56       * <p>Return a <code>Map</code> of Application scoped values.</p>
57       *
58       * <p>This is implemented in analogy with the Application scope in the
59       * Servlet API, but it seems reasonable to expect that any Struts
60       * implementation will have an equivalent concept.</p>
61       *
62       * <p>The ultimate meaning of "application scope" is an implementation
63       * detail left unspecified by Struts.</p>
64       *
65       * @return A Map of "application scope" attributes.
66       */
67      Map<String, Object> getApplicationScope();
68  
69      /**
70       * <p>Return a <code>Map</code> of Session scoped values.  A session is
71       * understood as a sequence of requests made by the same user.</p>
72       *
73       * <p>This is implemented in analogy with the Session scope in the Servlet
74       * API, but it seems reasonable to expect that any Struts implementation
75       * will have an equivalent concept.</p>
76       *
77       * <p>The ultimate meaning of "session scope" is an implementation detail
78       * left unspecified by Struts.</p>
79       *
80       * @return A Map of "session scope" attributes.
81       */
82      Map<String, Object> getSessionScope();
83  
84      /**
85       * <p>Return a <code>Map</code> of request scoped values.  A request is
86       * understood as the fundamental motivation for any particular instance of
87       * an <code>ActionContext</code>.</p>
88       *
89       * <p>This is implemented in analogy with the Request Context in the
90       * Servlet API, but it seems reasonable to expect that any Struts
91       * implementation will have an equivalent concept.</p>
92       *
93       * <p>The ultimate meaning of "request scope" is an implementation detail
94       * left unspecified by Struts.</p>
95       *
96       * @return a Map of "request scope" attributes.
97       */
98      Map<String, Object> getRequestScope();
99  
100     /**
101      * Return the Map representing the scope identified by
102      * <code>scopeName</code>. Implementations should support at minimum the
103      * names associated with the constants <code>APPLICATION_SCOPE</code>,
104      * <code>SESSION_SCOPE</code>, and <code>REQUEST_SCOPE</code>, but are
105      * permitted to support others as well.
106      *
107      * @param scopeName A token identifying a scope, including but not limited
108      *                  to <code>APPLICATION_SCOPE</code>, <code>SESSION_SCOPE</code>,
109      *                  <code>REQUEST_SCOPE</code>.
110      * @return A Map of attributes for the specified scope.
111      */
112     Map<String, Object> getScope(String scopeName);
113 
114     /**
115      * <p>Return a <code>Map</code> of parameters submitted by the user as
116      * part of this request.  The keys to this map will be request parameter
117      * names (of type <code>String</code>), and the values will be
118      * <code>String[]</code>.</p>
119      *
120      * <p>This is implemented in analogy with the Request parameters of the
121      * Servlet API, but it seems reasonable to expect that any Struts
122      * implementation will have an equivalent concept.</p>
123      *
124      * @return A map of the request parameter attributes
125      */
126     Map<String, String[]> getParameterMap();
127 
128     // -------------------------------
129     // General Struts properties
130     // -------------------------------
131 
132     /**
133      * <p> Set the action which has been identified to be executed as part of
134      * processing this request. </p>
135      *
136      * @param action
137      */
138     void setAction(Action action);
139 
140     /**
141      * <p> Get the action which has been identified to be executed as part of
142      * processing this request. </p>
143      *
144      * @return The action to be executed with this request
145      */
146     Action getAction();
147 
148     /**
149      * <p> Set the ActionForm instance which will carry any data submitted as
150      * part of this request. </p>
151      *
152      * @param form The ActionForm instance to use with this request
153      */
154     void setActionForm(ActionForm form);
155 
156     /**
157      * <p> Get the ActionForm instance which will carry any data submitted as
158      * part of this request. </p>
159      *
160      * @return The ActionForm being used with this request
161      */
162     ActionForm getActionForm();
163 
164     /**
165      * <p> Set the ActionConfig class contains the details for processing this
166      * request. </p>
167      *
168      * @param config The ActionConfig class to use with this request
169      */
170     void setActionConfig(ActionConfig config);
171 
172     /**
173      * <p> Get the ActionConfig which contains the details for processing this
174      * request.
175      *
176      * @return The ActionConfig class being used with this request </p>
177      */
178     ActionConfig getActionConfig();
179 
180     /**
181      * <p> Set the ForwardConfig which should be used as the basis of the view
182      * segment of the overall processing. This is the primary method of
183      * "communication" with the "view" sub-chain. </p>
184      *
185      * @param forward The ForwardConfig to use with this request
186      */
187     void setForwardConfig(ForwardConfig forward);
188 
189     /**
190      * <p> Get the ForwardConfig which has been identified as the basis for
191      * view-processing. </p>
192      *
193      * @return The ForwardConfig being used with this request
194      */
195     ForwardConfig getForwardConfig();
196 
197     /**
198      * <p> Set the include path which should be processed as part of
199      * processing this request. </p>
200      *
201      * @param include The include path to be used with this request
202      */
203     void setInclude(String include);
204 
205     /**
206      * <p> Get the include path which should be processed as part of
207      * processing this request. </p>
208      *
209      * @return The include path being used with this request
210      */
211     String getInclude();
212 
213     /**
214      * <p> Set the ModuleConfig which is operative for the current request.
215      * </p>
216      *
217      * @param config The ModuleConfig to be used with this request
218      */
219     void setModuleConfig(ModuleConfig config);
220 
221     /**
222      * <p> Get the ModuleConfig which is operative for the current request.
223      * </p>
224      *
225      * @return The MooduleConfig being used with this request
226      */
227     ModuleConfig getModuleConfig();
228 
229     /**
230      * <p> Is the ActionForm for this context valid? This method <em>does
231      * not</em> actually perform form validation. It is simply a holder
232      * property where processes which perform validation can store the results
233      * of the validation for other processes' benefit. </p>
234      *
235      * @return <code>Boolean.TRUE</code> if the form passed validation;
236      *         <code>Boolean.FALSE</code> if the form failed validation; null
237      *         if the form has not yet been validated
238      */
239     Boolean getFormValid();
240 
241     /**
242      * <p> Store the result of the validation of the Context's ActionForm.
243      * </p>
244      *
245      * @param valid Whether the ActionForm for this request passes validation
246      */
247     void setFormValid(Boolean valid);
248 
249     /**
250      * <p> Retrieve an exception which may have been caught by some code using
251      * this ActionContext, usually by an exception handler. </p>
252      *
253      * @return Any exception that may have been caught by this ActionContext
254      */
255     Exception getException();
256 
257     /**
258      * <p> Store an exception in this context for use by other handling code.
259      * </p>
260      *
261      * @param e An exception to be stored for handling by another member
262      */
263     void setException(Exception e);
264 
265     // -------------------------------
266     // ActionMessage Processing
267     // -------------------------------
268 
269     /**
270      * <p> Append the given messages keys to an internal cache, creating the
271      * cache if one is not already present. </p>
272      *
273      * @param messages New ActionMessages to cache
274      */
275     void addMessages(ActionMessages messages);
276 
277     /**
278      * <p> Append the given errors keys to an internal cache, creating the
279      * cache if one is not already present. </p>
280      *
281      * @param errors New ActionMessages to cache as errors
282      */
283     void addErrors(ActionMessages errors);
284 
285     /**
286      * <p> Retrieve error messages from an internal cache, creating an empty
287      * cache if one is not already present. </p>
288      *
289      * @return The ActionMessage cache for errors
290      */
291     ActionMessages getErrors();
292 
293     /**
294      * <p> Retrieve messages from an internal cache, creating an empty cache
295      * if one is not already present. </p>
296      *
297      * @return The ActionMessage cache for errors
298      */
299     ActionMessages getMessages();
300 
301     /**
302      * <p> Save the given error messages to the internal cache, clearing any
303      * previous messages in the cache. </p> <p> If the parameter is null or
304      * empty, the internal cache is removed. </p>
305      *
306      * @param errors ActionMesssages to cache as errors
307      */
308     void saveErrors(ActionMessages errors);
309 
310     /**
311      * <p> Save the given messages to the internal cache, clearing any
312      * previous messages in the cache. </p> <p> If the parameter is null or
313      * empty, the internal cache is removed. </p>
314      *
315      * @param messages ActionMesssages to cache
316      */
317     void saveMessages(ActionMessages messages);
318 
319     /**
320      * <p> Save the given messages to the internal cache, clearing any
321      * previous messages in the cache, but only for the specified scope. </p>
322      * <p> If the parameter is null or empty, the internal cache is removed.
323      * </p>
324      *
325      * @param scope    The scope for the internal cache
326      * @param messages ActionMesssages to cache
327      */
328     void saveMessages(String scope, ActionMessages messages);
329 
330     // -------------------------------
331     // Token Processing
332     // -------------------------------
333 
334     /**
335      * <p>Generate a new transaction token, to be used for enforcing a single
336      * request for a particular transaction.</p>
337      */
338     String generateToken();
339 
340     /**
341      * <p> Indicate whether a transaction token for this context is valid.
342      * </p> <p> A typical implementation will place a transaction token in the
343      * session" scope Map and a matching value in the  "parameter" Map. If the
344      * "session" token does not match the "parameter" attribute, or the
345      * session token is missing, then the transactional token is deemed
346      * invalid. </p>
347      */
348     boolean isTokenValid();
349 
350     /**
351      * <p> Indicate whether a transaction token is stored in the "session"
352      * scope for this context, optionally clearing the token, so that the next
353      * check would return false. </p>
354      *
355      * @param reset On true, clear the transactional token
356      */
357     boolean isTokenValid(boolean reset);
358 
359     /**
360      * <p> Clear any transactional token stored in the "session" scope for
361      * this context, so that the next check would return false. </p>
362      */
363     void resetToken();
364 
365     /**
366      * <p> Save a new transaction token in the "session" scope for this
367      * context, creating new resources, if needed. </p>
368      */
369     void saveToken();
370 
371     // -------------------------------
372     // Cancel Processing
373     // -------------------------------
374 
375     /**
376      * Indicate if the "cancel event" state is set for for this context,
377      *
378      * @see ActionContextBase#CANCEL_KEY
379      */
380     Boolean getCancelled();
381 
382     /**
383      * Set the "cancel event" state for this context.
384      *
385      * @param cancelled On true, set the cancel event state to true. On false,
386      *                  set the cancel event state to false.
387      *
388      * @see ActionContextBase#CANCEL_KEY
389      */
390     void setCancelled(Boolean cancelled);
391 
392     // -------------------------------
393     // MessageResources Processing
394     // -------------------------------
395 
396     /**
397      * <p>Return the default message resources for the current module.</p>
398      */
399     MessageResources getMessageResources();
400 
401     /**
402      * <p>Set the default message resources for the current module.</p>
403      */
404     void setMessageResources(MessageResources resources);
405 
406     /**
407      * <p>Return the specified message resources for the current module.</p>
408      *
409      * @param key The key specified in the <code>&lt;message-resources&gt;</code>
410      *            element for the requested bundle
411      */
412     MessageResources getMessageResources(String key);
413 
414     // -------------------------------
415     // Locale Processing
416     // -------------------------------
417 
418     /**
419      * <p>Return the user's currently selected Locale.</p>
420      */
421     Locale getLocale();
422 
423     /**
424      * <p>Set the user's currently selected <code>Locale</code>.</p>
425      *
426      * @param locale The user's selected Locale to be set, or null to select
427      *               the server's default Locale
428      */
429     void setLocale(Locale locale);
430 }