querylogic.java

osworkflow修改版本

/*
 * Copyright (c) 2002-2003 by OpenSymphony
 * All rights reserved.
 */
/*
 * Created on Feb 12, 2004
 *
 *
 */
package com.opensymphony.workflow.spi.prevayler;

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.WorkflowStore;

import java.security.InvalidParameterException;

import java.util.Date;
import java.util.Iterator;
import java.util.List;


/**
 *
 * This is basically the query logic cut and pasted from MemoryWorkflowStore.  I've separated
 * it into a separate class which relies on WorkflowStore for its query base, that way any future
 * or other WorkflowStore can rely on this logic.
 *
 * I thought about refactoring MemoryWorkflowStore to use this class, but as its such a well used
 * class I didn't want to do it before some more eyes looked at things here.
 *
 * @author Christopher Farnham
 **/
public class QueryLogic {
    //~ Instance fields ////////////////////////////////////////////////////////

    private WorkflowStore _store = null;

    //~ Constructors ///////////////////////////////////////////////////////////

    public QueryLogic(WorkflowStore store) {
        _store = store;
    }

    private QueryLogic() {
        super();
    }

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

    public boolean query(Long entryId, WorkflowExpressionQuery query) throws StoreException {
        Expression expression = query.getExpression();

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

    public boolean query(Long entryId, WorkflowQuery query) throws StoreException {
        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 checkExpression(long entryId, FieldExpression expression) throws StoreException {
        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) _store.findEntry(entryId);

            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);
            steps = (List) _store.findCurrentSteps(id.longValue());
        } else if (context == FieldExpression.HISTORY_STEPS) {
            //steps = (List) historyStepsCache.get(id);
            steps = (List) _store.findHistorySteps(id.longValue());
        } 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;
        }

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

    private boolean checkNestedExpression(long entryId, NestedExpression nestedExpression) throws StoreException {
        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 queryBasic(Long entryId, WorkflowQuery query) throws StoreException {
        // the query object is a comparison
        Object value = query.getValue();
        int operator = query.getOperator();
        int field = query.getField();
        int type = query.getType();

        switch (operator) {
        case WorkflowQuery.EQUALS:
            return queryEquals(entryId, field, type, value);

        case WorkflowQuery.NOT_EQUALS:
            return queryNotEquals(entryId, field, type, value);

        case WorkflowQuery.GT:
            return queryGreaterThan(entryId, field, type, value);

        case WorkflowQuery.LT:
            return queryLessThan(entryId, field, type, value);
        }

        return false;
    }

    private boolean queryEquals(Long entryId, int field, int type, Object value) throws StoreException {
        List steps;

        if (type == WorkflowQuery.CURRENT) {
            //steps = (List) currentStepsCache.get(entryId);
            steps = (List) _store.findCurrentSteps(entryId.longValue());
        } else {
            //steps = (List) historyStepsCache.get(entryId);
            steps = (List) _store.findCurrentSteps(entryId.longValue());
        }

        switch (field) {
        case WorkflowQuery.ACTION:

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

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

                if (step.getActionId() == actionId) {
                    return true;
                }
            }

            return false;

        case WorkflowQuery.CALLER:

            String caller = (String) value;

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

                if (TextUtils.noNull(step.getCaller()).equals(caller)) {
                    return true;
                }
            }

            return false;

        case WorkflowQuery.FINISH_DATE:

            Date finishDate = (Date) value;

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

                if (finishDate.equals(step.getFinishDate())) {