memoryworkflowstore.cs

基于DotNet的工作流引擎实现

using System;
using System.Collections;
using DotNetTools.PropertySet;
using DotNetTools.Util;
using DotNetTools.Workflow.Query;
using DotNetTools.Workflow.Util;
/*
* Copyright (c) 2002-2003 by OpenSymphony
* All rights reserved.
*/

namespace DotNetTools.Workflow.Spi.Memory
{
	/// <summary> Simple memory implementation.
	/// *
	/// </summary>
	/// <author>  <a href="mailto:[e-mail]">Pat Lightbody</a>
	/// 
	/// </author>
	public class MemoryWorkflowStore : IWorkflowStore
	{
		//~ Static fields/initializers /////////////////////////////////////////////

		private static IDictionary entryCache;
		private static IDictionary currentStepsCache;
		private static IDictionary historyStepsCache;
		private static IDictionary propertySetCache;
		private static long globalEntryId = 1;
		private static long globalStepId = 1;

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

		public virtual void SetEntryState(long entryId, int state)
		{
			SimpleWorkflowEntry theEntry = (SimpleWorkflowEntry) FindEntry(entryId);
			theEntry.State = state;
		}

		public virtual IPropertySet GetPropertySet(long entryId)
		{
			
			IPropertySet ps = (IPropertySet) propertySetCache[entryId];

			if (ps == null)
			{
				ps = PropertySetManager.GetInstance("memory", null);
				propertySetCache.Add(entryId, ps);
			}

			return ps;
		}

		public virtual IStep CreateCurrentStep(long entryId, int stepId, String owner, DateTime startDate, DateTime dueDate, String status, long[] previousIds)
		{
			long id = globalStepId++;
			SimpleStep step = new SimpleStep(id, entryId, stepId, 0, owner, startDate, dueDate, DateTime.MinValue, status, previousIds, null);

			IList currentSteps = (IList) currentStepsCache[entryId];

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

			currentSteps.Add(step);

			return step;
		}

		/// <summary> 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.
		/// </summary>
		public static void reset()
		{
			entryCache.Clear();
			currentStepsCache.Clear();
			historyStepsCache.Clear();
			propertySetCache.Clear();
		}

		public virtual IWorkflowEntry CreateEntry(String workflowName)
		{
			long id = globalEntryId++;
			SimpleWorkflowEntry entry = new SimpleWorkflowEntry(id, workflowName, SimpleWorkflowEntry.CREATED);
			entryCache.Add(id, entry);

			return entry;
		}

		public virtual IList FindCurrentSteps(long entryId)
		{
			IList currentSteps = (IList) currentStepsCache[entryId];

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

			return new ArrayList(currentSteps);
		}

		public virtual IWorkflowEntry FindEntry(long entryId)
		{
			return (IWorkflowEntry) entryCache[entryId];
		}

		public virtual IList FindHistorySteps(long entryId)
		{
			IList historySteps = (IList) historyStepsCache[entryId];

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

			return new ArrayList(historySteps);
		}

		public virtual void Init(IDictionary props)
		{
		}

		public virtual IStep MarkFinished(IStep step, int actionId, DateTime finishDate, String status, String caller)
		{
			IList currentSteps = (IList) currentStepsCache[step.EntryId];

			foreach (SimpleStep theStep in currentSteps)
			{
				if (theStep.Id == step.Id)
				{
					theStep.Status = status;
					theStep.ActionId = actionId;
					theStep.FinishDate = finishDate;
					theStep.Caller = caller;

					return theStep;
				}
			}

			return null;
		}

		public virtual void MoveToHistory(IStep step)
		{
			IList currentSteps = (IList) currentStepsCache[step.EntryId];

			IList historySteps = (IList) historyStepsCache[step.EntryId];

			if (historySteps == null)
			{
				historySteps = new ArrayList();
				historyStepsCache.Add(step.EntryId, historySteps);
			}

			SimpleStep simpleStep = (SimpleStep) step;
			foreach (IStep currentStep in currentSteps)
			{
				if (simpleStep.Id == currentStep.Id)
				{
					currentSteps.Remove(currentStep);
					historySteps.Insert(0, simpleStep);

					break;
				}
			}
		}

