From 99035d83c371a03b176f85040c25b675ec14c269 Mon Sep 17 00:00:00 2001 From: Rich Date: Mon, 23 Jan 2012 13:42:32 +0000 Subject: [PATCH] extension methods for revision object of approval process --- .../Extension/RevisionInfoExt.cs | 1278 +++++++++++++++++ 1 file changed, 1278 insertions(+) create mode 100644 PROMS/VEPROMS.CSLA.Library/Extension/RevisionInfoExt.cs diff --git a/PROMS/VEPROMS.CSLA.Library/Extension/RevisionInfoExt.cs b/PROMS/VEPROMS.CSLA.Library/Extension/RevisionInfoExt.cs new file mode 100644 index 00000000..30612e90 --- /dev/null +++ b/PROMS/VEPROMS.CSLA.Library/Extension/RevisionInfoExt.cs @@ -0,0 +1,1278 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Csla; +using Csla.Data; +using Csla.Validation; +using System.Data.SqlClient; +using System.Data; +using Volian.Base.Library; +using System.ComponentModel; +using System.Xml; +using System.Xml.Serialization; +using System.Text.RegularExpressions; + +namespace VEPROMS.CSLA.Library +{ + public partial class ItemInfo + { + internal string _CheckXML; + public string CheckXML + { + get { return _CheckXML; } + set { _CheckXML = value; } + } + private ConsistencyChecks _MyDifferences; + public ConsistencyChecks MyDifferences + { + get + { + if (CheckXML == null) + { + return null; + } + if (_MyDifferences == null) + { + _MyDifferences = GenericSerializer.StringDeserialize(CheckXML); + } + return _MyDifferences; + } + } + private string _MyDifferenceReasons; + public string MyDifferenceReasons + { + get + { + _MyDifferenceReasons = string.Empty; + string sep = ""; + if (MyDifferences != null) + { + if (MyDifferences.ROConsistency.MyROChecks.Length > 0) + { + _MyDifferenceReasons += sep + "Reference Object"; + sep = ", "; + } + if (MyDifferences.TransitionConsistency.MyTransitionChecks.Length > 0) + { + _MyDifferenceReasons += sep + "Transition"; + sep = ", "; + } + if (MyDifferences.LibDocConsistency.MyLibDocChecks.Length > 0) + { + _MyDifferenceReasons += sep + "Library Document"; + } + } + if (_MyDifferenceReasons == string.Empty) + _MyDifferenceReasons = "No Differences Found"; + return _MyDifferenceReasons; + } + } + private string _MyDifferencesText; + public string MyDifferencesText + { + get + { + _MyDifferencesText = string.Empty; + StringBuilder sb = new StringBuilder(); + if (MyDifferences != null) + { + if (MyDifferences.ROConsistency.MyROChecks.Length > 0) + { + sb.Append("Reference Objects Differences:\r\n"); + ROFSTLookup lu = MyDocVersion.DocVersionAssociations[0].MyROFst.ROFSTLookup; + foreach (ROCheck roc in MyDifferences.ROConsistency.MyROChecks) + { + ROFSTLookup.rochild rocc = lu.GetRoChild12(roc.ROID); + if(rocc.type == 1) + sb.Append(string.Format(" {0} - Old Value: {1} - New Value: {2}\r\n", lu.GetROTitle(roc.ROID), roc.OldROValue, roc.ROValue)); + else + sb.Append(string.Format(" {0} - Value has changed.\r\n", lu.GetROTitle(roc.ROID))); + } + } +//jcb + if (MyDifferences.TransitionConsistency.MyTransitionChecks.Length > 0) + { + if (sb.Length > 0) + sb.AppendLine(); + sb.Append("Transition Differences:\r\n"); + foreach (TransitionCheck tc in MyDifferences.TransitionConsistency.MyTransitionChecks) + { + TransitionInfo tmp = TransitionInfo.Get(tc.TransitionID); + string tt = tmp.MyContent.ContentItems[0].Path; + string ov = ItemInfo.ConvertToDisplayText(tc.OldTransitionValue); + string nv = ItemInfo.ConvertToDisplayText(tc.TransitionValue); + sb.Append(string.Format(" From {0}\r\n", tt)); + sb.Append(string.Format(" Old To: {0}\r\n", ov)); + sb.Append(string.Format(" New To: {0}\r\n", nv)); + } + } +//end jcb + if (MyDifferences.LibDocConsistency.MyLibDocChecks.Length > 0) + { + if (sb.Length > 0) + sb.AppendLine(); + sb.Append("Library Document Differences:\r\n"); + foreach (LibDocCheck ldc in MyDifferences.LibDocConsistency.MyLibDocChecks) + { + DocumentInfo di = DocumentInfo.Get(ldc.DocID); + string libdoc = string.Format(" {0} - Old Date: {1} - New Date: {2}\r\n", di.DocumentTitle, ldc.OldDocDate.ToString(), ldc.DocDate.ToString()); + sb.Append(libdoc); + } + } + _MyDifferencesText = sb.ToString(); + } + if (_MyDifferencesText == string.Empty) + _MyDifferencesText = MyDifferenceReasons; + return _MyDifferencesText; + } + } + private bool _IsSelected = false; + public bool IsSelected + { + get { return _IsSelected; } + set { _IsSelected = value; } + } + } + public delegate void ItemInfoListCCEvent(object sender, ItemInfoListCCEventArgs args); + public class ItemInfoListCCEventArgs : EventArgs + { + private ProcedureInfo _MyProcedure; + + public ProcedureInfo MyProcedure + { + get { return _MyProcedure; } + set { _MyProcedure = value; } + } + private int _MyCount; + + public int MyCount + { + get { return _MyCount; } + set { _MyCount = value; } + } + public ItemInfoListCCEventArgs(ProcedureInfo myProcedure, int myCount) + { + _MyProcedure = myProcedure; + _MyCount = myCount; + } + } + public partial class ItemInfoList + { + public static event ItemInfoListCCEvent ConsistencyCheckUpdated; + private static void OnConsistencyCheckUpdated(object sender, ItemInfoListCCEventArgs args) + { + if (ConsistencyCheckUpdated != null) + ConsistencyCheckUpdated(sender, args); + } + public static ItemInfoList GetMoreProcedures(List procs) + { + StringBuilder sb = new StringBuilder(""); + int count = 1; + foreach (ProcedureInfo pi in procs) + { + OnConsistencyCheckUpdated(pi, new ItemInfoListCCEventArgs(pi, count++)); + string cc = RevisionInfo.BuildRevisionChecks(pi); + cc = Regex.Replace(cc, @"\<\?.*?\?\>", ""); + sb.Append(cc); + } + sb.Append(""); + OnConsistencyCheckUpdated(null, new ItemInfoListCCEventArgs(null, -1)); + try + { + ItemInfoList tmp = DataPortal.Fetch(new ItemListConsistencyCheckCriteria(procs[0].MyDocVersion.VersionID, sb.ToString())); + ItemInfo.AddList(tmp); + tmp.AddEvents(); + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on ItemInfoList.GetMoreProcedures", ex); + } + } + [Serializable()] + private class ItemListConsistencyCheckCriteria + { + private int _DocVersionID; + public int DocVersionID + { + get { return _DocVersionID; } + set { _DocVersionID = value; } + } + private string _CheckXML; + public string CheckXML + { + get { return _CheckXML; } + set { _CheckXML = value; } + } + public ItemListConsistencyCheckCriteria(int docVersionID, string checkXML) + { + _DocVersionID = docVersionID; + _CheckXML = checkXML; + } + } + private void DataPortal_Fetch(ItemListConsistencyCheckCriteria criteria) + { + this.RaiseListChangedEvents = false; + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "vesp_GetConsistencyCheckProcedures"; + cm.Parameters.AddWithValue("@DocVersionID", criteria.DocVersionID); + cm.Parameters.AddWithValue("@MyXml", criteria.CheckXML); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + while (dr.Read()) + { + ItemInfo itemInfo = null; + int itemType = dr.GetInt32("Type") / 10000; + switch (itemType) + { + case 0: + itemInfo = new ProcedureInfo(dr); + break; + case 1: + itemInfo = new SectionInfo(dr); + break; + default: + itemInfo = new StepInfo(dr); + break; + } + itemInfo.AddContent(dr); + itemInfo.CheckXML = dr.GetString("ChkXml"); + IsReadOnly = false; + this.Add(itemInfo); + IsReadOnly = true; + } + } + } + } + } + catch (Exception ex) + { + Database.LogException("ItemInfoList.DataPortal_Fetch", ex); + throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + //new for all procs + public static ItemInfoList GetAllInconsistencies(int docVersionID) + { + try + { + ItemInfoList tmp = DataPortal.Fetch(new ItemListAllInConsistenciesCriteria(docVersionID)); + ItemInfo.AddList(tmp); + tmp.AddEvents(); + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on ItemInfoList.GetAllInconsistencies", ex); + } + } + [Serializable()] + private class ItemListAllInConsistenciesCriteria + { + private int _DocVersionID; + public int DocVersionID + { + get { return _DocVersionID; } + set { _DocVersionID = value; } + } + public ItemListAllInConsistenciesCriteria(int docVersionID) + { + _DocVersionID = docVersionID; + } + } + private void DataPortal_Fetch(ItemListAllInConsistenciesCriteria criteria) + { + this.RaiseListChangedEvents = false; + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "vesp_GetAllConsistencyIssues"; + cm.Parameters.AddWithValue("@DocVersionID", criteria.DocVersionID); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + while (dr.Read()) + { + ItemInfo itemInfo = null; + int itemType = dr.GetInt32("Type") / 10000; + switch (itemType) + { + case 0: + itemInfo = new ProcedureInfo(dr); + break; + case 1: + itemInfo = new SectionInfo(dr); + break; + default: + itemInfo = new StepInfo(dr); + break; + } + itemInfo.AddContent(dr); + itemInfo.CheckXML = dr.GetString("ChkXml"); + IsReadOnly = false; + this.Add(itemInfo); + IsReadOnly = true; + } + } + } + } + } + catch (Exception ex) + { + Database.LogException("ItemInfoList.DataPortal_Fetch", ex); + throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + //end new for all procs + } + public partial class Revision + { + public static Revision GetByItemIDAndRevisionNumber(int itemID, string revisionNumber) + { + if (!CanGetObject()) + throw new System.Security.SecurityException("User not authorized to view a Revision"); + try + { + //Revision tmp = GetCachedByPrimaryKey(revisionID); + //if (tmp == null) + //{ + Revision tmp = DataPortal.Fetch(new ItemRevisionNumberCriteria(itemID, revisionNumber)); + // AddToCache(tmp); + //} + if (tmp.ErrorMessage == "No Record Found") + { + tmp.Dispose(); // Clean-up Revision + tmp = null; + } + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on Revision.GetByItemIDAndRevisionNumber", ex); + } + } + [Serializable()] + protected class ItemRevisionNumberCriteria + { + private int _ItemID; + public int ItemID + { get { return _ItemID; } } + private string _RevisionNumber; + public string RevisionNumber + { get { return _RevisionNumber; } } + public ItemRevisionNumberCriteria(int itemID, string revisionNumber) + { + _ItemID = itemID; + _RevisionNumber = revisionNumber; + } + } + private void DataPortal_Fetch(ItemRevisionNumberCriteria criteria) + { + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Revision.DataPortal_Fetch", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + ApplicationContext.LocalContext["cn"] = cn; + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getRevisionByItemIDandRevisionNumber"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + cm.Parameters.AddWithValue("@RevisionNumber", criteria.RevisionNumber); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + if (!dr.Read()) + { + _ErrorMessage = "No Record Found"; + return; + } + ReadData(dr); + // load child objects + dr.NextResult(); + _RevisionChecks = RevisionChecks.Get(dr); + // load child objects + dr.NextResult(); + _RevisionVersions = RevisionVersions.Get(dr); + } + } + // removing of item only needed for local data portal + if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client) + ApplicationContext.LocalContext.Remove("cn"); + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("Revision.DataPortal_Fetch", ex); + _ErrorMessage = ex.Message; + throw new DbCslaException("Revision.DataPortal_Fetch", ex); + } + } + } + public partial class RevisionInfoList + { + public static RevisionInfoList GetByItemID(int itemID) + { + try + { + //if (_RevisionInfoList != null) + // return _RevisionInfoList; + RevisionInfoList tmp = DataPortal.Fetch(new ItemCriteria(itemID)); + RevisionInfo.AddList(tmp); + tmp.AddEvents(); + //_RevisionInfoList = tmp; + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on RevisionInfoList.GetByItemID", ex); + } + } + [Serializable()] + protected class ItemCriteria + { + private int _ItemID; + public int ItemID + { get { return _ItemID; } } + public ItemCriteria(int itemID) + { + _ItemID = itemID; + } + } + private void DataPortal_Fetch(ItemCriteria criteria) + { + this.RaiseListChangedEvents = false; + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] RevisionInfoList.DataPortal_Fetch", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getRevisionsByItemID"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + IsReadOnly = false; + while (dr.Read()) this.Add(new RevisionInfo(dr)); + IsReadOnly = true; + } + } + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("RevisionInfoList.DataPortal_Fetch", ex); + throw new DbCslaException("RevisionInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + } + public partial class RevisionInfo + { + #region new bozo + [Serializable()] + protected class ItemCriteria + { + private int _ItemID; + public int ItemID + { get { return _ItemID; } } + public ItemCriteria(int itemID) + { + _ItemID = itemID; + } + } + [Serializable()] + protected class CurrentItemCriteria : ItemCriteria + { + public CurrentItemCriteria(int itemID) + : base(itemID) + { + } + } + [Serializable()] + protected class PreviousItemCriteria : ItemCriteria + { + public PreviousItemCriteria(int itemID) + : base(itemID) + { + } + } + public static RevisionInfo GetCurrentByItemID(int itemID) + { + try + { + //RevisionInfo tmp = GetCachedByPrimaryKey(revisionID); + //if (tmp == null) + //{ + // tmp = DataPortal.Fetch(new PKCriteria(revisionID)); + // AddToCache(tmp); + //} + RevisionInfo tmp = DataPortal.Fetch(new CurrentItemCriteria(itemID)); + if (tmp.ErrorMessage == "No Record Found") + { + tmp.Dispose(); // Clean-up RevisionInfo + tmp = null; + } + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on RevisionInfo.GetCurrentByItemID", ex); + } + } + public static RevisionInfo GetPreviousByItemID(int itemID) + { + try + { + //RevisionInfo tmp = GetCachedByPrimaryKey(revisionID); + //if (tmp == null) + //{ + // tmp = DataPortal.Fetch(new PKCriteria(revisionID)); + // AddToCache(tmp); + //} + RevisionInfo tmp = DataPortal.Fetch(new PreviousItemCriteria(itemID)); + if (tmp.ErrorMessage == "No Record Found") + { + tmp.Dispose(); // Clean-up RevisionInfo + tmp = null; + } + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on RevisionInfo.GetPreviousByItemID", ex); + } + } + private void DataPortal_Fetch(CurrentItemCriteria criteria) + { + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] RevisionInfo.DataPortal_Fetch", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + ApplicationContext.LocalContext["cn"] = cn; + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getCurrentRevisionByItemID"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + if (!dr.Read()) + { + _ErrorMessage = "No Record Found"; + return; + } + ReadData(dr); + } + } + // removing of item only needed for local data portal + if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client) + ApplicationContext.LocalContext.Remove("cn"); + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("RevisionInfo.DataPortal_Fetch", ex); + _ErrorMessage = ex.Message; + throw new DbCslaException("RevisionInfo.DataPortal_Fetch", ex); + } + } + private void DataPortal_Fetch(PreviousItemCriteria criteria) + { + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] RevisionInfo.DataPortal_Fetch", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + ApplicationContext.LocalContext["cn"] = cn; + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getPreviousRevisionByItemID"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + if (!dr.Read()) + { + _ErrorMessage = "No Record Found"; + return; + } + ReadData(dr); + } + } + // removing of item only needed for local data portal + if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client) + ApplicationContext.LocalContext.Remove("cn"); + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("RevisionInfo.DataPortal_Fetch", ex); + _ErrorMessage = ex.Message; + throw new DbCslaException("RevisionInfo.DataPortal_Fetch", ex); + } + } + #endregion + //jcb stuff + public VersionInfo LatestVersion + { + get + { + if (this.RevisionVersions.Count == 0) return null; + VersionInfo latest = this.RevisionVersions[0]; + foreach (VersionInfo vi in this.RevisionVersions) + { + if (vi.DTS > latest.DTS) + latest = vi; + } + return latest; + } + } + public override string ToString() + { + return string.Format("{0} Revision {1} on {2}", LatestVersion.MyStage.Name, this.RevisionNumber, this.RevisionDate.Value.ToShortDateString()); + } + public static string BuildRevisionChecks(ProcedureInfo proc) + { + ConsistencyChecks cc = new ConsistencyChecks(); + cc.ItemID = proc.ItemID; + BuildROChecks(cc, proc); + BuildTransitionFromChecks(cc, proc); + BuildTransitionToChecks(cc, proc); + BuildLibDocChecks(cc, proc); + return cc.ToString().Replace("OldDocDate=\"0001-01-01T00:00:00\"",""); + } + //end jcb stuff + private static void BuildROChecks(ConsistencyChecks cc, ProcedureInfo proc) + { + //grab all roids from rousages for this proc and children + List myROIDs = new List(); + //_MyTimer.ActiveProcess = "Build Distinct RO Usage List"; + using (RoUsageInfoList myList = RoUsageInfoList.GetAllForProcedure(proc)) + foreach (RoUsageInfo myRO in myList) + if (!myROIDs.Contains(myRO.ROID.ToUpper())) + myROIDs.Add(myRO.ROID.ToUpper()); + //create checkro record for each roid + //_MyTimer.ActiveProcess = "Get DocVersionInfo"; + DocVersionInfo dbi = proc.ActiveParent as DocVersionInfo; + //_MyTimer.ActiveProcess = "Get MyROFst"; + ROFstInfo rofst = ROFstInfo.GetJustROFst(dbi.DocVersionAssociations[0].ROFstID); + //_MyTimer.ActiveProcess = "Get ROFst Lookup"; + ROFSTLookup lookup = rofst.ROFSTLookup; + //_MyTimer.ActiveProcess = "Populating RevisionChecksXML table"; + cc.ROConsistency.ROFstDate = rofst.DTS; + foreach (string s in myROIDs) + cc.AddROCheck(s, ItemInfo.ConvertToDisplayText(lookup.GetRoValue(s))); + //_MyTimer.ActiveProcess = "External"; + } + private static void BuildTransitionFromChecks(ConsistencyChecks cc, ProcedureInfo proc) + { + using (TransitionInfoList myList = TransitionInfoList.GetAllForProcedure(proc, true)) + foreach (TransitionInfo myTI in myList) + { + //\v \v0 + string lookFor = string.Format(@"", myTI.TranType, myTI.TransitionID); + //string lookFor = string.Format(@"", tran.TranType, tran.TransitionID); + Match m = Regex.Match(myTI.ContentText, lookFor); + if (m != null && m.Groups.Count > 1) + { + System.Text.RegularExpressions.Group g = m.Groups[3]; + cc.AddTransitionFromCheck(myTI.TransitionID, g.ToString()); + } + //_MyTimer.ActiveProcess = "get from path"; + //string myPath = myTI.MyItemToID.ShortPath; + } + } + private static void BuildTransitionToChecks(ConsistencyChecks cc, ProcedureInfo proc) + { + using (TransitionInfoList myList = TransitionInfoList.GetAllForProcedure(proc, false)) + foreach (TransitionInfo myTI in myList) + { + string lookFor = string.Format(@"", myTI.TranType, myTI.TransitionID); + //string lookFor = string.Format(@"", tran.TranType, tran.TransitionID); + Match m = Regex.Match(myTI.ContentText, lookFor); + if (m != null && m.Groups.Count > 1) + { + System.Text.RegularExpressions.Group g = m.Groups[3]; + cc.AddTransitionToCheck(myTI.TransitionID, g.ToString()); + } + } + } + private static void BuildLibDocChecks(ConsistencyChecks cc, ProcedureInfo proc) + { + using (DocumentInfoList myList = DocumentInfoList.GetAllForProcedure(proc)) + foreach (DocumentInfo myDI in myList) + cc.AddLibDocCheck(myDI.DocID, myDI.DTS); + } + private static Volian.Base.Library.VlnTimer _MyTimer; + public static void SetupTimer() + { + _MyTimer = new Volian.Base.Library.VlnTimer(); + } + public static void ShowTimer() + { + _MyTimer.ShowElapsedTimes("BuildROChecks"); + } + } + public partial class RoUsageInfoList + { + [Serializable()] + private class AllForProcedureCriteria + { + public AllForProcedureCriteria(int itemID) + { + _ItemID = itemID; + } + private int _ItemID; + public int ItemID + { + get { return _ItemID; } + set { _ItemID = value; } + } + } + public static RoUsageInfoList GetAllForProcedure(ProcedureInfo proc) + { + try + { + RoUsageInfoList tmp = DataPortal.Fetch(new AllForProcedureCriteria(proc.ItemID)); + RoUsageInfo.AddList(tmp); + tmp.AddEvents(); + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on ROUsageInfoList.GetAllForProcedure", ex); + } + } + private void DataPortal_Fetch(AllForProcedureCriteria criteria) + { + this.RaiseListChangedEvents = false; + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ROUsageInfoList.DataPortal_FetchAllForProc", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getRoUsagesForProc"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + IsReadOnly = false; + while (dr.Read()) + this.Add(new RoUsageInfo(dr)); + IsReadOnly = true; + } + } + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("RoUsageInfoList.DataPortal_FetchAllForProc", ex); + throw new DbCslaException("ROUsageInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + } + public partial class TransitionInfo + { + internal string _ContentText; + public string ContentText + { + get { return _ContentText; } + set { _ContentText = value; } + } + } + public partial class TransitionInfoList + { + [Serializable()] + private class AllForProcedureCriteria + { + public AllForProcedureCriteria(int itemID, bool from) + { + _ItemID = itemID; + _From = from; + } + private int _ItemID; + public int ItemID + { + get { return _ItemID; } + set { _ItemID = value; } + } + private bool _From; + public bool From + { + get { return _From; } + set { _From = value; } + } + } + public static TransitionInfoList GetAllForProcedure(ProcedureInfo proc, bool from) + { + try + { + TransitionInfoList tmp = DataPortal.Fetch(new AllForProcedureCriteria(proc.ItemID, from)); + TransitionInfo.AddList(tmp); + tmp.AddEvents(); + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on TransitionInfoList.GetAllForProcedure", ex); + } + } + private void DataPortal_Fetch(AllForProcedureCriteria criteria) + { + this.RaiseListChangedEvents = false; + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] TransitionInfoList.DataPortal_FetchAllForProc", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + if(criteria.From) + cm.CommandText = "getTransitionsFromProc"; + else + cm.CommandText = "getTransitionsToProc"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + IsReadOnly = false; + while (dr.Read()) + { + TransitionInfo ti = new TransitionInfo(dr); + ti.ContentText = dr.GetString("ContentText"); + this.Add(ti); + } + IsReadOnly = true; + } + } + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("TransitionInfoList.DataPortal_FetchAllForProc", ex); + throw new DbCslaException("TransitionInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + } + public partial class DocumentInfoList + { + [Serializable()] + private class AllForProcedureCriteria + { + public AllForProcedureCriteria(int itemID) + { + _ItemID = itemID; + } + private int _ItemID; + public int ItemID + { + get { return _ItemID; } + set { _ItemID = value; } + } + } + public static DocumentInfoList GetAllForProcedure(ProcedureInfo proc) + { + try + { + DocumentInfoList tmp = DataPortal.Fetch(new AllForProcedureCriteria(proc.ItemID)); + DocumentInfo.AddList(tmp); + tmp.AddEvents(); + return tmp; + } + catch (Exception ex) + { + throw new DbCslaException("Error on DocumentInfoList.GetAllForProcedure", ex); + } + } + private void DataPortal_Fetch(AllForProcedureCriteria criteria) + { + this.RaiseListChangedEvents = false; + if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] DocumentInfoList.DataPortal_FetchAllForProc", GetHashCode()); + try + { + using (SqlConnection cn = Database.VEPROMS_SqlConnection) + { + using (SqlCommand cm = cn.CreateCommand()) + { + cm.CommandType = CommandType.StoredProcedure; + cm.CommandText = "getLibDocsForProc"; + cm.Parameters.AddWithValue("@ItemID", criteria.ItemID); + + using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader())) + { + IsReadOnly = false; + while (dr.Read()) + this.Add(new DocumentInfo(dr)); + IsReadOnly = true; + } + } + } + } + catch (Exception ex) + { + if (_MyLog.IsErrorEnabled) _MyLog.Error("DocumentInfoList.DataPortal_FetchAllForProc", ex); + throw new DbCslaException("DocumentInfoList.DataPortal_Fetch", ex); + } + this.RaiseListChangedEvents = true; + } + } + [Serializable] + [XmlRoot("ConsistencyChecks")] + public class ConsistencyChecks + { + public static ConsistencyChecks Get(string xml) + { + return GenericSerializer.StringDeserialize(xml); + } + public override string ToString() + { + return GenericSerializer.StringSerialize(this); + } + private int _ItemID; + [XmlAttribute("ItemID")] + public int ItemID + { + get { return _ItemID; } + set { _ItemID = value; } + } + private ROConsistency _ROConsistency = new ROConsistency(); + [XmlElement("ROChecks")] + [Category("Referenced Objects")] + [Description("RO Consistency Data")] + [DisplayName("RO Consistency")] + public ROConsistency ROConsistency + { + get { return _ROConsistency; } + set { _ROConsistency = value; } + } + public void AddROCheck(string roid, string roValue) + { + ROConsistency.AddROCheck(roid, roValue); + } + + private TransitionConsistency _TransitionFromConsistency = new TransitionConsistency(); + [XmlElement("TransitionFromChecks")] + [Category("Transitions")] + [Description("Transition From Consistency Data")] + [DisplayName("Transition From Consistency")] + public TransitionConsistency TransitionFromConsistency + { + get { return _TransitionFromConsistency; } + set { _TransitionFromConsistency = value; } + } + public void AddTransitionFromCheck(int transitionid, string transitionValue) + { + TransitionFromConsistency.AddTransitionCheck(transitionid, transitionValue); + } + private TransitionConsistency _TransitionToConsistency = new TransitionConsistency(); + [XmlElement("TransitionToChecks")] + [Category("Transitions")] + [Description("Transition To Consistency Data")] + [DisplayName("Transition To Consistency")] + public TransitionConsistency TransitionToConsistency + { + get { return _TransitionToConsistency; } + set { _TransitionToConsistency = value; } + } + public void AddTransitionToCheck(int transitionid, string transitionValue) + { + TransitionToConsistency.AddTransitionCheck(transitionid, transitionValue); + } + private TransitionConsistency _TransitionConsistency = new TransitionConsistency(); + [XmlElement("TransitionChecks")] + [Category("Transitions")] + [Description("Transition Consistency Data")] + [DisplayName("Transition Consistency")] + public TransitionConsistency TransitionConsistency + { + get { return _TransitionConsistency; } + set { _TransitionConsistency = value; } + } + + private LibDocConsistency _LibDocConsistency = new LibDocConsistency(); + [XmlElement("LibDocChecks")] + [Category("Library Documents")] + [Description("Lib Doc Consistency Data")] + [DisplayName("Lib Doc Consistency")] + public LibDocConsistency LibDocConsistency + { + get { return _LibDocConsistency; } + set { _LibDocConsistency = value; } + } + public void AddLibDocCheck(int docid, DateTime docdate) + { + LibDocConsistency.AddLibDocCheck(docid, docdate); + } + } + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class ROConsistency + { + private DateTime _ROFstDate = DateTime.Now; + [XmlAttribute("ROFstDate")] + [Description("Date ROFst Generated")] + [DisplayName("ROFst Date")] + public DateTime ROFstDate + { + get { return _ROFstDate; } + set { _ROFstDate = value; } + } + private SortedDictionary _ROCheckList = new SortedDictionary(); + [XmlElement("ROCheck")] + [Description("RO Data")] + [DisplayName("RO Data")] + public ROCheck[] MyROChecks + { + get + { + ROCheck[] ros = new ROCheck[_ROCheckList.Count]; + _ROCheckList.Values.CopyTo(ros, 0); + return ros; + } + set + { + _ROCheckList = new SortedDictionary(); + foreach (ROCheck ro in value) + _ROCheckList.Add(ro.ROID, ro); + } + } + public void AddROCheck(string roid, string roValue) + { + if (!_ROCheckList.ContainsKey(roid)) + _ROCheckList.Add(roid, new ROCheck(roid, roValue)); + } + public override string ToString() + { + return string.Format("{0} ROs", _ROCheckList.Count); + } + } + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class ROCheck + { + private string _ROID; + [XmlAttribute("ROID")] + [Description("RO Unique ID")] + public string ROID + { + get { return _ROID; } + set { _ROID = value; } + } + private string _ROValue; + [XmlAttribute("ROValue")] + [Description("RO Value")] + public string ROValue + { + get { return _ROValue; } + set { _ROValue = value; } + } + private string _OldROValue; + [XmlAttribute("OldROValue")] + [Description("Old RO Value")] + public string OldROValue + { + get { return _OldROValue; } + set { _OldROValue = value; } + } + public ROCheck(string roid, string rovalue) + { + _ROID = roid; + _ROValue = rovalue; + } + public ROCheck() + { + } + public override string ToString() + { + return string.Format("{0} - '{1}'", ROID, ROValue); + } + } + + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class TransitionConsistency + { + private SortedDictionary _TransitionCheckList = new SortedDictionary(); + [XmlElement("TransitionCheck")] + [Description("Transition Data")] + [DisplayName("Transition Data")] + public TransitionCheck[] MyTransitionChecks + { + get + { + TransitionCheck[] ts = new TransitionCheck[_TransitionCheckList.Count]; + _TransitionCheckList.Values.CopyTo(ts, 0); + return ts; + } + set + { + _TransitionCheckList = new SortedDictionary(); + foreach (TransitionCheck tc in value) + _TransitionCheckList.Add(tc.TransitionID, tc); + } + } + public void AddTransitionCheck(int transitionid, string transitionValue) + { + if (!_TransitionCheckList.ContainsKey(transitionid)) + _TransitionCheckList.Add(transitionid, new TransitionCheck(transitionid, transitionValue)); + } + public override string ToString() + { + return string.Format("{0} Transitions", _TransitionCheckList.Count); + } + } + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class TransitionCheck + { + private int _TransitionID; + [XmlAttribute("TransitionID")] + [Description("Transition Unique ID")] + public int TransitionID + { + get { return _TransitionID; } + set { _TransitionID = value; } + } + private string _TransitionValue; + [XmlAttribute("TransitionValue")] + [Description("Transition Value")] + public string TransitionValue + { + get { return _TransitionValue; } + set { _TransitionValue = value; } + } + private string _OldTransitionValue; + [XmlAttribute("OldTransitionValue")] + [Description("Old Transition Value")] + public string OldTransitionValue + { + get { return _OldTransitionValue; } + set { _OldTransitionValue = value; } + } + public TransitionCheck(int transitionid, string transitionvalue) + { + _TransitionID = transitionid; + _TransitionValue = transitionvalue; + } + public TransitionCheck() + { + } + public override string ToString() + { + return string.Format("{0} - '{1}'", TransitionID, TransitionValue); + } + } + + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class LibDocConsistency + { + private SortedDictionary _LibDocCheckList = new SortedDictionary(); + [XmlElement("LibDocCheck")] + [Description("LibDoc Data")] + [DisplayName("LibDoc Data")] + public LibDocCheck[] MyLibDocChecks + { + get + { + LibDocCheck[] lds = new LibDocCheck[_LibDocCheckList.Count]; + _LibDocCheckList.Values.CopyTo(lds, 0); + return lds; + } + set + { + _LibDocCheckList = new SortedDictionary(); + foreach (LibDocCheck ld in value) + _LibDocCheckList.Add(ld.DocID, ld); + } + } + public void AddLibDocCheck(int docid, DateTime docDate) + { + if (!_LibDocCheckList.ContainsKey(docid)) + _LibDocCheckList.Add(docid, new LibDocCheck(docid, docDate)); + } + public override string ToString() + { + return string.Format("{0} LibDocs", _LibDocCheckList.Count); + } + } + [Serializable] + [TypeConverter(typeof(ExpandableObjectConverter))] + public class LibDocCheck + { + private int _DocID; + [XmlAttribute("DocID")] + [Description("Lib Doc Unique ID")] + public int DocID + { + get { return _DocID; } + set { _DocID = value; } + } + private DateTime _DocDate; + [XmlAttribute("DocDate")] + [Description("Lib Doc Date")] + public DateTime DocDate + { + get { return _DocDate; } + set { _DocDate = value; } + } + private DateTime _OldDocDate; + [XmlAttribute("OldDocDate")] + [Description("Old Lib Doc Date")] + public DateTime OldDocDate + { + get + { + //if (_OldDocDate == DateTime.MinValue) + // return null; + return _OldDocDate; + } + set + { + //if (value == null) + // _OldDocDate = DateTime.MinValue; + //else + // _OldDocDate = value.Value; + _OldDocDate = value; + } + } + public LibDocCheck(int docid, DateTime docdate) + { + _DocID = docid; + _DocDate = docdate; + } + public LibDocCheck() + { + } + public override string ToString() + { + return string.Format("{0} - '{1}'", DocID, DocDate); + } + } + public enum Rev_Types : int + { + Revision = 1, TempMod = 2 + } + +}