编写自己的 secret Santa Web 应用程序，第 2 部分: 控制器

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class BasicServlet
    extends HttpServlet {
  protected void
  doGet
  (HttpServletRequest request, HttpServletResponse response)
  throws ServletException, IOException {
    [...]
  }
}

<action
   path="/login"
   type="org.example.LoginAction">
  <forward 
     name="success" 
     path="/account.action"
     redirect="true" />
  <forward 
     name="failure" 
     path="/WEB-INF/jsp/login-failure.jsp" />
</action>

<form name="loginForm">
  <field name="email"
         depends="required,email">
    <arg0 key="email.displayname">
  </field>
  <field name="password"
         depends="required">
    <arg0 key="password.displayname">
  </field>
</form>

package org.merlin.santa.servlets;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.activation.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.naming.*;
import javax.servlet.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;

  public class SantaMailer {
  private String
  _url;
  
  private HttpServletRequest
  _request;
  private HttpServletResponse
  _response;
  
  private SantaServlet
  _servlet;
  private Session
  _session;
  
  public SantaMailer
  (String email,
   ActionMapping mapping,
   HttpServletRequest request, 
   HttpServletResponse response,
   SantaServlet servlet)
  throws IOException, NamingException, ServletException {
    ActionForward forward = mapping.findForward (email);
    if (forward == null)
      throw new ServletException ("Unknown e-mail name: " + email);
    _url = forward.getPath ();
    _request = request;
    _response = response;
    _servlet = servlet;
    request.setAttribute ("org.merlin.santa.baseURL", _servlet.getBaseURL ());
    InitialContext initialContext = new InitialContext ();
    try {
      _session = (Session) initialContext.lookup ("java:/Mail");
    } finally {
      initialContext.close ();
    }
  }

<action    
   path="/register"
   type="org.merlin.santa.actions.family.RegisterAction"
   [...]
  <forward 
     name="success" 
     path="/WEB-INF/jsp/family/registered.jsp" />
  <forward 
     name="register-email" 
     path="/WEB-INF/jsp/email/register.jsp" />
</action>

  private StringBuffer
  invoke
  (String url)
  throws IOException, ServletException {
    ServletContext servletContext = _servlet.getServletContext ();
    RequestDispatcher requestDispatcher =
      servletContext.getRequestDispatcher (url);
    SantaServletResponseWrapper responseWrapper =
      new SantaServletResponseWrapper (_response);
    requestDispatcher.include (_request, responseWrapper);
    return responseWrapper.getStringBuffer ();
  }

package org.merlin.santa.servlets;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SantaServletResponseWrapper
    extends HttpServletResponseWrapper {
  private StringWriter
  _stringWriter;
  
  private PrintWriter
  _printWriter;
  
  public SantaServletResponseWrapper
  (HttpServletResponse servletResponse) {
    super (servletResponse);
    _stringWriter = new StringWriter ();
    _printWriter = new PrintWriter (_stringWriter);
  }
  public ServletOutputStream
  getOutputStream
  ()
  throws IOException {
    throw new IOException ("getOutputStream() unsupported");
  }
  
  public PrintWriter
  getWriter
  () {
    return _printWriter;
  }
  
  public StringBuffer
  getStringBuffer
  () {
    return _stringWriter.getBuffer ();
  }
}  

  private String
  tidyText
  (StringBuffer buffer)
  throws ServletException {
    String subject = null;      
    int index = 0, length = buffer.length (), old;
    char[] chars = new char[length];
    buffer.getChars (0, length, chars, 0);
    buffer.setLength (0);
    for (boolean wasBlank = true, isBlank; index < length; 
      wasBlank = isBlank) {
      char c = chars[old = index ++];
      isBlank = Character.isWhitespace (c);
      while ((index < length) && (c != '\n') && (c != '\r'))
        isBlank &= Character.isWhitespace (c = chars[index ++]);
      if (!isBlank && (subject == null)) {
        subject = new String (chars, old, index - old);
      } else if (!isBlank) {
        if (wasBlank && (buffer.length () > 0))
          buffer.append ('\n');
        buffer.append (chars, old, index - old - 1).append ('\n');
      }
      if ((c == '\r') && (index < length) && (chars[index] == '\n'))
        ++ index;
    }
    if ((subject == null) || !subject.startsWith ("Subject:"))
      throw new ServletException 
        ("E-mail contains no subject line: " + subject);
    return subject.substring (8).trim ();
  }

  private List
  tidyHTML
  (StringBuffer buffer)
  throws IOException, ServletException, MessagingException {
    List resources = new ArrayList ();
    String contextPath = _request.getContextPath ();
    String string = buffer.toString ();
    buffer.setLength (0);
    int index = 0, next;
    while ((next = string.indexOf ("src=\"", index) + 5) >= 5) {
      buffer.append (string.substring (index, next));
      String contentID = 
        "Resource." + resources.size () + "@north-pole.int";
      buffer.append ("cid:").append (contentID);
      index = string.indexOf ('"', next);
      if (index < 0)
        index = string.length ();
      final String src = string.substring (next, index);
      if (!src.startsWith (contextPath))
        throw new ServletException ("Image URI is not absolute: " + src);
      URL source = _servlet.getServletContext ().getResource
        (src.substring (contextPath.length ()));
      if (source == null)
        throw new ServletException ("Error attaching image URI: " + src);
      MimeBodyPart resource = new MimeBodyPart ();
      resource.setDataHandler (new DataHandler (source) {
          public String getContentType () {
            return URLConnection.getFileNameMap ().getContentTypeFor (src);
          }
        });
      resource.setHeader ("Content-ID", "<" + contentID + ">");
      resources.add (resource);
    }
    buffer.append (string.substring (index));
    return resources;
  }

  public void
  sendEmail
  (String address, String name)
  throws IOException, MessagingException, ServletException {
    String htmlPath = _url;
    StringBuffer htmlBuffer = invoke (htmlPath);
    List resources = tidyHTML (htmlBuffer);
    String html = htmlBuffer.toString ();
    
    String textPath = _url.substring (0, _url.length () - 4) + "_text.jsp";
    StringBuffer textBuffer = invoke (textPath);
    String subject = tidyText (textBuffer);
    String text = textBuffer.toString ();
    
    MimeBodyPart plainTextPart = new MimeBodyPart ();
    plainTextPart.setContent (text, "text/plain");
    MimeBodyPart htmlTextPart = new MimeBodyPart ();
    htmlTextPart.setContent (html, "text/html");
    MimeMultipart alternative = new MimeMultipart ("alternative");
    alternative.addBodyPart (plainTextPart);
    alternative.addBodyPart (htmlTextPart);
    MimeBodyPart alternativePart = new MimeBodyPart ();
    alternativePart.setContent (alternative);
    MimeMultipart related = new MimeMultipart ("related");
    related.addBodyPart (alternativePart);
    for (Iterator i = resources.iterator (); i.hasNext ();)
      related.addBodyPart ((MimeBodyPart) i.next ());
    MimeMessage message = new MimeMessage (_session);
    message.setFrom (_servlet.getEmailAddress ());
    message.setRecipients (Message.RecipientType.TO,
      new InternetAddress[] { new InternetAddress (address, name) });
    message.setSubject (subject);
    message.setContent (related);
    Transport.send (message);
  }
}

