887 lines
31 KiB
C#
887 lines
31 KiB
C#
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.IO;
|
|
using System.Xml;
|
|
using System.Text.RegularExpressions;
|
|
using VEPROMS.CSLA.Library;
|
|
using log4net;
|
|
using Volian.Controls.Library;
|
|
using C1.Win.C1FlexGrid;
|
|
using System.Data.SqlClient;
|
|
|
|
namespace ConvertAlarms
|
|
{
|
|
public partial class frmConvertAlarms : Form
|
|
{
|
|
public frmConvertAlarms()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
private void SetDatabaseConnection()
|
|
{
|
|
Database.VEPROMS_Connection = string.Format("Data Source={0};Initial Catalog={1};Integrated Security=True", tbServer.Text, cmbDatabase.SelectedText);
|
|
}
|
|
private void btnBrowse_Click(object sender, EventArgs e)
|
|
{
|
|
FileInfo fi = new FileInfo(tbFileName.Text);
|
|
ofd.InitialDirectory = fi.DirectoryName;
|
|
ofd.FileName = fi.Name;
|
|
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
|
|
{
|
|
tbFileName.Text = ofd.FileName;
|
|
ProcessXML();
|
|
}
|
|
}
|
|
private void ProcessXML()
|
|
{
|
|
string fileName = tbFileName.Text;
|
|
ProcessXmlFile(fileName);
|
|
}
|
|
private void ProcessXmlFile(string fileName)
|
|
{
|
|
UpdateHTML = false;
|
|
tbXML.Clear();
|
|
UpdateHTML = true;
|
|
XmlDocument xDoc = new XmlDocument();
|
|
xDoc.Load(fileName);
|
|
XmlElement xe1 = xDoc.DocumentElement;
|
|
XmlElement xe2 = xe1.ChildNodes[0] as XmlElement;
|
|
XmlElement xe3 = xe2.ChildNodes[0] as XmlElement;
|
|
XmlElement xe4 = (xe1.ChildNodes[1] as XmlElement).ChildNodes[0] as XmlElement;
|
|
RelatedFunction = xe3.Attributes["relatedFunction"].Value;
|
|
PNSNo = xe3.Attributes["PNSNo"].Value;
|
|
ShortName = xe3.Attributes["shortName"].Value;
|
|
FullName = xe3.Attributes["fullName"].Value;
|
|
RevisionNumber = xe3.Attributes["revisionNumber"].Value;
|
|
Priority = xe3.Attributes["priority"].Value;
|
|
Number = xe3.Attributes["number"].Value;
|
|
Responsibility = xe4.Attributes["implementor"].Value;
|
|
ApSystem = GetSystem(xe3);
|
|
XmlNode xn = xDoc.DocumentElement.LastChild.LastChild.LastChild;
|
|
string html = GetHtml(xn);
|
|
tbXML.Text = html;
|
|
}
|
|
private static string _RelatedFunction;
|
|
public static string RelatedFunction
|
|
{
|
|
get { return _RelatedFunction; }
|
|
set { _RelatedFunction = value; }
|
|
}
|
|
private static string _PNSNo;
|
|
public static string PNSNo
|
|
{
|
|
get { return _PNSNo; }
|
|
set { _PNSNo = value; }
|
|
}
|
|
private static string _fullName;
|
|
public static string FullName
|
|
{
|
|
get { return _fullName; }
|
|
set { _fullName = value; }
|
|
}
|
|
private static string _Number;
|
|
public static string Number
|
|
{
|
|
get { return frmConvertAlarms._Number; }
|
|
set { frmConvertAlarms._Number = value; }
|
|
}
|
|
private static string _RevisionNumber;
|
|
public static string RevisionNumber
|
|
{
|
|
get { return frmConvertAlarms._RevisionNumber; }
|
|
set { frmConvertAlarms._RevisionNumber = value; }
|
|
}
|
|
private static string _Priority;
|
|
public static string Priority
|
|
{
|
|
get { return frmConvertAlarms._Priority; }
|
|
set { frmConvertAlarms._Priority = value; }
|
|
}
|
|
private static string Responsibility;
|
|
public static string Responsibility1
|
|
{
|
|
get { return frmConvertAlarms.Responsibility; }
|
|
set { frmConvertAlarms.Responsibility = value; }
|
|
}
|
|
private static string _shortName;
|
|
public static string ShortName
|
|
{
|
|
get { return _shortName; }
|
|
set { _shortName = value; }
|
|
}
|
|
private static string _system;
|
|
public static string ApSystem
|
|
{
|
|
get { return _system; }
|
|
set { _system = value; }
|
|
}
|
|
private static string _MyFileName;
|
|
|
|
public static string MyFileName
|
|
{
|
|
get { return frmConvertAlarms._MyFileName; }
|
|
set { frmConvertAlarms._MyFileName = value; }
|
|
}
|
|
private static string GetHtml(XmlNode xn)
|
|
{
|
|
XmlNode pr = xn.PreviousSibling;
|
|
int i = 0;
|
|
string html = xn.Attributes["content"].Value;
|
|
//Console.WriteLine(@"{0} ""{1}""", i++, html);
|
|
if (xn != pr)
|
|
{
|
|
while (pr != null && pr.Name == "NoteInstruction")
|
|
{
|
|
string html2 = pr.Attributes["content"].Value;
|
|
//Console.WriteLine(@"{0} ""{1}""", i++, html2);
|
|
html = MergeHTML(html2, html);
|
|
//Console.WriteLine(@"{0} ""{1}""", -1, html);
|
|
pr = pr.PreviousSibling;
|
|
}
|
|
}
|
|
return html;
|
|
}
|
|
|
|
private static string MergeHTML(string part1, string part2)
|
|
{
|
|
part1 = part1.Replace("</body></html", "");
|
|
part2 = Regex.Replace(part2, "^.*<body[^<>]*>", "", RegexOptions.Singleline);
|
|
//part2 = part2.Substring(part2.IndexOf("<p"));
|
|
return part1 + part2;
|
|
}
|
|
private void htmlChanged(string html)
|
|
{
|
|
byte[] bytes = Encoding.UTF8.GetBytes(html.Replace("\u2022", "•"));
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.Write(bytes, 0, bytes.Length);
|
|
ms.Position = 0;
|
|
wb.DocumentStream = ms;
|
|
}
|
|
private string _HtmlPrefix = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">";
|
|
public string HtmlPrefix
|
|
{
|
|
get { return _HtmlPrefix; }
|
|
set { _HtmlPrefix = value; }
|
|
}
|
|
private string prcSerialNoFldName;
|
|
private string prcSerialNoValue;
|
|
private string prcTitleFldName;
|
|
private string prcTitleValue;
|
|
private string prcNumberFldName;
|
|
private string prcNumberValue;
|
|
private string prcSourceFldName;
|
|
private string prcSourceValue;
|
|
private string prcSetpointFldName;
|
|
private string prcSetpointValue;
|
|
|
|
//private Regex myReg01 = new Regex("<br /></span>", RegexOptions.Compiled);
|
|
//private Regex myReg02 = new Regex("</span><br />", RegexOptions.Compiled);
|
|
//private Regex myReg03 = new Regex("<span [^<>]+>", RegexOptions.Compiled);
|
|
//private Regex myReg04 = new Regex("</span *>", RegexOptions.Compiled);
|
|
//private Regex myReg05 = new Regex("</p>[ \r\n]+<p [^<>]+>", RegexOptions.Compiled);
|
|
//private Regex myReg06 = new Regex("<p [^<>]+>", RegexOptions.Compiled);
|
|
////private Regex myReg07 = new Regex(@"<br /> +(?=\w)", RegexOptions.Compiled);
|
|
//private Regex myReg08 = new Regex(@"<br />[ \r\n]*\t +", RegexOptions.Compiled);
|
|
//private Regex myReg09 = new Regex(@"<br />[ \t\r\n]+\[", RegexOptions.Compiled);
|
|
//private Regex myReg10 = new Regex("</p *>", RegexOptions.Compiled);
|
|
//private Regex myReg11 = new Regex(@"] *\t{4,10}", RegexOptions.Compiled);
|
|
//private Regex myReg12 = new Regex("<br ?/>\t+(?=None)", RegexOptions.Compiled);
|
|
//private Regex myReg13 = new Regex("<br ?/>\t+(?![[\\u2022]|[1-9])", RegexOptions.Compiled);
|
|
//private Regex myReg14 = new Regex("<br />", RegexOptions.Compiled);
|
|
//private Regex myReg15 = new Regex("\t\t+", RegexOptions.Compiled);
|
|
//private Regex myReg16 = new Regex("\r\n +", RegexOptions.Compiled);
|
|
//private Regex myReg17 = new Regex("(\r\n){2,}", RegexOptions.Compiled);
|
|
//private Regex myReg18 = new Regex("<table [^<>]+>", RegexOptions.Compiled);
|
|
////private Regex myReg19 = new Regex("(?<!\\\\line )\r\n\t(?!([[\\u2022]|None|[1-9]))", RegexOptions.Compiled);
|
|
//private Regex myReg20 = new Regex("(?<!\\\\line )\r\n\t(?!([[\\u2022]|None|[1-9]))", RegexOptions.Compiled);
|
|
//private Regex myReg21 = new Regex("<table>[^<>]*<tr[^<>]*>[^<>]*<td[^<>]*>[^<>]*<p>(NOTE|CAUTION|WARNING)([^<>]+?)</p>[^<>]*</td>[^<>]*</tr>[^<>]*</table>", RegexOptions.Compiled & RegexOptions.Singleline );
|
|
//private Regex myReg22 = new Regex("\\.\\.\\.+", RegexOptions.Compiled);
|
|
private void XMLChanged(string xml)
|
|
{
|
|
Application.DoEvents();
|
|
xml = "<?xml version='1.0' encoding='UTF-8'?>\n" + xml;
|
|
xml = xml.Replace(HtmlPrefix, "");
|
|
//xml = myReg01.Replace(xml, "<br /> </span>");
|
|
//xml = myReg02.Replace(xml, "</span><br /> ");
|
|
//xml = myReg03.Replace(xml, "");// Remove Style Span start
|
|
//xml = myReg04.Replace(xml, "");//
|
|
//xml = myReg05.Replace(xml, "<br />\r\n");
|
|
//xml = myReg06.Replace(xml, "<br />\r\n<p>");
|
|
////xml = myReg07.Replace(xml, " ");//New
|
|
//xml = myReg08.Replace(xml, " ");//New
|
|
//xml = myReg09.Replace(xml, @"\line [");
|
|
//xml = myReg10.Replace(xml, "</p>");
|
|
//xml = myReg11.Replace(xml, "]\r\n");
|
|
//xml = myReg12.Replace(xml, "\r\n\t");
|
|
//xml = myReg13.Replace(xml, " ");
|
|
//xml = myReg14.Replace(xml, "\r\n");
|
|
//xml = myReg15.Replace(xml, " ");
|
|
//xml = myReg16.Replace(xml, "\r\n");
|
|
//xml = myReg17.Replace(xml, "\r\n");
|
|
//xml = myReg18.Replace(xml, "<table>");
|
|
////xml = myReg19.Replace(xml, "{SPACE}");
|
|
//xml = myReg20.Replace(xml, " ");
|
|
//xml = myReg21.Replace(xml, "<p>\r\n$1$2\r\n</p>");
|
|
//xml = myReg22.Replace(xml, ""); //Remove multiple periods
|
|
xml = Regex.Replace(xml, "<br /></span>", "<br /> </span>");
|
|
xml = Regex.Replace(xml, "</span><br />", "</span><br /> ");
|
|
xml = Regex.Replace(xml, "<span [^<>]+>", "");// Remove Style Span start
|
|
xml = Regex.Replace(xml, "</span *>", "");//
|
|
xml = Regex.Replace(xml, "</p>[ \r\n]+<p [^<>]+>", "<br />\r\n");
|
|
xml = Regex.Replace(xml, "<p [^<>]+>", "<br />\r\n<p>");
|
|
// xml = Regex.Replace(xml, @"<br /> +(?=\w)", " ");//New
|
|
xml = Regex.Replace(xml, @"<br />[ \r\n]*\t (?! +[[\\u2022]| +[1-9]| +[A-Z][.])", " ");//New
|
|
//xml = Regex.Replace(xml, @"<br />[ \r\n]*\t +", " ");//New
|
|
xml = Regex.Replace(xml, @"<br />[ \t\r\n]+\[", @"\line [");
|
|
xml = Regex.Replace(xml, "</p *>", "</p>");
|
|
xml = Regex.Replace(xml, @"] *\t{4,10}", "]\r\n");
|
|
xml = Regex.Replace(xml, "<br ?/>\t+(?=None)", "\r\n\t");
|
|
xml = Regex.Replace(xml, "<br ?/>\t+(?![[\\u2022]|[1-9]|[A-Z]\\.)", " ");
|
|
xml = Regex.Replace(xml, "<br />", "\r\n");
|
|
xml = Regex.Replace(xml, "\t\t+", " ");
|
|
xml = Regex.Replace(xml, "\r\n +", "\r\n");
|
|
xml = Regex.Replace(xml, "(\r\n){2,}", "\r\n");
|
|
xml = Regex.Replace(xml, "<table [^<>]+>", "<table>");
|
|
//xml = Regex.Replace(xml, "(?<!\\\\line )\r\n\t(?!([[\\u2022]|None|[1-9]))", "{SPACE}");
|
|
xml = Regex.Replace(xml, "(?<!\\\\line )\r\n\t(?!([[\\u2022]|None|[1-9]))", " ");
|
|
xml = Regex.Replace(xml, "<table>[^<>]*<tr[^<>]*>[^<>]*<td[^<>]*>[^<>]*<p>(NOTE|CAUTION|WARNING)([^<>]+?)</p>[^<>]*</td>[^<>]*</tr>[^<>]*</table>", "<p$1>\r\n$1$2\r\n</p$1>", RegexOptions.Singleline);
|
|
xml = Regex.Replace(xml, "\\.\\.\\.+", ""); //Remove multiple periods
|
|
//xml = Regex.Replace(xml,"
|
|
//xml = xml.Replace(">", "");
|
|
Application.DoEvents();
|
|
byte[] bytes = Encoding.UTF8.GetBytes(xml);
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.Write(bytes, 0, bytes.Length);
|
|
ms.Position = 0;
|
|
XmlDocument xDoc2 = new XmlDocument();
|
|
xDoc2.Load(ms);
|
|
int iStart = 1;
|
|
XmlNode xn3 = xDoc2.ChildNodes[1].ChildNodes[1].ChildNodes[0];
|
|
if (!xn3.OuterXml.Contains("table"))
|
|
{
|
|
iStart = 2;
|
|
xn3 = xDoc2.ChildNodes[1].ChildNodes[1].ChildNodes[1];
|
|
}
|
|
prcSerialNoFldName = GetProcInfo(xn3, 0, 0, 0);
|
|
prcSerialNoValue = GetProcInfo(xn3, 0, 1, 0);
|
|
SerialNo = int.Parse(prcSerialNoValue);
|
|
prcTitleFldName = GetProcInfo(xn3, 1, 0, 0);
|
|
prcTitleValue = GetProcInfo(xn3, 1, 1, 0);
|
|
prcNumberFldName = GetProcInfo(xn3, 2, 0, 0);
|
|
prcNumberValue = GetProcInfo(xn3, 2, 1, 0);
|
|
prcSourceFldName = GetProcInfo(xn3, 3, 0, 0);
|
|
prcSourceValue = GetProcInfo(xn3, 3, 1, 0);
|
|
prcSetpointFldName = GetProcInfo(xn3, 4, 0, 0);
|
|
prcSetpointValue = GetProcInfo(xn3, 4, 1, 0);
|
|
Console.WriteLine("\"FromProcedures\"\t\"{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}\""
|
|
, PNSNo.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, ApSystem.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, FullName.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, ShortName.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, RelatedFunction.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, "Rev" + RevisionNumber.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, Priority.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, Number.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, prcNumberValue.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, prcSerialNoValue.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, prcSetpointValue.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, prcSourceValue.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, prcTitleValue.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, Responsibility.Replace("\r\n", ";CR;").Replace("\n", ";CR;").Replace("\r", ";CR;")
|
|
, MyFileName);
|
|
ProcNumber = prcNumberValue;
|
|
ProcTitle = prcTitleValue;
|
|
// Skip First Node
|
|
UpdateHTML = false;
|
|
tbPROMS.Clear();
|
|
tbPROMS.AppendText(string.Format("{0} = '{1}'\r\n", prcSerialNoFldName, prcSerialNoValue));
|
|
tbPROMS.AppendText(string.Format("{0} = '{1}'\r\n", prcTitleFldName, prcTitleValue));
|
|
tbPROMS.AppendText(string.Format("{0} = '{1}'\r\n", prcNumberFldName, prcNumberValue));
|
|
tbPROMS.AppendText(string.Format("{0} = '{1}'\r\n", prcSourceFldName, prcSourceValue));
|
|
tbPROMS.AppendText(string.Format("{0} = '{1}'\r\n", prcSetpointFldName, prcSetpointValue));
|
|
StringBuilder sbAllText = new StringBuilder();
|
|
for (int i = iStart; i < xDoc2.ChildNodes[1].ChildNodes[1].ChildNodes.Count; i++)
|
|
{
|
|
XmlNode xn2 = xDoc2.ChildNodes[1].ChildNodes[1].ChildNodes[i];
|
|
if (xn2.OuterXml != ">\r\n" && xn2.OuterXml != "<p></p>")
|
|
{
|
|
sbAllText.Append("\r\n" + xn2.OuterXml);
|
|
//Console.WriteLine("--{0}--|{1}|", i, IndentifySpecialCharacters(xn2.OuterXml));
|
|
}
|
|
}
|
|
tbPROMS.AppendText(sbAllText.ToString().Replace(" ", "\xB7"));
|
|
//SaveTree(sbAllText.ToString(), prcNumberValue, prcTitleValue);
|
|
ProcTextAll = sbAllText.ToString();
|
|
UpdateHTML = true;
|
|
}
|
|
String ProcTextAll;
|
|
int SerialNo;
|
|
String ProcNumber;
|
|
String ProcTitle;
|
|
TreeNode lastNode = null;
|
|
private void SaveTree(string text, string procNumber, string procTitle)
|
|
{
|
|
tv.Nodes.Clear();
|
|
MemoryStream ms = GetMemoryStream(text);
|
|
using (TextReader tr = new StreamReader(ms))
|
|
{
|
|
Dictionary<int, TreeNode> lookup = new Dictionary<int, TreeNode>();
|
|
lookup.Add(0, tv.Nodes.Add(string.Format("{0} - {1}", procNumber, procTitle)));
|
|
int level = 0;
|
|
int lastLevel = 0;
|
|
int lastIndent = 0;
|
|
int extra = 0;
|
|
bool textContinued = false;
|
|
string lastTab = "";
|
|
Queue<string> enQueue = null;
|
|
Queue<string> deQueue = null;
|
|
bool isTable = false;
|
|
while (tr.Peek() >= 0 || deQueue != null)
|
|
{
|
|
string lineText;
|
|
if (deQueue != null)
|
|
{
|
|
extra = 1;
|
|
lineText = deQueue.Dequeue();
|
|
if (deQueue.Count == 0)
|
|
deQueue = null;
|
|
}
|
|
else
|
|
{
|
|
extra = 0;
|
|
lineText = tr.ReadLine();
|
|
if (lineText.StartsWith("<table>"))
|
|
{
|
|
while (!lineText.Contains("</table>"))
|
|
{
|
|
lineText += " " + tr.ReadLine();
|
|
lineText = Regex.Replace(lineText, "</table>.*", "</table>");
|
|
}
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.LoadXml(lineText);
|
|
LoadTable2(xd.DocumentElement, null, 0);
|
|
isTable = true;
|
|
//StringBuilder sbxml= new StringBuilder();
|
|
//using(StringWriter sw = new StringWriter(sbxml))
|
|
// _MyFlexGrid.WriteXml(sw);
|
|
//using(StringReader sr= new StringReader(sbxml.ToString()))
|
|
// _MyFlexGrid.ReadXml(sr);
|
|
//Application.DoEvents();
|
|
}
|
|
else if (lineText == "NOTE" || lineText == "CAUTION" || lineText == "Warning")
|
|
enQueue = new Queue<string>();
|
|
}
|
|
lineText = Regex.Replace(lineText, "<[^<>]+>", "");
|
|
textContinued = false;
|
|
if (lineText.Replace("\t", "") != "")
|
|
{
|
|
Match m = Regex.Match(lineText, @"^(\t*)([1-9][0-9]*\.0|[1-9][0-9]*\.[1-9][0-9]*|\u2022|\u25CB)([\t ]+)([^\u2022]*)$", RegexOptions.Multiline);
|
|
string tab = m.Groups[2].Value;
|
|
int indent = m.Groups[1].Value.Length;
|
|
//if (lineText.Contains("THEN·GO·TO·1N2-OP-EOP-XX-0002"))
|
|
// Console.WriteLine("here");
|
|
if (isTable)
|
|
{
|
|
// do nothing
|
|
}
|
|
if (indent == 0 && tab.EndsWith(".0")) // High Level Step
|
|
{
|
|
level = 1;
|
|
if (deQueue == null && enQueue != null)
|
|
{
|
|
deQueue = enQueue;
|
|
enQueue = null;
|
|
}
|
|
}
|
|
else if (Regex.IsMatch(tab, "[1-9][0-9]*[.0-9]*")) // Substep
|
|
{
|
|
level = 2;
|
|
if (deQueue == null && enQueue != null)
|
|
{
|
|
deQueue = enQueue;
|
|
enQueue = null;
|
|
}
|
|
}
|
|
else if (tab == "") // Paragraph
|
|
{
|
|
if (Regex.IsMatch(lineText, "(NOTE|NOTES|CAUTION|CAUTIONS|WARNING|WARNINGS)"))
|
|
extra = 0;
|
|
else
|
|
{
|
|
lastNode.Text += " " + lineText.TrimStart("\r\n \t".ToCharArray());
|
|
//Console.WriteLine("maybe continue '{0}'", lineText);
|
|
textContinued = true;
|
|
}
|
|
level = lastLevel + 1;
|
|
}
|
|
else if (tab == "\u2022")//bullet
|
|
level = indent + 2;
|
|
else if (tab == "\u25CB")//bullet
|
|
level = indent + 3;
|
|
if (level < lastLevel)
|
|
while (level < lastLevel) lookup.Remove(lastLevel--);
|
|
string txt = string.Format("{0}|{1}||{2}", m.Groups[1].Value, m.Groups[2].Value, m.Groups[4].Value);
|
|
if (txt == "|||") txt = lineText;
|
|
if (enQueue == null)
|
|
{
|
|
if (!textContinued && !isTable)
|
|
{
|
|
if (level > lookup.Count - extra) extra = 0;
|
|
//if (level + extra - 1 == lookup.Count)
|
|
// Console.WriteLine("Problems {0}, {1}", procNumber, txt);
|
|
else if (lookup.Count <= level)
|
|
lookup.Add(level + extra, lookup[level + extra - 1].Nodes.Add(txt));
|
|
else
|
|
lookup[level + extra] = lookup[level + extra - 1].Nodes.Add(txt);
|
|
lastNode = lookup[level + extra];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
enQueue.Enqueue(lineText);
|
|
}
|
|
lastTab = tab;
|
|
lastLevel = level;
|
|
lastIndent = indent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private ItemInfo FindPrevious(SortedDictionary<int, ItemInfo> dicSerialNo, int serialNo)
|
|
{
|
|
ItemInfo lastItem = null;
|
|
foreach (int serno in dicSerialNo.Keys)
|
|
{
|
|
if (serno > serialNo)
|
|
return lastItem;
|
|
lastItem = dicSerialNo[serno];
|
|
}
|
|
return lastItem;
|
|
}
|
|
private bool runOne = true;
|
|
private static MemoryStream GetMemoryStream(string text)
|
|
{
|
|
byte[] bytes = Encoding.UTF8.GetBytes(text);
|
|
MemoryStream ms = new MemoryStream(bytes);
|
|
ms.Position = 0;
|
|
return ms;
|
|
}
|
|
private string GetProcInfo(XmlNode xn3, int p1, int p2, int p3)
|
|
{
|
|
if (xn3.OuterXml == "<p></p>") xn3 = xn3.NextSibling;
|
|
return xn3.ChildNodes[p1].ChildNodes[p2].ChildNodes[p3].ChildNodes[0].Value.Trim("\r\n ".ToCharArray());
|
|
}
|
|
private bool _UpdateHTML = true;
|
|
public bool UpdateHTML
|
|
{
|
|
get { return _UpdateHTML; }
|
|
set { _UpdateHTML = value; }
|
|
}
|
|
private string IndentifySpecialCharacters(string xml)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string txt = Regex.Replace(xml, "<span[^<>]+>", "");
|
|
foreach (char c in txt)
|
|
{
|
|
if (((int)c) < 32 || ((int)c) > 256)
|
|
sb.Append(string.Format("[x{0:X4}]", (int)c));
|
|
else
|
|
sb.Append(c == ' ' ? '\xb7' : c);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
private void btnRun_Click(object sender, EventArgs e)
|
|
{
|
|
ProcessXML();
|
|
}
|
|
Regex regColorCode = new Regex(@"(\<[^<>]+\>)([^<>]*)", RegexOptions.Singleline);
|
|
Regex regColorCodeText = new Regex("(\t*)([^\t]*)", RegexOptions.Singleline);
|
|
private void ColorCoded(string str)
|
|
{
|
|
rtbXML.Clear();
|
|
Color fColor = Color.PaleTurquoise;
|
|
Color fNext = Color.PaleTurquoise;
|
|
foreach (Match m in regColorCode.Matches(str))
|
|
{
|
|
string fmt = m.Groups[1].Value;
|
|
string txt = m.Groups[2].Value;
|
|
if (fmt.StartsWith("<table"))
|
|
fNext = fColor = Color.PaleGreen;
|
|
else if (fmt == "</table>")
|
|
fNext = Color.PaleTurquoise;
|
|
else if (fmt == "<br />")
|
|
fColor = Color.PeachPuff;
|
|
else if (fmt == "</p>")
|
|
fColor = Color.LightPink;
|
|
AddToXML(fmt, fColor);
|
|
fColor = fNext;
|
|
foreach (Match mm in regColorCodeText.Matches(txt))
|
|
{
|
|
string tabs = mm.Groups[1].Value;
|
|
string nontabs = mm.Groups[2].Value;
|
|
AddToXML(tabs, Color.Khaki);
|
|
AddToXML(nontabs, Color.Yellow);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddToXML(string txt, Color fColor)
|
|
{
|
|
if (txt == "") return;
|
|
rtbXML.SelectionStart = rtbXML.TextLength;
|
|
rtbXML.SelectionBackColor = fColor;
|
|
rtbXML.SelectedText = txt;
|
|
}
|
|
private void frmConvertAlarms_Load(object sender, EventArgs e)
|
|
{
|
|
LoadSettings();
|
|
SetEventHandlers();
|
|
_MyFlexGrid = new VlnFlexGrid();
|
|
tpGrid.Controls.Add(_MyFlexGrid);
|
|
string str = AutoFolder;
|
|
if (str != null && str.Length > 5)
|
|
{
|
|
tmr.Enabled = true;
|
|
}
|
|
}
|
|
private void SetEventHandlers()
|
|
{
|
|
tbFileName.TextChanged += tbFileName_TextChanged;
|
|
Move += frmConvertAlarms_Move;
|
|
Resize += frmConvertAlarms_Resize;
|
|
sc1.SplitterMoved += sc1_SplitterMoved;
|
|
//sc2.SplitterMoved += sc2_SplitterMoved;
|
|
tbServer.TextChanged += tbServer_TextChanged;
|
|
cmbDatabase.TextChanged += cmbDatabase_TextChanged;
|
|
cmbDatabase.Click += cmbDatabase_Click;
|
|
cmbDocVersion.TextChanged += cmbDocVersion_TextChanged;
|
|
//BuildTableCombo();
|
|
//BuildProcedureSetCombo();
|
|
}
|
|
|
|
void cmbDatabase_Click(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.Database = cmbDatabase.Text;
|
|
Properties.Settings.Default.Save();
|
|
BuildProcedureSetCombo();
|
|
}
|
|
|
|
private void BuildProcedureSetCombo()
|
|
{
|
|
DocVersionInfoList dvil = DocVersionInfoList.Get();
|
|
cmbDocVersion.DataSource = dvil;
|
|
cmbDocVersion.DisplayMember = "SearchDVPath";
|
|
cmbDocVersion.ValueMember = "VersionId";
|
|
}
|
|
|
|
private void cmbDocVersion_TextChanged(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.ProcedureSet = (int)cmbDocVersion.SelectedValue;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private void cmbDatabase_TextChanged(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.Database = cmbDatabase.Text;
|
|
Properties.Settings.Default.Save();
|
|
BuildProcedureSetCombo();
|
|
}
|
|
|
|
private void tbServer_TextChanged(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.SqlServer = tbServer.Text;
|
|
Properties.Settings.Default.Save();
|
|
string db = cmbDatabase.Text;
|
|
try
|
|
{
|
|
BuildDatabaseCombo();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
tsslStatus.Text = ex.Message;
|
|
}
|
|
}
|
|
|
|
private void BuildDatabaseCombo()
|
|
{
|
|
string tmp = string.Format("Data Source={0};Initial Catalog={1};Integrated Security=True", tbServer.Text, "MASTER");
|
|
SqlConnection cn = new SqlConnection(tmp);
|
|
cn.Open();
|
|
// SqlDataAdapter da = new SqlDataAdapter("select name from sysdatabases where name like 'VEP%' order by name", cn);
|
|
//SqlDataAdapter da = new SqlDataAdapter("select name, case when object_id('[' + name + ']..Items') is null then 'Not PROMS' when object_id('[' + name + ']..Revisions') is not null then 'Approval' when object_id('[' + name + ']..ContentAudits') is not null then 'Change Manager' else 'Original' end functionality from sysdatabases where name not in ('master','model','msdb','tempdb') order by name", cn);
|
|
SqlDataAdapter da = new SqlDataAdapter("select name, 'Approval' functionality from sysdatabases where name not in ('master','model','msdb','tempdb') order by name", cn);
|
|
da.SelectCommand.CommandTimeout = 300; // 300 sec timeout
|
|
DataSet ds = new DataSet();
|
|
try
|
|
{
|
|
da.Fill(ds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Windows.Forms.MessageBox.Show(ex.GetType().Name, ex.Message);
|
|
throw (new Exception("Cannot Load Data List", ex));
|
|
}
|
|
cn.Close();
|
|
//System.Windows.Forms.ContextMenuStrip cms = new System.Windows.Forms.ContextMenuStrip();
|
|
//cms.Items.Add("Choose Database");
|
|
//System.Windows.Forms.ToolStripMenuItem tsmi = cms.Items[0] as System.Windows.Forms.ToolStripMenuItem;
|
|
//tsmi.BackColor = System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor.ActiveCaption);// System.Drawing.Color.Pink;
|
|
//tsmi.ForeColor = System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor.ActiveCaptionText);
|
|
//tsmi.Font = new System.Drawing.Font(tsmi.Font, System.Drawing.FontStyle.Bold);
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
if (dr["functionality"].ToString() == "Approval")
|
|
cmbDatabase.Items.Add(dr["name"].ToString());
|
|
}
|
|
}
|
|
void frmConvertAlarms_Resize(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.Size = Size;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
void frmConvertAlarms_Move(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.Location = Location;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
void tbFileName_TextChanged(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.FileName = tbFileName.Text;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
private void sc1_SplitterMoved(object sender, SplitterEventArgs e)
|
|
{
|
|
Properties.Settings.Default.Split1 = sc1.SplitterDistance;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
private void LoadSettings()
|
|
{
|
|
Size = Properties.Settings.Default.Size;
|
|
Location = Properties.Settings.Default.Location;
|
|
if (Properties.Settings.Default.FileName != null && Properties.Settings.Default.FileName != "")
|
|
{
|
|
FileInfo fi = new FileInfo(Properties.Settings.Default.FileName);
|
|
tbFileName.Text = fi.FullName;
|
|
}
|
|
sc1.SplitterDistance = Properties.Settings.Default.Split1;
|
|
tbServer.Text = Properties.Settings.Default.SqlServer;
|
|
cmbDatabase.Text = Properties.Settings.Default.Database;
|
|
try
|
|
{
|
|
BuildDatabaseCombo();
|
|
Database.VEPROMS_Connection = string.Format("Data Source={0};Initial Catalog={1};Integrated Security=True", tbServer.Text, cmbDatabase.Text);
|
|
BuildProcedureSetCombo();
|
|
cmbDocVersion.SelectedValue = Properties.Settings.Default.ProcedureSet;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
tsslStatus.Text = ex.Message;
|
|
}
|
|
}
|
|
|
|
private void tsslStatus_Click(object sender, EventArgs e)
|
|
{
|
|
tsslStatus.Text = string.Format("Selection = '{0}'", IndentifySpecialCharacters(tbXML.SelectedText));
|
|
Clipboard.Clear();
|
|
if (tbXML.SelectedText != "")
|
|
Clipboard.SetText(IndentifySpecialCharacters(tbXML.SelectedText));
|
|
}
|
|
|
|
private void rtbXML_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
}
|
|
private void tbXML_TextChanged(object sender, EventArgs e)
|
|
{
|
|
if (UpdateHTML)
|
|
{
|
|
if (AutoFolder == null) htmlChanged(tbXML.Text);
|
|
XMLChanged(tbXML.Text);
|
|
if (AutoFolder == null) ColorCoded(tbXML.Text);
|
|
}
|
|
}
|
|
private bool _UpdateTbXML = true;
|
|
|
|
public bool UpdateTbXML
|
|
{
|
|
get { return _UpdateTbXML; }
|
|
set { _UpdateTbXML = value; }
|
|
}
|
|
private void rtbXML_TextChanged(object sender, EventArgs e)
|
|
{
|
|
//if (UpdateHTML)
|
|
//{
|
|
// UpdateHTML = false;
|
|
// htmlChanged(rtbXML.Text);
|
|
// XMLChanged(rtbXML.Text);
|
|
// tbXML.Text = rtbXML.Text;
|
|
// UpdateHTML = true;
|
|
//}
|
|
}
|
|
private void btnConvert_Click(object sender, EventArgs e)
|
|
{
|
|
//SaveProcedure(ProcTextAll, ProcNumber, ProcTitle,999999);
|
|
DVI = DocVersionInfo.Get((int)cmbDocVersion.SelectedValue);
|
|
SaveProcedure(ProcTextAll, ProcNumber, ProcTitle, tbFileName.Text);
|
|
}
|
|
string lastLine = "";
|
|
SortedDictionary<int, ItemInfo> dicSerialNo;
|
|
int errorCount;
|
|
private void btnAll_Click(object sender, EventArgs e)
|
|
{
|
|
DVI = DocVersionInfo.Get((int)cmbDocVersion.SelectedValue);
|
|
string fileName = tbFileName.Text;
|
|
ConvertFiles(fileName);
|
|
}
|
|
|
|
private void ConvertFiles(string fileName)
|
|
{
|
|
Application.DoEvents();
|
|
DateTime dtStart = DateTime.Now;
|
|
errorCount = 0;
|
|
dicSerialNo = new SortedDictionary<int, ItemInfo>();
|
|
runOne = false;
|
|
// Get List of files
|
|
FileInfo fi = new FileInfo(fileName);
|
|
DirectoryInfo di = fi.Directory;
|
|
// Loop through list
|
|
FileInfo[] fs = di.GetFiles("*.xml");
|
|
tspb.Visible = true;
|
|
tspb.Value = 0;
|
|
tspb.Maximum = fs.Length;
|
|
foreach (FileInfo f in fs)
|
|
{
|
|
//ResetSpecial();
|
|
MyFileName = f.FullName;
|
|
tspb.Value++;
|
|
tsslStatus.Text = f.Name;
|
|
Application.DoEvents();
|
|
// Process each file
|
|
try
|
|
{
|
|
ProcessXmlFile(f.FullName);
|
|
// Convert each file
|
|
//SaveProcedure(ProcTextAll, ProcNumber, ProcTitle, SerialNo);
|
|
SaveProcedure(ProcTextAll, ProcNumber, ProcTitle, f.Name);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
++errorCount;
|
|
Console.WriteLine("*** {0} - {1}\r\n*** Procedure {2}\r\n*** Text: {3}\r\n*** File Name:{4} ",
|
|
ex.GetType().Name, ex.Message, ProcNumber, lastLine, f.Name);
|
|
//break;
|
|
}
|
|
//break; one Procedure per set
|
|
}
|
|
runOne = true;
|
|
tspb.Visible = false;
|
|
tsslStatus.Text = "Done";
|
|
//MessageBox.Show(string.Format(
|
|
// "{0} Errors\r\n{1} Procedures\r\n{2:F} Seconds", errorCount,
|
|
// fs.Length,
|
|
// TimeSpan.FromTicks(DateTime.Now.Ticks - dtStart.Ticks).TotalSeconds),
|
|
// "Done with this set", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
private void statusStrip1_Click(object sender, EventArgs e)
|
|
{
|
|
if (rtbXML.SelectedText != "")
|
|
{
|
|
tsslStatus.Text = string.Format("Selection = '{0}'", IndentifySpecialCharacters(rtbXML.SelectedText));
|
|
Clipboard.Clear();
|
|
Clipboard.SetText(IndentifySpecialCharacters(rtbXML.SelectedText));
|
|
}
|
|
}
|
|
ROFSTLookup MyLookUp;
|
|
private void tmr_Tick(object sender, EventArgs e)
|
|
{
|
|
tmr.Enabled = false;
|
|
// If timer on the its ready to proccess
|
|
string str = AutoFolder;
|
|
if (str != null && str.Length > 5)
|
|
{
|
|
DirectoryInfo di = new DirectoryInfo(str);
|
|
FileInfo fi = di.GetFiles("*.xml")[0];
|
|
DVI = GetDVI(fi.FullName);
|
|
ConvertFiles(fi.FullName);
|
|
}
|
|
this.Close();
|
|
}
|
|
private static string _AutoFolder = null;
|
|
private static string AutoFolder
|
|
{
|
|
get
|
|
{
|
|
if (_AutoFolder == null)
|
|
{
|
|
_AutoFolder = System.Environment.CommandLine;
|
|
_AutoFolder = _AutoFolder.Substring(_AutoFolder.IndexOf(@".exe"" ") + 6).Trim(" \t\r\n".ToCharArray());
|
|
}
|
|
if (_AutoFolder.Length < 1)
|
|
return null;
|
|
return _AutoFolder;
|
|
}
|
|
}
|
|
|
|
private DocVersionInfo GetDVI(string fileName)
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.Load(fileName);
|
|
XmlElement xe = xd.DocumentElement;
|
|
while (xe.Name != "ident")
|
|
xe = xe.ChildNodes[0] as XmlElement;
|
|
string DVIFolderName = xe.Attributes["PNSNo"].Value;
|
|
if (cmbDocVersion.SelectedValue != null)
|
|
{
|
|
DocVersionInfo dvi = DocVersionInfo.Get((int)(cmbDocVersion.SelectedValue));
|
|
int idnew;
|
|
ROFstInfo fst = dvi.DocVersionAssociations[0].MyROFst;
|
|
FolderInfo grandParent = dvi.ActiveParent.ActiveParent as FolderInfo;
|
|
// Create a folder
|
|
double myOrder = GetMyOrder(grandParent.SortedChildFolders, DVIFolderName);
|
|
using (Folder flder = Folder.MakeFolder(grandParent.Get(), null, DVIFolderName, fileName, GetSystem(xe), null, myOrder, null))
|
|
{
|
|
flder.ManualOrder = 0;
|
|
flder.ManualOrder = myOrder;
|
|
//Console.WriteLine("myOrder = {0}, flder = {1}", myOrder, flder.ManualOrder);
|
|
flder.Save();
|
|
// create a a DocVersion
|
|
using (DocVersion dv = DocVersion.MakeDocVersion(flder, "Working Draft", null, null, null, null))
|
|
{
|
|
dv.DocVersionAssociations.Add(fst.Get());
|
|
dv.Save();
|
|
idnew = dv.VersionID;
|
|
}
|
|
}
|
|
return DocVersionInfo.Get(idnew);
|
|
}
|
|
return null;
|
|
}
|
|
private double GetMyOrder(Csla.SortedBindingList<FolderInfo> myList, string DVIFolderName)
|
|
{
|
|
double lastNum = 0;
|
|
// Console.WriteLine("--->>> FolderName {0} Insert Count {1}",DVIFolderName, myList.Count);
|
|
foreach (FolderInfo myFolder in myList)
|
|
{
|
|
// Console.WriteLine("--->>> FolderName {0} Insert Name {1} Insert Order {2}",DVIFolderName, myFolder.Name, myFolder.ManualOrder);
|
|
if (myFolder.Name.CompareTo(DVIFolderName) >= 0)
|
|
return (lastNum + (double) myFolder.ManualOrder) / 2.0;
|
|
lastNum = myFolder.ManualOrder ?? 1.0;
|
|
}
|
|
return lastNum + 1;
|
|
}
|
|
private string GetSystem(XmlElement xe)
|
|
{
|
|
XmlAttribute xa = xe.Attributes["system"];
|
|
if (xa is XmlAttribute) return xa.Value;
|
|
return "N/A";
|
|
}
|
|
}
|
|
}
|