memoryworkflowstore.java

一个很好实用的工作流OSWORKFLOW开发例子.有着非常优秀的灵活性.

/*
 * Copyright (c) 2002-2003 by OpenSymphony
 * All rights reserved.
 */
package com.opensymphony.workflow.spi.memory;

import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.module.propertyset.PropertySetManager;

import com.opensymphony.util.DataUtil;
import com.opensymphony.util.TextUtils;

import com.opensymphony.workflow.StoreException;
import com.opensymphony.workflow.query.Expression;
import com.opensymphony.workflow.query.FieldExpression;
import com.opensymphony.workflow.query.NestedExpression;
import com.opensymphony.workflow.query.WorkflowExpressionQuery;
import com.opensymphony.workflow.query.WorkflowQuery;
import com.opensymphony.workflow.spi.SimpleStep;
import com.opensymphony.workflow.spi.SimpleWorkflowEntry;
import com.opensymphony.workflow.spi.Step;
import com.opensymphony.workflow.spi.WorkflowEntry;
import com.opensymphony.workflow.spi.WorkflowStore;

import java.security.InvalidParameterException;

import java.util.*;


/**
 * Simple memory implementation.
 *
 * @author <a href="mailto:[e-mail]">Pat Lightbody</a>
 */
public class MemoryWorkflowStore implements WorkflowStore {
    //~ Static fields/initializers /////////////////////////////////////////////

    private static HashMap entryCache = new HashMap();
    private static HashMap currentStepsCache = new HashMap();
    private static HashMap historyStepsCache = new HashMap();
    private static HashMap propertySetCache = new HashMap();
    private static long globalEntryId = 1;
    private static long globalStepId = 1;

    //~ Methods ////////////////////////////////////////////////////////////////

    public void setEntryState(long entryId, int state) throws StoreException {
        SimpleWorkflowEntry theEntry = (SimpleWorkflowEntry) findEntry(entryId);
        theEntry.setState(state);
    }

    public PropertySet getPropertySet(long entryId) {
        PropertySet ps = (PropertySet) propertySetCache.get(new Long(entryId));

        if (ps == null) {
            ps = PropertySetManager.getInstance("memory", null);
            propertySetCache.put(new Long(entryId), ps);
        }

        return ps;
    }

    public Step createCurrentStep(long entryId, int stepId, String owner, Date startDate, Date dueDate, String status, long[] previousIds) {
        long id = globalStepId++;
        SimpleStep step = new SimpleStep(id, entryId, stepId, 0, owner, startDate, dueDate, null, status, previousIds, null);

        List currentSteps = (List) currentStepsCache.get(new Long(entryId));

        if (currentSteps == null) {
            currentSteps = new ArrayList();
            currentStepsCache.put(new Long(entryId), currentSteps);
        }

        currentSteps.add(step);

        return step;
    }

    /**
    * Reset the MemoryWorkflowStore so it doesn't have any information.
    * Useful when testing and you don't want the MemoryWorkflowStore to
    * have old data in it.
    */
    public static void reset() {
        entryCache.clear();
        currentStepsCache.clear();
        historyStepsCache.clear();
        propertySetCache.clear();
    }

    public WorkflowEntry createEntry(String workflowName) {
        long id = globalEntryId++;
        SimpleWorkflowEntry entry = new SimpleWorkflowEntry(id, workflowName, WorkflowEntry.CREATED);
        entryCache.put(new Long(id), entry);

        return entry;
    }

    public List findCurrentSteps(long entryId) {
        List currentSteps = (List) currentStepsCache.get(new Long(entryId));

        if (currentSteps == null) {
            currentSteps = new ArrayList();
            currentStepsCache.put(new Long(entryId), currentSteps);
        }

        return new ArrayList(currentSteps);
    }

    public WorkflowEntry findEntry(long entryId) {
        return (WorkflowEntry) entryCache.get(new Long(entryId));
    }

