618 lines
20 KiB
C#
618 lines
20 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
|
|
[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.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 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;
|
|
}
|
|
}
|
|
|
|
}
|