0001: /*
0002: * Copyright (c) 2002-2003 by OpenSymphony
0003: * All rights reserved.
0004: */
0005: package com.opensymphony.workflow.spi.memory;
0006:
0007: import com.opensymphony.module.propertyset.PropertySet;
0008: import com.opensymphony.module.propertyset.PropertySetManager;
0009:
0010: import com.opensymphony.util.DataUtil;
0011: import com.opensymphony.util.TextUtils;
0012:
0013: import com.opensymphony.workflow.StoreException;
0014: import com.opensymphony.workflow.query.Expression;
0015: import com.opensymphony.workflow.query.FieldExpression;
0016: import com.opensymphony.workflow.query.NestedExpression;
0017: import com.opensymphony.workflow.query.WorkflowExpressionQuery;
0018: import com.opensymphony.workflow.query.WorkflowQuery;
0019: import com.opensymphony.workflow.spi.SimpleStep;
0020: import com.opensymphony.workflow.spi.SimpleWorkflowEntry;
0021: import com.opensymphony.workflow.spi.Step;
0022: import com.opensymphony.workflow.spi.WorkflowEntry;
0023: import com.opensymphony.workflow.spi.WorkflowStore;
0024:
0025: import java.security.InvalidParameterException;
0026:
0027: import java.util.*;
0028:
0029: /**
0030: * Simple memory implementation.
0031: *
0032: * @author <a href="mailto:plightbo@hotmail.com">Pat Lightbody</a>
0033: */
0034: public class MemoryWorkflowStore implements WorkflowStore {
0035: //~ Static fields/initializers /////////////////////////////////////////////
0036:
0037: private static HashMap entryCache = new HashMap();
0038: private static HashMap currentStepsCache = new HashMap();
0039: private static HashMap historyStepsCache = new HashMap();
0040: private static HashMap propertySetCache = new HashMap();
0041: private static long globalEntryId = 1;
0042: private static long globalStepId = 1;
0043:
0044: //~ Methods ////////////////////////////////////////////////////////////////
0045:
0046: public void setEntryState(long entryId, int state)
0047: throws StoreException {
0048: SimpleWorkflowEntry theEntry = (SimpleWorkflowEntry) findEntry(entryId);
0049: theEntry.setState(state);
0050: }
0051:
0052: public PropertySet getPropertySet(long entryId) {
0053: PropertySet ps = (PropertySet) propertySetCache.get(new Long(
0054: entryId));
0055:
0056: if (ps == null) {
0057: ps = PropertySetManager.getInstance("memory", null);
0058: propertySetCache.put(new Long(entryId), ps);
0059: }
0060:
0061: return ps;
0062: }
0063:
0064: public Step createCurrentStep(long entryId, int stepId,
0065: String owner, Date startDate, Date dueDate, String status,
0066: long[] previousIds) {
0067: long id = globalStepId++;
0068: SimpleStep step = new SimpleStep(id, entryId, stepId, 0, owner,
0069: startDate, dueDate, null, status, previousIds, null);
0070:
0071: List currentSteps = (List) currentStepsCache.get(new Long(
0072: entryId));
0073:
0074: if (currentSteps == null) {
0075: currentSteps = new ArrayList();
0076: currentStepsCache.put(new Long(entryId), currentSteps);
0077: }
0078:
0079: currentSteps.add(step);
0080:
0081: return step;
0082: }
0083:
0084: /**
0085: * Reset the MemoryWorkflowStore so it doesn't have any information.
0086: * Useful when testing and you don't want the MemoryWorkflowStore to
0087: * have old data in it.
0088: */
0089: public static void reset() {
0090: entryCache.clear();
0091: currentStepsCache.clear();
0092: historyStepsCache.clear();
0093: propertySetCache.clear();
0094: }
0095:
0096: public WorkflowEntry createEntry(String workflowName) {
0097: long id = globalEntryId++;
0098: SimpleWorkflowEntry entry = new SimpleWorkflowEntry(id,
0099: workflowName, WorkflowEntry.CREATED);
0100: entryCache.put(new Long(id), entry);
0101:
0102: return entry;
0103: }
0104:
0105: public List findCurrentSteps(long entryId) {
0106: List currentSteps = (List) currentStepsCache.get(new Long(
0107: entryId));
0108:
0109: if (currentSteps == null) {
0110: currentSteps = new ArrayList();
0111: currentStepsCache.put(new Long(entryId), currentSteps);
0112: }
0113:
0114: return new ArrayList(currentSteps);
0115: }
0116:
0117: public WorkflowEntry findEntry(long entryId) {
0118: return (WorkflowEntry) entryCache.get(new Long(entryId));
0119: }
0120:
0121: public List findHistorySteps(long entryId) {
0122: List historySteps = (List) historyStepsCache.get(new Long(
0123: entryId));
0124:
0125: if (historySteps == null) {
0126: historySteps = new ArrayList();
0127: historyStepsCache.put(new Long(entryId), historySteps);
0128: }
0129:
0130: return new ArrayList(historySteps);
0131: }
0132:
0133: public void init(Map props) {
0134: }
0135:
0136: public Step markFinished(Step step, int actionId, Date finishDate,
0137: String status, String caller) {
0138: List currentSteps = (List) currentStepsCache.get(new Long(step
0139: .getEntryId()));
0140:
0141: for (Iterator iterator = currentSteps.iterator(); iterator
0142: .hasNext();) {
0143: SimpleStep theStep = (SimpleStep) iterator.next();
0144:
0145: if (theStep.getId() == step.getId()) {
0146: theStep.setStatus(status);
0147: theStep.setActionId(actionId);
0148: theStep.setFinishDate(finishDate);
0149: theStep.setCaller(caller);
0150:
0151: return theStep;
0152: }
0153: }
0154:
0155: return null;
0156: }
0157:
0158: public void moveToHistory(Step step) {
0159: List currentSteps = (List) currentStepsCache.get(new Long(step
0160: .getEntryId()));
0161:
0162: List historySteps = (List) historyStepsCache.get(new Long(step
0163: .getEntryId()));
0164:
0165: if (historySteps == null) {
0166: historySteps = new ArrayList();
0167: historyStepsCache.put(new Long(step.getEntryId()),
0168: historySteps);
0169: }
0170:
0171: SimpleStep simpleStep = (SimpleStep) step;
0172:
0173: for (Iterator iterator = currentSteps.iterator(); iterator
0174: .hasNext();) {
0175: Step currentStep = (Step) iterator.next();
0176:
0177: if (simpleStep.getId() == currentStep.getId()) {
0178: iterator.remove();
0179: historySteps.add(0, simpleStep);
0180:
0181: break;
0182: }
0183: }
0184: }
0185:
0186: public List query(WorkflowQuery query) {
0187: ArrayList results = new ArrayList();
0188:
0189: for (Iterator iterator = entryCache.entrySet().iterator(); iterator
0190: .hasNext();) {
0191: Map.Entry mapEntry = (Map.Entry) iterator.next();
0192: Long entryId = (Long) mapEntry.getKey();
0193:
0194: if (query(entryId, query)) {
0195: results.add(entryId);
0196: }
0197: }
0198:
0199: return results;
0200: }
0201:
0202: public List query(WorkflowExpressionQuery query) {
0203: ArrayList results = new ArrayList();
0204:
0205: for (Iterator iterator = entryCache.entrySet().iterator(); iterator
0206: .hasNext();) {
0207: Map.Entry mapEntry = (Map.Entry) iterator.next();
0208: Long entryId = (Long) mapEntry.getKey();
0209:
0210: if (query(entryId.longValue(), query)) {
0211: results.add(entryId);
0212: }
0213: }
0214:
0215: return results;
0216: }
0217:
0218: private boolean checkExpression(long entryId,
0219: FieldExpression expression) {
0220: Object value = expression.getValue();
0221: int operator = expression.getOperator();
0222: int field = expression.getField();
0223: int context = expression.getContext();
0224:
0225: Long id = new Long(entryId);
0226:
0227: if (context == FieldExpression.ENTRY) {
0228: SimpleWorkflowEntry theEntry = (SimpleWorkflowEntry) entryCache
0229: .get(id);
0230:
0231: if (field == FieldExpression.NAME) {
0232: return this .compareText(theEntry.getWorkflowName(),
0233: (String) value, operator);
0234: }
0235:
0236: if (field == FieldExpression.STATE) {
0237: return this .compareLong(DataUtil
0238: .getInt((Integer) value), theEntry.getState(),
0239: operator);
0240: }
0241:
0242: throw new InvalidParameterException("unknown field");
0243: }
0244:
0245: List steps;
0246:
0247: if (context == FieldExpression.CURRENT_STEPS) {
0248: steps = (List) currentStepsCache.get(id);
0249: } else if (context == FieldExpression.HISTORY_STEPS) {
0250: steps = (List) historyStepsCache.get(id);
0251: } else {
0252: throw new InvalidParameterException("unknown field context");
0253: }
0254:
0255: if (steps == null) {
0256: return false;
0257: }
0258:
0259: boolean expressionResult = false;
0260:
0261: switch (field) {
0262: case FieldExpression.ACTION:
0263:
0264: long actionId = DataUtil.getInt((Integer) value);
0265:
0266: for (Iterator iterator = steps.iterator(); iterator
0267: .hasNext();) {
0268: SimpleStep step = (SimpleStep) iterator.next();
0269:
0270: if (this .compareLong(step.getActionId(), actionId,
0271: operator)) {
0272: expressionResult = true;
0273:
0274: break;
0275: }
0276: }
0277:
0278: break;
0279:
0280: case FieldExpression.CALLER:
0281:
0282: String caller = (String) value;
0283:
0284: for (Iterator iterator = steps.iterator(); iterator
0285: .hasNext();) {
0286: SimpleStep step = (SimpleStep) iterator.next();
0287:
0288: if (this
0289: .compareText(step.getCaller(), caller, operator)) {
0290: expressionResult = true;
0291:
0292: break;
0293: }
0294: }
0295:
0296: break;
0297:
0298: case FieldExpression.FINISH_DATE:
0299:
0300: Date finishDate = (Date) value;
0301:
0302: for (Iterator iterator = steps.iterator(); iterator
0303: .hasNext();) {
0304: SimpleStep step = (SimpleStep) iterator.next();
0305:
0306: if (this .compareDate(step.getFinishDate(), finishDate,
0307: operator)) {
0308: expressionResult = true;
0309:
0310: break;
0311: }
0312: }
0313:
0314: break;
0315:
0316: case FieldExpression.OWNER:
0317:
0318: String owner = (String) value;
0319:
0320: for (Iterator iterator = steps.iterator(); iterator
0321: .hasNext();) {
0322: SimpleStep step = (SimpleStep) iterator.next();
0323:
0324: if (this .compareText(step.getOwner(), owner, operator)) {
0325: expressionResult = true;
0326:
0327: break;
0328: }
0329: }
0330:
0331: break;
0332:
0333: case FieldExpression.START_DATE:
0334:
0335: Date startDate = (Date) value;
0336:
0337: for (Iterator iterator = steps.iterator(); iterator
0338: .hasNext();) {
0339: SimpleStep step = (SimpleStep) iterator.next();
0340:
0341: if (this .compareDate(step.getStartDate(), startDate,
0342: operator)) {
0343: expressionResult = true;
0344:
0345: break;
0346: }
0347: }
0348:
0349: break;
0350:
0351: case FieldExpression.STEP:
0352:
0353: int stepId = DataUtil.getInt((Integer) value);
0354:
0355: for (Iterator iterator = steps.iterator(); iterator
0356: .hasNext();) {
0357: SimpleStep step = (SimpleStep) iterator.next();
0358:
0359: if (this
0360: .compareLong(step.getStepId(), stepId, operator)) {
0361: expressionResult = true;
0362:
0363: break;
0364: }
0365: }
0366:
0367: break;
0368:
0369: case FieldExpression.STATUS:
0370:
0371: String status = (String) value;
0372:
0373: for (Iterator iterator = steps.iterator(); iterator
0374: .hasNext();) {
0375: SimpleStep step = (SimpleStep) iterator.next();
0376:
0377: if (this
0378: .compareText(step.getStatus(), status, operator)) {
0379: expressionResult = true;
0380:
0381: break;
0382: }
0383: }
0384:
0385: break;
0386:
0387: case FieldExpression.DUE_DATE:
0388:
0389: Date dueDate = (Date) value;
0390:
0391: for (Iterator iterator = steps.iterator(); iterator
0392: .hasNext();) {
0393: SimpleStep step = (SimpleStep) iterator.next();
0394:
0395: if (this .compareDate(step.getDueDate(), dueDate,
0396: operator)) {
0397: expressionResult = true;
0398:
0399: break;
0400: }
0401: }
0402:
0403: break;
0404: }
0405:
0406: if (expression.isNegate()) {
0407: return !expressionResult;
0408: } else {
0409: return expressionResult;
0410: }
0411: }
0412:
0413: private boolean checkNestedExpression(long entryId,
0414: NestedExpression nestedExpression) {
0415: for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {
0416: boolean expressionResult;
0417: Expression expression = nestedExpression.getExpression(i);
0418:
0419: if (expression.isNested()) {
0420: expressionResult = this .checkNestedExpression(entryId,
0421: (NestedExpression) expression);
0422: } else {
0423: expressionResult = this .checkExpression(entryId,
0424: (FieldExpression) expression);
0425: }
0426:
0427: if (nestedExpression.getExpressionOperator() == NestedExpression.AND) {
0428: if (expressionResult == false) {
0429: return nestedExpression.isNegate();
0430: }
0431: } else if (nestedExpression.getExpressionOperator() == NestedExpression.OR) {
0432: if (expressionResult == true) {
0433: return !nestedExpression.isNegate();
0434: }
0435: }
0436: }
0437:
0438: if (nestedExpression.getExpressionOperator() == NestedExpression.AND) {
0439: return !nestedExpression.isNegate();
0440: } else if (nestedExpression.getExpressionOperator() == NestedExpression.OR) {
0441: return nestedExpression.isNegate();
0442: }
0443:
0444: throw new InvalidParameterException("unknown operator");
0445: }
0446:
0447: private boolean compareDate(Date value1, Date value2, int operator) {
0448: switch (operator) {
0449: case FieldExpression.EQUALS:
0450: return value1.compareTo(value2) == 0;
0451:
0452: case FieldExpression.NOT_EQUALS:
0453: return value1.compareTo(value2) != 0;
0454:
0455: case FieldExpression.GT:
0456: return (value1.compareTo(value2) > 0);
0457:
0458: case FieldExpression.LT:
0459: return value1.compareTo(value2) < 0;
0460: }
0461:
0462: throw new InvalidParameterException("unknown field operator");
0463: }
0464:
0465: private boolean compareLong(long value1, long value2, int operator) {
0466: switch (operator) {
0467: case FieldExpression.EQUALS:
0468: return value1 == value2;
0469:
0470: case FieldExpression.NOT_EQUALS:
0471: return value1 != value2;
0472:
0473: case FieldExpression.GT:
0474: return value1 > value2;
0475:
0476: case FieldExpression.LT:
0477: return value1 < value2;
0478: }
0479:
0480: throw new InvalidParameterException("unknown field operator");
0481: }
0482:
0483: private boolean compareText(String value1, String value2,
0484: int operator) {
0485: switch (operator) {
0486: case FieldExpression.EQUALS:
0487: return TextUtils.noNull(value1).equals(value2);
0488:
0489: case FieldExpression.NOT_EQUALS:
0490: return !TextUtils.noNull(value1).equals(value2);
0491:
0492: case FieldExpression.GT:
0493: return TextUtils.noNull(value1).compareTo(value2) > 0;
0494:
0495: case FieldExpression.LT:
0496: return TextUtils.noNull(value1).compareTo(value2) < 0;
0497: }
0498:
0499: throw new InvalidParameterException("unknown field operator");
0500: }
0501:
0502: private boolean query(Long entryId, WorkflowQuery query) {
0503: if (query.getLeft() == null) {
0504: return queryBasic(entryId, query);
0505: } else {
0506: int operator = query.getOperator();
0507: WorkflowQuery left = query.getLeft();
0508: WorkflowQuery right = query.getRight();
0509:
0510: switch (operator) {
0511: case WorkflowQuery.AND:
0512: return query(entryId, left) && query(entryId, right);
0513:
0514: case WorkflowQuery.OR:
0515: return query(entryId, left) || query(entryId, right);
0516:
0517: case WorkflowQuery.XOR:
0518: return query(entryId, left) ^ query(entryId, right);
0519: }
0520: }
0521:
0522: return false;
0523: }
0524:
0525: private boolean query(long entryId, WorkflowExpressionQuery query) {
0526: Expression expression = query.getExpression();
0527:
0528: if (expression.isNested()) {
0529: return this .checkNestedExpression(entryId,
0530: (NestedExpression) expression);
0531: } else {
0532: return this .checkExpression(entryId,
0533: (FieldExpression) expression);
0534: }
0535: }
0536:
0537: private boolean queryBasic(Long entryId, WorkflowQuery query) {
0538: // the query object is a comparison
0539: Object value = query.getValue();
0540: int operator = query.getOperator();
0541: int field = query.getField();
0542: int type = query.getType();
0543:
0544: switch (operator) {
0545: case WorkflowQuery.EQUALS:
0546: return queryEquals(entryId, field, type, value);
0547:
0548: case WorkflowQuery.NOT_EQUALS:
0549: return queryNotEquals(entryId, field, type, value);
0550:
0551: case WorkflowQuery.GT:
0552: return queryGreaterThan(entryId, field, type, value);
0553:
0554: case WorkflowQuery.LT:
0555: return queryLessThan(entryId, field, type, value);
0556: }
0557:
0558: return false;
0559: }
0560:
0561: private boolean queryEquals(Long entryId, int field, int type,
0562: Object value) {
0563: List steps;
0564:
0565: if (type == WorkflowQuery.CURRENT) {
0566: steps = (List) currentStepsCache.get(entryId);
0567: } else {
0568: steps = (List) historyStepsCache.get(entryId);
0569: }
0570:
0571: if (steps == null) {
0572: return false;
0573: }
0574:
0575: switch (field) {
0576: case WorkflowQuery.ACTION:
0577:
0578: long actionId = DataUtil.getInt((Integer) value);
0579:
0580: for (Iterator iterator = steps.iterator(); iterator
0581: .hasNext();) {
0582: SimpleStep step = (SimpleStep) iterator.next();
0583:
0584: if (step.getActionId() == actionId) {
0585: return true;
0586: }
0587: }
0588:
0589: return false;
0590:
0591: case WorkflowQuery.CALLER:
0592:
0593: String caller = (String) value;
0594:
0595: for (Iterator iterator = steps.iterator(); iterator
0596: .hasNext();) {
0597: SimpleStep step = (SimpleStep) iterator.next();
0598:
0599: if (TextUtils.noNull(step.getCaller()).equals(caller)) {
0600: return true;
0601: }
0602: }
0603:
0604: return false;
0605:
0606: case WorkflowQuery.FINISH_DATE:
0607:
0608: Date finishDate = (Date) value;
0609:
0610: for (Iterator iterator = steps.iterator(); iterator
0611: .hasNext();) {
0612: SimpleStep step = (SimpleStep) iterator.next();
0613:
0614: if (finishDate.equals(step.getFinishDate())) {
0615: return true;
0616: }
0617: }
0618:
0619: return false;
0620:
0621: case WorkflowQuery.OWNER:
0622:
0623: String owner = (String) value;
0624:
0625: for (Iterator iterator = steps.iterator(); iterator
0626: .hasNext();) {
0627: SimpleStep step = (SimpleStep) iterator.next();
0628:
0629: if (TextUtils.noNull(step.getOwner()).equals(owner)) {
0630: return true;
0631: }
0632: }
0633:
0634: return false;
0635:
0636: case WorkflowQuery.START_DATE:
0637:
0638: Date startDate = (Date) value;
0639:
0640: for (Iterator iterator = steps.iterator(); iterator
0641: .hasNext();) {
0642: SimpleStep step = (SimpleStep) iterator.next();
0643:
0644: if (startDate.equals(step.getStartDate())) {
0645: return true;
0646: }
0647: }
0648:
0649: return false;
0650:
0651: case WorkflowQuery.STEP:
0652:
0653: int stepId = DataUtil.getInt((Integer) value);
0654:
0655: for (Iterator iterator = steps.iterator(); iterator
0656: .hasNext();) {
0657: SimpleStep step = (SimpleStep) iterator.next();
0658:
0659: if (stepId == step.getStepId()) {
0660: return true;
0661: }
0662: }
0663:
0664: return false;
0665:
0666: case WorkflowQuery.STATUS:
0667:
0668: String status = (String) value;
0669:
0670: for (Iterator iterator = steps.iterator(); iterator
0671: .hasNext();) {
0672: SimpleStep step = (SimpleStep) iterator.next();
0673:
0674: if (TextUtils.noNull(step.getStatus()).equals(status)) {
0675: return true;
0676: }
0677: }
0678:
0679: return false;
0680: }
0681:
0682: return false;
0683: }
0684:
0685: private boolean queryGreaterThan(Long entryId, int field, int type,
0686: Object value) {
0687: List steps;
0688:
0689: if (type == WorkflowQuery.CURRENT) {
0690: steps = (List) currentStepsCache.get(entryId);
0691: } else {
0692: steps = (List) historyStepsCache.get(entryId);
0693: }
0694:
0695: switch (field) {
0696: case WorkflowQuery.ACTION:
0697:
0698: long actionId = DataUtil.getLong((Long) value);
0699:
0700: for (Iterator iterator = steps.iterator(); iterator
0701: .hasNext();) {
0702: SimpleStep step = (SimpleStep) iterator.next();
0703:
0704: if (step.getActionId() > actionId) {
0705: return true;
0706: }
0707: }
0708:
0709: return false;
0710:
0711: case WorkflowQuery.CALLER:
0712:
0713: String caller = (String) value;
0714:
0715: for (Iterator iterator = steps.iterator(); iterator
0716: .hasNext();) {
0717: SimpleStep step = (SimpleStep) iterator.next();
0718:
0719: if (TextUtils.noNull(step.getCaller())
0720: .compareTo(caller) > 0) {
0721: return true;
0722: }
0723: }
0724:
0725: return false;
0726:
0727: case WorkflowQuery.FINISH_DATE:
0728:
0729: Date finishDate = (Date) value;
0730:
0731: for (Iterator iterator = steps.iterator(); iterator
0732: .hasNext();) {
0733: SimpleStep step = (SimpleStep) iterator.next();
0734:
0735: if (step.getFinishDate().compareTo(finishDate) > 0) {
0736: return true;
0737: }
0738: }
0739:
0740: return false;
0741:
0742: case WorkflowQuery.OWNER:
0743:
0744: String owner = (String) value;
0745:
0746: for (Iterator iterator = steps.iterator(); iterator
0747: .hasNext();) {
0748: SimpleStep step = (SimpleStep) iterator.next();
0749:
0750: if (TextUtils.noNull(step.getOwner()).compareTo(owner) > 0) {
0751: return true;
0752: }
0753: }
0754:
0755: return false;
0756:
0757: case WorkflowQuery.START_DATE:
0758:
0759: Date startDate = (Date) value;
0760:
0761: for (Iterator iterator = steps.iterator(); iterator
0762: .hasNext();) {
0763: SimpleStep step = (SimpleStep) iterator.next();
0764:
0765: if (step.getStartDate().compareTo(startDate) > 0) {
0766: return true;
0767: }
0768: }
0769:
0770: return false;
0771:
0772: case WorkflowQuery.STEP:
0773:
0774: int stepId = DataUtil.getInt((Integer) value);
0775:
0776: for (Iterator iterator = steps.iterator(); iterator
0777: .hasNext();) {
0778: SimpleStep step = (SimpleStep) iterator.next();
0779:
0780: if (step.getStepId() > stepId) {
0781: return true;
0782: }
0783: }
0784:
0785: return false;
0786:
0787: case WorkflowQuery.STATUS:
0788:
0789: String status = (String) value;
0790:
0791: for (Iterator iterator = steps.iterator(); iterator
0792: .hasNext();) {
0793: SimpleStep step = (SimpleStep) iterator.next();
0794:
0795: if (TextUtils.noNull(step.getStatus())
0796: .compareTo(status) > 0) {
0797: return true;
0798: }
0799: }
0800:
0801: return false;
0802: }
0803:
0804: return false;
0805: }
0806:
0807: private boolean queryLessThan(Long entryId, int field, int type,
0808: Object value) {
0809: List steps;
0810:
0811: if (type == WorkflowQuery.CURRENT) {
0812: steps = (List) currentStepsCache.get(entryId);
0813: } else {
0814: steps = (List) historyStepsCache.get(entryId);
0815: }
0816:
0817: switch (field) {
0818: case WorkflowQuery.ACTION:
0819:
0820: long actionId = DataUtil.getLong((Long) value);
0821:
0822: for (Iterator iterator = steps.iterator(); iterator
0823: .hasNext();) {
0824: SimpleStep step = (SimpleStep) iterator.next();
0825:
0826: if (step.getActionId() < actionId) {
0827: return true;
0828: }
0829: }
0830:
0831: return false;
0832:
0833: case WorkflowQuery.CALLER:
0834:
0835: String caller = (String) value;
0836:
0837: for (Iterator iterator = steps.iterator(); iterator
0838: .hasNext();) {
0839: SimpleStep step = (SimpleStep) iterator.next();
0840:
0841: if (TextUtils.noNull(step.getCaller())
0842: .compareTo(caller) < 0) {
0843: return true;
0844: }
0845: }
0846:
0847: return false;
0848:
0849: case WorkflowQuery.FINISH_DATE:
0850:
0851: Date finishDate = (Date) value;
0852:
0853: for (Iterator iterator = steps.iterator(); iterator
0854: .hasNext();) {
0855: SimpleStep step = (SimpleStep) iterator.next();
0856:
0857: if (step.getFinishDate().compareTo(finishDate) < 0) {
0858: return true;
0859: }
0860: }
0861:
0862: return false;
0863:
0864: case WorkflowQuery.OWNER:
0865:
0866: String owner = (String) value;
0867:
0868: for (Iterator iterator = steps.iterator(); iterator
0869: .hasNext();) {
0870: SimpleStep step = (SimpleStep) iterator.next();
0871:
0872: if (TextUtils.noNull(step.getOwner()).compareTo(owner) < 0) {
0873: return true;
0874: }
0875: }
0876:
0877: return false;
0878:
0879: case WorkflowQuery.START_DATE:
0880:
0881: Date startDate = (Date) value;
0882:
0883: for (Iterator iterator = steps.iterator(); iterator
0884: .hasNext();) {
0885: SimpleStep step = (SimpleStep) iterator.next();
0886:
0887: if (step.getStartDate().compareTo(startDate) < 0) {
0888: return true;
0889: }
0890: }
0891:
0892: return false;
0893:
0894: case WorkflowQuery.STEP:
0895:
0896: int stepId = DataUtil.getInt((Integer) value);
0897:
0898: for (Iterator iterator = steps.iterator(); iterator
0899: .hasNext();) {
0900: SimpleStep step = (SimpleStep) iterator.next();
0901:
0902: if (step.getStepId() < stepId) {
0903: return true;
0904: }
0905: }
0906:
0907: return false;
0908:
0909: case WorkflowQuery.STATUS:
0910:
0911: String status = (String) value;
0912:
0913: for (Iterator iterator = steps.iterator(); iterator
0914: .hasNext();) {
0915: SimpleStep step = (SimpleStep) iterator.next();
0916:
0917: if (TextUtils.noNull(step.getStatus())
0918: .compareTo(status) < 0) {
0919: return true;
0920: }
0921: }
0922:
0923: return false;
0924: }
0925:
0926: return false;
0927: }
0928:
0929: private boolean queryNotEquals(Long entryId, int field, int type,
0930: Object value) {
0931: List steps;
0932:
0933: if (type == WorkflowQuery.CURRENT) {
0934: steps = (List) currentStepsCache.get(entryId);
0935: } else {
0936: steps = (List) historyStepsCache.get(entryId);
0937: }
0938:
0939: switch (field) {
0940: case WorkflowQuery.ACTION:
0941:
0942: long actionId = DataUtil.getLong((Long) value);
0943:
0944: for (Iterator iterator = steps.iterator(); iterator
0945: .hasNext();) {
0946: SimpleStep step = (SimpleStep) iterator.next();
0947:
0948: if (step.getActionId() != actionId) {
0949: return true;
0950: }
0951: }
0952:
0953: return false;
0954:
0955: case WorkflowQuery.CALLER:
0956:
0957: String caller = (String) value;
0958:
0959: for (Iterator iterator = steps.iterator(); iterator
0960: .hasNext();) {
0961: SimpleStep step = (SimpleStep) iterator.next();
0962:
0963: if (!TextUtils.noNull(step.getCaller()).equals(caller)) {
0964: return true;
0965: }
0966: }
0967:
0968: return false;
0969:
0970: case WorkflowQuery.FINISH_DATE:
0971:
0972: Date finishDate = (Date) value;
0973:
0974: for (Iterator iterator = steps.iterator(); iterator
0975: .hasNext();) {
0976: SimpleStep step = (SimpleStep) iterator.next();
0977:
0978: if (!finishDate.equals(step.getFinishDate())) {
0979: return true;
0980: }
0981: }
0982:
0983: return false;
0984:
0985: case WorkflowQuery.OWNER:
0986:
0987: String owner = (String) value;
0988:
0989: for (Iterator iterator = steps.iterator(); iterator
0990: .hasNext();) {
0991: SimpleStep step = (SimpleStep) iterator.next();
0992:
0993: if (!TextUtils.noNull(step.getOwner()).equals(owner)) {
0994: return true;
0995: }
0996: }
0997:
0998: return false;
0999:
1000: case WorkflowQuery.START_DATE:
1001:
1002: Date startDate = (Date) value;
1003:
1004: for (Iterator iterator = steps.iterator(); iterator
1005: .hasNext();) {
1006: SimpleStep step = (SimpleStep) iterator.next();
1007:
1008: if (!startDate.equals(step.getStartDate())) {
1009: return true;
1010: }
1011: }
1012:
1013: return false;
1014:
1015: case WorkflowQuery.STEP:
1016:
1017: int stepId = DataUtil.getInt((Integer) value);
1018:
1019: for (Iterator iterator = steps.iterator(); iterator
1020: .hasNext();) {
1021: SimpleStep step = (SimpleStep) iterator.next();
1022:
1023: if (stepId != step.getStepId()) {
1024: return true;
1025: }
1026: }
1027:
1028: return false;
1029:
1030: case WorkflowQuery.STATUS:
1031:
1032: String status = (String) value;
1033:
1034: for (Iterator iterator = steps.iterator(); iterator
1035: .hasNext();) {
1036: SimpleStep step = (SimpleStep) iterator.next();
1037:
1038: if (!TextUtils.noNull(step.getStatus()).equals(status)) {
1039: return true;
1040: }
1041: }
1042:
1043: return false;
1044: }
1045:
1046: return false;
1047: }
1048: }
|