/*
* $Header: /home/cvs/jakarta-struts/contrib/workflow/ActivityAction.java,v 1.3 2004/03/14 07:15:07 sraeburn Exp $
* $Revision: 1.3 $
* $Date: 2004/03/14 07:15:07 $
*
* 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 $Revision: 1.3 $ $Date: 2004/03/14 07:15:07 $
*/
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