dom4jfpdlserializer.java.svn-base

Fire-Workflow-Engine-All-In-One-20090208 包含全部文档

package org.fireflow.model.io;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.fireflow.model.DataField;
import org.fireflow.model.Duration;
import org.fireflow.model.EventListener;
import org.fireflow.model.Task;
import org.fireflow.model.WorkflowProcess;
import org.fireflow.model.net.Activity;
import org.fireflow.model.net.EndNode;
import org.fireflow.model.net.StartNode;
import org.fireflow.model.net.Synchronizer;
import org.fireflow.model.net.Transition;
import org.fireflow.model.reference.Application;
import org.fireflow.model.reference.Form;
import org.fireflow.model.reference.Participant;
import org.fireflow.model.reference.SubWorkflowProcess;

public class Dom4JFPDLSerializer implements IFPDLSerializer {

    public static final String DEFAULT_XPDL_VERSION = "1.0";
    public static final String DEFAULT_VENDOR = "\u975E\u4E5F";

    // private static final Log log =
    // LogFactory.getLog(Dom4JFPDLSerializer.class);
    public void serialize(WorkflowProcess workflowProcess, OutputStream out)
            throws IOException, FPDLSerializerException {

        serialize(workflowProcess, new OutputStreamWriter(out));
    }

    public void serialize(WorkflowProcess workflowProcess, Writer out)
            throws IOException, FPDLSerializerException {
        // create the Document object
        Document document = workflowProcessToDom(workflowProcess);

        // write the document to the output stream
        OutputFormat format = new OutputFormat("    ", true);
        format.setEncoding("utf-8");
        XMLWriter writer = new XMLWriter(out, format);
        writer.write(document);
        out.flush();
    }

    public Document workflowProcessToDom(WorkflowProcess workflowProcess)
            throws FPDLSerializerException {
        DocumentFactory df = new DocumentFactory();

        // serialize the Package
        Element workflowProcessElement = df.createElement(new QName(
                WORKFLOW_PROCESS, FPDL_NS));
        workflowProcessElement.addNamespace(FPDL_NS_PREFIX, FPDL_URI);
//        workflowProcessElement.addNamespace(XSD_NS_PREFIX, XSD_URI);
//        workflowProcessElement.addNamespace(XSI_NS_PREFIX, XSI_URI);
        workflowProcessElement.addAttribute(ID, workflowProcess.getId());
        workflowProcessElement.addAttribute(NAME, workflowProcess.getName());
        workflowProcessElement.addAttribute(DISPLAY_NAME, workflowProcess.getDisplayName());
        workflowProcessElement.addAttribute(RESOURCE_FILE, workflowProcess.getResourceFile());
        workflowProcessElement.addAttribute(RESOURCE_MANAGER, workflowProcess.getResourceManager());

        Util4Serializer.addElement(workflowProcessElement, DESCRIPTION,
                workflowProcess.getDescription());

        writeDataFields(workflowProcess.getDataFields(), workflowProcessElement);
        writeStartNode(workflowProcess.getStartNode(), workflowProcessElement);
        writeActivities(workflowProcess.getActivities(), workflowProcessElement);
        writeSynchronizers(workflowProcess.getSynchronizers(),
                workflowProcessElement);
        writeEndNodes(workflowProcess.getEndNodes(), workflowProcessElement);
        writeTransitions(workflowProcess.getTransitions(),
                workflowProcessElement);

        writeEventListeners(workflowProcess.getEventListeners(),workflowProcessElement);
        
        writeExtendedAttributes(workflowProcess.getExtendedAttributes(),
                workflowProcessElement);

        Document document = df.createDocument(workflowProcessElement);
        document.addDocType(FPDL_NS_PREFIX+":"+WORKFLOW_PROCESS, PUBLIC_ID, SYSTEM_ID);
        return document;

    }

    public String workflowProcessToXMLString(WorkflowProcess workflowProcess)
            throws IOException, FPDLSerializerException {
        Document dom = workflowProcessToDom(workflowProcess);
        OutputFormat format = new OutputFormat("    ", true);
        format.setEncoding("utf-8");
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        XMLWriter writer = new XMLWriter(out, format);

        writer.write(dom);
        return out.toString();

    }

