adoworkflowstore.cs

基于DotNet的工作流引擎实现

			stmt.Parameters.Add(createDataParameter(stepStepId, wfStepId));
			stmt.Parameters.Add(createDataParameter(stepActionId,0));
			stmt.Parameters.Add(createDataParameter(stepOwner, owner));
			stmt.Parameters.Add(createDataParameter(stepStartDate, startDate));

			stmt.Parameters.Add(createDataParameter(stepDueDate, dueDate));
			stmt.Parameters.Add(createDataParameter(stepFinishDate,DateTime.MaxValue));
			stmt.Parameters.Add(createDataParameter(stepStatus, status));

			stmt.ExecuteNonQuery();
			cleanup(null, stmt, null);

			return id;
		}

		private String getInitProperty(IDictionary props, String strName, String strDefault)
		{
			Object o = props[strName];

			if (o == null)
			{
				return strDefault;
			}

			return (String) o;
		}

		private String buildNested(NestedExpression nestedExpression, StringBuilder sel, IList values)
		{
			sel.Append("SELECT DISTINCT(");

			// Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead
			//sel.append(entryId);
			sel.Append(stepEntryId);
			sel.Append(") FROM ");

			// Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead
			// sel.append(entryTable);
			sel.Append(currentTable);

			if (log.IsDebugEnabled)
			{
				log.Debug("Thus far, query is: " + sel.ToString());
			}

			for (int i = 0; i < nestedExpression.ExpressionCount; i++)
			{
				Expression expression = nestedExpression.getExpression(i);

				if (i == 0)
				{
					sel.Append(" WHERE ");
				}
				else
				{
					if (nestedExpression.ExpressionOperator == NestedExpression.AND)
					{
						sel.Append(" AND ");
					}
					else
					{
						sel.Append(" OR ");
					}
				}

				if (expression.Negate)
				{
					sel.Append(" NOT ");
				}

				// Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead
				// sel.append(entryId);
				sel.Append(stepEntryId);
				sel.Append(" IN (");

				if (expression.Nested)
				{
					this.buildNested((NestedExpression) nestedExpression.getExpression(i), sel, values);
				}
				else
				{
					FieldExpression sub = (FieldExpression) nestedExpression.getExpression(i);
					this.buildSimple(sub, sel, values);
				}

				sel.Append(")");
			}

			// Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead
			// return (entryId);
			return (stepEntryId);
		}

		private String buildSimple(FieldExpression fieldExpression, StringBuilder sel, IList values)
		{
			String table;
			String columnName;

			if (fieldExpression.Context == FieldExpression.CURRENT_STEPS)
			{
				table = currentTable;
				columnName = stepEntryId;
			}
			else if (fieldExpression.Context == FieldExpression.HISTORY_STEPS)
			{
				table = historyTable;
				columnName = stepEntryId;
			}
			else
			{
				table = entryTable;
				columnName = entryId;
			}

			sel.Append("SELECT DISTINCT(");
			sel.Append(columnName);
			sel.Append(") FROM ");
			sel.Append(table);
			sel.Append(" WHERE ");
			queryComparison(fieldExpression, sel, values);

			return columnName;
		}

		private IList doExpressionQuery(String sel, String columnName, IList values)
		{
			if (log.IsDebugEnabled)
			{
				log.Debug(sel);
			}

			IDbConnection conn = null;
			IDbCommand stmt = null;
			IDataReader rs = null;
			IList results = new ArrayList();

			try
			{
				conn = Connection;
				stmt = createDbCommand(conn, sel);

				if (values.Count != 0)
				{
					for (int i = 1; i <= values.Count; i++)
					{
						stmt.Parameters.Add(createDataParameter(columnName,values[i-1]));
						
					}
				}

				rs = stmt.ExecuteReader();

				while (rs.Read())
				{
					// get entryIds and add to results list
					Int64 id = Convert.ToInt64(rs[(columnName)]);
					results.Add(id);
				}

				return results;
			}
			catch (Exception ex)
			{
				throw new StoreException("SQL Exception in query: " + ex.Message);
			}
			finally
			{
				cleanup(conn, stmt, rs);
			}
		}

		private static String escape(String s)
		{
			StringBuilder sb = new StringBuilder(s);

			char c;
			char[] chars = s.ToCharArray();

			for (int i = 0; i < chars.Length; i++)
			{
				c = chars[i];

				switch (c)
				{
					case '\'':
						sb.Insert(i, '\'');
						i++;

						break;


					case '\\':
						sb.Insert(i, '\\');
						i++;
						break;
				}
			}

			return sb.ToString();
		}

		private String fieldName(int field)
		{
			switch (field)
			{
				case FieldExpression.ACTION:
					return stepActionId;


				case FieldExpression.CALLER:
					return stepCaller;


				case FieldExpression.FINISH_DATE:
					return stepFinishDate;


				case FieldExpression.OWNER:
					return stepOwner;


				case FieldExpression.START_DATE:
					return stepStartDate;


				case FieldExpression.STEP:
					return stepStepId;


				case FieldExpression.STATUS:
					return stepStatus;


				case FieldExpression.STATE:
					return entryState;


				case FieldExpression.NAME:
					return entryName;


				case FieldExpression.DUE_DATE:
					return stepDueDate;


				default:
					return "1";

			}
		}


		private String queryComparison(WorkflowQuery query)
		{
			Object value_Renamed = query.Value;
			int operator_Renamed = query.Operator;
			int field = query.Field;

			//int type = query.getType();
			String oper;

			switch (operator_Renamed)
			{
				case WorkflowQuery.EQUALS:
					oper = " = ";

					break;


				case WorkflowQuery.NOT_EQUALS:
					oper = " <> ";

					break;


				case WorkflowQuery.GT:
					oper = " > ";

					break;


				case WorkflowQuery.LT:
					oper = " < ";

					break;


				default:
					oper = " = ";
					break;

			}

			String left = fieldName(field);
			String right;

			if (value_Renamed != null)
			{
				//UPGRADE_TODO: The equivalent in .NET for method 'java.Object.toString' may return a different value. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1043"'
				right = "'" + escape(value_Renamed.ToString()) + "'";
			}
			else
			{
				right = "null";
			}

			return left + oper + right;
		}

		/// <summary> Method queryComparison
		/// *
		/// </summary>
		/// <param name="expression">         a  FieldExpression
		/// </param>
		/// <param name="sel">                a  StringBuffer
		/// *
		/// 
		/// </param>
		private void queryComparison(FieldExpression expression, StringBuilder sel, IList values)
		{
			Object value_Renamed = expression.Value;
			int operator_Renamed = expression.Operator;
			int field = expression.Field;

			String oper;

			switch (operator_Renamed)
			{
				case FieldExpression.EQUALS:

					if (value_Renamed == null)
					{
						oper = " IS ";
					}
					else
					{
						oper = " = ";
					}

					break;


				case FieldExpression.NOT_EQUALS:

					if (value_Renamed == null)
					{
						oper = " IS NOT ";
					}
					else
					{
						oper = " <> ";
					}

					break;


				case FieldExpression.GT:
					oper = " > ";

					break;


				case FieldExpression.LT:
					oper = " < ";

					break;


				default:
					oper = " = ";
					break;

			}

			String left = fieldName(field);
			String right = "?";

			switch (field)
			{
				case FieldExpression.FINISH_DATE:
					values.Add(new DateTime(((((DateTime) value_Renamed).Ticks - 621355968000000000)/10000) - (long) TimeZone.CurrentTimeZone.GetUtcOffset(((DateTime) value_Renamed)).TotalMilliseconds*10000L + 621355968000000000));

					break;


				case FieldExpression.START_DATE:
					values.Add(new DateTime(((((DateTime) value_Renamed).Ticks - 621355968000000000)/10000) - (long) TimeZone.CurrentTimeZone.GetUtcOffset(((DateTime) value_Renamed)).TotalMilliseconds*10000L + 621355968000000000));

					break;


				case FieldExpression.DUE_DATE:
					values.Add(new DateTime(((((DateTime) value_Renamed).Ticks - 621355968000000000)/10000) - (long) TimeZone.CurrentTimeZone.GetUtcOffset(((DateTime) value_Renamed)).TotalMilliseconds*10000L + 621355968000000000));

					break;


				default:

					if (value_Renamed == null)
					{
						right = "null";
					}
					else
					{
						values.Add(value_Renamed);
					}
					break;

			}

			sel.Append(left);
			sel.Append(oper);
			sel.Append(right);
		}

		private String queryWhere(WorkflowQuery query)
		{
			if (query.Left == null)
			{
				// leaf node
				return queryComparison(query);
			}
			else
			{
				int operator_Renamed = query.Operator;
				WorkflowQuery left = query.Left;
				WorkflowQuery right = query.Right;

				switch (operator_Renamed)
				{
					case WorkflowQuery.AND:
						return "(" + queryWhere(left) + " AND " + queryWhere(right) + ")";


					case WorkflowQuery.OR:
						return "(" + queryWhere(left) + " OR " + queryWhere(right) + ")";


					case WorkflowQuery.XOR:
						return "(" + queryWhere(left) + " XOR " + queryWhere(right) + ")";
				}
			}

			return ""; // not sure if we should throw an exception or how this should be handled
		}

		static AdoWorkflowStore()
		{
			log = LogManager.GetLogger(typeof (AdoWorkflowStore));
		}
	}
}