2103 lines
62 KiB
C#
2103 lines
62 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Text.RegularExpressions;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Linq;
|
|
|
|
using Csla.Data;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace VEPROMS.CSLA.Library
|
|
{
|
|
|
|
[Flags]
|
|
public enum E_ROValueType : uint
|
|
{
|
|
All = 0,
|
|
Text = 1,
|
|
Table = 2,
|
|
Graph = 4,
|
|
Image = 8,
|
|
Video = 16,
|
|
Hologram = 32
|
|
}
|
|
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ROFSTLookup
|
|
{
|
|
#region Log4Net
|
|
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
#endregion
|
|
|
|
#region Enums
|
|
|
|
[Flags]
|
|
public enum SearchTypes
|
|
{
|
|
StartsWith = 1,
|
|
EndsWith = 2,
|
|
Contains = 3,
|
|
ExactMatch = 4
|
|
}
|
|
|
|
public enum HeaderStatuses
|
|
{
|
|
Unknown = 0,
|
|
NotLoaded = 1,
|
|
InProgress = 2,
|
|
LoadComplete = 3,
|
|
LoadFailed = 4
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Structs / Internal Classes
|
|
|
|
[Serializable]
|
|
public struct roHdr
|
|
{
|
|
public int hSize;
|
|
public int hYear;
|
|
public byte hMonth;
|
|
public byte hDay;
|
|
public int hcYear;
|
|
public byte hcMonth;
|
|
public byte hcDay;
|
|
public byte hcHour;
|
|
public byte hcMin;
|
|
public byte hcSec;
|
|
public byte hcHund;
|
|
public rodbi[] myDbs;
|
|
};
|
|
|
|
[Serializable]
|
|
public struct rodbi
|
|
{
|
|
public int dbiID;
|
|
public int dbiType;
|
|
public int dbiAW;
|
|
public string dbiTitle;
|
|
public string dbiAP;
|
|
public int ID;
|
|
public int ParentID;
|
|
public rochild[] children;
|
|
};
|
|
|
|
[Serializable]
|
|
public struct rogrp
|
|
{
|
|
public string value;
|
|
public string appid;
|
|
public int ID;
|
|
public int ParentID;
|
|
public rochild[] children;
|
|
};
|
|
|
|
[Serializable]
|
|
public struct rochild
|
|
{
|
|
public int ID;
|
|
public int ParentID;
|
|
public int type;
|
|
public string title; // gets used for treeview
|
|
public string roid; // roid unique identifier
|
|
public string appid; // accessory page id - user specified unique id
|
|
public string value; // return value, can be multiple values
|
|
public rochild[] children;
|
|
};
|
|
|
|
public class RoExtension
|
|
{
|
|
public int Offset;
|
|
public string RoidExt;
|
|
public string AccPageExt;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Fields
|
|
|
|
public static Regex regRoKeyHigh = new Regex("( |-|_)(HIGH|HI)([0-9])");
|
|
public static Regex regRoKeyLow = new Regex("( |-|_)(LOW|LO)([0-9])");
|
|
|
|
public const string RoMissingDefaultValue = "[TBD]";
|
|
|
|
private static List<RoExtension> _extensions;
|
|
|
|
// RofstLookup/Conversion Variables
|
|
private int _rofstID;
|
|
private DocVersionInfo _myDocVersionInfo;
|
|
private int _selectedSlave;
|
|
private string _otherChild = string.Empty;
|
|
|
|
private List<string> _lstRoValues;
|
|
private List<string> _multiRoValues;
|
|
private Dictionary<string, string> _dicRoVars;
|
|
|
|
private ItemInfo _itemInfo;
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public int RofstID
|
|
{
|
|
get { return _rofstID; }
|
|
}
|
|
|
|
public DocVersionInfo MyDocVersionInfo
|
|
{
|
|
get { return _myDocVersionInfo; }
|
|
set
|
|
{
|
|
_myDocVersionInfo = value;
|
|
_selectedSlave = (_myDocVersionInfo == null) ? 0 : _myDocVersionInfo.DocVersionConfig.SelectedSlave;
|
|
}
|
|
}
|
|
|
|
// C2021-065 see if we need to get the RO information for the "Other" Child applicability value
|
|
public int SelectedSlave
|
|
{
|
|
get { return (!string.IsNullOrEmpty(_otherChild)) ? Convert.ToInt32(_otherChild) : _selectedSlave; }
|
|
}
|
|
|
|
//C2021-065 used by Barakah Alarms so that we get ROLookUp for the Other applicability
|
|
public string OtherChild
|
|
{
|
|
get { return _otherChild; }
|
|
set { _otherChild = value; }
|
|
}
|
|
|
|
// B2022-020 to pass information into error log if needed
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _itemInfo; }
|
|
set { _itemInfo = value; }
|
|
}
|
|
|
|
public List<RoExtension> Extensions
|
|
{
|
|
get
|
|
{
|
|
if (_extensions == null)
|
|
{
|
|
_extensions = RofstDataGetExtensions();
|
|
}
|
|
|
|
return _extensions;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public ROFSTLookup(int rofstID, DocVersionInfo dvi, string otherChild)
|
|
{
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = dvi;
|
|
_otherChild = otherChild;
|
|
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
public ROFSTLookup(int rofstID, DocVersionInfo dvi)
|
|
{
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = dvi;
|
|
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
public ROFSTLookup(int rofstID)
|
|
{
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = null;
|
|
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
|
|
#region (RO Search / Collections)
|
|
|
|
public Dictionary<string, string> Search(string value, int searchTypeID, bool onlyRoid16, int? maxNumRecords = null)
|
|
{
|
|
if (string.IsNullOrEmpty(value))
|
|
return null;
|
|
|
|
return RofstDataSearch(_rofstID, value, searchTypeID, onlyRoid16, maxNumRecords);
|
|
}
|
|
|
|
public ROFSTLookup.rochild[] GetRoChildrenByID(int id, int dbiID, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
return RofstDataGetChildrenByID(_rofstID, dbiID, id, loadChildren, loadAllChildren);
|
|
}
|
|
|
|
public ROFSTLookup.rochild[] GetRoChildrenByRoid(string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
return RofstDataGetChildrenByRoid(_rofstID, roid, loadChildren, loadAllChildren);
|
|
}
|
|
|
|
public ROFSTLookup.rochild[] GetRoChildrenByType(E_ROValueType valueTypes, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
return RofstDataGetRoChildrenByType(_rofstID, valueTypes, loadChildren, loadAllChildren);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (RO Database Info)
|
|
|
|
public int GetRODatabaseTitleIndex(string roid)
|
|
{
|
|
return Convert.ToInt32("0x" + roid.Substring(0, 4), 16);
|
|
}
|
|
|
|
public string GetRODatabaseTitle(int idx)
|
|
{
|
|
ROFSTLookup.rodbi rd = RofstDataGetDatabaseByID(_rofstID, idx);
|
|
return (!string.IsNullOrEmpty(rd.dbiTitle) ? rd.dbiTitle : "RO Database Title Not Found");
|
|
}
|
|
|
|
public ROFSTLookup.rodbi GetRODatabase(string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
int idx = GetRODatabaseTitleIndex(roid);
|
|
ROFSTLookup.rodbi rd = RofstDataGetDatabaseByID(_rofstID, idx, loadChildren, loadAllChildren);
|
|
return (rd.dbiID > 0) ? rd : RofstDataGetDatabaseByID(_rofstID, 1, loadChildren, loadAllChildren);
|
|
}
|
|
|
|
public ROFSTLookup.rodbi[] GetRODatabaseList(bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
return RofstDataGetDatabases(_rofstID, loadChildren, loadAllChildren);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (RO Info By AccPageID)
|
|
|
|
public static string FormatAccPageKey(string accPageID, string spDefault, string igDefault)
|
|
{
|
|
if (!string.IsNullOrEmpty(accPageID))
|
|
{
|
|
accPageID = accPageID.ToUpper();
|
|
|
|
if (!accPageID.StartsWith("<"))
|
|
accPageID = string.Format("<{0}", accPageID);
|
|
|
|
if (!accPageID.EndsWith(">"))
|
|
accPageID = string.Format("{0}>", accPageID);
|
|
|
|
accPageID = accPageID.Replace("<U>", "<U-ID>");
|
|
accPageID = accPageID.ToCleanString(); // Removes any spaces
|
|
|
|
// Clean up the AccPageID before using it to do a lookup
|
|
if (!string.IsNullOrEmpty(spDefault))
|
|
accPageID = accPageID.Replace("<SP-", "<" + spDefault + "-");
|
|
|
|
if (!string.IsNullOrEmpty(igDefault))
|
|
accPageID = accPageID.Replace("<IG-", "<" + igDefault + "-");
|
|
|
|
if (!accPageID.StartsWith("<U-"))
|
|
accPageID = accPageID.Trim("<>".ToCharArray()); // String < and >
|
|
|
|
accPageID = regRoKeyHigh.Replace(accPageID, "_HIGH$3");
|
|
accPageID = regRoKeyLow.Replace(accPageID, "_LOW$3");
|
|
accPageID = accPageID.ToUpper();
|
|
}
|
|
|
|
return accPageID;
|
|
}
|
|
|
|
public static string FormatAccPageKey(string accPageID, string spDefault, string igDefault, ref string accPageBase, ref string accPageExt, bool useDefaultExt = true)
|
|
{
|
|
string accPageKey = FormatAccPageKey(accPageID, spDefault, igDefault);
|
|
|
|
if (Regex.IsMatch(accPageKey, @".*\.[A-Z]"))
|
|
{
|
|
accPageBase = accPageKey.Substring(0, accPageKey.Length - 2);
|
|
accPageExt = Convert.ToString(accPageKey.ToCharArray().LastOrDefault());
|
|
}
|
|
else
|
|
{
|
|
accPageBase = accPageKey;
|
|
accPageExt = (!accPageKey.StartsWith("<U-") && useDefaultExt) ? "A" : string.Empty;
|
|
}
|
|
|
|
return accPageKey;
|
|
}
|
|
|
|
public ROFSTLookup.rochild GetROChildByAccPageID(string accPageID, string spDefault, string igDefault)
|
|
{
|
|
string accPageKey = FormatAccPageKey(accPageID, spDefault, igDefault);
|
|
|
|
ROFSTLookup.rochild rc = RofstDataGetChildByAccPageID(_rofstID, accPageID, spDefault, igDefault);
|
|
|
|
if (!string.IsNullOrEmpty(rc.roid) && Regex.IsMatch(accPageKey, @".*\.[A-Z]") && rc.children != null && rc.children.Count() > 0)
|
|
{
|
|
// Check if AccPageID/Key has a return value specific extension. Try to find the RoChild record with the specific return value type,
|
|
// If not found Or the specific extension value is (Null or Empty), then just return the first/default return value type in the list of children
|
|
var accPageExt = Convert.ToString(accPageKey.ToCharArray().LastOrDefault());
|
|
var roExt = Extensions.Where(x => x.AccPageExt.Equals(accPageExt)).SingleOrDefault();
|
|
|
|
return (rc.children.Where(x => x.roid.Substring(12, 4) == roExt.RoidExt && !string.IsNullOrEmpty(x.value)).Any()) ? rc.children.Where(x => x.roid.Substring(12, 4) == roExt.RoidExt).Single() : rc.children.First();
|
|
}
|
|
|
|
return rc; // If RoChild is not found, then a default (ROFSTLookup.rochild) object will be returned, but its ID will be -1
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (RO Info By Roid)
|
|
|
|
public static string FormatRoidKey(string roid, bool check16Digits = false)
|
|
{
|
|
if (!string.IsNullOrEmpty(roid))
|
|
{
|
|
roid = roid.ToUpper();
|
|
roid = roid.Replace("<U>", "<U-ID>");
|
|
roid = roid.ToCleanString(); // Removes any spaces
|
|
|
|
if ((!roid.StartsWith("<U-")) && ((roid.Length == 16 && roid.EndsWith("0000")) || (check16Digits && roid.Length < 16)))
|
|
{
|
|
roid = string.Format("{0}0041", roid.Substring(0, 12));
|
|
}
|
|
}
|
|
|
|
return roid;
|
|
}
|
|
|
|
public static string FormatRoidKey(string roid, ref string roid12, ref string roidExt, bool check16Digits = false)
|
|
{
|
|
roid = FormatRoidKey(roid, check16Digits);
|
|
|
|
// Default / Initialize Reference Parameters
|
|
roid12 = string.Empty;
|
|
roidExt = string.Empty;
|
|
|
|
if (!string.IsNullOrEmpty(roid) && !roid.StartsWith("<U-"))
|
|
{
|
|
roid12 = roid.Substring(0, 12);
|
|
if (roid.Length == 16) roidExt = roid.Substring(12, 4);
|
|
}
|
|
|
|
return roid;
|
|
}
|
|
|
|
public ROFSTLookup.rochild GetRoChild(string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
// Cleanup Roid if necessary (Note* This method also handles the UnitInfo Ro Values. ex: "<U-NUMBER>")
|
|
roid = FormatRoidKey(roid);
|
|
|
|
ROFSTLookup.rochild rc = GetRoChild12(roid, loadChildren, loadAllChildren);
|
|
|
|
if (!roid.StartsWith("FFFF") && roid.Length == 16 && rc.children != null && rc.children.Length > 0)
|
|
{
|
|
// If specific match exists for multi-return values, then return specified value, otherwise default to the first child
|
|
if (rc.children.Where(x => x.roid.ToUpper() == roid.ToUpper()).Any())
|
|
return rc.children.Where(x => x.roid.ToUpper() == roid.ToUpper()).Single();
|
|
else
|
|
return rc.children.First();
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
public string GetRoValue(string roid)
|
|
{
|
|
return GetRoChild(roid).value;
|
|
}
|
|
|
|
public string GetTranslatedRoValue(string roid, bool DoCaret, bool DoDOSSuperSubScript)
|
|
{
|
|
roid = FormatRoidKey(roid);
|
|
|
|
string retval = GetRoValue(roid);
|
|
retval = ReplaceUnicode(retval, DoCaret);
|
|
retval = ConvertFortranFormatToScienctificNotation(retval);
|
|
|
|
// B2019-037 handle the super an sub scripts after getting the RO value from the FST
|
|
// the corrected RO text is added to the display text in the link info
|
|
if (DoDOSSuperSubScript)
|
|
{
|
|
retval = Regex.Replace(retval, "[#](.*?)[#]", "\\up2 $1\\up0 ");// Superscript
|
|
retval = Regex.Replace(retval, "[~](.*?)[~]", "\\dn2 $1\\up0 ");// Subscript
|
|
}
|
|
|
|
return (!string.IsNullOrEmpty(retval)) ? retval.Replace("\r\n", @"\par ") : retval;
|
|
}
|
|
|
|
public static string GetParentChildDefaultValue(string roval)
|
|
{
|
|
var test = GetParentChildROValue(roval, 0);
|
|
|
|
// C2021-026 Get the Parent (Default) RO value if the return value include P/C information otherwise return the RO value as is.
|
|
// This is used for the insert RO interface on the Step Properties panel
|
|
if (string.IsNullOrEmpty(roval))
|
|
return null;
|
|
|
|
|
|
string rntval = roval.Replace("\xFF", "\xa0").Replace(@"\u160?", " ");
|
|
|
|
while (rntval.Contains("<APL DefaultVal=")) // C2021-026 remove Parent/Child values for the menu item text
|
|
{
|
|
int startCVIdx = rntval.IndexOf("<APL DefaultVal=");
|
|
int EndCVidx = rntval.IndexOf(" /APL>", startCVIdx);
|
|
string aplicValues = rntval.Substring(startCVIdx, EndCVidx + 6 - startCVIdx);
|
|
int endDefIdx = rntval.IndexOf(",", startCVIdx);
|
|
|
|
// C2022-001 - handle if there is no child value in the RO FSt
|
|
// B2022-051 - was sometimes leaving "/APL>" when processing return value made up from multiple RO (editor) fields
|
|
// added check to make where next found comma was within the current <APL ... /APL>
|
|
string defValue = rntval.Substring(startCVIdx + 16, ((endDefIdx > 0 && endDefIdx < EndCVidx) ? endDefIdx : EndCVidx) - (startCVIdx + 16));
|
|
rntval = rntval.Replace(aplicValues, defValue);
|
|
}
|
|
|
|
rntval = rntval.Trim();
|
|
|
|
// If Default Value is selected (selChldIdx = 0), and return value is empty then replace with Standard Missing Default Value
|
|
return (string.IsNullOrEmpty(rntval)) ? ROFSTLookup.RoMissingDefaultValue : rntval;
|
|
//return rntval;
|
|
}
|
|
|
|
|
|
|
|
public List<string> GetValueDifferences(int originalRofstID, ref List<string> delList)
|
|
{
|
|
return RofstDataGetValueDifferences(originalRofstID, _rofstID, ref delList);
|
|
}
|
|
|
|
public List<string> GetROTitleAndGroupPath(string roid, bool reportMissingROs, bool convertCaretToDelta)
|
|
{
|
|
// Return the RO Title in a list of strings. The last item in the list is the actual RO title,
|
|
// the items preceding it are the titles of the groups and sub-groups containing the RO
|
|
|
|
List<string> titlePath = new List<string>();
|
|
|
|
roid = FormatRoidKey(roid);
|
|
|
|
ROFSTLookup.rochild roc = GetRoChild12(roid);
|
|
|
|
if (!string.IsNullOrEmpty(roc.appid))
|
|
{
|
|
string tmp = roc.title;
|
|
|
|
if (!string.IsNullOrEmpty(roc.appid) && roc.title.Contains(roc.appid))
|
|
{
|
|
tmp = roc.title.Replace(roc.appid, string.Empty).Trim();
|
|
}
|
|
|
|
tmp = string.Format("[{0}] {1}", roc.appid, tmp);
|
|
tmp = tmp.Replace("`", "\u00B0"); //degree
|
|
tmp = tmp.Replace("\xF8", "\u00B0"); //degree
|
|
if (convertCaretToDelta) tmp = tmp.Replace("^", "\u0394"); // delta
|
|
|
|
titlePath.Add(tmp);
|
|
|
|
if (roc.ParentID > 0)
|
|
{
|
|
do
|
|
{
|
|
string parent = roid.Substring(0, 4) + string.Format("{0:X8}", roc.ParentID);
|
|
roc = GetRoChild12(parent);
|
|
if (roc.ID >= 0) titlePath.Add(roc.title.Trim());
|
|
|
|
} while (roc.ID >= 0);
|
|
}
|
|
|
|
titlePath.Reverse();
|
|
}
|
|
else if (reportMissingROs) // Missing RO, put a message with the ROID on the report...
|
|
{
|
|
titlePath.Add(string.Format("Missing RO for ROID {0}", roid));
|
|
}
|
|
|
|
return titlePath;
|
|
}
|
|
|
|
public string GetROTitle(string roid)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
roid = FormatRoidKey(roid);
|
|
ROFSTLookup.rochild rc = GetRoChild(roid);
|
|
|
|
// B2020-125: View of Consistency check report displaying error message and crashing. And also in 'else' check for null
|
|
if (rc.ID < 0)
|
|
{
|
|
sb.Append("Could not find RO data");
|
|
}
|
|
else
|
|
{
|
|
string tmp = string.Empty;
|
|
if (!string.IsNullOrEmpty(rc.title)) tmp = rc.title;
|
|
if (!string.IsNullOrEmpty(rc.appid)) tmp = tmp.Replace(rc.appid, string.Empty);
|
|
if (!string.IsNullOrEmpty(rc.value)) tmp = tmp.Replace(rc.value, string.Empty);
|
|
sb.Append(tmp.Trim());
|
|
}
|
|
|
|
if (rc.ParentID > 0)
|
|
{
|
|
do
|
|
{
|
|
string parentROID = roid.Substring(0, 4) + string.Format("{0:X8}", rc.ParentID);
|
|
rc = GetRoChild12(parentROID);
|
|
if (rc.ID > 0) sb.Insert(0, rc.title + " - ");
|
|
|
|
} while (rc.ID > 0);
|
|
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (RO Info Helper Methods)
|
|
|
|
public static byte[] GetRofstLookupBytes(int rofstID)
|
|
{
|
|
return RofstDataGetRofstLookupBytes(rofstID);
|
|
}
|
|
|
|
public static DateTime GetRoFSTdts(int rofstID)
|
|
{
|
|
return GetRofstDtsByID(rofstID);
|
|
}
|
|
|
|
public DateTime GetRoFSTdts()
|
|
{
|
|
return GetRoFSTdts(_rofstID);
|
|
}
|
|
|
|
public bool HasChildren(ref ROFSTLookup.rochild child)
|
|
{
|
|
LoadChildren(ref child);
|
|
return child.children.Any();
|
|
}
|
|
|
|
public bool HasChildren(ref ROFSTLookup.rodbi db)
|
|
{
|
|
LoadChildren(ref db);
|
|
return db.children.Any();
|
|
}
|
|
|
|
public void LoadChildren(ref ROFSTLookup.rochild child)
|
|
{
|
|
// If Children is null then it hasn't been loaded yet
|
|
if (child.children == null)
|
|
{
|
|
if (!string.IsNullOrEmpty(child.appid))
|
|
child = GetRoChild12(child.roid, true);
|
|
else
|
|
child.children = GetRoChildrenByRoid(child.roid, false);
|
|
}
|
|
}
|
|
|
|
public void LoadChildren(ref ROFSTLookup.rodbi db)
|
|
{
|
|
// If Children is null then it hasn't been loaded yet
|
|
if (db.children == null)
|
|
db.children = GetRoChildrenByID(db.ID, db.dbiID, false);
|
|
}
|
|
|
|
public static ROFSTLookup.rochild GetEmptyRoChild()
|
|
{
|
|
return new ROFSTLookup.rochild() { ID = -1, type = 0 };
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
#region (Database Calls)
|
|
|
|
private bool RofstDataExists(int rofstID)
|
|
{
|
|
int headerStatusID = RofstDataGetHeaderLoadStatus(rofstID);
|
|
|
|
while (headerStatusID == (int)HeaderStatuses.InProgress)
|
|
{
|
|
// Wait 5 sec(s) then Check Header Status Again
|
|
Thread.Sleep(5000);
|
|
|
|
headerStatusID = RofstDataGetHeaderLoadStatus(rofstID);
|
|
}
|
|
|
|
return (headerStatusID == (int)HeaderStatuses.LoadComplete); // false includes [NotLoaded = 1 || LoadFailed = 4 || Unknown = 0]
|
|
}
|
|
|
|
private int RofstDataGetHeaderLoadStatus(int rofstID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetHeaderRofstByID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read()) return Convert.ToInt32(dr.GetValue("RofstHeaderStatusID"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0; // Unknown Status
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetHeaderRofstByID", ex);
|
|
}
|
|
}
|
|
|
|
private static byte[] RofstDataGetRofstLookupBytes(int rofstID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetRofstByID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@IncludeRoLookup", SqlDbType.Bit)).Value = 1;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read()) return (byte[])dr.GetValue("ROLookup");
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetRofstByID", ex);
|
|
}
|
|
}
|
|
|
|
private static DateTime GetRofstDtsByID(int rofstID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetRofstByID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@IncludeRoLookup", SqlDbType.Bit)).Value = 0;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read()) return (DateTime)dr.GetValue("DTS");
|
|
}
|
|
}
|
|
}
|
|
|
|
return new DateTime();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetRofstByID", ex);
|
|
}
|
|
}
|
|
|
|
private void RofstHeaderInsert(int rofstID, int hSize, int hMonth, int hDay, int hcYear, int hcMonth, int hcDay, int hcHour, int hcMin, int hcSec, int hcHund, string userID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstHeaderInsert";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@hSize", SqlDbType.Int)).Value = hSize;
|
|
cmd.Parameters.Add(new SqlParameter("@hMonth", SqlDbType.Int)).Value = hMonth;
|
|
cmd.Parameters.Add(new SqlParameter("@hDay", SqlDbType.Int)).Value = hDay;
|
|
cmd.Parameters.Add(new SqlParameter("@hcYear", SqlDbType.Int)).Value = hcYear;
|
|
cmd.Parameters.Add(new SqlParameter("@hcMonth", SqlDbType.Int)).Value = hcMonth;
|
|
cmd.Parameters.Add(new SqlParameter("@hcDay", SqlDbType.Int)).Value = hcDay;
|
|
cmd.Parameters.Add(new SqlParameter("@hcHour", SqlDbType.Int)).Value = hcHour;
|
|
cmd.Parameters.Add(new SqlParameter("@hcMin", SqlDbType.Int)).Value = hcMin;
|
|
cmd.Parameters.Add(new SqlParameter("@hcSec", SqlDbType.Int)).Value = hcSec;
|
|
cmd.Parameters.Add(new SqlParameter("@hcHund", SqlDbType.Int)).Value = hcHund;
|
|
cmd.Parameters.Add(new SqlParameter("@userID", SqlDbType.VarChar)).Value = userID;
|
|
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("ROFSTLookup.RofstHeaderInsert.vesp_RofstHeaderInsert", ex);
|
|
}
|
|
}
|
|
|
|
private void RofstHeaderFinalizeLoad(int rofstID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstHeaderFinalizeLoad";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstHeaderFinalizeLoad", ex);
|
|
}
|
|
}
|
|
|
|
private void RofstDatabaseInsert(int rofstID, int dbiID, int dbiType, int dbiAW, string dbiTitle, string dbiAP, int id, int parentID)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDatabaseInsert";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiType", SqlDbType.Int)).Value = dbiType;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiAW", SqlDbType.Int)).Value = dbiAW;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiTitle", SqlDbType.VarChar)).Value = dbiTitle;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiAP", SqlDbType.VarChar)).Value = dbiAP;
|
|
cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;
|
|
cmd.Parameters.Add(new SqlParameter("@ParentID", SqlDbType.Int)).Value = parentID;
|
|
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDatabaseInsert", ex);
|
|
}
|
|
}
|
|
|
|
private void RofstChildInsert(int rofstID, int id, int parentID, int dbiID, int type, string title, string roid, string appid, string value)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstChildInsert";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;
|
|
cmd.Parameters.Add(new SqlParameter("@ParentID", SqlDbType.Int)).Value = parentID;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;
|
|
cmd.Parameters.Add(new SqlParameter("@type", SqlDbType.Int)).Value = type;
|
|
cmd.Parameters.Add(new SqlParameter("@title", SqlDbType.VarChar)).Value = title;
|
|
cmd.Parameters.Add(new SqlParameter("@roid", SqlDbType.VarChar)).Value = roid;
|
|
|
|
if (!string.IsNullOrEmpty(appid))
|
|
cmd.Parameters.Add(new SqlParameter("@appid", SqlDbType.VarChar)).Value = appid;
|
|
if (!string.IsNullOrEmpty(value))
|
|
cmd.Parameters.Add(new SqlParameter("@value", SqlDbType.VarChar)).Value = value;
|
|
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstChildInsert", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rodbi RofstDataGetDatabaseByID(int rofstID, int dbiID, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetDatabaseByID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read())
|
|
{
|
|
return ConvertToRodbiObject(dr, loadChildren, loadAllChildren);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new ROFSTLookup.rodbi();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetDatabaseByID", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rodbi[] RofstDataGetDatabases(int rofstID, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
List<ROFSTLookup.rodbi> dbs = new List<ROFSTLookup.rodbi>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetDatabases";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
dbs.Add(ConvertToRodbiObject(dr, loadChildren, loadAllChildren));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return dbs.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetDatabases", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rochild[] RofstDataGetChildrenByID(int rofstID, int dbiID, int id, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetChildrenByID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@DbiID", SqlDbType.Int)).Value = dbiID;
|
|
cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return lst.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetChildrenByID", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rochild[] RofstDataGetChildrenByRoid(int rofstID, string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetChildrenByRoid";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@Roid", SqlDbType.VarChar)).Value = roid;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return lst.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetChildrenByRoid", ex);
|
|
}
|
|
}
|
|
|
|
private List<string> RofstDataGetValueDifferences(int originalRofstID, int currentRofstID, ref List<string> delList)
|
|
{
|
|
// use this list to see what differences are between the current and the original
|
|
List<string> modList = new List<string>();
|
|
List<string> roidList = new List<string>();
|
|
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetValueDifferences";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@OriginalRofstID", SqlDbType.Int)).Value = originalRofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@CurrentRofstID", SqlDbType.Int)).Value = currentRofstID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
roidList.Add((string)dr.GetValue("Roid"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ROFSTLookup.rochild originalRoChild;
|
|
ROFSTLookup.rochild currentRoChild;
|
|
|
|
Dictionary<string, string> originalRos = new Dictionary<string, string>();
|
|
Dictionary<string, string> currentRos = new Dictionary<string, string>();
|
|
|
|
foreach (string roid in roidList)
|
|
{
|
|
originalRoChild = RofstDataGetChildByRoid(originalRofstID, roid);
|
|
originalRos.Add(originalRoChild.roid, originalRoChild.value);
|
|
|
|
if (originalRoChild.children != null && originalRoChild.children.Length > 0)
|
|
{
|
|
foreach (ROFSTLookup.rochild roc in originalRoChild.children)
|
|
{
|
|
originalRos.Add(roc.roid, roc.value);
|
|
}
|
|
}
|
|
|
|
currentRoChild = RofstDataGetChildByRoid(currentRofstID, roid);
|
|
currentRos.Add(currentRoChild.roid, currentRoChild.value);
|
|
|
|
if (currentRoChild.children != null && currentRoChild.children.Length > 0)
|
|
{
|
|
foreach (ROFSTLookup.rochild roc in currentRoChild.children)
|
|
{
|
|
currentRos.Add(roc.roid, roc.value);
|
|
}
|
|
}
|
|
}
|
|
|
|
string cvalue = string.Empty;
|
|
string ovalue = string.Empty;
|
|
|
|
foreach (string key in originalRos.Keys)
|
|
{
|
|
cvalue = null;
|
|
ovalue = originalRos[key];
|
|
|
|
if (currentRos.ContainsKey(key))
|
|
cvalue = currentRos[key];
|
|
|
|
if (cvalue == null && cvalue != ovalue)
|
|
delList.Add(key);
|
|
else if (cvalue != ovalue)
|
|
modList.Add(key);
|
|
}
|
|
|
|
return modList;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetValueDifferences", ex);
|
|
}
|
|
}
|
|
|
|
private Dictionary<string, string> RofstDataSearch(int rofstID, string value, int searchTypeID, bool onlyRoid16, int? maxNumRecords)
|
|
{
|
|
Dictionary<string, string> dic = new Dictionary<string, string>();
|
|
|
|
if (string.IsNullOrEmpty(value))
|
|
return dic;
|
|
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataSearch";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@Value", SqlDbType.VarChar)).Value = value;
|
|
cmd.Parameters.Add(new SqlParameter("@SearchTypeID", SqlDbType.Int)).Value = searchTypeID;
|
|
cmd.Parameters.Add(new SqlParameter("@OnlyRoid16", SqlDbType.Bit)).Value = (onlyRoid16) ? 1 : 0;
|
|
|
|
if (maxNumRecords != null)
|
|
cmd.Parameters.Add(new SqlParameter("@MaxNumOfRecords", SqlDbType.Int)).Value = (int)maxNumRecords;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
dic.Add((string)dr.GetValue("roid"), (string)dr.GetValue("value"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return dic;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataSearch", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rochild[] RofstDataGetRoChildrenByType(int rofstID, E_ROValueType valueTypes, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetChildrenByType";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@ValueTypes", SqlDbType.VarChar)).Value = valueTypes.ToCommaDelimString();
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return lst.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.RofstDataGetRoChildrenByType", ex);
|
|
}
|
|
}
|
|
|
|
private List<RoExtension> RofstDataGetExtensions()
|
|
{
|
|
try
|
|
{
|
|
List<RoExtension> lst = new List<RoExtension>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetExtensions";
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
lst.Add(ConvertToRoExtensionObject(dr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return lst;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetExtensions", ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (Core/Base logic for RO Values & UnitInfo RO Values)
|
|
|
|
private ROFSTLookup.rochild RofstDataGetChildByRoid(int rofstID, string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
// Cleanup Roid if necessary (Note* This method also handles the UnitInfo Ro Values. ex: "<U-NUMBER>")
|
|
roid = FormatRoidKey(roid);
|
|
|
|
// Check if roid is for a Unit Information RO Value Tag
|
|
if (!string.IsNullOrEmpty(roid) && roid.StartsWith("FFFF"))
|
|
{
|
|
return GetUnitInfoRoChild(roid);
|
|
}
|
|
|
|
// Lookup RO Value in the database based on the roid
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetChildByRoid";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@Roid", SqlDbType.VarChar)).Value = roid;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read())
|
|
{
|
|
return ConvertToRochildObject(dr, loadChildren, loadAllChildren);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return GetEmptyRoChild();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetChildByRoid", ex);
|
|
}
|
|
}
|
|
|
|
private ROFSTLookup.rochild RofstDataGetChildByAccPageID(int rofstID, string accPageID, string spDefault, string igDefault, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
try
|
|
{
|
|
// Cleanup / Reformat the AccPageID if necessary (Note* This method also handles the UnitInfo Ro Values. ex: "<U-NUMBER>")
|
|
string accPageKey = FormatAccPageKey(accPageID, spDefault, igDefault);
|
|
|
|
// Check if roid is for a Unit Information RO Value Tag
|
|
if (!string.IsNullOrEmpty(accPageKey) && accPageKey.StartsWith("<U-"))
|
|
{
|
|
return GetUnitInfoRoChild(GetUnitInfoRoidByAccPageID(accPageKey));
|
|
}
|
|
|
|
// Lookup RO Value in the database based on the AccPageKey
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetChildByAccPageID";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
|
|
cmd.Parameters.Add(new SqlParameter("@AccPageID", SqlDbType.VarChar)).Value = accPageKey;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read())
|
|
{
|
|
return ConvertToRochildObject(dr, loadChildren, loadAllChildren);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return GetEmptyRoChild();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetChildByAccPageID", ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (Parse/Load)
|
|
|
|
private ROFSTLookup.roHdr ConvertFst2Objects(byte[] ab)
|
|
{
|
|
ROFSTLookup.roHdr roh = new ROFSTLookup.roHdr();
|
|
|
|
roh.hSize = BitConverter.ToInt32(ab, 0);
|
|
roh.hYear = BitConverter.ToInt16(ab, 4);
|
|
roh.hMonth = ab[6];
|
|
roh.hDay = ab[7];
|
|
roh.hcYear = BitConverter.ToInt16(ab, 8);
|
|
roh.hcMonth = ab[10];
|
|
roh.hcDay = ab[11];
|
|
roh.hcHour = ab[12];
|
|
roh.hcMin = ab[13];
|
|
roh.hcSec = ab[14];
|
|
roh.hcHund = ab[15];
|
|
|
|
int hdrOffset = BitConverter.ToInt32(ab, 16);
|
|
int dbs = BitConverter.ToInt16(ab, hdrOffset + 4);
|
|
|
|
roh.myDbs = new ROFSTLookup.rodbi[dbs];
|
|
|
|
for (int i = 0; i < dbs; i++)
|
|
{
|
|
int offset = hdrOffset + 6 + (i * 30);
|
|
|
|
roh.myDbs[i].dbiID = BitConverter.ToInt16(ab, offset + 0);
|
|
int tableID = roh.myDbs[i].dbiID;
|
|
|
|
roh.myDbs[i].dbiType = BitConverter.ToInt16(ab, offset + 2);
|
|
roh.myDbs[i].dbiAW = BitConverter.ToInt16(ab, offset + 4);
|
|
|
|
int iPtr = BitConverter.ToInt32(ab, offset + 22) + hdrOffset + 6;
|
|
roh.myDbs[i].dbiTitle = Encoding.Default.GetString(ab, iPtr, StringLength(ab, iPtr));
|
|
|
|
iPtr = BitConverter.ToInt32(ab, offset + 26) + hdrOffset + 6;
|
|
roh.myDbs[i].dbiAP = Encoding.Default.GetString(ab, iPtr, StringLength(ab, iPtr));
|
|
|
|
ROFSTLookup.rogrp tmp = LoadGroup(ab, BitConverter.ToInt32(ab, offset + 6), tableID);
|
|
|
|
roh.myDbs[i].ID = tmp.ID;
|
|
roh.myDbs[i].children = tmp.children;
|
|
}
|
|
|
|
return roh;
|
|
}
|
|
|
|
private ROFSTLookup.rogrp LoadGroup(byte[] ab, int offset, int tableID)
|
|
{
|
|
ROFSTLookup.rogrp myGrp = new ROFSTLookup.rogrp();
|
|
|
|
myGrp.ID = BitConverter.ToInt32(ab, offset);
|
|
myGrp.ParentID = BitConverter.ToInt32(ab, offset + 4);
|
|
|
|
int numChildren = BitConverter.ToInt16(ab, offset + 8);
|
|
|
|
if (numChildren > 0)
|
|
{
|
|
myGrp.children = new ROFSTLookup.rochild[numChildren];
|
|
|
|
int myOffset = offset + 10;
|
|
|
|
for (int i = 0; i < myGrp.children.Length; i++)
|
|
{
|
|
ROFSTLookup.rochild tmp = new ROFSTLookup.rochild();
|
|
|
|
int childOffset = BitConverter.ToInt32(ab, myOffset);
|
|
tmp.type = BitConverter.ToInt16(ab, myOffset + 4);
|
|
|
|
int slen = StringLength(ab, myOffset + 6);
|
|
tmp.title = Encoding.Default.GetString(ab, myOffset + 6, slen);
|
|
|
|
myOffset += (7 + slen);
|
|
|
|
ROFSTLookup.rogrp tmpg = LoadGroup(ab, childOffset, tableID);
|
|
|
|
//MultipleReturnValuesInheritType(ref tmpg, tmp.type);
|
|
|
|
tmp.ID = tmpg.ID;
|
|
tmp.ParentID = tmpg.ParentID;
|
|
tmp.value = tmpg.value;
|
|
tmp.appid = tmpg.appid;
|
|
tmp.roid = tableID.ToString("X4") + tmp.ID.ToString("X8");
|
|
tmp.children = tmpg.children;
|
|
|
|
int j;
|
|
|
|
for (j = i - 1; j >= 0 && tmp.ID < myGrp.children[j].ID; j--)
|
|
{
|
|
myGrp.children[j + 1] = myGrp.children[j];
|
|
}
|
|
|
|
myGrp.children[j + 1] = tmp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int slen = StringLength(ab, offset + 12);
|
|
myGrp.value = Encoding.Default.GetString(ab, offset + 12, slen);
|
|
|
|
//ProcessROReturnValue(ref myGrp, Encoding.Default.GetString(ab, offset + 12, slen), tableID, dvi);
|
|
|
|
int slen2 = StringLength(ab, offset + 13 + slen);
|
|
myGrp.appid = Encoding.Default.GetString(ab, offset + 13 + slen, slen2);
|
|
}
|
|
|
|
return myGrp;
|
|
}
|
|
|
|
private void Load(int rofstID)
|
|
{
|
|
//Get Original ROLookup Bytes
|
|
byte[] bytes = RofstDataGetRofstLookupBytes(rofstID);
|
|
|
|
//Convert Bytes to Objects
|
|
ROFSTLookup.roHdr roh = ConvertFst2Objects(bytes);
|
|
|
|
//Save FstObjects to Database
|
|
string userID = "System";
|
|
|
|
//Insert Rofst Header
|
|
RofstHeaderInsert(rofstID, roh.hSize, roh.hMonth, roh.hDay, roh.hcYear, roh.hcMonth,
|
|
roh.hcDay, roh.hcHour, roh.hcMin, roh.hcSec, roh.hcHund, userID);
|
|
|
|
for (int i = 0; i < roh.myDbs.Length; i++)
|
|
{
|
|
ROFSTLookup.rodbi rodbi = roh.myDbs[i];
|
|
|
|
//Insert Rofst Database
|
|
RofstDatabaseInsert(rofstID, rodbi.dbiID, rodbi.dbiType, rodbi.dbiAW,
|
|
rodbi.dbiTitle, rodbi.dbiAP, rodbi.ID, rodbi.ParentID);
|
|
|
|
if (rodbi.children != null && rodbi.children.Length > 0)
|
|
{
|
|
for (int j = 0; j < rodbi.children.Length; j++)
|
|
{
|
|
//Insert Rofst Child
|
|
LoadChild(rofstID, rodbi.dbiID, rodbi.children[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Finalized Load for Rofst Header / Rebuild Indexes
|
|
RofstHeaderFinalizeLoad(rofstID);
|
|
|
|
}
|
|
|
|
private void LoadChild(int rofstID, int dbiID, ROFSTLookup.rochild child)
|
|
{
|
|
//Insert Rofst Child
|
|
RofstChildInsert(rofstID, child.ID, child.ParentID, dbiID, child.type, child.title, child.roid, child.appid, child.value);
|
|
|
|
if (child.children != null && child.children.Length > 0)
|
|
{
|
|
for (int i = 0; i < child.children.Length; i++)
|
|
{
|
|
//Insert Rofst Child
|
|
LoadChild(rofstID, dbiID, child.children[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (Convert To Objects)
|
|
|
|
private ROFSTLookup.roHdr ConvertToRoHdrObject(SafeDataReader dr, bool loadChildren)
|
|
{
|
|
ROFSTLookup.roHdr rh = new ROFSTLookup.roHdr();
|
|
|
|
rh.hSize = (int)dr.GetValue("hSize");
|
|
rh.hYear = (int)dr.GetValue("hYear");
|
|
rh.hMonth = (byte)dr.GetValue("hMonth");
|
|
rh.hDay = (byte)dr.GetValue("hDay");
|
|
rh.hcYear = (int)dr.GetValue("hcYear");
|
|
rh.hcMonth = (byte)dr.GetValue("hcMonth");
|
|
rh.hcDay = (byte)dr.GetValue("hcDay");
|
|
rh.hcHour = (byte)dr.GetValue("hcHour");
|
|
rh.hcMin = (byte)dr.GetValue("hcMin");
|
|
rh.hcSec = (byte)dr.GetValue("hcSec");
|
|
rh.hcHund = (byte)dr.GetValue("hcHund");
|
|
|
|
if (loadChildren)
|
|
{
|
|
rh.myDbs = RofstDataGetDatabases(_rofstID);
|
|
}
|
|
|
|
return rh;
|
|
}
|
|
|
|
private ROFSTLookup.rodbi ConvertToRodbiObject(SafeDataReader dr, bool loadChildren, bool loadAllChildren)
|
|
{
|
|
ROFSTLookup.rodbi rd = new ROFSTLookup.rodbi();
|
|
|
|
rd.dbiID = (int)dr.GetValue("dbiID");
|
|
rd.dbiType = (int)dr.GetValue("dbiType");
|
|
rd.dbiAW = (int)dr.GetValue("dbiAW");
|
|
rd.dbiAP = (string)dr.GetValue("dbiAP");
|
|
rd.dbiTitle = (string)dr.GetValue("dbiTitle");
|
|
rd.ID = (int)dr.GetValue("ID");
|
|
rd.ParentID = (int)dr.GetValue("ParentID");
|
|
|
|
if (loadChildren || loadAllChildren)
|
|
{
|
|
rd.children = RofstDataGetChildrenByID(_rofstID, rd.dbiID, rd.ID, false, loadAllChildren);
|
|
}
|
|
|
|
return rd;
|
|
}
|
|
|
|
private ROFSTLookup.rochild ConvertToRochildObject(SafeDataReader dr, bool loadChildren, bool loadAllChildren)
|
|
{
|
|
ROFSTLookup.rochild rc = new ROFSTLookup.rochild();
|
|
|
|
rc.ID = (int)dr.GetValue("ID");
|
|
rc.ParentID = (int)dr.GetValue("ParentID");
|
|
rc.type = (int)dr.GetValue("type");
|
|
rc.title = (string)dr.GetValue("title");
|
|
rc.roid = (string)dr.GetValue("roid");
|
|
|
|
if (!string.IsNullOrEmpty((string)dr.GetValue("appid")))
|
|
rc.appid = (string)dr.GetValue("appid");
|
|
|
|
if (!string.IsNullOrEmpty((string)dr.GetValue("value")))
|
|
{
|
|
rc.value = (string)dr.GetValue("value");
|
|
ProcessROReturnValue(ref rc, rc.value, GetRODatabaseTitleIndex(rc.roid));
|
|
}
|
|
else if (loadChildren || loadAllChildren)
|
|
{
|
|
rc.children = RofstDataGetChildrenByRoid(_rofstID, rc.roid, false, loadAllChildren);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
private ROFSTLookup.RoExtension ConvertToRoExtensionObject(SafeDataReader dr)
|
|
{
|
|
ROFSTLookup.RoExtension re = new ROFSTLookup.RoExtension();
|
|
|
|
re.Offset = (int)dr.GetValue("Offset");
|
|
re.RoidExt = (string)dr.GetValue("RoidExt");
|
|
re.AccPageExt = (string)dr.GetValue("AccPageExt");
|
|
|
|
return re;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (RO Values)
|
|
|
|
private ROFSTLookup.rochild GetRoChild12(string roid, bool loadChildren = false, bool loadAllChildren = false)
|
|
{
|
|
ROFSTLookup.rochild rc = RofstDataGetChildByRoid(_rofstID, roid, loadChildren, loadAllChildren);
|
|
|
|
if (rc.ID <= 0 && roid.Length == 4)
|
|
{
|
|
rc.title = GetRODatabaseTitle(GetRODatabaseTitleIndex(roid));
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
private void ProcessROReturnValue(ref ROFSTLookup.rochild child, string rawvalue, int tableID)
|
|
{
|
|
// This function will take the raw RO return value and resolve any macros, conditionals,
|
|
// and generate the return value or a list of multiple return values.
|
|
List<string> lstValues = GetROReturnValue(rawvalue);
|
|
|
|
if (lstValues.Count > 0) // Single or Multiple Return Values
|
|
{
|
|
child.children = new ROFSTLookup.rochild[lstValues.Count];
|
|
|
|
for (int i = 0; i < lstValues.Count; i++)
|
|
{
|
|
var roExt = Extensions.Where(x => x.Offset.Equals(i + 1)).SingleOrDefault();
|
|
|
|
string roValue = GetParentChildROValue(lstValues[i], this.SelectedSlave);
|
|
|
|
child.children[i].ParentID = child.ID;
|
|
child.children[i].type = child.type; // Multiple return value inherit type from parent
|
|
child.children[i].title = roValue;
|
|
child.children[i].value = roValue;
|
|
|
|
child.children[i].appid = (roExt != null) ? string.Format("{0}.{1}", child.appid, roExt.AccPageExt) : child.appid;
|
|
child.children[i].roid = string.Format("{0}{1}{2}", tableID.ToString("X4"), child.ID.ToString("X8"), (roExt.RoidExt != null) ? roExt.RoidExt : string.Empty).ToUpper();
|
|
child.children[i].children = new List<ROFSTLookup.rochild>().ToArray();
|
|
}
|
|
|
|
child.value = null;
|
|
}
|
|
|
|
_lstRoValues.Clear();
|
|
_multiRoValues.Clear();
|
|
|
|
return;
|
|
}
|
|
|
|
private static string GetParentChildROValue(string roval, int selChldIdx)
|
|
{
|
|
// C2021-026 Get the child RO value if it exists, otherwise to the default (parent) RO value
|
|
// C2022-001 new logic to handle new format of Parent/Child RO.FST
|
|
// The RO.FST will not have a specific child value if that child value is the same as the default value
|
|
// B2021-093 Don't look for child RO values if "roval" is null
|
|
if (string.IsNullOrEmpty(roval))
|
|
return null;
|
|
|
|
// Clean Up RoValue
|
|
roval = roval.Replace("\xFF", "\xa0");
|
|
roval = roval.Replace(@"\u160?", " ");
|
|
|
|
// B2022-020 remove a un-needed question mark that was in the search criteria "(<APL [^<]+) /APL>"
|
|
// B2022-050 change the search string from "(<APL [^<]+) /APL>" to "<APL .*? /APL>" to handle when RO values have less then sign
|
|
// B2022-077 Need to use the RegexOption of Single Line to handle cases of an RO Return value having ascii newline characters (\r\n)
|
|
MatchCollection mm = Regex.Matches(roval, "<APL .*? /APL>", RegexOptions.Singleline);
|
|
|
|
// C2022-014 commented write to error log. Keep for debugging purposes.
|
|
//if (mm.Count == 0) // B2022-020 will now write in error log if there is a problem
|
|
// _MyLog.WarnFormat("Parent/Child Values not parsable for <APL ... /APL>\r\nItemId={0}\r\nROValue={1} ",MyDocVersionInfo.ItemID,roval);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
int lastIndex = 0;
|
|
|
|
// Get Selected Child Value
|
|
foreach (Match m in mm)
|
|
{
|
|
sb.Append(roval.Substring(lastIndex, m.Index - lastIndex));
|
|
|
|
string aplString = m.Value;
|
|
string chldValStr = string.Format("UnitIdx={0} Value=", selChldIdx);
|
|
int offsetIdx = aplString.IndexOf(chldValStr);
|
|
int nextIDX = -1;
|
|
|
|
if (offsetIdx == -1)
|
|
{
|
|
offsetIdx = aplString.IndexOf("DefaultVal=") + 11;
|
|
}
|
|
else
|
|
{
|
|
offsetIdx += chldValStr.Length;
|
|
}
|
|
|
|
nextIDX = aplString.IndexOf(",UnitIdx", offsetIdx);
|
|
if (nextIDX == -1) nextIDX = aplString.IndexOf(" /APL>");
|
|
sb.Append(aplString.Substring(offsetIdx, nextIDX - offsetIdx));
|
|
|
|
lastIndex = m.Index + m.Length;
|
|
}
|
|
|
|
// B2022-018 append any remaining text
|
|
if (lastIndex < roval.Length)
|
|
{
|
|
sb.Append(roval.Substring(lastIndex));
|
|
}
|
|
|
|
// If Default Value is selected (selChldIdx = 0), and return value is empty then replace with Standard Missing Default Value
|
|
return (selChldIdx == 0 && sb.ToString().Trim().Length <= 0) ? ROFSTLookup.RoMissingDefaultValue : sb.ToString().Trim();
|
|
//return sb.ToString();
|
|
}
|
|
|
|
private List<string> GetROReturnValue(string roval)
|
|
{
|
|
_lstRoValues = new List<string>();
|
|
_multiRoValues = new List<string>();
|
|
_dicRoVars = new Dictionary<string, string>();
|
|
|
|
string tmp = ProcessRO(_myDocVersionInfo == null ? roval : _myDocVersionInfo.ProcessDocVersionSpecificInfo(roval), false);
|
|
|
|
if (!string.IsNullOrEmpty(tmp) && _lstRoValues.Count == 0) // was not a multiple return value
|
|
{
|
|
_lstRoValues.Add(tmp);
|
|
}
|
|
|
|
return _lstRoValues;
|
|
}
|
|
|
|
private string ProcessRO(string roval, bool multiRtnVal)
|
|
{
|
|
string str = roval;
|
|
string rtnstr = "";
|
|
int len = roval.Length;
|
|
|
|
while (len > 0)
|
|
{
|
|
int ptr = NextDelimiter("{", str);
|
|
|
|
if (ptr == -1)
|
|
{
|
|
rtnstr += str; // add remaining text
|
|
len = 0; // break out of while loop
|
|
}
|
|
else
|
|
{
|
|
int cnt = ptr;
|
|
|
|
if (cnt > 0)
|
|
{
|
|
// add text
|
|
rtnstr += str.Substring(0, cnt);
|
|
len -= cnt;
|
|
str = str.Substring(ptr);
|
|
}
|
|
|
|
ptr = MatchingBrace(str) + 1;
|
|
cnt = ptr;
|
|
|
|
bool nfnd = false;
|
|
string pbstr = ProcessBrace(str.Substring(1, cnt - 2), cnt - 2, ref nfnd, multiRtnVal);
|
|
|
|
if (pbstr == null)
|
|
return null;
|
|
|
|
if (nfnd)
|
|
rtnstr += str.Substring(0, cnt);
|
|
else
|
|
rtnstr += pbstr;
|
|
|
|
len -= cnt;
|
|
str = str.Substring(ptr);
|
|
}
|
|
}
|
|
|
|
return ProcessMacros(rtnstr);
|
|
}
|
|
|
|
private string ProcessBrace(string str, int l, ref bool nfnd, bool multiRtnVal)
|
|
{
|
|
string rtnstr = "";
|
|
int nxt = NextDelimiter("{=", str);
|
|
|
|
if (nxt == -1) // no delimiter found
|
|
{
|
|
if (_dicRoVars.ContainsKey(str))
|
|
rtnstr = _dicRoVars[str];
|
|
else
|
|
nfnd = true;
|
|
}
|
|
else
|
|
{
|
|
if (str[nxt] == '{')
|
|
{
|
|
if (nxt == 0) // Multiple Return Values
|
|
{
|
|
ProcessMultiReturnValues(str, l);
|
|
}
|
|
else // Conditional
|
|
{
|
|
rtnstr = ProcessConditional(str, str.Substring(nxt), nxt, str.Length - nxt - 1, multiRtnVal);
|
|
}
|
|
}
|
|
else // must be variable definition
|
|
{
|
|
// 'l' is the length up to the matching brace of the variable definition
|
|
string tmpval = ProcessRO(str.Substring(nxt + 1, l - nxt - 1), multiRtnVal);
|
|
|
|
if (string.IsNullOrEmpty(tmpval)) tmpval = " "; // nothing assigned to variable
|
|
|
|
if (!_dicRoVars.ContainsKey(str.Substring(0, nxt)))
|
|
{
|
|
_dicRoVars.Add(str.Substring(0, nxt), tmpval);
|
|
if (nxt == 1) _multiRoValues.Add(str.Substring(0, nxt));
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (multiRtnVal) rtnstr = tmpval;
|
|
}
|
|
}
|
|
|
|
return rtnstr;
|
|
}
|
|
|
|
private void ProcessMultiReturnValues(string str, int len)
|
|
{
|
|
string tstr = (!string.IsNullOrEmpty(str)) ? str.Substring(0, len) : string.Empty;
|
|
|
|
while (tstr.Length > 0)
|
|
{
|
|
int idx = MatchingBrace(tstr);
|
|
string tmpVal = ProcessRO(tstr.Substring(0, idx + 1), true);
|
|
if (tmpVal != null) _lstRoValues.Add(tmpVal); // duplicates get returned as null
|
|
tstr = tstr.Substring(idx + 1);
|
|
}
|
|
}
|
|
|
|
private string ProcessConditional(string cnd, string opt, int lencnd, int lenopt, bool multiRtnVal)
|
|
{
|
|
// Evaluate Condition
|
|
string stat = (_myDocVersionInfo != null) ? _myDocVersionInfo.Evaluate(cnd, lencnd) : string.Empty;
|
|
|
|
// if evaluation not defined then return an empty string - no matches can be made, look for match - remember default
|
|
if (stat.Length == 0)
|
|
return string.Empty;
|
|
|
|
int ls = stat.Length;
|
|
string match = null;
|
|
string def = null;
|
|
int deflen = 0;
|
|
|
|
while (lenopt > 0 && match == null)
|
|
{
|
|
int end = MatchingBrace(opt);
|
|
int eq = opt.IndexOf('=');
|
|
int len = end + 1;
|
|
int li = eq - 1;
|
|
int ld = len - li - 3;
|
|
|
|
if (def == null || eq == 1)
|
|
{
|
|
def = opt.Substring(eq + 1);
|
|
deflen = ld;
|
|
}
|
|
|
|
if (ls == li && opt.Substring(1).StartsWith(stat + "="))
|
|
{
|
|
match = opt.Substring(eq + 1, ld);
|
|
}
|
|
|
|
opt = opt.Substring(len); // point to the next piece
|
|
lenopt -= len;
|
|
}
|
|
|
|
// if match process option - or process default
|
|
if (match == null) //(!match)
|
|
{
|
|
match = def.Substring(0, deflen);
|
|
}
|
|
|
|
return ProcessRO(match, multiRtnVal);
|
|
}
|
|
|
|
private string ProcessMacros(string str)
|
|
{
|
|
// Takes the RO text value and sees if a macro has been used.
|
|
// If so it will perform the macro operation on the substring in the text value
|
|
// Note** Right now the only macro is @HSP(), where every space between the "(" and ")" will be replaced with a hard space
|
|
|
|
if (string.IsNullOrEmpty(str))
|
|
return str;
|
|
|
|
string rtnstr = str;
|
|
int indx;
|
|
|
|
while ((indx = rtnstr.ToUpper().IndexOf("@HSP(")) > -1)
|
|
{
|
|
string resstr = rtnstr.Substring(0, indx);
|
|
int endHsp = rtnstr.IndexOf(")", indx);
|
|
string tmpstr = rtnstr.Substring(indx + 5, endHsp - indx - 5);
|
|
|
|
// B2017-012 Don't convert space to hard spaces for XY Plots.
|
|
if (!tmpstr.Contains("<<G")) tmpstr = tmpstr.Replace(" ", @"\u160?");
|
|
|
|
resstr = resstr + tmpstr;
|
|
rtnstr = resstr + rtnstr.Substring(endHsp + 1);
|
|
}
|
|
|
|
return rtnstr;
|
|
}
|
|
|
|
private int StringLength(byte[] ab, int offset)
|
|
{
|
|
int i = 0;
|
|
while (ab[i + offset] != 0) i++;
|
|
return i;
|
|
}
|
|
|
|
private int NextDelimiter(string delim, string str)
|
|
{
|
|
return (!string.IsNullOrEmpty(str)) ? str.IndexOfAny(delim.ToCharArray()) : -1;
|
|
}
|
|
|
|
private int MatchingBrace(string str)
|
|
{
|
|
int level = 1;
|
|
int idx = 0; // the while will skip the first position (the first brace)
|
|
|
|
if (!string.IsNullOrEmpty(str))
|
|
{
|
|
while (level > 0 && idx++ < str.Length)
|
|
{
|
|
switch (str[idx])
|
|
{
|
|
case '{':
|
|
level++;
|
|
break;
|
|
|
|
case '}':
|
|
level--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (level != 0) ? -1 : idx; //return -1 if didn't find matching brace otherwise length including end brace
|
|
}
|
|
|
|
private string ReplaceUnicode(string s2, bool DoCaret)
|
|
{
|
|
string orig = s2;
|
|
|
|
s2 = s2.Replace(@"\u160?", "<HSP>"); // convert hard spaces bug fix: B2016-206
|
|
s2 = s2.Replace(@"\", @"\u9586?"); // convert backslashes to a backslash symbol
|
|
s2 = s2.Replace("<HSP>", @"\u160?"); // convert hard spaces bug fix: B2016-206
|
|
s2 = s2.Replace("`", @"\'b0"); // convert backquote to degree - left over from DOS days.
|
|
s2 = s2.Replace("\xf8", @"\'b0"); // convert \xf8 to degree.
|
|
s2 = s2.Replace("\xa0", @"\u160?"); // hardspace
|
|
s2 = s2.Replace("\xb0", @"\'b0"); // degree
|
|
s2 = s2.Replace("\x7f", @"\u916?"); // delta
|
|
s2 = s2.Replace("\x2265", @"\u8805?"); // greater than or equal
|
|
s2 = s2.Replace("\x2264", @"\u8804?"); // less than or equal
|
|
s2 = s2.Replace("\xB1", @"\'b1"); // plus minus
|
|
s2 = s2.Replace("\x3A3", @"\u931?"); // sigma
|
|
s2 = s2.Replace("\x3C4", @"\u947?"); // gamma
|
|
s2 = s2.Replace("\xBD", @"\'bd"); // half
|
|
s2 = s2.Replace("\x25A0", @"\u9604?"); // accum 2584
|
|
s2 = s2.Replace("\x7", @"\u9679?"); // bullet 25CF
|
|
s2 = s2.Replace("\x2248", @"\u8776?"); // approx eq
|
|
s2 = s2.Replace("\x2261", @"\u8773?"); // similar eq 2245
|
|
s2 = s2.Replace("\xF7", @"\'f7"); // division
|
|
s2 = s2.Replace("\x221A", @"\u8730?"); // square root
|
|
s2 = s2.Replace("\x393", @"\u961?"); // rho 3C1
|
|
s2 = s2.Replace("\x3C0", @"\u960?"); // pi
|
|
s2 = s2.Replace("\xb5", @"\u956?"); // micro 3BC (try e6, if not work try 109)
|
|
s2 = s2.Replace("\x3B4", @"\u948?"); // lower case delta
|
|
s2 = s2.Replace("\x3C3", @"\u963?"); // lower case sigma
|
|
s2 = s2.Replace("\xBC", @"\'bc"); // quarter
|
|
s2 = s2.Replace("\x3C6", @"\'d8"); // dist zero, D8
|
|
s2 = s2.Replace("\xC9", @"\u274?"); // energy, 112
|
|
s2 = s2.Replace("\xEC", @"\'ec"); // grave
|
|
s2 = s2.Replace("\x2502", @"\u9474?"); // bar
|
|
s2 = s2.Replace("\x3B5", @"\u949?"); // epsilon
|
|
s2 = s2.Replace("\x398", @"\u952?"); // theta, 3B8
|
|
s2 = s2.Replace("\x221E", @"\u8857?"); // dot in oval, 2299
|
|
s2 = s2.Replace("\xBF", @"\u964?"); // tau, 3C4
|
|
s2 = s2.Replace("\x2310", @"\u9830?"); // diamond, 2666
|
|
s2 = s2.Replace("\x2192", @"\u8594?"); // Rightwards Arrow
|
|
s2 = s2.Replace("\x2190", @"\u8592?"); // Leftwards Arrow
|
|
s2 = s2.Replace("\x2191", @"\u8593?"); // Upwards Arrow
|
|
s2 = s2.Replace("\x2193", @"\u8595?"); // Downwards Arrow
|
|
s2 = s2.Replace("\x2207", @"\u8711?"); // Nabla
|
|
s2 = s2.Replace("\x2591", @"\'b0"); // Degree Symbol
|
|
s2 = s2.Replace("\xFF", @"\u8593?"); // Up Arrow
|
|
s2 = s2.Replace("\xD6", @"\u8595?"); // Down Arrow
|
|
|
|
if (DoCaret) s2 = s2.Replace("^", @"\u916?");
|
|
// Convert dash to a non-breaking dash. This is a unicode character.
|
|
// This character will be used in veproms rather than a dash.
|
|
//if the dash is preceeded byte a token remove the space following the token
|
|
s2 = Regex.Replace(s2, @"(\\[^ \\?]*) \-", @"$1\u8209?");
|
|
s2 = s2.Replace("-", @"\u8209?");
|
|
|
|
return s2;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region (Unit Info - RO Values)
|
|
|
|
private ROFSTLookup.rochild GetUnitInfoRoChild(string roid)
|
|
{
|
|
ROFSTLookup.rochild rc = GetEmptyRoChild();
|
|
|
|
if (!string.IsNullOrEmpty(roid))
|
|
{
|
|
rc.roid = FormatRoidKey(roid).Substring(0, 12);
|
|
|
|
DocVersionConfig dvc = (_myDocVersionInfo != null) ? _myDocVersionInfo.DocVersionConfig : null;
|
|
if (dvc != null) dvc.SelectedSlave = this.SelectedSlave;
|
|
|
|
switch (rc.roid)
|
|
{
|
|
case "FFFF00000001":
|
|
rc.title = "Number";
|
|
rc.appid = "U-NUMBER";
|
|
rc.value = (dvc != null) ? dvc.Unit_Number : null;
|
|
break;
|
|
|
|
case "FFFF00000002":
|
|
rc.title = "Other Number";
|
|
rc.appid = "U-OTHERNUMBER";
|
|
rc.value = (dvc != null) ? dvc.Other_Unit_Number : null;
|
|
break;
|
|
|
|
case "FFFF00000003":
|
|
rc.title = "Text";
|
|
rc.appid = "U-TEXT";
|
|
rc.value = (dvc != null) ? dvc.Unit_Text : null;
|
|
break;
|
|
|
|
case "FFFF00000004":
|
|
rc.title = "Other Text";
|
|
rc.appid = "U-OTHERTEXT";
|
|
rc.value = (dvc != null) ? dvc.Other_Unit_Text : null;
|
|
break;
|
|
|
|
case "FFFF00000005":
|
|
rc.title = "ID";
|
|
rc.appid = "U-ID";
|
|
rc.value = (dvc != null) ? dvc.Unit_ID : null;
|
|
break;
|
|
|
|
case "FFFF00000006":
|
|
rc.title = "Other ID";
|
|
rc.appid = "U-OTHERID";
|
|
rc.value = (dvc != null) ? dvc.Other_Unit_ID : null;
|
|
break;
|
|
|
|
case "FFFF00000007":
|
|
rc.title = "Name";
|
|
rc.appid = "U-NAME";
|
|
rc.value = (dvc != null) ? dvc.Unit_Name : null;
|
|
break;
|
|
|
|
case "FFFF00000008":
|
|
rc.title = "Other Name";
|
|
rc.appid = "U-OTHERNAME";
|
|
rc.value = (dvc != null) ? dvc.Other_Unit_Name : null;
|
|
break;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(rc.appid))
|
|
{
|
|
rc.ID = 0;
|
|
rc.ParentID = 0;
|
|
rc.type = 1; // Single Text
|
|
rc.roid = string.Format("{0}0041", rc.roid);
|
|
rc.children = new List<ROFSTLookup.rochild>().ToArray();
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
private string GetUnitInfoRoidByAccPageID(string accPageID)
|
|
{
|
|
string roid = string.Empty;
|
|
|
|
if (!string.IsNullOrEmpty(accPageID))
|
|
{
|
|
string accPageKey = accPageID;
|
|
|
|
// Try to cleanup / standardize the Unit Info Tag before attempting to lookup the associated value
|
|
if (!accPageKey.StartsWith("<")) accPageKey = string.Format("<{0}", accPageKey);
|
|
if (!accPageKey.EndsWith(">")) accPageKey = string.Format("{0}>", accPageKey);
|
|
accPageKey = FormatAccPageKey(accPageKey, null, null);
|
|
|
|
if (accPageKey == "<U-NUMBER>") roid = "FFFF00000001";
|
|
if (accPageKey == "<U-OTHERNUMBER>") roid = "FFFF00000002";
|
|
if (accPageKey == "<U-TEXT>") roid = "FFFF00000003";
|
|
if (accPageKey == "<U-OTHERTEXT>") roid = "FFFF00000004";
|
|
if (accPageKey == "<U-ID>") roid = "FFFF00000005";
|
|
if (accPageKey == "<U-OTHERID>") roid = "FFFF00000006";
|
|
if (accPageKey == "<U-NAME>") roid = "FFFF00000007";
|
|
if (accPageKey == "<U-OTHERNAME>") roid = "FFFF00000008";
|
|
}
|
|
|
|
return roid;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Public Static Methods
|
|
|
|
#region (FortranFormat)
|
|
|
|
public static string ConvertFortranFormatToScienctificNotation(string str)
|
|
{
|
|
// ([+-]?|\\u8209\?) either an optional single character Plus (+) or Minus (-) or non-breaking dash (\u8209?)
|
|
// ([0-9]+) a group of at least one digits
|
|
// [.] a decimal point
|
|
// ([0-9]*?) a group of zero or more digits
|
|
// 0*E optional zeros (spare zeros) followed
|
|
// ([+-]?|\\u8209\?) either an optional single character Plus (+) or Minus (-) or non-breaking dash (\u8209?)
|
|
// ([0-9]+) a group of at least one digits
|
|
|
|
return Regex.Replace(str, @"([+-]?|\\u8209\?)([0-9]+)[.]([0-9]*?)0*E([+-]?|\\u8209\?)([0-9]+)", new MatchEvaluator(FixFortranNumber));
|
|
}
|
|
|
|
public static string FixFortranNumber(Match match)
|
|
{
|
|
StringBuilder sb = new StringBuilder(match.Groups[1].Value.Replace("-", @"\u8209?"));
|
|
|
|
if (match.Groups[3].Length == 0) // Nothing to the right of the decimal
|
|
{
|
|
if (match.Groups[2].Value != "1") // Other than "1", multiply it times 10 raised to a power
|
|
{
|
|
sb.Append(match.Groups[2].Value + "x10");
|
|
}
|
|
else // The number is simply 1 so it can be ignored and 10 can be raised to a power
|
|
{
|
|
sb.Append("10");
|
|
}
|
|
}
|
|
else // A number with a decimal point
|
|
{
|
|
sb.Append(match.Groups[2].Value + "." + match.Groups[3].Value + "x10");
|
|
}
|
|
|
|
// Add the exponent as superscript
|
|
return sb.ToString() + "\\up2 " + match.Groups[4].Value.Replace("-", @"\u8209?") + match.Groups[5].Value + "\\up0 ";
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|