instancemanager.java

一个工作流的原型

/*
 * InstanceManager.java
 *
 * Created on 2004年12月29日, 下午11:40
 */

package workflow.xwfbox.instance;

import java.util.Date;
import java.util.Calendar;
import java.util.Vector;
import java.util.Iterator;

import workflow.xwfbox.engine.InstanceBinding;
import workflow.xwfbox.process.Activity;
/**
 *
 * @author  Administrator
 */
public class InstanceManager {

    String InstanceMapping = "file:///D:/xwfbox-v3/Source/xml/mapping/mapping.xml";

    Instance _instance;
    String _loc;
    
    /** Creates a new instance of InstanceManager */
    public InstanceManager(String loc) {
        _loc = loc;
        _instance = (Instance)InstanceBinding.getXMLInfo(loc, InstanceMapping);
    }
    
    public Instance getInstance() {
        return _instance;
    }
    
    public void update() {
        InstanceBinding.putXMLInfo(_instance, _loc, InstanceMapping);
    }
    
    public void setInstanceInfo(String processId, String processName, Date started, Date completed, String orgId, String initiator,String state) {
        if (processId != null) {  _instance.getInstanceInfo().setProcessId(processId); }
        if (processName != null) { _instance.getInstanceInfo().setProcessName(processName); }
        if (started != null) { _instance.getInstanceInfo().setStarted(started); }
        if (completed != null) { _instance.getInstanceInfo().setCompleted(completed); }
        if (orgId != null) { _instance.getInstanceInfo().setOrgId(orgId); }
        if (initiator != null) { _instance.getInstanceInfo().setInitiator(initiator); }
        if (state != null) { _instance.getInstanceInfo().setState(state); }
    }
    
    public void buildStartTask() {
        Task task = new Task();
        task.setId("START%" + _instance.getId());
        task.setName("Start");
        task.setStarted(_instance.getInstanceInfo().getStarted());
        task.setAssignee(_instance.getInstanceInfo().getInitiator());
        task.setStatus("INIT");
        Tasks tasks = new Tasks();
        tasks.addTask(task);
        _instance.setTasks(tasks);
     }
    
    public void buildStartEndNode() {
        Vector exts = _instance.getExtendedAttributes().getExtendedAttributes();
        Iterator it = exts.iterator();
        int i = 0;
        while (it.hasNext()) {
            ExtendedAttribute ext = (ExtendedAttribute)it.next();
            if (ext.getName().compareTo("StartOfWorkflow") == 0) {
                String ps = ext.getValue();
                int b = ps.indexOf(";");
                String role = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String aId = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String sx = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String sy = ps.substring(0,b);
                InstanceGraphics instGraph = _instance.getInstanceGraphics();
                TaskNode tn = new TaskNode();
                tn.setId("START%" + _instance.getId());
                tn.setActivityId("ProcessStart");
                tn.setName("Start");
                Position pt = new Position();
                pt.setXOffset(Float.parseFloat(sx));
                pt.setYOffset(Float.parseFloat(sy));
                tn.setPosition(pt);
                TaskType tt = new TaskType();
                tt.setValue("START");
                tn.setTaskType(tt);
                tn.setToken("1");
                instGraph.addTaskNode(tn);
                Transition tran = new Transition();
                tran.setId("StartTransition");
                tran.setFrom("ProcessStart");
                tran.setTo(aId);
                instGraph.addTransition(tran);
            } else if (ext.getName().compareTo("EndOfWorkflow") == 0) {
                String ps = ext.getValue();
                int b = ps.indexOf(";");
                String role = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String aId = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String sx = ps.substring(0,b);
                ps = ps.substring(b+1);
                b = ps.indexOf(";");
                String sy = ps.substring(0,b);
                InstanceGraphics instGraph = _instance.getInstanceGraphics();
                TaskNode tn = new TaskNode();
                tn.setId("END%" + _instance.getId() + i);
                tn.setActivityId("ProcessEnd"+i);
                tn.setName("End");
                Position pt = new Position();
                pt.setXOffset(Float.parseFloat(sx));
                pt.setYOffset(Float.parseFloat(sy));
                tn.setPosition(pt);
                TaskType tt = new TaskType();
                tt.setValue("END");
                tn.setTaskType(tt);
                tn.setToken("0");
                instGraph.addTaskNode(tn);
                Transition tran = new Transition();
                tran.setId("EndTransition"+i);
                tran.setFrom(aId);
                tran.setTo("ProcessEnd"+i);
                instGraph.addTransition(tran);
                i++;
            }
        }
    }
    
    public Task getTaskById(String taskId) {
        Vector tasks = _instance.getTasks().getTasks();
        Iterator it = tasks.iterator();
        while (it.hasNext()) {
            Task task = (Task)it.next();
            if (task.getId().equals(taskId)) {
                return task;
            }
        }
        return null;
    }
    
    public TaskNode getTaskNodeById(String taskId) {
        Vector taskNodes = _instance.getInstanceGraphics().getTaskNodes();
        Iterator it = taskNodes.iterator();
        while (it.hasNext()) {
            TaskNode tn = (TaskNode)it.next();
            if (tn.getId().equals(taskId)) {
                return tn;
            }
        }
        return null;
    }

