servletactioncontext.java.svn-base

MVC开源框架

/*
 * $Id$
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.struts.chain.contexts;

import org.apache.commons.chain.web.servlet.ServletWebContext;
import org.apache.struts.Globals;
import org.apache.struts.action.ActionMessages;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.chain.Constants;
import org.apache.struts.config.ActionConfig;
import org.apache.struts.util.MessageResources;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * <p> Implement ActionContext interface while making Servlet API-specific
 * values available. </p>
 */
public class ServletActionContext extends WebActionContext {
    /**
     * <p> Instantiate this composite by wrapping a ServletWebContext. </p>
     *
     * @param context The ServletWebContext to wrap
     */
    public ServletActionContext(ServletWebContext context) {
        super(context);
    }

    /**
     * <p> Instantiate this Context for a given ServletContext,
     * HttpServletRequest, and HttpServletResponse. </p>
     *
     * @param context  The instant ServletContext
     * @param request  The instant HttpServletRequest
     * @param response The instant HttpServletResponse
     */
    public ServletActionContext(ServletContext context,
        HttpServletRequest request, HttpServletResponse response) {
        this(new ServletWebContext(context, request, response));
    }

    /**
     * <p> Provide the ServletWebContext for this composite. </p>
     *
     * @return Our ServletWebContext
     */
    protected ServletWebContext servletWebContext() {
        return (ServletWebContext) this.getBaseContext();
    }

    public void release() {
        this.servletWebContext().release();
        super.release();
    }

    // -------------------------------
    // Servlet specific properties
    // -------------------------------

    /**
     * <p> Return the ServletContext for this context. </p>
     *
     * @return Our ServletContext
     */
    public ServletContext getContext() {
        return servletWebContext().getContext();
    }

    /**
     * <p> Return the HttpServletRequest for this context. </p>
     *
     * @return Our HttpServletRequest
     */
    public HttpServletRequest getRequest() {
        return servletWebContext().getRequest();
    }

    /**
     * <p> Return the HttpServletResponse for this context. </p>
     *
     * @return Our HttpServletResponse
     */
    public HttpServletResponse getResponse() {
        return servletWebContext().getResponse();
    }

    /**
     * <p> Return the ActionServlet for this context. </p>
     *
     * @return Our ActionServlet
     */
    public ActionServlet getActionServlet() {
        return (ActionServlet) this.get(Constants.ACTION_SERVLET_KEY);
    }

    /**
     * <p> Set the ActionServlet instance for this context. </p>
     *
     * @param servlet Our ActionServlet instance
     */
    public void setActionServlet(ActionServlet servlet) {
        this.put(Constants.ACTION_SERVLET_KEY, servlet);
    }

    // -------------------------------
    // Servlet specific modifications to base properties.
    // -------------------------------
    public void setActionConfig(ActionConfig actionConfig) {
        super.setActionConfig(actionConfig);
        this.getRequestScope().put(Globals.MAPPING_KEY, actionConfig);

        // ISSUE: Should we check this call to put?
    }

    public MessageResources getMessageResources() {
        return ((MessageResources) getRequest().getAttribute(Globals.MESSAGES_KEY));
    }

    // ISSUE: This method would probably be better handled by a "Struts"
    // object which encapsulated the servler (Application) scope.
    public MessageResources getMessageResources(String key) {
        // Identify the current module
        ServletContext context = getActionServlet().getServletContext();

        // Return the requested message resources instance
        return (MessageResources) context.getAttribute(key
            + getModuleConfig().getPrefix());
    }

    public void setMessageResources(MessageResources resources) {
        super.setMessageResources(resources);
        this.getRequest().setAttribute(Globals.MESSAGES_KEY, resources);
    }

    /**
     * <p> Store the mesasage resources for the current module under the given
     * request attribute key. </p>
     *
     * @param key       Request attribute key
     * @param resources Message resouces to store
     */
    public void setMessageResources(String key, MessageResources resources) {
        this.getRequest().setAttribute(key + getModuleConfig().getPrefix(),
            resources);
    }

    // -------------------------------
    // ActionMessage Processing
    // -------------------------------
    public void saveErrors(ActionMessages errors) {
        // Remove any error messages attribute if none are required
        if ((errors == null) || errors.isEmpty()) {
            getRequest().removeAttribute(Globals.ERROR_KEY);

            return;
        }

        // Save the error messages we need
        getRequest().setAttribute(Globals.ERROR_KEY, errors);
    }

    public void saveMessages(ActionMessages messages) {
        if ((messages == null) || messages.isEmpty()) {
            getRequest().removeAttribute(Globals.MESSAGE_KEY);

            return;
        }

        getRequest().setAttribute(Globals.MESSAGE_KEY, messages);
    }

    public void addMessages(ActionMessages messages) {
        if (messages == null) {
            return;
        }

        ActionMessages requestMessages = getMessages();

        if (requestMessages == null) {
            requestMessages = new ActionMessages();
        }

        requestMessages.add(messages);
        saveMessages(requestMessages);
    }

    public void addErrors(ActionMessages errors) {
        if (errors == null) {
            return;
        }

        ActionMessages requestErrors = getErrors();

        if (requestErrors == null) {
            requestErrors = new ActionMessages();
        }

        requestErrors.add(errors);
        saveErrors(requestErrors);
    }

    public ActionMessages getErrors() {
        return (ActionMessages) this.getRequest().getAttribute(Globals.ERROR_KEY);
    }

    public ActionMessages getMessages() {
        return (ActionMessages) this.getRequest().getAttribute(Globals.MESSAGE_KEY);
    }

    // -------------------------------
    // Token Processing
    // Implementing the servlet-aware versions by using the
    // TokenProcessor class
    // directly should ensure greater compatibility.
    // -------------------------------
    public void saveToken() {
        token.saveToken(getRequest());
    }

    public String generateToken() {
        return token.generateToken(getRequest());
    }

    public boolean isTokenValid(boolean reset) {
        return token.isTokenValid(getRequest(), reset);
    }

    public void resetToken() {
        token.resetToken(getRequest());
    }
}