		public virtual IList Query(WorkflowQuery query)
		{
			ArrayList results = new ArrayList();
			foreach (DictionaryEntry mapEntry in entryCache)
			{
				Int64 entryId = (Int64) mapEntry.Key;

				if (query_Renamed(entryId, query))
				{
					results.Add(entryId);
				}

			}

			return results;
		}

		public virtual IList Query(WorkflowExpressionQuery query)
		{
			ArrayList results = new ArrayList();

			foreach (DictionaryEntry mapEntry in entryCache)
			{
				Int64 entryId = (Int64) mapEntry.Key;

				if (query_Renamed2(entryId, query))
				{
					results.Add(entryId);
				}
			}

			return results;
		}

		private bool checkExpression(long entryId, FieldExpression expression)
		{
			Object value_Renamed = expression.Value;
			int operator_Renamed = expression.Operator;
			int field = expression.Field;
			int context = expression.Context;

			Int64 id = entryId;

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

				if (field == FieldExpression.NAME)
				{
					return this.compareText(theEntry.WorkflowName, (String) value_Renamed, operator_Renamed);
				}

				if (field == FieldExpression.STATE)
				{
					return this.compareLong(DataUtil.getInt((Int32) value_Renamed), theEntry.State, operator_Renamed);
				}

				throw new ArgumentException("unknown field");
			}

			IList steps;

			if (context == FieldExpression.CURRENT_STEPS)
			{
				steps = (IList) currentStepsCache[id];
			}
			else if (context == FieldExpression.HISTORY_STEPS)
			{
				steps = (IList) historyStepsCache[id];
			}
			else
			{
				throw new ArgumentException("unknown field context");
			}

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

			bool expressionResult = false;

			switch (field)
			{
				case FieldExpression.ACTION:

					long actionId = DataUtil.getInt((Int32) value_Renamed);

					foreach (SimpleStep step in steps)
					{
						if (this.compareLong(step.ActionId, actionId, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.CALLER:

					String caller = (String) value_Renamed;
					foreach (SimpleStep step in steps)
					{
						if (this.compareText(step.Caller, caller, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.FINISH_DATE:

					DateTime finishDate = (DateTime) value_Renamed;

					foreach (SimpleStep step in steps)
					{
						if (this.compareDate(step.FinishDate, finishDate, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.OWNER:

					String owner = (String) value_Renamed;
					foreach (SimpleStep step in steps)
					{
						if (this.compareText(step.Owner, owner, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.START_DATE:

					DateTime startDate = (DateTime) value_Renamed;
					foreach (SimpleStep step in steps)
					{
						if (this.compareDate(step.StartDate, startDate, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.STEP:

					int stepId = DataUtil.getInt((Int32) value_Renamed);
					foreach (SimpleStep step in steps)
					{
						if (this.compareLong(step.StepId, stepId, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.STATUS:

					String status = (String) value_Renamed;
					foreach (SimpleStep step in steps)
					{
						if (this.compareText(step.Status, status, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;


				case FieldExpression.DUE_DATE:

					DateTime dueDate = (DateTime) value_Renamed;
					foreach (SimpleStep step in steps)
					{
						if (this.compareDate(step.DueDate, dueDate, operator_Renamed))
						{
							expressionResult = true;

							break;
						}
					}

					break;
			}

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

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

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

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

			if (nestedExpression.ExpressionOperator == NestedExpression.AND)
			{
				return !nestedExpression.Negate;
			}
			else if (nestedExpression.ExpressionOperator == NestedExpression.OR)
			{
				return nestedExpression.Negate;
			}

			throw new ArgumentException("unknown operator");
		}

		private bool compareDate(DateTime value1, DateTime value2, int operator_Renamed)
		{
			switch (operator_Renamed)
			{
				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 ArgumentException("unknown field operator");
		}

		private bool compareLong(long value1, long value2, int operator_Renamed)
		{
			switch (operator_Renamed)
			{
				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 ArgumentException("unknown field operator");
		}

		private bool compareText(String value1, String value2, int operator_Renamed)
		{
			switch (operator_Renamed)
			{
				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 ArgumentException("unknown field operator");
		}

		private bool query_Renamed(Int64 entryId, WorkflowQuery query)
		{
			if (query.Left == null)
			{
				return queryBasic(entryId, query);
			}
			else
			{
				int operator_Renamed = query.Operator;
				WorkflowQuery left = query.Left;
				WorkflowQuery right = query.Right;

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


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


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