<VirtualHost www.north-pole.int>
  [...]
  ProxyPass /santa/ http://jws.internal:13666/santa/
  ProxyPassReverse /santa/ http://jws.internal:13666/santa/
  [...]
</VirtualHost>

package org.merlin.santa.tags;
import java.io.*;
import java.net.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
import org.apache.struts.util.*;
public class EmailURLTag
    extends TagSupport {
  private String
  _action;
  public void
  setAction
  (String action) {
    _action = action;
  }
  public String
  getAction
  () {
    return _action;
  }
  
  public int
  doEndTag
  ()
  throws JspException {
    try {
      JspWriter out = pageContext.getOut ();
      HttpServletRequest request = 
        (HttpServletRequest) pageContext.getRequest ();
      URL baseURL = 
        (URL) request.getAttribute ("org.merlin.santa.baseURL");
      if (baseURL == null)
        baseURL = new URL (request.getScheme (), request.getServerName (), 
                           request.getServerPort (), "/");
      URL url = new URL
        (baseURL, RequestUtils.getActionMappingURL (_action, pageContext));
      out.print (url.toExternalForm ());
      return EVAL_PAGE;
    } catch (IOException ex) {
      throw new JspException ("EmailURLTag error", ex);
    }
  }
}

  <tag>
    <name>emailurl</name>
    <tagclass>org.merlin.santa.tags.EmailURLTag</tagclass>
    <bodycontent>empty</bodycontent>
    <attribute>
      <name>action</name>
      <required>true</required>
      <rtexprvalue>true</rtexprvalue>
    </attribute>
  </tag>

