Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

C2025-023 Electronic Procedures - Modifications to PROMS (Phase 1)

Browse Source
This commit is contained in:
Matthew Schill
2025-04-08 10:54:19 -04:00
parent 689ea71846
commit 6fd84e2f2a
23 changed files with 2791 additions and 1316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
PROMS/VEPROMS.CSLA.Library/Config/AnnotationConfig.cs Normal file
View File

@@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
namespace VEPROMS.CSLA.Library
{
//C2025-023 - Electronic Procedures - Modifications to PROMS
//new class to handle access of tblAnnotations.Config
[Serializable]
[TypeConverter(typeof(ExpandableObjectConverter))]
public class AnnotationConfig : ConfigDynamicTypeDescriptor, INotifyPropertyChanged
{
private XMLProperties _Xp;
private XMLProperties Xp
{
get { return _Xp; }
}
public AnnotationConfig(string xml)
{
if (xml == string.Empty) xml = "<Config/>";
_Xp = new XMLProperties(xml);
}
public AnnotationConfig()
{
_Xp = new XMLProperties();
}
public override string ToString()
{
string s = _Xp.ToString();
if (s == "<Config/>" || s == "<Config></Config>") return string.Empty;
return s;
}
public string GetValue(string group, string item)
{
return _Xp[group, item];
}
public void SetValue(string group, string item, string newvalue)
{
_Xp[group, item] = newvalue;
}
}
}

77
PROMS/VEPROMS.CSLA.Library/Extension/FormatExt.cs
View File

@@ -19,6 +19,7 @@ using System.Xml;
using System.Drawing;
using System.ComponentModel;
using System.Collections.Generic;
using Volian.Base.Library;
namespace VEPROMS.CSLA.Library
{
@@ -226,6 +227,34 @@ namespace VEPROMS.CSLA.Library
//}
}
OnFormatLoaded(null, new FormatEventArgs("Formats Updated"));
//C2025-023 - Electronic Procedures - Modifications to PROMS
//Begin section for processing Electronic Procedure (EP) Format Files
// now loop through all EP format files
string epPath = fmtPath.Replace("\\fmtall", "\\epall");
DirectoryInfo diEP = new DirectoryInfo(epPath);
if (diEP.Exists)
{
FileInfo[] fisEP = diEP.GetFiles("*.xml");
OnFormatLoaded(null, new FormatEventArgs(fisEP.Length.ToString() + " EP Formats to Load"));
foreach (FileInfo fi in fisEP)
{
string fmtname = Path.GetFileNameWithoutExtension(fi.Name);
try
{
AddEPFormatToDB(fmtname, DateTime.Now, VlnSettings.UserID, epPath);
}
catch (Exception ex)
{
Console.WriteLine("{0} - {1}", ex.GetType().Name, ex.Message);
}
}
OnFormatLoaded(null, new FormatEventArgs("EP Formats Updated"));
// update all in-use annotation types that have Electronic Procedures
EPFormatFile.UpdateAllInUseEPAnnotationTypes();
}
}
private static Dictionary<string, int> _LookupFormats;
@@ -338,8 +367,54 @@ namespace VEPROMS.CSLA.Library
}
return rec;
}
//C2025-023 - Electronic Procedures - Modifications to PROMS
//Procedure to load the EP format fiels into the DB
private static void AddEPFormatToDB(string formatname, DateTime Dts, string Userid, string epPath)
{
string fmtdata = null;
FileInfo fmtfi = null;
XmlDocument xd = null;
OnFormatLoaded(null, new FormatEventArgs("Loading Format " + formatname));
string path = Path.Combine(epPath, formatname + ".xml");
if (File.Exists(path))
{
try
{
using (StreamReader srf = new StreamReader(path))
{
fmtfi = new FileInfo(path);
xd = new XmlDocument();
xd.XmlResolver = null;
xd.Load(srf);
fmtdata = xd.OuterXml;
}
}
catch (Exception ex)
{
OnFormatLoaded(null, new FormatEventArgs("Error Loading Format " + formatname));
_MyLog.ErrorFormat($"AddEPFormatToDB('{path}')");
return;
}
}
if (string.IsNullOrEmpty(Userid)) Userid = "Migration";
try
{
EPFormatFile.UpdateEPFormat(formatname, fmtdata, Userid);
}
catch (Exception ex)
{
_MyLog.ErrorFormat($"AddFormatToDB-make format('{path}')");
}
}
}
public partial class FormatInfo : IFormatOrFormatInfo
public partial class FormatInfo : IFormatOrFormatInfo
{
//transition report stuff
private static Dictionary<int, string> _TransitionTypes;

39
PROMS/VEPROMS.CSLA.Library/Extension/ItemExt.cs
View File

@@ -2112,6 +2112,45 @@ namespace VEPROMS.CSLA.Library
return (sd.Type == type);
}
// C2025-023 - Electronic Procedures - Modifications to PROMS
//return EPFields that match this step type or a parent step type
public EPFields GetValidEPFields(int AnnTypeID)
{
EPFields filtered = new EPFields();
EPFields unfiltered = ActiveFormat.PlantFormat.EPFormatFiles.First(x => x.AnnotationTypeID == AnnTypeID).FieldList;
//Build list of step type and step type of it's parents
List<string> steptypelist = new List<string>();
if ((int)MyContent.Type < 20000) return filtered;
int stepType = ((int)MyContent.Type) % 10000;
StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
if (stepType > sdlist.MaxIndex)
{
Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
return filtered;
}
StepData sd = sdlist[stepType];
while (sd.Index != 0)
{
steptypelist.Add(sd.Type);
sd = sdlist[sd.ParentType];
}
//if unfiltered list contains All as a step type, include it
foreach (EPField EP in unfiltered)
{
//if unfiltered list contains All as a step type, include it
if (EP.IsValidForStepType("All"))
filtered.Add(EP);
//check for intersections between unfiltered list and step type list
if (EP.validforsteptypes.Any(steptypelist.Contains))
filtered.Add(EP);
}
return filtered;
}
// determine if the the current step should automatically be placed on the Continuous Action Summary
// Note, this logic only checks the format setting of the step. We will check the value of the Tag's Check Box later on.
public bool IncludeOnContActSum