    public List findHistorySteps(long entryId) {
        List historySteps = (List) historyStepsCache.get(new Long(entryId));

        if (historySteps == null) {
            historySteps = new ArrayList();
            historyStepsCache.put(new Long(entryId), historySteps);
        }

        return new ArrayList(historySteps);
    }

    public void init(Map props) {
    }

    public Step markFinished(Step step, int actionId, Date finishDate, String status, String caller) {
        List currentSteps = (List) currentStepsCache.get(new Long(step.getEntryId()));

        for (Iterator iterator = currentSteps.iterator(); iterator.hasNext();) {
            SimpleStep theStep = (SimpleStep) iterator.next();

            if (theStep.getId() == step.getId()) {
                theStep.setStatus(status);
                theStep.setActionId(actionId);
                theStep.setFinishDate(finishDate);
                theStep.setCaller(caller);

                return theStep;
            }
        }

        return null;
    }

    public void moveToHistory(Step step) {
        List currentSteps = (List) currentStepsCache.get(new Long(step.getEntryId()));

        List historySteps = (List) historyStepsCache.get(new Long(step.getEntryId()));

        if (historySteps == null) {
            historySteps = new ArrayList();
            historyStepsCache.put(new Long(step.getEntryId()), historySteps);
        }

        SimpleStep simpleStep = (SimpleStep) step;

        for (Iterator iterator = currentSteps.iterator(); iterator.hasNext();) {
            Step currentStep = (Step) iterator.next();

            if (simpleStep.getId() == currentStep.getId()) {
                iterator.remove();
                historySteps.add(0, simpleStep);

                break;
            }
        }
    }

    public List query(WorkflowQuery query) {
        ArrayList results = new ArrayList();

        for (Iterator iterator = entryCache.entrySet().iterator();
                iterator.hasNext();) {
            Map.Entry mapEntry = (Map.Entry) iterator.next();
            Long entryId = (Long) mapEntry.getKey();

            if (query(entryId, query)) {
                results.add(entryId);
            }
        }

        return results;
    }

    public List query(WorkflowExpressionQuery query) {
        ArrayList results = new ArrayList();

        for (Iterator iterator = entryCache.entrySet().iterator();
                iterator.hasNext();) {
            Map.Entry mapEntry = (Map.Entry) iterator.next();
            Long entryId = (Long) mapEntry.getKey();

            if (query(entryId.longValue(), query)) {
                results.add(entryId);
            }
        }

        return results;
    }