<action    
    path="/register"
    type="org.merlin.santa.actions.family.RegisterAction"
    name="familyRegisterForm"
    scope="request"
    validate="true"
    input="/WEB-INF/jsp/family/register.jsp">
  <forward 
      name="success" 
      path="/WEB-INF/jsp/family/registered.jsp" />
  <forward 
      name="email" 
      path="/WEB-INF/jsp/email/register.jsp" />
</action>

package org.merlin.santa.forms.family;
import org.merlin.santa.forms.*;
/**
 * @struts.form
 *   name="familyRegisterForm"
 */
public class RegisterForm
    extends SantaForm {
  private String
  _name;
  /**
   * @struts.validator
   *   type="required"
   * @struts.validator-args
   *   arg0resource="form.family.register.name"
   */
  public void
  setName
  (String name) {
    _name = name;
  }
  public String
  getName
  () {
    return _name;
  }
  private String
  _email;
  
  /**
   * @struts.validator
   *   type="required,email"
   * @struts.validator-args
   *   arg0resource="form.family.register.email"
   */
  public void
  setEmail
  (String email) {
    _email = email;
  }
  public String
  getEmail
  () {
    return _email;
  }
}

<html:form action="/register"
   onsubmit="return validateFamilyRegisterForm(this);">
  Family name: <html:text property="name" /><br />
  Your name: <html:text property="email" /><br />
  <html:submit property="register" />
</html:form>
<html:javascript formName="familyRegisterForm" />

<plug-in
   className="org.apache.struts.validator.ValidatorPlugIn">
  <set-property
     property="pathnames"
     value="/WEB-INF/xml/validator-rules.xml, /WEB-INF/xml/validation.xml" />
</plug-in>

package org.merlin.santa.actions.family;
import javax.ejb.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.merlin.santa.*;
import org.merlin.santa.actions.*;
import org.merlin.santa.forms.family.*;
import org.merlin.santa.interfaces.*;
import org.merlin.santa.servlets.*;
import org.merlin.santa.utils.*;
import org.merlin.santa.values.*;
public class RegisterAction
    extends SantaAction {
  protected ActionForward
  santaAction
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    RegisterForm registerForm = (RegisterForm) form;
    FamilyLocal family = null;
    try {
      FamilyValue value = new FamilyValue ();
      value.setName (registerForm.getName ());
      value.setEmailAddress (registerForm.getEmail ());
      FamilyLocalHome home = FamilyUtil.getLocalHome ();
      try {
        family = home.create (value);
      } catch (DuplicateKeyException ex) {
        throw new SantaException
          (SantaMessages.ERROR_FAMILY_DUPLICATE, registerForm.getName ());
      }
      request.setAttribute ("familyValue", getFamilyValue (family));
      SantaMailer mailer = getMailer ("email", mapping, request, response);
      mailer.sendEmail (registerForm.getEmail (), registerForm.getName ());
      HttpSession session = request.getSession ();
      session.setAttribute ("familyName", value.getName ());
      return mapping.findForward ("success");
    } catch (Exception ex) {
      if (family != null)
        family.remove ();
      throw ex;
    }
  }
}

/**
 * @struts.action
 *   path="/register"
 *   name="familyRegisterForm"
 *   scope="request"
 *   validate="true"
 *   input="/WEB-INF/jsp/family/register.jsp"
 * @struts.action-forward
 *   name="success"
 *   path="/WEB-INF/jsp/family/registered.jsp"
 * @struts.action-forward
 *   name="email"
 *   path="/WEB-INF/jsp/email/register.jsp"
 */

<message-resources
   parameter="org.merlin.santa.SantaResources"
   null="false" />

