2094 lines
57 KiB
C#
2094 lines
57 KiB
C#
#define ItemWithContent
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using Csla;
|
|
using Csla.Data;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Xml;
|
|
using System.Drawing;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace VEPROMS.CSLA.Library
|
|
{
|
|
#region Item
|
|
public partial class Item : IVEDrillDown
|
|
{
|
|
public static void ShowAllocated(string title)
|
|
{
|
|
Console.WriteLine("{0} - {1} Items in the dictionary", title, _CacheByPrimaryKey.Count);
|
|
foreach (List<Item> itmlst in _CacheByPrimaryKey.Values)
|
|
foreach(Item itm in itmlst)
|
|
Console.WriteLine("Item {0} UniqueID {1}", itm.ItemID, itm.MyItemUnique);
|
|
Console.WriteLine("- - - - - -");
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} {1}", MyContent.Number, MyContent.Text).Trim();
|
|
}
|
|
// TODO: Move to ItemInfo Extension
|
|
|
|
#region IVEDrillDown
|
|
public System.Collections.IList GetChildren()
|
|
{
|
|
return this.MyContent.ContentParts;
|
|
}
|
|
public bool HasChildren
|
|
{
|
|
get { return this.MyContent.ContentPartCount > 0; }
|
|
}
|
|
public Item MyProcedure
|
|
{
|
|
get
|
|
{
|
|
// Walk up active parents until the parent is not an item
|
|
Item tmp = this;
|
|
while (tmp.ActiveParent.GetType() != typeof(DocVersion)) tmp = (Item)tmp.ActiveParent;
|
|
return tmp;
|
|
}
|
|
} private IVEDrillDown _ActiveParent = null;
|
|
public IVEDrillDown ActiveParent
|
|
{
|
|
get
|
|
{
|
|
if (_ActiveParent == null)
|
|
{
|
|
if (MyPrevious != null)
|
|
_ActiveParent = _MyPrevious.ActiveParent;
|
|
else
|
|
{
|
|
if (ItemDocVersionCount > 0)
|
|
_ActiveParent = this.ItemDocVersions[0].MyDocVersion;
|
|
else
|
|
{
|
|
if (this.ItemParts == null || this.ItemPartCount == 0)
|
|
_ActiveParent = this;
|
|
else
|
|
_ActiveParent = this.ItemParts[0].MyContent.ContentItems[0].MyItem;
|
|
}
|
|
}
|
|
}
|
|
return _ActiveParent == this ? null : _ActiveParent;
|
|
}
|
|
}
|
|
private Format _ActiveFormat = null;// Added to cache ActiveFormat
|
|
public Format ActiveFormat
|
|
{
|
|
get
|
|
{
|
|
if (_ActiveFormat == null)
|
|
_ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
|
|
return _ActiveFormat;
|
|
}
|
|
set
|
|
{
|
|
_ActiveFormat = null; // Reset
|
|
}
|
|
}
|
|
public Format LocalFormat
|
|
{
|
|
get { return MyContent.MyFormat; }
|
|
}
|
|
public ConfigDynamicTypeDescriptor MyConfig
|
|
{
|
|
get { return null; }
|
|
}
|
|
#endregion
|
|
public void MoveItem(IVEDrillDownReadOnly pInfo, int index)
|
|
{
|
|
bool wasfirstchild = false;
|
|
ItemInfo parentInfo = pInfo as ItemInfo;
|
|
DocVersionInfo parentInfoDV = pInfo as DocVersionInfo;
|
|
IList<ItemInfo> children = null;
|
|
E_FromType partType = 0; // this is needed later to determine sub-group type.
|
|
if (parentInfo != null)
|
|
{
|
|
// this may have subgroups, need to use part type to get children list...
|
|
ItemInfo thisinfo = ItemInfo.Get(ItemID);
|
|
partType = thisinfo.FirstSibling.ItemParts[0].PartType;
|
|
children = (IList<ItemInfo>)parentInfo.Lookup((int)partType);
|
|
}
|
|
else
|
|
children = (IList<ItemInfo>)parentInfoDV.GetChildren();
|
|
int numChild = children.Count;
|
|
|
|
if (this.MyPrevious == null) wasfirstchild = true;
|
|
Item origNextItem = null;
|
|
|
|
// First, remove from this item from its list. To do this, get the current item's next point and redirect it's myprevious
|
|
// to this item's previous...
|
|
if (NextItems != null && NextItems.Count > 0)
|
|
{
|
|
origNextItem = NextItems.Items[0];
|
|
origNextItem.MyPrevious = this.MyPrevious;
|
|
this.Save();
|
|
}
|
|
|
|
// check to see if the item is being moved into the middle of some items. newPreviousItem is the item defined
|
|
// by index-1, i.e. inserting below newPreviousItem.
|
|
ItemInfo newPreviousInfo = (index == 0) ? null : children[index - 1];
|
|
ItemInfo newNextInfo = (index == children.Count) ? null : children[index];
|
|
|
|
// Adjust the new next proc to be me.
|
|
if (newNextInfo != null)
|
|
{
|
|
using (Item newNextItem = newNextInfo.Get())
|
|
{
|
|
newNextItem.MyPrevious = this;
|
|
newNextItem.Save().Dispose();
|
|
}
|
|
}
|
|
|
|
// adjust the previous node, i.e. may either be at same level or, if first in list, adjust the parent...
|
|
// if 'newPreviousItem' isn't null, then adding to the middle of the list.
|
|
if (newPreviousInfo != null)
|
|
{
|
|
using (Item newPreviousItem = newPreviousInfo.Get())
|
|
{
|
|
MyPrevious = newPreviousItem;
|
|
Save();
|
|
}
|
|
}
|
|
// newPreviousInfo == null if moving into first child, and wasfirstchild == true if moving out of first child.
|
|
// This will require adjusting the DocVersion to point to the correct first child if a procedure is moved.
|
|
if (newPreviousInfo == null || wasfirstchild)
|
|
{
|
|
if (parentInfo != null) // Moving Item within procedure, i.e. moving a section or step
|
|
{
|
|
using (Item parentItem = parentInfo.Get())
|
|
{
|
|
// moving first child out... reset parent to point to the original next item
|
|
if (wasfirstchild)
|
|
parentItem.MyContent.ContentParts[(int)partType].MyItem = origNextItem;
|
|
else
|
|
parentItem.MyContent.ContentParts[(int)partType].MyItem = this;
|
|
parentItem.Save().Dispose();
|
|
}
|
|
}
|
|
else if (parentInfoDV != null) // Moving Item (Procedure) within DocVersion
|
|
{
|
|
using (DocVersion parentItemDV = parentInfoDV.Get())
|
|
{
|
|
ItemInfo firstinfo = parentInfoDV.FirstChild();
|
|
parentItemDV.MyItem = wasfirstchild?parentInfoDV.Procedures[1].Get():this;
|
|
parentItemDV.Save().Dispose();
|
|
if (!wasfirstchild && firstinfo != null)
|
|
{
|
|
using (Item firstchild = firstinfo.Get())
|
|
{
|
|
firstchild.MyPrevious = this;
|
|
firstchild.Save().Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!wasfirstchild)
|
|
{
|
|
this.MyPrevious = null;
|
|
this.Save();
|
|
}
|
|
if (origNextItem != null) origNextItem.Dispose();
|
|
if (parentInfo != null)
|
|
parentInfo.MyContent.RefreshContentParts();
|
|
if (parentInfoDV != null)
|
|
parentInfoDV.ResetProcedures();
|
|
}
|
|
|
|
}
|
|
protected static int MakeNewItem(IVEDrillDownReadOnly parentInfoDD, ItemInfo previousInfo, string number, string title, int type, E_FromType partType)
|
|
{
|
|
int newitemid = 0;
|
|
if (parentInfoDD == null)
|
|
parentInfoDD = previousInfo.ActiveParent;
|
|
ItemInfo parentInfo = parentInfoDD as ItemInfo;
|
|
DocVersionInfo parentInfoDV = parentInfoDD as DocVersionInfo;
|
|
using (Content cont = Content.New(number, title, type, null, null))
|
|
{
|
|
using (Item fromitem = previousInfo == null ? null : previousInfo.Get())
|
|
{
|
|
ItemInfo nextInfo = null; // Check to see if the item is being inserted in the middle of some items.
|
|
if (previousInfo != null && previousInfo.NextItems != null && previousInfo.NextItems.Count > 0)
|
|
nextInfo = previousInfo.NextItems[0];
|
|
using (Item itm = Item.MakeItem(fromitem, cont))
|
|
{
|
|
newitemid = itm.ItemID;
|
|
if (nextInfo != null)
|
|
{
|
|
using (Item nextItem = nextInfo.Get())
|
|
{
|
|
nextItem.MyPrevious = itm;// Aim the next item back at the new item.
|
|
nextItem.Save().Dispose();
|
|
}
|
|
}
|
|
if (fromitem == null)
|
|
{
|
|
if (parentInfo != null) // Adding Item to Procedure, Section or Step
|
|
{
|
|
using (Item parentItem = parentInfo.Get())
|
|
{
|
|
ItemInfo firstinfo = parentInfo.FirstChild(partType);
|
|
if (firstinfo != null)
|
|
{
|
|
using (Item firstchild = firstinfo.Get())
|
|
{
|
|
parentItem.MyContent.ContentParts[(int)partType].MyItem = itm;// First update the parent to point to the new first child
|
|
parentItem.Save().Dispose();
|
|
firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
|
|
firstchild.Save().Dispose();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parentItem.MyContent.ContentParts.Add((int)partType, itm);// update the parent to point to the new first child
|
|
parentItem.Save().Dispose();
|
|
}
|
|
}
|
|
}
|
|
if (parentInfoDV != null) // Adding Item (Procedure) to DocVersion
|
|
{
|
|
using (DocVersion parentItemDV = parentInfoDV.Get())
|
|
{
|
|
ItemInfo firstinfo = parentInfoDV.FirstChild();
|
|
parentItemDV.MyItem = itm;// First update the parent to point to the new first child
|
|
parentItemDV.Save().Dispose();
|
|
if (firstinfo != null)
|
|
{
|
|
using (Item firstchild = firstinfo.Get())
|
|
{
|
|
firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
|
|
firstchild.Save().Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (parentInfo != null)
|
|
parentInfo.MyContent.RefreshContentParts();
|
|
if (parentInfoDV != null)
|
|
parentInfoDV.ResetProcedures();
|
|
return newitemid;
|
|
}
|
|
}
|
|
#endregion
|
|
#region ItemInfo
|
|
public partial class ItemInfo:IVEDrillDownReadOnly
|
|
{
|
|
protected void ExtensionRefreshFields(Item tmp)
|
|
{
|
|
_ActiveParent = null;
|
|
}
|
|
#region LoadAtOnce2
|
|
public static ItemInfo GetItemAndChildren2(int? itemID)
|
|
{
|
|
try
|
|
{
|
|
ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria2(itemID));
|
|
AddToCache(tmp);
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetItemAndChildren2", ex);
|
|
}
|
|
}
|
|
// Criteria to get Item and children
|
|
[Serializable()]
|
|
private class ItemAndChildrenCriteria2
|
|
{
|
|
public ItemAndChildrenCriteria2(int? itemID)
|
|
{
|
|
_ItemID = itemID;
|
|
}
|
|
private int? _ItemID;
|
|
public int? ItemID
|
|
{
|
|
get { return _ItemID; }
|
|
set { _ItemID = value; }
|
|
}
|
|
}
|
|
// Data Portal to Get Item and Children
|
|
private void DataPortal_Fetch(ItemAndChildrenCriteria2 criteria)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
ApplicationContext.LocalContext["cn"] = cn;
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
cm.CommandText = "getItem";
|
|
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
|
|
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
|
|
{
|
|
if (!dr.Read())
|
|
{
|
|
_ErrorMessage = "No Record Found";
|
|
return;
|
|
}
|
|
ReadData(dr);
|
|
}
|
|
}
|
|
SpinThroughChildren();
|
|
// removing of item only needed for local data portal
|
|
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
|
|
ApplicationContext.LocalContext.Remove("cn");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
|
|
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
|
|
}
|
|
RemoveFromCache(this);
|
|
}
|
|
private void SpinThroughChildren()
|
|
{
|
|
if(MyContent.ContentPartCount > 0)
|
|
foreach(PartInfo partInfo in MyContent.ContentParts)
|
|
foreach (ItemInfo itemInfo in partInfo.MyItems)
|
|
itemInfo.SpinThroughChildren();
|
|
}
|
|
#endregion
|
|
#region LoadAtOnce
|
|
// Method to Get Item and children
|
|
public static ItemInfo GetItemAndChildren(int? itemID,int? parentID)
|
|
{
|
|
try
|
|
{
|
|
ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria(itemID,parentID));
|
|
AddToCache(tmp);
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
|
|
}
|
|
}
|
|
// Criteria to get Item and children
|
|
[Serializable()]
|
|
private class ItemAndChildrenCriteria
|
|
{
|
|
public ItemAndChildrenCriteria(int? itemID, int? parentID)
|
|
{
|
|
_ItemID = itemID;
|
|
_ParentID = parentID;
|
|
}
|
|
private int? _ItemID;
|
|
public int? ItemID
|
|
{
|
|
get { return _ItemID; }
|
|
set { _ItemID = value; }
|
|
}
|
|
private int? _ParentID;
|
|
public int? ParentID
|
|
{
|
|
get { return _ParentID; }
|
|
set { _ParentID = value; }
|
|
}
|
|
}
|
|
// Data Portal to Get Item and Children
|
|
private void DataPortal_Fetch(ItemAndChildrenCriteria criteria)
|
|
{
|
|
//ItemInfo tmp = null;
|
|
Dictionary<int, ItemInfo> lookup = new Dictionary<int, ItemInfo>(); ;
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
cm.CommandText = "vesp_ListItemAndChildren";
|
|
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
|
|
cm.Parameters.AddWithValue("@ParentID", criteria.ParentID);
|
|
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
if (dr.GetInt32("Level")==0)
|
|
{
|
|
//tmp = itemInfo;
|
|
ReadData(dr);
|
|
AddContent(dr);
|
|
lookup[this.ItemID] = this;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
case 2:
|
|
itemInfo = new StepInfo(dr);
|
|
break;
|
|
}
|
|
// Load Children
|
|
itemInfo.AddContent(dr);
|
|
ItemInfo parent = lookup[dr.GetInt32("ParentID")];
|
|
itemInfo._ActiveParent = parent;
|
|
itemInfo._ActiveSection = (itemInfo.IsSection ? itemInfo : parent._ActiveSection);
|
|
parent.AddPart(dr, itemInfo);
|
|
lookup.Add(itemInfo.ItemID, itemInfo);
|
|
}
|
|
}
|
|
//Console.WriteLine("I'm here {0}",this.MyContent.ContentPartCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
|
|
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
|
|
}
|
|
}
|
|
private void AddPart(SafeDataReader dr, ItemInfo itemInfo)
|
|
{
|
|
// Either a new PartInfo or an existing PartInfo
|
|
if (dr.IsDBNull(dr.GetOrdinal("PreviousID")))
|
|
{
|
|
//PartInfo prt = new PartInfo(dr, itemInfo);
|
|
_MyContent.AddPart(dr, itemInfo);
|
|
}
|
|
else
|
|
{
|
|
foreach (PartInfo pi in MyContent.ContentParts)
|
|
{
|
|
if (dr.GetInt32("FromType") == (int)pi.PartType)
|
|
{
|
|
if (pi._MyItems == null)
|
|
pi._MyItems = new ItemInfoList(itemInfo);
|
|
else
|
|
pi.MyItems.AddItem(itemInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
public bool IsCautionStructure
|
|
{
|
|
get
|
|
{
|
|
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Caution));
|
|
}
|
|
}
|
|
public bool IsNoteStructure
|
|
{
|
|
get
|
|
{
|
|
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Note));
|
|
}
|
|
}
|
|
|
|
public bool IsCautionStructureFirstSib
|
|
{
|
|
get
|
|
{
|
|
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Caution));
|
|
}
|
|
}
|
|
public bool IsNoteStructureFirstSib
|
|
{
|
|
get
|
|
{
|
|
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Note));
|
|
}
|
|
}
|
|
|
|
public bool IsType(string type)
|
|
{
|
|
int stepType = ((int)MyContent.Type) % 10000;
|
|
StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
|
|
StepData sd = sdlist[stepType];
|
|
// TODO: RHM20071115 while (sd.Index != 0)
|
|
// TODO: RHM20071115 {
|
|
// TODO: RHM20071115 if (sd.Type == type) return true;
|
|
// TODO: RHM20071115 sd = sdlist[sd.ParentType];
|
|
// TODO: RHM20071115 }
|
|
return false;
|
|
}
|
|
public bool IsCaution
|
|
{
|
|
get
|
|
{
|
|
return IsType("CAUTION");
|
|
}
|
|
}
|
|
public bool IsNote
|
|
{
|
|
get
|
|
{
|
|
return IsType("NOTE");
|
|
}
|
|
}
|
|
public bool IsTable
|
|
{
|
|
get
|
|
{
|
|
return IsType("TABLE");
|
|
}
|
|
}
|
|
public bool IsFigure
|
|
{
|
|
get
|
|
{
|
|
return IsType("FIGURE");
|
|
}
|
|
}
|
|
public bool IsOr
|
|
{
|
|
get
|
|
{
|
|
return IsType("OR");
|
|
}
|
|
}
|
|
public bool IsAnd
|
|
{
|
|
get
|
|
{
|
|
return IsType("AND");
|
|
}
|
|
}
|
|
public bool IsEquipmentList
|
|
{
|
|
get
|
|
{
|
|
return IsType("EQUIPMENTLIST");
|
|
}
|
|
}
|
|
public bool IsTitle
|
|
{
|
|
get
|
|
{
|
|
return IsType("TITLE");
|
|
}
|
|
}
|
|
public bool IsAccPages
|
|
{
|
|
get
|
|
{
|
|
return IsType("ACCPAGES");
|
|
}
|
|
}
|
|
public bool IsParagraph
|
|
{
|
|
get
|
|
{
|
|
return IsType("PARAGRAPH");
|
|
}
|
|
}
|
|
public bool IsDefault
|
|
{
|
|
get
|
|
{
|
|
return IsType("DEFAULT");
|
|
}
|
|
}
|
|
public bool IsContAcSequential
|
|
{
|
|
get
|
|
{
|
|
return IsType("CONTACSEQUENTIAL");
|
|
}
|
|
}
|
|
public bool IsHigh
|
|
{
|
|
get
|
|
{
|
|
// check to see if ActiveParent is a section, if so it is a high level step
|
|
if (MyContent.Type / 10000 != 2) return false;
|
|
ItemInfo parent = ActiveParent as ItemInfo;
|
|
if (parent == null) return false;
|
|
if ((parent.MyContent.Type / 10000) == 1)
|
|
return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsSequential
|
|
{
|
|
get
|
|
{
|
|
if (((MyContent.Type / 10000) == 2) && ((((int)MyContent.Type) % 10000) == 1)) return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsRNO
|
|
{
|
|
get
|
|
{
|
|
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.RNO));
|
|
}
|
|
}
|
|
public bool IsInRNO
|
|
{
|
|
get
|
|
{
|
|
if (IsHigh) return false;
|
|
if (IsRNO) return true;
|
|
ItemInfo parent = ActiveParent as ItemInfo;
|
|
if (parent == null) return false;
|
|
return parent.IsInRNO;
|
|
}
|
|
}
|
|
public int RNOLevel
|
|
{
|
|
get
|
|
{
|
|
return ((IsProcedure || IsSection || IsHigh)?0:(IsRNO?1:0)+((ItemInfo)ActiveParent).RNOLevel);
|
|
}
|
|
}
|
|
public int Columns
|
|
{
|
|
get
|
|
{
|
|
// check config value on my section, if null/default use Pmode of active format
|
|
SectionInfo si = SectionInfo.Get(ActiveSection.ItemID); //ActiveSection as SectionInfo;
|
|
if (si != null)
|
|
{
|
|
if (si.SectionConfig.Section_ColumnMode != SectionConfig.SectionColumnMode.Default)
|
|
return (int)si.SectionConfig.Section_ColumnMode;
|
|
}
|
|
return ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PMode ?? 2;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// FormatStepType - Maps to step type in format file. All types map directly from step type in content
|
|
/// to step type in format except rno. The '39' is the RNO index in the format file. Note that we
|
|
/// could loop through the format's stepdata to find rnotype if we want this to be more flexible?
|
|
/// </summary>
|
|
public int FormatStepType
|
|
{
|
|
get
|
|
{
|
|
if (IsRNO) return 40;
|
|
else return (((int)MyContent.Type) % 10000);
|
|
}
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public StepData FormatStepData
|
|
{
|
|
get
|
|
{
|
|
if (IsRNO) return ActiveFormat.PlantFormat.FormatData.StepDataList[40];
|
|
int typ = (int)MyContent.Type - 20000;
|
|
foreach (StepData sd in ActiveFormat.PlantFormat.FormatData.StepDataList)
|
|
{
|
|
if (sd.Index == typ) return sd;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
public ItemInfo FirstSibling
|
|
{
|
|
get
|
|
{
|
|
ItemInfo temp = this;
|
|
while (temp.MyPrevious != null) temp = temp.MyPrevious;
|
|
return temp;
|
|
}
|
|
}
|
|
public ItemInfo LastSibling
|
|
{
|
|
get
|
|
{
|
|
ItemInfo temp = this;
|
|
while (temp.NextItems != null) temp = temp.NextItems[0];
|
|
return temp;
|
|
}
|
|
}
|
|
public ItemInfo LastChild(E_FromType partType)
|
|
{
|
|
ItemInfoList myitems = Lookup((int)partType);
|
|
if (myitems !=null) return myitems[myitems.Count-1];
|
|
return null;
|
|
}
|
|
public ItemInfo FirstChild(E_FromType partType)
|
|
{
|
|
ItemInfoList myitems = Lookup((int)partType);
|
|
if (myitems != null) return myitems[0];
|
|
return null;
|
|
}
|
|
public bool IsSubStep
|
|
{
|
|
get
|
|
{
|
|
ItemInfo temp = FirstSibling;
|
|
return ((temp.ItemPartCount > 0) && (temp.ItemParts[0].PartType == E_FromType.Step));
|
|
}
|
|
}
|
|
public bool IsInSubStep
|
|
{
|
|
get
|
|
{
|
|
if (IsHigh) return false;
|
|
if (IsSubStep) return true;
|
|
ItemInfo parent = ActiveParent as ItemInfo;
|
|
if (parent == null) return false;
|
|
return parent.IsInSubStep;
|
|
}
|
|
}
|
|
public bool IsInFirstLevelSubStep
|
|
{
|
|
get
|
|
{
|
|
ItemInfo temp = FirstSibling;
|
|
if(temp.ActiveParent.GetType() == typeof(VEPROMS.CSLA.Library.DocVersionInfo))return false;
|
|
while (((ItemInfo)temp.ActiveParent).IsHigh == false) temp = ((ItemInfo)temp.ActiveParent).FirstSibling;
|
|
return temp.IsSubStep;
|
|
}
|
|
}
|
|
public bool IsStepSection
|
|
{
|
|
get
|
|
{
|
|
if (MyContent.Type == 10000) return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsSection
|
|
{
|
|
get
|
|
{
|
|
if ((MyContent.Type / 10000) == 1) return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsDefaultSection
|
|
{
|
|
get
|
|
{
|
|
// check to see if ActiveParent is a section, if so it is a high level step
|
|
if (MyContent.Type / 10000 != 1) return false;
|
|
// get procedure section and then
|
|
ItemInfo parent = (ItemInfo)ActiveParent;
|
|
if (!parent.IsProcedure) return false;
|
|
ProcedureConfig pc = (ProcedureConfig)parent.MyConfig;
|
|
int sectstartid = -1;
|
|
string ss = pc == null ? null : pc.SectionStart;
|
|
if (ss != null) sectstartid = System.Convert.ToInt32(ss);
|
|
else return false;
|
|
if (ItemID == sectstartid) return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsProcedure
|
|
{
|
|
get
|
|
{
|
|
if ((MyContent.Type / 10000) == 0) return true;
|
|
return false;
|
|
}
|
|
}
|
|
public bool IsStep
|
|
{
|
|
get
|
|
{
|
|
if ((MyContent.Type / 10000) == 2) return true;
|
|
return false;
|
|
}
|
|
}
|
|
private E_FromType ItemType
|
|
{
|
|
get
|
|
{
|
|
if (MyContent.Type == 0) return E_FromType.Procedure;
|
|
if (MyContent.Type < 20000) return E_FromType.Section;
|
|
return E_FromType.Step;
|
|
}
|
|
}
|
|
public Item GetByType()
|
|
{
|
|
Item tmp = null;
|
|
switch (ItemType)
|
|
{
|
|
case E_FromType.Procedure:
|
|
tmp = Procedure.Get(_ItemID);
|
|
break;
|
|
//case E_FromType.Section:
|
|
// itemInfo = new Section(dr);
|
|
// break;
|
|
//default:
|
|
// itemInfo = new Step(dr);
|
|
// break;
|
|
}
|
|
return tmp;
|
|
}
|
|
private int? _Ordinal;
|
|
public int Ordinal
|
|
{
|
|
get
|
|
{
|
|
if (_Ordinal == null)
|
|
{
|
|
if (MyPrevious != null)
|
|
_Ordinal = MyPrevious.Ordinal + 1;
|
|
else
|
|
_Ordinal = 1;
|
|
}
|
|
return (int) _Ordinal;
|
|
}
|
|
}
|
|
public string CslaType
|
|
{ get { return this.GetType().FullName; } }
|
|
public override string ToString()
|
|
{
|
|
//Item editable = Item.GetExistingByPrimaryKey(_ItemID);
|
|
//return string.Format("{0}{1} {2}", (editable == null ? "" : (editable.IsDirty ? "* " : "")),
|
|
// (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : MyContent.Number), MyContent.Text);
|
|
ContentInfo cont = MyContent;
|
|
string number = cont.Number;
|
|
if (cont.Type >= 20000) number = Ordinal.ToString() + ".";
|
|
return string.Format("{0} {1}", number, cont.Text).Trim();
|
|
//return string.Format("{0} {1}", cont.Number, cont.Text);
|
|
//return "Now is the time for all good men to come to the aid of their country!";
|
|
}
|
|
//public string ToString(string str,System.IFormatProvider ifp)
|
|
//{
|
|
// return ToString();
|
|
//}
|
|
public string nz(string str, string def)
|
|
{
|
|
return (str == null ? def : str);
|
|
}
|
|
internal string _SearchDVPath;
|
|
public string SearchDVPath
|
|
{
|
|
get { return _SearchDVPath; }
|
|
}
|
|
internal string _SearchPath;
|
|
public string SearchPath
|
|
{
|
|
get { return _SearchPath; }
|
|
}
|
|
public string ShortSearchPath
|
|
{
|
|
get { return Regex.Replace(_SearchPath, "\x11.*?\x07", "\x07"); }
|
|
}
|
|
internal int _SearchAnnotationID;
|
|
public int SearchAnnotationID
|
|
{
|
|
get { return _SearchAnnotationID; }
|
|
}
|
|
internal string _SearchAnnotationText;
|
|
public string SearchAnnotationText
|
|
{
|
|
get { return _SearchAnnotationText; }
|
|
}
|
|
internal string _SearchAnnotationType;
|
|
public string SearchAnnotationType
|
|
{
|
|
get { return _SearchAnnotationType; }
|
|
}
|
|
public string DisplayText
|
|
{
|
|
get { return ConvertToDisplayText(MyContent.Text); }
|
|
}
|
|
public static string ConvertToDisplayText(string txt)
|
|
{
|
|
string retval = txt;
|
|
retval = StripRtfFormatting(retval);
|
|
retval = StripLinks(retval);
|
|
retval = ReplaceSpecialCharacters(retval);
|
|
return retval;
|
|
}
|
|
private static string StripRtfFormatting(string rtf)
|
|
{
|
|
string retval = rtf;
|
|
retval = Regex.Replace(retval, @"\\b0 ?", "");
|
|
retval = Regex.Replace(retval, @"\\b ?", "");
|
|
retval = Regex.Replace(retval, @"\\ul0 ?", "");
|
|
retval = Regex.Replace(retval, @"\\ul ?", "");
|
|
retval = Regex.Replace(retval, @"\\i0 ?", "");
|
|
retval = Regex.Replace(retval, @"\\i ?", "");
|
|
retval = Regex.Replace(retval, @"\\super ?", "");
|
|
retval = Regex.Replace(retval, @"\\sub ?", "");
|
|
retval = Regex.Replace(retval, @"\\nosupersub ?", "");
|
|
return retval;
|
|
}
|
|
private static string StripLinks(string rtf)
|
|
{
|
|
string retval = rtf;
|
|
retval = Regex.Replace(retval, @"\\v.*?\\v0", "");
|
|
retval = retval.Replace("\u252C", "");// Unicode 9516 Transition
|
|
retval = retval.Replace("\u2566", "");// Unicode 9574 Transition
|
|
retval = retval.Replace("\u0015", "");// Unicode 21 RO
|
|
return retval;
|
|
}
|
|
private static string ReplaceSpecialCharacter(Match m)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
int i = int.Parse(m.ToString().Substring(2,m.ToString().Length-3));
|
|
sb.Append((char)i);
|
|
return sb.ToString();
|
|
}
|
|
private static string ReplaceSpecialHexCharacter(Match m)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
int i = int.Parse(m.ToString().Substring(2), System.Globalization.NumberStyles.HexNumber);
|
|
sb.Append((char)i);
|
|
return sb.ToString();
|
|
}
|
|
private static string ReplaceSpecialCharacters(string rtf)
|
|
{
|
|
string retval = rtf;
|
|
retval = retval.Replace("`", "\u00BA");// Degree
|
|
retval = Regex.Replace(retval, @"\\u[0-9]+[?]", new MatchEvaluator(ReplaceSpecialCharacter));
|
|
retval = Regex.Replace(retval, @"\\'[0-9A-Fa-f][0-9A-Fa-f]", new MatchEvaluator(ReplaceSpecialHexCharacter));
|
|
return retval;
|
|
}
|
|
public string Path
|
|
{
|
|
get
|
|
{
|
|
string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : (nz(MyContent.Number,"")==""? MyContent.Text: MyContent.Number));
|
|
ItemInfo parent = this;
|
|
while (parent.MyPrevious != null) parent = parent.MyPrevious;
|
|
if (parent.ItemPartCount == 0)
|
|
return number + ", " + MyContent.Text;
|
|
else
|
|
{
|
|
PartInfo partInfo = parent.ItemParts[0];
|
|
return partInfo.MyContent.ContentItems.Items[0].Path + " " + ((E_FromType)partInfo.FromType).ToString() + " " + number;
|
|
}
|
|
}
|
|
}
|
|
public ContentInfo ParentContent
|
|
{
|
|
get
|
|
{
|
|
string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : (nz(MyContent.Number, "") == "" ? MyContent.Text : MyContent.Number));
|
|
ItemInfo parent = this;
|
|
while (parent.MyPrevious != null) parent = parent.MyPrevious;
|
|
if (parent.ItemPartCount == 0)
|
|
return null;
|
|
else
|
|
{
|
|
return parent.ItemParts[0].MyContent;
|
|
}
|
|
}
|
|
}
|
|
public ItemInfo MyParent
|
|
{
|
|
get
|
|
{
|
|
//if (ItemDocVersionCount > 0) return ItemDocVersions[0]; Need to create one interface to support Folders, DocVersions and Items
|
|
ContentInfo parentContent = ParentContent;
|
|
if (parentContent == null || parentContent.ContentItemCount == 0) return null;
|
|
return parentContent.ContentItems[0];
|
|
}
|
|
}
|
|
private ItemInfoList Lookup(int fromType, ref ItemInfoList itemInfoList)
|
|
{
|
|
if (itemInfoList == null)
|
|
itemInfoList = Lookup(fromType);
|
|
return itemInfoList;
|
|
}
|
|
internal ItemInfoList Lookup(int fromType)
|
|
{
|
|
ItemInfoList itemInfoList = null;
|
|
if (MyContent.ContentPartCount != 0)
|
|
foreach (PartInfo partInfo in MyContent.ContentParts)
|
|
if (partInfo.FromType == fromType)
|
|
{
|
|
itemInfoList = partInfo._MyItems = ItemInfoList.GetList(partInfo.ItemID, partInfo.FromType);
|
|
return itemInfoList;
|
|
}
|
|
return null;
|
|
}
|
|
public static void ResetParts(int itemID)
|
|
{
|
|
string key = itemID.ToString();
|
|
if (_CacheByPrimaryKey.ContainsKey(key))
|
|
foreach (ItemInfo itm in _CacheByPrimaryKey[key])
|
|
itm.ResetParts();
|
|
}
|
|
public void ResetParts()
|
|
{
|
|
_Procedures = null;
|
|
_Sections = null;
|
|
_Cautions = null;
|
|
_Notes = null;
|
|
_RNOs = null;
|
|
_Steps = null;
|
|
_Tables = null;
|
|
}
|
|
private ItemInfoList _Procedures;
|
|
public ItemInfoList Procedures
|
|
{ get { return Lookup(1,ref _Procedures); } }
|
|
private ItemInfoList _Sections;
|
|
public ItemInfoList Sections
|
|
{ get { return Lookup(2,ref _Sections); } }
|
|
private ItemInfoList _Cautions;
|
|
public ItemInfoList Cautions
|
|
{ get { return Lookup(3,ref _Cautions); } }
|
|
private ItemInfoList _Notes;
|
|
public ItemInfoList Notes
|
|
{ get { return Lookup(4,ref _Notes); } }
|
|
private ItemInfoList _RNOs;
|
|
public ItemInfoList RNOs
|
|
{ get { return Lookup(5,ref _RNOs); } }
|
|
private ItemInfoList _Steps;
|
|
public ItemInfoList Steps
|
|
{ get { return Lookup(6,ref _Steps); } }
|
|
private ItemInfoList _Tables;
|
|
public ItemInfoList Tables
|
|
{ get { return Lookup(7,ref _Tables); } }
|
|
//public XmlDocument ToXml()
|
|
//{
|
|
// XmlDocument retval = new XmlDocument();
|
|
// retval.LoadXml("<root/>");
|
|
// return ToXml(retval.DocumentElement);
|
|
//}
|
|
//public void AddList(XmlNode xn,string name, ItemInfoList itemInfoList)
|
|
//{
|
|
// if (itemInfoList != null)
|
|
// {
|
|
// XmlNode nd = xn.OwnerDocument.CreateElement(name);
|
|
// xn.AppendChild(nd);
|
|
// itemInfoList.ToXml(xn);
|
|
// }
|
|
//}
|
|
//public XmlDocument ToXml(XmlNode xn)
|
|
//{
|
|
// XmlNode nd = MyContent.ToXml(xn);
|
|
// // Now add the children
|
|
// AddList(nd, "Procedures", Procedures);
|
|
// AddList(nd, "Sections", Sections);
|
|
// AddList(nd, "Cautions", Cautions);
|
|
// AddList(nd, "Notes", Notes);
|
|
// AddList(nd, "RNOs", RNOs);
|
|
// AddList(nd, "Steps", SubItems);
|
|
// AddList(nd, "Tables", Tables);
|
|
// return xn.OwnerDocument;
|
|
//}
|
|
public string TabToolTip
|
|
{
|
|
get
|
|
{
|
|
if (MyContent.MyEntry == null)
|
|
return MyContent.Number + " - " + MyContent.Text;
|
|
string toolTip = MyProcedure.TabToolTip + "\r\n";
|
|
if (MyContent.Number != "")
|
|
toolTip += MyContent.Number + " - " + MyContent.Text;
|
|
else
|
|
toolTip += MyContent.Text;
|
|
DocumentInfo myDocument = MyContent.MyEntry.MyDocument;
|
|
if (myDocument.LibTitle != "")
|
|
{
|
|
toolTip += string.Format("\r\n(Library Document - {0})", myDocument.LibTitle);
|
|
toolTip += myDocument.LibraryDocumentUsage;
|
|
}
|
|
return toolTip;
|
|
}
|
|
}
|
|
public string TabTitle
|
|
{
|
|
get
|
|
{
|
|
if (MyContent.MyEntry == null)
|
|
return MyContent.Number;
|
|
if (MyContent.Number != "")
|
|
return MyContent.Number;
|
|
if (MyContent.Text.Length <= 10)
|
|
return MyContent.Text;
|
|
return MyContent.Text.Split(" ,.;:-_".ToCharArray())[0] + "...";
|
|
}
|
|
}
|
|
#region IVEReadOnlyItem
|
|
PartInfoList _PartInfoList;
|
|
public System.Collections.IList GetChildren()
|
|
{
|
|
_PartInfoList = this.MyContent.ContentParts;
|
|
if (_PartInfoList.Count == 1 && ( _PartInfoList[0].ToString() == "Sections" || _PartInfoList[0].ToString() == "Steps"))
|
|
return _PartInfoList[0].GetChildren();
|
|
return _PartInfoList;
|
|
}
|
|
public System.Collections.IList GetChildren(bool allParts)
|
|
{
|
|
_PartInfoList = this.MyContent.ContentParts;
|
|
if (allParts)
|
|
{
|
|
if (_PartInfoList.Count == 1 && (_PartInfoList[0].ToString() == "Sections" || _PartInfoList[0].ToString() == "Steps"))
|
|
return _PartInfoList[0].GetChildren();
|
|
return _PartInfoList;
|
|
}
|
|
else // Steps and Sections only
|
|
{
|
|
for(int i = 0;i<_PartInfoList.Count;i++)
|
|
if(_PartInfoList[i].ToString() == "Sections" || _PartInfoList[i].ToString() == "Steps")
|
|
return _PartInfoList[i].GetChildren();
|
|
return null;
|
|
}
|
|
}
|
|
//public bool ChildrenAreLoaded
|
|
//{
|
|
// get { return _PartInfoList == null; }
|
|
//}
|
|
public bool HasChildren
|
|
{
|
|
get { return this.MyContent.ContentPartCount > 0; }
|
|
}
|
|
public bool HasWordContent
|
|
{
|
|
get { return this.MyContent.MyEntry != null; }
|
|
}
|
|
public bool HasStepContent
|
|
{
|
|
get
|
|
{
|
|
if (MyContent.ContentPartCount == 0) return false;
|
|
if (MyContent.ContentPartCount == 1 && MyContent.ContentParts[0].PartType == E_FromType.Section) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public ItemInfo MyProcedure
|
|
{
|
|
get
|
|
{
|
|
// Walk up active parents until the parent is not an item
|
|
ItemInfo tmp = this;
|
|
while (tmp.ActiveParent != null && tmp.ActiveParent.GetType() != typeof(DocVersionInfo))
|
|
tmp = (ItemInfo)tmp.ActiveParent;
|
|
return tmp;
|
|
}
|
|
}
|
|
private IVEDrillDownReadOnly _ActiveParent = null;
|
|
public IVEDrillDownReadOnly MyActiveParent { get { return _ActiveParent; } }
|
|
public IVEDrillDownReadOnly ActiveParent
|
|
{
|
|
get
|
|
{
|
|
//if (_ActiveParent == this)_ActiveParent = null;
|
|
if (_ActiveParent == null)
|
|
{
|
|
if (MyPrevious != null)
|
|
_ActiveParent = _MyPrevious.ActiveParent;
|
|
else
|
|
{
|
|
if (this.ItemDocVersions != null && this.ItemDocVersions.Count > 0)
|
|
_ActiveParent = this.ItemDocVersions[0];
|
|
else
|
|
{
|
|
ContentInfo parentContent = ParentContent;
|
|
if (parentContent == null || parentContent.ContentItemCount == 0)
|
|
_ActiveParent = this;
|
|
else
|
|
_ActiveParent = parentContent.ContentItems[0];
|
|
}
|
|
}
|
|
}
|
|
return _ActiveParent==this ? null : _ActiveParent;
|
|
}
|
|
internal set
|
|
//set
|
|
{
|
|
_ActiveParent = value;
|
|
}
|
|
}
|
|
private ItemInfo _ActiveSection = null;
|
|
public ItemInfo MyActiveSection { get { return _ActiveSection; } }
|
|
public ItemInfo ActiveSection
|
|
{
|
|
get
|
|
{
|
|
if (_ActiveSection == null)
|
|
{
|
|
if (IsSection)
|
|
_ActiveSection = this;
|
|
else
|
|
{
|
|
ItemInfo parent = ActiveParent as ItemInfo;
|
|
if (parent != null)
|
|
_ActiveSection = parent.ActiveSection;
|
|
else
|
|
_ActiveSection = this;
|
|
}
|
|
}
|
|
return _ActiveSection.IsSection ? _ActiveSection : null;
|
|
}
|
|
set
|
|
{
|
|
_ActiveSection = value;
|
|
}
|
|
}
|
|
private FormatInfo _ActiveFormat = null;
|
|
public FormatInfo ActiveFormat
|
|
{
|
|
get
|
|
{
|
|
if (_ActiveFormat == null)
|
|
_ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
|
|
return _ActiveFormat;
|
|
}
|
|
//get { return LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat; }
|
|
}
|
|
public FormatInfo LocalFormat
|
|
{
|
|
get { return MyContent.MyFormat; }
|
|
}
|
|
private ConfigDynamicTypeDescriptor _MyConfig=null;
|
|
public ConfigDynamicTypeDescriptor MyConfig
|
|
{
|
|
get
|
|
{
|
|
if (_MyConfig == null)
|
|
{
|
|
switch (MyContent.Type / 10000)
|
|
{
|
|
case 0:
|
|
_MyConfig = new ProcedureConfig(MyContent.Config);
|
|
break;
|
|
case 1:
|
|
_MyConfig = new SectionConfig(MyContent.Config);
|
|
break;
|
|
case 2:
|
|
_MyConfig = new StepConfig(MyContent.Config);
|
|
break;
|
|
}
|
|
}
|
|
return _MyConfig;
|
|
}
|
|
set
|
|
{
|
|
if (_MyConfig == null) return;
|
|
// MyContent.Config = value;
|
|
}
|
|
}
|
|
//public bool HasStandardSteps()
|
|
//{ return MyContent.ContentItemCount > 1; }
|
|
public Color ForeColor
|
|
{ get { return (HasBrokenRules != null ? Color.Red : (MyContent.ContentItemCount > 1 ? Color.Blue : Color.Black)); } }
|
|
public Color BackColor
|
|
{ get { return (ItemAnnotationCount > 0 ? Color.Yellow : Color.White); } }
|
|
#endregion
|
|
internal ItemInfo(SafeDataReader dr, bool forItem)
|
|
{
|
|
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ItemInfo.Constructor", GetHashCode());
|
|
try
|
|
{
|
|
ReadData(dr);
|
|
AddContent(dr);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_MyLog.IsErrorEnabled) _MyLog.Error("ItemInfo.Constructor", ex);
|
|
throw new DbCslaException("ItemInfo.Constructor", ex);
|
|
}
|
|
}
|
|
internal void AddContent(SafeDataReader dr)
|
|
{
|
|
_MyContent = new ContentInfo(dr, true);
|
|
}
|
|
}
|
|
#endregion ItemInfo
|
|
#region ItemInfoList
|
|
public partial class ItemInfoList
|
|
{
|
|
//public void ToXml(XmlNode xn)
|
|
//{
|
|
// foreach (ItemInfo itemInfo in this)
|
|
// {
|
|
// itemInfo.ToXml(xn);
|
|
// }
|
|
//}
|
|
internal ItemInfoList(ItemInfo itemInfo)
|
|
{
|
|
AddItem(itemInfo);
|
|
}
|
|
public static ItemInfoList GetList(int? itemID,int type)
|
|
{
|
|
try
|
|
{
|
|
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListCriteria(itemID,type));
|
|
ItemInfo.AddList(tmp);
|
|
tmp.AddEvents();
|
|
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
|
|
ContentInfoList.GetList(itemID); // Performance - Load All Content
|
|
#endif
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
|
|
}
|
|
}
|
|
[Serializable()]
|
|
private class ItemListCriteria
|
|
{
|
|
public ItemListCriteria(int? itemID,int type)
|
|
{
|
|
_ItemID = itemID;
|
|
_Type = type;
|
|
}
|
|
private int? _ItemID;
|
|
public int? ItemID
|
|
{
|
|
get { return _ItemID; }
|
|
set { _ItemID = value; }
|
|
}
|
|
private int _Type;
|
|
public int Type
|
|
{
|
|
get { return _Type; }
|
|
set { _Type = value; }
|
|
}
|
|
}
|
|
private void DataPortal_Fetch(ItemListCriteria criteria)
|
|
{
|
|
this.RaiseListChangedEvents = false;
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
#if ItemWithContent
|
|
cm.CommandText = "vesp_ListItemsAndContent";
|
|
#else
|
|
cm.CommandText = "vesp_ListItems";
|
|
#endif
|
|
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
|
|
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
ItemInfo itemInfo = null;
|
|
switch ((E_FromType)criteria.Type)
|
|
{
|
|
case E_FromType.Procedure:
|
|
itemInfo = new ProcedureInfo(dr);
|
|
break;
|
|
case E_FromType.Section:
|
|
itemInfo = new SectionInfo(dr);
|
|
break;
|
|
default:
|
|
itemInfo = new StepInfo(dr);
|
|
break;
|
|
}
|
|
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;
|
|
}
|
|
internal void AddItem(ItemInfo itemInfo)
|
|
{
|
|
IsReadOnly = false;
|
|
this.Add(itemInfo);
|
|
IsReadOnly = true;
|
|
}
|
|
#region Text Search
|
|
public static ItemInfoList GetListFromTextSearch(string docVersionList, string stepTypeList, string searchString, bool caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters)
|
|
{
|
|
try
|
|
{
|
|
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListSearchCriteria(docVersionList, stepTypeList, searchString, caseSensitive, includeLinks, includeRtfFormatting, includeSpecialCharacters));
|
|
ItemInfo.AddList(tmp);
|
|
tmp.AddEvents();
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
|
|
}
|
|
}
|
|
[Serializable()]
|
|
private class ItemListSearchCriteria
|
|
{
|
|
private string _DocVersionList;
|
|
public string DocVersionList
|
|
{
|
|
get { return _DocVersionList; }
|
|
set { _DocVersionList = value; }
|
|
}
|
|
private string _StepTypeList;
|
|
public string StepTypeList
|
|
{
|
|
get { return _StepTypeList; }
|
|
set { _StepTypeList = value; }
|
|
}
|
|
private string _SearchString;
|
|
public string SearchString
|
|
{
|
|
get { return _SearchString; }
|
|
set { _SearchString = value; }
|
|
}
|
|
private bool _CaseSensitive;
|
|
public bool CaseSensitive
|
|
{
|
|
get { return _CaseSensitive; }
|
|
set { _CaseSensitive = value; }
|
|
}
|
|
private ItemSearchIncludeLinks _IncludeLinks;
|
|
public ItemSearchIncludeLinks IncludeLinks
|
|
{
|
|
get { return _IncludeLinks; }
|
|
set { _IncludeLinks = value; }
|
|
}
|
|
private bool _IncludeRtfFormatting;
|
|
public bool IncludeRtfFormatting
|
|
{
|
|
get { return _IncludeRtfFormatting; }
|
|
set { _IncludeRtfFormatting = value; }
|
|
}
|
|
private bool _IncludeSpecialCharacters;
|
|
public bool IncludeSpecialCharacters
|
|
{
|
|
get { return _IncludeSpecialCharacters; }
|
|
set { _IncludeSpecialCharacters = value; }
|
|
}
|
|
public ItemListSearchCriteria(string docVersionList, string stepTypeList, string searchString,
|
|
bool caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters)
|
|
{
|
|
_DocVersionList = docVersionList;
|
|
_StepTypeList = stepTypeList;
|
|
_SearchString = searchString;
|
|
_CaseSensitive = caseSensitive;
|
|
_IncludeLinks = includeLinks;
|
|
_IncludeRtfFormatting = includeRtfFormatting;
|
|
_IncludeSpecialCharacters = includeSpecialCharacters;
|
|
}
|
|
}
|
|
private void DataPortal_Fetch(ItemListSearchCriteria criteria)
|
|
{
|
|
this.RaiseListChangedEvents = false;
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
cm.CommandText = "vesp_SearchItemAndChildren";
|
|
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
|
|
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
|
|
cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
|
|
cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive ? 1 : 0);
|
|
cm.Parameters.AddWithValue("@IncludeLinks", (int) criteria.IncludeLinks);
|
|
cm.Parameters.AddWithValue("@IncludeRtfFormatting", criteria.IncludeRtfFormatting ? 1 : 0);
|
|
cm.Parameters.AddWithValue("@IncludeSpecialCharacters", criteria.IncludeSpecialCharacters ? 1 : 0);
|
|
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._SearchDVPath = dr.GetString("DVPath");
|
|
itemInfo._SearchPath = dr.GetString("Path");
|
|
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;
|
|
}
|
|
#endregion
|
|
#region RO Search
|
|
public static ItemInfoList GetListFromROSearch(string docVersionList, string stepTypeList, string roSearchString)
|
|
{
|
|
try
|
|
{
|
|
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListROSearchCriteria(docVersionList, stepTypeList, roSearchString));
|
|
ItemInfo.AddList(tmp);
|
|
tmp.AddEvents();
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
|
|
}
|
|
}
|
|
[Serializable()]
|
|
private class ItemListROSearchCriteria
|
|
{
|
|
private string _DocVersionList;
|
|
public string DocVersionList
|
|
{
|
|
get { return _DocVersionList; }
|
|
set { _DocVersionList = value; }
|
|
}
|
|
private string _StepTypeList;
|
|
public string StepTypeList
|
|
{
|
|
get { return _StepTypeList; }
|
|
set { _StepTypeList = value; }
|
|
}
|
|
private string _ROSearchString;
|
|
public string ROSearchString
|
|
{
|
|
get { return _ROSearchString; }
|
|
set { _ROSearchString = value; }
|
|
}
|
|
public ItemListROSearchCriteria(string docVersionList, string stepTypeList, string roSearchString)
|
|
{
|
|
_DocVersionList = docVersionList;
|
|
_StepTypeList = stepTypeList;
|
|
_ROSearchString = roSearchString;
|
|
}
|
|
}
|
|
private void DataPortal_Fetch(ItemListROSearchCriteria criteria)
|
|
{
|
|
this.RaiseListChangedEvents = false;
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
cm.CommandText = "vesp_SearchROItemAndChildren";
|
|
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
|
|
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
|
|
cm.Parameters.AddWithValue("@ROSearchString", criteria.ROSearchString);
|
|
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._SearchDVPath = dr.GetString("DVPath");
|
|
itemInfo._SearchPath = dr.GetString("Path");
|
|
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;
|
|
}
|
|
#endregion
|
|
#region Annotation Search
|
|
public static ItemInfoList GetListFromAnnotationSearch(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive)
|
|
{
|
|
try
|
|
{
|
|
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListAnnotationSearchCriteria(docVersionList, stepTypeList, annotationTypeList, searchString, caseSensitive));
|
|
ItemInfo.AddList(tmp);
|
|
tmp.AddEvents();
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
|
|
}
|
|
}
|
|
[Serializable()]
|
|
private class ItemListAnnotationSearchCriteria
|
|
{
|
|
private string _DocVersionList;
|
|
public string DocVersionList
|
|
{
|
|
get { return _DocVersionList; }
|
|
set { _DocVersionList = value; }
|
|
}
|
|
private string _StepTypeList;
|
|
public string StepTypeList
|
|
{
|
|
get { return _StepTypeList; }
|
|
set { _StepTypeList = value; }
|
|
}
|
|
private string _AnnotationTypeList;
|
|
public string AnnotationTypeList
|
|
{
|
|
get { return _AnnotationTypeList; }
|
|
set { _AnnotationTypeList = value; }
|
|
}
|
|
private string _SearchString;
|
|
public string SearchString
|
|
{
|
|
get { return _SearchString; }
|
|
set { _SearchString = value; }
|
|
}
|
|
private bool _CaseSensitive;
|
|
public bool CaseSensitive
|
|
{
|
|
get { return _CaseSensitive; }
|
|
set { _CaseSensitive = value; }
|
|
}
|
|
public ItemListAnnotationSearchCriteria(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive)
|
|
{
|
|
_DocVersionList = docVersionList;
|
|
_StepTypeList = stepTypeList;
|
|
_AnnotationTypeList = annotationTypeList;
|
|
_SearchString = searchString;
|
|
_CaseSensitive = caseSensitive;
|
|
}
|
|
}
|
|
private void DataPortal_Fetch(ItemListAnnotationSearchCriteria criteria)
|
|
{
|
|
this.RaiseListChangedEvents = false;
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cm = cn.CreateCommand())
|
|
{
|
|
cm.CommandType = CommandType.StoredProcedure;
|
|
cm.CommandText = "vesp_SearchAnnotationItemAndChildren";
|
|
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
|
|
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
|
|
cm.Parameters.AddWithValue("@AnnotationTypeList", criteria.AnnotationTypeList);
|
|
cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
|
|
cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive ? 1 : 0);
|
|
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._SearchDVPath = dr.GetString("DVPath");
|
|
itemInfo._SearchPath = dr.GetString("Path");
|
|
itemInfo._SearchAnnotationID = dr.GetInt32("SearchAnnotationID");
|
|
itemInfo._SearchAnnotationText = dr.GetString("SearchText");
|
|
itemInfo._SearchAnnotationType = dr.GetString("AnnotationType");
|
|
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;
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region ProcedureInfo
|
|
[Serializable()]
|
|
public partial class ProcedureInfo : ItemInfo, IVEDrillDownReadOnly
|
|
{
|
|
protected override void RefreshFields(Item tmp)
|
|
{
|
|
base.RefreshFields(tmp);
|
|
ExtensionRefreshFields(tmp);
|
|
}
|
|
#if ItemWithContent
|
|
public ProcedureInfo(SafeDataReader dr) : base(dr, true) { }
|
|
#else
|
|
public ProcedureInfo(SafeDataReader dr) : base(dr) { }
|
|
#endif
|
|
private ProcedureInfo() : base() { ;}
|
|
public new static ProcedureInfo Get(int itemID)
|
|
{
|
|
//if (!CanGetObject())
|
|
// throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
ProcedureInfo tmp = GetCachedByPrimaryKey(itemID) as ProcedureInfo;
|
|
if (tmp == null)
|
|
{
|
|
tmp = DataPortal.Fetch<ProcedureInfo>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
public void MoveProcedure(IVEDrillDownReadOnly pInfo, int index)
|
|
{
|
|
using (Item ii = Item.Get(this.ItemID))
|
|
{
|
|
ii.MoveItem(pInfo, index);
|
|
}
|
|
}
|
|
public new Procedure Get()
|
|
{
|
|
return (Procedure) (_Editable = Procedure.Get(ItemID));
|
|
}
|
|
#region ProcedureConfig
|
|
[NonSerialized]
|
|
private ProcedureConfig _ProcedureConfig;
|
|
public ProcedureConfig ProcedureConfig
|
|
{ get { return (_ProcedureConfig != null ? _ProcedureConfig : _ProcedureConfig = new ProcedureConfig(this)); } }
|
|
#endregion
|
|
public new ConfigDynamicTypeDescriptor MyConfig
|
|
{
|
|
get { return ProcedureConfig ; }
|
|
}
|
|
}
|
|
#endregion
|
|
#region Procedure
|
|
[Serializable()]
|
|
public partial class Procedure : Item
|
|
{
|
|
public new static Procedure Get(int itemID)
|
|
{
|
|
if (!CanGetObject())
|
|
throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
Item itm = GetCachedByPrimaryKey(itemID);
|
|
Procedure tmp = itm as Procedure;
|
|
//Procedure tmp = (Procedure)GetExistingByPrimaryKey(itemID);
|
|
if (tmp == null)
|
|
{
|
|
if (itm != null) Console.WriteLine("type = {0}", itm.GetType().Name);
|
|
tmp = DataPortal.Fetch<Procedure>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
public new Procedure Save()
|
|
{
|
|
return (Procedure)base.Save();
|
|
}
|
|
public static Procedure MakeProcedure(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string procNumber, string procTitle, int procType)
|
|
{
|
|
int newitemid = MakeNewItem(parentInfo, previousInfo, procNumber, procTitle, procType, E_FromType.Procedure);
|
|
return Procedure.Get(newitemid);
|
|
}
|
|
#region ProcedureConfig
|
|
[NonSerialized]
|
|
private ProcedureConfig _ProcedureConfig;
|
|
public ProcedureConfig ProcedureConfig
|
|
{
|
|
get
|
|
{
|
|
if (_ProcedureConfig == null)
|
|
{
|
|
_ProcedureConfig = new ProcedureConfig(this);
|
|
_ProcedureConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_ProcedureConfig_PropertyChanged);
|
|
}
|
|
return _ProcedureConfig;
|
|
}
|
|
}
|
|
private void _ProcedureConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
MyContent.Config = _ProcedureConfig.ToString();
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region SectionInfo
|
|
[Serializable()]
|
|
public partial class SectionInfo : ItemInfo, IVEDrillDownReadOnly
|
|
{
|
|
protected override void RefreshFields(Item tmp)
|
|
{
|
|
base.RefreshFields(tmp);
|
|
ExtensionRefreshFields(tmp);
|
|
}
|
|
#if ItemWithContent
|
|
public SectionInfo(SafeDataReader dr) : base(dr, true) { }
|
|
#else
|
|
public SectionInfo(SafeDataReader dr) : base(dr) { }
|
|
#endif
|
|
private SectionInfo() : base() { ;}
|
|
public new static SectionInfo Get(int itemID)
|
|
{
|
|
//if (!CanGetObject())
|
|
// throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
SectionInfo tmp = GetCachedByPrimaryKey(itemID) as SectionInfo;
|
|
if (tmp == null)
|
|
{
|
|
tmp = DataPortal.Fetch<SectionInfo>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
public void MoveSection(IVEDrillDownReadOnly pInfo, int index)
|
|
{
|
|
using (Item ii = Item.Get(this.ItemID))
|
|
{
|
|
ii.MoveItem(pInfo, index);
|
|
}
|
|
}
|
|
public new Section Get()
|
|
{
|
|
return (Section)(_Editable = Section.Get(ItemID));
|
|
}
|
|
|
|
#region SectionConfig
|
|
[NonSerialized]
|
|
private SectionConfig _SectionConfig;
|
|
public SectionConfig SectionConfig
|
|
{ get { return (_SectionConfig != null ? _SectionConfig : _SectionConfig = new SectionConfig(this)); } }
|
|
#endregion
|
|
public new ConfigDynamicTypeDescriptor MyConfig
|
|
{
|
|
get { return SectionConfig; }
|
|
}
|
|
}
|
|
#endregion
|
|
#region Section
|
|
[Serializable()]
|
|
public partial class Section : Item
|
|
{
|
|
public new static Section Get(int itemID)
|
|
{
|
|
if (!CanGetObject())
|
|
throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
Section tmp = GetCachedByPrimaryKey(itemID) as Section;
|
|
if (tmp == null)
|
|
{
|
|
tmp = DataPortal.Fetch<Section>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
public new Section Save()
|
|
{
|
|
return (Section)base.Save();
|
|
}
|
|
public static Section MakeSection(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string sectNumber, string sectTitle, int sectType)
|
|
{
|
|
int newitemid = MakeNewItem(parentInfo, previousInfo, sectNumber, sectTitle, sectType, E_FromType.Section);
|
|
return Section.Get(newitemid);
|
|
}
|
|
#region SectionConfig
|
|
[NonSerialized]
|
|
private SectionConfig _SectionConfig;
|
|
public SectionConfig SectionConfig
|
|
{
|
|
get
|
|
{
|
|
if (_SectionConfig == null)
|
|
{
|
|
_SectionConfig = new SectionConfig(this);
|
|
_SectionConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_SectionConfig_PropertyChanged);
|
|
}
|
|
return _SectionConfig;
|
|
}
|
|
}
|
|
private void _SectionConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
MyContent.Config = _SectionConfig.ToString();
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region StepInfo
|
|
[Serializable()]
|
|
public partial class StepInfo : ItemInfo
|
|
{
|
|
protected override void RefreshFields(Item tmp)
|
|
{
|
|
base.RefreshFields(tmp);
|
|
ExtensionRefreshFields(tmp);
|
|
}
|
|
//public override string ToString()
|
|
//{
|
|
// return "Step " + base.ToString();
|
|
//}
|
|
#if ItemWithContent
|
|
public StepInfo(SafeDataReader dr) : base(dr, true) { }
|
|
#else
|
|
public StepInfo(SafeDataReader dr) : base(dr) { }
|
|
#endif
|
|
private StepInfo() : base() { ;}
|
|
public new static StepInfo Get(int itemID)
|
|
{
|
|
//if (!CanGetObject())
|
|
// throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
StepInfo tmp = GetCachedByPrimaryKey(itemID) as StepInfo;
|
|
if (tmp == null)
|
|
{
|
|
tmp = DataPortal.Fetch<StepInfo>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
public void MoveStep(IVEDrillDownReadOnly pInfo, int index)
|
|
{
|
|
using (Item ii = Item.Get(this.ItemID))
|
|
{
|
|
ii.MoveItem(pInfo, index);
|
|
}
|
|
}
|
|
public new Step Get()
|
|
{
|
|
return (Step)(_Editable = Step.Get(ItemID));
|
|
}
|
|
//public E_FromType FromType
|
|
//{ get { return E_FromType.Step; } }
|
|
}
|
|
|
|
#endregion
|
|
#region Step
|
|
[Serializable()]
|
|
public partial class Step : Item
|
|
{
|
|
public new static Step Get(int itemID)
|
|
{
|
|
if (!CanGetObject())
|
|
throw new System.Security.SecurityException("User not authorized to view a Item");
|
|
try
|
|
{
|
|
Step tmp = (Step)GetCachedByPrimaryKey(itemID);
|
|
if (tmp == null)
|
|
{
|
|
tmp = DataPortal.Fetch<Step>(new PKCriteria(itemID));
|
|
AddToCache(tmp);
|
|
}
|
|
if (tmp.ErrorMessage == "No Record Found") tmp = null;
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on Item.Get", ex);
|
|
}
|
|
}
|
|
// TODO :MakeCaution;
|
|
// TODO :MakeNote;
|
|
// TODO :MakeRNO;
|
|
// TODO :MakeSection;
|
|
// TODO :MakeSubStep;
|
|
// TODO :MakeTable;
|
|
public static Step MakeStep(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string stepNumber, string stepTitle, int stepType, E_FromType fromType)
|
|
{
|
|
int newitemid = MakeNewItem(parentInfo, previousInfo, stepNumber, stepTitle, stepType, fromType);
|
|
return Step.Get(newitemid);
|
|
}
|
|
//#region StepConfig
|
|
//[NonSerialized]
|
|
//private StepConfig _StepConfig;
|
|
//public StepConfig StepConfig
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_StepConfig == null)
|
|
// {
|
|
// _StepConfig = new StepConfig(this);
|
|
// _StepConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_StepConfig_PropertyChanged);
|
|
// }
|
|
// return _SectionConfig;
|
|
// }
|
|
//}
|
|
//private void _StepConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
//{
|
|
// MyContent.Config = _StepConfig.ToString();
|
|
//}
|
|
//#endregion
|
|
}
|
|
#endregion
|
|
public enum ItemSearchIncludeLinks
|
|
{
|
|
Nothing = 0,
|
|
Value = 1,
|
|
Everything =2
|
|
}
|
|
}
|