form.java

一个java工作流引擎

package org.jbpm.web.formgen;

import java.lang.reflect.*;
import java.text.*;
import java.util.*;
import org.apache.commons.logging.*;
import org.dom4j.*;
import org.jbpm.*;
import org.jbpm.model.definition.Definition;
import org.jbpm.model.execution.*;
import org.jbpm.util.xml.*;
import org.jbpm.web.formgen.format.DefaultFormat;

public class Form {

  /**
   * double nested map : definitionId's --> stateName's --> Form's
   */
  private static Map allForms = new HashMap();

  private Long definitionId = null;
  private List formElements = null;
  private String stateName = null;
  private String taskName = null;
  private String strutsAction = null;
  private Map variableFormats = null;
  private Map submitButtons = null;
	private String formGeneratorClassName = null;

  public static void initialiseForms(
    Definition definition,
    ExecutionService executionService)
    throws DocumentException {
    if (!allForms.containsKey(definition.getId())) {

      Map stateNameToForms = new HashMap();

      byte[] bytes = executionService.getFile(definition.getId(), "forms.xml");
      Iterator iter =
        Dom4jHelper.getRootElement(bytes).elements("form").iterator();
      while (iter.hasNext()) {
        Element formElement = (Element) iter.next();
        Form formConfiguration =
          new Form(definition.getId(), formElement, executionService);
        stateNameToForms.put(
          formConfiguration.getStateName(),
          formConfiguration);
      }

      allForms.put(definition.getId(), stateNameToForms);
    }
  }
  
  // Constructor for test purposes
  Form() {
  }

  public Form(
    Long definitionId,
    Element formElement,
    ExecutionService executionService) {
    this.definitionId = definitionId;

    String formFileName = Dom4jHelper.getElementText(formElement, "file", null);
    byte[] bytes = executionService.getFile(definitionId, formFileName);
    this.formElements = FormParser.parseForm(new String(bytes));

    this.stateName = Dom4jHelper.getElementText(formElement, "state-name", null);
    this.taskName = Dom4jHelper.getElementText(formElement, "task-name", null);
    this.strutsAction = Dom4jHelper.getElementText(formElement, "struts-action", "taskformprepare.do");
    this.formGeneratorClassName = Dom4jHelper.getElementText(formElement, "generator", null);
    
    initializeVariableFormats(formElement);

    initializeSubmitButtons(formElement);
  }

  private void initializeSubmitButtons(Element formElement) {
    this.submitButtons = new HashMap();
    Iterator iter = formElement.elements("submitbutton").iterator();
    while (iter.hasNext()) {
      Element submitButtonElement = (Element) iter.next();

      String value =
        Dom4jHelper.getAttribute(submitButtonElement, "value", null);
      String transitionName =
        Dom4jHelper.getAttribute(submitButtonElement, "transition-name", null);
       this.submitButtons.put(value, transitionName);
    }
  }

  private void initializeVariableFormats(Element formElement) {
    this.variableFormats = new HashMap();
    Iterator iter = formElement.elements("variable").iterator();
    while (iter.hasNext()) {
      Element variableElement = (Element) iter.next();

      String variableName =
        Dom4jHelper.getAttribute(variableElement, "name", null);
      String formatClassName =
        Dom4jHelper.getAttribute(variableElement, "format", null);
      Format variableFormat = new DefaultFormat();
      if (formatClassName != null) {
        try {
          variableFormat =
            (Format) Form
              .class
              .getClassLoader()
              .loadClass(formatClassName)
              .newInstance();
        } catch (Exception e) {
          log.error(
            "couldn't instante variable formatter '" + formatClassName + "'",
            e);
        }
      }
      this.variableFormats.put(variableName, variableFormat);
    }
  }

  public static Form getForm(Long definitionId, String stateName) {
    Form formConfiguration = null;
    if (definitionId == null)
      throw new NullPointerException("definitionId is null in Form.getForm");
    if (stateName == null)
      throw new NullPointerException("stateName is null in Form.getForm");

    Map stateNameToForms = (Map) allForms.get(definitionId);
    if (stateNameToForms == null)
      throw new IllegalArgumentException(
        "forms for definition '" + definitionId + "' were not yet initialised");
    formConfiguration = (Form) stateNameToForms.get(stateName);
    if (stateNameToForms == null)
      throw new IllegalArgumentException(
        "no form was specified for state '"
          + stateName
          + "' in definition '"
          + definitionId
          + "'");

    return formConfiguration;
  }

  public static String getLink(Token token) {
    Long definitionId = token.getProcessInstance().getDefinition().getId();
    String stateName = token.getState().getName();

    Map parameters = new HashMap();
    parameters.put("tokenId", token.getId());

    Form form = getForm(definitionId, stateName);
    return form.getLink(parameters);
  }

  public static String getLink(Definition definition) {
    Long definitionId = definition.getId();
    String stateName = definition.getStartState().getName();

    Map parameters = new HashMap();
    parameters.put("definitionId", definition.getId());

    Form form = getForm(definitionId, stateName);
    return form.getLink(parameters);
  }

  public String getLink(Map parameters) {
    StringBuffer buffer = new StringBuffer();

    buffer.append("<a href=\"");
    buffer.append(strutsAction);

    if ((parameters != null) && (parameters.size() > 0)) {
      buffer.append("?");
      Iterator iter = parameters.entrySet().iterator();
      while (iter.hasNext()) {
        // TODO convert the keys and values using url-encoding
        Map.Entry entry = (Map.Entry) iter.next();
        buffer.append(entry.getKey());
        buffer.append("=");
        buffer.append(entry.getValue());
        if (iter.hasNext()) {
          buffer.append("&");
        }
      }
    }

    buffer.append("\">");
    buffer.append(taskName);
    buffer.append("</a>");

    return buffer.toString();
  }
  
  public FormGenerator getGenerator() {
    FormGenerator formGenerator = null;
    if ( formGeneratorClassName != null ) {
      try {
				Class generatorClass = Form.class.getClassLoader().loadClass( formGeneratorClassName );
				Constructor constructor = generatorClass.getConstructor( new Class[]{ Form.class } );
				formGenerator = (FormGenerator) constructor.newInstance( new Object[]{ this } );
			} catch (Exception e) {
				log.error( "couldn't instantiate form generator '" + formGeneratorClassName +"'", e );
			}
    } else {
      formGenerator = new FormGenerator( this ); 
    }
    return formGenerator;
  }
  
  public Map getVariableFormats() {
    return variableFormats;
  }
  
  public Map getSubmitButtons() {
    return submitButtons;
  }

  public List getFormElements() {
    return formElements;
  }

  public String getTransitionName(String submitButtonValue) {
    return (String) submitButtons.get(submitButtonValue);
  }

  public String getStateName() {
    return stateName;
  }
  
  public String getTaskName() {
    return taskName;
  }

  private static Log log = LogFactory.getLog(Form.class);
}