mschill
8eb8a328d1
Add some code to rebuild specific indexes (like [IX_RofstID_DbiID_ParentID] ON [dbo].[RofstChild]) after a new RO.FST is imported.
2366 lines
74 KiB
C#
2366 lines
74 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 System.Threading;
|
|
|
|
using Csla.Data;
|
|
|
|
|
|
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])");
|
|
|
|
private List<RoExtension> _extensions;
|
|
private List<string> _baseAccPageKeys;
|
|
|
|
// RofstLookup/Conversion Variables
|
|
private int _rofstID;
|
|
private DocVersionInfo _myDocVersionInfo;
|
|
private int _selectedSlave;
|
|
private string _otherChild = string.Empty;
|
|
private string _roMissingDefaultValue = "[TBD]";
|
|
|
|
private bool _autoCombineSingleRetValues = true;
|
|
|
|
private List<string> _lstRoValues;
|
|
private List<string> _multiRoValues;
|
|
private Dictionary<string, string> _dicRoVars;
|
|
private ItemInfo _itemInfo;
|
|
|
|
// B2022-107: Display Progress Bar Messages/Statuses when a new ROFST binary file is loaded into the database
|
|
private frmRofstLoadStatus _frmRofstLoadStatus = null;
|
|
private Dictionary<int, int> _dicRoCounts = null;
|
|
private bool _showLoadingStatus = true;
|
|
|
|
private int _curRoCnt = 0;
|
|
private int _dbRoCnt = 0;
|
|
private int _totalRoCnt = 0;
|
|
private double _pctComplete = 0;
|
|
|
|
#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; }
|
|
}
|
|
|
|
// B2022-124: [JPR] Blank RO Values (All Spaces) printing as "?"
|
|
public string RoMissingDefaultValue
|
|
{
|
|
get { return _roMissingDefaultValue; }
|
|
set { _roMissingDefaultValue = value; }
|
|
}
|
|
|
|
public List<RoExtension> Extensions
|
|
{
|
|
get
|
|
{
|
|
if (_extensions == null)
|
|
{
|
|
_extensions = RofstDataGetExtensions();
|
|
}
|
|
|
|
return _extensions;
|
|
}
|
|
}
|
|
|
|
public List<string> BaseAccPageKeys
|
|
{
|
|
get
|
|
{
|
|
if (_baseAccPageKeys == null)
|
|
{
|
|
_baseAccPageKeys = GetBaseAccPageKeys();
|
|
}
|
|
|
|
return _baseAccPageKeys;
|
|
}
|
|
}
|
|
|
|
public bool AutoCombineSingleRetValues
|
|
{
|
|
get { return _autoCombineSingleRetValues; }
|
|
set { _autoCombineSingleRetValues = value; }
|
|
}
|
|
|
|
public bool ShowLoadingStatus
|
|
{
|
|
get { return _showLoadingStatus; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public ROFSTLookup(int rofstID, DocVersionInfo dvi, string otherChild, bool showLoadingStatus = true)
|
|
{
|
|
// Set Fields/Properties
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = dvi;
|
|
_otherChild = otherChild;
|
|
_showLoadingStatus = showLoadingStatus;
|
|
|
|
// Check if ROFST file is already loaded, if not then parse/load Ro Values
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
public ROFSTLookup(int rofstID, DocVersionInfo dvi, bool showLoadingStatus = true)
|
|
{
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = dvi;
|
|
_showLoadingStatus = showLoadingStatus;
|
|
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
public ROFSTLookup(int rofstID, bool showLoadingStatus = true)
|
|
{
|
|
_rofstID = rofstID;
|
|
MyDocVersionInfo = null;
|
|
_showLoadingStatus = showLoadingStatus;
|
|
|
|
if (!RofstDataExists(rofstID))
|
|
{
|
|
Load(rofstID);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ROTextConvertMethods
|
|
// B2023-037: Handle <=, >=, +-, -> and <- symbols. Convert to unicode for output, i.e. print and edit/view (when editing
|
|
// step, will show as 2 characters, not unicode, unless ro inserted when code replaced link text with unicode.
|
|
public static string ROConvertSymbols(string retval, bool arr1, bool arr2)
|
|
{
|
|
if (arr1)
|
|
{
|
|
retval = retval.Replace("\\u8209?>", @"\u8594?"); // Right Arrow
|
|
retval = retval.Replace("<\\u8209?", @"\u8592?"); // Left Arrow
|
|
retval = retval.Replace("->", @"\u8594?"); // Right Arrow
|
|
retval = retval.Replace("<-", @"\u8592?"); // Left Arrow
|
|
}
|
|
if (arr2)
|
|
{
|
|
retval = retval.Replace("<=", @"\u8804?"); // Less than or Equal
|
|
retval = retval.Replace(">=", @"\u8805?"); // Greater than or Equal
|
|
retval = retval.Replace("+\\u8209?", @"\'b1"); // plus minus
|
|
retval = retval.Replace("+-", @"\'b1"); // plus minus
|
|
}
|
|
return retval;
|
|
}
|
|
#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 string FormatAccPageKey(string accPageID)
|
|
{
|
|
string accPageBase = string.Empty;
|
|
string accPageExt = string.Empty;
|
|
|
|
string spDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_setpointprefix : string.Empty;
|
|
string igDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_graphicsprefix : string.Empty;
|
|
|
|
return FormatAccPageKeyWithExt(accPageID, spDefault, igDefault, ref accPageBase, ref accPageExt);
|
|
}
|
|
|
|
public string FormatAccPageKey(string accPageID, ref string accPageBase, ref string accPageExt)
|
|
{
|
|
string spDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_setpointprefix : string.Empty;
|
|
string igDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_graphicsprefix : string.Empty;
|
|
|
|
return FormatAccPageKeyWithExt(accPageID, spDefault, igDefault, ref accPageBase, ref accPageExt);
|
|
}
|
|
|
|
public string FormatAccPageKey(string accPageID, string spDefault, string igDefault)
|
|
{
|
|
string accPageBase = string.Empty;
|
|
string accPageExt = string.Empty;
|
|
|
|
return FormatAccPageKeyWithExt(accPageID, spDefault, igDefault, ref accPageBase, ref accPageExt);
|
|
}
|
|
|
|
public string FormatAccPageKey(string accPageID, string spDefault, string igDefault, ref string accPageBase, ref string accPageExt)
|
|
{
|
|
return FormatAccPageKeyWithExt(accPageID, spDefault, igDefault, ref accPageBase, ref accPageExt);
|
|
}
|
|
|
|
public ROFSTLookup.rochild GetROChildByAccPageID(string accPageID)
|
|
{
|
|
string spDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_setpointprefix : string.Empty;
|
|
string igDefault = (MyDocVersionInfo != null && MyDocVersionInfo.DocVersionConfig != null) ? MyDocVersionInfo.DocVersionConfig.RODefaults_graphicsprefix : string.Empty;
|
|
|
|
return GetROChildByAccPageID(accPageID, spDefault, igDefault);
|
|
}
|
|
|
|
public ROFSTLookup.rochild GetROChildByAccPageID(string accPageID, string spDefault, string igDefault)
|
|
{
|
|
string accPageBase = string.Empty;
|
|
string accPageExt = string.Empty;
|
|
|
|
// Cleanup accPageID if necessary [Note* This will also handle any UnitInfo Ro Values (ex: "<U-NUMBER>")]
|
|
string accPageKey = FormatAccPageKeyWithExt(accPageID, spDefault, igDefault, ref accPageBase, ref accPageExt);
|
|
|
|
ROFSTLookup.rochild rc = RofstDataGetChildByAccPageID(_rofstID, accPageBase);
|
|
|
|
//if (rc.ID >=0 && rc.roid.Length < 16 && Regex.IsMatch(accPageKey, @".*\.[A-Z]") && rc.children != null && rc.children.Count() > 0)
|
|
if (rc.ID >= 0 && rc.roid.Length < 16 && !string.IsNullOrEmpty(accPageExt) && 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 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-NUMBER>");
|
|
roid = roid.ToCleanString(); // Removes any spaces
|
|
|
|
if ((!roid.StartsWith("<U-")) && ((roid.Length == 16 && roid.EndsWith("0000")) || (check16Digits && roid.Length < 16)))
|
|
{
|
|
// Pad roid with zeros to ensure the minimum length of any roid is (12) digits.
|
|
// This fixes any roids that are less than (12) digits or ones that have (16) digits and end with the older "0000" default ext.
|
|
// The default extension for any RoChild return value is now "0041", which is always the first RoChild Return Value object in the "Childrens" collection for
|
|
// the RO Base Object and is also used as the Default Return Value if the specified extension specific return value doesn't exist or has been deleted.
|
|
// This applies to all RoChild Return Values (Single / Multiple / Unit Info Tags)
|
|
// [Example: Unit Info Roid(12) "FFFF00000002" ==> "FFFF000000020041"]
|
|
|
|
roid = string.Format("{0}00000000", roid).Substring(0, 12) + "0041";
|
|
}
|
|
roid = roid.TrimStart(); //B2022-140 remove any preceding spaces
|
|
}
|
|
|
|
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 will also handle any UnitInfo Ro Values (ex: "<U-NUMBER>")]
|
|
roid = FormatRoidKey(roid);
|
|
|
|
ROFSTLookup.rochild rc = GetRoChild12(roid, loadChildren, loadAllChildren);
|
|
|
|
if (!roid.StartsWith("FFFF") && rc.children != null && rc.children.Length > 0 && roid.Length == 16)
|
|
{
|
|
// 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 GetTranslatedRoValue(string roid, bool DoCaret, bool DoDOSSuperSubScript, bool convertRoSymbols, ItemInfo myiteminfo)
|
|
{
|
|
roid = FormatRoidKey(roid, true);
|
|
|
|
string retval = GetRoChild(roid).value;
|
|
|
|
if (string.IsNullOrEmpty(retval))
|
|
return "?"; // Returning a "?" character indicates that the selected RO Value no longer exists or has been deleted.
|
|
|
|
retval = ReplaceUnicode(retval, DoCaret);
|
|
// B2023-037: Handle <=, >=, +-, -> and <- symbols. Convert to unicode for output, i.e. print and edit/view (when editing
|
|
// step, will show as 2 characters, not unicode, unless ro inserted when code replaced link text with unicode.
|
|
|
|
//(_MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseDashGreaterLessThenForArrowsInROValue ||
|
|
// _MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertGTELTEPMinROValue))
|
|
bool arrows1 = myiteminfo.ActiveFormat.PlantFormat.FormatData.SectData.UseDashGreaterLessThenForArrowsInROValue;
|
|
bool arrows2 = myiteminfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertGTELTEPMinROValue;
|
|
|
|
if (convertRoSymbols) retval = ROFSTLookup.ROConvertSymbols(retval, arrows1, arrows2);
|
|
|
|
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 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 };
|
|
}
|
|
|
|
public static string CalculateDuration(DateTime dtStart)
|
|
{
|
|
string duration = string.Empty;
|
|
|
|
double totalSecs = TimeSpan.FromTicks(DateTime.Now.Ticks - dtStart.Ticks).TotalSeconds;
|
|
int minutes = (totalSecs > 60) ? Convert.ToInt32(totalSecs) / 60 : 0;
|
|
double secs = (minutes <= 0) ? totalSecs : (totalSecs - Convert.ToDouble(minutes * 60));
|
|
|
|
if (minutes > 0) duration = string.Format("{0} min(s) ", minutes.ToString("n0"));
|
|
if (secs < 0) secs = 0.00;
|
|
duration = duration + string.Format("{0,10:#####0.00} sec(s)", secs).Trim();
|
|
|
|
return duration;
|
|
|
|
//return string.Format("{0,10:#####0.00}", TimeSpan.FromTicks(DateTime.Now.Ticks - dtStart.Ticks).TotalSeconds);
|
|
}
|
|
|
|
#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 = 0;
|
|
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;
|
|
|
|
// B2022-124: [JPR] Blank RO Values (All Spaces) printing as "?"
|
|
if (!string.IsNullOrEmpty(this.RoMissingDefaultValue))
|
|
cmd.Parameters.Add(new SqlParameter("@missingDefaultValue", SqlDbType.VarChar)).Value = this.RoMissingDefaultValue;
|
|
|
|
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)
|
|
{
|
|
// Currently, the RO Value Search only uses the default values for each of the (16) digit Ext Specific RO Return Values
|
|
// The defaults for each (16) digit Ext Specific RO Return Value are stored separately in the [RofstDefaultValue] table so they can be indexed / optimized
|
|
// for performance. In the future, the search can easily be modified to also include all unit specific return values as well. All we need to do is
|
|
// add a new table [RofstReturnValue] in the database to hold all of the different extension specific return values for each unit when applicable.
|
|
// All of the records in the [RofstReturnValue] will have a Foreign Key reference back to their RO Child Base objects in the [RofstChild] table.
|
|
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);
|
|
}
|
|
}
|
|
|
|
private List<string> GetBaseAccPageKeys()
|
|
{
|
|
try
|
|
{
|
|
List<string> lst = new List<string>();
|
|
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = cn.CreateCommand())
|
|
{
|
|
cmd.CommandTimeout = Database.DefaultTimeout;
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = "vesp_RofstDataGetBaseAccPageKeys";
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = _rofstID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
while (dr.Read())
|
|
{
|
|
lst.Add(dr.GetValue("BaseAccPageID").ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return lst;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetBaseAccPageKeys", 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)
|
|
{
|
|
try
|
|
{
|
|
// Check if roid is for a Unit Information RO Value Tag
|
|
if (!string.IsNullOrEmpty(accPageID) && accPageID.StartsWith("<U-"))
|
|
{
|
|
return GetUnitInfoRoChild(GetUnitInfoRoidByAccPageID(accPageID));
|
|
}
|
|
|
|
// 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 = accPageID;
|
|
|
|
using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
|
|
{
|
|
if (dr.Read())
|
|
{
|
|
return ConvertToRochildObject(dr, false, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return GetEmptyRoChild();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("RofstData.vesp_RofstDataGetChildByAccPageID", ex);
|
|
}
|
|
}
|
|
|
|
private string FormatAccPageKeyWithExt(string accPageID, string spDefault, string igDefault, ref string accPageBase, ref string accPageExt)
|
|
{
|
|
accPageBase = string.Empty;
|
|
accPageExt = string.Empty;
|
|
|
|
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-NUMBER>");
|
|
accPageID = accPageID.ToCleanString(); // Removes any spaces
|
|
|
|
// Clean up the AccPageID before using it to do a lookup
|
|
if (accPageID.StartsWith("<U-"))
|
|
{
|
|
accPageBase = accPageID;
|
|
accPageExt = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
if (!string.IsNullOrEmpty(spDefault)) accPageID = accPageID.Replace("<SP-", "<" + spDefault + "-");
|
|
if (!string.IsNullOrEmpty(igDefault)) accPageID = accPageID.Replace("<IG-", "<" + igDefault + "-");
|
|
|
|
accPageID = regRoKeyHigh.Replace(accPageID, "_HIGH$3");
|
|
accPageID = regRoKeyLow.Replace(accPageID, "_LOW$3");
|
|
accPageID = accPageID.Trim("<>".ToCharArray()); // String < and >
|
|
|
|
// Check the end of the AccPageID to determine if its an extension or part of the base key
|
|
// If the AccPageID doesn't have an extension then set to default
|
|
// B2022-121: RO values containing curly braces around values that are NOT multi return values do not resolved in Word Sections.
|
|
if (!Regex.IsMatch(accPageID.Substring(accPageID.Length - 2, 2), @".*\.[A-Z]") || BaseAccPageKeys.Contains(accPageID))
|
|
{
|
|
// No Extension, set to default
|
|
accPageID = string.Format("{0}.A", accPageID);
|
|
}
|
|
|
|
// Set AccPage Base and Extension return values
|
|
accPageBase = accPageID.Substring(0, (accPageID.Length - 2));
|
|
accPageExt = Convert.ToString(accPageID.ToCharArray().LastOrDefault());
|
|
}
|
|
}
|
|
|
|
return (!string.IsNullOrEmpty(accPageID)) ? accPageID.ToUpper() : accPageID;
|
|
}
|
|
|
|
#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++)
|
|
{
|
|
_dbRoCnt = 0;
|
|
|
|
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;
|
|
|
|
_dicRoCounts.Add(tableID, _dbRoCnt);
|
|
}
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
int slen2 = StringLength(ab, offset + 13 + slen);
|
|
myGrp.appid = Encoding.Default.GetString(ab, offset + 13 + slen, slen2);
|
|
|
|
_dbRoCnt++;
|
|
}
|
|
|
|
return myGrp;
|
|
}
|
|
// B2024-001: Loading of Ros was getting called over and over when ROs are in tables. Added
|
|
// a flag to only process once until completed, 'currentlyLoading'.
|
|
static bool currentlyLoading = false;
|
|
private void Load(int rofstID)
|
|
{
|
|
if (currentlyLoading) return; // B2024-001: don't load if in process of loading
|
|
currentlyLoading = true;
|
|
_dicRoCounts = new Dictionary<int, int>();
|
|
|
|
DateTime dtStart = DateTime.Now;
|
|
string title = string.Empty;
|
|
string displayText = string.Empty;
|
|
|
|
try
|
|
{
|
|
if (ShowLoadingStatus)
|
|
{
|
|
_frmRofstLoadStatus = new frmRofstLoadStatus();
|
|
_frmRofstLoadStatus.Show();
|
|
_frmRofstLoadStatus.Focus();
|
|
}
|
|
|
|
//Get Original ROLookup Bytes
|
|
OnProgressChanged("Importing ROFST File...", null, 1, 100);
|
|
byte[] bytes = RofstDataGetRofstLookupBytes(rofstID);
|
|
|
|
//Convert Bytes to Objects
|
|
OnProgressChanged("Converting RO Values to Objects...", null, 5, 100);
|
|
ROFSTLookup.roHdr roh = ConvertFst2Objects(bytes);
|
|
|
|
//Save FstObjects to Database
|
|
string userID = "System";
|
|
|
|
//Insert Rofst Header
|
|
OnProgressChanged("Creating Rofst Header...", null, 10, 100);
|
|
RofstHeaderInsert(rofstID, roh.hSize, roh.hMonth, roh.hDay, roh.hcYear, roh.hcMonth,
|
|
roh.hcDay, roh.hcHour, roh.hcMin, roh.hcSec, roh.hcHund, userID);
|
|
|
|
_pctComplete = 10.0;
|
|
_totalRoCnt = Convert.ToInt32(_dicRoCounts.Sum(x => x.Value));
|
|
|
|
for (int i = 0; i < roh.myDbs.Length; i++)
|
|
{
|
|
ROFSTLookup.rodbi rodbi = roh.myDbs[i];
|
|
|
|
_dbRoCnt = (_dicRoCounts.Where(x => x.Key == rodbi.dbiID).Any()) ? Convert.ToInt32(_dicRoCounts.Where(x => x.Key == rodbi.dbiID).FirstOrDefault().Value) : 0;
|
|
_curRoCnt = 0;
|
|
|
|
title = string.Format("Loading '{0}' Database... ({1} of {2})", rodbi.dbiTitle, i + 1, roh.myDbs.Length);
|
|
displayText = string.Format("Processing RO Value... ({0} of {1})", 1, _dbRoCnt.ToString("n0"));
|
|
|
|
//Insert Rofst Database
|
|
OnProgressChanged(title, displayText, Convert.ToInt32(_pctComplete), 100);
|
|
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]);
|
|
|
|
displayText = string.Format("Processing RO Values... ({0} of {1})", _curRoCnt.ToString("n0"), _dbRoCnt.ToString("n0"));
|
|
OnProgressChanged(displayText, Convert.ToInt32(_pctComplete), 100);
|
|
}
|
|
}
|
|
|
|
// Update Progress Bar Accordingly
|
|
if (_totalRoCnt > 0) _pctComplete = _pctComplete + ((Convert.ToDouble(_dbRoCnt) / Convert.ToDouble(_totalRoCnt)) * 80.0);
|
|
|
|
OnProgressChanged(displayText, Convert.ToInt32(_pctComplete), 100);
|
|
}
|
|
|
|
//Finalized Load for Rofst Header / Rebuild Indexes
|
|
OnProgressChanged("Finalizing Rofst Header and Rebuilding Indexes...", null, 90, 100);
|
|
RofstHeaderFinalizeLoad(rofstID);
|
|
|
|
title = string.Format("Successfully Loaded ({0}) RO Values... Total Duration {1}", _totalRoCnt.ToString("n0"), CalculateDuration(dtStart));
|
|
OnProgressChanged(title, null, 100, 100);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
OnProgressChanged("Error Imported RO Values...", ex.Message, 100, 100);
|
|
}
|
|
finally
|
|
{
|
|
try
|
|
{
|
|
if (_frmRofstLoadStatus != null)
|
|
{
|
|
_frmRofstLoadStatus.Close();
|
|
_frmRofstLoadStatus.Dispose();
|
|
_frmRofstLoadStatus = null;
|
|
}
|
|
|
|
if (_dicRoCounts != null || _dicRoCounts.Count > 0)
|
|
{
|
|
_dicRoCounts = null;
|
|
}
|
|
}
|
|
catch { }
|
|
}
|
|
currentlyLoading = false; // B2024-001: done loading
|
|
}
|
|
|
|
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);
|
|
|
|
//Increment RO Count if RoChild has a return value
|
|
if (!string.IsNullOrEmpty(child.value)) _curRoCnt++;
|
|
|
|
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]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region (Parse/Load - Events/Handlers)
|
|
|
|
protected virtual void OnProgressChanged(string title, string displayText, int curVal = 0, int maxVal = 100)
|
|
{
|
|
// If frmRofstLoadStatus is not null then call Update Progress Method
|
|
if (_frmRofstLoadStatus != null)
|
|
_frmRofstLoadStatus.UpdateProgress(title, displayText, curVal, maxVal);
|
|
}
|
|
|
|
protected virtual void OnProgressChanged(string displayText, int curVal = 0, int maxVal = 100)
|
|
{
|
|
// If frmRofstLoadStatus is not null then call Update Progress Method
|
|
if (_frmRofstLoadStatus != null)
|
|
_frmRofstLoadStatus.UpdateProgress(_frmRofstLoadStatus.Title, displayText, curVal, maxVal);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#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("AccPageID");
|
|
|
|
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));
|
|
}
|
|
// B2023-038: return a "?" if none found - this is used by calling methods to flag none found.
|
|
if (rc.ID < 0 && rc.value == null) rc.value = "?";
|
|
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];
|
|
|
|
// Load all extension specific return values (1 to many)
|
|
for (int i = 0; i < lstValues.Count; i++)
|
|
{
|
|
// B2022-110: PC/PC Multi return values are correct in editor but not correct in Step Properties/ROs when selected, or when printed
|
|
// B2022-110 continued (9/12/22): for lstValues.Count of 1, needed to use code that was there so that value can be used later for
|
|
// setting appid and roid
|
|
var roExt = lstValues.Count==1? Extensions.Where(x => x.Offset.Equals(i + 1)).SingleOrDefault() : Extensions.Where(x => x.AccPageExt.Equals(_multiRoValues[i])).SingleOrDefault();
|
|
|
|
// B2022-124: [JPR] Blank RO Values (All Spaces) printing as "?"
|
|
string roValue = GetParentChildROValue(lstValues[i], this.SelectedSlave, this.RoMissingDefaultValue);
|
|
|
|
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 != null && roExt.RoidExt != null) ? roExt.RoidExt : string.Empty).ToUpper();
|
|
child.children[i].children = new List<ROFSTLookup.rochild>().ToArray();
|
|
}
|
|
|
|
|
|
if (AutoCombineSingleRetValues && lstValues.Count == 1)
|
|
{
|
|
// When the RO object only has only return value and the "AutoCombineSingleRetValues" is set to True.
|
|
// Instead of returning the RoChildBase object with a single RoReturnVal object attached, just return the single Ro ReturnValue object.
|
|
var roRetVal = child.children.First();
|
|
|
|
//child.title = roRetVal.title;
|
|
child.appid = roRetVal.appid;
|
|
child.roid = roRetVal.roid;
|
|
child.value = roRetVal.value;
|
|
child.children = new List<ROFSTLookup.rochild>().ToArray();
|
|
}
|
|
else
|
|
{
|
|
child.value = null;
|
|
}
|
|
}
|
|
|
|
_lstRoValues.Clear();
|
|
_multiRoValues.Clear();
|
|
|
|
return;
|
|
}
|
|
|
|
private static string GetParentChildROValue(string roval, int selChldIdx, string roMissingDefaultValue)
|
|
{
|
|
// 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
|
|
// B2022-124: [JPR] Blank RO Values (All Spaces) printing as "?", Added roMissingDefaultValue parameter
|
|
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
|
|
// TODO: [JAKE]
|
|
return (selChldIdx == 0 && sb.ToString().Length <= 0) ? roMissingDefaultValue : 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)
|
|
{
|
|
if (string.IsNullOrEmpty(s2))
|
|
return 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 PROMS rather than a dash.
|
|
// if the dash is proceeded 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
|
|
|
|
}
|
|
}
|