5209 lines
206 KiB
C#
5209 lines
206 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using VEPROMS.CSLA.Library;
|
|
using Volian.Controls.Library;
|
|
using Volian.Base.Library;
|
|
using System.Xml;
|
|
using System.IO;
|
|
using Ionic.Zip;
|
|
using System.Text.RegularExpressions;
|
|
using JR.Utils.GUI.Forms;
|
|
|
|
namespace VEPROMS
|
|
{
|
|
public partial class dlgExportImport : Form
|
|
{
|
|
#region Log4Net
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
#endregion
|
|
frmVEPROMS _MyFrmVEPROMS = null;// Save frmVEPROMS for Import to shutoff SessionPing
|
|
public frmVEPROMS MyFrmVEPROMS
|
|
{
|
|
get { return _MyFrmVEPROMS; }
|
|
set { _MyFrmVEPROMS = value; }
|
|
}
|
|
private bool _ConvertROsToTextDuringImport = false;
|
|
private bool _ConvertROsAndTransitionsToText = false; // set to true when Approval creates an Export file
|
|
|
|
// B2016-225 notify user when Transitions and/or ROs are converted to text
|
|
private bool _DidConvertTransitionsToText = false;
|
|
private bool _DidConvertROsToText = false;
|
|
private bool _DidUCF = false;
|
|
|
|
private ItemInfo _ExternalTransitionItem = null;
|
|
public ItemInfo ExternalTransitionItem
|
|
{
|
|
get { return _ExternalTransitionItem; }
|
|
set { _ExternalTransitionItem = value; }
|
|
}
|
|
private Dictionary<int, int> floatFoldout;
|
|
private Dictionary<int, string> importedFormat;
|
|
private Dictionary<string, int> existingFormat;
|
|
private Dictionary<string, string> renamedUCFFormatName; // if format is renamed, this is its new name so references to it can be made
|
|
private Dictionary<int, int> renamedUCFFormatId; // if format is renamed, this is its old->new formatid
|
|
private int oldRODbID;
|
|
private int newRODbID;
|
|
private FolderInfo _MyNewFolder;
|
|
public FolderInfo MyNewFolder
|
|
{
|
|
get { return _MyNewFolder; }
|
|
}
|
|
private ProcedureInfo _MyNewProcedure;
|
|
public ProcedureInfo MyNewProcedure
|
|
{
|
|
get { return _MyNewProcedure; }
|
|
set { _MyNewProcedure = value; }
|
|
}
|
|
private string PEIPath;
|
|
private string _MyMode;
|
|
private FolderInfo MyFolder = null;
|
|
private DocVersionInfo MyDocVersion = null;
|
|
private ProcedureInfo MyProcedure = null;
|
|
private XmlAttribute AddAttribute(XmlDocument xd, string name, string value)
|
|
{
|
|
XmlAttribute xa = xd.CreateAttribute(name);
|
|
xa.InnerText = value;
|
|
return xa;
|
|
}
|
|
public dlgExportImport(string mode, FolderInfo folderInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
|
|
{
|
|
UCFImportDefaultFromSettings = frset;
|
|
MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
|
|
_MyMode = mode;
|
|
MyFolder = folderInfo;
|
|
InitializeComponent();
|
|
this.Text = mode + " Dialog for " + folderInfo.Name;
|
|
}
|
|
public dlgExportImport(string mode, DocVersionInfo docVersionInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
|
|
{
|
|
UCFImportDefaultFromSettings = frset;
|
|
MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
|
|
_MyMode = mode;
|
|
MyDocVersion = docVersionInfo;
|
|
InitializeComponent();
|
|
if (mode.ToUpper().Contains("FORMAT"))
|
|
this.Text = mode;
|
|
else
|
|
this.Text = mode + " Dialog for " + docVersionInfo.Name + " of " + docVersionInfo.MyFolder.Name;
|
|
}
|
|
public dlgExportImport(string mode, ProcedureInfo procedureInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
|
|
{
|
|
UCFImportDefaultFromSettings = frset;
|
|
MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
|
|
_MyMode = mode;
|
|
MyProcedure = procedureInfo;
|
|
InitializeComponent();
|
|
this.Text = mode + " Dialog for " + procedureInfo.DisplayNumber;
|
|
}
|
|
private void dlgExportImport_Load(object sender, EventArgs e)
|
|
{
|
|
PEIPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\VEPROMS\PEI_" + Database.VEPROMS_SqlConnection.Database;
|
|
if (!Directory.Exists(PEIPath))
|
|
Directory.CreateDirectory(PEIPath);
|
|
if (_MyMode == "Import")
|
|
{
|
|
//If you try to import a procedure into an empty PROMS folder, the code was deleting the File System Folder including the import file. This happened during D.C. Cook training (12/3/2015).
|
|
//if (MyFolder != null && MyFolder.ChildFolderCount == 0 )
|
|
//{
|
|
// Directory.Delete(PEIPath, true);
|
|
// Directory.CreateDirectory(PEIPath);
|
|
//}
|
|
}
|
|
pnlExport.Dock = DockStyle.Fill;
|
|
pnlImport.Dock = DockStyle.Fill;
|
|
int formsize = 2;
|
|
if (_MyMode.ToLower().Contains("export"))
|
|
{
|
|
// if doing formats, make various controls invisible:
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
cbxExportAudits.Visible = false;
|
|
lblExportProcedure.Visible = lblExportSection.Visible = lblExportStep.Visible = false;
|
|
pbExportProcedure.Visible = pbExportSection.Visible = pbExportStep.Visible = false;
|
|
lblExportTime.Visible = false;
|
|
formsize = 4;
|
|
}
|
|
sfd.InitialDirectory = PEIPath;
|
|
pnlExport.BringToFront();
|
|
}
|
|
else
|
|
{
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
cbxImportAudits.Visible = false;
|
|
lblImportProcedure.Visible = lblImportSection.Visible = lblImportStep.Visible = false;
|
|
pbImportProcedure.Visible = pbImportSection.Visible = pbImportStep.Visible = false;
|
|
lblExportTime.Visible = false;
|
|
formsize = 4;
|
|
}
|
|
ofd.InitialDirectory = PEIPath;
|
|
pnlImport.BringToFront();
|
|
}
|
|
this.Height = this.Height / formsize;
|
|
}
|
|
private void btnExport_Click(object sender, EventArgs e)
|
|
{
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
txtExport.Text = string.Format(@"{0}\{1}.pxml", PEIPath, "UCF");
|
|
return;
|
|
}
|
|
if (MyFolder != null)
|
|
{
|
|
//Database.SelectedDatabase
|
|
//sfd.FileName = string.Format("{0}.expx", MyFolder.Name);
|
|
sfd.FileName = string.Format("{0}-{1}.expx", Database.ActiveDatabase, MyFolder.Name);
|
|
if (sfd.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
if (sfd.FileName != string.Empty)
|
|
{
|
|
txtExport.Text = sfd.FileName;
|
|
if (File.Exists(txtExport.Text))
|
|
File.Delete(txtExport.Text);
|
|
MyExpxZipFile = new ZipFile(txtExport.Text, Encoding.UTF8);
|
|
MyExpxZipFile.Save();
|
|
}
|
|
}
|
|
}
|
|
else if (MyProcedure != null)
|
|
{
|
|
txtExport.Text = string.Format(@"{0}\{1}.pxml", PEIPath, MyProcedure.DisplayNumber.Replace("/", "_").Replace("\\", "_"));
|
|
}
|
|
}
|
|
private void txtExport_TextChanged(object sender, EventArgs e)
|
|
{
|
|
btnDoExport.Enabled = txtExport.TextLength > 0;
|
|
if (btnDoExport.Enabled)
|
|
lblExportStatus.Text = "Ready To Perform Export";
|
|
else
|
|
lblExportStatus.Text = "Awaiting Export File Name:";
|
|
}
|
|
private XmlWriter MyWriter = null;
|
|
private ZipFile MyExpxZipFile = null;
|
|
private ZipFile MyImpxZipFile = null;
|
|
private DateTime MyStart;
|
|
private bool successfullExport = true;
|
|
private void btnDoExport_Click(object sender, EventArgs e)
|
|
{
|
|
btnExport.Enabled = false;
|
|
string msg = "Finished Exporting:\n\n";
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
this.Cursor = Cursors.WaitCursor;
|
|
MyStart = DateTime.Now;
|
|
btnDoExport.Enabled = false;
|
|
lblExportStatus.Text = "Performing Export of UC Formats";
|
|
SaveExportUCF();
|
|
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblExportStatus.Text = "Format Export Completed in " + elapsed.ToString();
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
else if (MyFolder != null)
|
|
{
|
|
this.Cursor = Cursors.WaitCursor;
|
|
MyStart = DateTime.Now;
|
|
btnDoExport.Enabled = false;
|
|
lblExportStatus.Text = "Performing Export";
|
|
SaveExportData();
|
|
//SaveExportDataWriter();
|
|
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblExportStatus.Text = "Export Completed in " + elapsed.ToString();
|
|
this.Cursor = Cursors.Default;
|
|
msg += MyFolder.Name;
|
|
}
|
|
else if (MyProcedure != null)
|
|
{
|
|
this.Cursor = Cursors.WaitCursor;
|
|
MyStart = DateTime.Now;
|
|
btnDoExport.Enabled = false;
|
|
lblExportStatus.Text = "Performing Export";
|
|
pbExportProcedure.Maximum = 1;
|
|
XmlDocument xd = new XmlDocument();
|
|
ExportItem(xd, MyProcedure, "procedure");
|
|
XmlElement xe = xd.CreateElement("formats");
|
|
xd.DocumentElement.AppendChild(xe);
|
|
ExportFormats(FormatInfoList.GetFormatInfoListUsed(), xe, "formats", false);
|
|
xd.Save(txtExport.Text);
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblExportStatus.Text = "Export Completed in " + elapsed.ToString();
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
// added message to user when export of a procedure or procedure set has completed
|
|
if (successfullExport)
|
|
{
|
|
if (!_MyMode.ToUpper().Contains("FORMAT"))
|
|
msg += MyProcedure;
|
|
else
|
|
msg += "Formats";
|
|
}
|
|
else
|
|
msg = "Could not complete export";
|
|
MessageBox.Show(msg, "Export Completed", MessageBoxButtons.OK, MessageBoxIcon.Information); // C2020-042 changed mesage box title
|
|
btnCloseExport.Enabled = true;
|
|
}
|
|
|
|
private void SaveExportUCF()
|
|
{
|
|
lblExportStatus.Text = "Exporting UC Formats...";
|
|
Application.DoEvents();
|
|
XmlDocument xd = new XmlDocument();
|
|
XmlElement xe = xd.CreateElement("ucformats");
|
|
xd.AppendChild(xe);
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
{
|
|
if (fi.Config != null && fi.Config != "")
|
|
ExportFormat(xe, fi, "ucformat");
|
|
}
|
|
xd.Save(txtExport.Text);
|
|
}
|
|
private void SaveExportData()
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
MyFrmVEPROMS.DisablePing = true;//B2018-030 Shutoff ping when doing Export
|
|
ExportFolder(xd, MyFolder, "folder");
|
|
MyFrmVEPROMS.DisablePing = false;//B2018-030 turn on ping Export is done
|
|
}
|
|
|
|
// appears to not be used -jsj 4-29-2016
|
|
//private void SaveExportDataWriter()
|
|
//{
|
|
// XmlWriterSettings ws = new XmlWriterSettings();
|
|
// ws.Indent = true;
|
|
// ws.NewLineHandling = NewLineHandling.Entitize;
|
|
// ws.CheckCharacters = false;
|
|
// MyWriter = XmlWriter.Create(txtExport.Text, ws);
|
|
// ExportFolder(MyFolder, "folder");
|
|
// MyWriter.Close();
|
|
//}
|
|
|
|
private void btnDoImport_Click(object sender, EventArgs e)
|
|
{
|
|
bool isImported = false;
|
|
bool canceledPressed = false;
|
|
btnImport.Enabled = false;
|
|
this.Cursor = Cursors.WaitCursor;
|
|
MyStart = DateTime.Now;
|
|
btnDoImport.Enabled = false;
|
|
lblImportStatus.Text = "Performing Import";
|
|
_DidConvertTransitionsToText = false;
|
|
_DidConvertROsToText = false;
|
|
_DidProcessTransitions = false; // B2017-076 to know if we processed any transition (used in status message at the end of importing)
|
|
_DidProcessROs = false; // B2017-076 to know if we processed any transition (used in status message at the end of importing)
|
|
//LoadImportDataReader();
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
TurnChangeManagerOff.Execute();
|
|
MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing
|
|
bool result = TryToImportUCFs(ref isImported, ref canceledPressed);
|
|
MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
|
|
TurnChangeManagerOn.Execute();
|
|
if (!result) // B2019-006: let user know there was an error during import:
|
|
{
|
|
MessageBox.Show("Error occurred during import. Format(s) not imported.");
|
|
this.Cursor = Cursors.Default;
|
|
btnCloseImport.Enabled = true;
|
|
return;
|
|
}
|
|
if (isImported)
|
|
{
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblImportStatus.Text = "Format Import Completed in " + elapsed.ToString();
|
|
}
|
|
else
|
|
{
|
|
btnImport.Enabled = true;
|
|
btnDoImport.Enabled = true;
|
|
}
|
|
}
|
|
else if (MyFolder != null) // import a folder - a .expx file
|
|
{
|
|
TurnChangeManagerOff.Execute();
|
|
MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing
|
|
// B2019-046: improved error handling (added return value)
|
|
isImported = TryToLoadImportDataDocument();// Added Try Catch Error Handling to assure that the Change Manager is tuned-on
|
|
MyDocVersion = null;
|
|
MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
|
|
TurnChangeManagerOn.Execute();
|
|
}
|
|
if (MyDocVersion != null) // import a procedure - a .pxml file
|
|
{
|
|
// compare the ROPath of MyDocVerion
|
|
// if no path set, display Pick RO Folder dialog
|
|
// if MyDocVersion ROPath is different than the import file ROPath, then ask user:
|
|
// - use MyDocVersion ROPath (warn resulting RO values may be be correct)
|
|
// * set oldRODbID to id in import file
|
|
// * set newRODbid to MyDocVersion rodbid
|
|
// - or convert ROs to text
|
|
TurnChangeManagerOff.Execute();
|
|
// Added Try Catch Error Handling to assure that the Change Manager is tuned-off
|
|
MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing B2017-157
|
|
bool result = TryToImportProcedure(ref isImported, ref canceledPressed);
|
|
MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
|
|
TurnChangeManagerOn.Execute();
|
|
if (!result) return;
|
|
if (isImported)
|
|
{
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblImportStatus.Text = "Import Completed in " + elapsed.ToString();
|
|
}
|
|
else
|
|
{
|
|
btnImport.Enabled = true;
|
|
btnDoImport.Enabled = true;
|
|
}
|
|
}
|
|
this.Cursor = Cursors.Default;
|
|
btnCloseImport.Enabled = true;
|
|
if (isImported)
|
|
{
|
|
string msg = string.Format("Finished Importing:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1));
|
|
if (_DidUCF) // B2019-015: add a message to state to exit re-enter on format imports
|
|
{
|
|
msg += "\n\nRestart PROMS to have user controlled formats become available.";
|
|
}
|
|
else if (_DidConvertTransitionsToText || _DidConvertROsToText)
|
|
{
|
|
string msg1 = (_DidConvertTransitionsToText && _DidConvertROsToText) ? "Transitions and Referenced Objects" : (_DidConvertTransitionsToText) ? "Transitions" : "Referenced Objects";
|
|
msg += string.Format("\n\n{0} converted to text.\n\nThe locations can be found by doing a Global Search for the \"Link Converted To Text\" annotation type", msg1);
|
|
}
|
|
else if (_ImportingApprovedExportFile) // B2020-095 An approved version of a procedure was imported, all ROs and Transitions are unlinked.
|
|
{
|
|
msg += "\n\nYou had imported an Approved Version of a procedure.\n\nAll Transition and Referenced Object values are text."; // B2017-076 Approved import file does not have ROs nor Transition
|
|
}
|
|
// B2016-225 added more information to the finish import message to tell the user when ROs or Transitions are converted to text.
|
|
MessageBox.Show(msg, "Import Completed", MessageBoxButtons.OK, MessageBoxIcon.Information); // C2020-042 changed mesage box title
|
|
//MessageBox.Show(string.Format("Finished Importing:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1)), "Import", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
if (canceledPressed)
|
|
{
|
|
MessageBox.Show(string.Format("Canceling the import of:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1)), "Import", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
btnCloseImport.PerformClick();
|
|
}
|
|
}
|
|
|
|
private bool TryToImportUCFs(ref bool isImported, ref bool canceledPressed)
|
|
{
|
|
try
|
|
{
|
|
existingFormat = new Dictionary<string, int>();
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
existingFormat.Add(fi.Name, fi.FormatID);
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.Load(txtImport.Text);
|
|
XmlNodeList nl = xd.SelectNodes("ucformats/ucformat");
|
|
if (nl == null || nl.Count == 0) // B2019-014: Check contents of import file for compatible operation
|
|
{
|
|
MessageBox.Show("A Procedure export file can only be imported from the Tree View.", "Import Failed", MessageBoxButtons.OK);
|
|
this.Close();
|
|
isImported = false;
|
|
return false;
|
|
}
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
|
|
string name = nd.Attributes.GetNamedItem("name").InnerText;
|
|
string config = null;
|
|
XmlNode cfg = nd.Attributes.GetNamedItem("config");
|
|
if (cfg != null) config = cfg.InnerText;
|
|
string pname = nd.Attributes.GetNamedItem("pname").InnerText;
|
|
string description = null;
|
|
XmlNode descript = nd.Attributes.GetNamedItem("description");
|
|
if (descript != null) description = descript.InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
if (!existingFormat.ContainsKey(pname)) return false;
|
|
int pid = existingFormat[pname];
|
|
Format pformat = Format.Get(pid);
|
|
if (existingFormat.ContainsKey(name)) // this UCF already exists in database, just update the record.
|
|
{
|
|
FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
|
|
if (exFI.Config != config)
|
|
{
|
|
using (Format f = Format.Get(exFI.FormatID))
|
|
{
|
|
f.Name = name;
|
|
f.MyParent = pformat;
|
|
f.Description = description;
|
|
f.UserID = userid;
|
|
f.DTS = dts;
|
|
f.Config = config;
|
|
f.Save();
|
|
}
|
|
}
|
|
}
|
|
else // doesn't exist in the database, add it
|
|
{
|
|
|
|
Format rec = Format.MakeFormat(pformat, name, description, null, null, dts, userid);
|
|
rec.Config = config;
|
|
rec.Save();
|
|
existingFormat.Add(name, rec.FormatID); // B2019-006: add imported format to existing so derived format can find parent
|
|
}
|
|
}
|
|
isImported = true;
|
|
_DidUCF = true;
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.StackTrace, ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
|
|
_MyLog.Warn("Failed during UC Formats Import", ex);
|
|
this.Close();
|
|
isImported = false;
|
|
return false;
|
|
}
|
|
}
|
|
private bool TryToImportProcedure(ref bool isImported, ref bool canceledPressed)
|
|
{
|
|
try
|
|
{
|
|
return ImportProcedure(ref isImported, ref canceledPressed);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.StackTrace, ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
|
|
_MyLog.Warn("Failed during Procedure Import", ex);
|
|
this.Close();
|
|
return false;
|
|
}
|
|
}
|
|
// B2020-095 exported files generated from approval has "APPROVED_REV_" in the file name
|
|
// if found, then sent the ImportingApprovedExportFile flag to true.
|
|
private bool _ImportingApprovedExportFile = false;
|
|
private bool ImportingApprovedExport(string fnAndPath)
|
|
{
|
|
bool rtnval = false;
|
|
int idx = fnAndPath.LastIndexOf("//") + 1;
|
|
string tmp = fnAndPath.Substring(idx);
|
|
rtnval = tmp.ToUpper().Contains("APPROVED_REV_");
|
|
return rtnval;
|
|
}
|
|
private bool ImportProcedure(ref bool isImported, ref bool canceledPressed)
|
|
{
|
|
_ImportingApprovedExportFile = ImportingApprovedExport(txtImport.Text); //B2020-095 see if import file was generated from Approved (versions) menu
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.Load(txtImport.Text);
|
|
pbImportProcedure.Maximum = 1;
|
|
XmlNode ucf = xd.SelectSingleNode("ucformats"); // B2019-014: Check contents of import file for compatible operation
|
|
if (ucf != null)
|
|
{
|
|
MessageBox.Show("A User Control of Format export file can only be imported from Administration on the V-Button.", "Import Failed", MessageBoxButtons.OK);
|
|
this.Cursor = Cursors.Default;
|
|
this.btnImport.Enabled = true; // allow user to select a different export file to import
|
|
this.btnCloseImport.Enabled = true; // allow user to close import dialog
|
|
return false;
|
|
}
|
|
string rofolderpath = xd.DocumentElement.Attributes.GetNamedItem("rofolderpath").InnerText;
|
|
int rodbid = int.Parse(xd.DocumentElement.Attributes.GetNamedItem("rodbid").InnerText);
|
|
int rofstid = int.Parse(xd.DocumentElement.Attributes.GetNamedItem("rofstid").InnerText);
|
|
if (MyDocVersion.DocVersionAssociationCount > 0)
|
|
{
|
|
// use current ROPath
|
|
MyRODb = RODb.GetJustRoDb(MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.RODbID);
|
|
// if the current RO Path and the import file RO Path are not the same
|
|
// then ask if we should import using the current workingdraft RO Path, convert the ROs to text, or cancel the import
|
|
if (MyRODb.FolderPath != rofolderpath && !_ImportingApprovedExportFile) //B2020-095 don't display dialog if importing approved procedure export file
|
|
{
|
|
dlgImpHowToHandleROs dlg = new dlgImpHowToHandleROs();
|
|
dlg.ImportedROFolder = rofolderpath;
|
|
dlg.WorkingDraftROFolder = MyRODb.FolderPath;
|
|
dlg.ShowDialog(this);
|
|
if (dlg.CancelImport)
|
|
{
|
|
this.Cursor = Cursors.Default;
|
|
this.btnImport.Enabled = true; // allow user to select a different export file to import
|
|
this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
|
|
return false; // Return False to Indicate that the Import did not succeed
|
|
}
|
|
_ConvertROsToTextDuringImport = dlg.ConvertROsToText;
|
|
}
|
|
// this saves the old RO database ID and the current RO database ID so that we can change the RODBIDs in the RO links
|
|
newRODbID = MyRODb.RODbID;
|
|
oldRODbID = rodbid;
|
|
}
|
|
else
|
|
{
|
|
#region NeedToSelectROPath
|
|
// MyDocVersion does not have an RO database (ro folder path) assigned to it so we need to select an RO Path
|
|
List<string> localROPaths = new List<string>();
|
|
RODbInfoList rolist = RODbInfoList.Get();
|
|
foreach (RODbInfo dbi in rolist)
|
|
{
|
|
if (dbi.FolderPath == rofolderpath && dbi.RODbID == rodbid)
|
|
{
|
|
MyRODb = RODb.GetJustRoDb(rodbid);
|
|
oldRODbID = newRODbID = rodbid;
|
|
break;
|
|
}
|
|
// B2016-175 have the correct (matching) RO Path but the rodbid is different (procedure came from a different SQL database)
|
|
// We can use the RO Path but we need to change the rodbid in the RO links of the procedure we are importing
|
|
else if (dbi.FolderPath == rofolderpath && dbi.RODbID != rodbid)
|
|
{
|
|
MyRODb = RODb.GetByFolderPath(rofolderpath);
|
|
newRODbID = MyRODb.RODbID;
|
|
oldRODbID = rodbid;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DirectoryInfo di = new DirectoryInfo(dbi.FolderPath);
|
|
if (di.Exists)
|
|
localROPaths.Add(dbi.FolderPath);
|
|
}
|
|
}
|
|
if (MyRODb == null)
|
|
{
|
|
if (localROPaths.Count == 0)
|
|
{
|
|
MessageBox.Show("There has been no RO folder defined for this database.\r\n\r\nIn order to import a procedure, you need to assign a RO folder path.\r\n\r\nImport process will terminate.");
|
|
this.Cursor = Cursors.Default;
|
|
return false;// Return False to Indicate that the Import did not succeed
|
|
}
|
|
else
|
|
{
|
|
this.Cursor = Cursors.Default;
|
|
dlgPickROFolder dlg = new dlgPickROFolder();
|
|
dlg.ImportedROFolder = rofolderpath;
|
|
dlg.LocalROFolders = localROPaths;
|
|
dlg.ShowDialog(this);
|
|
if ((dlg.SelectedROFolder ?? string.Empty) != string.Empty) // B2015-216 If the return value is null treat it like an empty string
|
|
{
|
|
MyRODb = RODb.GetByFolderPath(dlg.SelectedROFolder);
|
|
RODbInfo myRODBInfo = RODbInfo.Get(MyRODb.RODbID);
|
|
oldRODbID = newRODbID = MyRODb.RODbID;
|
|
ROFstInfo fstInfo = null;
|
|
foreach (ROFstInfo tmp in myRODBInfo.RODbROFsts)
|
|
if (fstInfo == null || tmp.ROFstID > fstInfo.ROFstID)
|
|
fstInfo = tmp;
|
|
using (DocVersion dv = MyDocVersion.Get())
|
|
{
|
|
using (ROFst fst = fstInfo.Get())
|
|
{
|
|
dv.DocVersionAssociations.Add(fst);
|
|
dv.Save();
|
|
}
|
|
dv.Reset_DocVersionAssociations();
|
|
MyDocVersion.RefreshDocVersionAssociations();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Since you did not pick an existing RO folder defined for this database, the import process will terminate.");
|
|
this.Close();// Close the Import Window
|
|
return false;// Return False to Indicate that the Import did not succeed
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
} // end - need to select RO Path
|
|
bool didImp = LoadFormats(xd, "procedure/formats/format");
|
|
if (!didImp)
|
|
{
|
|
this.Cursor = Cursors.Default;
|
|
this.btnImport.Enabled = true; // allow user to select a different export file to import
|
|
this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
|
|
return false; // Return False to Indicate that the Import did not succeed
|
|
}
|
|
// use resolvedProcNum to determine if procedure is 'unique', i.e. if the procedure number exists
|
|
// and user does not overwrite or copy, then the procedure should NOT be imported. Fix for B2016-045
|
|
bool resolvedProcNum = true;
|
|
foreach (ProcedureInfo pi in MyDocVersion.Procedures)
|
|
{
|
|
// procedure numbers that contain a hyphen may have the hyphen represented as the unicode character
|
|
// '\u8209?' or the '-' character. If proc number is same except for hyphen representation, they
|
|
// should be considered the same procedure (fix for B2016-084)
|
|
string hyphenNum = pi.MyContent.Number == null ? "" : pi.MyContent.Number.Replace(@"\u8209?", "-").Replace("\u2011", "-").Replace(@"\u9586?", @"\").Replace("\u2572", @"\");
|
|
string hyphenImpNum = xd.SelectSingleNode("procedure/content/@number").InnerText;
|
|
// bug fix C2015-044 - jsj
|
|
// - the cancel button would ignor the user's wishes and proceed with the import (overwriting the existing procedure)
|
|
// - also found that the message about overwriting or making a copy wasn't appearing because we where not converting the import procedure number
|
|
// - our standard unicode dash (\u8209?) before conparing the existing and imported
|
|
// - also found the Overrite and make a copy of messages looked too similar - fixed that as well.
|
|
//hyphenImpNum = hyphenImpNum == null ? "" : hyphenImpNum.Replace("\u8030?", "-"); -did not find any reason to have this \u8030? - note retested sourcesafe doc for B2016-084 without this logic and it was fine
|
|
hyphenImpNum = hyphenImpNum == null ? "" : hyphenImpNum.Replace(@"\u8209?", "-").Replace("\u2011", "-").Replace(@"\u9586?", @"\").Replace("\u2572", @"\");
|
|
|
|
if (hyphenNum == hyphenImpNum)
|
|
{
|
|
string msg = string.Format("The procedure you are importing{0}already exists in this procedure set.\n\nDo you want to OVERWRITE the existing procedure?", !hyphenImpNum.Equals("") ? string.Format(" ({0}) ", hyphenImpNum) : " ");
|
|
DialogResult dr = MessageBox.Show(this, msg, "Overwrite Existing Procedure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
|
|
if (dr == DialogResult.Yes)
|
|
{
|
|
bool success = ImportProcedureOverwrite(xd, pi); // C2018-020: check for successful Import
|
|
if (!success)
|
|
{
|
|
canceledPressed = true;
|
|
resolvedProcNum = false;
|
|
break;
|
|
}
|
|
isImported = true;
|
|
break;
|
|
}
|
|
if (dr == DialogResult.No)
|
|
{
|
|
msg = string.Format("Do you want to import {0} as a COPY of the existing procedure?\n\nThis will prefix the procedure number with \"Copy of\"", !hyphenImpNum.Equals("") ? string.Format("({0})", hyphenImpNum) : "the procedure");
|
|
dr = MessageBox.Show(this, msg, "Create Copy Of Existing Procedure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
|
|
if (dr == DialogResult.Yes)
|
|
{
|
|
ImportProcedureCopy(xd);
|
|
isImported = true;
|
|
break;
|
|
}
|
|
else
|
|
resolvedProcNum = false;
|
|
}
|
|
if (dr == System.Windows.Forms.DialogResult.Cancel)
|
|
{
|
|
canceledPressed = true;
|
|
resolvedProcNum = false;
|
|
}
|
|
break; // user selected No or Cancel so break out of the foreach loop
|
|
}
|
|
}
|
|
if (!canceledPressed && !isImported && resolvedProcNum)
|
|
{
|
|
ImportProcedureNew(xd);
|
|
isImported = true;
|
|
}
|
|
if (isImported && UCFImportCase == E_UCFImportOptions.LoadForSetOnly) UpdateFormatForUCFInSet();
|
|
return true;// Import Suceeded
|
|
}
|
|
private void UpdateFormatForUCFInSet()
|
|
{
|
|
// this gets called if the UCFImportCase == LoadForSetOnly, i.e. only items in this PROCEDURE Set whose formats point to a
|
|
// UCF format should point to the updated (copied) UCF format.
|
|
if (renamedUCFFormatId == null) return;
|
|
foreach (int key in renamedUCFFormatId.Keys)
|
|
{
|
|
using (ContentInfoList cil = ContentInfoList.FixFormatIDAfterImport(MyDocVersion.VersionID.ToString(), renamedUCFFormatId[key], key))
|
|
{
|
|
foreach (ContentInfo ci in cil)
|
|
{
|
|
using (Content c = ci.Get())
|
|
{
|
|
ContentInfo.Refresh(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Added Error Handling to assure that Change Manager is turned-on regardless of success or failure of the import
|
|
// B2019-046: improved error handling (added return value & error message)
|
|
private bool TryToLoadImportDataDocument()
|
|
{
|
|
try
|
|
{
|
|
bool retval = LoadImportDataDocument();
|
|
return retval;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
FlexibleMessageBox.Show("The import failed, check the error log for more information.", "Import Failed", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
_MyLog.Warn("Failure During Import", ex);
|
|
}
|
|
return false;
|
|
}
|
|
private void ImportProcedureNew(XmlDocument xd)
|
|
{
|
|
//add imported procedure
|
|
floatFoldout = new Dictionary<int, int>();
|
|
importedFormat = new Dictionary<int, string>();
|
|
existingFormat = new Dictionary<string, int>();
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
{
|
|
importedFormat.Add(fi.FormatID, fi.Name);
|
|
existingFormat.Add(fi.Name, fi.FormatID);
|
|
}
|
|
Old2NewItem = new Dictionary<int, int>();
|
|
Old2NewContent = new Dictionary<int, int>();
|
|
Old2NewLibDoc = new Dictionary<int, int>();
|
|
GetExistingLibDocsList(); // B2019-035 better memory management
|
|
PendingTransitions = new XmlDocument();
|
|
XmlElement xe = PendingTransitions.CreateElement("transitions");
|
|
PendingTransitions.AppendChild(xe);
|
|
string fn = PEIPath + @"\transitions.xml";
|
|
PendingTransitions.Save(fn);
|
|
ProcedureInfo lastProcedure = null;
|
|
foreach (ProcedureInfo pi in MyDocVersion.Procedures)
|
|
lastProcedure = pi;
|
|
_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
|
|
//update transitions
|
|
AddTransitions(PendingTransitions);
|
|
PendingTransitions.Save(fn);
|
|
FixFloatingFoldouts();
|
|
//File.Delete(fn);
|
|
}
|
|
private void ImportProcedureCopy(XmlDocument xd)
|
|
{
|
|
floatFoldout = new Dictionary<int, int>();
|
|
importedFormat = new Dictionary<int, string>();
|
|
existingFormat = new Dictionary<string, int>();
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
{
|
|
importedFormat.Add(fi.FormatID, fi.Name);
|
|
existingFormat.Add(fi.Name, fi.FormatID);
|
|
}
|
|
Old2NewItem = new Dictionary<int, int>();
|
|
Old2NewContent = new Dictionary<int, int>();
|
|
Old2NewLibDoc = new Dictionary<int, int>();
|
|
GetExistingLibDocsList(); // B2019-035 better memory management
|
|
PendingTransitions = new XmlDocument();
|
|
XmlElement xe = PendingTransitions.CreateElement("transitions");
|
|
PendingTransitions.AppendChild(xe);
|
|
string fn = PEIPath + @"\transitions.xml";
|
|
PendingTransitions.Save(fn);
|
|
ProcedureInfo lastProcedure = null;
|
|
//determine count of existing procedures with same number
|
|
string number = xd.SelectSingleNode("procedure/content/@number").InnerText;
|
|
|
|
// kbr - could replace '-' with unicode in number, here.
|
|
int count = 0;
|
|
foreach (ProcedureInfo pi in MyDocVersion.Procedures)
|
|
{
|
|
lastProcedure = pi;
|
|
if (pi.MyContent.Number.EndsWith(number))
|
|
count++;
|
|
}
|
|
xd.SelectSingleNode("procedure/content/@number").InnerText = string.Format("Copy({0}) of {1}", count.ToString(), number);
|
|
//add imported procedure and copy count
|
|
_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
|
|
//update transitions
|
|
AddTransitions(PendingTransitions);
|
|
FixFloatingFoldouts();
|
|
File.Delete(fn);
|
|
}
|
|
private bool ImportProcedureOverwrite(XmlDocument xd, ProcedureInfo pi)
|
|
{
|
|
floatFoldout = new Dictionary<int, int>();
|
|
importedFormat = new Dictionary<int, string>();
|
|
existingFormat = new Dictionary<string, int>();
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
{
|
|
importedFormat.Add(fi.FormatID, fi.Name);
|
|
existingFormat.Add(fi.Name, fi.FormatID);
|
|
}
|
|
Old2NewItem = new Dictionary<int, int>();
|
|
Old2NewContent = new Dictionary<int, int>();
|
|
Old2NewLibDoc = new Dictionary<int, int>();
|
|
GetExistingLibDocsList(); // B2019-035 better memory management
|
|
PendingTransitions = new XmlDocument();
|
|
XmlElement xe = PendingTransitions.CreateElement("transitions");
|
|
PendingTransitions.AppendChild(xe);
|
|
string fn = PEIPath + @"\transitions.xml";
|
|
PendingTransitions.Save(fn);
|
|
ProcedureInfo lastProcedure = null;
|
|
//delete old procedure
|
|
foreach (ProcedureInfo lp in MyDocVersion.Procedures)
|
|
lastProcedure = lp;
|
|
//delete opi
|
|
try
|
|
{
|
|
TurnChangeManagerOn.Execute(); // Import Turns off the Change Manager - Delete needs to have it on
|
|
Item.DeleteItemAndChildren(pi);
|
|
TurnChangeManagerOff.Execute(); // Assure that the Change Manager is off
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// C2018-020: cannot overwrite the procedure because transitions point to this. Show dialog listing transitions and then
|
|
// return false to flag that import was not successful.
|
|
if (ex.Message.Contains("has External Transitions"))
|
|
{
|
|
using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(pi.ItemID))
|
|
{
|
|
DialogResult ans = MessageBox.Show("Transitions exist to this procedure and cannot be adjusted automatically." +
|
|
"\r\nSteps with Problem Transitions:" +
|
|
exTrans.Summarize(),
|
|
"Cannot Overwrite Procedure", MessageBoxButtons.OK, MessageBoxIcon.Question);
|
|
}
|
|
}
|
|
else
|
|
MessageBox.Show(ex.Message, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
File.Delete(fn);
|
|
TurnChangeManagerOff.Execute(); // Assure that the Change Manager is off
|
|
return false;
|
|
}
|
|
//add imported procedure
|
|
_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
|
|
//update transitions
|
|
AddTransitions(PendingTransitions);
|
|
FixFloatingFoldouts();
|
|
return true;
|
|
}
|
|
private bool LoadImportDataDocument()
|
|
{
|
|
floatFoldout = new Dictionary<int, int>();
|
|
ZipEntry ze = MyExpxZipFile[0];
|
|
string fn = PEIPath + @"\" + ze.FileName;
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.Load(fn);
|
|
bool didImp = LoadFormats(xd, "folder/formats/format");
|
|
if (!didImp)
|
|
{
|
|
this.Cursor = Cursors.Default;
|
|
this.btnImport.Enabled = true; // allow user to select a different export file to import
|
|
this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
|
|
return false; // Return False to Indicate that the Import did not succeed
|
|
}
|
|
string name = xd.DocumentElement.Attributes.GetNamedItem("name").InnerText;
|
|
Folder ff = AddFolder(Folder.Get(MyFolder.FolderID), xd, name);
|
|
if (ff == null)
|
|
{
|
|
// C2020-032: Import Procedure set when existing name exists, allow user to import with 'Copy (#) of'.
|
|
// This is similar functionality to the import of a procedure without the overwrite part.
|
|
string msg = string.Format("The procedure set you are importing, {0}, already exists.\n\nDo you want to import {0} as a COPY of the existing set?\n\nThis will prefix the name with \"Copy (#) of\"", name);
|
|
DialogResult dr = MessageBox.Show(this, msg, "Create Copy Of Existing Procedure Set", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
|
|
if (dr == DialogResult.Yes)
|
|
{
|
|
string number = "";
|
|
int max = -1;
|
|
// get maximum number of existing copies.
|
|
foreach (FolderInfo fi in MyFolder.ChildFolders)
|
|
{
|
|
int indx = fi.Name.IndexOf("Copy (");
|
|
if (indx > -1)
|
|
{
|
|
int indxend = fi.Name.IndexOf(")", indx);
|
|
if (indxend > indx)
|
|
{
|
|
string tmp = fi.Name.Substring(indx + 6, indxend - (indx + 6));
|
|
int ii = Convert.ToInt32(tmp);
|
|
if (ii > max) max = ii;
|
|
}
|
|
}
|
|
}
|
|
number = max > -1 ? (max + 1).ToString() : "1";
|
|
name = string.Format("Copy ({0}) of {1}", number, name);
|
|
|
|
ff = AddFolder(Folder.Get(MyFolder.FolderID), xd, name);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
_MyNewFolder = FolderInfo.Get(ff.FolderID);
|
|
AddAnnotationTypes(xd);
|
|
DocVersionInfo dvi = AddDocVersion(ff, xd);
|
|
MyDocVersion = dvi;
|
|
xd = null;
|
|
lblImportStatus.Text = "Creating Procedures...";
|
|
Application.DoEvents();
|
|
ProcedureInfo pi = null;
|
|
pbImportProcedure.Value = 0;
|
|
pbImportProcedure.Maximum = MyExpxZipFile.Entries.Count - 1;
|
|
for (int i = 1; i < MyExpxZipFile.Entries.Count; i++)
|
|
{
|
|
ze = MyExpxZipFile[i];
|
|
fn = PEIPath + @"\" + ze.FileName;
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
xd = new XmlDocument();
|
|
xd.Load(fn);
|
|
pi = AddProcedure(xd.DocumentElement, dvi, pi);
|
|
GC.Collect(); // need to cleanup memory after importing each procedure due to use of Regular Expressions in processing RO and Transition links
|
|
}
|
|
DirectoryInfo di = new DirectoryInfo(PEIPath);
|
|
DirectoryInfo[] dis = di.GetDirectories();
|
|
for (int d = 0; d < dis.Length; d++)
|
|
dis[d].Delete(true);
|
|
lblImportStatus.Text = "Updating Transitions";
|
|
AddTransitions();
|
|
FixFloatingFoldouts();
|
|
SaveTransitionAndItemContentIDs();
|
|
return true;
|
|
}
|
|
private void FixSectionStart(ProcedureInfo pi)
|
|
{
|
|
Content c = Content.Get(pi.MyContent.ContentID);
|
|
XmlDocument xd = new XmlDocument();
|
|
// If the config field is empty, add an empty xml node.
|
|
if (c.Config == "") c.Config = "<Config/>";
|
|
xd.LoadXml(c.Config);
|
|
XmlNode xn = xd.SelectSingleNode("Config/Procedure/@SectionStart");
|
|
if (xn != null)
|
|
{
|
|
int iid = int.Parse(xn.InnerText);
|
|
if (Old2NewItem.ContainsKey(iid))
|
|
iid = Old2NewItem[iid];
|
|
else
|
|
{
|
|
int oldid = iid;
|
|
iid = pi.ItemID;
|
|
XmlAttribute xa = xd.CreateAttribute("ErrorSectionStart");
|
|
xa.InnerText = oldid.ToString();
|
|
XmlNode xp = xd.SelectSingleNode("Config/Procedure");
|
|
xp.Attributes.SetNamedItem(xa);
|
|
}
|
|
xn.InnerText = iid.ToString();
|
|
c.Config = xd.OuterXml;
|
|
c.Save();
|
|
}
|
|
}
|
|
private void FixFloatingFoldouts()
|
|
{
|
|
foreach (int key in floatFoldout.Keys)
|
|
{
|
|
lblImportStatus.Text = "Updating Floating Foldouts";
|
|
int cid = Old2NewContent[key];
|
|
int iid = Old2NewItem[floatFoldout[key]];
|
|
Content c = Content.Get(cid);
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.LoadXml(c.Config);
|
|
XmlNode xn = xd.SelectSingleNode("Config/Step/@FloatingFoldout");
|
|
xn.InnerText = iid.ToString();
|
|
c.Config = xd.OuterXml;
|
|
c.Save();
|
|
}
|
|
}
|
|
private E_UCFImportOptions UCFImportDefaultFromSettings;
|
|
private E_UCFImportOptions UCFImportCase = E_UCFImportOptions.LoadOnlyImported;
|
|
Dictionary<string, string> existingCopyFCName = new Dictionary<string, string>();
|
|
// note that this is used when importing a folder or a procedure (procedure was added for UCF changes)
|
|
private bool LoadFormats(XmlDocument xd, string xmlpath)
|
|
{
|
|
existingFormat = new Dictionary<string, int>();
|
|
FormatInfoList fil = FormatInfoList.Get();
|
|
foreach (FormatInfo fi in fil)
|
|
existingFormat.Add(fi.Name, fi.FormatID);
|
|
|
|
importedFormat = new Dictionary<int, string>();
|
|
XmlNodeList nl = xd.SelectNodes(xmlpath);
|
|
|
|
bool conflictingUCFdata = false;
|
|
List<string> existingFC = new List<string>();
|
|
List<string> importedFC = new List<string>();
|
|
List<string> fname = new List<string>();
|
|
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
string copyOfUCF = null;
|
|
// see if any of the imported formats are 'UCF' formats, i.e. have config data. If they are UCF,
|
|
// see if this is different that what is in the database. If it is, the user needs to decide
|
|
// whether to associate sections with existing UCF format or the new one. All UCF formats will be
|
|
// connected the same way, i.e. existing or new.
|
|
int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
|
|
string name = nd.Attributes.GetNamedItem("name").InnerText;
|
|
string config = null;
|
|
XmlNode cfg = nd.Attributes.GetNamedItem("config");
|
|
if (cfg != null) config = cfg.InnerText;
|
|
if (existingFormat.ContainsKey(name) && config != null && config != "")
|
|
{
|
|
FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
|
|
if (exFI.Config != config && exFI.Config != "" && exFI.Config != null && config != "" && config != null)
|
|
{
|
|
// See if there are copies of this UCF format, if so, this may match (have same config) one of those and should
|
|
// use it before stating there is conflicting data.
|
|
copyOfUCF = ContentsOfUCFExists(name, config);
|
|
if (copyOfUCF == null)
|
|
{
|
|
existingFC.Add(exFI.Config);
|
|
importedFC.Add(config);
|
|
conflictingUCFdata = true;
|
|
fname.Add(name);
|
|
}
|
|
else
|
|
existingCopyFCName.Add(name, copyOfUCF);
|
|
}
|
|
}
|
|
}
|
|
|
|
// there is a difference in UCF data, see if user wants sections to use the existing or new ucf data:
|
|
if (conflictingUCFdata)
|
|
{
|
|
// Bring up dialog to allow user to choose how the UCF data is handled:
|
|
// Importing of a procedure(s) (names of UCF exist in current DB and in exported DB)
|
|
//Case 0 - ignore (don't bring in new UCF)
|
|
//Case 1 - bringing in new UCF and not using it
|
|
//Case 2 - bringing in new UCF and only using it for imported data
|
|
//Case 3 - bringing in new UCF and using it across the board
|
|
//Case 4 - bringing in new UCF and using it for the current procedure set (not applicable for procedure sets)
|
|
UCFImportCase = UCFImportDefaultFromSettings; // from the options/settings
|
|
dlgUCFImportOptions ucfoptDlg = new dlgUCFImportOptions(fname, existingFC, importedFC, UCFImportCase, xmlpath);
|
|
DialogResult dr = ucfoptDlg.ShowDialog();
|
|
if (dr != DialogResult.OK) return false;
|
|
UCFImportCase = ucfoptDlg.UCFImportOptionsCase; // may be reset from dialog.
|
|
}
|
|
// first see if any of the imported formats have different data. If so,
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
|
|
string name = nd.Attributes.GetNamedItem("name").InnerText;
|
|
string config = null;
|
|
XmlNode cfg = nd.Attributes.GetNamedItem("config");
|
|
if (cfg != null) config = cfg.InnerText;
|
|
// B2020-084 GetNmaedItems was returning a null for pname.
|
|
// Only get the pname text if the pname attribute is found
|
|
// If there is no pname, then don't try to process and continue on with the next XML Node in the node list
|
|
string pname = null;
|
|
XmlNode pnameAttrib = nd.Attributes.GetNamedItem("pname");
|
|
if (pnameAttrib != null)
|
|
pname = pnameAttrib.InnerText;
|
|
if (pname == null) continue;
|
|
string description = null;
|
|
XmlNode descript = nd.Attributes.GetNamedItem("description");
|
|
if (descript != null) description = descript.InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
// If the format that is being imported exists as a copy (already was imported and a 'Copy x of name' was created) and the imported and
|
|
// existing config match, use the existing (copied) format's name rather than importing it again (the dictionary was set up during
|
|
// the import formats process.
|
|
if (existingCopyFCName.ContainsKey(name)) name = existingCopyFCName[name];
|
|
|
|
// compare this imported format to the original in the database.
|
|
// If format name exists, or if it has same config data, just use it.
|
|
if (existingFormat.ContainsKey(name))
|
|
{
|
|
// Note that Data & Genmac fields can have different contents. The format information should always be used from
|
|
// the original database, not the export file. So no processing is done on these fields when exporting & importing.
|
|
// Data or Genmac can be different if formats were updated in one database & not the other.
|
|
FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
|
|
if ((exFI.Config == config || ((exFI.Config == "" || exFI.Config == null) && (config == "" || config == null))))
|
|
{
|
|
// importedFormat is used to set correct formatid on imported sections (if different formatid <-> name between
|
|
// the current database and the one from which export came)
|
|
importedFormat.Add(formatid, name);
|
|
continue; // go on to next format in import list
|
|
}
|
|
}
|
|
// parent format will always be in there, if it is a new format, it will be added before the child. Check just in case (no null reference).
|
|
if (!existingFormat.ContainsKey(pname)) break;
|
|
int pid = existingFormat[pname];
|
|
Format pformat = Format.Get(pid);
|
|
|
|
// if the new format doesn't exist, it will be added (after these other checks). Otherwise, handle the
|
|
// various cases listed above:
|
|
if (existingFormat.ContainsKey(name))
|
|
{
|
|
// if case 0 and this ucf already exists, ignore it:
|
|
if (UCFImportCase == E_UCFImportOptions.Ignore) continue;
|
|
|
|
// if case 1, 2, 4 and the name exists, make a 'copy' of the newly imported format:
|
|
// need to add this format - name must be unique so add 'COPY(x) of 'original name'' where x is unique number:
|
|
if (UCFImportCase == E_UCFImportOptions.LoadNotUsed || UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly)
|
|
{
|
|
int count = 0;
|
|
foreach (FormatInfo fi in fil) if (fi.Name.EndsWith(name)) count++;
|
|
if (count > 0)
|
|
{
|
|
string origname = name;
|
|
name = string.Format("Copy {0} of {1}", count.ToString(), name);
|
|
if (UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly)
|
|
{
|
|
if (renamedUCFFormatName == null) renamedUCFFormatName = new Dictionary<string, string>();
|
|
renamedUCFFormatName.Add(origname, name);
|
|
}
|
|
}
|
|
}
|
|
// if case 3, take the existing config data and create in a record whose name is Old(x) of 'original name' (the record
|
|
// creation gets done below). Then modify the existing record to have the config data. The result is that any
|
|
// sections that used this UCF throughout the database will have the new config data.
|
|
if (UCFImportCase == E_UCFImportOptions.LoadUseAll)
|
|
{
|
|
string savname = name;
|
|
int count = 0;
|
|
foreach (FormatInfo fi in fil) if (fi.Name.EndsWith(name)) count++;
|
|
if (count > 0)
|
|
{
|
|
name = string.Format("Old {0} of {1}", count.ToString(), name);
|
|
}
|
|
// update the 'old' record by getting the original config data.
|
|
string savdesc = null;
|
|
DateTime savdts = DateTime.Now;
|
|
string savuid = null;
|
|
int savpar = 0;
|
|
string savconfig = null;
|
|
using (Format origRecord = Format.Get(existingFormat[savname]))
|
|
{
|
|
savdesc = origRecord.Description;
|
|
savdts = origRecord.DTS;
|
|
savuid = origRecord.UserID;
|
|
savpar = origRecord.ParentID;
|
|
savconfig = origRecord.Config;
|
|
origRecord.Name = savname;
|
|
origRecord.Description = description;
|
|
origRecord.DTS = dts;
|
|
origRecord.UserID = userid;
|
|
origRecord.MyParent = pformat;
|
|
origRecord.Config = config;
|
|
origRecord.Save();
|
|
description = savdesc;
|
|
dts = savdts;
|
|
userid = savuid;
|
|
pformat = Format.Get(savpar);
|
|
config = savconfig;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
if (UCFImportCase == 0) // ignore it
|
|
{
|
|
importedFormat.Add(formatid, name);
|
|
}
|
|
else
|
|
{
|
|
Format rec = Format.MakeFormat(pformat, name, description, null, null, dts, userid);
|
|
rec.Config = config;
|
|
rec.Save();
|
|
if (UCFImportCase == E_UCFImportOptions.LoadNotUsed || UCFImportCase == E_UCFImportOptions.LoadUseAll) // don't reset format id (case 1 don't use it, case 3 copies new data into original record
|
|
importedFormat.Add(formatid, name);
|
|
else if (UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly) // case 2 uses it for any items imported, case 4 uses it for any sections within current set
|
|
{
|
|
existingFormat.Add(name, rec.FormatID); // change to original name?
|
|
importedFormat.Add(rec.FormatID, name);
|
|
|
|
// get format id for the original named format
|
|
if (UCFImportCase == E_UCFImportOptions.LoadForSetOnly && renamedUCFFormatName != null)
|
|
{
|
|
int origformatid = -1;
|
|
foreach (var kvp in renamedUCFFormatName)
|
|
{
|
|
if (kvp.Value == name)
|
|
{
|
|
origformatid = existingFormat[kvp.Key];
|
|
break;
|
|
}
|
|
}
|
|
if (origformatid != -1)
|
|
{
|
|
if (renamedUCFFormatId == null) renamedUCFFormatId = new Dictionary<int, int>();
|
|
renamedUCFFormatId.Add(rec.FormatID, origformatid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
FormatInfoList.Reset();
|
|
return true;
|
|
}
|
|
|
|
private string ContentsOfUCFExists(string name, string config)
|
|
{
|
|
// See if there is an existing format file that was created as a copy. If so, check if the passed in format's
|
|
// config is the same as an existing 'Copy of' format - if so, use rather than importing the same format as
|
|
// defined by config.
|
|
foreach (var existname in existingFormat)
|
|
{
|
|
if (existname.Key.Contains(name))
|
|
{
|
|
string cpy = existname.Key;
|
|
if (cpy.StartsWith("Copy") && cpy.Contains("of " + name))
|
|
{
|
|
FormatInfo exFI = FormatInfo.Get(existingFormat[cpy]);
|
|
if (exFI.Config == config) return cpy;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//jsj 4-29-2016 appears to not be used
|
|
//Dictionary<int, ItemInfo> dicParentItem = null;
|
|
//private void UpdateParentItem(int depth, ItemInfo ii)
|
|
//{
|
|
// if (dicParentItem == null) dicParentItem = new Dictionary<int, ItemInfo>();
|
|
// if (!dicParentItem.ContainsKey(depth)) dicParentItem.Add(depth, null);
|
|
// dicParentItem[depth] = ii;
|
|
//}
|
|
|
|
//jsj 4-29-2016 appears to not be used
|
|
//Dictionary<int, ItemInfo> dicPreviousItem = null;
|
|
//private void UpdatePreviousItem(int depth, ItemInfo ii)
|
|
//{
|
|
// if (dicPreviousItem == null) dicPreviousItem = new Dictionary<int, ItemInfo>();
|
|
// if (!dicPreviousItem.ContainsKey(depth)) dicPreviousItem.Add(depth, null);
|
|
// dicPreviousItem[depth] = ii;
|
|
//}
|
|
|
|
Dictionary<int, int> dicItemDepth = null;
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private void UpdateItemDepth(int depth, int id)
|
|
//{
|
|
// if (dicItemDepth == null) dicItemDepth = new Dictionary<int, int>();
|
|
// if (!dicItemDepth.ContainsKey(depth)) dicItemDepth.Add(depth, 0);
|
|
// dicItemDepth[depth] = id;
|
|
//}
|
|
// jsj 2016Feb17 - this appears to not be used
|
|
//private void LoadImportDataReader()
|
|
//{
|
|
// int pCount = 0;
|
|
// int sCount = 0;
|
|
// Folder folder = null;
|
|
// DocVersion docversion = null;
|
|
// Dictionary<string, string> dicRofst = null;
|
|
// Dictionary<string, string> dicEntry = null;
|
|
// ROFst rofst = null;
|
|
// GetImportDataCounts();
|
|
// pbImportProcedure.Maximum = MyCounts.Count;
|
|
// pbImportProcedure.Value = 0;
|
|
// Application.DoEvents();
|
|
// FileStream fs = File.OpenRead(txtImport.Text);
|
|
// XmlReaderSettings rs = new XmlReaderSettings();
|
|
// rs.CheckCharacters = false;
|
|
// XmlReader xr = XmlReader.Create(fs, rs);
|
|
// while (xr.Read())
|
|
// {
|
|
// if (xr.IsStartElement())
|
|
// {
|
|
// switch (xr.Name)
|
|
// {
|
|
// case "annotation":
|
|
// AddAnnotation(xr);
|
|
// break;
|
|
// //case "association":
|
|
// // break;
|
|
// case "content":
|
|
// {
|
|
// if (xr.Depth == 3) //content for procedure
|
|
// {
|
|
// ItemInfo ii = AddProcedure(xr, docversion, dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// }
|
|
// else
|
|
// {
|
|
|
|
// int fromtype = dicItemDepth.ContainsKey(xr.Depth - 2) ? dicItemDepth[xr.Depth - 2] : 0;
|
|
// switch (fromtype)
|
|
// {
|
|
// case 2:
|
|
// { //sections
|
|
// ItemInfo ii = AddSection(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// case 3:
|
|
// { //cautions
|
|
// ItemInfo ii = AddCaution(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// case 4:
|
|
// { //notes
|
|
// ItemInfo ii = AddNote(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// case 5:
|
|
// { //rnos
|
|
// ItemInfo ii = AddRNO(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// case 6:
|
|
// { //steps
|
|
// ItemInfo ii = AddStep(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// case 7:
|
|
// { //tables
|
|
// ItemInfo ii = AddTable(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
|
|
// UpdatePreviousItem(xr.Depth, ii);
|
|
// UpdateParentItem(xr.Depth, ii);
|
|
// break;
|
|
// }
|
|
// default:
|
|
// break;
|
|
// }
|
|
// }
|
|
// break;
|
|
// }
|
|
// case "document":
|
|
// AddDocument(xr, dicEntry);
|
|
// break;
|
|
// case "docversion":
|
|
// {
|
|
// docversion = AddDocVersion(folder, xr);
|
|
// UpdatePreviousItem(xr.Depth + 2, null);
|
|
// break;
|
|
// }
|
|
// case "entry":
|
|
// dicEntry = AddEntry(xr);
|
|
// break;
|
|
// case "folder":
|
|
// folder = AddFolder(Folder.Get(MyFolder.FolderID), xr);
|
|
// break;
|
|
// case "grid":
|
|
// AddGrid(xr);
|
|
// break;
|
|
// case "procedure":
|
|
// {
|
|
// UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
|
|
// pbImportProcedure.PerformStep();
|
|
// lblImportProcedure.Text = string.Format("{0} of {1} Procedures", pbImportProcedure.Value.ToString(), pbImportProcedure.Maximum.ToString());
|
|
// pCount++;
|
|
// pbImportSection.Maximum = MyCounts[pCount].Count;
|
|
// pbImportSection.Value = 0;
|
|
// sCount = 0;
|
|
// Application.DoEvents();
|
|
// break;
|
|
// }
|
|
// case "section":
|
|
// {
|
|
// UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
|
|
// pbImportSection.PerformStep();
|
|
// lblImportSection.Text = string.Format("{0} of {1} Sections", pbImportSection.Value.ToString(), pbImportSection.Maximum.ToString());
|
|
// sCount++;
|
|
// pbImportStep.Maximum = MyCounts[pCount][sCount];
|
|
// pbImportStep.Value = 0;
|
|
// Application.DoEvents();
|
|
// break;
|
|
// }
|
|
// case "step":
|
|
// {
|
|
// UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
|
|
// if (xr.Depth == 8)
|
|
// {
|
|
// pbImportStep.PerformStep();
|
|
// lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
// Application.DoEvents();
|
|
// }
|
|
// break;
|
|
// }
|
|
// case "caution":
|
|
// case "note":
|
|
// case "rno":
|
|
// case "table":
|
|
// UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
|
|
// break;
|
|
// case "cautions":
|
|
// case "notes":
|
|
// case "rnos":
|
|
// case "sections":
|
|
// case "steps":
|
|
// case "tables":
|
|
// {
|
|
// UpdateItemDepth(xr.Depth, int.Parse(xr.GetAttribute("fromtype")));
|
|
// UpdatePreviousItem(xr.Depth + 2, null);
|
|
// UpdateParentItem(xr.Depth + 2, dicParentItem[xr.Depth - 1]);
|
|
// break;
|
|
// }
|
|
// case "rodb":
|
|
// {
|
|
// MyRODb = AddRODb(xr);
|
|
// rofst = AddROFst(dicRofst);
|
|
// docversion.DocVersionAssociations.Add(rofst);
|
|
// docversion.Save();
|
|
// break;
|
|
// }
|
|
// case "rofst":
|
|
// dicRofst = GetROFstData(xr);
|
|
// break;
|
|
// case "rousage":
|
|
// AddROUsage(xr);
|
|
// break;
|
|
// //case "transition":
|
|
// // break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
// Console.WriteLine("{0} - {1}", xr.Name, xr.Depth.ToString());
|
|
// }
|
|
// }
|
|
// pbImportProcedure.PerformStep();
|
|
// Application.DoEvents();
|
|
// fs.Close();
|
|
// FixImportDataTransitions();
|
|
// StoreItemContentIDs();
|
|
// ResolveExternalTransitions(folder);
|
|
//}
|
|
|
|
// This is called only when we are importing an entire folder.
|
|
// if there is a .impx file (a zip file generated from the last folder export file and based on location -folder name- of the export file you are importing), then it updates it with new values,
|
|
// else it will create a .impx file, and saves the id information listed below.
|
|
// This will create and save the ItemIDs (old and new), ContentIDs (old andnew), library document IDs (old and new), and pending transitions each in their own xml file
|
|
// the xml files are then added (or replaced) in the .impx file.
|
|
private void SaveTransitionAndItemContentIDs()
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
XmlElement xe = xd.CreateElement("items");
|
|
xd.AppendChild(xe);
|
|
string fn = PEIPath + @"\items.xml";
|
|
foreach (int key in Old2NewItem.Keys)
|
|
{
|
|
xe = xd.CreateElement("item");
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "old", key.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "new", Old2NewItem[key].ToString()));
|
|
xd.DocumentElement.AppendChild(xe);
|
|
}
|
|
xd.Save(fn);
|
|
ZipEntry ze = MyImpxZipFile["items.xml"];
|
|
MyImpxZipFile.RemoveEntry(ze);
|
|
MyImpxZipFile.Save();
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
xd = new XmlDocument();
|
|
xe = xd.CreateElement("contents");
|
|
xd.AppendChild(xe);
|
|
fn = PEIPath + @"\contents.xml";
|
|
foreach (int key in Old2NewContent.Keys)
|
|
{
|
|
xe = xd.CreateElement("content");
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "old", key.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "new", Old2NewContent[key].ToString()));
|
|
xd.DocumentElement.AppendChild(xe);
|
|
}
|
|
xd.Save(fn);
|
|
ze = MyImpxZipFile["contents.xml"];
|
|
MyImpxZipFile.RemoveEntry(ze);
|
|
MyImpxZipFile.Save();
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
xd = new XmlDocument();
|
|
xe = xd.CreateElement("transitions");
|
|
xd.AppendChild(xe);
|
|
fn = PEIPath + @"\transitions.xml";
|
|
if (PendingTransitions != null && PendingTransitions.DocumentElement.HasChildNodes)
|
|
{
|
|
foreach (XmlNode nd in PendingTransitions.DocumentElement.ChildNodes)
|
|
{
|
|
if (nd.InnerText == "")
|
|
xd.DocumentElement.AppendChild(xd.ImportNode(nd, true));
|
|
}
|
|
}
|
|
xd.Save(fn);
|
|
ze = MyImpxZipFile["transitions.xml"];
|
|
MyImpxZipFile.RemoveEntry(ze);
|
|
MyImpxZipFile.Save();
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
}
|
|
// appears to not be used - jsj 4-28-2016
|
|
//private void StoreItemContentIDs()
|
|
//{
|
|
// XmlDocument xd = new XmlDocument();
|
|
// string fn = PEIPath + @"\ExternalTransitions.xml";
|
|
// xd.Load(fn);
|
|
// XmlElement xe = (XmlElement)xd.SelectSingleNode("externaltransitions/oldtonewitem");
|
|
// foreach (int key in Old2NewItem.Keys)
|
|
// {
|
|
// XmlElement xee = xd.CreateElement("item");
|
|
// XmlAttribute xa = AddAttribute(xd, "old", key.ToString());
|
|
// xee.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "new", Old2NewItem[key].ToString());
|
|
// xee.Attributes.SetNamedItem(xa);
|
|
// xe.AppendChild(xee);
|
|
// }
|
|
// xd.Save(fn);
|
|
// xe = (XmlElement)xd.SelectSingleNode("externaltransitions/oldtonewcontent");
|
|
// foreach (int key in Old2NewContent.Keys)
|
|
// {
|
|
// XmlElement xee = xd.CreateElement("content");
|
|
// XmlAttribute xa = AddAttribute(xd, "old", key.ToString());
|
|
// xee.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "new", Old2NewContent[key].ToString());
|
|
// xee.Attributes.SetNamedItem(xa);
|
|
// xe.AppendChild(xee);
|
|
// }
|
|
// xd.Save(fn);
|
|
//}
|
|
//private void ResolveExternalTransitions(Folder folder)
|
|
//{
|
|
// XmlDocument xd = new XmlDocument();
|
|
// string fn = PEIPath + @"\ExternalTransitions.xml";
|
|
// xd.Load(fn);
|
|
// AddStoredItemContentIDs(xd);
|
|
// XmlNodeList nl = xd.SelectNodes("//transition[@folder!='']");
|
|
// foreach (XmlNode nd in nl)
|
|
// {
|
|
// int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
|
|
// int fromid = int.Parse(nd.Attributes.GetNamedItem("fromid").InnerText);
|
|
// int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
|
|
// int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);
|
|
// if (Old2NewContent.ContainsKey(fromid) && Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid))
|
|
// {
|
|
// int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
|
|
// int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
|
|
// string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
// string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
// DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
// string lookfor;
|
|
// if (isrange == 0)
|
|
// lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
// else
|
|
// lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
// fromid = Old2NewContent[fromid];
|
|
// toid = Old2NewItem[toid];
|
|
// rangeid = Old2NewItem[rangeid];
|
|
// Content cc = Content.Get(fromid);
|
|
// Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
|
|
// transitionid = tt.TransitionID;
|
|
// string replacewith;
|
|
// if (isrange == 0)
|
|
// replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
// else
|
|
// replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
// cc.Text = cc.Text.Replace(lookfor, replacewith);
|
|
// cc.Save();
|
|
// nd.Attributes.GetNamedItem("folder").InnerText = "";
|
|
// }
|
|
// }
|
|
// xd.Save(fn);
|
|
//}
|
|
|
|
// This is called only when we are importing an entire folder and there is a .impx file (a zip file)
|
|
// the name of the .impx file is based on the folder name containing the export file being imported
|
|
// This will read in the saved ItemIDs (old and new), ContentIDs (old andnew), library document IDs (old and new), and pending transitions
|
|
private void ReadTransitionAndItemContentIDs()
|
|
{
|
|
ZipEntry ze = MyImpxZipFile["items.xml"];
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
string fn = PEIPath + @"\items.xml";
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.Load(fn);
|
|
// B2016-176, B2016-197 Transitions were no always properly resolved - don't load in the old item ids
|
|
//XmlNodeList nl = xd.SelectNodes("//item");
|
|
//foreach (XmlNode nd in nl)
|
|
//{
|
|
// int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
|
|
// int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
|
|
// //if (!Old2NewItem.ContainsKey(oldid))
|
|
// Old2NewItem.Add(oldid, newid);
|
|
//}
|
|
File.Delete(fn);
|
|
ze = MyImpxZipFile["contents.xml"];
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
fn = PEIPath + @"\contents.xml";
|
|
xd = new XmlDocument();
|
|
xd.Load(fn);
|
|
// B2016-176, B2016-197 Transitions were no always properly resolved - don't load in the old content ids
|
|
//nl = xd.SelectNodes("//content");
|
|
//foreach (XmlNode nd in nl)
|
|
//{
|
|
// int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
|
|
// int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
|
|
// //if (!Old2NewContent.ContainsKey(oldid))
|
|
// Old2NewContent.Add(oldid, newid);
|
|
//}
|
|
File.Delete(fn);
|
|
ze = MyImpxZipFile["libdocs.xml"];
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
fn = PEIPath + @"\libdocs.xml";
|
|
xd = new XmlDocument();
|
|
xd.Load(fn);
|
|
XmlNodeList nl = xd.SelectNodes("//libdoc");
|
|
//nl = xd.SelectNodes("//libdoc");
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
|
|
int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
|
|
//if (!Old2NewContent.ContainsKey(oldid))
|
|
Old2NewLibDoc.Add(oldid, newid);
|
|
}
|
|
File.Delete(fn);
|
|
ze = MyImpxZipFile["transitions.xml"];
|
|
ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
|
|
fn = PEIPath + @"\transitions.xml";
|
|
PendingTransitions.Load(fn);
|
|
File.Delete(fn);
|
|
}
|
|
// appears not to be used - jsj 4-28-2016
|
|
//private void AddStoredItemContentIDs(XmlDocument xd)
|
|
//{
|
|
// XmlNodeList nl = xd.SelectNodes("//item");
|
|
// foreach (XmlNode nd in nl)
|
|
// {
|
|
// int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
|
|
// int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
|
|
// if (!Old2NewItem.ContainsKey(oldid))
|
|
// Old2NewItem.Add(oldid, newid);
|
|
// }
|
|
// nl = xd.SelectNodes("//content");
|
|
// foreach (XmlNode nd in nl)
|
|
// {
|
|
// int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
|
|
// int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
|
|
// if (!Old2NewContent.ContainsKey(oldid))
|
|
// Old2NewContent.Add(oldid, newid);
|
|
// }
|
|
//}
|
|
|
|
// appears not to be used - jsj 4-28-2016
|
|
//private void FixImportDataTransitions()
|
|
//{
|
|
// XmlDocument xd = new XmlDocument();
|
|
// string fn = PEIPath + @"\ExternalTransitions.xml";
|
|
// if (!File.Exists(fn))
|
|
// {
|
|
// XmlElement xe = xd.CreateElement("externaltransitions");
|
|
// XmlElement xee = xd.CreateElement("oldtonewitem");
|
|
// xe.AppendChild(xee);
|
|
// xee = xd.CreateElement("oldtonewcontent");
|
|
// xe.AppendChild(xee);
|
|
// xee = xd.CreateElement("transitions");
|
|
// xe.AppendChild(xee);
|
|
// xd.AppendChild(xe);
|
|
// xd.Save(fn);
|
|
// }
|
|
// else
|
|
// {
|
|
// xd.Load(fn);
|
|
// }
|
|
// FileStream fs = File.OpenRead(txtImport.Text);
|
|
// XmlReaderSettings rs = new XmlReaderSettings();
|
|
// rs.CheckCharacters = false;
|
|
// XmlReader xr = XmlReader.Create(fs, rs);
|
|
// while (xr.Read())
|
|
// {
|
|
// if (xr.IsStartElement())
|
|
// {
|
|
// switch (xr.Name)
|
|
// {
|
|
// case "transition":
|
|
// AddTransitions(xr);
|
|
// break;
|
|
// case "externaltransition":
|
|
// {
|
|
// AddExternalTransition(xr, xd);
|
|
// break;
|
|
// }
|
|
// default:
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// fs.Close();
|
|
// xd.Save(fn);
|
|
//}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private Dictionary<int, Dictionary<int, int>> MyCounts = null;
|
|
//private Dictionary<int, int> MySubCounts = null;
|
|
//private void GetImportDataCounts()
|
|
//{
|
|
// int pCount = 0;
|
|
// int sCount = 0;
|
|
// int tCount = 0;
|
|
// MyCounts = new Dictionary<int, Dictionary<int, int>>();
|
|
// MySubCounts = new Dictionary<int, int>();
|
|
// FileStream fs = File.OpenRead(txtImport.Text);
|
|
// XmlReaderSettings rs = new XmlReaderSettings();
|
|
// rs.CheckCharacters = false;
|
|
// XmlReader xr = XmlReader.Create(fs, rs);
|
|
// while (xr.Read())
|
|
// {
|
|
// if (xr.IsStartElement())
|
|
// {
|
|
// switch (xr.Name)
|
|
// {
|
|
// case "procedure":
|
|
// {
|
|
// if (pCount > 0)
|
|
// {
|
|
// MySubCounts.Add(sCount, tCount);
|
|
// MyCounts.Add(pCount, MySubCounts);
|
|
// sCount = 0;
|
|
// tCount = 0;
|
|
// MySubCounts = new Dictionary<int, int>();
|
|
// }
|
|
// pCount++;
|
|
// break;
|
|
// }
|
|
// case "section":
|
|
// {
|
|
// if (sCount > 0)
|
|
// {
|
|
// MySubCounts.Add(sCount, tCount);
|
|
// tCount = 0;
|
|
// }
|
|
// sCount++;
|
|
// break;
|
|
// }
|
|
// case "step":
|
|
// {
|
|
// if (xr.Depth == 8)
|
|
// tCount++;
|
|
// break;
|
|
// }
|
|
// default:
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// MySubCounts.Add(sCount, tCount);
|
|
// MyCounts.Add(pCount, MySubCounts);
|
|
// fs.Close();
|
|
//}
|
|
|
|
private void btnImport_Click(object sender, EventArgs e)
|
|
{
|
|
if (_MyMode.ToUpper().Contains("FORMAT"))
|
|
{
|
|
ofd.Filter = "PROMS Procedure Export Files|*.pxml";
|
|
if (ofd.ShowDialog(this) == DialogResult.OK)
|
|
txtImport.Text = ofd.FileName;
|
|
return;
|
|
}
|
|
if (MyFolder != null)
|
|
{
|
|
if (ofd.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
if (ofd.FileName != string.Empty)
|
|
{
|
|
Old2NewItem = new Dictionary<int, int>();
|
|
Old2NewContent = new Dictionary<int, int>();
|
|
Old2NewLibDoc = new Dictionary<int, int>();
|
|
GetExistingLibDocsList(); // B2019-035 better memory management
|
|
PendingTransitions = new XmlDocument();
|
|
FileInfo fi = new FileInfo(ofd.FileName);
|
|
string dn;
|
|
if (fi.Name.IndexOf("-") > 0)
|
|
dn = fi.Name.Substring(0, fi.Name.IndexOf("-"));
|
|
else
|
|
dn = fi.Name.Substring(0, fi.Name.IndexOf("."));
|
|
txtImport.Text = ofd.FileName;
|
|
ReadOptions ro = new ReadOptions();
|
|
ro.Encoding = Encoding.UTF8;
|
|
MyExpxZipFile = ZipFile.Read(txtImport.Text, ro);
|
|
string fn = string.Format(@"{0}\{1}.impx", PEIPath, dn);
|
|
if (File.Exists(fn))
|
|
{
|
|
MyImpxZipFile = ZipFile.Read(fn, ro);
|
|
ReadTransitionAndItemContentIDs();
|
|
}
|
|
else
|
|
{
|
|
MyImpxZipFile = new ZipFile(fn, Encoding.UTF8);
|
|
//transitions
|
|
XmlElement xe = PendingTransitions.CreateElement("transitions");
|
|
PendingTransitions.AppendChild(xe);
|
|
fn = PEIPath + @"\transitions.xml";
|
|
PendingTransitions.Save(fn);
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
//itemids
|
|
XmlDocument xd = new XmlDocument();
|
|
xe = xd.CreateElement("items");
|
|
xd.AppendChild(xe);
|
|
fn = PEIPath + @"\items.xml";
|
|
xd.Save(fn);
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
//contentids
|
|
xd = new XmlDocument();
|
|
xe = xd.CreateElement("contents");
|
|
xd.AppendChild(xe);
|
|
fn = PEIPath + @"\contents.xml";
|
|
xd.Save(fn);
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
//libdocids
|
|
xd = new XmlDocument();
|
|
xe = xd.CreateElement("libdocs");
|
|
xd.AppendChild(xe);
|
|
fn = PEIPath + @"\libdocs.xml";
|
|
xd.Save(fn);
|
|
MyImpxZipFile.AddFile(fn, "");
|
|
MyImpxZipFile.Save();
|
|
File.Delete(fn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (MyDocVersion != null)
|
|
{
|
|
ofd.Filter = "PROMS Procedure Export Files|*.pxml";
|
|
if (ofd.ShowDialog(this) == DialogResult.OK)
|
|
txtImport.Text = ofd.FileName;
|
|
}
|
|
}
|
|
private void txtImport_TextChanged(object sender, EventArgs e)
|
|
{
|
|
btnDoImport.Enabled = txtImport.TextLength > 0;
|
|
if (btnDoImport.Enabled)
|
|
lblImportStatus.Text = "Ready To Perform Import";
|
|
else
|
|
lblImportStatus.Text = "Awaiting Import File Name:";
|
|
}
|
|
#region Export for Merge
|
|
private string FromFolderName = string.Empty;
|
|
private void ExportFolder(XmlDocument xd, FolderInfo fi, string nodename)
|
|
{
|
|
/*
|
|
FolderID
|
|
ParentID
|
|
DBID
|
|
Name
|
|
Title
|
|
ShortName
|
|
FormatID
|
|
ManualOrder
|
|
Config
|
|
DTS
|
|
UsrID
|
|
*/
|
|
lblExportStatus.Text = "Exporting Folder...";
|
|
Application.DoEvents();
|
|
string formatFileName = (fi.MyFormat != null) ? fi.MyFormat.Name : "";
|
|
FromFolderName = fi.Name;
|
|
XmlElement xe = xd.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "folderid", fi.FolderID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "parentid", fi.ParentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "dbid", fi.DBID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "name", fi.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "title", fi.Title));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "shortname", fi.ShortName));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "formatid", fi.FormatID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "manualorder", fi.ManualOrder.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "config", fi.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "usrid", fi.UsrID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xd, "formatfilename", formatFileName));
|
|
xd.AppendChild(xe);
|
|
ExportAnnotationTypes(xe, "annotationtypes");
|
|
ExportFormats(FormatInfoList.GetFormatInfoListUsed(), xe, "formats", true);
|
|
if (fi.FolderDocVersionCount > 0)
|
|
foreach (DocVersionInfo dvi in fi.FolderDocVersions)
|
|
ExportDocVersion(xe, dvi, "docversion");
|
|
}
|
|
private void ExportFormats(FormatInfoList fil, XmlElement xn, string nodename, bool doElement)
|
|
{
|
|
XmlElement xe = null;
|
|
if (doElement) xe = xn.OwnerDocument.CreateElement(nodename);
|
|
else xe = xn;
|
|
foreach (FormatInfo fi in fil)
|
|
ExportFormat(xe, fi, "format");
|
|
if (doElement) xn.AppendChild(xe);
|
|
}
|
|
private void ExportFormat(XmlElement xn, FormatInfo fi, string nodename)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", fi.FormatID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", fi.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "pname", fi.MyParent == null ? "null" : fi.MyParent.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "description", fi.Description));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", fi.UserID));
|
|
|
|
if (fi.Config != null && fi.Config != "")
|
|
{
|
|
FormatConfig MyFormatConfig = FormatConfig.Get(fi.Config);
|
|
string scf = MyFormatConfig.ConvertToString();
|
|
scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", scf));
|
|
}
|
|
xn.AppendChild(xe);
|
|
}
|
|
private void ExportAnnotationTypes(XmlElement xn, string nodename)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
AnnotationTypeInfoList atl = AnnotationTypeInfoList.Get();
|
|
foreach (AnnotationTypeInfo ati in atl)
|
|
ExportAnnotationType(xe, ati, "annotationtype");
|
|
xn.AppendChild(xe);
|
|
}
|
|
private void ExportAnnotationType(XmlElement xn, AnnotationTypeInfo ati, string nodename)
|
|
{
|
|
/*
|
|
TypeID
|
|
Name
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typeid", ati.TypeID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", ati.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ati.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ati.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ati.UserID.ToString()));
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private void ExportFolder(FolderInfo fi, string nodename)
|
|
//{
|
|
// /*
|
|
// FolderID
|
|
// ParentID
|
|
// DBID
|
|
// Name
|
|
// Title
|
|
// ShortName
|
|
// FormatID
|
|
// ManualOrder
|
|
// Config
|
|
// DTS
|
|
// UsrID
|
|
// */
|
|
// string formatFileName = (fi.MyFormat != null) ? fi.MyFormat.Name : "";
|
|
// FromFolderName = fi.Name;
|
|
// MyWriter.WriteStartDocument();
|
|
// MyWriter.WriteStartElement(nodename);
|
|
// MyWriter.WriteAttributeString("folderid", fi.FolderID.ToString());
|
|
// MyWriter.WriteAttributeString("parentid", fi.ParentID.ToString());
|
|
// MyWriter.WriteAttributeString("dbid", fi.DBID.ToString());
|
|
// MyWriter.WriteAttributeString("name", fi.Name);
|
|
// MyWriter.WriteAttributeString("title", fi.Title);
|
|
// MyWriter.WriteAttributeString("shortname", fi.ShortName);
|
|
// MyWriter.WriteAttributeString("formatid", fi.FormatID.ToString());
|
|
// MyWriter.WriteAttributeString("manualorder", fi.ManualOrder.ToString());
|
|
// MyWriter.WriteAttributeString("config", fi.Config);
|
|
// MyWriter.WriteAttributeString("dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
// MyWriter.WriteAttributeString("usrid", fi.UsrID.ToString());
|
|
// MyWriter.WriteAttributeString("formatfilename", formatFileName);
|
|
|
|
// if (fi.FolderDocVersionCount > 0)
|
|
// foreach (DocVersionInfo dvi in fi.FolderDocVersions)
|
|
// ExportDocVersion(dvi, "docversion");
|
|
// MyWriter.WriteEndElement();
|
|
// MyWriter.WriteEndDocument();
|
|
//}
|
|
|
|
// bug fix: B2017-082 don't export if no RO Path - display an message to the user to assign a RO Path
|
|
private bool ValidDocVersionAssociation(DocVersionInfo dvi)
|
|
{
|
|
if (dvi.DocVersionAssociationCount <= 0)
|
|
{
|
|
MessageBox.Show("Assign a Referenced Object path to the Working Draft tree node before exporting.", "RO Path not assigned");
|
|
successfullExport = false;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
private void ExportDocVersion(XmlElement xn, DocVersionInfo dvi, string nodename)
|
|
{
|
|
/*
|
|
VersionID
|
|
FolderID
|
|
VersionType
|
|
Name
|
|
Title
|
|
ItemID
|
|
FormatID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
lblExportStatus.Text = "Exporting DocVersion...";
|
|
Application.DoEvents();
|
|
string formatFileName = (dvi.MyFormat != null) ? dvi.MyFormat.Name : "";
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
|
|
// B2022-072: if the exported docversion doesn't have the format set, look up folder tree to find the format used
|
|
int tmpFormatID = (dvi.FormatID != null) ? (int)dvi.FormatID : 0;
|
|
FolderInfo fi = dvi.MyFolder;
|
|
while (formatFileName == "" && fi != null)
|
|
{
|
|
if (fi.FormatID != null && fi.FormatID != 0)
|
|
{
|
|
formatFileName = (fi.MyFormat != null) ? fi.MyFormat.Name : "";
|
|
tmpFormatID = (fi.FormatID != null) ? (int)fi.FormatID : 0;
|
|
break;
|
|
}
|
|
fi = fi.MyParent;
|
|
}
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versionid", dvi.VersionID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "folderid", dvi.FolderID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versiontype", dvi.VersionType.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", dvi.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "title", dvi.Title));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", dvi.ItemID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", tmpFormatID.ToString()));//dvi.FormatID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", dvi.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", dvi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", dvi.UserID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatfilename", formatFileName));
|
|
xn.AppendChild(xe);
|
|
if (!ValidDocVersionAssociation(dvi)) return; // bug fix: B2017-082 don't export if no RO Path
|
|
|
|
if (dvi.DocVersionAssociationCount > 0)
|
|
foreach (AssociationInfo ai in dvi.DocVersionAssociations)
|
|
ExportAssociation(xe, ai, "association");
|
|
string fn = PEIPath + @"\folder.xml";
|
|
xn.OwnerDocument.Save(fn);
|
|
MyExpxZipFile.AddFile(fn, "folder");
|
|
MyExpxZipFile.Save();
|
|
File.Delete(fn);
|
|
//here
|
|
lblExportStatus.Text = "Exporting Procedures...";
|
|
Application.DoEvents();
|
|
if (dvi.Procedures.Count > 0)
|
|
{
|
|
pbExportProcedure.Value = 0;
|
|
pbExportProcedure.Maximum = dvi.Procedures.Count;
|
|
lblExportProcedure.Text = pbExportProcedure.Maximum.ToString() + " Procedures";
|
|
foreach (ItemInfo ii in dvi.Procedures)
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
ExportItem(xd, ii, "procedure");
|
|
fn = string.Format(@"{0}\proc{1}.xml", PEIPath, pbExportProcedure.Value.ToString().PadLeft(4, '0'));
|
|
xd.Save(fn);
|
|
MyExpxZipFile.AddFile(fn, "procedures");
|
|
MyExpxZipFile.Save();
|
|
File.Delete(fn);
|
|
xd = null;
|
|
}
|
|
}
|
|
}
|
|
private void ExportDocVersion(DocVersionInfo dvi, string nodename)
|
|
{
|
|
/*
|
|
VersionID
|
|
FolderID
|
|
VersionType
|
|
Name
|
|
Title
|
|
ItemID
|
|
FormatID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
string formatFileName = (dvi.MyFormat != null) ? dvi.MyFormat.Name : "";
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("versionid", dvi.VersionID.ToString());
|
|
MyWriter.WriteAttributeString("folderid", dvi.FolderID.ToString());
|
|
MyWriter.WriteAttributeString("versiontype", dvi.VersionType.ToString());
|
|
MyWriter.WriteAttributeString("name", dvi.Name);
|
|
MyWriter.WriteAttributeString("title", dvi.Title);
|
|
MyWriter.WriteAttributeString("itemid", dvi.ItemID.ToString());
|
|
MyWriter.WriteAttributeString("formatid", dvi.FormatID.ToString());
|
|
MyWriter.WriteAttributeString("config", dvi.Config);
|
|
MyWriter.WriteAttributeString("dts", dvi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", dvi.UserID.ToString());
|
|
MyWriter.WriteAttributeString("formatfilename", formatFileName);
|
|
if (dvi.DocVersionAssociationCount > 0)
|
|
foreach (AssociationInfo ai in dvi.DocVersionAssociations)
|
|
ExportAssociation(ai, "association");
|
|
if (dvi.Procedures.Count > 0)
|
|
{
|
|
pbExportProcedure.Value = 0;
|
|
pbExportProcedure.Maximum = dvi.Procedures.Count;
|
|
lblExportProcedure.Text = pbExportProcedure.Maximum.ToString() + " Procedures";
|
|
foreach (ItemInfo ii in dvi.Procedures)
|
|
{
|
|
ExportItem(ii, "procedure");
|
|
}
|
|
}
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
private void ExportAssociation(XmlElement xn, AssociationInfo ai, string nodename)
|
|
{
|
|
/*
|
|
AssociationID
|
|
VersionID
|
|
ROFstID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
lblExportStatus.Text = "Exporting Association...";
|
|
Application.DoEvents();
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "associationid", ai.AssociationID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versionid", ai.VersionID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", ai.ROFstID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ai.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ai.UserID.ToString()));
|
|
xn.AppendChild(xe);
|
|
ExportROFst(xe, ai.MyROFst, "rofst");
|
|
}
|
|
private void ExportAssociation(AssociationInfo ai, string nodename)
|
|
{
|
|
/*
|
|
AssociationID
|
|
VersionID
|
|
ROFstID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("associationid", ai.AssociationID.ToString());
|
|
MyWriter.WriteAttributeString("versionid", ai.VersionID.ToString());
|
|
MyWriter.WriteAttributeString("rofstid", ai.ROFstID.ToString());
|
|
MyWriter.WriteAttributeString("config", ai.Config);
|
|
MyWriter.WriteAttributeString("dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ai.UserID.ToString());
|
|
ExportROFst(ai.MyROFst, "rofst");
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportROFst(XmlElement xn, ROFstInfo fst, string nodename)
|
|
{
|
|
/*
|
|
ROFstID
|
|
RODbID
|
|
ROLookup
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
lblExportStatus.Text = "Exporting ROFst...";
|
|
Application.DoEvents();
|
|
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", fst.ROFstID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", fst.RODbID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rolookup", Convert.ToBase64String(ROFSTLookup.GetRofstLookupBytes(fst.ROFstID)))); // B2022-026 RO Memory reduction - new calls
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", fst.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", fst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", fst.UserID.ToString()));
|
|
xn.AppendChild(xe);
|
|
|
|
ExportFigures(xe, fst);
|
|
ExportRODb(xe, fst.MyRODb, "rodb");
|
|
}
|
|
|
|
private void ExportROFst(ROFstInfo fst, string nodename)
|
|
{
|
|
/*
|
|
ROFstID
|
|
RODbID
|
|
ROLookup
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("rofstid", fst.ROFstID.ToString());
|
|
MyWriter.WriteAttributeString("rodbid", fst.RODbID.ToString());
|
|
MyWriter.WriteAttributeString("rolookup", Convert.ToBase64String(ROFSTLookup.GetRofstLookupBytes(fst.ROFstID))); // B2022-026 RO Memory reduction - new calls
|
|
MyWriter.WriteAttributeString("config", fst.Config);
|
|
MyWriter.WriteAttributeString("dts", fst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", fst.UserID.ToString());
|
|
|
|
ExportRODb(fst.MyRODb, "rodb");
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportFigures(XmlElement xn, ROFstInfo fst)
|
|
{
|
|
if (fst.ROFstFigureCount > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("figures");
|
|
xn.AppendChild(xe);
|
|
|
|
foreach (FigureInfo figure in fst.ROFstFigures)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("figure");
|
|
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "figureid", figure.FigureID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "rofstid", figure.ROFstID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "imageid", figure.ImageID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", figure.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", figure.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", figure.UserID));
|
|
xe.AppendChild(xee);
|
|
|
|
// B2018-031 Output figure names as they are exported to provide more constant feedback
|
|
lblExportStatus.Text = string.Format("Exporting Figure...{0}", figure.MyROImage.FileName);
|
|
Application.DoEvents();
|
|
|
|
ExportROImage(xee, figure.MyROImage);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportROImage(XmlElement xn, ROImageInfo image)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("image");
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "imageid", image.ImageID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", image.RODbID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "filename", image.FileName));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "content", Convert.ToBase64String(image.Content)));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", image.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", image.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", image.UserID));
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportRODb(XmlElement xn, RODbInfo db, string nodename)
|
|
{
|
|
/*
|
|
RODbID
|
|
ROName
|
|
FolderPath
|
|
DBConnectionString
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
lblExportStatus.Text = "Exporting RODb...";
|
|
Application.DoEvents();
|
|
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", db.RODbID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "roname", db.ROName));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "folderpath", db.FolderPath));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dbconnectionstring", db.DBConnectionString));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", db.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", db.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", db.UserID.ToString()));
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportRODb(RODbInfo db, string nodename)
|
|
{
|
|
/*
|
|
RODbID
|
|
ROName
|
|
FolderPath
|
|
DBConnectionString
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("rodbid", db.RODbID.ToString());
|
|
MyWriter.WriteAttributeString("roname", db.ROName);
|
|
MyWriter.WriteAttributeString("folderpath", db.FolderPath);
|
|
MyWriter.WriteAttributeString("dbconnectionstring", db.DBConnectionString);
|
|
MyWriter.WriteAttributeString("config", db.Config);
|
|
MyWriter.WriteAttributeString("dts", db.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", db.UserID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
public void ExportItem(XmlDocument xd, ItemInfo ii, string nodename)
|
|
{
|
|
XmlElement xe = xd.CreateElement(nodename);
|
|
if (ii.IsProcedure)
|
|
{
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.RODbID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofolderpath", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.ROFstID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstdts", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
}
|
|
xd.AppendChild(xe);
|
|
ExportItem(xe, ii, nodename);
|
|
}
|
|
|
|
private void ExportItem(XmlElement xn, ItemInfo ii, string nodename)
|
|
{
|
|
/*
|
|
ItemID
|
|
PreviousID
|
|
ContentID
|
|
DTS
|
|
*/
|
|
XmlElement xe = null;
|
|
if (xn.Name == "procedure")
|
|
xe = xn;
|
|
else
|
|
{
|
|
xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
if (ii.IsProcedure)
|
|
{
|
|
pbExportProcedure.PerformStep();
|
|
lblExportProcedure.Text = string.Format("{0} of {1} Procedures", pbExportProcedure.Value.ToString(), pbExportProcedure.Maximum.ToString());
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblExportTime.Text = "Elapsed Time: " + elapsed.ToString();
|
|
Application.DoEvents();
|
|
|
|
pbExportSection.Value = 0;
|
|
pbExportSection.Maximum = pbExportSection.Value;
|
|
pbExportStep.Value = 0;
|
|
pbExportStep.Maximum = pbExportStep.Value;
|
|
|
|
if (ii.Sections != null)
|
|
pbExportSection.Maximum = ii.Sections.Count;
|
|
else
|
|
{
|
|
pbExportSection.Maximum = 1;
|
|
pbExportSection.PerformStep();
|
|
pbExportStep.Maximum = 1;
|
|
pbExportStep.PerformStep();
|
|
lblExportSection.Text = "Sections";
|
|
lblExportStep.Text = "Steps";
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
if (ii.IsSection && ii.ActiveParent.IsProcedure)
|
|
{
|
|
pbExportSection.PerformStep();
|
|
lblExportSection.Text = string.Format("{0} of {1} Sections", pbExportSection.Value.ToString(), pbExportSection.Maximum.ToString());
|
|
Application.DoEvents();
|
|
pbExportStep.Value = 0;
|
|
pbExportStep.Maximum = pbExportStep.Value;
|
|
|
|
if (ii.Steps != null)
|
|
pbExportStep.Maximum = ii.Steps.Count;
|
|
else
|
|
{
|
|
pbExportStep.Maximum = 1;
|
|
pbExportStep.PerformStep();
|
|
lblExportStep.Text = "Word Section Data";
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
if (ii.IsStep && ii.ActiveParent.IsSection && ii.ActiveParent.ActiveParent.IsProcedure)
|
|
{
|
|
pbExportStep.PerformStep();
|
|
lblExportStep.Text = string.Format("{0} of {1} Steps", pbExportStep.Value.ToString(), pbExportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
}
|
|
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", ii.ItemID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "previousid", ii.PreviousID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ii.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
|
|
//item audits
|
|
ExportItemAudits(xe, ii);
|
|
ExportContent(xe, ii.MyContent, "content");
|
|
|
|
if (ii.ItemAnnotationCount > 0)
|
|
foreach (AnnotationInfo ai in ii.ItemAnnotations)
|
|
ExportAnnotation(xe, ai, "annotation");
|
|
}
|
|
|
|
private void ExportItemAudits(XmlElement xn, ItemInfo ii)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
ItemAuditInfoList audits = ItemAuditInfoList.Get(ii.ItemID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (ItemAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "previousid", audit.PreviousID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
|
|
xn.AppendChild(xe);
|
|
}
|
|
}
|
|
}
|
|
|
|
// used to save word sections with resolved ROs (export generated from Approve)
|
|
private Dictionary<int, byte[]> _DocReplace;
|
|
public Dictionary<int, byte[]> DocReplace
|
|
{
|
|
get { return _DocReplace; }
|
|
set
|
|
{
|
|
_DocReplace = value;
|
|
_ConvertROsAndTransitionsToText = (value != null);
|
|
}
|
|
}
|
|
|
|
private void ExportItem(ItemInfo ii, string nodename)
|
|
{
|
|
/*
|
|
ItemID
|
|
PreviousID
|
|
ContentID
|
|
DTS
|
|
*/
|
|
if (ii.IsProcedure)
|
|
{
|
|
pbExportProcedure.PerformStep();
|
|
lblExportProcedure.Text = string.Format("{0} of {1} Procedures", pbExportProcedure.Value.ToString(), pbExportProcedure.Maximum.ToString());
|
|
Application.DoEvents();
|
|
|
|
pbExportSection.Value = 0;
|
|
pbExportStep.Value = 0;
|
|
pbExportSection.Maximum = ii.Sections.Count;
|
|
|
|
if (ii.Sections != null)
|
|
pbExportSection.Maximum = ii.Sections.Count;
|
|
else
|
|
{
|
|
pbExportSection.Maximum = 1;
|
|
pbExportSection.PerformStep();
|
|
pbExportStep.Maximum = 1;
|
|
pbExportStep.PerformStep();
|
|
lblExportSection.Text = "Sections";
|
|
lblExportStep.Text = "Steps";
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
if (ii.IsSection)
|
|
{
|
|
pbExportSection.PerformStep();
|
|
lblExportSection.Text = string.Format("{0} of {1} Sections", pbExportSection.Value.ToString(), pbExportSection.Maximum.ToString());
|
|
Application.DoEvents();
|
|
pbExportStep.Value = 0;
|
|
if (ii.Steps != null)
|
|
pbExportStep.Maximum = ii.Steps.Count;
|
|
else
|
|
{
|
|
pbExportStep.Maximum = 1;
|
|
pbExportStep.PerformStep();
|
|
lblExportStep.Text = "Word Section Data";
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
if (ii.IsStep)
|
|
{
|
|
pbExportStep.PerformStep();
|
|
lblExportStep.Text = string.Format("{0} of {1} Steps", pbExportStep.Value.ToString(), pbExportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
}
|
|
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("itemid", ii.ItemID.ToString());
|
|
MyWriter.WriteAttributeString("previousid", ii.PreviousID.ToString());
|
|
MyWriter.WriteAttributeString("contentid", ii.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
|
|
ExportContent(ii.MyContent, "content");
|
|
if (ii.ItemAnnotationCount > 0)
|
|
foreach (AnnotationInfo ai in ii.ItemAnnotations)
|
|
ExportAnnotation(ai, "annotation");
|
|
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportContent(XmlElement xn, ContentInfo ci, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
Number
|
|
Text
|
|
Type
|
|
FormatID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
// strip the link information if we are convertingthe RO and Transitions to text
|
|
string ciText = (_ConvertROsAndTransitionsToText) ? ItemInfo.StripLinks(ci.Text) : ci.Text;
|
|
string formatFileName = (ci.MyFormat != null) ? ci.MyFormat.Name : "";
|
|
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ci.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "number", ci.Number));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "text", ciText));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "type", ci.Type.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", ci.FormatID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ci.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ci.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ci.UserID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatfilename", formatFileName));
|
|
|
|
//content audits
|
|
ExportContentAudits(xe, ci);
|
|
xn.AppendChild(xe);
|
|
|
|
if (ci.ContentTransitionCount > 0)
|
|
foreach (TransitionInfo ti in ci.ContentTransitions)
|
|
ExportTransition(xe, ti, "transition");
|
|
|
|
if (ci.ContentRoUsageCount > 0)
|
|
foreach (RoUsageInfo ri in ci.ContentRoUsages)
|
|
ExportROUsage(xe, ri, "rousage");
|
|
|
|
if (ci.ContentEntryCount > 0)
|
|
ExportEntry(xe, ci.MyEntry, "entry");
|
|
|
|
if (ci.ContentGridCount > 0)
|
|
ExportGrid(xe, ci.MyGrid, "grid");
|
|
|
|
if (ci.ContentImageCount > 0)
|
|
ExportImage(xe, ci.MyImage, "image");
|
|
|
|
if (ci.ContentPartCount > 0)
|
|
foreach (PartInfo pi in ci.ContentParts)
|
|
ExportPart(xe, pi, ((E_FromTypes)pi.FromType).ToString().ToLower());
|
|
}
|
|
|
|
private void ExportContentAudits(XmlElement xn, ContentInfo ci)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
ContentAuditInfoList audits = ContentAuditInfoList.Get(ci.ContentID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (ContentAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "number", audit.Number));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "text", audit.Text));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "type", audit.Type.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "formatid", audit.FormatID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "actiondts", audit.ActionWhen.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportContent(ContentInfo ci, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
Number
|
|
Text
|
|
Type
|
|
FormatID
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
// strip the link information if we are convertinga the ROs and Transitions to text
|
|
string ciText = (_ConvertROsAndTransitionsToText) ? ItemInfo.StripLinks(ci.Text) : ci.Text;
|
|
string formatFileName = (ci.MyFormat != null) ? ci.MyFormat.Name : "";
|
|
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("contentid", ci.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("number", ci.Number);
|
|
MyWriter.WriteAttributeString("text", ciText);
|
|
MyWriter.WriteAttributeString("type", ci.Type.ToString());
|
|
MyWriter.WriteAttributeString("formatid", ci.FormatID.ToString());
|
|
MyWriter.WriteAttributeString("config", ci.Config);
|
|
MyWriter.WriteAttributeString("dts", ci.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ci.UserID.ToString());
|
|
MyWriter.WriteAttributeString("formatfilename", formatFileName);
|
|
|
|
if (ci.ContentTransitionCount > 0)
|
|
foreach (TransitionInfo ti in ci.ContentTransitions)
|
|
ExportTransition(ti, "transition");
|
|
|
|
if (ci.ContentRoUsageCount > 0)
|
|
foreach (RoUsageInfo ri in ci.ContentRoUsages)
|
|
ExportROUsage(ri, "rousage");
|
|
|
|
if (ci.ContentEntryCount > 0)
|
|
ExportEntry(ci.MyEntry, "entry");
|
|
|
|
if (ci.ContentGridCount > 0)
|
|
ExportGrid(ci.MyGrid, "grid");
|
|
|
|
if (ci.ContentImageCount > 0)
|
|
ExportImage(ci.MyImage, "image");
|
|
|
|
if (ci.ContentPartCount > 0)
|
|
foreach (PartInfo pi in ci.ContentParts)
|
|
ExportPart(pi, ((E_FromTypes)pi.FromType).ToString().ToLower());
|
|
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportGrid(XmlElement xn, GridInfo gi, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
Data
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
string giData = gi.Data;
|
|
if (_ConvertROsAndTransitionsToText)
|
|
{
|
|
giData = giData.Replace("<IsRoTable>True", "<IsRoTable>False"); // converts a RO table to a unlinked regular table
|
|
giData = ItemInfo.StripLinks(giData); // this converts ROs and transitions to text
|
|
}
|
|
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", gi.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "data", giData));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", gi.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", gi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", gi.UserID.ToString()));
|
|
|
|
//grid audits
|
|
ExportGridAudits(xe, gi);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportGridAudits(XmlElement xn, GridInfo gi)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
GridAuditInfoList audits = GridAuditInfoList.Get(gi.ContentID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (GridAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "data", audit.Data));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentauditid", audit.ContentAuditID.ToString()));
|
|
xe.AppendChild(xee);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportGrid(GridInfo gi, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
Data
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
string giData = gi.Data;
|
|
if (_ConvertROsAndTransitionsToText)
|
|
{
|
|
giData = giData.Replace("IsRoTable>True", "IsRoTable>False"); // converts a RO table to regular table
|
|
giData = ItemInfo.StripLinks(giData); // converts ROs and Transitions to text
|
|
}
|
|
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("contentid", gi.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("data", giData);
|
|
MyWriter.WriteAttributeString("config", gi.Config);
|
|
MyWriter.WriteAttributeString("dts", gi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", gi.UserID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportEntry(XmlElement xn, EntryInfo ei, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
DocID
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ei.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docid", ei.DocID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ei.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ei.UserID.ToString()));
|
|
|
|
//entry audits
|
|
ExportEntryAudits(xe, ei);
|
|
xn.AppendChild(xe);
|
|
ExportDocument(xe, ei.MyDocument, "document");
|
|
}
|
|
|
|
private void ExportEntryAudits(XmlElement xn, EntryInfo ei)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
EntryAuditInfoList audits = EntryAuditInfoList.Get(ei.ContentID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (EntryAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docid", audit.DocID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportEntry(EntryInfo ei, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
DocID
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("contentid", ei.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("docid", ei.DocID.ToString());
|
|
MyWriter.WriteAttributeString("dts", ei.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ei.UserID.ToString());
|
|
ExportDocument(ei.MyDocument, "document");
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportImage(XmlElement xn, ImageInfo ii, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
ImageType
|
|
FileName
|
|
Data
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ii.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "imagetype", ii.ImageType.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "filename", ii.FileName));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "data", Convert.ToBase64String(ii.Data)));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ii.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ii.UserID.ToString()));
|
|
//image audits
|
|
ExportImageAudits(xe, ii);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportImageAudits(XmlElement xn, ImageInfo ii)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
ImageAuditInfoList audits = ImageAuditInfoList.Get(ii.ContentID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (ImageAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "imagetype", audit.ImageType.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "filename", audit.FileName));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "data", Convert.ToBase64String(audit.Data)));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportImage(ImageInfo ii, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
ImageType
|
|
FileName
|
|
Data
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("contentid", ii.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("imagetype", ii.ImageType.ToString());
|
|
MyWriter.WriteAttributeString("filename", ii.FileName);
|
|
MyWriter.WriteAttributeString("data", Convert.ToBase64String(ii.Data));
|
|
MyWriter.WriteAttributeString("config", ii.Config);
|
|
MyWriter.WriteAttributeString("dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ii.UserID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportDocument(XmlElement xn, DocumentInfo di, string nodename)
|
|
{
|
|
/*
|
|
DocID
|
|
LibTitle
|
|
DocContent
|
|
DocAscii
|
|
Config
|
|
DTS
|
|
UserID
|
|
FileExtension
|
|
*/
|
|
byte[] buf = di.DocContent;
|
|
string libDocTitle = di.LibTitle;
|
|
if (DocReplace != null && DocReplace.ContainsKey(di.DocID) && _ConvertROsAndTransitionsToText)
|
|
{
|
|
buf = DocReplace[di.DocID];
|
|
libDocTitle = null; // unlink the word section from the library document
|
|
}
|
|
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docid", di.DocID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "libtitle", libDocTitle)); // di.LibTitle));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "doccontent", Convert.ToBase64String(buf)));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docascii", di.DocAscii));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", di.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", di.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", di.UserID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fileextension", di.FileExtension));
|
|
|
|
//document audits
|
|
ExportDocumentAudits(xe, di);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportDocumentAudits(XmlElement xn, DocumentInfo di)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
DocumentAuditInfoList audits = DocumentAuditInfoList.Get(di.DocID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (DocumentAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docid", audit.DocID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "libtitle", audit.LibTitle));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "doccontent", Convert.ToBase64String(audit.DocContent)));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docascii", audit.DocAscii));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "fileextension", audit.FileExtension));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void ExportDocument(DocumentInfo di, string nodename)
|
|
{
|
|
/*
|
|
DocID
|
|
LibTitle
|
|
DocContent
|
|
DocAscii
|
|
Config
|
|
DTS
|
|
UserID
|
|
FileExtension
|
|
*/
|
|
byte[] buf = di.DocContent;
|
|
string libDocTitle = di.LibTitle;
|
|
if (DocReplace != null && DocReplace.ContainsKey(di.DocID) && _ConvertROsAndTransitionsToText)
|
|
{
|
|
buf = DocReplace[di.DocID];
|
|
libDocTitle = null; // unlink the word section from the library document
|
|
}
|
|
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("docid", di.DocID.ToString());
|
|
MyWriter.WriteAttributeString("libtitle", libDocTitle);// di.LibTitle);
|
|
MyWriter.WriteAttributeString("doccontent", Convert.ToBase64String(buf));
|
|
MyWriter.WriteAttributeString("docascii", di.DocAscii);
|
|
MyWriter.WriteAttributeString("config", di.Config);
|
|
MyWriter.WriteAttributeString("dts", di.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", di.UserID.ToString());
|
|
MyWriter.WriteAttributeString("fileextension", di.FileExtension);
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportROUsage(XmlElement xn, RoUsageInfo ri, string nodename)
|
|
{
|
|
/*
|
|
ROUsageID
|
|
ContentID
|
|
ROID
|
|
Config
|
|
DTS
|
|
UserID
|
|
RODbID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rousageid", ri.ROUsageID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ri.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "roid", ri.ROID));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ri.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ri.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ri.UserID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", ri.RODbID.ToString()));
|
|
|
|
//rousage audits
|
|
ExportROUsageAudits(xe, ri);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportROUsageAudits(XmlElement xe, RoUsageInfo ri)
|
|
{
|
|
if (cbxExportAudits.Checked) { };
|
|
}
|
|
|
|
private void ExportROUsage(RoUsageInfo ri, string nodename)
|
|
{
|
|
/*
|
|
ROUsageID
|
|
ContentID
|
|
ROID
|
|
Config
|
|
DTS
|
|
UserID
|
|
RODbID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("rousageid", ri.ROUsageID.ToString());
|
|
MyWriter.WriteAttributeString("contentid", ri.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("roid", ri.ROID);
|
|
MyWriter.WriteAttributeString("config", ri.Config);
|
|
MyWriter.WriteAttributeString("dts", ri.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ri.UserID.ToString());
|
|
MyWriter.WriteAttributeString("rodbid", ri.RODbID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportPart(XmlElement xn, PartInfo pi, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
FromType
|
|
ItemID
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", pi.ContentID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fromtype", pi.FromType.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", pi.ItemID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", pi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", pi.UserID.ToString()));
|
|
|
|
//part audits
|
|
ExportPartAudits(xe, pi);
|
|
xn.AppendChild(xe);
|
|
foreach (ItemInfo ii in pi.MyItems)
|
|
ExportItem(xe, ii, pi.PartType.ToString().ToLower());
|
|
}
|
|
|
|
private void ExportPartAudits(XmlElement xn, PartInfo pi)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
PartAuditInfoList audits = PartAuditInfoList.Get(pi.ContentID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (PartAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "fromtype", audit.FromType.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportPart(PartInfo pi, string nodename)
|
|
{
|
|
/*
|
|
ContentID
|
|
FromType
|
|
ItemID
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("contentid", pi.ContentID.ToString());
|
|
MyWriter.WriteAttributeString("fromtype", pi.FromType.ToString());
|
|
MyWriter.WriteAttributeString("itemid", pi.ItemID.ToString());
|
|
MyWriter.WriteAttributeString("dts", pi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", pi.UserID.ToString());
|
|
foreach (ItemInfo ii in pi.MyItems)
|
|
ExportItem(ii, pi.PartType.ToString().ToLower());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportTransition(XmlElement xn, TransitionInfo ti, string nodename)
|
|
{
|
|
/*
|
|
TransitionID
|
|
FromID
|
|
ToID
|
|
RangeID
|
|
IsRange
|
|
TranType
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "transitionid", ti.TransitionID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fromid", ti.FromID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "toid", ti.ToID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rangeid", ti.RangeID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "isrange", ti.IsRange.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "trantype", ti.TranType.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ti.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ti.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ti.UserID.ToString()));
|
|
|
|
//transition audits
|
|
ExportTransitionAudits(xe, ti);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportTransitionAudits(XmlElement xe, TransitionInfo ti)
|
|
{
|
|
if (cbxExportAudits.Checked) { };
|
|
}
|
|
|
|
private void ExportTransition(TransitionInfo ti, string nodename)
|
|
{
|
|
/*
|
|
TransitionID
|
|
FromID
|
|
ToID
|
|
RangeID
|
|
IsRange
|
|
TranType
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
string folder = string.Empty;
|
|
if (ti.MyItemToID.MyDocVersion != null && ti.MyItemToID.MyDocVersion.MyFolder.Name != MyFolder.Name)
|
|
{
|
|
nodename = "external" + nodename;
|
|
folder = ti.MyItemToID.MyDocVersion.MyFolder.Name;
|
|
}
|
|
else
|
|
{
|
|
nodename = "external" + nodename;
|
|
folder = "UNKNOWN";
|
|
}
|
|
|
|
MyWriter.WriteStartElement(nodename);
|
|
|
|
if (folder != string.Empty)
|
|
MyWriter.WriteAttributeString("folder", folder);
|
|
|
|
MyWriter.WriteAttributeString("transitionid", ti.TransitionID.ToString());
|
|
MyWriter.WriteAttributeString("fromid", ti.FromID.ToString());
|
|
MyWriter.WriteAttributeString("toid", ti.ToID.ToString());
|
|
MyWriter.WriteAttributeString("rangeid", ti.RangeID.ToString());
|
|
MyWriter.WriteAttributeString("isrange", ti.IsRange.ToString());
|
|
MyWriter.WriteAttributeString("trantype", ti.TranType.ToString());
|
|
MyWriter.WriteAttributeString("config", ti.Config);
|
|
MyWriter.WriteAttributeString("dts", ti.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ti.UserID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
private void ExportAnnotation(XmlElement xn, AnnotationInfo ai, string nodename)
|
|
{
|
|
/*
|
|
AnnotationID
|
|
ItemID
|
|
TypeID
|
|
RtfText
|
|
SearchText
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "annotationid", ai.AnnotationID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", ai.ItemID.ToString()));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typeid", ai.TypeID.ToString()));
|
|
//if(ai.TypeID > 6)
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typename", ai.MyAnnotationType.Name));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rtftext", ai.RtfText));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "searchtext", ai.SearchText));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ai.Config));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ai.UserID.ToString()));
|
|
//annotation audits
|
|
ExportAnnotationAudits(xe, ai);
|
|
xn.AppendChild(xe);
|
|
}
|
|
|
|
private void ExportAnnotationAudits(XmlElement xn, AnnotationInfo ai)
|
|
{
|
|
if (cbxExportAudits.Checked)
|
|
{
|
|
AnnotationAuditInfoList audits = AnnotationAuditInfoList.GetByAnnotationID(ai.AnnotationID);
|
|
|
|
if (audits.Count > 0)
|
|
{
|
|
XmlElement xe = xn.OwnerDocument.CreateElement("audits");
|
|
|
|
foreach (AnnotationAuditInfo audit in audits)
|
|
{
|
|
if (audit.DeleteStatus == 0)
|
|
{
|
|
XmlElement xee = xn.OwnerDocument.CreateElement("audit");
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "annotationid", audit.AnnotationID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "typeid", audit.TypeID.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "rtftext", audit.RtfText));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "searchtext", audit.SearchText));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
|
|
xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "actiondts", audit.ActionWhen.ToString("MM/dd/yyyy HH:mm:ss.fff")));
|
|
xe.AppendChild(xee);
|
|
}
|
|
}
|
|
xn.AppendChild(xe);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExportAnnotation(AnnotationInfo ai, string nodename)
|
|
{
|
|
/*
|
|
AnnotationID
|
|
ItemID
|
|
TypeID
|
|
RtfText
|
|
SearchText
|
|
Config
|
|
DTS
|
|
UserID
|
|
*/
|
|
MyWriter.WriteStartElement(nodename);
|
|
MyWriter.WriteAttributeString("annotationid", ai.AnnotationID.ToString());
|
|
MyWriter.WriteAttributeString("itemid", ai.ItemID.ToString());
|
|
MyWriter.WriteAttributeString("typeid", ai.TypeID.ToString());
|
|
MyWriter.WriteAttributeString("rtftext", ai.RtfText);
|
|
MyWriter.WriteAttributeString("searchtext", ai.SearchText);
|
|
MyWriter.WriteAttributeString("config", ai.Config);
|
|
MyWriter.WriteAttributeString("dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
|
|
MyWriter.WriteAttributeString("userid", ai.UserID.ToString());
|
|
MyWriter.WriteEndElement();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Import for Merge
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private void AddExternalTransition(XmlReader xr, XmlDocument xd)
|
|
//{
|
|
// XmlElement xe = xd.CreateElement("transition");
|
|
// XmlAttribute xa = AddAttribute(xd, "folder", xr.GetAttribute("folder"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "transitionid", xr.GetAttribute("transitionid"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "fromid", xr.GetAttribute("fromid"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "toid", xr.GetAttribute("toid"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "rangeid", xr.GetAttribute("rangeid"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "isrange", xr.GetAttribute("isrange"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "trantype", xr.GetAttribute("trantype"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "config", xr.GetAttribute("config"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "userid", xr.GetAttribute("userid"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xa = AddAttribute(xd, "dts", xr.GetAttribute("dts"));
|
|
// xe.Attributes.SetNamedItem(xa);
|
|
// xd.SelectSingleNode("externaltransitions/transitions").AppendChild(xe);
|
|
//}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private void AddTransitions(XmlReader xr)
|
|
//{
|
|
// int transitionid = int.Parse(xr.GetAttribute("transitionid"));
|
|
// int fromid = int.Parse(xr.GetAttribute("fromid"));
|
|
// int toid = int.Parse(xr.GetAttribute("toid"));
|
|
// int rangeid = int.Parse(xr.GetAttribute("rangeid"));
|
|
// int isrange = int.Parse(xr.GetAttribute("isrange"));
|
|
// int trantype = int.Parse(xr.GetAttribute("trantype"));
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// string lookfor;
|
|
// if (isrange == 0)
|
|
// lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
// else
|
|
// lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
// fromid = Old2NewContent[fromid];
|
|
// toid = Old2NewItem[toid];
|
|
// rangeid = Old2NewItem[rangeid];
|
|
// Content cc = Content.Get(fromid);
|
|
// Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
|
|
// transitionid = tt.TransitionID;
|
|
// string replacewith;
|
|
// if (isrange == 0)
|
|
// replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
// else
|
|
// replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
// cc.Text = cc.Text.Replace(lookfor, replacewith);
|
|
// cc.Save();
|
|
//}
|
|
|
|
private bool _DidProcessTransitions = false; // B2017-076 keep track whether we procrocessed Transitions
|
|
|
|
private void AddTransitions(Content content, XmlNode xn)
|
|
{
|
|
/*
|
|
Content
|
|
Item
|
|
Item
|
|
int
|
|
int
|
|
string
|
|
dts
|
|
string
|
|
<transition transitionid="1" fromid="186" toid="175" rangeid="177" isrange="1" trantype="2" config="" dts="4/11/1997 1:20:00 PM" userid="MH" />
|
|
|
|
#Link:Transition:1 2 187
|
|
type,id,toid
|
|
|
|
#Link:TransitionRange:2 1 175 177
|
|
type,id,toid,rangeid
|
|
*/
|
|
XmlNodeList nl = xn.SelectNodes("./transition");
|
|
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
|
|
int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);
|
|
|
|
if (Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid))
|
|
{
|
|
int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
|
|
int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
|
|
int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
string lookfor;
|
|
|
|
if (isrange == 0)
|
|
lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
//fromid = content.ContentID;
|
|
toid = Old2NewItem[toid];
|
|
rangeid = Old2NewItem[rangeid];
|
|
Transition tt = Transition.MakeTransition(content, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
|
|
transitionid = tt.TransitionID;
|
|
string replacewith;
|
|
|
|
if (isrange == 0)
|
|
replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
content.Text = content.Text.Replace(lookfor, replacewith);
|
|
|
|
if (content.MyGrid != null && content.MyGrid.Data != "")
|
|
{
|
|
content.MyGrid.Data = content.MyGrid.Data.Replace(lookfor, replacewith);
|
|
}
|
|
|
|
_DidProcessTransitions |= content.FixTransitionText(TransitionInfo.Get(tt.TransitionID)); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
|
|
// B2017=003 make sure any grid changes are saved.
|
|
// done here because FixTransitionText() could update the transitions in the grid
|
|
if (content.MyGrid != null && content.MyGrid.Data != "")
|
|
content.MyGrid.Save();
|
|
|
|
content.Save();
|
|
}
|
|
else
|
|
{
|
|
PendingTransitions.DocumentElement.AppendChild(PendingTransitions.ImportNode(nd, true));
|
|
//save to holding pen
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddTransitions()
|
|
{
|
|
AddTransitions(PendingTransitions);
|
|
}
|
|
|
|
private void AddTransitions(XmlDocument xd)
|
|
{
|
|
/*
|
|
Content
|
|
Item
|
|
Item
|
|
int
|
|
int
|
|
string
|
|
dts
|
|
string
|
|
<transition transitionid="1" fromid="186" toid="175" rangeid="177" isrange="1" trantype="2" config="" dts="4/11/1997 1:20:00 PM" userid="MH" />
|
|
|
|
#Link:Transition:1 2 187
|
|
type,id,toid
|
|
|
|
#Link:TransitionRange:2 1 175 177
|
|
type,id,toid,rangeid
|
|
*/
|
|
XmlNodeList nl = xd.SelectNodes("//transition");
|
|
lblImportStatus.Text = string.Format("Updating {0} Tranistions", nl.Count.ToString());
|
|
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
int fromid = int.Parse(nd.Attributes.GetNamedItem("fromid").InnerText);
|
|
int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
|
|
int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);
|
|
int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
|
|
if (Old2NewContent.ContainsKey(fromid)) //transition from new contentid
|
|
{
|
|
if (Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid)) //transition to new itemid (internal)
|
|
{
|
|
int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
|
|
int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
string lookfor;
|
|
|
|
if (isrange == 0)
|
|
lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
fromid = Old2NewContent[fromid];
|
|
toid = Old2NewItem[toid];
|
|
rangeid = Old2NewItem[rangeid];
|
|
Content cc = Content.Get(fromid);
|
|
Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
|
|
transitionid = tt.TransitionID;
|
|
string replacewith;
|
|
|
|
if (isrange == 0)
|
|
replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
cc.Text = cc.Text.Replace(lookfor, replacewith);
|
|
|
|
if (cc.MyGrid != null && !string.IsNullOrEmpty(cc.MyGrid.Data))
|
|
{
|
|
cc.MyGrid.Data = cc.MyGrid.Data.Replace(lookfor, replacewith);
|
|
}
|
|
|
|
bool forceConvertToText = false;
|
|
if (TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection != null)
|
|
{
|
|
SectionConfig sc = TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection.MyConfig as SectionConfig;
|
|
// Bug fix B2016-081 also check if transition is to a step element
|
|
// This was found when fixing B2018-002 but it actually applies to B2016-081
|
|
forceConvertToText = (sc.SubSection_Edit == "N" && TransitionInfo.Get(tt.TransitionID).MyItemToID.IsStep);
|
|
}
|
|
|
|
_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
|
|
// B2017=003 make sure any grid changes are saved.
|
|
// done here because FixTransitionText() could update the transitions in the grid
|
|
if (cc.MyGrid != null && cc.MyGrid.Data != "")
|
|
cc.MyGrid.Save();
|
|
cc.Save();
|
|
nd.InnerText = "done";
|
|
}
|
|
else //transition to existing itemid (external)
|
|
{
|
|
bool forceConvertToText = false;
|
|
int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
|
|
int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
string lookfor;
|
|
|
|
if (isrange == 0)
|
|
lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
fromid = Old2NewContent[fromid];
|
|
Content cc = Content.Get(fromid);
|
|
Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
|
|
|
|
if (tt.TransitionID < 0)
|
|
{
|
|
forceConvertToText = true;
|
|
_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
|
|
cc.Save();
|
|
nd.InnerText = "done";
|
|
}
|
|
else
|
|
{
|
|
transitionid = tt.TransitionID;
|
|
string replacewith;
|
|
|
|
if (isrange == 0)
|
|
replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
|
|
else
|
|
replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
|
|
|
|
cc.Text = cc.Text.Replace(lookfor, replacewith);
|
|
|
|
if (cc.MyGrid != null && !string.IsNullOrEmpty(cc.MyGrid.Data))
|
|
{
|
|
cc.MyGrid.Data = cc.MyGrid.Data.Replace(lookfor, replacewith);
|
|
}
|
|
|
|
// B2016-176, B2016-197 - external transitions should be converted to text
|
|
forceConvertToText = true;
|
|
//if (TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection != null)
|
|
//{
|
|
// SectionConfig sc = TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection.MyConfig as SectionConfig;
|
|
// forceConvertToText = (sc.SubSection_Edit == "N");
|
|
//}
|
|
//if (!forceConvertToText) //check to see if external with internal format
|
|
//{
|
|
// TransitionInfo tran = TransitionInfo.Get(transitionid);
|
|
// if (tran.MyContent.ContentItems[0].MyProcedure.ItemID != tran.MyItemToID.MyProcedure.ItemID)
|
|
// if (!tran.MyContent.ContentItems[0].ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[tran.TranType].TransMenu.Contains("Proc"))
|
|
// forceConvertToText = true;
|
|
//}
|
|
//if (!forceConvertToText) //check to see if external to different doc version
|
|
//{
|
|
// TransitionInfo tran = TransitionInfo.Get(transitionid);
|
|
// if (tran.MyContent.ContentItems[0].MyDocVersion.VersionID != tran.MyItemToID.MyDocVersion.VersionID)
|
|
// forceConvertToText = true;
|
|
//}
|
|
_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
|
|
// B2017=003 make sure any grid changes are saved.
|
|
// done here because FixTransitionText() could update the transitions in the grid
|
|
if (cc.MyGrid != null && cc.MyGrid.Data != "")
|
|
cc.MyGrid.Save();
|
|
cc.Save();
|
|
nd.InnerText = "done";
|
|
_DidConvertTransitionsToText |= (forceConvertToText && _DidProcessTransitions); // B2016-225 - notify user when transitions are converted to text
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Dictionary<int, int> Old2NewItem;
|
|
private Dictionary<int, int> Old2NewContent;
|
|
private Dictionary<int, int> Old2NewLibDoc;
|
|
private Dictionary<string, int> ExistingLibDocs; // B2019-035 better memory management
|
|
private XmlDocument PendingTransitions;
|
|
private RODb MyRODb = null;
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private Folder AddFolder(Folder folder, XmlReader xr)
|
|
//{
|
|
// Old2NewItem = new Dictionary<int, int>();
|
|
// Old2NewContent = new Dictionary<int, int>();
|
|
// Old2NewLibDoc = new Dictionary<int, int>();
|
|
// string title = xr.GetAttribute("title");
|
|
// string name = xr.GetAttribute("name");
|
|
// string shortname = xr.GetAttribute("shortname");
|
|
// string usrid = xr.GetAttribute("usrid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid),formatfilename);
|
|
// folder = Folder.MakeFolder(folder, folder.MyConnection, name, title, shortname, format, null, dts, usrid);
|
|
// //f.Save();
|
|
// return folder;
|
|
//}
|
|
|
|
private Folder AddFolder(Folder p, XmlDocument xd, string name)
|
|
{
|
|
lblImportStatus.Text = "Creating Folder...";
|
|
Application.DoEvents();
|
|
|
|
string title = xd.DocumentElement.Attributes.GetNamedItem("title").InnerText;
|
|
//string name = xd.DocumentElement.Attributes.GetNamedItem("name").InnerText;
|
|
string shortname = xd.DocumentElement.Attributes.GetNamedItem("shortname").InnerText;
|
|
string usrid = xd.DocumentElement.Attributes.GetNamedItem("usrid").InnerText;
|
|
DateTime dts = DateTime.Parse(xd.DocumentElement.Attributes.GetNamedItem("dts").InnerText);
|
|
string formatid = xd.DocumentElement.Attributes.GetNamedItem("formatid").InnerText;
|
|
XmlNode fnNode = xd.DocumentElement.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
|
|
if (Folder.GetByParentID_Name(p.FolderID, name) != null)
|
|
return null;
|
|
|
|
// B2020-053: procedure set (folder) specific info was not imported:
|
|
string config = xd.DocumentElement.Attributes.GetNamedItem("config").InnerText;
|
|
Folder f = Folder.MakeFolder(p, p.MyConnection, name, title, shortname, format, config, dts, usrid);
|
|
|
|
return f;
|
|
}
|
|
|
|
private Format OldToNewFormat(int formatID, string formatFileName)
|
|
{
|
|
try
|
|
{
|
|
string formatName = formatFileName; // B2016-103, new export files include the format filename use that if it exists
|
|
if (formatFileName == string.Empty)
|
|
{
|
|
if (formatID >= importedFormat.Count) return null; // formatID not found, use default file name
|
|
formatName = importedFormat[formatID]; // for backwards compatibility with older export files
|
|
}
|
|
if (renamedUCFFormatName != null && renamedUCFFormatName.ContainsKey(formatFileName)) formatName = renamedUCFFormatName[formatName];
|
|
formatID = existingFormat[formatName];
|
|
return Format.Get(formatID);
|
|
}
|
|
catch
|
|
{
|
|
return null; // format not found return null to use default format
|
|
}
|
|
}
|
|
|
|
private DocVersion AddDocVersion(Folder f, XmlReader xr)
|
|
{
|
|
int versiontype = int.Parse(xr.GetAttribute("versiontype"));
|
|
string name = xr.GetAttribute("name");
|
|
string config = xr.GetAttribute("config");
|
|
string userid = xr.GetAttribute("userid");
|
|
DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
string formatid = xr.GetAttribute("formatid");
|
|
string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
|
|
DocVersion dv = DocVersion.MakeDocVersion(f, versiontype, name, null, null, format, config, dts, userid);
|
|
|
|
return dv;
|
|
}
|
|
|
|
private void AddAnnotationTypes(XmlDocument xd)
|
|
{
|
|
XmlNodeList nl = xd.SelectNodes("folder/annotationtypes/annotationtype");
|
|
foreach (XmlNode nd in nl)
|
|
{
|
|
AnnotationTypeInfo ati = AnnotationTypeInfo.GetByName(nd.Attributes.GetNamedItem("name").InnerText);
|
|
if (ati == null)
|
|
AnnotationType.MakeAnnotationType(nd.Attributes.GetNamedItem("name").InnerText, nd.Attributes.GetNamedItem("config").InnerText, DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText), nd.Attributes.GetNamedItem("userid").InnerText);
|
|
}
|
|
}
|
|
|
|
private DocVersionInfo AddDocVersion(Folder f, XmlDocument xd)
|
|
{
|
|
lblImportStatus.Text = "Creating DocVersion...";
|
|
Application.DoEvents();
|
|
|
|
XmlElement xe = (XmlElement)xd.SelectSingleNode("folder/docversion");
|
|
int versiontype = int.Parse(xe.Attributes.GetNamedItem("versiontype").InnerText);
|
|
string name = xe.Attributes.GetNamedItem("name").InnerText;
|
|
string config = xe.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
string userid = xe.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xe.Attributes.GetNamedItem("dts").InnerText);
|
|
string formatid = xe.Attributes.GetNamedItem("formatid").InnerText;
|
|
XmlNode fnNode = xe.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
|
|
DocVersion dv = DocVersion.MakeDocVersion(f, versiontype, name, null, null, format, config, dts, userid);
|
|
XmlNode xassoc = xe.SelectSingleNode("association");
|
|
|
|
if (xassoc != null)
|
|
{
|
|
XmlNode xrofst = xassoc.SelectSingleNode("rofst");
|
|
XmlNode xrodb = xrofst.SelectSingleNode("rodb");
|
|
MyRODb = AddRODb(xrodb);
|
|
ROFst rofst = AddROFst(xrofst);
|
|
|
|
DocVersionAssociation dva = dv.DocVersionAssociations.Add(rofst);
|
|
|
|
dv.Save();
|
|
}
|
|
|
|
return DocVersionInfo.Get(dv.VersionID);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private Dictionary<string, string> GetROFstData(XmlReader xr)
|
|
//{
|
|
// Dictionary<string, string> rv = new Dictionary<string, string>();
|
|
// rv.Add("rolookup", xr.GetAttribute("rolookup"));
|
|
// rv.Add("config", xr.GetAttribute("config"));
|
|
// rv.Add("userid", xr.GetAttribute("userid"));
|
|
// rv.Add("dts", xr.GetAttribute("dts"));
|
|
// return rv;
|
|
//}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ROFst AddROFst(Dictionary<string,string> dic)
|
|
//{
|
|
// byte[] rolookup = Convert.FromBase64String(dic["rolookup"]);
|
|
// string config = dic["config"];
|
|
// string userid = dic["userid"];
|
|
// DateTime dts = DateTime.Parse(dic["dts"]);
|
|
// ROFst rv = null;
|
|
// rv = ROFst.GetByRODbID_DTS(MyRODb.RODbID, dts); //MyRODb.DTS);
|
|
// if (rv == null)
|
|
// rv = ROFst.MakeROFst(MyRODb, rolookup, config, dts, userid);
|
|
// return rv;
|
|
//}
|
|
|
|
private ROFst AddROFst(XmlNode xrofst)
|
|
{
|
|
lblImportStatus.Text = "Creating ROFst...";
|
|
Application.DoEvents();
|
|
|
|
byte[] rolookup = Convert.FromBase64String(xrofst.Attributes.GetNamedItem("rolookup").InnerText);
|
|
string config = xrofst.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = xrofst.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xrofst.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
ROFst rv = ROFst.GetByRODbID_DTS(MyRODb.RODbID, dts);
|
|
|
|
// if the RO database is not found in the current data (does not have the same RODBid nor date/time stamp
|
|
// then spin through the list of RO databases and compare the FST information.
|
|
// If the RO FST information is the same, then use that current RO database when importing
|
|
if (rv == null)
|
|
{
|
|
RODbInfoList rodblst = RODbInfoList.Get();
|
|
|
|
foreach (RODbInfo roinfo in rodblst)
|
|
{
|
|
rv = ROFst.GetByRODbID_DTS(roinfo.RODbID, dts);
|
|
if (rv != null && Same(ROFSTLookup.GetRofstLookupBytes(rv.ROFstID), rolookup)) // B2022-026 RO Memory reduction - new calls
|
|
{
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
rv = ROFst.MakeROFst(MyRODb, rolookup, config, dts, userid);
|
|
|
|
XmlNode xfigures = xrofst.SelectSingleNode("figures");
|
|
if (xfigures != null)
|
|
AddFigures(xfigures, rv);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
private bool Same(byte[] p, byte[] rolookup)
|
|
{
|
|
if (p.Length != rolookup.Length) return false;
|
|
for (int i = 0; i < p.Length; i++)
|
|
if (p[i] != rolookup[i]) return false;
|
|
return true;
|
|
}
|
|
|
|
private void AddFigures(XmlNode xfigures, ROFst rofst)
|
|
{
|
|
foreach (XmlNode nd in xfigures.SelectNodes("figure"))
|
|
{
|
|
XmlNode image = nd.SelectSingleNode("image");
|
|
int imageid = int.Parse(image.Attributes.GetNamedItem("imageid").InnerText);
|
|
|
|
using (ROImage roimage = ROImage.GetJustROImage(imageid))//Dispose when done
|
|
{
|
|
string config;
|
|
DateTime dts;
|
|
string userid;
|
|
|
|
if (roimage == null)
|
|
{
|
|
string filename = image.Attributes.GetNamedItem("filename").InnerText;
|
|
byte[] content = Convert.FromBase64String(image.Attributes.GetNamedItem("content").InnerText);
|
|
config = image.Attributes.GetNamedItem("config").InnerText;
|
|
dts = DateTime.Parse(image.Attributes.GetNamedItem("dts").InnerText);
|
|
userid = image.Attributes.GetNamedItem("userid").InnerText;
|
|
|
|
// Dispose when done
|
|
using (ROImage roimage1 = ROImage.MakeROImage(MyRODb, filename, content, config, dts, userid))
|
|
{
|
|
config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
|
|
// Dispose when done
|
|
using (Figure fig = Figure.MakeFigure(rofst, roimage, config, dts, userid)) { ;}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
// Dispose when done
|
|
using (Figure fig = Figure.MakeFigure(rofst, roimage, config, dts, userid)) { ;}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private RODb AddRODb(XmlReader xr)
|
|
//{
|
|
// oldRODbID = int.Parse(xr.GetAttribute("rodbid"));
|
|
// string roname = xr.GetAttribute("roname");
|
|
// string folderpath = xr.GetAttribute("folderpath");
|
|
// string dbconnectionstring = xr.GetAttribute("dbconnectionstring");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// RODb rv = null;
|
|
// rv = RODb.GetByFolderPath(folderpath);
|
|
// if (rv == null)
|
|
// rv = RODb.MakeRODb(roname, folderpath, dbconnectionstring, config, dts, userid);
|
|
// newRODbID = rv.RODbID;
|
|
// return rv;
|
|
//}
|
|
|
|
private RODb AddRODb(XmlNode xrodb)
|
|
{
|
|
lblImportStatus.Text = "Creating RODb...";
|
|
Application.DoEvents();
|
|
|
|
oldRODbID = int.Parse(xrodb.Attributes.GetNamedItem("rodbid").InnerText);
|
|
string roname = xrodb.Attributes.GetNamedItem("roname").InnerText;
|
|
string folderpath = xrodb.Attributes.GetNamedItem("folderpath").InnerText;
|
|
string dbconnectionstring = xrodb.Attributes.GetNamedItem("dbconnectionstring").InnerText;
|
|
string config = xrodb.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = xrodb.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xrodb.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
RODb rv = RODb.GetByFolderPath(folderpath);
|
|
|
|
if (rv == null)
|
|
{
|
|
// create a list of the RO databases currently in the database
|
|
List<string> roDbNameList = new List<string>();
|
|
RODbInfoList rolist = RODbInfoList.Get();
|
|
|
|
foreach (RODbInfo rodbinfo in rolist)
|
|
{
|
|
if (!roDbNameList.Contains(rodbinfo.ROName))
|
|
roDbNameList.Add(rodbinfo.ROName);
|
|
}
|
|
|
|
rolist.Dispose();
|
|
int cnt = 0;
|
|
string roNameNew = roname;
|
|
|
|
// if the ROname we are importing is the same as one already in the database
|
|
// and the ROpaths are different, then rename the one we are importing
|
|
while (roDbNameList.Contains(roNameNew))
|
|
{
|
|
roNameNew = string.Format("{0}_{1}", roname, (++cnt).ToString());
|
|
}
|
|
|
|
rv = RODb.MakeRODb(roNameNew, folderpath, dbconnectionstring, config, dts, userid);
|
|
}
|
|
|
|
newRODbID = rv.RODbID;
|
|
return rv;
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private int GetProcedureData(XmlReader xr)
|
|
//{
|
|
// return int.Parse(xr.GetAttribute("itemid"));
|
|
//}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ItemInfo AddProcedure(XmlReader xr, DocVersion dv, ItemInfo procInfo, int oldid)
|
|
//{
|
|
// DocVersionInfo dvInfo = DocVersionInfo.Get(dv.VersionID);
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int proctype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Procedure p = Procedure.MakeProcedure(dvInfo, procInfo, number, text, proctype);
|
|
// p.DTS = dts;
|
|
// p.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// p.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid),formatfilename);
|
|
// p.MyContent.Config = config;
|
|
// p.MyContent.DTS = dts;
|
|
// p.MyContent.UserID = userid;
|
|
// p.Save();
|
|
// Old2NewItem.Add(oldid, p.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), p.MyContent.ContentID);
|
|
// procInfo = ProcedureInfo.Get(p.ItemID);
|
|
// return procInfo;
|
|
//}
|
|
private ProcedureInfo AddProcedure(XmlNode xn, DocVersionInfo dvInfo, ProcedureInfo procInfo)
|
|
{
|
|
pbImportProcedure.PerformStep();
|
|
lblImportProcedure.Text = string.Format("{0} of {1} Procedures", pbImportProcedure.Value.ToString(), pbImportProcedure.Maximum.ToString());
|
|
TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
|
|
lblImportTime.Text = "Elapsed Time: " + elapsed.ToString();
|
|
Application.DoEvents();
|
|
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int proctype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
using (Procedure p = Procedure.MakeProcedure(dvInfo, procInfo, number, text, proctype))
|
|
{
|
|
p.DTS = dts;
|
|
p.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
|
|
if (formatid != string.Empty) p.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
p.MyContent.Config = config;
|
|
p.MyContent.DTS = dts;
|
|
p.MyContent.UserID = userid;
|
|
|
|
p.Save();
|
|
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), p.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = p.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), p.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = p.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(p.ItemID, xn);
|
|
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(p.MyContent, xc);
|
|
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(p.MyContent, xc);
|
|
|
|
procInfo = ProcedureInfo.Get(p.ItemID);
|
|
}
|
|
|
|
if (xc.HasChildNodes)
|
|
{
|
|
AddParts(xc, procInfo);
|
|
}
|
|
|
|
FixSectionStart(procInfo);
|
|
|
|
return procInfo;
|
|
}
|
|
|
|
// jsj 2016Feb16 - This appears to not be used
|
|
//private void AddROUsage(XmlReader xr)
|
|
//{
|
|
// int contentid = int.Parse(xr.GetAttribute("contentid"));
|
|
// contentid = Old2NewContent[contentid];
|
|
// Content content = Content.Get(contentid);
|
|
// string rousageid = xr.GetAttribute("rousageid");
|
|
// string roid = xr.GetAttribute("roid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// RoUsage rou = RoUsage.MakeRoUsage(content, roid, config, dts, userid, MyRODb);
|
|
// rou.Save();
|
|
// string lookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rousageid, roid, oldRODbID.ToString());
|
|
// string replaceWith = (cbxCvrtROsToText.Checked) ? "" : string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
|
|
// if (lookFor != replaceWith)
|
|
// {
|
|
// content.Text = content.Text.Replace(lookFor, replaceWith);
|
|
// content.Save();
|
|
// }
|
|
//}
|
|
private string GetMyPrefix(string text, int start, int lastIndex)
|
|
{
|
|
string defPrefix = text.Substring(start - 3, 3);
|
|
if (defPrefix != @"\v ") throw new Exception(string.Format("rtf string {0} does not match expected format", defPrefix));
|
|
string txt = text.Substring(lastIndex, start - lastIndex - 3);
|
|
int lastSlash = txt.LastIndexOf(@"\");
|
|
int lastSpace = txt.LastIndexOf(" ");
|
|
int lastCR = txt.LastIndexOf("\r");
|
|
if (lastSpace < lastCR)
|
|
lastSpace = lastCR;
|
|
if (lastSlash <= lastSpace) //this will return "\v "
|
|
return defPrefix;
|
|
txt = txt.Substring(lastSlash);
|
|
if (txt.StartsWith(@"\'")) //this is a hex
|
|
return defPrefix;
|
|
if (Regex.IsMatch(txt, @"\\u[0-9].*")) //this is unicode
|
|
return defPrefix;
|
|
return @"\v";
|
|
}
|
|
private string GetMySuffix(string text, int start)
|
|
{
|
|
string txt = text.Substring(start);
|
|
int firstSlashVeeZero = txt.IndexOf(@"\v0");
|
|
if (firstSlashVeeZero == 0 && txt.Length > 3 && txt[3] == ' ') //"\v0 "
|
|
return text.Substring(start, 4);
|
|
return text.Substring(start, firstSlashVeeZero + 3); //everything upto \v0"
|
|
}
|
|
private void ConvertImportProcedureROsToText(Content content, XmlNode xn)
|
|
{
|
|
foreach (XmlNode nd in xn.SelectNodes("rousage"))
|
|
{
|
|
string rousageid = nd.Attributes.GetNamedItem("rousageid").InnerText;
|
|
string roid = nd.Attributes.GetNamedItem("roid").InnerText;
|
|
|
|
string findLink = @"<START\].*?\[END>";
|
|
content.Text = content.Text.Replace("<START]<START]", "<START]").Replace(@"[END><START]", @"[END>\v0 \v <START]"); //B2020-057 bad RO link - remove extra START and insert comment off/on between <END]<START]
|
|
content.Save();
|
|
MatchCollection ms = Regex.Matches(content.Text, findLink);
|
|
string lookFor = string.Format(@"^<START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}~\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}}~ \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:{0} .*?\[END>$", rousageid);
|
|
int lastIndex = 0;
|
|
string newText = content.Text;
|
|
// B2018-046 This loop repeats code to convert duplicate ROs in text to text
|
|
int originalCount = 0;
|
|
while (ms.Count > 0 && (originalCount == 0 || ms.Count < originalCount))
|
|
{
|
|
originalCount = ms.Count;
|
|
foreach (Match mm in ms)
|
|
{
|
|
int offset = mm.Index;
|
|
Match m = Regex.Match(mm.Value, lookFor, RegexOptions.Singleline);
|
|
if (m != null && m.Groups.Count > 1)
|
|
{
|
|
string prefix = GetMyPrefix(content.Text, mm.Index, lastIndex);
|
|
string suffix = GetMySuffix(content.Text, mm.Index + mm.Length);
|
|
int myIndex = m.Groups[4].Index + mm.Index;
|
|
int myLength = m.Groups[4].Length;
|
|
if (m.Groups[3].Value != " ")
|
|
{
|
|
myIndex = m.Groups[3].Index + mm.Index;
|
|
myLength += m.Groups[3].Length;
|
|
}
|
|
string gg = newText.Substring(myIndex, myLength);
|
|
gg = gg.Replace("{", @"\{").Replace("}", @"\}");
|
|
string part1 = newText.Substring(0, mm.Index);
|
|
string part2 = gg;
|
|
string part3 = newText.Substring(mm.Index + mm.Length);
|
|
//modify part1 based on prefix
|
|
if (prefix == @"\v ")
|
|
part1 = part1.Substring(0, part1.Length - 3);
|
|
else
|
|
part1 = part1.Substring(0, part1.Length - 3) + " ";
|
|
//modify part3 based on suffix
|
|
if (suffix == @"\v0 ")
|
|
part3 = part3.Substring(4);
|
|
else
|
|
part3 = suffix.Replace(@"\v0", "") + part3.Substring(suffix.Length);
|
|
content.Text = part1 + part2 + part3;
|
|
ROToTextAnnotation(content, part2); // B2016-225 (follow through) add annotation when RO is converted to text
|
|
_DidProcessROs = true; // B2017-076 flag that ROs where processed
|
|
break; // B2018-046 If it finds a match try again
|
|
}
|
|
lastIndex = mm.Index + mm.Length;
|
|
}
|
|
ms = Regex.Matches(content.Text, findLink); // B2018-046 Look for match again
|
|
}
|
|
}
|
|
content.Save();
|
|
}
|
|
|
|
// B2016-225 (follow through) add annotation when RO is converted to text
|
|
private void ROToTextAnnotation(Content content, string txtRO)
|
|
{
|
|
// replace unicode symbols to DOS code symbols
|
|
txtRO = txtRO.Replace(@"\u8209?", "-"); // dash
|
|
txtRO = txtRO.Replace(@"\u9586?", @"\\"); // backslash
|
|
txtRO = txtRO.Replace(@"\'b0", "\xb0"); //degree
|
|
txtRO = txtRO.Replace(@"\u160?", " "); //hard space
|
|
txtRO = txtRO.Replace(@"\u916?", "\x7F"); // delta
|
|
txtRO = txtRO.Replace(@"\u8805?", "\xF2"); //greater than or equal
|
|
txtRO = txtRO.Replace(@"\u8804?", "\xF3"); // less than or equal
|
|
txtRO = txtRO.Replace(@"\u931?", "\xE4"); // sigma
|
|
txtRO = txtRO.Replace(@"\u947?", "\xE7"); // gamma
|
|
txtRO = txtRO.Replace(@"\u9604?", "\xFE"); // accum 2584
|
|
txtRO = txtRO.Replace(@"\u9679?", "\x7"); // bullet 25CF
|
|
txtRO = txtRO.Replace(@"\u8776?", "\xF7"); // approx eq
|
|
txtRO = txtRO.Replace(@"\u8773?", "\xF0"); // similar eq 2245
|
|
txtRO = txtRO.Replace(@"\u8730?", "\xFB"); // square root
|
|
txtRO = txtRO.Replace(@"\u961?", "\xE2"); // rho 3C1
|
|
txtRO = txtRO.Replace(@"\u960?", "\xE3"); // pi
|
|
txtRO = txtRO.Replace(@"\u956?", "\xE6"); // micro
|
|
txtRO = txtRO.Replace(@"\u948?", "\xEB"); // lower case delta
|
|
txtRO = txtRO.Replace(@"\u963?", "\xE5"); // lower case sigma
|
|
txtRO = txtRO.Replace(@"\u274?", "\x90"); // energy, 112
|
|
txtRO = txtRO.Replace(@"\u949?", "\xEE"); // epsilon
|
|
txtRO = txtRO.Replace(@"\u952?", "\xE9"); // theta, 3B8
|
|
txtRO = txtRO.Replace(@"\u8857?", "\xEC"); // dot in oval, 2299
|
|
txtRO = txtRO.Replace(@"\u964?", "\xA8"); // tau, 3C4
|
|
txtRO = txtRO.Replace(@"\u9830?", "\xA9"); // diamond, 2666
|
|
txtRO = txtRO.Replace(@"\u8593?", "\x18"); // Up Arrow - changes to \xff
|
|
txtRO = txtRO.Replace(@"\u8595?", "\x19"); // Down Arrow - changes to \xd6
|
|
|
|
Item myitem = content.ContentItems[0].MyItem; // The Using statement caused the content.text to disappear
|
|
//using (Item myitem = content.ContentItems[0].MyItem) // so that myitem does not stay in cache
|
|
//{
|
|
Annotation.MakeAnnotation(myitem, AnnotationType.GetByNameOrCreate("Link Converted To Text"), "", string.Format("RO value ({0}) converted to text", txtRO), null);
|
|
//}
|
|
_DidConvertROsToText |= true;
|
|
}
|
|
|
|
private bool _DidProcessROs = false; // B2017-076 flag that ROs where processed
|
|
private void AddROUsages(Content content, XmlNode xn)
|
|
{
|
|
AddROUsages(content, xn, false);
|
|
}
|
|
|
|
// part of bug fix B2017-060 added the isGrid parameter
|
|
private void AddROUsages(Content content, XmlNode xn, bool isGrid)
|
|
{
|
|
if (_ImportingApprovedExportFile) return; //B2020-095 the links are already removed from the import file
|
|
_DidProcessROs = false;
|
|
|
|
if (_ConvertROsToTextDuringImport)
|
|
ConvertImportProcedureROsToText(content, xn);
|
|
else
|
|
{
|
|
foreach (XmlNode nd in xn.SelectNodes("rousage"))
|
|
{
|
|
string rousageid = nd.Attributes.GetNamedItem("rousageid").InnerText;
|
|
string roid = nd.Attributes.GetNamedItem("roid").InnerText;
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
if (MyDocVersion.DocVersionAssociations == null)
|
|
MyDocVersion.RefreshDocVersionAssociations();
|
|
|
|
ROFSTLookup lookup = MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(MyDocVersion);
|
|
|
|
// B2023-104 use this to replace RO Link information in the imported text
|
|
// FormatRoidKey() was creating the roid with the new formatting introduce with B2022-088 & B2022-098
|
|
// We need to save the ROID from the imported text in order to update it with the new RO link information
|
|
string contentROID = roid;
|
|
|
|
// B2022-088: [JPR] Find Doc Ro button not working in Word Sections
|
|
// B2022-098: [JPR] ROs not being resolved in Word Sections
|
|
roid = ROFSTLookup.FormatRoidKey(roid, true);
|
|
ROFSTLookup.rochild roc = lookup.GetRoChild(roid);
|
|
string roval = roc.value;
|
|
|
|
if (roval == "?")
|
|
{
|
|
RoUsageInfo roui = RoUsageInfo.Get(int.Parse(rousageid));
|
|
content.FixContentText(roui, roval, 0, MyDocVersion.DocVersionAssociations[0].MyROFst, null, rousageid); // + " " + roid);
|
|
_DidConvertROsToText |= true; // B2016-225 (follow through) add annotation when RO is converted to text
|
|
_DidProcessROs = true; // B2017-076 flag that ROs where processed
|
|
}
|
|
else
|
|
{
|
|
RoUsage rou = RoUsage.MakeRoUsage(content, roid, config, dts, userid, MyRODb);
|
|
rou.Save();
|
|
|
|
RoUsageInfo roui = RoUsageInfo.Get(rou.ROUsageID);
|
|
//B2023-104 use the ROID from the imported text (contentROID) to create the lookFor string
|
|
string lookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rousageid, contentROID, oldRODbID.ToString());
|
|
string replaceWith = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
|
|
_DidProcessROs = content.Text.Contains(lookFor); // B2017-076 RO link in the text so we will be processing it
|
|
|
|
if (lookFor != replaceWith)
|
|
{
|
|
content.Text = content.Text.Replace(lookFor, replaceWith);
|
|
content.FixContentText(roui, roval, 0, MyDocVersion.DocVersionAssociations[0].MyROFst);
|
|
}
|
|
|
|
if (isGrid) // B2017-060 when importing a grid, also update the grid's xml defination
|
|
{
|
|
string glookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rousageid, roid, oldRODbID.ToString());
|
|
string greplaceWith = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
|
|
|
|
if (glookFor != greplaceWith)
|
|
{
|
|
// B2024-011: For unit RO in grid, old grid data had the ROID in the #Link:ReferencedObject ending in '0000'
|
|
// so when compared with the newer format "0041" it was not found and not replaced with updated rousageid
|
|
bool hasNewROID = (content.MyGrid.Data.Contains(glookFor));
|
|
if (hasNewROID)
|
|
content.MyGrid.Data = content.MyGrid.Data.Replace(glookFor, greplaceWith);
|
|
else if (!hasNewROID && glookFor.Contains("0041") && glookFor.Contains("FFFF"))
|
|
{
|
|
string newGlookFor = glookFor;
|
|
newGlookFor = newGlookFor.Replace("0041", "0000");
|
|
if (content.MyGrid.Data.Contains(newGlookFor))
|
|
content.MyGrid.Data = content.MyGrid.Data.Replace(newGlookFor, greplaceWith);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
content.Save();
|
|
|
|
if (isGrid)
|
|
GridInfo.Refresh(content.MyGrid); // force the updated grid (table) to refresh
|
|
}
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private void AddAnnotation(XmlReader xr)
|
|
//{
|
|
// int itemid = int.Parse(xr.GetAttribute("itemid"));
|
|
// itemid = Old2NewItem[itemid];
|
|
// Item itm = Item.Get(itemid);
|
|
// int typeid = int.Parse(xr.GetAttribute("typeid"));
|
|
// string rtftext = xr.GetAttribute("rtftext");
|
|
// string searchtext = xr.GetAttribute("searchtext");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Annotation ann = Annotation.MakeAnnotation(itm, AnnotationType.Get(typeid), rtftext, searchtext, config, dts, userid);
|
|
//}
|
|
private void AddImage(Content content, XmlNode xc)
|
|
{
|
|
XmlNode xn = xc.SelectSingleNode("image");
|
|
int imagetype = int.Parse(xn.Attributes.GetNamedItem("imagetype").InnerText);
|
|
string filename = xn.Attributes.GetNamedItem("filename").InnerText;
|
|
byte[] data = Convert.FromBase64String(xn.Attributes.GetNamedItem("data").InnerText);
|
|
string config = xn.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = xn.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xn.Attributes.GetNamedItem("dts").InnerText);
|
|
VEPROMS.CSLA.Library.Image img = VEPROMS.CSLA.Library.Image.MakeImage(content, imagetype, filename, data, config, dts, userid);
|
|
img.Save();
|
|
}
|
|
private void AddAnnotations(int itemID, XmlNode xn)
|
|
{
|
|
using (Item itm = Item.Get(itemID)) //B2019-035 better memory management
|
|
{
|
|
foreach (XmlNode nd in xn.SelectNodes("annotation"))
|
|
{
|
|
int typeid = int.Parse(nd.Attributes.GetNamedItem("typeid").InnerText);
|
|
string rtftext = nd.Attributes.GetNamedItem("rtftext").InnerText;
|
|
string searchtext = nd.Attributes.GetNamedItem("searchtext").InnerText;
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
AnnotationType annType = AnnotationType.GetByNameOrCreate(nd.Attributes.GetNamedItem("typename").InnerText);
|
|
Annotation ann = Annotation.MakeAnnotation(itm, annType, rtftext, searchtext, config, dts, userid);
|
|
ann.Save();
|
|
}
|
|
}
|
|
}
|
|
private void AddParts(XmlNode myNode, ItemInfo parentInfo)
|
|
{
|
|
foreach (XmlNode xn in myNode.ChildNodes)
|
|
{
|
|
// B2018-154 Code added to check for incorrect Part record.
|
|
// Barakah Conversion Code incorrectly set the FromType to Step rather than Table.
|
|
// This has been corrected in the conversion code.
|
|
string xnName = xn.Name;
|
|
if (xn.SelectSingleNode("step/content/grid") != null)
|
|
xnName = "tables";
|
|
switch (xnName)
|
|
{
|
|
case "sections":
|
|
AddSections(xn, parentInfo);
|
|
break;
|
|
case "cautions":
|
|
AddCautions(xn, parentInfo);
|
|
break;
|
|
case "notes":
|
|
AddNotes(xn, parentInfo);
|
|
break;
|
|
case "rnos":
|
|
AddRNOs(xn, parentInfo);
|
|
break;
|
|
case "steps":
|
|
AddSteps(xn, parentInfo);
|
|
break;
|
|
case "supinfos":
|
|
AddSupInfos(xn, parentInfo);
|
|
break;
|
|
case "tables":
|
|
AddTables(xn, parentInfo);
|
|
break;
|
|
case "entry": // this is word section max out the status bar
|
|
lblImportStep.Text = "Word Section Data";
|
|
pbImportStep.Maximum = 1;
|
|
pbImportStep.PerformStep();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddTables(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddTable(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
// jsj 2016Feb16 - This appears to not be used
|
|
//private ItemInfo AddTable(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int steptype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Table);
|
|
// step.DTS = dts;
|
|
// step.UserID = userid;
|
|
// if (formatid != string.Empty)
|
|
// step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid));
|
|
// step.MyContent.Config = config;
|
|
// step.MyContent.DTS = dts;
|
|
// step.MyContent.UserID = userid;
|
|
// step.Save();
|
|
// Old2NewItem.Add(oldid, step.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
|
|
// prevInfo = StepInfo.Get(step.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
private ItemInfo AddTable(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Table))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
|
|
step.Save();
|
|
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
|
|
if (xc.SelectNodes("grid").Count > 0)
|
|
AddGrid(step.MyContent, xc);
|
|
|
|
if (xc.SelectNodes("image").Count > 0)
|
|
AddImage(step.MyContent, xc);
|
|
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc, true); // part of bug fix: B2017060 to properly convert invalid RO to text
|
|
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
|
|
return prevInfo;
|
|
}
|
|
|
|
private void AddSteps(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddStep(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ItemInfo AddStep(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int steptype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Step);
|
|
// step.DTS = dts;
|
|
// step.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid),formatfilename);
|
|
// step.MyContent.Config = config;
|
|
// step.MyContent.DTS = dts;
|
|
// step.MyContent.UserID = userid;
|
|
// step.Save();
|
|
// Old2NewItem.Add(oldid, step.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
|
|
// prevInfo = StepInfo.Get(step.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
private ItemInfo AddStep(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Step))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
|
|
step.Save();
|
|
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc);
|
|
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
|
|
return prevInfo;
|
|
}
|
|
|
|
private void AddRNOs(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddRNO(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
private void AddSupInfos(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddSupInfo(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ItemInfo AddRNO(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int steptype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.RNO);
|
|
// step.DTS = dts;
|
|
// step.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
// step.MyContent.Config = config;
|
|
// step.MyContent.DTS = dts;
|
|
// step.MyContent.UserID = userid;
|
|
// step.Save();
|
|
// Old2NewItem.Add(oldid, step.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
|
|
// prevInfo = StepInfo.Get(step.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
|
|
private ItemInfo AddRNO(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.RNO))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
step.Save();
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc);
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
return prevInfo;
|
|
}
|
|
private ItemInfo AddSupInfo(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.SupInfo))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
step.Save();
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc);
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
return prevInfo;
|
|
}
|
|
private void AddNotes(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddNote(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ItemInfo AddNote(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int steptype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Note);
|
|
// step.DTS = dts;
|
|
// step.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
// step.MyContent.Config = config;
|
|
// step.MyContent.DTS = dts;
|
|
// step.MyContent.UserID = userid;
|
|
// step.Save();
|
|
// Old2NewItem.Add(oldid, step.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
|
|
// prevInfo = StepInfo.Get(step.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
|
|
private ItemInfo AddNote(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Note))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
step.Save();
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc);
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
return prevInfo;
|
|
}
|
|
private void AddCautions(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddCaution(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private ItemInfo AddCaution(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int steptype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Caution);
|
|
// step.DTS = dts;
|
|
// step.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
// step.MyContent.Config = config;
|
|
// step.MyContent.DTS = dts;
|
|
// step.MyContent.UserID = userid;
|
|
// step.Save();
|
|
// Old2NewItem.Add(oldid, step.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
|
|
// prevInfo = StepInfo.Get(step.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
|
|
private ItemInfo AddCaution(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportStep.PerformStep();
|
|
lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
|
|
Application.DoEvents();
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
Step step;
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Caution))
|
|
{
|
|
step.DTS = dts;
|
|
step.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
if (formatid != string.Empty)
|
|
step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
step.MyContent.Config = config;
|
|
step.MyContent.DTS = dts;
|
|
step.MyContent.UserID = userid;
|
|
step.Save();
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(step.ItemID, xn);
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(step.MyContent, xc);
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(step.MyContent, xc);
|
|
prevInfo = StepInfo.Get(step.ItemID);
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
return prevInfo;
|
|
}
|
|
private void AddSections(XmlNode xn, ItemInfo parentInfo)
|
|
{
|
|
if (parentInfo.IsProcedure)
|
|
{
|
|
pbImportSection.Value = 0;
|
|
pbImportStep.Value = 0;
|
|
pbImportSection.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
if (parentInfo.IsSection)
|
|
{
|
|
pbImportStep.Value = 0;
|
|
pbImportStep.Maximum = xn.ChildNodes.Count;
|
|
}
|
|
ItemInfo prevInfo = null;
|
|
foreach (XmlNode nd in xn.ChildNodes)
|
|
prevInfo = AddSection(nd, parentInfo, prevInfo);
|
|
}
|
|
|
|
private Dictionary<string, string> GetSectionData(XmlReader xr)
|
|
{
|
|
Dictionary<string, string> rv = new Dictionary<string, string>();
|
|
rv.Add("itemid", xr.GetAttribute("itemid"));
|
|
return rv;
|
|
}
|
|
|
|
// js j4-29-2016 appears to not be used
|
|
//private ItemInfo AddSection(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
|
|
//{
|
|
// string number = xr.GetAttribute("number");
|
|
// string text = xr.GetAttribute("text");
|
|
// int sectiontype = int.Parse(xr.GetAttribute("type"));
|
|
// string formatid = xr.GetAttribute("formatid");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Section sect = Section.MakeSection(parentInfo, prevInfo, number, text, sectiontype);
|
|
// sect.DTS = dts;
|
|
// sect.UserID = userid;
|
|
// string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
// if (formatid != string.Empty)
|
|
// sect.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
// sect.MyContent.Config = config;
|
|
// sect.MyContent.DTS = dts;
|
|
// sect.MyContent.UserID = userid;
|
|
// sect.Save();
|
|
// Old2NewItem.Add(oldid, sect.ItemID);
|
|
// Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), sect.MyContent.ContentID);
|
|
// prevInfo = SectionInfo.Get(sect.ItemID);
|
|
// return prevInfo;
|
|
//}
|
|
|
|
private ItemInfo AddSection(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
|
|
{
|
|
pbImportSection.PerformStep();
|
|
lblImportSection.Text = string.Format("{0} of {1} Sections", pbImportSection.Value.ToString(), pbImportSection.Maximum.ToString());
|
|
Application.DoEvents();
|
|
XmlNode xc = xn.SelectSingleNode("content");
|
|
string number = xc.Attributes.GetNamedItem("number").InnerText;
|
|
string text = xc.Attributes.GetNamedItem("text").InnerText;
|
|
int sectiontype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
|
|
string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
|
|
string config = xc.Attributes.GetNamedItem("config").InnerText;
|
|
config = StripEnhanced(config);
|
|
int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
|
|
CheckForFloatingFoldout(contentid, config);
|
|
string userid = xc.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
|
|
using (Section sect = Section.MakeSection(parentInfo, prevInfo, number, text, sectiontype)) // B2019-035 better memory management
|
|
{
|
|
sect.DTS = dts;
|
|
sect.UserID = userid;
|
|
// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
|
|
XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103 the formatid in an Export file may not match the formatid where you are importing to
|
|
string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
|
|
// If this formatfile is a copy in this database (was not in exported database), use the copy name (note that the
|
|
// Config data must match and this was checked in the code that loads the formats:
|
|
if (formatid != string.Empty)
|
|
{
|
|
if (existingCopyFCName.ContainsKey(formatfilename)) formatfilename = existingCopyFCName[formatfilename];
|
|
sect.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
|
|
}
|
|
sect.MyContent.Config = config;
|
|
sect.MyContent.DTS = dts;
|
|
sect.MyContent.UserID = userid;
|
|
sect.Save();
|
|
if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
|
|
Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), sect.MyContent.ContentID);
|
|
else
|
|
Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = sect.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
|
|
if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
|
|
Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), sect.ItemID);
|
|
else
|
|
Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = sect.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
|
|
if (xn.SelectNodes("annotation").Count > 0)
|
|
AddAnnotations(sect.ItemID, xn);
|
|
if (xc.SelectNodes("entry").Count > 0)
|
|
AddEntry(sect.MyContent, xc);
|
|
if (xc.SelectNodes("rousage").Count > 0)
|
|
AddROUsages(sect.MyContent, xc);
|
|
if (xc.SelectNodes("transition").Count > 0)
|
|
AddTransitions(sect.MyContent, xc);
|
|
prevInfo = SectionInfo.Get(sect.ItemID);
|
|
if (xc.HasChildNodes)
|
|
AddParts(xc, prevInfo);
|
|
}
|
|
return prevInfo;
|
|
}
|
|
|
|
private string StripEnhanced(string config)
|
|
{
|
|
if (config.Length > 0)
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.LoadXml(config);
|
|
XmlNodeList nl = xd.DocumentElement.SelectNodes("//Enhanced");
|
|
foreach (XmlNode nd in nl)
|
|
nd.ParentNode.RemoveChild(nd);
|
|
return xd.OuterXml;
|
|
}
|
|
return config;
|
|
}
|
|
|
|
private void CheckForFloatingFoldout(int contentid, string config)
|
|
{
|
|
if (config != string.Empty)
|
|
{
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.LoadXml(config);
|
|
XmlNode xn = xd.SelectSingleNode("Config/Step/@FloatingFoldout");
|
|
if (xn != null)
|
|
floatFoldout.Add(contentid, int.Parse(xn.InnerText));
|
|
}
|
|
}
|
|
|
|
// jsj 2016Feb16 - This appears to not be used
|
|
//private void AddGrid(XmlReader xr)
|
|
//{
|
|
// int contentid = int.Parse(xr.GetAttribute("contentid"));
|
|
// contentid = Old2NewContent[contentid];
|
|
// Content content = Content.Get(contentid);
|
|
// string data = xr.GetAttribute("data");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// Grid gg = Grid.MakeGrid(content, data, config, dts, userid);
|
|
//}
|
|
|
|
private void AddGrid(Content content, XmlNode xc)
|
|
{
|
|
XmlNode nd = xc.SelectSingleNode("grid");
|
|
string data = nd.Attributes.GetNamedItem("data").InnerText;
|
|
XmlDocument xd = new XmlDocument();
|
|
xd.LoadXml(data);
|
|
XmlNode gn = xd.SelectSingleNode("C1FlexGrid/Control/IsRoTable");
|
|
|
|
if (gn.InnerText.ToLower() == "true")
|
|
{
|
|
if (_ConvertROsToTextDuringImport)
|
|
{
|
|
gn.InnerText = "False";
|
|
ROToTextAnnotation(content, "RO Table"); // B2016-225 (follow through) add annotation when RO is converted to text
|
|
}
|
|
else
|
|
{
|
|
gn = xd.SelectSingleNode("C1FlexGrid/Control/RODbId");
|
|
gn.InnerText = newRODbID.ToString();
|
|
}
|
|
data = xd.OuterXml;
|
|
}
|
|
else
|
|
{
|
|
XmlNodeList nl = xd.SelectNodes("C1FlexGrid/Cells/Cell/Data");
|
|
bool modified = false;
|
|
if (_ConvertROsToTextDuringImport)
|
|
{
|
|
string newvalue = "";
|
|
// if it's an ro within a table, need to process into an flex grid to save the grid data:
|
|
string findLinkXml = @"<START\].*?\[END>";
|
|
//string lookForXml = string.Format(@"^<START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}} \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:{0} .*?\[END>$", rousageid);
|
|
string lookForXml = @"^<START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}} \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:.*?\[END>$";
|
|
MatchCollection msg = Regex.Matches(data, findLinkXml);
|
|
int nmsg = msg.Count;
|
|
for (int i = nmsg - 1; i >= 0; i--)
|
|
{
|
|
Match mmg = msg[i];
|
|
Match mg = Regex.Match(mmg.Value, lookForXml);// Regex.Match(MyGrid.Data, lookForXml);
|
|
if (mg != null && mg.Groups.Count > 1)
|
|
{
|
|
int myIndex = mg.Groups[4].Index + mmg.Index;
|
|
int myLength = mg.Groups[4].Length;
|
|
if (mg.Groups[3].Value != " ")
|
|
{
|
|
myIndex = mg.Groups[3].Index + mmg.Index;
|
|
myLength += mg.Groups[3].Length;
|
|
}
|
|
string ss = data.Substring(myIndex, myLength);
|
|
if (ss != newvalue)
|
|
{
|
|
data = Content.ConvertGridROsToText(data, mmg, mg, ss); // part of bug fix: B2017060 to properly convert invalid RO to text
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string lookFor = string.Format(" {0}[END", oldRODbID.ToString());
|
|
string replaceWith = string.Format(" {0}[END", newRODbID.ToString());
|
|
foreach (XmlNode nn in nl)
|
|
{
|
|
if (nn.InnerText.Contains("#Link:ReferencedObject:"))
|
|
{
|
|
nn.InnerText = nn.InnerText.Replace(lookFor, replaceWith);
|
|
modified = true;
|
|
}
|
|
}
|
|
if (modified)
|
|
data = xd.OuterXml;
|
|
}
|
|
}
|
|
|
|
string config = nd.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
Grid gg = Grid.MakeGrid(content, data, config, dts, userid);
|
|
|
|
gg.Save();
|
|
|
|
content.MyGrid = gg;
|
|
}
|
|
|
|
|
|
// jsj 4-29-2016 appears to not be used
|
|
//private Dictionary<string, string> AddEntry(XmlReader xr)
|
|
//{
|
|
// Dictionary<string, string> dic = new Dictionary<string, string>();
|
|
// dic.Add("contentid", xr.GetAttribute("contentid"));
|
|
// dic.Add("dts", xr.GetAttribute("dts"));
|
|
// dic.Add("userid", xr.GetAttribute("userid"));
|
|
// return dic;
|
|
//}
|
|
|
|
private void AddEntry(Content content, XmlNode xc)
|
|
{
|
|
XmlNode nd = xc.SelectSingleNode("entry");
|
|
string userid = nd.Attributes.GetNamedItem("userid").InnerText;
|
|
DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
|
|
using (Document dd = AddDocument(nd.SelectSingleNode("document"))) // B2019-035 better memory management
|
|
{
|
|
Entry ee = Entry.MakeEntry(content, dd, dts, userid);
|
|
ee.Save();
|
|
}
|
|
}
|
|
// jsj 2016Feb16 - This appears to not be used
|
|
//private void AddDocument(XmlReader xr, Dictionary<string, string> dic)
|
|
//{
|
|
// string libtitle = xr.GetAttribute("libtitle");
|
|
// byte[] doccontent = Convert.FromBase64String(xr.GetAttribute("doccontent"));
|
|
// string docascii = xr.GetAttribute("docascii");
|
|
// string config = xr.GetAttribute("config");
|
|
// string userid = xr.GetAttribute("userid");
|
|
// DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
|
|
// string fileextension = xr.GetAttribute("fileextension");
|
|
// Document dd = Document.MakeDocument(libtitle, doccontent, docascii, config, dts, userid, fileextension);
|
|
// int contentid = int.Parse(dic["contentid"]);
|
|
// contentid = Old2NewContent[contentid];
|
|
// Content content = Content.Get(contentid);
|
|
// dts = DateTime.Parse(dic["dts"]);
|
|
// userid = dic["userid"];
|
|
// Entry ee = Entry.MakeEntry(content, dd, dts, userid);
|
|
//}
|
|
|
|
// B2019-035 This is called only once to get the existing library document info.
|
|
// when it was in the AddDocument() logic, it would use up (and not free up) memory each time
|
|
// a Word section was added during the import
|
|
private void GetExistingLibDocsList()
|
|
{
|
|
ExistingLibDocs = new Dictionary<string,int>();
|
|
using (DocumentInfoList dil = DocumentInfoList.GetLibraries(true))
|
|
{
|
|
foreach (DocumentInfo di in dil)
|
|
{
|
|
string keystr = di.LibTitle; // B2019-085 don't add the date/time to the title of the existing list of lib docs - was causing multiple copies of the lib doc to be added
|
|
if (!ExistingLibDocs.ContainsKey(keystr))
|
|
ExistingLibDocs.Add(keystr, di.DocID);
|
|
di.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Document AddDocument(XmlNode xn)
|
|
{
|
|
Document d=null;
|
|
int docid = int.Parse(xn.Attributes.GetNamedItem("docid").InnerText);
|
|
if (Old2NewLibDoc.ContainsKey(docid))
|
|
{
|
|
docid = Old2NewLibDoc[docid];
|
|
d = Document.Get(docid);
|
|
}
|
|
else // see if it is in the existing database
|
|
{
|
|
string libtitle = xn.Attributes.GetNamedItem("libtitle").InnerText;
|
|
DateTime dts = DateTime.Parse(xn.Attributes.GetNamedItem("dts").InnerText);
|
|
if (libtitle != "")
|
|
{
|
|
// C2019-026 if the lib doc title exists in the current database, compare it with the contents of what we
|
|
// are importing. If the same, use it, else enter a new lib doc appending the date/time
|
|
byte[] doccontent = Convert.FromBase64String(xn.Attributes.GetNamedItem("doccontent").InnerText);
|
|
|
|
if (ExistingLibDocs.ContainsKey(libtitle))
|
|
{
|
|
d = Document.Get(ExistingLibDocs[libtitle]);
|
|
if (!ByteArrayCompare.DoCompare(d.DocContent,doccontent))
|
|
d = null;
|
|
}
|
|
|
|
if (d == null)
|
|
{
|
|
// B2019-035 better memory management. Prior logic would eat up memory (and not free it).
|
|
string libkey = libtitle + "_" + dts.ToString();
|
|
if (ExistingLibDocs.ContainsKey(libkey))
|
|
d = Document.Get(ExistingLibDocs[libkey]); // found library document in existing database
|
|
}
|
|
}
|
|
|
|
if (d == null) // not found in existing database, create it
|
|
{
|
|
byte[] doccontent = Convert.FromBase64String(xn.Attributes.GetNamedItem("doccontent").InnerText);
|
|
string docascii = xn.Attributes.GetNamedItem("docascii").InnerText;
|
|
string config = xn.Attributes.GetNamedItem("config").InnerText;
|
|
string userid = xn.Attributes.GetNamedItem("userid").InnerText;
|
|
string fileextension = xn.Attributes.GetNamedItem("fileextension").InnerText;
|
|
if (libtitle != "") libtitle = libtitle + "_" + dts.ToString(); // if a lib document, append the date/time to the title incase there are duplicate titles
|
|
d = Document.MakeDocument(libtitle, doccontent, docascii, config, dts, userid, fileextension);
|
|
d.Save();
|
|
Old2NewLibDoc.Add(docid, d.DocID);
|
|
}
|
|
|
|
}
|
|
|
|
return d;
|
|
}
|
|
#endregion
|
|
|
|
private void btnCloseExport_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
private void btnCloseImport_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
}
|
|
}
|