    protected void writeEventListeners(List eventListeners,Element parentElement){
        if (eventListeners == null || eventListeners.size() == 0) {
            return ;
        }

        Element eventListenersElm =
                Util4Serializer.addElement(parentElement,
                EVENT_LISTENERS);
        for (int i=0;i<eventListeners.size();i++) {
            EventListener listener = (EventListener)eventListeners.get(i);
            Element eventListenerElm = Util4Serializer.addElement(
                    eventListenersElm, EVENT_LISTENER);
            eventListenerElm.addAttribute(CLASS_NAME, listener.getClassName());
        }        
    }
    
    protected void writeDataFields(List dataFields, Element parent)
            throws FPDLSerializerException {

        if (dataFields == null || dataFields.size() == 0) {
            return;
        }

        Element dataFieldsElement = Util4Serializer.addElement(parent,
                DATA_FIELDS);
        Iterator iter = dataFields.iterator();
        while (iter.hasNext()) {
            DataField dataField = (DataField) iter.next();
            Element dataFieldElement = Util4Serializer.addElement(
                    dataFieldsElement, DATA_FIELD);

            dataFieldElement.addAttribute(ID, dataField.getId());
            dataFieldElement.addAttribute(NAME, dataField.getName());
            dataFieldElement.addAttribute(DISPLAY_NAME, dataField.getDisplayName());
            dataFieldElement.addAttribute(DATA_TYPE, dataField.getDataType());

            dataFieldElement.addAttribute(INITIAL_VALUE,
                    dataField.getInitialValue());

            Util4Serializer.addElement(dataFieldElement, DESCRIPTION, dataField.getDescription());

            writeExtendedAttributes(dataField.getExtendedAttributes(),
                    dataFieldElement);
        }
    }

    protected void writeEndNodes(List endNodes, Element parent) {
        Element endNodesElement = Util4Serializer.addElement(parent, END_NODES);
        Iterator iter = endNodes.iterator();

        while (iter.hasNext()) {
            writeEndNode((EndNode) iter.next(), endNodesElement);
        }
    }

    protected void writeEndNode(EndNode endNode, Element parent) {
        Element endNodeElement = Util4Serializer.addElement(parent, END_NODE);
        endNodeElement.addAttribute(ID, endNode.getId());
        endNodeElement.addAttribute(NAME, endNode.getName());
        endNodeElement.addAttribute(DISPLAY_NAME, endNode.getDisplayName());

        Util4Serializer.addElement(endNodeElement, DESCRIPTION, endNode.getDescription());

        writeExtendedAttributes(endNode.getExtendedAttributes(), endNodeElement);

    }

    protected void writeStartNode(StartNode startNode, Element parent)
            throws FPDLSerializerException {
        if (startNode == null) {
            return;
        }
        Element startElement = Util4Serializer.addElement(parent, START_NODE);
        startElement.addAttribute(ID, startNode.getId());
        startElement.addAttribute(NAME, startNode.getName());

        startElement.addAttribute(DISPLAY_NAME, startNode.getDisplayName());

        Util4Serializer.addElement(startElement, DESCRIPTION, startNode.getDescription());

        writeExtendedAttributes(startNode.getExtendedAttributes(), startElement);
    }

    protected void writeSynchronizers(List synchronizers, Element parent)
            throws FPDLSerializerException {
        if (synchronizers == null || synchronizers.size() == 0) {
            return;
        }
        Element synchronizersElement = Util4Serializer.addElement(parent,
                SYNCHRONIZERS);

        Iterator iter = synchronizers.iterator();

        while (iter.hasNext()) {
            writeSynchronizer((Synchronizer) iter.next(), synchronizersElement);
        }
    }

    protected void writeSynchronizer(Synchronizer synchronizer, Element parent)
            throws FPDLSerializerException {
        Element synchronizerElement = Util4Serializer.addElement(parent,
                SYNCHRONIZER);
        synchronizerElement.addAttribute(ID, synchronizer.getId());
        synchronizerElement.addAttribute(NAME, synchronizer.getName());
        synchronizerElement.addAttribute(DISPLAY_NAME, synchronizer.getDisplayName());

        Util4Serializer.addElement(synchronizerElement, DESCRIPTION,
                synchronizer.getDescription());