    public TaskNode getTaskNodeByActivityId(String activityId) {
        Vector taskNodes = _instance.getInstanceGraphics().getTaskNodes();
        Iterator it = taskNodes.iterator();
        while (it.hasNext()) {
            TaskNode tn = (TaskNode)it.next();
            if (tn.getActivityId().equals(activityId)) {
                return tn;
            }
        }
        return null;
    }
    
    public Vector getOutgoingActivityIds(String activityId) {
        Vector outTrans = new Vector();
        Vector transitions = _instance.getInstanceGraphics().getTransitions();
        Iterator it = transitions.iterator();
        while (it.hasNext()) {
            Transition tran = (Transition)it.next();
            if (tran.getFrom().equals(activityId)) {
                outTrans.addElement(tran.getTo());
            }
        }
        return outTrans;
    }
    
    public String getTransitionToId(String transitionId) {
        Vector trans = _instance.getInstanceGraphics().getTransitions();
        Iterator it = trans.iterator();
        while (it.hasNext()) {
            Transition tran = (Transition)it.next();
            if (tran.getId().equals(transitionId)) {
                return tran.getTo();
            }
        }
        return null;
    }

    public void buildTask(String taskId, Activity activity) {
        Task task = new Task();
        task.setId(taskId);
        task.setName(activity.getName());
        task.setAssignee((String)activity.getPerformer());
        Calendar rightNow = Calendar.getInstance();
        Date time = rightNow.getTime();
        task.setStarted(time);
        task.setPriority(1);
        task.setPermission("ALL");
//        task.setDeadline(Date deadline);
        task.setStatus("INIT");
        Tasks tasks = _instance.getTasks();
        tasks.addTask(task);
        _instance.setTasks(tasks);
     }

    public Condition getCondition(String transitionId) {
        Vector trans = _instance.getInstanceGraphics().getTransitions();
        Iterator it = trans.iterator();
        while (it.hasNext()) {
            Transition tran = (Transition)it.next();
            if (tran.getId().equals(transitionId)) {
                return tran.getCondition();
            }
        }
        return null;
    }
    
    public String checkCondition(String transitionId) {
        Condition cond = getCondition(transitionId);
        if (cond == null) {
            return "NOCONDITION";
        } else {
            if (cond.getType().equals("CONDITION")) {
                String condition = cond.getCondition();
                Vector parseCond = (new workflow.xwfbox.tools.Expression()).ParseCondition(condition);
                if (parseCond != null) {
                    boolean bl = checkVariable(parseCond);
                    if (bl) return "TRUE"; else return "FALSE";
                }
            } else if (cond.getType().equals("OTHERWISE")) {
                return "OTHERWISE";
            } else if (cond.getType().equals("EXCEPTION")) {
                return "EXCEPTION";
            } else if (cond.getType().equals("DEFAULTEXCEPTION")) {
                return "DEFAULTEXCEPTION";
            }
        }
        return null;
    }
    
    private boolean checkVariable(Vector parseCond) {
        // 下面语句不规范，容易出现异常
        String varId = parseCond.get(0).toString();
        String varValue = parseCond.get(2).toString();
        String oper = parseCond.get(1).toString();
        Variable var = getVariable(varId);
        String value = var.getValue();
        boolean bl = workflow.xwfbox.tools.Expression.computeExpression(value, oper, varValue);
        return bl;
    }
    
    public Variable getVariable(String varId) {
        Vector vars = _instance.getVariables().getVariables();
        Iterator it = vars.iterator();
        while (it.hasNext()) {
            Variable var = (Variable)it.next();
            if (var.getId().equals(varId)) {
                return var;
            }
        }
        return null;
    }
    
    public boolean isFinishedForAllIncomingActivities(TaskNode toTaskNode) {
        String actId = toTaskNode.getActivityId();
        Vector inActId = getAllIncomingActivityIds(actId);
        Iterator it = inActId.iterator();
        while (it.hasNext()) {
            String inAct = (String) it.next();
            TaskNode node = getActivityById(inAct);
            if (!node.getToken().equals("2")) {
                return false;
            }
        }
        return true;
    }
    
    public Vector getAllIncomingActivityIds(String activityId) {
        Vector inTrans = new Vector();
        Vector trans = _instance.getInstanceGraphics().getTransitions();
        Iterator it = trans.iterator();
        while (it.hasNext()) {
            Transition tran = (Transition)it.next();
            if (tran.getTo().equals(activityId)) {
                inTrans.add(tran.getFrom());
            }
        }
        return inTrans;
    }
    
    public TaskNode getActivityById(String activityId) {
        Vector nodes = _instance.getInstanceGraphics().getTaskNodes();
        Iterator it = nodes.iterator();
        while (it.hasNext()) {
            TaskNode node = (TaskNode)it.next();
            if (node.getActivityId().equals(activityId)) {
                return node;
            }
        }
        return null;
    }
}