# error messages
error.global-exception=An unexpected exception was caught.
error.family.duplicate=The family name {0} is already in use.
# form field names
form.family.register.name=Your family name
form.family.register.email=Your e-mail address
# validation errors from validator-rules.xml
errors.required={0} is required.
errors.email={0} must be a valid address.

package org.merlin.santa;
public interface SantaMessages {
  /** Duplicate family name. {0} is the family name. */
  public static final String ERROR_FAMILY_DUPLICATE = 
    "error.family.duplicate";
  /** Unknown family name. {0} is the family name. */
  public static final String ERROR_FAMILY_UNKNOWN = 
    "error.family.unknown";
  /** Incorrect family password. {0} is the family name. */
  public static final String ERROR_FAMILY_PASSWORD = 
    "error.family.password";
  /** Duplicate family member name. {0} is the member name. */
  public static final String ERROR_MEMBER_DUPLICATE = 
    "error.member.duplicate";
  /** Unknown family member name. {0} is the member name. */
  public static final String ERROR_MEMBER_UNKNOWN = 
    "error.member.unknown";
  [...]
}

<action    
   path="/register"
   type="org.merlin.santa.actions.family.RegisterAction"
   name="familyRegisterForm"
   scope="request"
   validate="true"
   input="/WEB-INF/jsp/family/register.jsp">
  <exception
     key="error.family.duplicate"
     type="javax.ejb.DuplicateKeyException" />
  <forward 
     name="success" 
     path="/WEB-INF/jsp/family/registered.jsp" />
  <forward 
     name="email" 
     path="/WEB-INF/jsp/email/register.jsp" />
</action>

package org.merlin.santa;
public class SantaException
    extends Exception {
  private Object[]
  _values;
  
  public SantaException
  (String key, Object[] values) {
    super (key);
    _values = (Object[]) values.clone ();
  }
  
  public SantaException
  (String key, Object value0, Object value1) {
    this (key, new Object[] { value0, value1 });
  }
  
  public SantaException
  (String key, Object value) {
    this (key, new Object[] { value });
  }
  
  public SantaException
  (String key) {
    this (key, new Object[0]);
  }
  public Object[]
  getValues
  () {
    return (Object[]) _values.clone ();
  }
}

<global-exceptions>
  <exception
     key="unused"
     type="org.merlin.santa.SantaException"
     handler="org.merlin.santa.actions.SantaExceptionHandler" />
  <exception
     key="error.global-exception"
     type="java.lang.Exception"
     handler="org.merlin.santa.actions.GlobalExceptionHandler" />
</global-exceptions>

package org.merlin.santa.actions;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.apache.struts.config.*;
import org.merlin.santa.*;
public class SantaExceptionHandler
    extends ExceptionHandler {
  public ActionForward
  execute
  (Exception exception,
   ExceptionConfig config,
   ActionMapping mapping,
   ActionForm form, 
   HttpServletRequest request,
   HttpServletResponse response) {
    SantaException santaException = (SantaException) exception;
    ActionError error = new ActionError
      (santaException.getMessage (), santaException.getValues ());
    ActionForward forward = mapping.getInputForward ();
    String property = ActionMessages.GLOBAL_MESSAGE;
    String scope = config.getScope ();
    storeException (request, property, error, forward, scope);
    return forward;
  }
}

package org.merlin.santa.actions;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.apache.struts.config.*;
import org.merlin.santa.*;
public class GlobalExceptionHandler
    extends ExceptionHandler {
  public ActionForward
  execute
  (Exception exception,
   ExceptionConfig config,
   ActionMapping mapping,
   ActionForm form, 
   HttpServletRequest request,
   HttpServletResponse response) {
    ActionError error = 
      new ActionError (config.getKey (), exception.getMessage ());
    ActionForward forward = mapping.getInputForward ();
    String property = ActionMessages.GLOBAL_MESSAGE;
    String scope = config.getScope ();
    storeException (request, property, error, forward, scope);
    exception.printStackTrace (System.err); // should log
    request.setAttribute ("exception", exception);
    return forward;
  }
}

package org.merlin.santa.forms;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.apache.struts.validator.*;
import org.merlin.santa.actions.*;
public abstract class SantaForm
    extends ValidatorForm {
  public ActionErrors
  validate
  (ActionMapping mapping, HttpServletRequest request) {
    return SantaAction.isSubmission (request) ? 
      super.validate (mapping, request) : null;
  }
}

