hibernateworkflowstore.cs

基于DotNet的工作流引擎实现

			if (expression.Nested)
			{
				expr = buildNested((NestedExpression) expression);
			}
			else
			{
				expr = queryComparison((FieldExpression) expression);
			}
			
			//get results and send them back
			ICriteria criteria = session.CreateCriteria(entityClass);
			criteria.Add(expr);
			
			try
			{
				ISet results = new HashedSet();
				
				foreach(Object next in results){
					Object item;
					
					if (next is HibernateStep)
					{
						HibernateStep step = (HibernateStep) next;
						item = step.EntryId;
					}
					else
					{
						IWorkflowEntry entry = (IWorkflowEntry) next;
						item = entry.Id;
					}
					
					results.Add(item);
				}
				
				return new ArrayList(results);
			}
			catch (HibernateException e)
			{
				throw new StoreException("Error executing query " + expression, e);
			}
		}
		
		public virtual IList Query(WorkflowQuery query)
		{
			Type entityClass;
			
			int qtype = query.Type;
			
			if (qtype == 0)
			{
				// then not set, so look in sub queries
				
				if (query.Left != null)
				{
					qtype = query.Left.Type;
				}
			}
			
			if (qtype == WorkflowQuery.CURRENT)
			{
				entityClass = typeof(HibernateCurrentStep);
			}
			else
			{
				entityClass = typeof(HibernateHistoryStep);
			}
			
			ICriteria criteria = session.CreateCriteria(entityClass);
			ICriterion expression = buildExpression(query);
			criteria.Add(expression);
			
			//get results and send them back
			try
			{
				ISet results = new HashedSet();
				IEnumerator iter = criteria.List().GetEnumerator();
				
				while (iter.MoveNext())
				{
					HibernateStep step = (HibernateStep) iter.Current;
					results.Add(step.EntryId);
				}
				
				return new ArrayList(results);
			}
			catch (HibernateException e)
			{
				throw new StoreException("Error executing query " + expression, e);
			}
		}
		
		/// <summary> Returns an expression generated from this query
		/// </summary>
		private ICriterion getExpression(WorkflowQuery query)
		{
			int operator_Renamed = query.Operator;
			
			switch (operator_Renamed)
			{
				
				case WorkflowQuery.EQUALS: 
					return Expression.Eq(getFieldName(query.Field), query.Value);
				
				
				case WorkflowQuery.NOT_EQUALS: 
					return Expression.Not(Expression.Like(getFieldName(query.Field), query.Value));
				
				
				case WorkflowQuery.GT: 
					return Expression.Gt(getFieldName(query.Field), query.Value);
				
				
				case WorkflowQuery.LT: 
					return Expression.Lt(getFieldName(query.Field), query.Value);
				
				
				default: 
					return Expression.Eq(getFieldName(query.Field), query.Value);
				
			}
		}
		
		/// <summary> returns the correct name of the field given or "1" if none is found
		/// which matches the input.
		/// </summary>
		/// <param name="field">
		/// </param>
		/// <returns>
		/// 
		/// </returns>
		private String getFieldName(int field)
		{
			switch (field)
			{
				
				case FieldExpression.ACTION: 
					return "actionId";
				
				
				case FieldExpression.CALLER: 
					return "caller";
				
				
				case FieldExpression.FINISH_DATE: 
					return "finishDate";
				
				
				case FieldExpression.OWNER: 
					return "owner";
				
				
				case FieldExpression.START_DATE: 
					return "startDate";
				
				
				case FieldExpression.STEP: 
					return "stepId";
				
				
				case FieldExpression.STATUS: 
					return "status";
				
				
				case FieldExpression.STATE: 
					return "state";
				
				
				case FieldExpression.NAME: 
					return "workflowName";
				
				
				case FieldExpression.DUE_DATE: 
					return "dueDate";
				
				
				default: 
					return "1";
				
			}
		}
		
		private Type getQueryClass(Query.Expression expr, IList classesCache)
		{
			if (classesCache == null)
			{
				classesCache = new ArrayList();
			}
			
			if (expr is FieldExpression)
			{
				FieldExpression fieldExpression = (FieldExpression) expr;
				
				switch (fieldExpression.Context)
				{
					
					case FieldExpression.CURRENT_STEPS: 
						classesCache.Add(typeof(HibernateCurrentStep));
						
						break;
					
					
					case FieldExpression.HISTORY_STEPS: 
						classesCache.Add(typeof(HibernateHistoryStep));
						
						break;
					
					
					case FieldExpression.ENTRY: 
						classesCache.Add(typeof(HibernateWorkflowEntry));
						
						break;
					
					
					default: 
						throw new QueryNotSupportedException("Query for unsupported context " + fieldExpression.Context);
					
				}
			}
			else
			{
				NestedExpression nestedExpression = (NestedExpression) expr;
				
				for (int i = 0; i < nestedExpression.ExpressionCount; i++)
				{
					Query.Expression expression = nestedExpression.getExpression(i);
					
					if (expression.Nested)
					{
						classesCache.Add(getQueryClass(nestedExpression.getExpression(i), classesCache));
					}
					else
					{
						classesCache.Add(getQueryClass(expression, classesCache));
					}
				}
			}
			
			if (classesCache.Count > 1)
			{
				throw new QueryNotSupportedException("Store does not support nested queries of different types (types found:" + classesCache + ")");
			}
			
			return (Type) classesCache[0];
		}
		
		/// <summary>  Recursive method for building Expressions using Query objects.
		/// </summary>
		private ICriterion buildExpression(WorkflowQuery query)
		{
			if (query.Left == null)
			{
				if (query.Right == null)
				{
					return getExpression(query); //leaf node
				}
				else
				{
					throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is null but QueryRight is not.");
				}
			}
			else
			{
				if (query.Right == null)
				{
					throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is not null but QueryRight is.");
				}
				
				int operator_Renamed = query.Operator;
				WorkflowQuery left = query.Left;
				WorkflowQuery right = query.Right;
				
				switch (operator_Renamed)
				{
					
					case WorkflowQuery.AND: 
						return Expression.And(buildExpression(left), buildExpression(right));
					
					
					case WorkflowQuery.OR: 
						return Expression.Or(buildExpression(left), buildExpression(right));
					
					
					case WorkflowQuery.XOR: 
						throw new StoreException("XOR Operator in Queries not supported by " + this.GetType().FullName);
					
					
					default: 
						throw new StoreException("Operator '" + operator_Renamed + "' is not supported by " + this.GetType().FullName);
					
				}
			}
		}
		
		private ICriterion buildNested(NestedExpression nestedExpression)
		{
			ICriterion full = null;
			
			for (int i = 0; i < nestedExpression.ExpressionCount; i++)
			{
				ICriterion expr;
				Query.Expression expression = nestedExpression.getExpression(i);
				
				if (expression.Nested)
				{
					expr = buildNested((NestedExpression) nestedExpression.getExpression(i));
				}
				else
				{
					FieldExpression sub = (FieldExpression) nestedExpression.getExpression(i);
					expr = queryComparison(sub);
					
					if (sub.Negate)
					{
						expr = Expression.Not(expr);
					}
				}
				
				if (full == null)
				{
					full = expr;
				}
				else
				{
					switch (nestedExpression.ExpressionOperator)
					{
						
						case NestedExpression.AND: 
							full = Expression.And(full, expr);
							
							break;
						
						
						case NestedExpression.OR: 
							full = Expression.Or(full, expr);
							break;
						}
				}
			}
			
			return full;
		}
		
		private ICriterion queryComparison(FieldExpression expression)
		{
			int operator_Renamed = expression.Operator;
			
			switch (operator_Renamed)
			{
				
				case FieldExpression.EQUALS: 
					return Expression.Eq(getFieldName(expression.Field), expression.Value);
				
				
				case FieldExpression.NOT_EQUALS: 
					return Expression.Not(Expression.Like(getFieldName(expression.Field), expression.Value));
				
				
				case FieldExpression.GT: 
					return Expression.Gt(getFieldName(expression.Field), expression.Value);
				
				
				case FieldExpression.LT: 
					return Expression.Lt(getFieldName(expression.Field), expression.Value);
				
				
				default: 
					return Expression.Eq(getFieldName(expression.Field), expression.Value);
				
			}
		}
		static HibernateWorkflowStore()
		{
			log = LogManager.GetLogger(typeof(HibernateWorkflowStore));
		}
	}
}