    private boolean checkExpression(long entryId, FieldExpression expression) {
        Object value = expression.getValue();
        int operator = expression.getOperator();
        int field = expression.getField();
        int context = expression.getContext();

        Long id = new Long(entryId);

        if (context == FieldExpression.ENTRY) {
            SimpleWorkflowEntry theEntry = (SimpleWorkflowEntry) entryCache.get(id);

            if (field == FieldExpression.NAME) {
                return this.compareText(theEntry.getWorkflowName(), (String) value, operator);
            }

            if (field == FieldExpression.STATE) {
                return this.compareLong(DataUtil.getInt((Integer) value), theEntry.getState(), operator);
            }

            throw new InvalidParameterException("unknown field");
        }

        List steps;

        if (context == FieldExpression.CURRENT_STEPS) {
            steps = (List) currentStepsCache.get(id);
        } else if (context == FieldExpression.HISTORY_STEPS) {
            steps = (List) historyStepsCache.get(id);
        } else {
            throw new InvalidParameterException("unknown field context");
        }

        if (steps == null) {
            return false;
        }

        boolean expressionResult = false;

        switch (field) {
        case FieldExpression.ACTION:

            long actionId = DataUtil.getInt((Integer) value);

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareLong(step.getActionId(), actionId, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.CALLER:

            String caller = (String) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareText(step.getCaller(), caller, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.FINISH_DATE:

            Date finishDate = (Date) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareDate(step.getFinishDate(), finishDate, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.OWNER:

            String owner = (String) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareText(step.getOwner(), owner, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.START_DATE:

            Date startDate = (Date) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareDate(step.getStartDate(), startDate, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.STEP:

            int stepId = DataUtil.getInt((Integer) value);

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareLong(step.getStepId(), stepId, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.STATUS:

            String status = (String) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareText(step.getStatus(), status, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;

        case FieldExpression.DUE_DATE:

            Date dueDate = (Date) value;

            for (Iterator iterator = steps.iterator(); iterator.hasNext();) {
                SimpleStep step = (SimpleStep) iterator.next();

                if (this.compareDate(step.getDueDate(), dueDate, operator)) {
                    expressionResult = true;

                    break;
                }
            }

            break;
        }

        if (expression.isNegate()) {
            return !expressionResult;
        } else {
            return expressionResult;
        }
    }

    private boolean checkNestedExpression(long entryId, NestedExpression nestedExpression) {
        for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {
            boolean expressionResult;
            Expression expression = nestedExpression.getExpression(i);

            if (expression.isNested()) {
                expressionResult = this.checkNestedExpression(entryId, (NestedExpression) expression);
            } else {
                expressionResult = this.checkExpression(entryId, (FieldExpression) expression);
            }

            if (nestedExpression.getExpressionOperator() == NestedExpression.AND) {
                if (expressionResult == false) {
                    return nestedExpression.isNegate();
                }
            } else if (nestedExpression.getExpressionOperator() == NestedExpression.OR) {
                if (expressionResult == true) {
                    return !nestedExpression.isNegate();
                }
            }
        }

        if (nestedExpression.getExpressionOperator() == NestedExpression.AND) {
            return !nestedExpression.isNegate();
        } else if (nestedExpression.getExpressionOperator() == NestedExpression.OR) {
            return nestedExpression.isNegate();
        }

        throw new InvalidParameterException("unknown operator");
    }

    private boolean compareDate(Date value1, Date value2, int operator) {
        switch (operator) {
        case FieldExpression.EQUALS:
            return value1.compareTo(value2) == 0;

        case FieldExpression.NOT_EQUALS:
            return value1.compareTo(value2) != 0;

        case FieldExpression.GT:
            return (value1.compareTo(value2) > 0);

        case FieldExpression.LT:
            return value1.compareTo(value2) < 0;
        }

        throw new InvalidParameterException("unknown field operator");
    }

    private boolean compareLong(long value1, long value2, int operator) {
        switch (operator) {
        case FieldExpression.EQUALS:
            return value1 == value2;

        case FieldExpression.NOT_EQUALS:
            return value1 != value2;

        case FieldExpression.GT:
            return value1 > value2;

        case FieldExpression.LT:
            return value1 < value2;
        }

        throw new InvalidParameterException("unknown field operator");
    }

    private boolean compareText(String value1, String value2, int operator) {
        switch (operator) {
        case FieldExpression.EQUALS:
            return TextUtils.noNull(value1).equals(value2);

        case FieldExpression.NOT_EQUALS:
            return !TextUtils.noNull(value1).equals(value2);

        case FieldExpression.GT:
            return TextUtils.noNull(value1).compareTo(value2) > 0;

        case FieldExpression.LT:
            return TextUtils.noNull(value1).compareTo(value2) < 0;
        }

        throw new InvalidParameterException("unknown field operator");
    }

    private boolean query(Long entryId, WorkflowQuery query) {
        if (query.getLeft() == null) {
            return queryBasic(entryId, query);
        } else {
            int operator = query.getOperator();
            WorkflowQuery left = query.getLeft();
            WorkflowQuery right = query.getRight();

            switch (operator) {
            case WorkflowQuery.AND:
                return query(entryId, left) && query(entryId, right);

            case WorkflowQuery.OR:
                return query(entryId, left) || query(entryId, right);

            case WorkflowQuery.XOR:
                return query(entryId, left) ^ query(entryId, right);
            }
        }

        return false;
    }

    private boolean query(long entryId, WorkflowExpressionQuery query) {