package org.merlin.santa.actions;
import java.io.*;
import javax.ejb.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.naming.*;
import org.apache.struts.action.*;
import org.merlin.santa.interfaces.*;
import org.merlin.santa.utils.*;
import org.merlin.santa.values.*;
import org.merlin.santa.servlets.*;
public abstract class SantaAction
    extends Action {
  public ActionForward
  execute
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    if ((form != null) && !isSubmission (request)) {
      return santaDisplay (mapping, form, request, response);
    } else {
      return santaAction (mapping, form, request, response);
    }
  }
  protected ActionForward
  santaDisplay
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    return mapping.getInputForward ();
  }
  protected abstract ActionForward
  santaAction
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception;
  protected FamilyValue
  getFamilyValue
  (FamilyLocal family)
  throws NamingException, CreateException {
    ValueFactoryLocalHome home = ValueFactoryUtil.getLocalHome ();
    ValueFactoryLocal factory = home.create ();
    return factory.getFamilyValue (family);
  }
  
  [...]
  protected SantaMailer
  getMailer
  (String email, ActionMapping mapping,
   HttpServletRequest request, HttpServletResponse response)
  throws IOException, NamingException, ServletException {
    return new SantaMailer 
      (email, mapping, request, response, (SantaServlet) getServlet ());
  }
  [...]
  protected void
  saveMessage
  (HttpServletRequest request, String key, Object[] values) {
    ActionMessages messages = new ActionMessages ();
    ActionMessage message = new ActionMessage (key, values);
    messages.add (ActionMessages.GLOBAL_MESSAGE, message);
    saveMessages (request, messages);
  }
  public static boolean
  isSubmission
  (HttpServletRequest request) {
    return !request.getParameterMap ().isEmpty ();
  }
}

package org.merlin.santa.servlets;
import java.net.*;
import javax.mail.internet.*;
import javax.servlet.*;
import org.apache.struts.action.*;
public class SantaServlet
    extends ActionServlet {
  private URL
  _baseURL;
  
  private InternetAddress
  _emailAddress;
  
  public void
  init
  ()
  throws ServletException {
    super.init ();
    ServletConfig servletConfig = getServletConfig ();
    String baseURL = servletConfig.getInitParameter
      ("org.merlin.santa.baseURL");
    if (baseURL != null) {
      try {
        _baseURL = new URL (baseURL);
      } catch (Exception ex) {
        throw new UnavailableException ("Invalid base URL: " + baseURL);
      }
    }
    String emailAddress = servletConfig.getInitParameter
      ("org.merlin.santa.emailAddress");
    if (emailAddress == null)
      throw new UnavailableException ("Missing e-mail address");
    String emailName = servletConfig.getInitParameter
      ("org.merlin.santa.emailName");
    if (emailName == null)
      throw new UnavailableException ("Missing e-mail name");
    try {
     _emailAddress = new InternetAddress (emailAddress, emailName);
    } catch (Exception ex) {
      throw new UnavailableException 
        ("Invalid e-mail address: " + emailAddress);
    }
  }
  public URL
  getBaseURL
  () {
    return _baseURL;
  }
  public InternetAddress
  getEmailAddress
  () {
    return _emailAddress;
  }
}

<servlet>
  <servlet-name>Santa</servlet-name>
  <servlet-class>org.merlin.santa.servlets.SantaServlet</servlet-class>
  <init-param>
    <param-name>config</param-name>
    <param-value>/WEB-INF/xml/struts-config.xml</param-value>
  </init-param>
  <init-param>
    <param-name>org.merlin.santa.baseURL</param-name>
    <param-value>http://santa/</param-value>
  </init-param>
  <init-param>
    <param-name>org.merlin.santa.emailAddress</param-name>
    <param-value>santa@north-pole.int</param-value>
  </init-param>
  <init-param>
    <param-name>org.merlin.santa.emailName</param-name>
    <param-value>Psychic Secret Santa</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>Santa</servlet-name>
  <url-pattern>*.santa</url-pattern>
</servlet-mapping>

