249ddafe54
Added property settings WhatROsToConvert, SelectedROFst, AnnotateWhenConvertingToText, AnnotateWhenShowingMissingRO, and AnnotateWhenShowingDifferentRO. Added ROUpdateMode enum Changed how text is added to tbErrors textbox Added property settings WhatROsToConvert, SelectedROFst, AnnotateWhenConvertingToText, AnnotateWhenShowingMissingRO, and AnnotateWhenShowingDifferentRO Added createEmptyPROMS boolean value to allow creating an empty PROMS database Added loadTree menu item click event handler Added Load Tree menu item, Selection main menu with Fix ROs menu item under Selection menu item and Create Empty database menu item Used createEmptyPROMS value. Changed how Migration Error annotation type created.
674 lines
22 KiB
C#
674 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.ComponentModel;
|
|
using System.Drawing.Design;
|
|
using System.Reflection;
|
|
using System.Data;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Data.SqlClient;
|
|
|
|
namespace DataLoader
|
|
{
|
|
[Serializable]
|
|
class DataLoaderSettings:ICloneable
|
|
{
|
|
#region Clone
|
|
public object Clone()
|
|
{
|
|
MemoryStream memoryStream = new MemoryStream();
|
|
BinaryFormatter binaryFormatter = new BinaryFormatter();
|
|
|
|
binaryFormatter.Serialize(memoryStream, this);
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
return binaryFormatter.Deserialize(memoryStream);
|
|
}
|
|
#endregion
|
|
#region 16-Bit Executable
|
|
private string _VEPromsPath; // Folder
|
|
[Category("16-Bit Executable")]
|
|
[DisplayName("VEProms Exe Folder")]
|
|
[Description("Path to the VE-PROMS Executable Folder")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string VEPromsPath
|
|
{
|
|
get { return _VEPromsPath; }
|
|
set { _VEPromsPath = value; }
|
|
}
|
|
private string _VESamFile; // File
|
|
[Category("16-Bit Executable")]
|
|
[DisplayName("VEProms Security File")]
|
|
[Description("VE-PROMS Securty File (VESam)")]
|
|
[UIFilenameEditor.FileDialogFilterAttribute("VEProms Security File|vesam.opt")]
|
|
[EditorAttribute(typeof(UIFilenameEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string VESamFile
|
|
{
|
|
get { return _VESamFile; }
|
|
set { _VESamFile = value; }
|
|
}
|
|
#endregion
|
|
#region 16-Bit Data
|
|
private string _ProcedureSetPath; // Folder
|
|
[Category("16-Bit Data")]
|
|
[DisplayName("Procedure Folder")]
|
|
[Description("Path to the Data Set being converted")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string ProcedureSetPath
|
|
{
|
|
get { return _ProcedureSetPath; }
|
|
set { _ProcedureSetPath = value; }
|
|
}
|
|
private bool _OnlyThisSet; // Boolean
|
|
[Category("16-Bit Data")]
|
|
[DisplayName("Only Process this Procedure Set")]
|
|
[Description("Only Convert the Selected Procedure Set")]
|
|
public bool OnlyThisSet
|
|
{
|
|
get { return _OnlyThisSet; }
|
|
set { _OnlyThisSet = value; }
|
|
}
|
|
private bool _LoadApproved; // Boolean
|
|
[Category("16-Bit Data")]
|
|
[DisplayName("Load approved data for this Procedure Set")]
|
|
[Description("Load approved PDFs (if they exist) and consistency checks for the Selected Procedure Set")]
|
|
public bool LoadApproved
|
|
{
|
|
get { return _LoadApproved; }
|
|
set { _LoadApproved = value; }
|
|
}
|
|
private string _ProcessOnlyInLocation; // Folder
|
|
[Category("16-Bit Data")]
|
|
[DisplayName("Process Only In Location")]
|
|
[Description("Limit to folder or group of folders (otherwise all plants will be processed)")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string ProcessOnlyInLocation
|
|
{
|
|
get { return _ProcessOnlyInLocation; }
|
|
set { _ProcessOnlyInLocation = value; }
|
|
}
|
|
#endregion
|
|
#region Format Data
|
|
private string _FormatFolder; // Folder
|
|
[Category("Format Data")]
|
|
[DisplayName("Format Folder")]
|
|
[Description("Location of XML Format Files.")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string FormatFolder
|
|
{
|
|
get { return _FormatFolder; }
|
|
set { _FormatFolder = value; }
|
|
}
|
|
private string _GenMacFolder; // Folder
|
|
[Category("Format Data")]
|
|
[DisplayName("GenMac Folder")]
|
|
[Description("Location of XML (SVG) GenMac Macro Files.")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string GenMacFolder
|
|
{
|
|
get { return _GenMacFolder; }
|
|
set { _GenMacFolder = value; }
|
|
}
|
|
#endregion
|
|
#region Backup Data
|
|
private string _BackupFileName; // String
|
|
[Category("Backup Data")]
|
|
[DisplayName("Backup File Name")]
|
|
[Description("Name of Backup File in the batch files created in the Log Folder")]
|
|
public string BackupFileName
|
|
{
|
|
get { return _BackupFileName; }
|
|
set { _BackupFileName = value; }
|
|
}
|
|
private string _BackupFolder; // Folder
|
|
[Category("Backup Data")]
|
|
[DisplayName("Backup Folder")]
|
|
[Description("Location of Backup Files created during each phase of the conversion process.")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string BackupFolder
|
|
{
|
|
get { return _BackupFolder; }
|
|
set { _BackupFolder = value; }
|
|
}
|
|
private string _Phase1Suffix; // String
|
|
[Category("Backup Data")]
|
|
[DisplayName("Phase 1 Suffix")]
|
|
[Description("Suffix to use for backup before Transitions are Fixed")]
|
|
public string Phase1Suffix
|
|
{
|
|
get { return _Phase1Suffix; }
|
|
set { _Phase1Suffix = value; }
|
|
}
|
|
private string _Phase2Suffix; // String
|
|
[Category("Backup Data")]
|
|
[DisplayName("Phase 2 Suffix")]
|
|
[Description("Suffix to use for backup before Change Manager Script")]
|
|
public string Phase2Suffix
|
|
{
|
|
get { return _Phase2Suffix; }
|
|
set { _Phase2Suffix = value; }
|
|
}
|
|
private string _Phase3Suffix; // String
|
|
[Category("Backup Data")]
|
|
[DisplayName("Phase 3 Suffix")]
|
|
[Description("Suffix to use for backup before Approval Script")]
|
|
public string Phase3Suffix
|
|
{
|
|
get { return _Phase3Suffix; }
|
|
set { _Phase3Suffix = value; }
|
|
}
|
|
private string _Phase4Suffix; // String
|
|
[Category("Backup Data")]
|
|
[DisplayName("Phase 4 Suffix")]
|
|
[Description("Suffix to use for backup before Loading Approved Data")]
|
|
public string Phase4Suffix
|
|
{
|
|
get { return _Phase4Suffix; }
|
|
set { _Phase4Suffix = value; }
|
|
}
|
|
#endregion
|
|
#region Process Log
|
|
private string _LogFilePath; // Folder
|
|
[Category("Process Log")]
|
|
[DisplayName("Log File Folder")]
|
|
[Description("Location of the Log Files")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string LogFilePath
|
|
{
|
|
get { return _LogFilePath; }
|
|
set { _LogFilePath = value; }
|
|
}
|
|
#endregion
|
|
#region Sql Database
|
|
private string _ConnectionString; // String
|
|
[Category("Sql Database")]
|
|
[DisplayName("SQL Connection String")]
|
|
[Description("Connection string for SQL")]
|
|
public string ConnectionString
|
|
{
|
|
get { return _ConnectionString; }
|
|
set { _ConnectionString = value; }
|
|
}
|
|
private string _DBName; // String
|
|
[Category("Sql Database")]
|
|
[DisplayName("Database Name")]
|
|
[Description("Name of the Database that will be created to contain the converted data.")]
|
|
public string DBName
|
|
{
|
|
get { return _DBName; }
|
|
set { _DBName = value; }
|
|
}
|
|
private string _DBPath; // Folder
|
|
[Category("Sql Database")]
|
|
[DisplayName("Database File Folder")]
|
|
[Description("Location of the Database files.")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string DBPath
|
|
{
|
|
get { return _DBPath; }
|
|
set { _DBPath = value; }
|
|
}
|
|
private bool _PurgeExistingData;
|
|
[Category("Sql Database")]
|
|
[DisplayName("Purge Existing Data")]
|
|
[Description("Should the data in the SQL database be purged (emptied) before adding this data.")]
|
|
public bool PurgeExistingData
|
|
{
|
|
get { return _PurgeExistingData; }
|
|
set { _PurgeExistingData = value; }
|
|
}
|
|
#endregion
|
|
#region PDFs
|
|
private string _PDFFolder; // Folder
|
|
[Category("PDFs")]
|
|
[DisplayName("PDF Folder")]
|
|
[Description("Location for PDFs when printing.")]
|
|
[EditorAttribute(typeof(UIFolderEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string PDFFolder
|
|
{
|
|
get { return _PDFFolder; }
|
|
set { _PDFFolder = value; }
|
|
}
|
|
#endregion
|
|
#region Debugging
|
|
private ExecutionMode _ExecutionMode;
|
|
[TypeConverter(typeof(EnumDescConverter))]
|
|
[DisplayName("Execution Mode")]
|
|
[Category("Debugging")]
|
|
[Description("Mode for Conversion")]
|
|
public ExecutionMode ExecutionMode
|
|
{
|
|
get { return _ExecutionMode; }
|
|
set { _ExecutionMode = value; }
|
|
}
|
|
private bool _CheckRTF;
|
|
[DisplayName("Check RTF")]
|
|
[Category("Debugging")]
|
|
[Description("This makes the Fix Transtion Code work Differently. Not sure what it does.")]
|
|
public bool CheckRTF
|
|
{
|
|
get { return _CheckRTF; }
|
|
set { _CheckRTF = value; }
|
|
}
|
|
private int _Skip; // Skip specified procedures during load.
|
|
[DisplayName("Skip First n Procedures")]
|
|
[Category("Debugging")]
|
|
[Description("Skip the specified number of procedures during conversion to get to a problem quicker.")]
|
|
public int Skip
|
|
{
|
|
get { return _Skip; }
|
|
set { _Skip = value; }
|
|
}
|
|
#endregion
|
|
#region Accessory Pages
|
|
private AccPageConversion _ConvertTo;
|
|
[TypeConverter(typeof(EnumDescConverter))]
|
|
[DisplayName("Convert To")]
|
|
[Category("Accessory Pages")]
|
|
[Description("Format to which the Accessory Page converted")]
|
|
public AccPageConversion ConvertTo
|
|
{
|
|
get { return _ConvertTo; }
|
|
set { _ConvertTo = value; }
|
|
}
|
|
private bool _RedPDFs; // Boolean
|
|
[Category("Accessory Pages")]
|
|
[DisplayName("Print MSWord PDFs in Red")]
|
|
[Description("Creates Word PDFs in Debug Mode so that Debug printing will not require Word to print again.")]
|
|
public bool RedPDFs
|
|
{
|
|
get { return _RedPDFs; }
|
|
set { _RedPDFs = value; }
|
|
}
|
|
#endregion
|
|
#region RO Update
|
|
private ROUpdateMode _WhatROsToConvert = 0;
|
|
[Category("RO Update")]
|
|
[DisplayName("What ROs To Convert")]
|
|
[Description("Select which ROs should be converted.")]
|
|
public ROUpdateMode WhatROsToConvert
|
|
{
|
|
get { return _WhatROsToConvert; }
|
|
set { _WhatROsToConvert = value; }
|
|
}
|
|
private int _SelectedROFst = -1;
|
|
[Category("RO Update")]
|
|
[DisplayName("Selected ROFst")]
|
|
[Description("Enter which ROFstID is the basis for the original text (-1 = None).")]
|
|
public int SelectedROFst
|
|
{
|
|
get { return _SelectedROFst; }
|
|
set { _SelectedROFst = value; }
|
|
}
|
|
private bool _AnnotateWhenConvertingToText;
|
|
[Category("RO Update")]
|
|
[DisplayName("Annotate When Converting To Text")]
|
|
[Description("Should the step have annotation when the ro data has been converted to text.")]
|
|
public bool AnnotateWhenConvertingToText
|
|
{
|
|
get { return _AnnotateWhenConvertingToText; }
|
|
set { _AnnotateWhenConvertingToText = value; }
|
|
}
|
|
private bool _AnnotateWhenShowingMissingRO;
|
|
[Category("RO Update")]
|
|
[DisplayName("Annotate When Showing Missing RO")]
|
|
[Description("Should the step have annotation when the ro data is missing and is being displayed as a question mark.")]
|
|
public bool AnnotateWhenShowingMissingRO
|
|
{
|
|
get { return _AnnotateWhenShowingMissingRO; }
|
|
set { _AnnotateWhenShowingMissingRO = value; }
|
|
}
|
|
private bool _AnnotateWhenShowingDifferentRO;
|
|
[Category("RO Update")]
|
|
[DisplayName("Annotate When Showing Different RO")]
|
|
[Description("Should the step have annotation when the ro data is different.")]
|
|
public bool AnnotateWhenShowingDifferentRO
|
|
{
|
|
get { return _AnnotateWhenShowingDifferentRO; }
|
|
set { _AnnotateWhenShowingDifferentRO = value; }
|
|
}
|
|
#endregion
|
|
[Browsable(false)]
|
|
public string ValidityCheck
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
string ErrorPrefix = "Settings are not valid\r\n";
|
|
// VEPromsPath = has to be non-blank
|
|
if ((VEPromsPath ?? "") == "" || !Directory.Exists(VEPromsPath))
|
|
{
|
|
sb.Append(ErrorPrefix + "VEProms Exe Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// VESamFile = has to be non-blank
|
|
if ((VESamFile ?? "") == "" || !File.Exists(VESamFile))
|
|
{
|
|
sb.Append(ErrorPrefix + "VEProms Security File must point to an existing file\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// ProcedureSetPath = If OnlyThisSet is checked, then has to be non-blank
|
|
if (OnlyThisSet)
|
|
{
|
|
if ((ProcedureSetPath ?? "") == "" || !Directory.Exists(ProcedureSetPath))
|
|
{
|
|
sb.Append(ErrorPrefix + "Procedure Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
else
|
|
{
|
|
if (!File.Exists(ProcedureSetPath + @"\set.dbf"))
|
|
{
|
|
sb.Append(ErrorPrefix + "Procedure Folder must point to an existing procedure data folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
}
|
|
}
|
|
//added by jcb 20121127
|
|
//check is ProcedureSetPath contains ProcessOnlyInLocation
|
|
if (ProcedureSetPath != null && ProcedureSetPath.StartsWith(ProcessOnlyInLocation ?? "") == false)
|
|
{
|
|
sb.Append(ErrorPrefix + "Check Process Only In Location value is pointing to similar directory as Procedure Set Path\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
//end added by jcb 20121127
|
|
// BackupFileName = Has to be non-blank
|
|
if ((BackupFileName ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "Backup File Name must not be blank\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
if ((Phase1Suffix ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "Phase 1 Suffix must not be blank\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
if ((Phase2Suffix ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "Phase 2 Suffix must not be blank\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
if ((Phase3Suffix ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "Phase 3 Suffix must not be blank\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// BackupFolder = Has to be non-blank
|
|
if (OnlyThisSet && (BackupFolder ?? "") == "" || !Directory.Exists(BackupFolder))
|
|
{
|
|
sb.Append(ErrorPrefix + "Backup Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// FormatFolder = Has to be non-blank
|
|
if (OnlyThisSet && (FormatFolder ?? "") == "" || !Directory.Exists(FormatFolder))
|
|
{
|
|
sb.Append(ErrorPrefix + "Format Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// GenMacFolder = Has to be non-blank
|
|
if (OnlyThisSet && (GenMacFolder ?? "") == "" || !Directory.Exists(GenMacFolder))
|
|
{
|
|
sb.Append(ErrorPrefix + "GenMac Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// LogFilePath = Has to be non-blank
|
|
if (OnlyThisSet && (LogFilePath ?? "") == "" || !Directory.Exists(LogFilePath))
|
|
{
|
|
sb.Append(ErrorPrefix + "Log File Folder must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// ConnectionString = Has to be non-blank
|
|
if ((ConnectionString ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "SQL Connection String must be a valid connection string\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
else
|
|
{
|
|
// Validate ConnectionString
|
|
string checkConnectionString = ValidateConnectionString("Master");
|
|
if (checkConnectionString != "")
|
|
{
|
|
sb.Append(ErrorPrefix + "SQL Connection String must be a valid connection string\r\n");
|
|
sb.Append(checkConnectionString);
|
|
ErrorPrefix = "";
|
|
}
|
|
}
|
|
// DBName = Has to be non-blank
|
|
if ((DBName ?? "") == "")
|
|
{
|
|
sb.Append(ErrorPrefix + "SQL Database Name must be a valid database name\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// DBPath = if null check to see if DBName DB has Path, if it does then set DBPath
|
|
if ((DBPath ?? "") == "" || !Directory.Exists(DBPath))
|
|
{
|
|
string filePath = GetDBFileName();
|
|
if (filePath != null)
|
|
{
|
|
FileInfo fi = new FileInfo(filePath);
|
|
DBPath = fi.DirectoryName;
|
|
}
|
|
else
|
|
{
|
|
sb.Append(ErrorPrefix + "SQL Database Path must point to an existing folder\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
}
|
|
// PDFFolder = if not set, then don't set PDFFolder in DocVersion.Config
|
|
if (ExecutionMode == ExecutionMode.Debug && ((PDFFolder ?? "") == "" || !Directory.Exists(PDFFolder)))
|
|
{
|
|
sb.Append(ErrorPrefix + "PDF Folder must point to an existing folder in debug mode\r\n");
|
|
ErrorPrefix = "";
|
|
}
|
|
// Skip = Any NUmber
|
|
// PurgeExistingData = N/A
|
|
// OnlyThisSet = N/A
|
|
// CheckRTF = N/A
|
|
// ConvertTo = N/A
|
|
// RedPDFs = N/A
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
private string ValidateConnectionString(string dbName)
|
|
{
|
|
if(!ConnectionString.Contains("{DBName}"))
|
|
return " Needs to have a {DBName} token for the Initial Catalog";
|
|
string cnstr = ConnectionString.Replace("{DBName}", dbName);
|
|
try
|
|
{
|
|
SqlConnection cn = new SqlConnection(cnstr);
|
|
cn.Open();
|
|
cn.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
while (ex != null)
|
|
{
|
|
sb.Append(string.Format(" {0}-{1}",ex.GetType().Name,ex.Message));
|
|
ex = ex.InnerException;
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
return "";
|
|
}
|
|
private string GetDBFileName()
|
|
{
|
|
string filename = null;
|
|
SqlConnection cn = new SqlConnection(ConnectionString.Replace("{DBName}","Master"));
|
|
cn.Open();
|
|
string cmd = string.Format("Select FileName from sysdatabases where Name = '{0}'",DBName);
|
|
SqlDataAdapter da = new SqlDataAdapter(cmd,cn);
|
|
DataSet ds = new DataSet();
|
|
da.Fill(ds);
|
|
if (ds.Tables.Count == 1 && ds.Tables[0].Rows.Count == 1)
|
|
filename = ds.Tables[0].Rows[0][0].ToString();
|
|
cn.Close();
|
|
return filename;
|
|
}
|
|
}
|
|
public enum AccPageConversion : int
|
|
{
|
|
[Description("Don't Convert")] DoNotConvert=0,
|
|
[Description("MS Word")] MSWord = 1,
|
|
[Description("Rich Text Format")] RichTextFormat = 2
|
|
}
|
|
public enum ExecutionMode : int
|
|
{
|
|
[Description("Debug")] Debug = 0,
|
|
[Description("Production")] Production = 1,
|
|
}
|
|
public enum ROUpdateMode : int
|
|
{
|
|
[Description("None")]
|
|
None = 0,
|
|
[Description("Missing")]
|
|
Missing = 1,
|
|
[Description("All")]
|
|
All = 2,
|
|
}
|
|
|
|
public class EnumDescConverter : System.ComponentModel.EnumConverter
|
|
{
|
|
protected System.Type myVal;
|
|
|
|
/// <summary>
|
|
/// Gets Enum Value's Description Attribute
|
|
/// </summary>
|
|
/// <param name="value">The value you want the description attribute for</param>
|
|
/// <returns>The description, if any, else it's .ToString()</returns>
|
|
public static string GetEnumDescription(Enum value)
|
|
{
|
|
//Console.WriteLine("{0}", value);
|
|
FieldInfo fi = value.GetType().GetField(value.ToString());
|
|
DescriptionAttribute[] attributes =
|
|
(DescriptionAttribute[])fi.GetCustomAttributes(
|
|
typeof(DescriptionAttribute), false);
|
|
//Console.WriteLine("{0},{1},{2}", value.ToString(), attributes.Length, (attributes.Length > 0) ? attributes[0].Description : value.ToString());
|
|
return (attributes.Length > 0) ? attributes[0].Description : value.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the description for certaing named value in an Enumeration
|
|
/// </summary>
|
|
/// <param name="value">The type of the Enumeration</param>
|
|
/// <param name="name">The name of the Enumeration value</param>
|
|
/// <returns>The description, if any, else the passed name</returns>
|
|
public static string GetEnumDescription(System.Type value, string name)
|
|
{
|
|
FieldInfo fi = value.GetField(name);
|
|
DescriptionAttribute[] attributes =
|
|
(DescriptionAttribute[])fi.GetCustomAttributes(
|
|
typeof(DescriptionAttribute), false);
|
|
return (attributes.Length > 0) ? attributes[0].Description : name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the value of an Enum, based on it's Description Attribute or named value
|
|
/// </summary>
|
|
/// <param name="value">The Enum type</param>
|
|
/// <param name="description">The description or name of the element</param>
|
|
/// <returns>The value, or the passed in description, if it was not found</returns>
|
|
public static object GetEnumValue(System.Type value, string description)
|
|
{
|
|
FieldInfo[] fis = value.GetFields();
|
|
foreach (FieldInfo fi in fis)
|
|
{
|
|
DescriptionAttribute[] attributes =
|
|
(DescriptionAttribute[])fi.GetCustomAttributes(
|
|
typeof(DescriptionAttribute), false);
|
|
if (attributes.Length > 0)
|
|
{
|
|
if (attributes[0].Description == description)
|
|
{
|
|
return fi.GetValue(fi.Name);
|
|
}
|
|
}
|
|
if (fi.Name == description)
|
|
{
|
|
return fi.GetValue(fi.Name);
|
|
}
|
|
}
|
|
return description;
|
|
}
|
|
|
|
public EnumDescConverter(System.Type type)
|
|
: base(type.GetType())
|
|
{
|
|
myVal = type;
|
|
}
|
|
|
|
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
|
|
{
|
|
if (value is Enum && destinationType == typeof(string))
|
|
{
|
|
return EnumDescConverter.GetEnumDescription((Enum)value);
|
|
}
|
|
if (value is string && destinationType == typeof(string))
|
|
{
|
|
return EnumDescConverter.GetEnumDescription(myVal, (string)value);
|
|
}
|
|
return base.ConvertTo(context, culture, value, destinationType);
|
|
}
|
|
|
|
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
|
|
{
|
|
if (value is string)
|
|
{
|
|
return EnumDescConverter.GetEnumValue(myVal, (string)value);
|
|
}
|
|
if (value is Enum)
|
|
{
|
|
return EnumDescConverter.GetEnumDescription((Enum)value);
|
|
}
|
|
return base.ConvertFrom(context, culture, value);
|
|
}
|
|
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
|
|
{
|
|
ArrayList values = new ArrayList();
|
|
FieldInfo[] fis = myVal.GetFields();
|
|
foreach (FieldInfo fi in fis)
|
|
{
|
|
DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(
|
|
typeof(DescriptionAttribute), false);
|
|
//if (attributes.Length > 0)
|
|
if (fi.Name != "value__")
|
|
values.Add(fi.GetValue(fi.Name));
|
|
}
|
|
return new TypeConverter.StandardValuesCollection(values);
|
|
}
|
|
public static string GetEnumKeyDescription(Enum value)
|
|
{
|
|
FieldInfo fi = value.GetType().GetField(value.ToString());
|
|
DescriptionAttribute[] attributes =
|
|
(DescriptionAttribute[])fi.GetCustomAttributes(
|
|
typeof(DescriptionAttribute), false);
|
|
return (attributes.Length > 0) ? attributes[0].Description : value.ToString();
|
|
}
|
|
|
|
public static DataTable GetEnumAsDataTable(System.Type EnumType)
|
|
{
|
|
DataTable DTEnum = new DataTable();
|
|
DTEnum.Columns.Add(new DataColumn("EnumID", typeof(Int32)));
|
|
DTEnum.Columns.Add(new DataColumn("Enum", typeof(string)));
|
|
DTEnum.Columns.Add(new DataColumn("Description", typeof(string)));
|
|
foreach (int i in Enum.GetValues(EnumType))
|
|
{
|
|
System.Enum fooItem = (System.Enum)Enum.ToObject(EnumType, i);
|
|
DTEnum.Rows.Add(new object[] { i, fooItem.ToString(), GetEnumKeyDescription(fooItem) });
|
|
}
|
|
return DTEnum;
|
|
}
|
|
}
|
|
|
|
}
|