private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
if (this.ContinueRuleDefinitionsChange())
{
selectedRuleSetData = null;
List<RuleSetData> ruleSetDataCollection = this.GetRuleSets();
this.BuildTree(ruleSetDataCollection);
this.EnableApplicationFields(true);
this.EnableRuleSetFields(false);
}
}
private bool IsDuplicateRuleSet(string name, int majorVersion, int minorVersion, out RuleSetData duplicateRuleSetData)
{
foreach (RuleSetData data in ruleSetDataDictionary.Values)
{
if (String.CompareOrdinal(data.Name, name) == 0 && data.MajorVersion == majorVersion && data.MinorVersion == minorVersion)
{
duplicateRuleSetData = data;
return true;
}
}
duplicateRuleSetData = null;
return false;
}
private void MarkDirty(RuleSetData data)
{
if (data != null)
data.Dirty = true;
dirty = true;
}
private List<RuleSetData> GetRuleSets()
{
List<RuleSetData> ruleSetDataCollection = new List<RuleSetData>();
dirty = false;
using (SqlConnection sqlConn = new SqlConnection(connectionString))
{
sqlConn.Open();
string commandString = "SELECT Name, MajorVersion, MinorVersion, RuleSet, Status, AssemblyPath, ActivityName, ModifiedDate FROM RuleSet ORDER BY Name,MajorVersion, MinorVersion";
SqlCommand command = new SqlCommand(commandString, sqlConn);
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
try
{
RuleSetData data = new RuleSetData();
data.Name = reader.GetString(0);
data.OriginalName = data.Name; // will be used later to see if one of these key values changed
data.MajorVersion = reader.GetInt32(1);
data.OriginalMajorVersion = data.MajorVersion;
data.MinorVersion = reader.GetInt32(2);
data.OriginalMinorVersion = data.MinorVersion;
data.RuleSetDefinition = reader.GetString(3);
data.Status = reader.GetInt16(4);
data.AssemblyPath = reader.GetString(5);
data.ActivityName = reader.GetString(6);
data.ModifiedDate = reader.GetDateTime(7);
data.Dirty = false;
ruleSetDataCollection.Add(data);
}
catch (InvalidCastException)
{
MessageBox.Show("Error parsing table row.", "RuleSet Open Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
sqlConn.Close();
}
return ruleSetDataCollection;
}
private TreeNode GetTreeNodeForRuleSetData(RuleSetData data)
{
if (data != null)
{
Dictionary<TreeNode, RuleSetData>.Enumerator enumerator = ruleSetDataDictionary.GetEnumerator();
while (enumerator.MoveNext())
{
RuleSetData otherData = enumerator.Current.Value;
if (String.CompareOrdinal(otherData.Name, data.Name) == 0 && otherData.MajorVersion == data.MajorVersion && otherData.MinorVersion == data.MinorVersion)
return enumerator.Current.Key;
}
}
return null;
}
private TreeNode FindParentNode(RuleSetData data)
{
if (data != null)
{
foreach (TreeNode node in treeView1.Nodes)
{
if (String.CompareOrdinal(node.Text, data.Name) == 0)
return node;
}
}
return null;
}
private void GenerateNewVersionInfo(RuleSetData currentRuleSetData, out int newMajorVersion, out int newMinorVersion)
{
List<RuleSetData> rsdOfInterest = new List<RuleSetData>();
foreach (RuleSetData data in ruleSetDataDictionary.Values)
{
if (data.Name == currentRuleSetData.Name && ((data.MajorVersion > currentRuleSetData.MajorVersion) || (data.MajorVersion == currentRuleSetData.MajorVersion && data.MinorVersion > currentRuleSetData.MinorVersion)))
rsdOfInterest.Add(data);
}
rsdOfInterest.Sort();
bool nextMajorTaken = false;
int lastMajorUsed = currentRuleSetData.MajorVersion;
int lastMinorUsed = currentRuleSetData.MinorVersion;
foreach (RuleSetData data in rsdOfInterest)
{
lastMajorUsed = data.MajorVersion;
if (data.MajorVersion == currentRuleSetData.MajorVersion)
lastMinorUsed = data.MinorVersion;
if (data.MajorVersion == currentRuleSetData.MajorVersion + 1)
nextMajorTaken = true;
}
if (!nextMajorTaken)
{
newMajorVersion = currentRuleSetData.MajorVersion + 1;
newMinorVersion = 0;
}
else if (lastMinorUsed < maxMinorVersions - 1)
{
newMajorVersion = currentRuleSetData.MajorVersion;
newMinorVersion = lastMinorUsed + 1;
}
else if (lastMajorUsed < maxMajorVersions - 1)
{
newMajorVersion = lastMajorUsed + 1;
newMinorVersion = 0;
}
else
{
newMajorVersion = currentRuleSetData.MajorVersion;
newMinorVersion = currentRuleSetData.MinorVersion;
MessageBox.Show(string.Format(CultureInfo.InvariantCulture, "Only {0} major versions are allowed for a single RuleSet name. \r\nYou must manually change the version information.", maxMajorVersions), "RuleSet Property Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private RuleSetData CreateRuleSetData(RuleSet ruleSet)
{
RuleSetData data = new RuleSetData();
if (ruleSet != null)
{
data.Name = ruleSet.Name;
data.RuleSet = ruleSet;
}
else
{
data.Name = this.GenerateRuleSetName();
data.RuleSet = new RuleSet(data.Name);
}
data.MajorVersion = 1;
this.MarkDirty(data);
return data;
}
private void AddRuleSetData(RuleSetData ruleSetData)
{
if (ruleSetData != null)
{
TreeNode parentNode = this.FindParentNode(ruleSetData);
if (parentNode == null)
{
parentNode = new TreeNode(ruleSetData.Name);
treeView1.Nodes.Add(parentNode);
}
TreeNode newVersionNode = new TreeNode(VersionTreeNodeText(ruleSetData.MajorVersion, ruleSetData.MinorVersion));
parentNode.Nodes.Add(newVersionNode);
treeView1.Sort();
ruleSetDataDictionary.Add(newVersionNode, ruleSetData);
this.SetSelectedNode(newVersionNode);
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
RuleSetData data;
if (e.Node != null && ruleSetDataDictionary.TryGetValue(e.Node, out data))
{
selectedRuleSetData = data;
assemblyPath = selectedRuleSetData.AssemblyPath;
ruleSetNameBox.Text = selectedRuleSetData.Name;
majorVersionBox.Value = selectedRuleSetData.MajorVersion;
minorVersionBox.Value = selectedRuleSetData.MinorVersion;
activityBox.Text = selectedRuleSetData.ActivityName;
if (selectedRuleSetData.Activity == null)
this.LoadAssemblyAndActivity();
this.PopulateMembers();
this.EnableRuleSetFields(true);
}
else
{
selectedRuleSetData = null;
assemblyPath = null;
this.EnableRuleSetFields(false);
}
}
public RuleSet GetRuleSet(RuleSetInfo ruleSetInfo)
{
if (ruleSetInfo != null)
{
SqlConnection sqlConn = new SqlConnection(connectionString);
sqlConn.Open();
string commandString;
// If both the major and minor are 0, it is assumed that a specific version is not being requested.
bool specificVersionRequested = !(ruleSetInfo.MajorVersion == 0 && ruleSetInfo.MinorVersion == 0);
if (specificVersionRequested)
{
commandString = String.Format(CultureInfo.InvariantCulture, "SELECT TOP 1 * FROM RuleSet WHERE Name=@name AND MajorVersion={0} AND MinorVersion={1} ORDER BY MajorVersion DESC, MinorVersion DESC", ruleSetInfo.MajorVersion, ruleSetInfo.MinorVersion);
}
else
{
commandString = "SELECT TOP 1 * FROM RuleSet WHERE Name=@name ORDER BY MajorVersion DESC , MinorVersion DESC";
}
SqlCommand command = new SqlCommand(commandString, sqlConn);
command.Parameters.Add("@name", System.Data.SqlDbType.NVarChar, 128);
command.Parameters["@name"].Value = ruleSetInfo.Name;
SqlDataReader reader = command.ExecuteReader();
RuleSetData data = null;
if (reader.HasRows)
{
reader.Read();
try
{
data = new RuleSetData();
data.Name = reader.GetString(0);
data.OriginalName = data.Name; // will be used later to see if one of these key values changed
data.MajorVersion = reader.GetInt32(1);
data.OriginalMajorVersion = data.MajorVersion;
data.MinorVersion = reader.GetInt32(2);
data.OriginalMinorVersion = data.MinorVersion;
data.RuleSetDefinition = reader.GetString(3);
data.Status = reader.GetInt16(4);
data.AssemblyPath = reader.GetString(5);
data.ActivityName = reader.GetString(6);
data.ModifiedDate = reader.GetDateTime(7);
data.Dirty = false;
}
catch (InvalidCastException)
{
MessageBox.Show("Error parsing table row", "RuleSet Open Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
sqlConn.Close();
if (data != null)
return data.RuleSet;
else if (specificVersionRequested)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Specified RuleSet version does not exist: '{0}'", ruleSetInfo.ToString())); //could use a custom exception type here
else
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "No RuleSets exist with this name: '{0}'", ruleSetInfo.Name));
}
else
{
return null;
}
}
public RuleSet GetRuleSet(RuleSetInfo ruleSetInfo)
{
if (ruleSetInfo != null)
{
SqlConnection sqlConn = new SqlConnection(connectionString);
sqlConn.Open();
string commandString;
// If both the major and minor are 0, it is assumed that a specific version is not being requested.
bool specificVersionRequested = !(ruleSetInfo.MajorVersion == 0 && ruleSetInfo.MinorVersion == 0);
if (specificVersionRequested)
{
commandString = String.Format(CultureInfo.InvariantCulture, "SELECT TOP 1 * FROM RuleSet WHERE Name=@name AND MajorVersion={0} AND MinorVersion={1} ORDER BY MajorVersion DESC, MinorVersion DESC", ruleSetInfo.MajorVersion, ruleSetInfo.MinorVersion);
}
else
{
commandString = "SELECT TOP 1 * FROM RuleSet WHERE Name=@name ORDER BY MajorVersion DESC , MinorVersion DESC";
}
SqlCommand command = new SqlCommand(commandString, sqlConn);
command.Parameters.Add("@name", System.Data.SqlDbType.NVarChar, 128);
command.Parameters["@name"].Value = ruleSetInfo.Name;
SqlDataReader reader = command.ExecuteReader();
RuleSetData data = null;
if (reader.HasRows)
{
reader.Read();
try
{
data = new RuleSetData();
data.Name = reader.GetString(0);
data.OriginalName = data.Name; // will be used later to see if one of these key values changed
data.MajorVersion = reader.GetInt32(1);
data.OriginalMajorVersion = data.MajorVersion;
data.MinorVersion = reader.GetInt32(2);
data.OriginalMinorVersion = data.MinorVersion;
data.RuleSetDefinition = reader.GetString(3);
data.Status = reader.GetInt16(4);
data.AssemblyPath = reader.GetString(5);
data.ActivityName = reader.GetString(6);
data.ModifiedDate = reader.GetDateTime(7);
data.Dirty = false;
}
catch (InvalidCastException)
{
MessageBox.Show("Error parsing table row", "RuleSet Open Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
sqlConn.Close();
if (data != null)
{
return(data.RuleSet);
}
else if (specificVersionRequested)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Specified RuleSet version does not exist: '{0}'", ruleSetInfo.ToString())); //could use a custom exception type here
}
else
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "No RuleSets exist with this name: '{0}'", ruleSetInfo.Name));
}
}
else
{
return(null);
}
}