<ejb-local-ref>
  <ejb-ref-name>ejb/ValueFactoryLocal</ejb-ref-name>
  <ejb-ref-type>Session</ejb-ref-type>
  <local-home>org.merlin.santa.interfaces.ValueFactoryLocalHome</local-home>
  <local>org.merlin.santa.interfaces.ValueFactoryLocal</local>
  <ejb-link>ValueFactory</ejb-link>
</ejb-local-ref>
<ejb-local-ref>
  <ejb-ref-name>ejb/FamilyLocal</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <local-home>org.merlin.santa.interfaces.FamilyLocalHome</local-home>
  <local>org.merlin.santa.interfaces.FamilyLocal</local>
  <ejb-link>Family</ejb-link>
</ejb-local-ref>
<ejb-local-ref>
  <ejb-ref-name>ejb/SantaLocal</ejb-ref-name>
  <ejb-ref-type>Entity</ejb-ref-type>
  <local-home>org.merlin.santa.interfaces.SantaLocalHome</local-home>
  <local>org.merlin.santa.interfaces.SantaLocal</local>
  <ejb-link>Santa</ejb-link>
</ejb-local-ref>

<action
   path="/authenticate"
   type="org.merlin.santa.actions.family.AuthenticateAction"
   name="familyAuthenticateForm"
   scope="request"
   validate="true"
   input="/WEB-INF/jsp/family/authenticate.jsp">
  <forward 
     name="success" 
     path="/describe.santa"
     redirect="true" />
</action>

package org.merlin.santa.forms.family;
import org.apache.struts.action.*;
import org.merlin.santa.forms.*;
/**
 * @struts.form
 *   name="familyAuthenticateForm"
 */
public class AuthenticateForm
    extends SantaForm {
  private String
  _name;
  /**
   * @struts.validator
   *   type="required"
   * @struts.validator-args
   *   arg0resource="form.family.authenticate.name"
   */
  public void
  setName
  (String name) {
    _name = name;
  }
  public String
  getName
  () {
    return _name;
  }
  
  private String
  _password;
  
  /**
   * @struts.validator
   *   type="required"
   * @struts.validator-args
   *   arg0resource="form.family.authenticate.password"
   */
  public void
  setPassword
  (String password) {
    _password = password;
  }
}

package org.merlin.santa.actions.family;
import javax.ejb.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.merlin.santa.*;
import org.merlin.santa.actions.*;
import org.merlin.santa.forms.family.*;
import org.merlin.santa.interfaces.*;
import org.merlin.santa.servlets.*;
import org.merlin.santa.utils.*;
import org.merlin.santa.values.*;
public class AuthenticateAction
    extends SantaAction {
  protected ActionForward
  santaDisplay
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    HttpSession session = request.getSession ();
    String familyName = (String) session.getAttribute ("familyName");
    if (familyName != null) {
      AuthenticateForm authenticateForm = (AuthenticateForm) form;
      authenticateForm.setName (familyName);
    }
    return super.santaDisplay (mapping, form, request, response);
  }
  
  protected ActionForward
  santaAction
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    HttpSession session = request.getSession ();
    session.setAttribute ("family", null);
    AuthenticateForm authenticateForm = (AuthenticateForm) form;
    String familyName = authenticateForm.getName ();
    FamilyLocalHome home = FamilyUtil.getLocalHome ();
    FamilyLocal family;
    try {
      family = home.findByPrimaryKey (familyName);
    } catch (ObjectNotFoundException ex) {
      throw new SantaException 
        (SantaMessages.ERROR_FAMILY_UNKNOWN, familyName);
    }
    String password = authenticateForm.getPassword ();
    if (!password.equals (family.getPassword ())) {
      authenticateForm.setPassword ("");
      throw new SantaException 
        (SantaMessages.ERROR_FAMILY_PASSWORD, familyName);
    }
    session.setAttribute ("family", family);
    return mapping.findForward ("success");
  }
}

