Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 2 Projects Releases Wiki Activity
Files
16876375df0dbe57045fdfee312d180718e3f7ff
SourceCode/PROMS/BarakahConvert/XMLConvert/frmConvertXML.cs
John 6ea9865669
2020-01-22 17:33:34 +00:00

3378 lines
115 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml;
using System.Text.RegularExpressions;
using VEPROMS.CSLA.Library;
using log4net;
using System.IO;
using Volian.Controls.Library;
using C1.Win.C1FlexGrid;
namespace XMLConvert
{
public partial class frmConvertXML : Form
{
public frmConvertXML()
{
InitializeComponent();
Database.VEPROMS_Connection =
"Data Source=.\\SQL2008EXPRESS;Initial Catalog=VEPROMS_Barakah;Integrated Security=True";
}
private XmlDocument _MyXMLDoc = new XmlDocument();
public XmlDocument MyXMLDoc
{
get { return _MyXMLDoc; }
set { _MyXMLDoc = value; }
}
private void btnLoad_Click(object sender, EventArgs e)
{
LoadXml(tbFile.Text, "Document Loaded");
}
private void LoadXml(string fileName, string status)
{
FileInfo fi = new FileInfo(fileName);
//Console.WriteLine(fi.FullName);
StreamReader sr = fi.OpenText();
string buf = sr.ReadToEnd();
sr.Close();
buf = buf.Replace(" \x8", "");
buf = buf.Replace(" \x7", "");
MyXMLDoc.LoadXml(buf);
if (status != null) tbResults.Text = status;
}
private void btnFindNodeTypes_Click(object sender, EventArgs e)
{
LoadXml(tbFile.Text, "Document Loaded");
tbResults.Text = "Finding Nodes\r\n";
SortedList<string, XmlElement> AllNodeTypes = new SortedList<string, XmlElement>();
FindAllNodeTypes(AllNodeTypes, MyXMLDoc.DocumentElement);
foreach (string key in AllNodeTypes.Keys)
tbResults.AppendText(string.Format("[{0}]{1}\r\n", key, Attributes(AllNodeTypes[key])));
}
private string Attributes(XmlElement xe)
{
StringBuilder sb = new StringBuilder();
string sep = "\r\n\t";
foreach (XmlAttribute xa in xe.Attributes)
{
sb.Append(string.Format("{0}[{1}]", sep, xa.Name));
//if (xa.Name == "content")
// sb.Append(string.Format ("\r\n\t\t{0}",xa.Value));
}
return sb.ToString();
}
private void FindAllNodeTypes(SortedList<string, XmlElement> AllNodeTypes, XmlElement xmlElement)
{
if (!AllNodeTypes.ContainsKey(xmlElement.Name))
AllNodeTypes.Add(xmlElement.Name, xmlElement);
foreach (XmlNode xe in xmlElement.ChildNodes)
{
if (xe is XmlElement)
FindAllNodeTypes(AllNodeTypes, xe as XmlElement);
}
}
private void btnStructure_Click(object sender, EventArgs e)
{
tbResults.Clear();
Node.Reset();
LoadStructure(tbFile.Text);
ShowStructure();
}
private void LoadStructure(string fileName)
{
LoadXml(fileName, null);
Node.Add(MyXMLDoc.DocumentElement);
}
private void ShowStructure()
{
foreach (string key in Node.AllNodes.Keys)
{
Node nd = Node.AllNodes[key];
tbResults.AppendText(string.Format("[{0}]{1}\r\n", key, (nd.HasText ? "\tText" : "")));
if (nd.Children.Count > 0)
{
tbResults.AppendText(string.Format("\tChildren:\r\n"));
foreach (string child in nd.Children)
tbResults.AppendText(string.Format("\t\t{0}\r\n", child));
}
if (nd.Attributes.Count > 0)
{
tbResults.AppendText(string.Format("\tAttributes:\r\n"));
foreach (string key1 in nd.Attributes.Keys)
{
Attribute attr = nd.Attributes[key1];
if (key1 == "content")
tbResults.AppendText(string.Format("\t\t{0} Count={1}\r\n", attr.Name, attr.Count));
else if (attr.MinValue == attr.MaxValue)
tbResults.AppendText(string.Format("\t\t{0} Count={1} All={2}\r\n", attr.Name, attr.Count, attr.MinValue));
else
tbResults.AppendText(string.Format("\t\t{0} Count={1} Min={2} Max={3}\r\n", attr.Name, attr.Count, attr.MinValue, attr.MaxValue));
}
}
}
}
private void ShowStructure2()
{
foreach (string key in Node.AllNodes.Keys)
{
Node nd = Node.AllNodes[key];
bool hasContent = false;
tbResults.AppendText(string.Format("case \"{0}\":~", key));
string prefix = "\tformat=\"";
foreach (string key1 in nd.Attributes.Keys)
{
if (key1 == "content")
hasContent = true;
else
{
tbResults.AppendText(string.Format("{0}{1}={{{1}}}\";", prefix, key1));
prefix = " ";
}
if (hasContent)
tbResults.AppendText(string.Format(" {{content}}"));
}
tbResults.AppendText("\";~\tbreak;\r\n");
}
}
private void btnLoadContent_Click(object sender, EventArgs e)
{
LoadXml(tbFile.Text, "Document Loaded");
tbResults.Clear();
ShowAllContent(MyXMLDoc.DocumentElement, 0);
}
private void ShowAllContent(XmlElement xe, int level)
{
ShowContent(xe, level);
foreach (XmlNode ch in xe.ChildNodes)
{
if (ch is XmlElement)
ShowAllContent(ch as XmlElement, level + 1);
}
}
Regex regFixAttributes = new Regex("(\\{[A-Za-z]+?\\})", RegexOptions.Compiled);
private void ShowContent(XmlElement xe, int level)
{
string format = "Not Defined";
string prefix = " ";
switch (xe.Name)
{
case "ident":
format = "Procedure (LabelType-number)={labelType}-{number} fullName={fullName} PNSNo={PNSNo}";
break;
case "type":
format = "Procedure Type: {procedureType}";
break;
case "GrossStep":
format = "number={number} name={name}";
break;
case "Step":
format = "{number} {name}";
prefix = "S ";
break;
case "Contingency":
format = "{number} {name}";
prefix = "C ";
break;
case "attrib":
case "procedure":
case "controllers":
case "row":
format = "";// No Content
break;
case "CautionInstruction":
case "NoteInstruction":
format = "number={number} {content}";
break;
case "UnitaryInstruction":
case "BinaryInstruction":
format = "number={number} Left Target: {leftTarget} Link Target: {linkTarget} {content}";
break;
case "JoinInstruction":
format = "Link Target: {linkTarget} JoinType: {joinType}";
break;
case "UnitaryContingencyCallInstruction":
format = "number={number} Link Target: {linkTarget} Evaluation Type: {evaluationType} {content}";
prefix = "U ";
break;
case "taskGroup":
format = "name={name} borderVisible={borderVisible}";
break;
case "BoolVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "TextVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "ovationGraphic":
format = "title={title} Diagram Number: {diagramNumber}";
break;
case "ovationGroupTrend":
format = "name={name} description={description}";
break;
case "controller":
format = "controller - Unknown";
break;
case "and":
format = "and id={id}";
break;
case "BigOverview":
format = "BigOverview grossStep={grossStep} number={number} id={id}";
break;
case "BovActionStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovCheckBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovIfStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} rightTarget={rightTarget} {content}";
break;
case "BovMessageBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovProcedureLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepInLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepOutLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "descr":
case "esinfo":
case "esproj":
case "esprop":
case "private":
case "pwg":
case "pwt":
case "revbase":
case "systemtest":
format = "";
break;
case "eq":
case "gt":
case "gte":
case "lt":
case "lte":
case "not":
case "or":
format = "id={id}";
break;
case "fcase":
case "tcase":
format = "rst={rst}";
break;
case "logic":
format = "id={id} number={number}";
break;
case "ovationSingleTrend":
format = "description={description} number={number} id={id} name={name}";
break;
case "prop":
format = "type={type} value={value} name={name}";
break;
case "TextVarInputInstruction":
format = "taskDescription={taskDescription} varInputLabel={varinputLabel} number={number} {content}";
break;
case "utest":
format = "tested={tested}";
break;
case "var":
format = "var_type={var_type} id={id} name={name} number={number}";
break;
case "const":
format = "var_type={var_type} id={id} value={value}";
break;
}
tbResults.AppendText(string.Format("\r\n{0}{1}{2} ", prefix, "".PadRight(level, ' ').Replace(" ", "| "), xe.Name));
tbResults.AppendText(ReplaceAllAttributes(format, xe, level, prefix));
}
private string ReplaceAllAttributes(string format, XmlElement xe, int level, string prefix)
{
MatchCollection m;
while ((m = regFixAttributes.Matches(format)).Count > 0)
{
string part1 = format.Substring(0, m[0].Groups[1].Index);
string part3 = format.Substring(m[0].Groups[1].Index + m[0].Groups[1].Length);
string att = m[0].Groups[1].Value.Replace("{", "").Replace("}", "");
XmlAttribute xa = xe.Attributes[att];
//if (xa == null)
// Console.WriteLine(xe.OuterXml);
string part2;
if (xa != null)
part2 = xe.Attributes[att].Value; //GetAttribute(xe, att);
else
part2 = "null";
if (part2 == string.Empty) part2 = "empty";
if (att == "content")
{
string imageSrc = null;
if (part2.Contains(" src="))
{
imageSrc = RegFindImage.Replace(part2, "$1");
//Console.WriteLine(imageSrc);
}
part2 = FixHTML(part2, level);
if (imageSrc != null) part2 += "\n" + imageSrc;
part2 = part2.Replace("<br />", "<br />\n ");
part2 = part2.Replace("\n", string.Format("\r\n {0} ", "".PadRight(level).Replace(" ", "| ")));
}
format = part1 + part2 + part3;
}
return format;
}
private static Regex RegFixHTMLMulti = new Regex("<(p|li) [^>]*?>([^<>]*)</(p|li)>", RegexOptions.Compiled | RegexOptions.Singleline);
private static Regex RegFixHTML = new Regex(".*<(p|li).*?>(.*)</(p|li)>.*", RegexOptions.Compiled | RegexOptions.Singleline);
private static Regex RegFixHTMLbody = new Regex(".*<body.*?>(.*)</body>.*", RegexOptions.Compiled | RegexOptions.Singleline);
private static Regex RegFindImage = new Regex(".*<img src=\"([^\"]*)\".*/>.*", RegexOptions.Compiled | RegexOptions.Singleline);
private string FixHTML(string html, int level)
{
html = cleanupHTML(html, level);
return html;
//Console.WriteLine(html);
MatchCollection mc = RegFixHTMLMulti.Matches(html);
if (mc.Count > 1)
{
StringBuilder sb = new StringBuilder();
string sep = "";
foreach (Match m in mc)
{
string str = RegFixHTML.Replace(m.Value, "$2");
if (str != "")
sb.Append(sep + str);
sep = "\r\n";
}
return StripSpan(sb.ToString());
}
string newHTML = RegFixHTML.Replace(html, "$2");
if (html != newHTML) return StripSpan(newHTML);
newHTML = RegFixHTMLbody.Replace(html, "$1");
if (html != newHTML) return StripSpan(newHTML);
return StripSpan(html);
}
private static Regex RegStripSpan1 = new Regex("<span.*?>", RegexOptions.Compiled | RegexOptions.Singleline);
private static Regex RegStripSpan2 = new Regex("</span>", RegexOptions.Compiled | RegexOptions.Singleline);
private string StripSpan(string html)
{
return RegStripSpan2.Replace(RegStripSpan1.Replace(html, ""), "");
}
private static Regex[] Cleanup =
{
new Regex("<![^>]*>", RegexOptions.Compiled ),
new Regex(" margin-top: ?[0-9]+px;", RegexOptions.Compiled ),
new Regex(" margin-bottom: ?[0-9]+px;", RegexOptions.Compiled ),
new Regex(" margin-right: ?[0-9]+px;", RegexOptions.Compiled ),
new Regex(" margin-left: ?[0-9]+px;", RegexOptions.Compiled ),
new Regex(" padding-top:0;", RegexOptions.Compiled ),
new Regex(" padding-bottom:0;", RegexOptions.Compiled ),
new Regex(" padding-right:0;", RegexOptions.Compiled ),
new Regex(" padding-left:0;", RegexOptions.Compiled ),
new Regex(" color:#000000;", RegexOptions.Compiled ),
new Regex("-qt-paragraph-type:empty;", RegexOptions.Compiled ),
new Regex(" text-indent: ?0px", RegexOptions.Compiled ),
new Regex(" -qt-block-indent: ?0;", RegexOptions.Compiled ),
new Regex(" font-family:'Arial';", RegexOptions.Compiled ),
new Regex(" font-family:'Gulim';", RegexOptions.Compiled ),
new Regex(" font-family:'A';", RegexOptions.Compiled ),
new Regex(" font-size:[0-9]+pt;", RegexOptions.Compiled ),
new Regex("style=\"(| |;)*\"", RegexOptions.Compiled ),
new Regex("</?span[^>]*>", RegexOptions.Compiled ),
new Regex("<style[^>]*>[^<]*</style>", RegexOptions.Compiled ),
new Regex("</?meta[^>]*>", RegexOptions.Compiled ),
//new Regex("</?html[^>]*>", RegexOptions.Compiled ),
new Regex("</?body[^>]*>", RegexOptions.Compiled ),
new Regex("<p ></p>", RegexOptions.Compiled ),
new Regex("</?head[^>]*>", RegexOptions.Compiled),
//new Regex("<p[^>]*>NOTE</p>", RegexOptions.Compiled),
//new Regex("<p[^>]*>CAUTION</p>", RegexOptions.Compiled),
new Regex("<p[^>]*></p>", RegexOptions.Compiled),
};
private static Regex regexFixPFrontPadding = new Regex("<p[^>]*> +", RegexOptions.Compiled);
private static Regex regexFixPRearPadding = new Regex(" +</p>", RegexOptions.Compiled);
private static Regex regexFixLiFrontPadding = new Regex("<li[^>]*> +", RegexOptions.Compiled);
private static Regex regexFixLiRearPadding = new Regex(" +</li>", RegexOptions.Compiled);
private static Regex removeExtraReturns = new Regex("\r?\n(\r?\n)+", RegexOptions.Compiled);
private static Regex RegFixMultipleULs = new Regex("</ul>[\r\n]*<ul[^<>]+>", RegexOptions.Compiled | RegexOptions.Multiline);
private static Regex RegFixMultipleOLs = new Regex("</ol>[\r\n]*<ol[^<>]+>", RegexOptions.Compiled | RegexOptions.Multiline);
private static RegexReplace[] MyRegExReplaceSpecialChars = {
new RegexReplace("oF","\\'b0F"),// Degree
new RegexReplace("oC","\\'b0C"),// Degree
new RegexReplace("\xB0","\\'b0"),// Degree
new RegexReplace("\xBA","\\'b0"),// Degree
new RegexReplace("\u02DA","\\'b0"),// Degree
new RegexReplace("\xB1","\\'b1"),//
new RegexReplace("\xB2","\\up3 2\\up0 "),// Square
new RegexReplace("\xD7","x"),// Times
new RegexReplace("\u2013","\\u8209?"),
new RegexReplace("\xB1","\\'B1"),
new RegexReplace("\xB7","\\u9679?"),
new RegexReplace("\u2022","\\u9679?"),
new RegexReplace("\u2022","*"),
new RegexReplace("\u25AA","\\u9679?"),
new RegexReplace("\xA0","\\u160?"),
new RegexReplace("\u2019","'"),
new RegexReplace("\u2018","'"),
new RegexReplace("\u201C","\""),
new RegexReplace("\u201D","\""),
new RegexReplace("\u0394","\\u916?"),
new RegexReplace("\uFF06","&"),
new RegexReplace("\u2265","\\u8805?"),
new RegexReplace("\u25CF","\\u9679?"),
new RegexReplace("\u33A0","cm\\up3 2\\up0 "),
new RegexReplace("\u2192","\\u8594?"),
new RegexReplace("\uF07F","\\u9633?"),
new RegexReplace("\\u2264","\\u8804?"),
/*
new RegexReplace("",""),
*/
new RegexReplace(@">NOTE\\line<",">NOTE<"),// Note - line break
new RegexReplace(@">NOTES\\line<",">NOTES<"),// Note - line break
new RegexReplace(@">NOTE CONTINUED\\line<",">NOTE CONTINUED<"),// Note - line break
new RegexReplace(@"</p>[\r\n]*<p ?>THEN"," THEN")// Break - THEN
};
private static string cleanupHTML(string html, int level)
{
//Console.WriteLine(html);
//Console.WriteLine("END {0}",level);
html = html.Replace("<br />", "\\line ");
//if (html.Contains("All Safety Function Status Check"))
// Console.WriteLine(html.Substring(html.IndexOf("All Safety Function Status Check") - 10, 20));
foreach (Regex clean in Cleanup)
{
html = clean.Replace(html, "");
}
//if (html.Contains("All Safety Function Status Check"))
// Console.WriteLine(html.Substring(html.IndexOf("All Safety Function Status Check") - 10, 20));
// TODO Remove Padding from Front
//html = regexFixPFrontPadding.Replace(html, "<p>");
//if (html.Contains("All Safety Function Status Check"))
// Console.WriteLine(html.Substring(html.IndexOf("All Safety Function Status Check") - 10, 20));
html = regexFixPRearPadding.Replace(html, "</p>");
html = regexFixLiFrontPadding.Replace(html, "<li>");
html = regexFixLiRearPadding.Replace(html, "</li>");
html = removeExtraReturns.Replace(html, "\n");
if (html.StartsWith("\r\n"))
html = html.Substring(2);
if (html.StartsWith("\n"))
html = html.Substring(1);
//if (html.Contains("IF the RCS has experienced cooldown rate greater than"))
// Console.WriteLine("Here");
html = RegFixMultipleULs.Replace(html, "");
html = RegFixMultipleOLs.Replace(html, "");
//if( html.Contains("NOTE\\"))
// Console.WriteLine("Here");
foreach (RegexReplace rr in MyRegExReplaceSpecialChars)
html = rr.DoReplace(html);
return html;
}
private void tbResults_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.A && e.Control)
{
tbResults.SelectAll();
e.Handled = true;
}
}
private void btnLoadProcedure_Click(object sender, EventArgs e)
{
if (_MyFlexGrid == null)
{
_MyFlexGrid = new VlnFlexGrid();
this.Controls.Add(_MyFlexGrid);
_MyFlexGrid.Location = tbResults.Location;
_MyFlexGrid.Size = tbResults.Size;
_MyFlexGrid.BringToFront();
_NodeProcessed = new List<XmlNode>();
}
XML2PROMSDB(tbFile.Text);
}
private static string _MyTablePrefix;
private static XmlNamespaceManager _NSMGR;
private void XML2PROMSDB(string filename)
{
try
{
LoadXml(filename, null);
FileInfo fi = new FileInfo(filename);
fi.Directory.CreateSubdirectory("TableHTMLs");
_MyTablePrefix = fi.DirectoryName + "\\TableHTMLs";
XmlNamespaceManager nsmgr = new XmlNamespaceManager(MyXMLDoc.NameTable);
nsmgr.AddNamespace("x", MyXMLDoc.DocumentElement.NamespaceURI);
_NSMGR = nsmgr;
XmlNode xn = GetProcedureIdentifier(nsmgr);
string procType = GetProcedureType(xn);
if (procType == "FRP") procType = "EOP";
// Walk through structure Adding Items as you go
DocVersionInfoList dvil = DocVersionInfoList.Get();
DocVersionInfo dvi = null;
foreach (DocVersionInfo dviC in dvil)
if (dviC.MyFolder.Name == procType)
dvi = dviC;
ProcedureInfo lastProc = GetLastProcedure(dvi);
//string ProcNum = GetProcedureNumber(lastProc, xn);
string ProcNum = GetProcedureNumber(lastProc, filename);
lblProcedure.Text = ProcNum;
Application.DoEvents();
using (Procedure proc = Procedure.MakeProcedure(dvi, lastProc, ProcNum, xn.Attributes["fullName"].Value, 0))
{
proc.Save();
lastProc = ProcedureInfo.Get(proc.ItemID);
}
try
{
AddGrossStep(lastProc, nsmgr);
}
catch (Exception ex)
{
Console.WriteLine(lastProc.DisplayNumber + "\r\n\r\n" + ex.GetType().Name + "\r\n\r\n" + ex.Message + "\r\n\r\n" + ex.StackTrace);
MessageBox.Show(lastProc.DisplayNumber + "\r\n\r\n" + ex.Message + "\r\n\r\n" + ex.StackTrace, ex.GetType().Name, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
tbResults.AppendText(string.Format("\r\n{0}\r\n{1} - {2}\r\n", filename, ex.GetType().Name, ex.Message));
}
}
private static string GetProcedureType(XmlNode xn)
{
foreach (XmlNode xnc in xn.ParentNode.ChildNodes)
if (xnc.Name == "type")
return xnc.Attributes["procedureType"].Value;
return null;
}
private static string GetProcedureNumber(string filename)
{
FileInfo fi = new FileInfo(filename);
string fn = Regex.Replace(fi.Name.Replace(fi.Extension, ""), @"1N2-OP-([-0-9A-Z]+).+", "$1");
return fn;
}
private static string GetProcedureNumber(ProcedureInfo lastProc, string filename)
{
string ProcNum = GetProcedureNumber(filename);
if (lastProc == null)
;// ProcNum is correct
else if (lastProc.DisplayNumber == ProcNum)
ProcNum += " Rev 1";
else if (lastProc.DisplayNumber.StartsWith(ProcNum))
{
ProcNum = ProcNum + " Rev " + (1 + int.Parse(lastProc.DisplayNumber.Substring(ProcNum.Length + 5))).ToString();
}
return ProcNum;
}
private static string GetProcedureNumber(ProcedureInfo lastProc, XmlNode xn)
{
string ProcNum = string.Format("{0}-{1}", GetProcedureType(xn), xn.Attributes["shortName"].Value);
if (lastProc == null)
;// ProcNum is correct
else if (lastProc.DisplayNumber == ProcNum)
ProcNum += " Rev 1";
else if (lastProc.DisplayNumber.StartsWith(ProcNum))
{
ProcNum = ProcNum + " Rev " + (1 + int.Parse(lastProc.DisplayNumber.Substring(ProcNum.Length + 5))).ToString();
}
return ProcNum;
}
private XmlNode GetProcedureIdentifier(XmlNamespaceManager nsmgr)
{
XmlNodeList xl = MyXMLDoc.DocumentElement.SelectNodes("//x:ident", nsmgr);
if (xl.Count != 1)
throw (new Exception("XML File Does not contain a Single Ident Node"));
XmlNode xn = xl[0];
return xn;
}
private static ProcedureInfo GetLastProcedure(DocVersionInfo dvi)
{
ProcedureInfo lastProc = null;
if (dvi.Procedures != null)
foreach (ProcedureInfo oldProc in dvi.Procedures)
lastProc = oldProc;
return lastProc;
}
private void AddGrossStep(ProcedureInfo lastProc, XmlNamespaceManager nsmgr)
{
XmlNodeList xl = MyXMLDoc.SelectNodes("//x:GrossStep", nsmgr);
SectionInfo prevSection = null;
pbSection.Maximum = xl.Count;
pbSection.Value = 0;
foreach (XmlNode xn in xl)
{
lblSection.Text = "Sect " + xn.Attributes["number"].Value;
pbSection.Value++;
Application.DoEvents();
string config = null;
int type = 10000;
string sectName = xn.Attributes["name"].Value;
switch (sectName)
{
case "Purpose":
case "Entry Conditions":
case "Exit Conditions":
type = 10001;// Purpose Symptoms and Entry Conditions
config = "<Config><Section ColumnMode=\"1\" /></Config>";
break;
default:
if (sectName.ToUpper().Contains("ACTION"))
type = 10000;// Procedure Steps
else
if (sectName.ToUpper().StartsWith("ATTACHMENT"))
{
type = 10008;
}
else if(HasContingency(xn))
{
type = 10002;// Attachment with Column Header
// Two Column
}
else
{
type = 10008;// Attachment without Column Header
config = "<Config><Section ColumnMode=\"1\" /></Config>";
}
break;
}
using (Section sect = Section.MakeSection(lastProc, prevSection, FixSectionNumber(xn.Attributes["number"].Value), xn.Attributes["name"].Value, type))
{
if (config != null)
sect.MyContent.Config = config;
sect.Save();
prevSection = SectionInfo.Get(sect.ItemID);
AddStepChildren(nsmgr, prevSection, xn.SelectNodes("x:Step", nsmgr));
}
}
}
private bool HasContingency(XmlNode xn)
{
XmlNodeList xl = xn.SelectNodes(".//x:Contingency", _NSMGR);
if (xl.Count == 0) xl = xn.SelectNodes(".//x:BinaryInstruction", _NSMGR);
//if (xl.Count > 0)
// Console.WriteLine("Found Contingency {0} {1} {2} {3}", _ProcNum,xn.Name ,GetAttribute( xn,"number"),GetAttribute( xn,"name"));
return xl.Count > 0;
}
private string FixSectionNumber(string num)
{
if (Regex.IsMatch(num, "[IVX]+"))
return num + ".";
return num;
}
private void AddStepChildren(XmlNamespaceManager nsmgr, SectionInfo prevSection, XmlNodeList xl)
{
if (xl.Count > 0)
{
if (prevSection.DisplayText.StartsWith("Attachment"))
AddAttachments(prevSection, xl, nsmgr);
else
switch (prevSection.DisplayText.ToUpper())
{
case "PURPOSE":
case "ENTRY CONDITIONS":
case "EXIT CONDITIONS":
AddPSEC(prevSection, xl[0].ChildNodes);
break;
default:
if (AllSiblingsAreCautionsOrNotes(xl))
AddPSEC(prevSection, xl[0].ChildNodes);
else
AddStep(prevSection, xl);
break;
}
}
}
private bool AllSiblingsAreCautionsOrNotes(XmlNodeList xl)
{
if (xl.Count > 1) return false;
return AllSiblingsAreCautionsOrNotes((xl[0] as XmlElement).ChildNodes[0] as XmlElement);
}
private void AddPSEC(SectionInfo prevSection, XmlNodeList xl)
{
SectionInfo keepPrevSection = prevSection;
//xl = (xl)[0].ChildNodes;
if (xl.Count == 0) return;
//TODO Need to add logic to save the first note as a step and the rest off of the first note
//TODO ChildNodes Can include xmlText as well as xmlElement nodes
//TODO Create list of children
XmlElement FirstNote = null;
XmlElement FirstCaution = null;
XmlElement FirstUnitary = null;
XmlElement FirstContingency = null;
int UnitaryCount = 0;
// List<XmlElement> xl1 = new List<XmlElement>();
foreach (XmlNode xn in xl)
{
if (xn is XmlElement)
{
//Find First Child that is a Note
if (FirstNote == null || (xn.Name == "NoteInstruction" && FirstNote.Name != "NoteInstruction"))
FirstNote = xn as XmlElement;
if (FirstCaution == null || (xn.Name == "CautionInstruction" && FirstCaution.Name != "CautionInstruction"))
FirstCaution = xn as XmlElement;
if(FirstUnitary == null && (xn.Name == "UnitaryInstruction" || xn.Name == "UnitaryContingencyCallInstruction"
|| xn.Name == "BinaryInstruction" || xn.Name == "Contingency"))
FirstUnitary = xn as XmlElement;
if (xn.Name == "UnitaryInstruction" || xn.Name == "UnitaryContingencyCallInstruction"
|| xn.Name == "BinaryInstruction" || xn.Name == "Contingency")
UnitaryCount++;
if (FirstContingency == null && xn.Name == "Contingency")
FirstContingency = xn as XmlElement;
////if (xn.OuterXml.Contains("ALL AAC"))
// Console.WriteLine("XN ALL AAC");
}
}
FirstNote = FirstNote ?? FirstCaution;
if (FirstNote != null && FirstNote.Name == "UnitaryInstruction")
if (FirstCaution != null && FirstCaution.Name == "NoteInstruction")
Console.WriteLine("oopsie!");
//Remove First Note from List
//xl1.Remove(FirstNote);
//TODO Add Remaining Children
StepLookup mySteps = new StepLookup();
int level = -1;
if (FirstUnitary != null)
{
_LastStepText.Clear();
while (FirstUnitary != null)
{
//XmlElement lastNote = FirstUnitary;
// Add Other Notes if they exist
prevSection = keepPrevSection;
level = -1;
if (FirstUnitary.Attributes["content"] != null)
{
AddContent(prevSection, mySteps, level, FirstUnitary, true, UnitaryCount);
//if (FirstUnitary.ChildNodes.Count > 0 && FirstUnitary.Name == "UnitaryInstruction")
if (FirstUnitary.Name == "UnitaryContingencyCallInstruction")
MyContingencies.Add((1 + MyContingencies.Count).ToString(), mySteps[mySteps.Count - 1].ItemID);
if (FirstUnitary.ChildNodes.Count > 0)
AddStepStucture(mySteps, mySteps.Count - 1, FirstUnitary, false);
//Console.WriteLine("\"Unitary\"\t\"{0}\"\t\"{1}\"", prevSection, mySteps[mySteps.Count - 1]);
if (FirstContingency != null)
{
ContingencyStep = mySteps[mySteps.Count -1];
int lev1 = 1 + Math.Min(level + 1, mySteps.Count);
int inc = 1;
FirstContingency = FirstContingency.ChildNodes[0] as XmlElement;
while (FirstContingency != null)
{
AddStepStucture(mySteps, lev1, FirstContingency, true);
lev1 += inc;
mySteps[lev1 - 1] = mySteps[lev1 - 1];
inc = 0;
FirstContingency = FirstContingency.NextSibling as XmlElement;
}
mySteps[lev1 - 2] = mySteps[lev1 - 2];
}
if (mySteps.Count > 0)
{
level = 1;
prevSection = null;
}
else
{
//Console.WriteLine("No Steps");
}
}
if (FirstNote != null && FirstNote.Name == "UnitaryInstruction")
Console.WriteLine("Should not be Unitary Instruction 1 \"{0}\" {1}", _StepLocation, _StepID);
AddNotesAndCautions(ref prevSection, FirstNote, mySteps, ref level);
FirstNote = null;
FirstUnitary = FirstUnitary.NextSibling as XmlElement;
if (FirstUnitary != null && FirstUnitary == FirstContingency) FirstUnitary = FirstUnitary.NextSibling as XmlElement;
while (FirstUnitary != null && (FirstUnitary.Name == "NoteInstruction" || FirstUnitary.Name == "CautionInstruction"))
{
if (FirstNote == null) FirstNote = FirstUnitary;
FirstUnitary = FirstUnitary.NextSibling as XmlElement;
if (FirstUnitary != null && FirstUnitary == FirstContingency) FirstUnitary = FirstUnitary.NextSibling as XmlElement;
break;
}
// if (FirstUnitary != null && FirstUnitary.Name == "Contingency") Console.WriteLine("Contingency");
//if (FirstUnitary != null && FirstUnitary.Name == "BinaryInstruction") Console.WriteLine("Contingency");
//if(FirstUnitary != null)
// Console.Write("{0}", mySteps[0]);
// if (FirstNote != null) Console.WriteLine("next");
}
}
else
AddNotesAndCautions(ref prevSection, FirstNote, mySteps, ref level);
//TODO Add Cautions
}
private static void AddNotesAndCautions(ref SectionInfo prevSection, XmlElement FirstNote, StepLookup mySteps, ref int level)
{
_LastStepText.Clear();
while (FirstNote != null)
{
//XmlElement lastNote = FirstNote;
// Add Other Notes if they exist
if (FirstNote.Attributes["content"] != null)
{
XmlElement nextNote = FirstNote.NextSibling as XmlElement;
AddContent(prevSection, mySteps, level, FirstNote, true);
if (FirstNote.ChildNodes.Count > 0 && FirstNote.Name != "NoteInstruction" && FirstNote.Name != "CautionInstruction")
AddStepStucture(mySteps, level, FirstNote);
if (mySteps.Count > 0 && (nextNote == null || nextNote.Name != FirstNote.Name))
{
level = 1;
prevSection = null;
}
else
{
//Console.WriteLine("No Steps");
}
}
FirstNote = FirstNote.NextSibling as XmlElement;
if (FirstNote != null && FirstNote.Name != "NoteInstruction" && FirstNote.Name != "CautionInstruction")
break;
// if (FirstNote != null) Console.WriteLine("next");
if (FirstNote != null && FirstNote.Name == "UnitaryInstruction")
Console.WriteLine("Should not be Unitary Instruction 2 \"{0}\" {1}",_StepLocation,_StepID);
}
}
private static StepInfo _ContingencyStep = null;
public static StepInfo ContingencyStep
{
get { return _ContingencyStep; }
set { _ContingencyStep = value; }
}
private static string _LastName = "";
private static List<XmlNode> _NodeProcessed = null;
private static void AddContent(SectionInfo prevSection, StepLookup mySteps, int level, XmlNode xn, bool ignoreNote)
{
AddContent(prevSection, mySteps, level, xn, ignoreNote, 0);
}
private static string _StepLocation;
private static int _StepID;
private static Dictionary<int, StepText> _LastStepText = new Dictionary<int, StepText>();
private static string _MyRawData = null;
private static string _MyRawType = null;
private static bool _MyRawCheck = true;
private static void AddContent(SectionInfo prevSection, StepLookup mySteps, int level, XmlNode xn, bool ignoreNote, int steps)
{
//if (!_NodeProcessed.Contains(xn))
// _NodeProcessed.Add(xn);
//else
// Console.WriteLine("node Being Processed again");
int nextLevel = 0;
int adjustLevel = 0;
//if (level >= mySteps.Count - 1)
//{
// adjustLevel = level - mySteps.Count;
// Console.WriteLine("Level beyond Range");
//}
string RNOGoTo = xn.Attributes["linkTarget"] == null ? "" : xn.Attributes["linkTarget"].Value;
int type = 20001;
if (prevSection != null && prevSection.IsSection ) type = 20002;
E_FromType frType = E_FromType.Step;
string xmlbase = xn.Attributes["content"].Value;
//if (xmlbase.Contains("qt-block-indent"))
// Console.WriteLine("Here Indent");
//if (xmlbase.Contains("the affected SG has been isolated and the cooldown"))
// Console.WriteLine("Here 6");
//if (xmlbase.Contains("unless misoperation"))
// Console.WriteLine("Here 1");
//if (xmlbase.Contains("5. Natural"))
// Console.WriteLine("Here 5");
string xml = cleanupHTML(xmlbase, 0);
_MyRawData = xml;
_MyRawType = xn.Name;
if (xn.Name == "NoteInstruction" && xml != null && xml.Contains("NOTE"))
Console.WriteLine(xml);
//if (xml.Contains("SET CV-PIK-201, Letdown Backpressure Controller"))
// Console.WriteLine("Found it");
//if (xml.Contains("<img")) Console.WriteLine("here");
//if (xn.Name.StartsWith("Unitary")) Console.WriteLine("here");
//if ((xml.Contains("<table") || xml.Contains("<img")) && _MyTableFileName != null)
if (GetSectionStyle(xn.ParentNode) == "Free Form" && _MyTableFileName != null)
{
xmlbase = BuildHTMLLibDoc(xn, xmlbase);
return;
}
//if(xml.Contains(@"\u916?") && !xmlbase.Contains(@"\u916?"))
// Console.WriteLine("here");
if (!xml.Contains("<"))
{
Console.WriteLine("not XML - '{0}'");
xml = "<html><p>" + xml + "</p></html>";
}
//if (xml.Contains("SPADES") || xml.Contains("CONFIRM the diagnosis of a SGTR by performing the following"))
// Console.WriteLine("HERE");
if (prevSection == null)
{
if (xn.Name == "CautionInstruction")
{
type = 20006;
frType = E_FromType.Caution;
}
else if (xn.Name == "NoteInstruction" && (xml.Contains(">NOTE<") || xml.Contains(">NOTES<") || xml.Contains(">NOTE CONTINUED<")))
{
type = 20007;
frType = E_FromType.Note;
}
else
{
if (ContingencyStep != null)
{
type = 20040;
frType = E_FromType.RNO;
}
else
{
type = 20001;
frType = E_FromType.Step;
}
}
}
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml);
//bool resetUL = true;
string lastNodeName = "";
//_LastStepText.Clear();
foreach (XmlNode xn2 in xd.DocumentElement.ChildNodes)
{
if (xn2.InnerText != "" && xn2.InnerText != "NOTE" && xn2.InnerText != "NOTES" && xn2.InnerText != "NOTE CONTINUED" && xn2.InnerText != "CAUTION" && xn2.InnerText != "WARNING")
{
//if (xn2.InnerText.StartsWith("VERIFY the most affected SG 1"))
// Console.WriteLine("{0},{1}",mySteps,level);
StepText xn2Text = FixText(xn2);
//if (xn2Text.Text.Contains("indications should be used to aid in evaluating plant"))
// Console.WriteLine("Here");
//if (xn2Text.Text.Contains("unless misoperation"))
// Console.WriteLine("Here 1");
//if (xn2Text.Text.Contains("temperatures. SG water level is calibrated for normal"))
// Console.WriteLine("Here 4.5");
//if (xn2Text.Text.StartsWith("Natural"))
// Console.WriteLine("Here 5.0");
//if (xn2Text.Text.Contains("the affected SG has been isolated and the cooldown"))
// Console.WriteLine("Here 6.0");
//if (xn2Text.Text.Contains("During all phases of the cooldown"))
// Console.WriteLine("Here 7.0");
//if (xn2Text.Text.Contains("Minimize the number of cycles of pressurizer auxiliary spray"))
// Console.WriteLine("Here 8.0");
//if (xn2Text.Text.Contains("Operators should be aware of the status of CCW supply to the"))
// Console.WriteLine("Here 18.0");
//if (xn2Text.Text.Contains("To minimize the unmonitored release of radioactivity"))
// Console.WriteLine("Here 10.0");
//if (xn2Text.Text.Contains("When indicated SG water level is excessively high"))
// Console.WriteLine("Here 11.0");
//if (xn2Text.Text.Contains("When restarting RCPs, it is preferable to first start an RCP"))
// Console.WriteLine("Here 22.0");
//if (xn2Text.Text.Contains("Allowing the secondary system to backflow to the primary system"))
// Console.WriteLine("Here 27.0");
//if (xn2Text.Text.Contains("SG backflow for level control Backflow is a permissible operational"))
// Console.WriteLine("Here 27.a");
//if (xn2Text.Text.Contains("SG backflow for depressurization and cooldown Back flow is"))
// Console.WriteLine("Here 27.b");
//if (xn2Text.Text.Contains("At least one RCP must be operating before attempting"))
// Console.WriteLine("Here 27.b.*");
//if (xn2Text.Text.Contains("Once the entire RCS has been successfully cooled to SDC entry"))
// Console.WriteLine("Here 28.0");
//if (xn2Text.Text.Contains("Operation of the Containment Spray System "))
// Console.WriteLine("Here 20.0");
//if (xn2Text.Text.StartsWith("10."))
// Console.WriteLine("Numbered Step");
//if (xn2Text.Text.Contains("Cooling System Entry Conditions are satisfied") ||
// xn2Text.Text.Contains("Recovery Guideline may be exited when ANY of the following") ||
// xn2Text.Text.Contains("has accomplished its purpose by satisfying"))
// Console.WriteLine("Here");
// Check against last
int lastLevel = level;
level = getMatchingLevel(_LastStepText, xn2Text,lastLevel);
if (level > 0 && type == 20002)
{
if (xn2Text.Tab == "") type = 20024;
else type = 20001;
}
//if (xn2Text.Tab == "*")
// type = 20004;
//else if (xn2Text.Tab == "" && level > 0)
// type = 20024;
//else
//type = 20001;
if (xn2Text.Text != "")
{
if (xn2.Name == "p")
{
//resetUL = true;
XmlNode pxn = PreviousNode(xn2, "p");
StepText pxnText = FixText(pxn);
XmlNode nxn = NextNode(xn2, "p");
StepText nxnText = FixText(nxn);
//ListMySteps("AddContent", mySteps);
bool levelIsOK = true;// level < 0 || level < mySteps.Count - 1;
if (xn2Text.Text != "AND" && xn2Text.Text != "OR")
{
if (pxnText != null && pxnText.Text == "OR")
using (Step step = MakeCSLAStep(mySteps, level, null, xn2Text.Text, 20005, E_FromType.Step)) { ;}
else if (pxnText != null && pxnText.Text == "AND")
using (Step step = MakeCSLAStep(mySteps, level, null, xn2Text.Text, 20019, E_FromType.Step)) { ;}
else if (nxnText != null && nxnText.Text == "OR" && NextNode(nxn, "p") != null && nxn.ParentNode.Name != "ul" && levelIsOK)
using (Step step = MakeCSLAStep(mySteps, level, null, xn2Text.Text, 20005, E_FromType.Step)) { ;}
else if (nxnText != null && nxnText.Text == "AND")
using (Step step = MakeCSLAStep(mySteps, level, null, xn2Text.Text, 20019, E_FromType.Step)) { ;}
else
{
if (level < 1 && prevSection != null)
{
if (type == 20007 || frType == E_FromType.Note)
Console.WriteLine("Here");
int myType = 20002;
if (prevSection.MyContent.Type == 10001 && steps == 0)
myType = 20041;
if(level < 0)level++;
//Console.WriteLine("\"prevSection1\"\t\"{0}\"\t\"{1}\"\t{2}\t{3}", prevSection, mySteps[level], level, myType);
using (Step step = MakeNewStep(prevSection, mySteps[level], null, xn2Text.Text, myType, E_FromType.Step))
{
//if (step.ItemID == 9408)
// Console.WriteLine("Here");
step.Save();
StepInfo si = mySteps[level] = StepInfo.Get(step.ItemID);
CheckHLS(si, "Case 1");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (step.ItemID >= 10079 && step.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
if ((nxnText == null || nxnText.Tab == "" || xn2Text.Tab == "") && (pxnText == null || pxnText.Tab == "" || xn2Text.Tab == ""))
{
prevSection = null;
nextLevel = level + 1;
}
}
}
else
{
switch (frType)
{
case E_FromType.Caution:
if (mySteps[0].Cautions != null && mySteps[0].Cautions.Count > 0)
mySteps[1] = StepInfo.Get(mySteps[0].Cautions[0].LastSibling.ItemID);
break;
case E_FromType.Note:
if (mySteps[0].Notes != null && mySteps[0].Notes.Count > 0)
mySteps[1] = StepInfo.Get(mySteps[0].Notes[0].LastSibling.ItemID);
break;
case E_FromType.RNO:
if (ContingencyStep != null)
{
//Console.WriteLine("BuildMySteps {0} type {1} frtype {2}", ContingencyStep,type,frType);
BuildMySteps(ContingencyStep, mySteps);
ContingencyStep = null;
}
else
{
type = 20024;
frType = E_FromType.Step;
}
level = mySteps.Count;
break;
case E_FromType.Step:
if (level > mySteps.Count) level = mySteps.Count;
if (level > 0 && mySteps[level - 1].Steps != null && mySteps[level - 1].Steps.Count > 0)
mySteps[level] = StepInfo.Get(mySteps[level - 1].Steps[0].LastSibling.ItemID);
break;
case E_FromType.SupInfo:
if (mySteps[level - 1].SupInfos != null && mySteps[level - 1].SupInfos.Count > 0)
mySteps[level] = StepInfo.Get(mySteps[level - 1].SupInfos[0].LastSibling.ItemID);
break;
case E_FromType.Table:
if (mySteps[level - 1].Tables != null && mySteps[level - 1].Tables.Count > 0)
mySteps[level] = StepInfo.Get(mySteps[level - 1].Tables[0].LastSibling.ItemID);
break;
default:
break;
}
switch (frType)
{
case E_FromType.Caution:
using (Step step = MakeNewStep(mySteps[0].MyHLS, GetFirstCaution(mySteps[0].MyHLS), null, xn2Text.Text, type, frType))
{
step.Save();
level = 1;
StepInfo si = mySteps[level] = StepInfo.Get(step.ItemID);
CheckHLS(si, "Case 2");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (step.ItemID >= 10079 && step.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
}
type = 20001;
break;
case E_FromType.Note:
using (Step step = MakeNewStep(mySteps[0].MyHLS, GetFirstNote(mySteps[0].MyHLS), null, xn2Text.Text, type, frType))
{
step.Save();
level = 1;
StepInfo si = mySteps[level] = StepInfo.Get(step.ItemID);
CheckHLS(si, "Case 3");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (step.ItemID >= 10079 && step.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
}
type = 20001;
break;
default:
//if (frType == E_FromType.RNO)
// Console.WriteLine("{0} {1} {2} {3}", mySteps[level - 1], mySteps[level], frType, xn2.InnerText.Trim(" ".ToCharArray()));
string originalText = null;
if (RNOGoTo != string.Empty && xn.Name != "UnitaryContingencyCallInstruction")
{
string xn2TextAfter = StripQuestion(xn2Text.Text);
if (xn2Text.Text != xn2TextAfter)
{
string removeWord = xn2Text.Text.Replace(xn2TextAfter, "").Replace("?", "");
originalText = xn2Text.Text;
xn2Text.Text = xn2TextAfter;
}
}
if (originalText != null)
_MyRawCheck = false;
using (Step step = MakeCSLAStep(mySteps, level, null, xn2Text.Text, type, frType))
{
if (frType == E_FromType.RNO) level++;
if (originalText != null)
Annotation.MakeAnnotation(step, AnnotationType.GetByNameOrCreate("Barakah Conversion1"), null,
string.Format("Original Text:\r\n\r\n{0}\r\n\r\nThis step may need edited.", originalText), null);
}
break;
}
}
if (RNOGoTo != string.Empty && xn.Name != "UnitaryContingencyCallInstruction")
{
//TODO Add Transitions
using (Step stepr = MakeCSLAStep(mySteps, level + 1, null, "Go to step " + RNOGoTo, 20040, E_FromType.RNO)) { ;}
if(level < 0) level = mySteps.Count - 1;
mySteps[level] = mySteps[level];
}
_MyRawCheck = true;
}
}
}
else if (xn2.Name == "ul" || xn2.Name == "ol")
{
int lev = mySteps.Count - 1;
//if (resetUL)
// mySteps.Remove(lev + 1);
if (lastNodeName == "ul" || lastNodeName == "ol")
lev--;
//resetUL = false;
XmlNodeList xl1 = xn2.SelectNodes("li");
foreach (XmlNode xn3 in xl1)
{
if (prevSection == null)
{
try
{
if(frType == E_FromType.Note && type == 20007)
using (Step step = MakeCSLAStep(mySteps, lev + 1, null, FixText(xn3).Text, type, frType)) { ;}
else
using (Step step = MakeCSLAStep(mySteps, lev + 1, null, FixText(xn3).Text, mySteps[lev].DisplayText.ToUpper().StartsWith("ONE ") ? 20005 : 20004, E_FromType.Step)) { ;}
}
catch (Exception ex)
{
ListMySteps(string.Format("makeCSLAStep Crash Level= {0}\r\n\r\n", lev), mySteps);
throw ex;
}
}
else
{
int myType = 20002;
if (mySteps.Count > level)
{
level++;
}
else
Console.WriteLine("Change in Conversion");
StepText xn3txt = FixText(xn3);
//if(xn3txt.Contains("The following actions are"))
//Console.WriteLine("\"prevSection2\"\t\"{0}\"\t\"{1}\"\t{2}\t{3}", prevSection, mySteps[level], level, myType);
using (Step step = MakeNewStep(prevSection, mySteps[level], null, xn3txt.Text, myType, E_FromType.Step))
{
step.Save();
StepInfo si = mySteps[level] = StepInfo.Get(step.ItemID);
CheckHLS(si, "Case 4");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (step.ItemID >= 10079 && step.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
prevSection = null;
lev = level;
}
}
}
}
else
{
if (xn2.Name == "table")
{
//Console.WriteLine("======================> Unprocessed table {0}", GetPath(xn));
//if (xn2.OuterXml.Contains(@"\u916?") )
// Console.WriteLine("Here");
if (mySteps.Count == 0)
using (Step step = MakeNewStep(prevSection, mySteps[level], null, "\xA0 Empty High Level Step", 2, E_FromType.Step))
{
step.Save();
level = Math.Max(level, 0);
StepInfo si = mySteps[level] = StepInfo.Get(step.ItemID);
CheckHLS(si, "Case 5");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (step.ItemID >= 10079 && step.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
prevSection = null;
}
if (_MyTableFileName == null)
{
Console.WriteLine("xml='{0}'",xn2.OuterXml);
LoadTable2(xn2, mySteps, level);
}
}
}
}
lastNodeName = xn2.Name;
if(xn2Text.Text != "AND" && xn2Text.Text != "OR")
_LastStepText[level] = xn2Text;
level = Math.Max(level, nextLevel);
}
}
RemoveStepsAbove(mySteps, level);
}
private static Step MakeNewStep(ItemInfo parentInfo, ItemInfo previousInfo, string stepNumber, string stepTitle, int stepType, E_FromType fromType)
{
Step step = Step.MakeStep(parentInfo, previousInfo, stepNumber, stepTitle, stepType, fromType);
if (_MyRawData != null)
{
if (_MyRawCheck && (FixRawData(_MyRawData) != stepTitle))
{
if (stepType != 20007 && _MyRawData.Contains(">NOTE"))
//Console.WriteLine("Here");
Annotation.MakeAnnotation(step, AnnotationType.GetByNameOrCreate("Barakah Raw Data"), null, _MyRawType + ":\r\n" + FixRawData(_MyRawData), null);
}
if (_MyRawCheck && _MyRawData != null && _MyRawType == "BinaryInstruction" && _MyRawType == "Contingency")
Annotation.MakeAnnotation(step, AnnotationType.GetByNameOrCreate("Barakah Raw Data2"), null, _MyRawType + ":\r\n" + FixRawData(_MyRawData), null);
_MyRawData = null;
}
return step;
}
private static string FixRawData(string str)
{
str = str.Replace("<p >", "").Replace("</p>", "").Replace("<li >", "\u25CF ").Replace("</li>", "\r\n").Replace("<html>", "")
.Replace("</html>", "").Replace(@"\line", "").Replace("</ul>","").TrimStart(" \r\n\t".ToCharArray())
.Replace(@"\u8209?", "\u2011").Replace(@"\u9679?", "\u25CF").Replace("<li >", "\u25CF ").Replace("<li>", "\u25CF ");
str = Regex.Replace(str, "<ul[^>]+>", "");
str = Regex.Replace(str, "<p[^>]+>", "");
str = Regex.Replace(str, "[\r\n]+", "\r\n");
return str;
}
private static void CheckHLS(StepInfo si, string str)
{
if (si.MyContent.Type == 20002 && si.ActiveParent is ItemInfo && (si.ActiveParent as ItemInfo).MyContent.Type == 20002)
Console.WriteLine("HLS Parent of HLS {0}",str);
}
private static Regex _regalpha = new Regex(@"[a-z][\.\)]");
private static Regex _regALPHA = new Regex(@"[A-Z][\.\)]");
private static Regex _regNumeric = new Regex(@"([0-9]+)[\.\)]");
private static string NextTab(string tab)
{
Match m = _regalpha.Match(tab);
if (m.Success)
{
string retval = ((char)(tab[0] + 1)) + tab.Substring(1);
return retval;
}
m = _regALPHA.Match(tab);
if (m.Success)
{
string retval = ((char)(tab[0] + 1)) + tab.Substring(1);
return retval;
}
m = _regNumeric.Match(tab);
if (m.Success)
return ((int.Parse(m.Groups[1].Value)+1).ToString() + tab.Substring(m.Groups[1].Length));
return tab;
}
private static Regex _RegFirst = new Regex(@"[1Aa][\.\)]", RegexOptions.Compiled);
private static bool IsFirstTab(string tab)
{
if (tab == "" || tab == "*") return true;
bool retval = _RegFirst.IsMatch(tab);
if(retval) return true;
return false;
}
private static int getMatchingLevel(Dictionary<int, StepText> lastStepText, StepText xn2Text, int level)
{
//if (xn2Text.Text.Contains("All Safety Function Status Check"))
// Console.WriteLine("here");
if (lastStepText.Count == 0) return level;
int maxkey = 0;
int i = 0;
foreach (int key in lastStepText.Keys) // Look at exact match first
{
StepText st = lastStepText[key];
if (NextTab(st.Tab) == xn2Text.Tab)
{
//if (st.Tab != "*" && st.Tab != "")
// Console.WriteLine("Here");
if (st.Indent == xn2Text.Indent)
{
return key;
}
if(xn2Text.Tab != "" && Math.Abs(st.Indent - xn2Text.Indent) > 1)
Console.WriteLine("\"Wrong Indent\"\t\"{0}\"\t{1}\t{2}\t{3}\t\"{4}\"\t\"{5}\"\t\"{6}\"",_StepLocation,_StepID, st.Indent, xn2Text.Indent, st.Tab, xn2Text.Tab, xn2Text.Text);
}
if (key > maxkey) maxkey = key;
i++;
}
i = 0;
foreach (int key in lastStepText.Keys) //Look for an indent match
{
StepText st = lastStepText[key];
if (st.Indent == xn2Text.Indent)
{
//Console.WriteLine("\"=\"\t{0}\t{1}\t{2}\t\"{3}\"\t\"{4}\"", i, st.Indent, xn2Text.Indent, st.Tab, xn2Text.Tab);
//Console.WriteLine("{0}\t\"{1}\"\t\"{2}\"", i, st.Tab, xn2Text.Tab);
if (NextTab(st.Tab) == xn2Text.Tab)
{
//if (st.Tab != "*" && st.Tab != "")
// Console.WriteLine("Here");
return key;
}
if (IsFirstTab(xn2Text.Tab))
return key + 1;
// Partial Indent Match
Console.WriteLine("\"Wrong Tab\"\t\"{0}\"\t{1}\t{2}\t{3}\t\"{4}\"\t\"{5}\"\t\"{6}\"", _StepLocation, _StepID, st.Indent, xn2Text.Indent, st.Tab, xn2Text.Tab, xn2Text.Text);
return key;
}
if (key > maxkey) maxkey = key;
i++;
}
i = 0;
foreach (int key in lastStepText.Keys) // Close Indent Match
{
StepText st = lastStepText[key];
if (st.Indent + 1 == xn2Text.Indent)
{
//Console.WriteLine("\">\"\t{0}\t{1}\t{2}\t\"{3}\"\t\"{4}\"", i, st.Indent, xn2Text.Indent, st.Tab, xn2Text.Tab);
if (xn2Text.Tab == "") return i+1;
return key;
}
if (st.Indent - 1 == xn2Text.Indent)
{
//Console.WriteLine("\"<\"\t{0}\t{1}\t{2}\t\"{3}\"\t\"{4}\"", i, st.Indent, xn2Text.Indent, st.Tab, xn2Text.Tab);
if (xn2Text.Tab == "") return i+1;
return key;
}
i++;
}
if (IsFirstTab(xn2Text.Tab))
return maxkey+1;
Console.WriteLine("\"First Not First\"\t\"{0}\"\t{1}\t{2}\t{3}\t\"{4}\"\t\"{5}\"\t\"{6}\"", _StepLocation, _StepID, "", xn2Text.Indent, "", xn2Text.Tab, xn2Text.Text);
return maxkey + 1;
}
private static string BuildHTMLLibDoc(XmlNode xn, string xmlbase)
{
XmlDocument xd1 = new XmlDocument();
xmlbase = Regex.Replace(xmlbase, "<![^>]+>[\r\n]*", "");
xmlbase = Regex.Replace(xmlbase, " style=\"\" style=\"", " style=\"");
string pat = " style=\\\"([^\"]+)\\\" style=\\\"";
xmlbase = Regex.Replace(xmlbase, pat, " style=\"$1");
xmlbase = xmlbase.Replace(" src=\".", " src=\"..");
if (_MyTableFileName == _LastTableFileName)
{
FileInfo fi = new FileInfo(_LastName);
using (StreamReader tr = fi.OpenText())
{
string lastContents = tr.ReadToEnd();
// Merge two HTML documents
int endLocation = lastContents.IndexOf("</body>");
int startLocation = xmlbase.IndexOf(">", xmlbase.IndexOf("<body "));
xmlbase = lastContents.Substring(0, endLocation) + xmlbase.Substring(startLocation + 1);
}
fi.Delete();
_TableNumber++;
}
else
{
_TableNumber = 1;
}
_LastTableFileName = _MyTableFileName;
xd1.LoadXml(xmlbase);
string filename = MakeFileName(xn);
_LastName = filename;
xd1.Save(filename);
return xmlbase;
}
private static string MakeFileName(XmlNode xn)
{
string filename = _MyTablePrefix + "\\" + GetLibDocName(xn).Replace(".", "").Replace("/", "").Replace("\\.", "") + "_" + _MyTableFileName + "_Table" + string.Format("{0:000}.HTML", _TableNumber);
return filename;
}
private static string GetLibDocName(XmlNode xn)
{
while (xn.Name != "Step")
xn = xn.ParentNode;
return xn.Attributes["name"].Value;
}
private static string _LastTableFileName=null;
private static int _TableNumber = 0;
//private static void LoadTable1(XmlNode xn)
//{
// XmlNode xn2 = xn.SelectSingleNode("tr/td/table");
// if (xn2 != null) xn = xn2;
// //xn.OwnerDocument.Save(filename);
// //if (xn.OuterXml.Contains("colspan") || xn.OuterXml.Contains("colspan"))
// // Console.WriteLine("Span");
// //XmlNodeList xlr = xn.SelectNodes("tr");
// //XmlNodeList xlc = xn.SelectNodes("tr/td");
// //XmlNodeList xlrs = xn.SelectNodes("tr/td/@colspan");
// //XmlNodeList xlcs = xn.SelectNodes("tr/td/@rowspan");
// //Console.WriteLine("{0}\t{1}\t{2}\t{3}", xlr.Count, xlc.Count, sum(xlcs,"colspan"),sum( xlrs,"rowspan"));
// //LoadTable(xn, 0,0,0);
//}
private static int sum(XmlNodeList xls,string attname)
{
int result = 0;
if(xls != null && xls.Count > 0)
foreach(XmlNode xc in xls)
if(xc is XmlAttribute)
result += int.Parse(xc.Value);
return result;
}
//private static void LoadTable(XmlNode xn, int level, int row, int col)
//{
// //if(xn is XmlText)
// //Console.WriteLine("T {0}{1}", "".PadLeft(2*level), xn.InnerText);
// //else
// if(xn is XmlElement)
// foreach(XmlNode xc in xn.ChildNodes)
// {
// if (xc is XmlElement && xc.Name == "td")
// {
// col++;
// //Console.WriteLine("X {0}{1} CS {2} RS {3}", "".PadLeft(2 * level), xc.Name, GetAttribute(xc, "colspan"), GetAttribute(xc, "rowspan"));
// }
// else if (xc is XmlElement && xc.Name == "tr")
// {
// row++;
// //Console.WriteLine("X {0}{1}", "".PadLeft(2 * level), xc.Name);
// }
// else
// //Console.WriteLine("X {0}{1}({2},{3})", "".PadLeft(2 * level), xc.Name,row,col);
// if (xc is XmlElement && xc.Name == "table")
// LoadTable(xc, level + 1, 0, 0);
// else
// LoadTable(xc, level + 1, row, col);
// }
//}
private static string GetAttribute(XmlNode xc, string attName)
{
string retval = null;
XmlAttribute xa = xc.Attributes[attName];
if (xa != null)
retval = xa.Value;
return retval;
}
private static string StripQuestion(string str)
{
string tmp = Regex.Replace(str, @"^(Is|Are|Has|Does|Did|Can|Do|Was|Were) (.+)\?$", "VERIFY $2");
//if (tmp != str)
// tmp = tmp.Substring(0, 1).ToUpper() + tmp.Substring(1);
return tmp;
}
private static Regex _RegRemoveLineBreaks = new Regex(@"\\line +", RegexOptions.Compiled);
private static StepText FixText(XmlNode xn)
{
if (xn == null) return null;
string str = xn.InnerText;
//if (str.Contains("may be exited when ANY of the following conditions"))
// Console.WriteLine("here");
// TODO Remove Tab Numbers
//str = Regex.Replace(xn.InnerText, "[A-Z0-9]+[.)] +", "");
//str = str.Trim(" \t".ToCharArray());
//str = Regex.Replace(str, " +", " ");
str = _RegRemoveLineBreaks.Replace(str, " ");
//if (str.Contains("The diagnosis of a SGTR is NOT confirmed"))
// Console.WriteLine("here");
return new StepText(str);
//RHM return Regex.Replace(str, "^(NOTE|NOTE CONTINUED|CAUTION|WARNING)$", "");
}
private static ItemInfo GetFirstNote(ItemInfo myItemInfo)
{
if (myItemInfo.Notes != null && myItemInfo.Notes.Count > 0)
return StepInfo.Get(myItemInfo.Notes[0].LastSibling.ItemID);
return null;
}
private static ItemInfo GetFirstCaution(ItemInfo myItemInfo)
{
if (myItemInfo.Cautions != null && myItemInfo.Cautions.Count > 0)
return StepInfo.Get(myItemInfo.Cautions[0].LastSibling.ItemID);
return null;
}
private static void BuildMySteps(StepInfo step, StepLookup mySteps)
{
if ((step.ActiveParent as ItemInfo).IsStep)
{
BuildMySteps(step.ActiveParent as StepInfo, mySteps);
mySteps.AddOne(step);
}
else
mySteps[0] = step;
}
private static void ListMySteps(string str, StepLookup mySteps)
{
int i = 0;
foreach (string key in mySteps.Keys)
{
//if (key != i.ToString())
Console.WriteLine("{0} {1} {2} {3}", str, i, key, mySteps[key].ToString());
i++;
}
}
public static Step MakeCSLAStep(StepLookup mySteps, int level, string stepNumber, string stepText, int stepType, E_FromType fromType)
{
if (mySteps.Count < level)
{
//Console.WriteLine("StepText + '{0}", stepText);
level = mySteps.Count;
//throw (new Exception("Error Making Step - null parent and previous"));
}
try
{
//if (mySteps.Count > 1 && mySteps[0].Ordinal == 5 && mySteps[level - 1].IsCautionOrNotePart)
// Console.WriteLine("Here");
if (level < 1) level = 1;
if (stepType == 20002)
{
if (mySteps[level - 1] != null && mySteps[level - 1].MyContent.Type == 20002)
stepType = 20001;
else if (mySteps[level] != null && mySteps[level].MyContent.Type == 20002)
Console.WriteLine("Oops");
}
else if (stepType == 20001)
{
if (mySteps[level] != null && mySteps[level].MyContent.Type == 20002)
stepType = 20002;
}
using (Step stp = MakeNewStep(mySteps[level - 1], mySteps[level], stepNumber, stepText, stepType, fromType))
{
stp.Save();
StepInfo si = mySteps[level] = StepInfo.Get(stp.ItemID);
CheckHLS(si, "Case 6");
_StepLocation = si.ShortPath;
_StepID = si.ItemID;
//if (stp.ItemID >= 10079 && stp.ItemID <= 10089)
// Console.WriteLine("{0} - {1} - {2}", si.ItemID, si.DisplayText, si.ShortPath);
return stp;
}
}
catch (Exception ex)
{
throw (new Exception("Error Making Step"));
}
}
private static void RemoveStepsAbove(StepLookup mySteps, int level)
{
List<string> removeList = new List<string>();
foreach (string key in mySteps.Keys)
if (int.Parse(key) > level)
removeList.Add(key);
foreach (string k in removeList)
mySteps.Remove(k);
//ListMySteps("RemoveStepsAbove", mySteps);
}
private static XmlNode NextNode(XmlNode xn2, string nodeName)
{
while (xn2 != null)
{
xn2 = xn2.NextSibling;
if (xn2 == null) return null;
if (xn2.Name == nodeName) return xn2;
}
return null;
}
private static XmlNode PreviousNode(XmlNode xn2, string nodeName)
{
while (xn2 != null)
{
xn2 = xn2.PreviousSibling;
if (xn2 == null) return null;
if (xn2.Name == nodeName) return xn2;
}
return null;
}
private void AddStep(SectionInfo prevSection, XmlNodeList xl)
{
StepLookup mySteps = new StepLookup();
pbStep.Value = 0;
pbStep.Maximum = xl.Count;
foreach (XmlNode xn in xl)
{
pbStep.Value++;
Application.DoEvents();
using (Step step = MakeNewStep(prevSection, mySteps[0], null, xn.Attributes["name"].Value, 20002, E_FromType.Step))
{
//if (step.ItemID == 9408)
// Console.WriteLine("Here");
//if (xn.Name == "UnitaryContingencyCallInstruction")
//{
// string key = xn.Attributes["number"].Value;
// MyContingencies.Add((1 + MyContingencies.Count).ToString(), step.ItemID);
//}
MyContingencies.Clear();
step.Save();
mySteps[0] = StepInfo.Get(step.ItemID);
CheckHLS(mySteps[0], "Case 7");
_StepLocation = mySteps[0].ShortPath;
_StepID = mySteps[0].ItemID;
lblStep.Text = "Step " + mySteps[0].Ordinal.ToString();
Application.DoEvents();
AddStepStucture(mySteps, 0, xn);
if (MyContingencies.Count > 0) Console.WriteLine("{0} Contingencies not processed", MyContingencies.Count);
}
}
}
private static Dictionary<string, int> _MyContingencies = new Dictionary<string, int>();
public static Dictionary<string, int> MyContingencies
{
get { return frmConvertXML._MyContingencies; }
set { frmConvertXML._MyContingencies = value; }
}
private static void AddStepStucture(StepLookup mySteps, int level, XmlNode xn)
{
AddStepStucture(mySteps, level, xn, true);
}
private static void AddStepStucture(StepLookup mySteps, int level, XmlNode xn, bool addContent)
{
//if (mySteps.Count > 0 && mySteps[0].ToString().StartsWith("5"))
//ListMySteps("AddStepStructure", mySteps);
if (xn.Name != "JoinInstruction" && xn.Attributes["content"] != null && xn.Attributes["content"].Value != "")
{
//if (xn.Attributes["content"].InnerText.Contains("the time of this procedure entry"))
// Console.WriteLine("here");
if (level == -1 && xn.Name != "NoteInstruction" && xn.Name != "CautionInstruction")
level = 0;
if(addContent)
{
_LastStepText.Clear();
AddContent(null, mySteps, level, xn, false);
}
if (level != mySteps.Count && xn.ParentNode.Name == "Contingency")
level = mySteps.Count;
if (xn.Name == "UnitaryContingencyCallInstruction")
{
if (level == 1)
{
string key = xn.Attributes["number"].Value;
MyContingencies.Add((1 + MyContingencies.Count).ToString(), mySteps[mySteps.Count - 1].ItemID);
//ListMyContingencies(string.Format("Parent Count={0} number={1} linkTarget={2}", MyContingencies.Count, key, xn.Attributes["linkTarget"].Value));
}
}
}
string lastNodeName = "";
foreach (XmlNode xn1 in xn.ChildNodes)
{
// ChildNodes can contain XmlText as well as XmlElement nodes
if (xn1 is XmlElement)
{
//if (mySteps.Count > 0 && mySteps[0].Ordinal==5)
// ListMySteps(string.Format("AddStepStructure {0}",xn1.Name), mySteps);
if (xn1.Name == "BoolVarInputItem" || xn1.Name == "TextVarInputItem")
level = mySteps.Count - 1;
//else
if (lastNodeName != xn1.Name && xn1.ParentNode.Name != "Contingency")// RHM 20181018
RemoveStepsAbove(mySteps, level);
lastNodeName = xn1.Name;
if (xn1.Name == "JoinInstruction")
{
AddStepStucture(mySteps, level, xn1);
}
else if (xn1.Name == "UnitaryContingencyCallInstruction")
{
AddStepStucture(mySteps, level + 1, xn1);
string key = xn1.Attributes["number"].Value;
if (level != 0)
{
MyContingencies.Add((1 + MyContingencies.Count).ToString(), mySteps[level + 1].ItemID);
//ListMyContingencies(string.Format("Child count={0} number={1} linkTarget={2}", MyContingencies.Count, key, xn1.Attributes["linkTarget"].Value));
}
}
else if (xn1.Name == "taskGroup")
{
XmlNodeList xl = xn1.SelectNodes(".//x:ovationGraphic",_NSMGR);
if (xl.Count > 0)
{
//Add CPSData annotation for Display
StringBuilder sb = new StringBuilder();
sb.AppendFormat ("<CPSData>");
int i = 0;
foreach (XmlNode xnog in xl)
{
sb.AppendFormat("<display number='{0}'>", ++i);
sb.AppendFormat("<identifier>{0}</identifier>", GetAttribute(xnog, "diagramNumber"));
sb.AppendFormat("<description>{0}</description>", GetAttribute(xnog, "title"));
sb.AppendFormat("</display>");
}
sb.AppendLine("</CPSData>");
if (mySteps.Count > 0)
{
using (Item itm = mySteps[mySteps.Count - 1].Get())
Annotation.MakeAnnotation(itm, AnnotationType.GetByNameOrCreate("CPS Data"), null, sb.ToString(), sb.ToString());
}
}
if (xn1.Attributes["name"].Value != "") AddTaskGroup(mySteps, level + 1, xn1);
else AddStepStucture(mySteps, level, xn1);
}
else if (xn1.Name == "row")
{
AddStepStucture(mySteps, level, xn1);
}
else if (xn1.Name == "BoolVarInputItem")
{
AddBoolVar(mySteps, level, xn1);
}
else if (xn1.Name == "TextVarInputItem")
{
AddTextVar(mySteps, level+1, xn1);
}
else if (xn1.Name == "Contingency")
{
string key = xn1.Attributes["number"].Value;
//Console.WriteLine("Try to use contingency {0}", key);
if (_MyContingencies.Count > 0)
{
if (ContingencyStep != null)
Console.WriteLine("Not Processed");
ContingencyStep = StepInfo.Get(MyContingencies[key]);
if (ContingencyStep == null)
{
Console.WriteLine("Could not find contingency");
}
else
{
//Console.WriteLine("Contingency + {0}", ContingencyStep);
}
MyContingencies.Remove(key);
//ListMyContingencies(string.Format("Remove number {0}", key));
AddStepStucture(mySteps, Math.Min(level + 1, mySteps.Count), xn1);
}
else
{
Console.WriteLine("No Contingencies left");
}
}
else
{
if (xn1.Name == "NoteInstruction" || xn1.Name == "CautionInstruction")
{
StepLookup stack = CloneSteps(mySteps);
//if (mySteps.Count > 0 && mySteps[0].ToString().StartsWith("5"))
// ListMySteps("AddStepStructure Before ", mySteps);
mySteps[0] = mySteps[0];
AddStepStucture(mySteps, 1, xn1);
foreach (string key in stack.Keys)
mySteps[key] = stack[key];
//if (mySteps.Count > 0 && mySteps[0].ToString().StartsWith("5"))
// ListMySteps("AddStepStructure After", mySteps);
}
else
AddStepStucture(mySteps, Math.Min(level + 1, mySteps.Count), xn1);
}
}
}
//if (mySteps.Count > 0 && mySteps[0].ToString().StartsWith("5"))
// ListMySteps("AddStepStructure", mySteps);
}
private static StepLookup CloneSteps(StepLookup mySteps)
{
StepLookup sl = new StepLookup();
foreach (string key in mySteps.Keys)
sl.Add(key, mySteps[key]);
return sl;
}
private static void ListMyContingencies(string name)
{
Console.WriteLine("contingencies - {0}", name);
foreach (string key in MyContingencies.Keys)
Console.WriteLine("{0}\t{1}", key, MyContingencies[key]);
}
private static void AddBoolVar(StepLookup mySteps, int level, XmlNode xn1)
{
if(xn1.Attributes["varInputReadOnly"].Value == "false")
using (Step step = MakeCSLAStep(mySteps, level, null, xn1.Attributes["varInputLabel"].Value + " True __ / False __", 20011, E_FromType.Step)) { ;}
else
using (Step step = MakeCSLAStep(mySteps, level, null, xn1.Attributes["varInputLabel"].Value, 20011, E_FromType.Step)) { ;}
}
private static void AddTextVar(StepLookup mySteps, int level, XmlNode xn1)
{
using (Step step = MakeCSLAStep(mySteps, level, null, xn1.Attributes["varInputLabel"].Value +" ____________", 20011, E_FromType.Step)) { ;}
}
private static void AddTaskGroup(StepLookup mySteps, int level, XmlNode xn1)
{
if (level > mySteps.Count) level = mySteps.Count;
using (Step step = MakeCSLAStep(mySteps, level, null, xn1.Attributes["name"].Value, 20024, E_FromType.Step)) { ;}
AddStepStucture(mySteps, level, xn1);
}
private void AddAttachments(SectionInfo parentSection, XmlNodeList xl, XmlNamespaceManager nsmgr)
{
SectionInfo prevSection = null;
foreach (XmlNode xn in xl)
{
string config = null;
int type ;
if(HasContingency(xn))
{
type=10002;
}
else
{
type = 10008;
config ="<Config><Section ColumnMode=\"1\" /></Config>";
}
using (Section sect = Section.MakeSection(parentSection, prevSection, "Attachment " + xn.Attributes["number"].Value, xn.Attributes["name"].Value, type))
{
if(config != null)
{
sect.MyContent.Config = config;
sect.Save();
}
prevSection = SectionInfo.Get(sect.ItemID);
//AddStepChildren(nsmgr, prevSection, xn.ChildNodes);
//Console.WriteLine("{0} - {1}", prevSection.ShortPath, xn.OuterXml);
_MyTableFileName = parentSection.MyProcedure.DisplayNumber + "_"
+ parentSection.DisplayNumber + prevSection.DisplayNumber;
//if (GetSectionStyle(xn) == "Free Form")
AddPSEC(prevSection, xn.ChildNodes);
//else
// AddStep(prevSection, xn.ChildNodes);
_MyTableFileName = null;
}
}
}
private static string _MyTableFileName;
private void btnBrowse_Click(object sender, EventArgs e)
{
ofd.FileName = tbFile.Text;
if (ofd.ShowDialog() == DialogResult.OK)
tbFile.Text = ofd.FileName;
}
private void btnAll_Click(object sender, EventArgs e)
{
if (_MyFlexGrid == null)
{
_MyFlexGrid = new VlnFlexGrid();
this.Controls.Add(_MyFlexGrid);
_MyFlexGrid.Location = tbResults.Location;
_MyFlexGrid.Size = tbResults.Size;
_MyFlexGrid.BringToFront();
}
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
_ProcNum = GetProcedureNumber(chld.FullName);
XML2PROMSDB(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
lblStep.Text = "Step";
lblSection.Text = "Section";
lblProcedure.Text = "Procedure";
tbResults.AppendText("\r\n\r\n Done\r\n");
}
private void btnAllStructure_Click(object sender, EventArgs e)
{
tbResults.Clear();
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
LoadStructure(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.Clear();
ShowStructure2();
}
private void btnAllStructure2_Click(object sender, EventArgs e)
{
tbResults.Clear();
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
LoadStructure(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.Clear();
ShowStructure();
}
private void btnAllContent_Click(object sender, EventArgs e)
{
tbResults.Text = "";
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
FileInfo [] children = fi.Directory.GetFiles("*.xml");
pbProcs.Maximum = children.Count();
pbProcs.Value = 0;
foreach (FileInfo chld in children)
{
if (!chld.Name.StartsWith("._"))
{
tbResults.AppendText("\r\n" + chld.FullName);
GetAllContents(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
}
tbResults.AppendText("\r\nDone");
}
private void GetAllContents(string fileName)
{
FileInfo fi = new FileInfo(fileName);
FileInfo fo = new FileInfo(fi.DirectoryName + "\\" + GetProcedureNumber(fileName) + ".txt");
GetAllContents(fi, fo);
}
private void GetAllContents(FileInfo fi, FileInfo fo)
{
StreamWriter sw = fo.CreateText();
LoadXml(fi.FullName, "Document Loaded");
ShowAllContent(MyXMLDoc.DocumentElement, 0, sw);
sw.Close();
}
private void ShowAllContent(XmlElement xe, int level, StreamWriter sw)
{
ShowContent(xe, level, sw);
foreach (XmlNode ch in xe.ChildNodes)
{
if (ch is XmlElement)
ShowAllContent(ch as XmlElement, level + 1, sw);
}
}
private void ShowContent(XmlElement xe, int level, StreamWriter sw)
{
string format = "Not Defined";
string prefix = " ";
switch (xe.Name)
{
case "ident":
format = "Procedure (LabelType-number)={labelType}-{number} fullName={fullName} PNSNo={PNSNo}";
break;
case "type":
format = "Procedure Type: {procedureType}";
break;
case "GrossStep":
format = "number={number} name={name}";
break;
case "Step":
format = "{number} {name}";
prefix = "S ";
break;
case "Contingency":
format = "{number} {name}";
prefix = "C ";
break;
case "attrib":
case "procedure":
case "controllers":
case "row":
format = "";// No Content
break;
case "CautionInstruction":
case "NoteInstruction":
format = "number={number} {content}";
break;
case "UnitaryInstruction":
case "BinaryInstruction":
format = "number={number} Left Target: {leftTarget} Link Target: {linkTarget} {content}";
break;
case "JoinInstruction":
format = "Link Target: {linkTarget} JoinType: {joinType}";
break;
case "UnitaryContingencyCallInstruction":
format = "number={number} Link Target: {linkTarget} Evaluation Type: {evaluationType} {content}";
prefix = "U ";
break;
case "taskGroup":
format = "name={name} borderVisible={borderVisible}";
break;
case "BoolVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "TextVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "ovationGraphic":
format = "title={title} Diagram Number: {diagramNumber}";
break;
case "ovationGroupTrend":
format = "name={name} description={description}";
break;
case "controller":
format = "controller - Unknown";
break;
case "and":
format = "and id={id}";
break;
case "BigOverview":
format = "BigOverview grossStep={grossStep} number={number} id={id}";
break;
case "BovActionStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovCheckBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovIfStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} rightTarget={rightTarget} {content}";
break;
case "BovMessageBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovProcedureLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepInLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepOutLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "descr":
case "esinfo":
case "esproj":
case "esprop":
case "private":
case "pwg":
case "pwt":
case "revbase":
case "systemtest":
format = "";
break;
case "eq":
case "gt":
case "gte":
case "lt":
case "lte":
case "not":
case "or":
format = "id={id}";
break;
case "fcase":
case "tcase":
format = "rst={rst}";
break;
case "logic":
format = "id={id} number={number}";
break;
case "ovationSingleTrend":
format = "description={description} number={number} id={id} name={name}";
break;
case "prop":
format = "type={type} value={value} name={name}";
break;
case "TextVarInputInstruction":
format = "taskDescription={taskDescription} varInputLabel={varinputLabel} number={number} {content}";
break;
case "utest":
format = "tested={tested}";
break;
case "var":
format = "var_type={var_type} id={id} name={name} number={number}";
break;
case "const":
format = "var_type={var_type} id={id} value={value}";
break;
}
sw.Write(string.Format("\r\n{0}{1}{2} ", prefix, "".PadRight(level, ' ').Replace(" ", "| "), xe.Name));
sw.Write(ReplaceAllAttributes(format, xe, level, prefix));
}
private void btnHTML_Click(object sender, EventArgs e)
{
tbResults.Clear();
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
LoadStructure3(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.Clear();
ShowStructure();
}
private void LoadStructure3(string fileName)
{
LoadXml(fileName, null);
//Find Content Attributes
LoadStructure3(MyXMLDoc.DocumentElement);
}
private void LoadStructure3(XmlElement xe)
{
LoadStructure3Content(xe);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
LoadStructure3(xn as XmlElement);
}
}
private void LoadStructure3Content(XmlElement xn)
{
if (xn.Attributes["content"] != null)
{
string xml = cleanupHTML(xn.Attributes["content"].Value, 0);
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
if (!xml.Contains("<"))
{
Console.WriteLine("not XML '{0}'", xml);
xml = "<html><p>" + xml + "</p></html>";
}
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml);
//xml = xml.Replace("<html>", "<html xmlns='http://www.w3.org/2000/html'>");
//vlnhtml myHTML = HtmlSerializer<vlnhtml>.StringDeserialize(xml);
Node.Add(xd.DocumentElement);
}
}
private Dictionary<string, int> _DicHTMLStruct;
public Dictionary<string, int> DicHTMLStruct
{
get { return _DicHTMLStruct; }
set { _DicHTMLStruct = value; }
}
private void btnHTML2_Click(object sender, EventArgs e)
{
DicHTMLStruct = new Dictionary<string, int>();
tbResults.Clear();
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
LoadStructure4(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.Clear();
ShowHtmlStructure();
}
/// <summary>
/// Show Count for each structure
/// </summary>
private void ShowHtmlStructure()
{
tbResults.Text = "";
foreach (string key in DicHTMLStruct.Keys)
tbResults.AppendText(string.Format("{0}\t\"{1}\"\r\n", DicHTMLStruct[key], key));
}
private void LoadStructure4(string fileName)
{
LoadXml(fileName, null);
//Find Content Attributes
LoadStructure4(MyXMLDoc.DocumentElement);
}
private void LoadStructure4(XmlElement xe)
{
LoadStructure4Content(xe);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
LoadStructure4(xn as XmlElement);
}
}
private void LoadStructure4Content(XmlElement xn)
{
if (xn.Attributes["content"] != null)
{
string xml = cleanupHTML(xn.Attributes["content"].Value, 0);
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
if (!xml.Contains("<"))
{
//Console.WriteLine("not XML '{0}'", xml);
xml = "<html><p>" + xml + "</p></html>";
}
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml);
XmlAttribute xa = xd.CreateAttribute("type");
xa.Value = xn.Name;
xd.DocumentElement.Attributes.Append(xa);
if (xn.Attributes["number"] != null && xn.Attributes["number"].Value != string.Empty)
{
XmlAttribute xa1 = xd.CreateAttribute("number");
xa1.Value = xn.Attributes["number"].Value;
if (Regex.IsMatch(xa1.Value, "[0-9]+")) xa1.Value = "#";
xd.DocumentElement.Attributes.Append(xa1);
}
//AddStructure(GetStructurePath(xd.DocumentElement).Replace("[br]-T",""));
AddStructure(GetStructurePath(xd.DocumentElement,true));
}
}
private void AddStructure(string mystruct)
{
if (!DicHTMLStruct.ContainsKey(mystruct))
DicHTMLStruct.Add(mystruct, 1);
else
DicHTMLStruct[mystruct]++;
}
private string GetStructurePath(XmlElement xe, bool removeDuplicates)
{
StringBuilder sb = new StringBuilder();
sb.Append("[" + xe.Name);
if (xe.Name == "ul")
sb.Append(GetUlDetail(xe));
//if (xe.Name == "html")
//{
// sb.Append(" " + xe.Attributes["type"].Value);
// if (xe.Attributes["number"] != null && xe.Attributes["number"].Value != string.Empty)
// sb.Append(" " + xe.Attributes["number"].Value);
//}
if (xe.ChildNodes != null && xe.ChildNodes.Count > 0)
{
if (xe.Name != "table")
{
foreach (XmlNode xc in xe.ChildNodes)
{
if (xc is XmlElement)
sb.Append(GetStructurePath(xc as XmlElement, removeDuplicates));
else if (xc is XmlText)
{
//Console.WriteLine(xc.Value);
Match ma = Regex.Match(xc.Value, "^ *(and|or|AND|OR) *$");
Match mcn = Regex.Match(xc.Value, "^ *(CAUTION|NOTE|WARNING|CAUTIONS|NOTES|WARNINGS|NOTE CONTINUED) *$");
Match m1 = Regex.Match(xc.Value, "^[0-9]+[\\.\\)] ");
Match m2 = Regex.Match(xc.Value, "^[A-Z][\\.\\)] ");
Match m3 = Regex.Match(xc.Value, "^[a-z][\\.\\)] ");
Match m4 = Regex.Match(xc.Value, "^[-\u2022\u25AA\u25CF]");// Bullets and Dashes
Match m5 = Regex.Match(xc.Value, "^[^#0-9\\t*(A-Za-z \u00A0\"<>\u2264\\[\uD558\u00B7\u0025\u002F\uF07F\uFF1C\uFF1E\u02C2\u02C3\u203B\u2265\u2267\u2460\u2461\u25AA\u25B2\u25BC\u25CF] ");
if (mcn.Value != string.Empty)
sb.Append("-T " + mcn.Value);
else if (ma.Value != string.Empty)
sb.Append("-T " + ma.Value);
else if (m1.Value != string.Empty)
sb.Append("-T " + m1.Value.Trim());
else if (m2.Value != string.Empty)
sb.Append("-T " + m2.Value.Trim());
else if (m3.Value != string.Empty)
sb.Append("-T " + m3.Value.Trim());
else if (m4.Value != string.Empty)
sb.Append("-T {" + "Bullet " + ((int)(m4.Value[0])).ToString() + "}");
else if (m5.Value != string.Empty)
sb.Append("-T {{" + ((int)(m5.Value[0])).ToString() + "}}");
else sb.Append("-T");
}
}
}
//else
//Console.WriteLine("here");
}
sb.Append("]");
RemoveRepeats(sb.ToString(),removeDuplicates);
return sb.ToString();
}
private string GetUlDetail(XmlElement xe)
{
XmlAttribute xaType = xe.Attributes["type"];
XmlAttribute xaStyle = xe.Attributes["style"];
string type = string.Empty;
if (xaType != null)
type = " t" + xaType.Value;
string indent = string.Empty;
if (xaStyle != null)
indent = " i" + Regex.Replace(xaStyle.Value, "^.*-qt-list-indent: ([0-9]+).*$", "$1");
return type + indent;
}
RegexReplace[] MyRegExReplaces = {
new RegexReplace("\\[p-T\\]","[Para]"),
new RegexReplace("\\[p-T OR\\]","[OR]"),
new RegexReplace("\\[p-T AND\\]","[AND]"),
new RegexReplace("\\[p-T NOTE\\]","[NOTE]"),
new RegexReplace("\\[p-T CAUTION\\]","[CAUTION]"),
new RegexReplace("\\[p-T WARNING\\]","[WARNING]"),
new RegexReplace("\\[p-T [0-9]+\\.\\]","[Seq1.]"),
new RegexReplace("\\[p-T [0-9]+\\)\\]","[Seq1)]"),
new RegexReplace("\\[p-T [A-Z]\\.\\]","[SeqA.]"),
new RegexReplace("\\[p-T [a-z]\\.\\]","[Seqa.]"),
new RegexReplace("\\[li-T\\]","[Li]"),
new RegexReplace(" tsquare i1","1"),
new RegexReplace(" tsquare i2","2"),
new RegexReplace(" tsquare i3","3"),
new RegexReplace(" tsquare i4","4"),
new RegexReplace("(\\[p\\])+","")
};
RegexReplace[] MyRegExRepeats = {
new RegexReplace("(\\[Para\\])+","[Para]"),
new RegexReplace("(\\[OR\\])+","[OR]"),
new RegexReplace("(\\[AND\\])+","[AND]"),
new RegexReplace("(\\[NOTE\\])+","[NOTE]"),
new RegexReplace("(\\[CAUTION\\])+","[CAUTION]"),
new RegexReplace("(\\[WARNING\\])+","[WARNING]"), new RegexReplace("\\[p-T \\{\u2022\\}\\]","[Bullet]"),
new RegexReplace("(\\[Bullet\\])+","[Bullet]"),
new RegexReplace("(\\[Seq1\\.\\])+","[Seq1.]"),
new RegexReplace("(\\[Seq1\\)\\])+","[Seq1)]"),
new RegexReplace("(\\[SeqA\\.\\])+","[SeqA.]"),
new RegexReplace("(\\[Seqa\\.\\])+","[Seqa.]"),
new RegexReplace("(\\[Li\\])+","[Li]")
};
private string RemoveRepeats(string str, bool removeDuplicates)
{
foreach (RegexReplace rr in MyRegExReplaces)
str = rr.DoReplace(str);
if (removeDuplicates)
foreach (RegexReplace rr in MyRegExRepeats)
str = rr.DoReplace(str);
return str;
}
private void btnCandN_Click(object sender, EventArgs e)
{
LoadXml(tbFile.Text, "Document Loaded");
tbResults.Clear();
FindCandN(MyXMLDoc.DocumentElement);
}
private void FindCandN(XmlElement xe)
{
if ((xe.Name == "CautionInstruction" || xe.Name == "NoteInstruction")
&& (xe.ParentNode as XmlElement).Name == "Step" && AllSiblingsAreCautionsOrNotes(xe))
tbResults.AppendText(xe.Name
+ "\t" + (xe.ParentNode as XmlElement).Attributes["name"].Value
+ "\t" + (xe.ParentNode as XmlElement).Attributes["name"].Value
+ "\t" + (xe.ParentNode.ParentNode as XmlElement).Attributes["name"].Value
+ "\r\n");
foreach (XmlNode xc in xe.ChildNodes)
if (xc is XmlElement)
FindCandN(xc as XmlElement);
}
private bool AllSiblingsAreCautionsOrNotes(XmlElement xe)
{
XmlElement xep = xe.ParentNode as XmlElement;
if (xep == null) return false;
foreach (XmlNode xc in xep.ChildNodes)
if (xc.Name != "CautionInstruction" && xc.Name != "NoteInstruction")
return false;
return true;
}
private void btnHTLM3_Click(object sender, EventArgs e)
{
MessageBox.Show("Not Implemented", "NA", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
private void btnAllContent2_Click(object sender, EventArgs e)
{
tbResults.Text = "";
Node.Reset();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
tbResults.AppendText("\r\n" + chld.FullName);
GetAllContents2(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.AppendText("\r\nDone");
}
private void GetAllContents2(string fileName)
{
FileInfo fi = new FileInfo(fileName);
FileInfo fo = new FileInfo(fi.DirectoryName + "\\" + GetProcedureNumber(fileName) + ".txt");
GetAllContents2(fi, fo);
}
private void GetAllContents2(FileInfo fi, FileInfo fo)
{
StreamWriter sw = fo.CreateText();
LoadXml(fi.FullName, "Document Loaded");
ShowAllContent2(MyXMLDoc.DocumentElement, 0, sw);
sw.Close();
}
private void ShowAllContent2(XmlElement xe, int level, StreamWriter sw)
{
ShowContent2(xe, level, sw);
foreach (XmlNode ch in xe.ChildNodes)
{
if (ch is XmlElement)
ShowAllContent2(ch as XmlElement, level + 1, sw);
}
}
private void ShowContent2(XmlElement xe, int level, StreamWriter sw)
{
string format = "Not Defined";
string prefix = " ";
switch (xe.Name)
{
case "ident":
format = "Procedure (LabelType-number)={labelType}-{number} fullName={fullName} PNSNo={PNSNo}";
break;
case "type":
format = "Procedure Type: {procedureType}";
break;
case "GrossStep":
format = "number={number} name={name}";
break;
case "Step":
format = "{number} {name}";
prefix = "S ";
break;
case "Contingency":
format = "{number} {name}";
prefix = "C ";
break;
case "attrib":
case "procedure":
case "controllers":
case "row":
format = "";// No Content
break;
case "CautionInstruction":
case "NoteInstruction":
format = "number={number} {content}";
break;
case "UnitaryInstruction":
case "BinaryInstruction":
format = "number={number} Left Target: {leftTarget} Link Target: {linkTarget} {content}";
break;
case "JoinInstruction":
format = "Link Target: {linkTarget} JoinType: {joinType}";
break;
case "UnitaryContingencyCallInstruction":
format = "number={number} Link Target: {linkTarget} Evaluation Type: {evaluationType} {content}";
prefix = "U ";
break;
case "taskGroup":
format = "name={name} borderVisible={borderVisible}";
break;
case "BoolVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "TextVarInputItem":
format = "varInputLabel={varInputLabel} Data Point: {varInputDataPoint}";
break;
case "ovationGraphic":
format = "title={title} Diagram Number: {diagramNumber}";
break;
case "ovationGroupTrend":
format = "name={name} description={description}";
break;
case "controller":
format = "controller - Unknown";
break;
case "and":
format = "and id={id}";
break;
case "BigOverview":
format = "BigOverview grossStep={grossStep} number={number} id={id}";
break;
case "BovActionStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovCheckBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovIfStep":
format = "column={column} number={number} linkTarget={linkTarget} group={group} id={id} name={name} label={label} rightTarget={rightTarget} {content}";
break;
case "BovMessageBox":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovProcedureLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepInLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "BovStepOutLink":
format = "column={column} linkTarget={linkTarget} group={group} id={id} name={name} label={label} {content}";
break;
case "descr":
case "esinfo":
case "esproj":
case "esprop":
case "private":
case "pwg":
case "pwt":
case "revbase":
case "systemtest":
format = "";
break;
case "eq":
case "gt":
case "gte":
case "lt":
case "lte":
case "not":
case "or":
format = "id={id}";
break;
case "fcase":
case "tcase":
format = "rst={rst}";
break;
case "logic":
format = "id={id} number={number}";
break;
case "ovationSingleTrend":
format = "description={description} number={number} id={id} name={name}";
break;
case "prop":
format = "type={type} value={value} name={name}";
break;
case "TextVarInputInstruction":
format = "taskDescription={taskDescription} varInputLabel={varinputLabel} number={number} {content}";
break;
case "utest":
format = "tested={tested}";
break;
case "var":
format = "var_type={var_type} id={id} name={name} number={number}";
break;
case "const":
format = "var_type={var_type} id={id} value={value}";
break;
}
sw.Write(string.Format("\r\n{0}{1}{2} ", prefix, "".PadRight(level, ' ').Replace(" ", "| "), xe.Name));
sw.Write(ReplaceAllAttributes2(format, xe, level, prefix));
}
private string ReplaceAllAttributes2(string format, XmlElement xe, int level, string prefix)
{
MatchCollection m;
while ((m = regFixAttributes.Matches(format)).Count > 0)
{
string part1 = format.Substring(0, m[0].Groups[1].Index);
string part3 = format.Substring(m[0].Groups[1].Index + m[0].Groups[1].Length);
string att = m[0].Groups[1].Value.Replace("{", "").Replace("}", "");
XmlAttribute xa = xe.Attributes[att];
//if (xa == null)
// Console.WriteLine(xe.OuterXml);
string part2;
if (xa != null)
part2 = xe.Attributes[att].Value; //GetAttribute(xe, att);
else
part2 = "null";
if (part2 == string.Empty) part2 = "empty";
if (att == "content")
{
if (!part2.Contains("<"))
{
part2 = "<html><p>" + part2 + "</p></html>";
}
XmlDocument xd = new XmlDocument();
xd.LoadXml(cleanupHTML(part2,1));
part2 = GetStructurePath(xd.DocumentElement,false);
part2 = part2.Replace("\n", string.Format("\r\n {0} ", "".PadRight(level).Replace(" ", "| ")));
}
format = part1 + part2 + part3;
}
return format;
}
Dictionary<string, int> _VerbList;
private void btnVerbs_Click(object sender, EventArgs e)
{
_VerbList = new Dictionary<string, int>();
tbResults.Clear();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
FindVerbs(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
tbResults.Clear();
ShowVerbs();
}
private void ShowVerbs()
{
foreach (string key in _VerbList.Keys)
tbResults.AppendText(string.Format("{0}\t\"{1}\"\r\n",_VerbList[key], key));
}
private void FindVerbs(string fileName)
{
LoadXml(fileName, null);
//Find Content Attributes
FindVerbs(MyXMLDoc.DocumentElement);
}
private void FindVerbs(XmlElement xe)
{
FindVerbContent(xe);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
FindVerbs(xn as XmlElement);
}
}
Regex _regFindSpan = new Regex("<span style=\" font-weight:600;\">([A-Z]+)</span>", RegexOptions.Compiled);
private void FindVerbContent(XmlElement xn)
{
if (xn.Attributes["content"] != null)
{
string xml = xn.Attributes["content"].Value;
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
//if (xml.Contains("font-weight:600")) Console.WriteLine("here");
MatchCollection mc = _regFindSpan.Matches(xml);
if (mc.Count == 0) return;
foreach (Match m in mc)
if (_VerbList.ContainsKey(m.Groups[1].Value))
_VerbList[m.Groups[1].Value]++;
else
_VerbList.Add(m.Groups[1].Value,1);
}
}
private SortedDictionary<string, int> _DicFigureUsage;
private void btnFigures_Click(object sender, EventArgs e)
{
_DicFigureUsage = new SortedDictionary<string, int>();
tbResults.Clear();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
// Loop through XML Files
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
FindImages(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
ShowFigures();
}
private void ShowFigures()
{
tbResults.AppendText("\r\n\r\n**** MultipleOccurences ****\r\n\r\n");
foreach (string key in _DicFigureUsage.Keys)
if(_DicFigureUsage[key]>1)
tbResults.AppendText(string.Format("{0}\t{1}\r\n", _DicFigureUsage[key], key));
}
private void FindImages(string fileName)
{
LoadXml(fileName, null);
//Find Content Attributes
FindImages(MyXMLDoc.DocumentElement, GetProcedureNumber(fileName));
}
private void FindImages(XmlElement xe, string procname)
{
FindImageContent(xe, procname);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
FindImages(xn as XmlElement, procname);
}
}
//Regex _regFindImage = new Regex("<img src=([A-Z]+)</span>", RegexOptions.Compiled);
private void FindImageContent(XmlElement xn, string procname)
{
if (xn.Attributes["content"] != null)
{
string xml = cleanupHTML(xn.Attributes["content"].Value, 0);
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
if (!xml.Contains("<img")) return;
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml);
XmlNodeList xl = xd.SelectNodes("//img");
foreach (XmlNode xnn in xl)
{
Console.WriteLine("\"{0}\"\t\"{1}\"\t\"{2}\"", procname, xnn.Attributes["src"].Value,GetPath(xn));
string key = string.Format("\"{0}\"\t\"{1}\"", procname, GetPath(xn));
//if (_DicFigureUsage.ContainsKey(key))
// _DicFigureUsage[key]++;
//else
// _DicFigureUsage.Add(key, 1);
}
}
}
private static string GetPath(XmlNode xn)
{
switch (xn.Name)
{
case "GrossStep":
return xn.Attributes["number"].Value + " " + xn.Attributes["name"].Value;
case "Step":
return GetPath(xn.ParentNode) + ":Step " + xn.Attributes["number"].Value + " " + xn.Attributes["name"].Value + ":";
default:
{
string siblings = GetSiblings(xn);
return GetPath(xn.ParentNode) + ":" + xn.Name + (siblings == null? "" : "(" + siblings + ")" );
}
}
}
private static string GetSiblings(XmlNode xn)
{
SortedDictionary<string,string> siblings = new SortedDictionary<string,string>();
XmlNode xp = xn.PreviousSibling;
while (xp != null)
{
string key = xp.Name;
if (!siblings.ContainsKey(key))
siblings.Add(key, ShortVersion(key));
xp = xp.PreviousSibling;
}
XmlNode xx = xn.NextSibling;
while (xx != null)
{
string key = xx.Name;
if (!siblings.ContainsKey(key))
siblings.Add(key, ShortVersion(key));
xx = xx.NextSibling;
}
string results = "";
foreach (string ky in siblings.Keys)
results += siblings[ky];
if (results == "") return null;
return results;
}
private static string ShortVersion(string key)
{
switch (key)
{
case "NoteInstruction":
return "N";
case "CautionInstruction":
return "C";
case "Contingency":
return "*";
case "UnitaryInstruction":
return "U";
case "BinaryInstruction":
return "B";
case "JoinInstruction":
return "J";
case "UnitaryContingencyCallInstruction":
return "R";
default:
return string.Format("[{0}]", key);
}
}
private void btnTables_Click(object sender, EventArgs e)
{
//Loop through content containing table(s) under td.
tbResults.Clear();
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
// Loop through XML Files
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
FindTables(chld.FullName);
pbProcs.Value++;
Application.DoEvents();
}
ShowTables();
}
private void ShowTables()
{
//throw new NotImplementedException();
}
private void FindTables(string fileName)
{
LoadXml(fileName, null);
//Find Content Attributes
FindTables(MyXMLDoc.DocumentElement, GetProcedureNumber(fileName));
}
private void FindTables(XmlElement xe, string procNum)
{
FindTableContent(xe, procNum);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
FindTables(xn as XmlElement, procNum);
}
}
private void FindTableContent(XmlElement xn, string procNum)
{
if (xn.Attributes["content"] != null)
{
string xml = cleanupHTML(xn.Attributes["content"].Value, 0);
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
if (!xml.Contains("<table")) return;
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml.Replace("&","&amp;"));
XmlNodeList xl = xd.SelectNodes("//table");
foreach (XmlNode xnn in xl)
{
if(xnn.ParentNode.Name == "td")
Console.WriteLine("\"TWT\"\t\"{0}\"\t\"{1}\"\t\"{2}\"\t{3}\t{4}\t{5}\t{6}", procNum, GetPath(xn), GetPath2(xnn), xnn.Name,GetNext(xnn), GetPrevious(xnn), xnn.ParentNode.Name);
else
Console.WriteLine("\"TBL\"\t\"{0}\"\t\"{1}\"\t\"{2}\"\t{3}\t{4}\t{5}\t{6}", procNum, GetPath(xn), GetPath2(xnn), xnn.Name,GetNext(xnn), GetPrevious(xnn), xnn.ParentNode.Name);
}
}
}
private object GetPrevious(XmlNode xnn)
{
if (xnn.PreviousSibling != null) return xnn.PreviousSibling.Name;
return "No Previous";
}
private object GetNext(XmlNode xnn)
{
if (xnn.NextSibling != null) return xnn.NextSibling.Name;
return "No Next";
}
private static string GetPath2(XmlNode xn)
{
if (xn == null) return "";
else return GetPath2(xn.ParentNode) + ":" + xn.Name;
}
private void FindFigures(XmlElement xe, string procNum)
{
FindImageContent(xe, procNum);
foreach (XmlNode xn in xe.ChildNodes)
{
if (xn is XmlElement)
FindImages(xn as XmlElement, procNum);
}
}
private void FindFigureContent(XmlElement xn, string procname)
{
if (xn.Attributes["content"] != null)
{
string xml = cleanupHTML(xn.Attributes["content"].Value, 0);
if (xml == string.Empty) return;
if (xml.Replace(" ", "") == xn.Name) return;
if (!xml.Contains("<table")) return;
XmlDocument xd = new XmlDocument();
xd.LoadXml(xml);
XmlNodeList xl = xd.SelectNodes("//table");
foreach (XmlNode xnn in xl)
{
Console.WriteLine("\"{0}\"\t\"{1}\"\t\"{2}\"", procname, GetPath(xn),xnn.Name);
}
}
}
private void bntTable2_Click(object sender, EventArgs e)
{
VlnFlexGrid fg = new VlnFlexGrid();
StepRTB rtb = new StepRTB();
this.Controls.Add(fg);
fg.Location = tbResults.Location;
fg.Size = tbResults.Size;
fg.Rows.Count = 5;
fg.Cols.Count = 5;
fg.BringToFront();
;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
{
rtb.Text = string.Format("{0},{1}", i, j);
fg[i, j] = rtb.Rtf;
fg.MyBorders.HorizontalLines[i, j] = GridLinePattern.Single;
fg.MyBorders.VerticalLines[i, j] = GridLinePattern.Single;
}
CellRange cr = new CellRange();
cr.c1 = 0;
cr.c2 = 4;
cr.r1 = 0;
cr.r2 = 4;
fg.SetBorders(cr, GridLinePattern.Single, GridLinePattern.Single, GridLinePattern.Single, GridLinePattern.Single, GridLinePattern.Single, GridLinePattern.Single);
fg.Refresh();
Application.DoEvents();
Console.WriteLine(fg.GetXMLData());
XmlDocument xd = new XmlDocument();
using (StringReader sr = new StringReader(xmlSample1))
{
fg.ReadXml(sr);
sr.Close();
}
}
private static string _ProcNum;
private void btnStepOrNo_Click(object sender, EventArgs e)
{
// start by doing one then expand to all
tbResults.Clear();
tbResults.AppendText("\"ProcNum\"\t\"Section\"\t\"Title\"\t\"Step\"\t\"Text\"" +
"\t\"Tables\"\t\"Images\"\t\"Style\"\t\"LastStyle\"\t\"NextStyle\"\t\"Notes\"\t\"Cautions\"\t\"Warnings\"" +
"\t\"Contingency\"\t\"Binary\"\t\"Join\"\t\"Note\"\t\"Caution\"\t\"Unitary\"\r\n");
FileInfo fi = new FileInfo(tbFile.Text);
pbProcs.Maximum = fi.Directory.GetFiles("*.xml").Count();
pbProcs.Value = 0;
foreach (FileInfo chld in fi.Directory.GetFiles("*.xml"))
{
LoadXml(chld.FullName, null);
_ProcNum = GetProcedureNumber(chld.FullName);
StepOrNo(MyXMLDoc.DocumentElement);
pbProcs.Value++;
Application.DoEvents();
}
}
private string _LastSectNo = "";
private string _LastStyle="";
private void StepOrNo(XmlNode xn)
{
if (xn.Name == "GrossStep" || xn.Name =="procedure")
{
foreach (XmlNode xc in xn.ChildNodes)
StepOrNo(xc);
}
else if (xn.Name == "Step")
{
string sectNo = _ProcNum + xn.ParentNode.Attributes["number"].Value;
string style = GetSectionStyle(xn);
if (sectNo != _LastSectNo)
_LastStyle = "";
XmlNode nn = xn.NextSibling;
while (nn != null && nn.Name == "esinfo")
nn = nn.NextSibling;
string nextStyle = "";
if(nn != null)
nextStyle = GetSectionStyle(nn);
//if (xn.ParentNode.Attributes["number"].Value == "IV") Console.WriteLine("here");
tbResults.AppendText(string.Format("\"{0}\"\t\"{1}\"\t\"{2}\"\t\"{3}\"\t\"{4}\"" +
"\t\"{5}\"\t\"{6}\"\t\"{7}\"\t\"{8}\"\t\"{9}\"\t\"{10}\"\t\"{11}\"\t\"{12}\"" +
"\t\"{13}\"\t\"{14}\"\t\"{15}\"\t\"{16}\"\t\"{17}\"\t\"{18}\"\r\n", _ProcNum
, xn.ParentNode.Attributes["number"].Value, xn.ParentNode.Attributes["name"].Value
, xn.Attributes["number"].Value, xn.Attributes["name"].Value
,GetContainsTable(xn),GetContainsImage(xn),style,_LastStyle, nextStyle
,GetContains(xn,"NOTE"),GetContains(xn,"CAUTION"),GetContains(xn,"WARNING")
, GetContainsNode(xn, "Contingency"), GetContainsNode(xn, "BinaryI"), GetContainsNode(xn, "JoinI")
, GetContainsNode(xn, "NoteI"), GetContainsNode(xn, "CautionI"), GetContainsNode(xn, "UnitaryI")));
_LastStyle = style;
_LastSectNo = sectNo;
}
}
private string GetContainsNode(XmlNode xn, string lookfor)
{
if (xn.Name.StartsWith(lookfor)) return lookfor;
foreach (XmlNode xc in xn.ChildNodes)
if (GetContainsNode(xc, lookfor) != null) return lookfor;
return null;
}
private string GetContains(XmlNode xn, string typ)
{
string retval = "";
if (xn.InnerXml.Contains(typ)) retval = typ.ToLower();
foreach (XmlNode xc in xn.ChildNodes)
{
if (xc.Name == "NoteInstruction" || xc.Name == "CautionInstruction")
if (FirstTextIsType(xc, typ)) return typ;
else return retval;
}
return retval;
}
private static bool FirstTextIsType(XmlNode xn, string typ)
{
XmlAttribute xa = xn.Attributes["content"];
string xmlbase = xa.Value;
xmlbase = Regex.Replace(xmlbase, "<![^>]+>[\r\n]*", "");
xmlbase = Regex.Replace(xmlbase, " style=\"\" style=\"", " style=\"");
string pat = " style=\\\"([^\"]+)\\\" style=\\\"";
xmlbase = Regex.Replace(xmlbase, pat, " style=\"$1");
XmlDocument xd = new XmlDocument();
//TODO 20180913 0644 Not XML
if (!xmlbase.Contains("<")) return false;
xd.LoadXml(xmlbase);
return FirstTextIsType1(xd.DocumentElement, typ);
}
private static bool FirstTextIsType1(XmlNode xn, string typ)
{
foreach (XmlNode xc in xn.ChildNodes)
{
if (xc is XmlText)
{
if ((xc as XmlText).Value.Contains(typ))
return true;
return false;
}
if (xc.Name == "body" || xc.Name == "p" || xc.Name == "li" || xc.Name == "span")
return FirstTextIsType1(xc, typ);
}
return false;
}
private static string GetSectionStyle(XmlNode xn)
{
foreach (XmlNode xc in xn.ChildNodes)
if (xc.Name == "BinaryInstruction" || xc.Name == "Contingency " || xc.Name=="UnitaryContingencyCallInstruction" || countChildNodes(xc)>0)
if(xc.Name != "esinfo") return "Substeps";
bool hasFreeForm = false;
bool hasSpecificNotes = false;
bool hasUnitary = false;
foreach (XmlNode xc in xn.ChildNodes)
{
if (xc.Name == "NoteInstruction" || xc.Name == "CautionInstruction")
{
if (FirstTextIsType(xc, "NOTE") || FirstTextIsType(xc, "CAUTION") || FirstTextIsType(xc, "WARNING"))
{
hasSpecificNotes = true;
}
else
hasFreeForm = true;
}
if (xc.Name == "UnitaryInstruction")
hasUnitary = true;
}
if (hasFreeForm) return "Free Form";
if (hasUnitary) return "Step or Free Form";
return hasSpecificNotes ? "Specific Notes" : "Unknown";
}
private static int countChildNodes(XmlNode xn)
{
if (xn.ChildNodes.Count == 0) return 0;
int retval = 0;
foreach (XmlNode xc in xn.ChildNodes)
{
if (xc.Name.EndsWith("Instruction") || xc.Name =="Contingency") retval++;
retval += countChildNodes(xc);
}
//if (retval > 0 && xn.Name == "NoteInstruction") Console.WriteLine("here");
return retval;
}
private object GetContainsImage(XmlNode xn)
{
if (xn.InnerXml.Contains("&lt;img ")) return "Image";
return "";
}
private object GetContainsTable(XmlNode xn)
{
if (xn.InnerXml.Contains("&lt;table ")) return "Table";
return "";
}
}
public class RegexReplace
{
private string _Pattern;
public string Pattern
{
get { return _Pattern; }
set { _Pattern = value; }
}
private string _Replace;
public string Replace
{
get { return _Replace; }
set { _Replace = value; }
}
private Regex _RegEx;
public Regex RegEx
{
get
{
if (_RegEx == null)
_RegEx = new Regex(Pattern, RegexOptions.Compiled);
return _RegEx;
}
}
public RegexReplace(string pattern, string replace)
{
_Pattern = pattern;
_Replace = replace;
}
public string DoReplace(string str)
{
return RegEx.Replace(str, Replace);
}
}
public class StepLookup : SortedDictionary<string, StepInfo>
{
public StepInfo this[int i]
{
get
{
if (this.ContainsKey(i.ToString())) return base[i.ToString()];
return null;
}
set
{
if (i > this.Count)
throw new Exception("Gap in Stack");
if (value == null)
throw new Exception("Null StepInfo");
//if (value.MyHLS.Ordinal==5 && (value.IsNote || value.IsCaution ))
// Volian.Base.Library.vlnStackTrace.ShowStackLocal(2,5,"=====> Adding Caution or Note on Step 5 {0}",value);
if (this.ContainsKey(i.ToString()))
{
base[i.ToString()] = value;
while (this.ContainsKey((i + 1).ToString()))
base.Remove((base.Count - 1).ToString());
}
else base.Add(i.ToString(), value);
//ListMySteps("Set ", this);
}
}
public void AddOne(StepInfo previousStep)
{
this[this.Count] = previousStep;
}
private static void ListMySteps(string str, StepLookup mySteps)
{
int i = 0;
foreach (string key in mySteps.Keys)
{
if (key != i.ToString())
Console.WriteLine("{0} {1} {2} {3}", str, i, key, mySteps[key].DisplayText);
i++;
}
}
}
public class StepText
{
private string _OriginalText;
public string OriginalText
{
get { return _OriginalText; }
set { _OriginalText = value; }
}
private int _Indent=0;
public int Indent
{
get { return _Indent; }
set { _Indent = value; }
}
private string _Tab=string.Empty;
public string Tab
{
get { return _Tab; }
set { _Tab = value; }
}
private string _Text;
public string Text
{
get { return _Text; }
set { _Text = value; }
}
public StepText()
{
}
private static Regex reg_SplitText = new Regex(@"^(([\t ]*)([a-z1-9A-Z][0-9]*[\.\)](?= |[^S0-9])|\*|)( *))((?![0-9]+\.[0-9]+ )[0-9A-Za-z][^\r\n]*)");
private static Regex reg_SplitText1 = new Regex(@"([\t ]*)([1-9][0-9]*\.[0-9]+(?= *(Manually )?[A-Z]))( *)([^\r\n]+)");
public StepText(string str)
{
OriginalText = str;
//if (str.Contains("\\u9679?"))
// Console.WriteLine("here");
if (str.Trim().StartsWith("T.S."))
{
Tab = "";
Indent = str.Length - str.TrimStart().Length;
Text = str.Substring(Indent);
}
//if (str.Contains("3.1") || str.Contains("1.1") || str.Contains("Line up the valves for manual operation"))
// Console.WriteLine("here");
Match m = reg_SplitText.Match(str.Replace("\\u9679?", "*"));
if (m.Success)
{
Tab = m.Groups[3].Value;
Indent = m.Groups[2].Length + Tab.Length + m.Groups[4].Length;
Text = m.Groups[5].Value;
//if (Text.Contains("OR") || Text.Contains("AND"))
// Console.WriteLine("here");
}
else
{
m = reg_SplitText1.Match(str.Replace("\\u9679?", "*"));
if (m.Success)
{
Tab = m.Groups[1].Value;
Indent = m.Groups[1].Length + Tab.Length + m.Groups[4].Length;
Text = m.Groups[5].Value;
}
else
{
Tab = "";
Indent = str.Length - str.TrimStart().Length;
Text = str.Substring(Indent);
}
}
//if(Regex.IsMatch(Text,@"^[1-9a-zA-Z][.\)]"))
// Console.WriteLine(Text);
}
public override string ToString()
{
return string.Format("{0} {1} {2}",Indent,Tab,Text);
}
}
public class Node
{
private static SortedList<string, Node> _AllNodes = new SortedList<string, Node>();
public static SortedList<string, Node> AllNodes
{
get { return Node._AllNodes; }
set { Node._AllNodes = value; }
}
public static void Reset()
{
_AllNodes = new SortedList<string, Node>();
}
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
private List<string> _Children = new List<string>();
public List<string> Children
{
get { return _Children; }
set { _Children = value; }
}
private Attributes _Attributes = new Attributes();
public Attributes Attributes
{
get { return _Attributes; }
set { _Attributes = value; }
}
private bool _HasText = false;
public bool HasText
{
get { return _HasText; }
set { _HasText = value; }
}
public Node(XmlElement xe)
{
_AllNodes.Add(xe.Name, this);
}
public static void Add(XmlElement xe)
{
BuildList(xe);
}
private static void BuildList(XmlElement xe)
{
Node nd;
if (!_AllNodes.ContainsKey(xe.Name))
nd = new Node(xe);
else
nd = _AllNodes[xe.Name];
AdjustChildren(nd, xe.ChildNodes);
AdjustAttributes(nd, xe.Attributes);
foreach (XmlNode ch in xe.ChildNodes)
// ChildNodes can contain XmlText as well as XmlElement nodes
if (ch is XmlElement)
BuildList(ch as XmlElement);
}
private static void AdjustAttributes(Node nd, XmlAttributeCollection xmlAttributeCollection)
{
foreach (XmlAttribute xa in xmlAttributeCollection)
AdjustAttribute(nd, xa);
}
private static void AdjustAttribute(Node nd, XmlAttribute xa)
{
nd.Attributes.Add(xa);
}
private static void AdjustChildren(Node nd, XmlNodeList xmlNodeList)
{
foreach (XmlNode ne in xmlNodeList)
{
// XmlNodeList can contain XmlText as well as XmlElement nodes
if (ne is XmlElement)
{
if (!nd.Children.Contains((ne as XmlElement).Name))
nd.Children.Add((ne as XmlElement).Name);
}
else if (ne is XmlText)
nd.HasText = true;
else
Console.WriteLine("Not Expected {0}", ne.GetType().FullName);
}
}
}
public class Attributes : Dictionary<string, Attribute>
{
public void Add(XmlAttribute xa)
{
if (!this.ContainsKey(xa.Name))
base.Add(xa.Name, new Attribute(xa));
else
{
Attribute att = this[xa.Name];
att.Count++;
att.MinValue = string.Compare(att.MinValue, xa.Value) > 0 ? xa.Value : att.MinValue;
att.MaxValue = string.Compare(att.MinValue, xa.Value) < 0 ? xa.Value : att.MaxValue;
}
}
}
public class Attribute
{
public Attribute(XmlAttribute xa)
{
_Name = xa.Name;
_MinValue = xa.Value;
_MaxValue = xa.Value;
_Count = 1;
}
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
private string _MinValue;
public string MinValue
{
get { return _MinValue; }
set { _MinValue = value; }
}
private string _MaxValue;
public string MaxValue
{
get { return _MaxValue; }
set { _MaxValue = value; }
}
private int _Count = 0;
public int Count
{
get { return _Count; }
set { _Count = value; }
}
}
}
Reference in New Issue View Git Blame Copy Permalink