diff --git a/PROMS/VEPROMS.CSLA.Library/Generated/Database.cs b/PROMS/VEPROMS.CSLA.Library/Generated/Database.cs
index 6e406c34..0d05942c 100644
--- a/PROMS/VEPROMS.CSLA.Library/Generated/Database.cs
+++ b/PROMS/VEPROMS.CSLA.Library/Generated/Database.cs
@@ -17,6 +17,8 @@ using System.Configuration;
 using System.IO;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Collections.Generic;
+
 namespace VEPROMS.CSLA.Library
 {
 	/// <summary>
@@ -253,4 +255,312 @@ namespace VEPROMS.CSLA.Library
 		internal DbCslaException(string message) : base(message) { ;}
 		internal DbCslaException() : base() { ;}
 	} // Class
+	#region commandbase object jcb
+	[Serializable()]
+	public class PurgeDataCommand : CommandBase
+	{
+		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+		private int _RowsAffected;
+		public int RowsAffected
+		{
+			get { return _RowsAffected; }
+			set { _RowsAffected = value; }
+		}
+		#region Factory Methods
+		public static int Execute()
+		{
+			PurgeDataCommand cmd = new PurgeDataCommand();
+			cmd = DataPortal.Execute<PurgeDataCommand>(cmd);
+			return cmd.RowsAffected;
+		}
+		private PurgeDataCommand()
+		{ /* require use of factory methods */ }
+		#endregion
+		#region Server-Side code
+		protected override void DataPortal_Execute()
+		{
+			try
+			{
+				//SqlConnection cn = VEPROMS_SqlConnection;
+				//SqlCommand cmd = new SqlCommand("purgedata", cn);
+				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
+				{
+					using (SqlCommand cmd = new SqlCommand("purgedata", cn))
+					{
+						cmd.CommandType = CommandType.StoredProcedure;
+						cmd.CommandTimeout = 0;
+						RowsAffected = cmd.ExecuteNonQuery();
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				if (_MyLog.IsErrorEnabled) _MyLog.Error("Purge Error", ex);
+				throw new ApplicationException("Failure on Purge", ex);
+			}
+		}
+		#endregion
+	}
+	[Serializable()]
+	public class CanTransitionBeCreatedCommand : CommandBase
+	{
+		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+		private string _ErrorMessage = string.Empty;
+		public string ErrorMessage
+		{
+			get { return _ErrorMessage; }
+		}
+		private ProposedTransition _ProposedTransition;
+		public ProposedTransition ProposedTransition
+		{
+			get { return _ProposedTransition; }
+			set { _ProposedTransition = value; }
+		}
+		private int _FromID;
+		public int FromID
+		{
+			get { return _FromID; }
+			set { _FromID = value; }
+		}
+		private int _ToID;
+		public int ToID
+		{
+			get { return _ToID; }
+			set { _ToID = value; }
+		}
+		#region Factory Methods
+		public static ProposedTransition Execute(int fromID, int toID)
+		{
+			CanTransitionBeCreatedCommand cmd = new CanTransitionBeCreatedCommand();
+			cmd.FromID = fromID;
+			cmd.ToID = toID;
+			cmd = DataPortal.Execute<CanTransitionBeCreatedCommand>(cmd);
+			return cmd.ProposedTransition;
+		}
+		private CanTransitionBeCreatedCommand()
+		{ /* require use of factory methods */ }
+		#endregion
+		#region Server-Side code
+		private void ReadData(SafeDataReader dr)
+		{
+			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] CanTransitionBeCreatedCommand.ReadData", GetHashCode());
+			try
+			{
+				_ProposedTransition = new ProposedTransition(dr.GetInt32("status"), dr.GetString("fromappl"), dr.GetString("toappl"), dr.GetString("fromstep"), dr.GetString("tostep"));
+			}
+			catch (Exception ex)
+			{
+				if (_MyLog.IsErrorEnabled) _MyLog.Error("Detail.ReadData", ex);
+				_ErrorMessage = ex.Message;
+				throw new DbCslaException("CanTransitionBeCreatedCommand.ReadData", ex);
+			}
+		}
+		protected override void DataPortal_Execute()
+		{
+			try
+			{
+				//SqlConnection cn = VEPROMS_SqlConnection;
+				//SqlCommand cmd = new SqlCommand("purgedata", cn);
+				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
+				{
+					using (SqlCommand cmd = new SqlCommand("vesp_CanTransitionBeCreated", cn))
+					{
+						cmd.CommandType = CommandType.StoredProcedure;
+						cmd.Parameters.AddWithValue("fromItemID", _FromID);
+						cmd.Parameters.AddWithValue("toItemID", _ToID);
+						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
+						{
+							if (!dr.Read())
+							{
+								_ErrorMessage = "No Record Found";
+								return;
+							}
+							ReadData(dr);
+						}
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				if (_MyLog.IsErrorEnabled) _MyLog.Error("CanTransitionBeCreatedCommand Error", ex);
+				throw new ApplicationException("Failure on CanTransitionBeCreatedCommand", ex);
+			}
+		}
+		#endregion
+	}
+	[Serializable()]
+	public class WillTransitionsBeValidCommand : CommandBase
+	{
+		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+		private string _ErrorMessage = string.Empty;
+		public string ErrorMessage
+		{
+			get { return _ErrorMessage; }
+		}
+		private List<InvalidTransition> _InvalidTransitions;
+		public List<InvalidTransition> InvalidTransitions
+		{
+			get { return _InvalidTransitions; }
+		}
+		private int _ItemID;
+		public int ItemID
+		{
+			get { return _ItemID; }
+			set { _ItemID = value; }
+		}
+		private string _NewAppl;
+		public string NewAppl
+		{
+			get { return _NewAppl; }
+			set { _NewAppl = value; }
+		}
+		#region Factory Methods
+		public static List<InvalidTransition> Execute(int itemID, string newAppl)
+		{
+			WillTransitionsBeValidCommand cmd = new WillTransitionsBeValidCommand();
+			cmd.ItemID = itemID;
+			cmd.NewAppl = newAppl;
+			cmd = DataPortal.Execute<WillTransitionsBeValidCommand>(cmd);
+			return cmd.InvalidTransitions;
+		}
+		private WillTransitionsBeValidCommand()
+		{ /* require use of factory methods */ }
+		#endregion
+		#region Server-Side code
+		private void ReadData(SafeDataReader dr)
+		{
+			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Detail.ReadData", GetHashCode());
+			try
+			{
+				do
+				{
+					_InvalidTransitions.Add(new InvalidTransition(dr.GetInt32("myitemid"), dr.GetString("srcappl"), dr.GetString("tgtappl"), dr.GetString("srcstep"), dr.GetString("tgtstep")));
+				} while (dr.Read());
+			}
+			catch (Exception ex)
+			{
+				if (_MyLog.IsErrorEnabled) _MyLog.Error("WillTransitionsBeValidCommand.ReadData", ex);
+				_ErrorMessage = ex.Message;
+				throw new DbCslaException("WillTransitionsBeValidCommand.ReadData", ex);
+			}
+		}
+		protected override void DataPortal_Execute()
+		{
+			try
+			{
+				//SqlConnection cn = VEPROMS_SqlConnection;
+				//SqlCommand cmd = new SqlCommand("purgedata", cn);
+				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
+				{
+					using (SqlCommand cmd = new SqlCommand("vesp_WillTransitionsBeValid", cn))
+					{
+						cmd.CommandType = CommandType.StoredProcedure;
+						cmd.Parameters.AddWithValue("ItemID", _ItemID);
+						cmd.Parameters.AddWithValue("NewAppl", _NewAppl);
+						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
+						{
+							_InvalidTransitions = new List<InvalidTransition>();
+							if (!dr.Read())
+							{
+								_ErrorMessage = "No Record Found";
+								return;
+							}
+							ReadData(dr);
+						}
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				if (_MyLog.IsErrorEnabled) _MyLog.Error("WillTransitionsBeValidCommand Error", ex);
+				throw new ApplicationException("Failure on WillTransitionsBeValidCommand", ex);
+			}
+		}
+		#endregion
+	}
+	[Serializable()]
+	public class InvalidTransition
+	{
+		private int _MyItemID;
+		public int MyItemID
+		{
+			get { return _MyItemID; }
+			set { _MyItemID = value; }
+		}
+		private string _SrcAppl;
+		public string SrcAppl
+		{
+			get { return _SrcAppl; }
+			set { _SrcAppl = value; }
+		}
+		private string _TgtAppl;
+		public string TgtAppl
+		{
+			get { return _TgtAppl; }
+			set { _TgtAppl = value; }
+		}
+		private string _SrcStep;
+		public string SrcStep
+		{
+			get { return _SrcStep; }
+			set { _SrcStep = value; }
+		}
+		private string _TgtStep;
+		public string TgtStep
+		{
+			get { return _TgtStep; }
+			set { _TgtStep = value; }
+		}
+		public InvalidTransition(int myItemID, string srcAppl, string tgtAppl, string srcStep, string tgtStep)
+		{
+			_MyItemID = myItemID;
+			_SrcAppl = srcAppl;
+			_TgtAppl = tgtAppl;
+			_SrcStep = srcStep;
+			_TgtStep = tgtStep;
+		}
+	}
+	[Serializable()]
+	public class ProposedTransition
+	{
+		private int _Status;
+		public int Status
+		{
+			get { return _Status; }
+			set { _Status = value; }
+		}
+		private string _FromAppl;
+		public string FromAppl
+		{
+			get { return _FromAppl; }
+			set { _FromAppl = value; }
+		}
+		private string _ToAppl;
+		public string ToAppl
+		{
+			get { return _ToAppl; }
+			set { _ToAppl = value; }
+		}
+		private string _FromStep;
+		public string FromStep
+		{
+			get { return _FromStep; }
+			set { _FromStep = value; }
+		}
+		private string _ToStep;
+		public string ToStep
+		{
+			get { return _ToStep; }
+			set { _ToStep = value; }
+		}
+		public ProposedTransition(int status, string fromAppl, string toAppl, string fromStep, string toStep)
+		{
+			_Status = status;
+			_FromAppl = fromAppl;
+			_ToAppl = toAppl;
+			_FromStep = fromStep;
+			_ToStep = toStep;
+		}
+	}
+	#endregion
 } // Namespace
diff --git a/PROMS/VEPROMS.CSLA.Library/VEObjects/VETreeNode.cs b/PROMS/VEPROMS.CSLA.Library/VEObjects/VETreeNode.cs
index 3e5a490a..6f3eb9d1 100644
--- a/PROMS/VEPROMS.CSLA.Library/VEObjects/VETreeNode.cs
+++ b/PROMS/VEPROMS.CSLA.Library/VEObjects/VETreeNode.cs
@@ -375,6 +375,13 @@ namespace VEPROMS.CSLA.Library
 		{
 			Text = _VEObject.ToString();
 			ItemInfo myItemInfo = _VEObject as ItemInfo;
+			if (myItemInfo != null && myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave > 0)
+			{
+				int k = myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave;
+				myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
+				Text = myItemInfo.ToString();
+				myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave = k;
+			}
 			if (myItemInfo != null && myItemInfo.IsSection)
 			{
 				myItemInfo.RefreshConfig();
diff --git a/PROMS/Volian.Base.Library/BigNum.cs b/PROMS/Volian.Base.Library/BigNum.cs
new file mode 100644
index 00000000..1567917a
--- /dev/null
+++ b/PROMS/Volian.Base.Library/BigNum.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace Volian.Base.Library
+{
+	[Serializable()]
+	//[XmlRoot("BigNum")]
+	public class BigNum
+	{
+		#region fields
+		private SortedDictionary<uint, ulong> _MyValue = new SortedDictionary<uint, ulong>();
+		private const ulong one = 1;
+		private SortedDictionary<uint, ulong> MyValue
+		{
+			get { return _MyValue; }
+			set { _MyValue = value; }
+		}
+		#endregion
+		#region constructors
+		public BigNum()
+		{
+		}
+		public BigNum(int value)
+		{
+			SetFlag(value);
+		}
+		public BigNum(string values)
+		{
+			SetFlags(values);
+		}
+		public BigNum(ICollection<int> values)
+		{
+			SetFlags(values);
+		}
+		public override string ToString()
+		{
+			return FlagList;
+		}
+		#endregion
+		#region operators
+		public static BigNum operator |(BigNum bn1, BigNum bn2)
+		{
+			BigNum bn = new BigNum(bn1.GetFlags());
+			bn.SetFlags(bn2.GetFlags());
+			return bn;
+		}
+		public static BigNum operator &(BigNum bn1, BigNum bn2)
+		{
+			BigNum bn = new BigNum(0);
+			foreach (uint k1 in bn1.MyValue.Keys)
+			{
+				if (bn2.MyValue.ContainsKey(k1) && (bn1.MyValue[k1] & bn2.MyValue[k1]) != 0)
+					bn.MyValue[k1] = (bn1.MyValue[k1] & bn2.MyValue[k1]);
+			}
+			return bn;
+		}
+		#endregion
+		#region methods
+		//public override string ToString()
+		//{
+		//  return GenericSerializer<BigNum>.StringSerialize(this);
+		//}
+		public bool Includes(BigNum other)
+		{
+			List<int> mine = GetFlags();
+			if (mine.Count == 0) return true;
+			List<int> yours = other.GetFlags();
+			if (yours.Count == 0) return false;
+			foreach (int y in yours)
+				if (mine.Contains(y)) return false;
+			return true;
+		}
+		public void SetFlags(string values)
+		{
+			if (values == string.Empty) return;
+			string[] myvalues = values.Split(',');
+			foreach (string v in myvalues)
+				SetFlag(int.Parse(v));
+		}
+		public List<int> GetFlags()
+		{
+			List<int> myints = new List<int>();
+			//if (MyValue.Count == 0)//1 && MyValue.ContainsKey(0) && MyValue[0] == 0)
+			//{
+			//  myints.Add(-1);
+			//}
+			//else
+			//{
+				foreach (uint key in MyValue.Keys)
+				{
+					ulong y = MyValue[key];
+					for (int i = 0; i < 64; i++)
+					{
+						if (((y >> i) & one) == one)
+							myints.Add((int)(i + (key * 64)));
+					}
+				}
+			//}
+			return myints;
+		}
+		public void SetFlag(int flag)
+		{
+			//if (flag == -1)
+			//{
+			//  MyValue = new SortedDictionary<uint, ulong>();
+			//  //MyValue.Add(0, 0);
+			//}
+			//else
+			//{
+				uint offset = (uint)(flag / 64);
+				ulong x = one << (flag % 64);
+				if (MyValue.ContainsKey(offset))
+					MyValue[offset] |= x;
+				else
+					MyValue.Add(offset, x);
+			//}
+		}
+		public void SetFlags(ICollection<int> flags)
+		{
+			foreach (int f in flags)
+				SetFlag(f);
+		}
+		public static BigNum MakeBigNum(string numbers)
+		{
+			if (numbers == "-1")
+				return null;
+			return new BigNum(numbers);
+		}
+		#endregion
+		#region properties
+		[XmlAttribute]
+		public string FlagList
+		{
+			get
+			{
+				StringBuilder sb = new StringBuilder();
+				string sep = "";
+				foreach (int i in GetFlags())
+				{
+					sb.Append(sep + i.ToString());
+					sep = ",";
+				}
+				return sb.ToString();
+			}
+			set { SetFlags(value); }
+		}
+		#endregion
+	}
+}