package org.merlin.santa.actions.family;
import java.util.*;
import javax.ejb.*;
import javax.servlet.http.*;
import javax.naming.*;
import org.apache.struts.action.*;
import org.merlin.santa.*;
import org.merlin.santa.actions.*;
import org.merlin.santa.interfaces.*;
import org.merlin.santa.utils.*;
import org.merlin.santa.values.*;
import org.merlin.santa.servlets.*;
public abstract class FamilyAction
    extends SantaAction {
  public ActionForward
  execute
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    HttpSession session = request.getSession ();
    FamilyLocal family = (FamilyLocal) session.getAttribute ("family");
    if (family == null) {
      return super.execute (mapping, form, request, response);
    } else {
      ActionForward forward;
      String states = mapping.getParameter ();
      if ((states != null) && !checkState (states, family)) {
        forward = mapping.findForward ("family-state-" + family.getState ());
      } else if ((form != null) && !isSubmission (request)) {
        forward = familyDisplay (family, mapping, form, request, response);
      } else {
        try {
          forward = familyAction (family, mapping, form, request, response);
        } catch (SantaException ex) {
          request.setAttribute ("familyValue", getFamilyValue (family));
          throw ex;
        }
      }
      request.setAttribute ("familyValue", getFamilyValue (family));
      return forward;
    }
  }
  private boolean
  checkState
  (String states, FamilyLocal family)
  throws Exception {
    String state = family.getState ();
    boolean okay = false;
    StringTokenizer tokens = new StringTokenizer (states, "|");
    while (!okay && tokens.hasMoreTokens ())
      okay = state.equals (tokens.nextToken ());
    return okay;
  }  
      
  protected ActionForward
  santaDisplay
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    return santaAction (mapping, form, request, response);
  }
  
  protected ActionForward
  santaAction
  (ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    return mapping.findForward ("family-unauthenticated");
  }
  protected ActionForward
  familyDisplay
  (FamilyLocal family,
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    return super.santaDisplay (mapping, form, request, response);
  }
  
  protected abstract ActionForward
  familyAction
  (FamilyLocal family,
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception;
}

<global-forwards
   type="org.apache.struts.action.ActionForward">
  <forward 
     name="family-unauthenticated" 
     path="/authenticate.santa"
     redirect="true" />
  <forward 
     name="family-state-created" 
     path="/describe.santa"
     redirect="true" />
  <forward 
     name="family-state-activated" 
     path="/status.santa"
     redirect="true" />
  [...]
</global-forwards>

<action
   path="/describe"
   type="org.merlin.santa.actions.family.DescribeAction"
   name="familyDescribeForm"
   scope="request"
   validate="true"
   parameter="created"
   input="/WEB-INF/jsp/family/describe.jsp">
  <forward 
     name="success" 
     path="/member.santa"
     redirect="true" />
</action>

<form-bean
   name="familyDescribeForm"
   type="org.merlin.santa.forms.DynaSantaForm">
  <form-property name="description"
     type="java.lang.String" />
</form-bean>

<formset>
  <form
     name="familyDescribeForm">
    <field
       property="description"
       depends="">
      <arg0
         key="form.family.describe.description" />
    </field>
  </form>
  [...]
</formset>

package org.merlin.santa.actions.family;
import javax.ejb.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.merlin.santa.*;
import org.merlin.santa.actions.*;
import org.merlin.santa.forms.*;
import org.merlin.santa.interfaces.*;
public class DescribeAction
    extends FamilyAction {
  protected ActionForward
  familyDisplay
  (FamilyLocal family,
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    DynaSantaForm dynaForm = (DynaSantaForm) form;
    dynaForm.set ("description", family.getDescription ());
    return super.familyDisplay (family, mapping, form, request, response);
  }
  
  protected ActionForward
  familyAction
  (FamilyLocal family,
   ActionMapping mapping,
   ActionForm form,
   HttpServletRequest request,
   HttpServletResponse response)
  throws Exception {
    DynaSantaForm dynaForm = (DynaSantaForm) form;
    String description = (String) dynaForm.get ("description");
    family.setDescription (description);
    return mapping.findForward ("success");
  }
}

package org.merlin.santa.forms;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.apache.struts.validator.*;
import org.merlin.santa.actions.*;
public class DynaSantaForm
    extends DynaValidatorForm {
  public ActionErrors
  validate
  (ActionMapping mapping, HttpServletRequest request) {
    return SantaAction.isSubmission (request) ? 
      super.validate (mapping, request) : null;
  }
}