343
PROMS/VEPROMS.CSLA.Library/Format/EPFormatFile.cs Normal file
View File

@@ -0,0 +1,343 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Xml;
using System.Linq;
using System.Data.SqlClient;
using System.Data;
using Csla.Data;
using static VEPROMS.CSLA.Library.ROFSTLookup;
namespace VEPROMS.CSLA.Library
{
//C2025-023 - Electronic Procedures - Modifications to PROMS
// class to handle storage and access of EPFormatFile and EPFormatFile details
#region EPFormatFiles
[TypeConverter(typeof(vlnListConverter<EPFormatFiles, EPFormatFile>))]
public class EPFormatFiles : vlnFormatList<EPFormatFile>
{
public EPFormatFiles(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region EPFormatFile
public class EPFormatFile : vlnFormatItem
{
#region Constructor
public EPFormatFile(XmlNode xmlNode) : base(xmlNode) { }
public EPFormatFile() : base() { }
#endregion
#region Business Fields
// Name of the EP Viewer Format File
private LazyLoad<string> _Name;
[DisplayName("Name")]
[Description("EP Viewer File Name")]
public string Name
{
get
{
return LazyLoad(ref _Name, "@Name");
}
}
// Name of the EP Viewer Format File
private LazyLoad<string> _Description;
[DisplayName("Description")]
[Description("EP Viewer Description")]
public string Description
{
get
{
return LazyLoad(ref _Description, "@Description");
}
}
// Id of Annotation Type Associated with this file
private LazyLoad<int?> _AnnotationTypeID;
[DisplayName("AnnotationTypeID")]
[Description("Id of Annotation Type Associated with this file")]
public int? AnnotationTypeID
{
get
{
return LazyLoad(ref _AnnotationTypeID, "@AnnotationTypeID");
}
}
// returns a list of fields that are defined in the EP format's structure
private EPFields _FieldList;
public EPFields FieldList
{
get
{
XmlDocument xd = GetEPFormatData(Name);
return _FieldList == null ? _FieldList = new EPFields(xd.SelectNodes("/EPFormat/EPField")) : _FieldList;
}
}
#endregion
#region Business Methods
// update all in-use annotation types that have Electronic Procedures
public static void UpdateAllInUseEPAnnotationTypes()
{
foreach (int formatid in GetAllInUseFormats())
{
PlantFormat frmt = FormatInfo.Get(formatid).PlantFormat;
foreach (EPFormatFile EP in frmt.EPFormatFiles)
{
UpdateAnnotationTypeAsEP((int) EP.AnnotationTypeID);
}
}
}
#endregion
#region Data Access
// static - Load EP Format details - save to db (insert/update)
public static void UpdateEPFormat(string name, string data, string userID)
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_UpdateEPFormat";
cm.Parameters.AddWithValue("@name", name);
cm.Parameters.AddWithValue("@data", data);
cm.Parameters.AddWithValue("@userID", userID);
cm.CommandTimeout = Database.DefaultTimeout;
cm.ExecuteNonQuery();
}
}
}
// load data for getting fieldlist for this EPFormat
public static XmlDocument GetEPFormatData(string name)
{
name = name.Replace(".xml", "");
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.Text;
cm.CommandText = "Select Data FROM EPFormats where Name = @Name";
cm.Parameters.AddWithValue("@Name", name);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (dr.Read())
{
XmlDocument xd = new XmlDocument();
xd.XmlResolver = null;
xd.LoadXml(dr.GetString("Data"));
return xd;
}
}
}
}
return null;
}
// Get all in-use formats
public static List<int> GetAllInUseFormats()
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.Text;
cm.CommandText = @"SELECT Distinct Formats.[FormatID]
FROM
(
SELECT FormatID FROM Contents
UNION
SELECT FormatID FROM DocVersions
UNION
SELECT FormatID FROM Folders
) inuse
inner join Formats
on inuse.FormatID = Formats.FormatID";
cm.CommandTimeout = Database.DefaultTimeout;
using (DataTable dt = new DataTable())
{
using (SqlDataAdapter da = new SqlDataAdapter(cm))
{
da.Fill(dt);
return dt.AsEnumerable().Select(x => x.Field<int>("FormatID")).ToList();
}
}
}
}
}
// update an annotation type as an Electronic Procedure Annotation Type
public static void UpdateAnnotationTypeAsEP(int typeID)
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.Text;
cm.CommandText = @"Update AnnotationTypes
SET IsEPAnnotationType = 1
WHERE TypeID = @typeID";
cm.Parameters.AddWithValue("@typeID", typeID);
cm.CommandTimeout = Database.DefaultTimeout;
cm.ExecuteNonQuery();
}
}
}
// Returns true if there are any EP Annotation Types
public static bool IsEPAnnotationType()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.Text;
cm.CommandText = @"SELECT RESULT = CASE WHEN
EXISTS(SELECT 1 FROM AnnotationTypes where IsEPAnnotationType = 1)
THEN 1 ELSE 0 END";
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (dr.Read() && dr.GetInt32("RESULT") == 1)
return true;
}
}
}
}
catch
{
// EP Support has not yet been added for this DB
// IsEPAnnotationType does not exist
// need to run PROMS Fixes
// until then will ignore EP code
// instead of crashing for a field not found
}
return false;
}
#endregion
}
public class EPFields : vlnFormatList<EPField>
{
public EPFields()
{
}
public EPFields(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
// EP field class
public class EPField : vlnFormatItem
{
public EPField(XmlNode xmlNode) : base(xmlNode) { }
public EPField() : base() { }
private LazyLoad<string> _name;
public string name
{
get
{
return LazyLoad(ref _name, "@name");
}
}
private LazyLoad<string> _type;
public string type
{
get
{
return LazyLoad(ref _type, "@type");
}
}
private LazyLoad<string> _label;
public string label
{
get
{
string tmp = LazyLoad(ref _label, "@label");
if (string.IsNullOrEmpty(tmp))
return LazyLoad(ref _name, "@name");
else
return tmp;
}
}
private LazyLoad<string> _text;
public string text
{
get
{
return LazyLoad(ref _text, "@text");
}
}
private LazyLoad<string> _rosource;
public string rosource
{
get
{
return LazyLoad(ref _rosource, "@rosource");
}
}
private LazyLoad<int?> _numlines;
public int numlines
{
get
{
int? tmp = LazyLoad(ref _numlines, "@numlines");
if (tmp == null)
return 1;
return (int) tmp;
}
}
//step types that the EPForma Item is valid for (as a list of types)
private LazyLoad<string> _validforsteptypes;
public List<string> validforsteptypes
{
get
{
try
{
string tmp = LazyLoad(ref _validforsteptypes, "@validforsteptypes");
return tmp.Split(',').Select(p => p.Trim()).ToList();
}
catch
{
throw new ArgumentException($"Error in validforsteptypes for EP file: {((EPFormatFile) MyParentFormat).Name}.xml, field: {name}");
}
}
}
public bool IsValidForStepType(string StepType)
{
return validforsteptypes.Contains(StepType);
}
//return a list of items based on the ROsource specified in the EPFormat File
public Dictionary<int, string> getROList(AnnotationInfo currAnn)
{
if (string.IsNullOrEmpty(rosource))
return new Dictionary<int, string>();
try
{
DocVersionInfo MyDocVersion = currAnn.MyItem.MyDocVersion;
ROFSTLookup lookup = MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(MyDocVersion);
string roid = FormatRoidKey(rosource, false);
rochild[] children = lookup.GetRoChildrenByRoid(roid);
return children.Select(x => new { x.ID, x.title }).ToDictionary(t => t.ID, t => t.title);
}
catch (Exception Ex)
{
throw new ArgumentException($"Error in rosource for EP file: {((EPFormatFile)MyParentFormat).Name}.xml, field: {name}");
}
}
}
#endregion
}

12
PROMS/VEPROMS.CSLA.Library/Format/PlantFormat.cs
View File

@@ -192,6 +192,18 @@ namespace VEPROMS.CSLA.Library
}
return (retlist);
}
//C2025-023 - Electronic Procedures - Modifications to PROMS
// EPFormatFiles contains which Electronic Procedure Format files apply to this main format file.
private EPFormatFiles _EPFormatFiles;
public EPFormatFiles EPFormatFiles
{
get
{
if (_EPFormatFiles == null) _EPFormatFiles = new EPFormatFiles(XmlDoc.SelectNodes("/PlantFormat/EPFormatFiles/EPFormatFile"));
return _EPFormatFiles;
}
}
}
#endregion
#region VE_Font

