001: /*
002: * $Id: ServletActionContext.java 471754 2006-11-06 14:55:09Z husted $
003: *
004: * Licensed to the Apache Software Foundation (ASF) under one
005: * or more contributor license agreements. See the NOTICE file
006: * distributed with this work for additional information
007: * regarding copyright ownership. The ASF licenses this file
008: * to you under the Apache License, Version 2.0 (the
009: * "License"); you may not use this file except in compliance
010: * with the License. You may obtain a copy of the License at
011: *
012: * http://www.apache.org/licenses/LICENSE-2.0
013: *
014: * Unless required by applicable law or agreed to in writing,
015: * software distributed under the License is distributed on an
016: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017: * KIND, either express or implied. See the License for the
018: * specific language governing permissions and limitations
019: * under the License.
020: */
021: package org.apache.struts.chain.contexts;
022:
023: import org.apache.commons.chain.web.servlet.ServletWebContext;
024: import org.apache.struts.Globals;
025: import org.apache.struts.action.ActionMessages;
026: import org.apache.struts.action.ActionServlet;
027: import org.apache.struts.chain.Constants;
028: import org.apache.struts.config.ActionConfig;
029: import org.apache.struts.util.MessageResources;
030:
031: import javax.servlet.ServletContext;
032: import javax.servlet.http.HttpServletRequest;
033: import javax.servlet.http.HttpServletResponse;
034:
035: /**
036: * <p> Implement ActionContext interface while making Servlet API-specific
037: * values available. </p>
038: */
039: public class ServletActionContext extends WebActionContext {
040: /**
041: * <p> Instantiate this composite by wrapping a ServletWebContext. </p>
042: *
043: * @param context The ServletWebContext to wrap
044: */
045: public ServletActionContext(ServletWebContext context) {
046: super (context);
047: }
048:
049: /**
050: * <p> Instantiate this Context for a given ServletContext,
051: * HttpServletRequest, and HttpServletResponse. </p>
052: *
053: * @param context The instant ServletContext
054: * @param request The instant HttpServletRequest
055: * @param response The instant HttpServletResponse
056: */
057: public ServletActionContext(ServletContext context,
058: HttpServletRequest request, HttpServletResponse response) {
059: this (new ServletWebContext(context, request, response));
060: }
061:
062: /**
063: * <p> Provide the ServletWebContext for this composite. </p>
064: *
065: * @return Our ServletWebContext
066: */
067: protected ServletWebContext servletWebContext() {
068: return (ServletWebContext) this .getBaseContext();
069: }
070:
071: public void release() {
072: this .servletWebContext().release();
073: super .release();
074: }
075:
076: // -------------------------------
077: // Servlet specific properties
078: // -------------------------------
079:
080: /**
081: * <p> Return the ServletContext for this context. </p>
082: *
083: * @return Our ServletContext
084: */
085: public ServletContext getContext() {
086: return servletWebContext().getContext();
087: }
088:
089: /**
090: * <p> Return the HttpServletRequest for this context. </p>
091: *
092: * @return Our HttpServletRequest
093: */
094: public HttpServletRequest getRequest() {
095: return servletWebContext().getRequest();
096: }
097:
098: /**
099: * <p> Return the HttpServletResponse for this context. </p>
100: *
101: * @return Our HttpServletResponse
102: */
103: public HttpServletResponse getResponse() {
104: return servletWebContext().getResponse();
105: }
106:
107: /**
108: * <p> Return the ActionServlet for this context. </p>
109: *
110: * @return Our ActionServlet
111: */
112: public ActionServlet getActionServlet() {
113: return (ActionServlet) this .get(Constants.ACTION_SERVLET_KEY);
114: }
115:
116: /**
117: * <p> Set the ActionServlet instance for this context. </p>
118: *
119: * @param servlet Our ActionServlet instance
120: */
121: public void setActionServlet(ActionServlet servlet) {
122: this .put(Constants.ACTION_SERVLET_KEY, servlet);
123: }
124:
125: // -------------------------------
126: // Servlet specific modifications to base properties.
127: // -------------------------------
128: public void setActionConfig(ActionConfig actionConfig) {
129: super .setActionConfig(actionConfig);
130: this .getRequestScope().put(Globals.MAPPING_KEY, actionConfig);
131:
132: // ISSUE: Should we check this call to put?
133: }
134:
135: public MessageResources getMessageResources() {
136: return ((MessageResources) getRequest().getAttribute(
137: Globals.MESSAGES_KEY));
138: }
139:
140: // ISSUE: This method would probably be better handled by a "Struts"
141: // object which encapsulated the servler (Application) scope.
142: public MessageResources getMessageResources(String key) {
143: // Identify the current module
144: ServletContext context = getActionServlet().getServletContext();
145:
146: // Return the requested message resources instance
147: return (MessageResources) context.getAttribute(key
148: + getModuleConfig().getPrefix());
149: }
150:
151: public void setMessageResources(MessageResources resources) {
152: super .setMessageResources(resources);
153: this .getRequest().setAttribute(Globals.MESSAGES_KEY, resources);
154: }
155:
156: /**
157: * <p> Store the mesasage resources for the current module under the given
158: * request attribute key. </p>
159: *
160: * @param key Request attribute key
161: * @param resources Message resouces to store
162: */
163: public void setMessageResources(String key,
164: MessageResources resources) {
165: this .getRequest().setAttribute(
166: key + getModuleConfig().getPrefix(), resources);
167: }
168:
169: // -------------------------------
170: // ActionMessage Processing
171: // -------------------------------
172: public void saveErrors(ActionMessages errors) {
173: // Remove any error messages attribute if none are required
174: if ((errors == null) || errors.isEmpty()) {
175: getRequest().removeAttribute(Globals.ERROR_KEY);
176:
177: return;
178: }
179:
180: // Save the error messages we need
181: getRequest().setAttribute(Globals.ERROR_KEY, errors);
182: }
183:
184: public void saveMessages(ActionMessages messages) {
185: if ((messages == null) || messages.isEmpty()) {
186: getRequest().removeAttribute(Globals.MESSAGE_KEY);
187:
188: return;
189: }
190:
191: getRequest().setAttribute(Globals.MESSAGE_KEY, messages);
192: }
193:
194: public void addMessages(ActionMessages messages) {
195: if (messages == null) {
196: return;
197: }
198:
199: ActionMessages requestMessages = getMessages();
200:
201: if (requestMessages == null) {
202: requestMessages = new ActionMessages();
203: }
204:
205: requestMessages.add(messages);
206: saveMessages(requestMessages);
207: }
208:
209: public void addErrors(ActionMessages errors) {
210: if (errors == null) {
211: return;
212: }
213:
214: ActionMessages requestErrors = getErrors();
215:
216: if (requestErrors == null) {
217: requestErrors = new ActionMessages();
218: }
219:
220: requestErrors.add(errors);
221: saveErrors(requestErrors);
222: }
223:
224: public ActionMessages getErrors() {
225: return (ActionMessages) this .getRequest().getAttribute(
226: Globals.ERROR_KEY);
227: }
228:
229: public ActionMessages getMessages() {
230: return (ActionMessages) this .getRequest().getAttribute(
231: Globals.MESSAGE_KEY);
232: }
233:
234: // -------------------------------
235: // Token Processing
236: // Implementing the servlet-aware versions by using the
237: // TokenProcessor class
238: // directly should ensure greater compatibility.
239: // -------------------------------
240: public void saveToken() {
241: token.saveToken(getRequest());
242: }
243:
244: public String generateToken() {
245: return token.generateToken(getRequest());
246: }
247:
248: public boolean isTokenValid(boolean reset) {
249: return token.isTokenValid(getRequest(), reset);
250: }
251:
252: public void resetToken() {
253: token.resetToken(getRequest());
254: }
255: }
|