| /* |
| * $Id$ |
| * |
| * Copyright 2001,2004 The Apache Software Foundation. |
| * |
| * Licensed 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.action; |
| |
| import java.io.IOException; |
| |
| |
| import javax.servlet.ServletException; |
| |
| |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpSession; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.apache.struts.action.Action; |
| import org.apache.struts.action.ActionError; |
| import org.apache.struts.action.ActionErrors; |
| import org.apache.struts.action.ActionForm; |
| import org.apache.struts.action.ActionForward; |
| import org.apache.struts.action.ActionMapping; |
| import org.apache.struts.action.ActionServlet; |
| |
| import org.apache.commons.workflow.Activity; |
| import org.apache.commons.workflow.Step; |
| import org.apache.commons.workflow.StepException; |
| import org.apache.commons.workflow.Context; |
| import org.apache.commons.workflow.ContextEvent; |
| import org.apache.commons.workflow.ContextListener; |
| import org.apache.commons.workflow.Registry; |
| |
| import org.apache.commons.workflow.web.WebContext; |
| |
| |
| |
| /** |
| * @author Craig McClanahan |
| * @author Ted Husted |
| * @version $Rev$ $Date$ |
| */ |
| public class ActivityAction extends Action implements ContextListener { |
| |
| |
| // --------------------------------------------------------- Instance Variables |
| |
| |
| // ** FOR THREAD-SAFETY THESE MUST BE GLOBAL TO APPLICATION |
| // ** AND NOT SPECIFIC TO A GIVEN REQUEST |
| |
| protected Registry registry = null; |
| |
| protected Activity activity = null; |
| |
| |
| // --------------------------------------------------------- Protected Methods |
| |
| |
| /** |
| * Whether the debug level is set to verbose logging. |
| */ |
| protected boolean doDebugLog() { |
| |
| return ((servlet.getDebug() > 1)); |
| |
| } |
| |
| |
| /** |
| * Whether the debug level is set to listening. |
| */ |
| protected boolean doDebugListener() { |
| |
| return ((servlet.getDebug() > 2)); |
| |
| } |
| |
| |
| /** |
| * Return Activity by ID |
| */ |
| protected Activity getActivity(String id) { |
| |
| // return (registry.getActivity(id)); |
| return this.activity; |
| |
| } |
| |
| |
| /** |
| * Return Activity by looking up ID in mapping. |
| */ |
| protected Activity getActivity(ActionMapping mapping) { |
| |
| return (getActivity(mapping.getParameter())); |
| |
| } |
| |
| |
| /** |
| * Return context, instantiating it if necessary. |
| */ |
| protected WebContext getContext(ActionMapping mapping, |
| HttpServletRequest request, HttpServletResponse response) { |
| |
| String contextId = mapping.getParameter(); |
| HttpSession session = request.getSession(); |
| WebContext context = (WebContext) |
| session.getAttribute(contextId); |
| if (context == null) { |
| if (doDebugLog()) |
| servlet.log("{" + session.getId() + "} Creating new Context"); |
| context = new WebContext(); |
| // context.setActivity(getActivity(contextId)); |
| context.setActivity(activity); |
| context.setHttpSession(session); |
| context.setServletContext(servlet.getServletContext()); |
| if (doDebugListener()) |
| context.addContextListener(this); |
| session.setAttribute(contextId, context); |
| context.call(context.getActivity()); |
| } |
| return context; |
| |
| } |
| |
| |
| /** |
| * Validate context, returning errors if found. |
| */ |
| protected void validateInit(ActionErrors errors, |
| Context context, Activity activity) { |
| |
| if ((context==null) || |
| (context.getActivity()==null)) { |
| errors.add(ActionErrors.GLOBAL_ERROR, |
| new ActionError("action.missing.parameter")); |
| } |
| |
| } |
| |
| |
| /** |
| * Execute the next stage of the current Activity |
| */ |
| protected void executeContext(WebContext context, Activity activity, |
| ActionMapping mapping, ActionForm form, |
| HttpServletRequest request, HttpServletResponse response) |
| throws ServletException { |
| |
| synchronized (context) { |
| |
| // If we are not already executing our associated Activity, call it |
| if (!activity.equals(context.getActivity())) { |
| if (doDebugLog()) |
| servlet.log("{" + request.getSession().getId() + |
| "} calling Activity " + |
| activity.getId()); |
| context.call(activity); |
| } |
| |
| // Associate our context with the current request and response |
| context.setServletRequest(request); |
| context.setServletResponse(response); |
| |
| // Execute our activity until suspended or ended |
| try { |
| if (doDebugLog()) |
| servlet.log("{" + context.getHttpSession().getId() + |
| "} executing Activity " + |
| context.getActivity().getId()); |
| context.execute(); |
| } catch (StepException e) { |
| if (e.getCause() == null) |
| throw new ServletException(e.getMessage(), e); |
| else |
| throw new ServletException(e.getMessage(), |
| e.getCause()); |
| } |
| } |
| } |
| |
| |
| /** |
| * Analyze initialization properties, |
| * and report any errors. |
| */ |
| protected void validateContext(ActionErrors errors, |
| Context context) { |
| } |
| |
| |
| /** |
| * Analyze result, and determine next forward. |
| * <p> |
| * If no errors, forward for id of next step is returned. |
| * <p> |
| * If there are errors, save errors to request, and |
| * forward to input. If there is not input property, |
| * then forward to local or global "errors" forwarding. |
| */ |
| protected ActionForward nextForward(ActionMapping mapping, |
| ActionErrors errors, HttpServletRequest request, |
| WebContext context) { |
| |
| if (!errors.empty()) { |
| |
| // Save for display |
| saveErrors(request,errors); |
| |
| // Return to input page, if there is one |
| if (mapping.getInput()!=null) |
| return (new ActionForward(mapping.getInput())); |
| |
| // If no input page, use error forwarding |
| return (mapping.findForward("error")); |
| } |
| |
| // If no errors, goto forwarding for next step |
| return (mapping.findForward( |
| context.getNextStep().getId())); |
| } |
| |
| |
| // --------------------------------------------------------- Public Properties |
| |
| |
| /** |
| * Set the Registry for this Action (or application) |
| */ |
| public void setRegistry(Registry registry) { |
| this.registry = registry; |
| } |
| |
| |
| |
| // --------------------------------------------------------- Public Methods |
| |
| /** |
| * Set the controller servlet instance to which we are attached |
| * (if servlet is non-null), or release any allocated resources |
| * (if servlet is null). |
| * Call setRegistry to obtain registry from servlet context. |
| */ |
| public void setServlet(ActionServlet servlet) { |
| super.setServlet(servlet); |
| |
| if (servlet==null) { |
| setRegistry(null); |
| this.activity = null; |
| } |
| else { |
| setRegistry((Registry) |
| servlet.getServletContext().getAttribute( |
| RegistryServlet.REGISTRY)); |
| this.activity = (Activity) |
| servlet.getServletContext().getAttribute( |
| RegistryServlet.ACTIVITY); |
| } |
| } |
| |
| |
| /** |
| * Retrieve or initialize context from session, using ActionMapping |
| * parameter as key. Returns action.missing.parameters if parameter |
| * missing or not found. Executes the next step of the actitivity. |
| * |
| * @param mapping The ActionMapping used to select this instance |
| * @param form The optional ActionForm bean for this request (if any) |
| * @param request The HTTP request we are processing |
| * @param response The HTTP response we are creating |
| * |
| * @exception IOException if an input/output error occurs |
| * @exception ServletException if a servlet exception occurs |
| */ |
| public ActionForward execute(ActionMapping mapping, |
| ActionForm form, |
| HttpServletRequest request, |
| HttpServletResponse response) |
| throws Exception { |
| |
| ActionErrors errors = new ActionErrors(); |
| |
| WebContext context = getContext(mapping,request, |
| response); |
| |
| Activity activity = getActivity(mapping); |
| |
| validateInit(errors,context,activity); |
| |
| if (errors.isEmpty()) { |
| |
| executeContext(context,activity, |
| mapping,form,request,response); |
| |
| } |
| |
| validateContext(errors,context); |
| |
| // return (nextForward(mapping,errors,request,context)); |
| return null; |
| |
| } // end ActionForward |
| |
| |
| // ------------------------------------------------ ContextListener Methods |
| |
| |
| /** |
| * Invoked immediately after execution of the related Activity has |
| * been completed normally, been suspended, or been aborted by |
| * the throwing of a StepException. The Step included in this event |
| * will be the last one to be executed. |
| * |
| * @param event The <code>ContextEvent</code> that has occurred |
| */ |
| public void afterActivity(ContextEvent event) { |
| |
| WebContext context = (WebContext) event.getContext(); |
| HttpSession session = context.getHttpSession(); |
| StringBuffer sb = new StringBuffer("{"); |
| sb.append(session.getId()); |
| sb.append("} afterActivity"); |
| servlet.log(sb.toString()); |
| |
| } |
| |
| |
| /** |
| * Invoked immediately after the specified Step was executed. |
| * |
| * @param event The <code>ContextEvent</code> that has occurred |
| */ |
| public void afterStep(ContextEvent event) { |
| |
| WebContext context = (WebContext) event.getContext(); |
| HttpSession session = context.getHttpSession(); |
| StringBuffer sb = new StringBuffer("{"); |
| sb.append(session.getId()); |
| sb.append("} afterStep "); |
| sb.append(event.getStep()); |
| if (context.getSuspend()) |
| sb.append(" (Suspended)"); |
| if (context.getNextStep() == null) |
| sb.append(" (Finished)"); |
| servlet.log(sb.toString()); |
| if (event.getException() != null) |
| servlet.log("-->Step threw exception", event.getException()); |
| |
| } |
| |
| |
| /** |
| * Invoked immediately before execution of the related Activity has |
| * started. The Step included in this event will be the first one |
| * to be executed. |
| * |
| * @param event The <code>ContextEvent</code> that has occurred |
| */ |
| public void beforeActivity(ContextEvent event) { |
| |
| WebContext context = (WebContext) event.getContext(); |
| HttpSession session = context.getHttpSession(); |
| StringBuffer sb = new StringBuffer("{"); |
| sb.append(session.getId()); |
| sb.append("} beforeActivity"); |
| servlet.log(sb.toString()); |
| |
| } |
| |
| |
| /** |
| * Invoked immediately before the specified Step is executed. |
| * |
| * @param event The <code>ContextEvent</code> that has occurred |
| */ |
| public void beforeStep(ContextEvent event) { |
| |
| WebContext context = (WebContext) event.getContext(); |
| HttpSession session = context.getHttpSession(); |
| StringBuffer sb = new StringBuffer("{"); |
| sb.append(session.getId()); |
| sb.append("} beforeStep "); |
| sb.append(event.getStep()); |
| servlet.log(sb.toString()); |
| |
| } |
| |
| |
| } // end Activity |