2
PROMS/VEPROMS.CSLA.Library/Format/vlnFormat.cs
View File

@@ -57,6 +57,8 @@ namespace VEPROMS.CSLA.Library
XmlNode xn = xmlNode.SelectSingleNode(path);
if (xmlNode.Name == "Box") return xn; // if box, don't do inheritance.
if (xmlNode.Name == "DocStyle") return xn;
//C2025-023 - Electronic Procedures - Modifications to PROMS
if (xmlNode.Name == "EPField") return xn; // if Electronic Procedure Field, don't do inheritance.
if (xmlNode.Name == "StructureStyle")
{
Volian.Base.Library.DebugText.WriteLine("vlnFormatDocument:LookupSingleNode:StructureStyle - shouldn't get to this line of code.\r\nPath = {0}", path);

25
PROMS/VEPROMS.CSLA.Library/Generated/AnnotationType.cs
View File

@@ -18,6 +18,8 @@ using System.IO;
using System.ComponentModel;
using System.Collections.Generic;
using Csla.Validation;
using System.Linq;
namespace VEPROMS.CSLA.Library
{
/// <summary>
@@ -207,6 +209,27 @@ namespace VEPROMS.CSLA.Library
}
}
}
//C2025-023 - Electronic Procedures - Modifications to PROMS
// Is Annotation Type an EP Annotation?
private bool _IsEPAnnotationType = false;
public bool IsEPAnnotationType
{
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
get
{
return _IsEPAnnotationType;
}
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
set
{
if (_IsEPAnnotationType != value)
{
_IsEPAnnotationType = value;
PropertyHasChanged();
}
}
}
private byte[] _LastChanged = new byte[8];//timestamp
private int _AnnotationTypeAnnotationCount = 0;
/// <summary>
@@ -712,6 +735,8 @@ namespace VEPROMS.CSLA.Library
_UserID = dr.GetString("UserID");
dr.GetBytes("LastChanged", 0, _LastChanged, 0, 8);
_AnnotationTypeAnnotationCount = dr.GetInt32("AnnotationCount");
if (dr.GetSchemaTable().Rows.OfType<DataRow>().Any(row => row["ColumnName"].ToString() == "IsEPAnnotationType"))
_IsEPAnnotationType = (bool)dr.GetValue("IsEPAnnotationType");
MarkOld();
}
catch (Exception ex)

17
PROMS/VEPROMS.CSLA.Library/Generated/AnnotationTypeInfo.cs
View File

@@ -17,6 +17,8 @@ using System.Configuration;
using System.IO;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
namespace VEPROMS.CSLA.Library
{
public delegate void AnnotationTypeInfoEvent(object sender);
@@ -135,6 +137,19 @@ namespace VEPROMS.CSLA.Library
return _UserID;
}
}
//C2025-023 - Electronic Procedures - Modifications to PROMS
// Is Annotation Type an EP Annotation?
private bool _IsEPAnnotationType = false;
public bool IsEPAnnotationType
{
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
get
{
return _IsEPAnnotationType;
}
}
private int _AnnotationTypeAnnotationCount = 0;
/// <summary>
/// Count of AnnotationTypeAnnotations for this AnnotationType
@@ -312,6 +327,8 @@ namespace VEPROMS.CSLA.Library
_DTS = dr.GetDateTime("DTS");
_UserID = dr.GetString("UserID");
_AnnotationTypeAnnotationCount = dr.GetInt32("AnnotationCount");
if (dr.GetSchemaTable().Rows.OfType<DataRow>().Any(row => row["ColumnName"].ToString() == "IsEPAnnotationType"))
_IsEPAnnotationType = (bool)dr.GetValue("IsEPAnnotationType");
}
catch (Exception ex)
{

3
PROMS/VEPROMS.CSLA.Library/VEPROMS.CSLA.Library.csproj
View File

@@ -98,6 +98,7 @@
<Reference Include="System" />
<Reference Include="System.configuration" />
<Reference Include="System.Data" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="System.Design" />
<Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" />
@@ -107,6 +108,7 @@
<Compile Include="..\VEPROMS User Interface\Properties\Settings.Designer.cs">
<Link>Properties\Settings.Designer.cs</Link>
</Compile>
<Compile Include="Config\AnnotationConfig.cs" />
<Compile Include="Config\AnnotationTypeConfig.cs" />
<Compile Include="Config\AssocConfig.cs" />
<Compile Include="Config\ColorConfig.cs" />
@@ -164,6 +166,7 @@
<Compile Include="Format\Comparator.cs" />
<Compile Include="Format\DocStyles.cs" />
<Compile Include="Format\ENums.cs" />
<Compile Include="Format\EPFormatFile.cs" />
<Compile Include="Format\PageStyles.cs" />
<Compile Include="Format\PlantFormat.cs" />
<Compile Include="Format\vlnFormat.cs" />