|
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
namespace System.Workflow.Activities.Rules
{
#region ConditionChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleConditionChangeAction : WorkflowChangeAction
{
public abstract string ConditionName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations required.
return new ValidationErrorCollection();
}
}
#endregion
#region RuleSetChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleSetChangeAction : WorkflowChangeAction
{
public abstract string RuleSetName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations can be done since we don't know the context the policy
// will execute in (i.e. no idea what the "this" object will be)
return new ValidationErrorCollection();
}
}
#endregion
#region AddedConditionAction
public sealed class AddedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (null == addedConditionDefinition)
throw new ArgumentNullException("addedConditionDefinition");
_conditionDefinition = addedConditionDefinition;
}
public AddedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Add(this.ConditionDefinition);
}
finally
{
if (setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedConditionAction
public sealed class RemovedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (null == removedConditionDefinition)
throw new ArgumentNullException("removedConditionDefinition");
_conditionDefinition = removedConditionDefinition;
}
public RemovedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.Conditions.Remove(this.ConditionDefinition.Name);
}
finally
{
if (setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedConditionAction
public sealed class UpdatedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
private RuleCondition _newConditionDefinition;
public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
{
if (null == conditionDefinition)
throw new ArgumentNullException("conditionDefinition");
if (null == newConditionDefinition)
throw new ArgumentNullException("newConditionDefinition");
if (newConditionDefinition.Name != conditionDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, newConditionDefinition.Name, conditionDefinition.Name);
throw new ArgumentException(message);
}
_conditionDefinition = conditionDefinition;
_newConditionDefinition = newConditionDefinition;
}
public UpdatedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition NewConditionDefinition
{
get
{
return this._newConditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._newConditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
if (rules.Conditions[this.ConditionDefinition.Name] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Remove(this.ConditionDefinition.Name);
rules.Conditions.Add(this.NewConditionDefinition);
}
finally
{
if (setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region AddedRuleSetAction
public sealed class AddedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public AddedRuleSetAction(RuleSet addedRuleSetDefinition)
{
if (addedRuleSetDefinition == null)
throw new ArgumentNullException("addedRuleSetDefinition");
ruleset = addedRuleSetDefinition;
}
public AddedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Add(ruleset);
}
finally
{
if (setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedRuleSetAction
public sealed class RemovedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public RemovedRuleSetAction(RuleSet removedRuleSetDefinition)
{
if (removedRuleSetDefinition == null)
throw new ArgumentNullException("removedRuleSetDefinition");
ruleset = removedRuleSetDefinition;
}
public RemovedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.RuleSets.Remove(ruleset.Name);
}
finally
{
if (setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedRuleSetAction
public sealed class UpdatedRuleSetAction : RuleSetChangeAction
{
private RuleSet original;
private RuleSet updated;
public UpdatedRuleSetAction(RuleSet originalRuleSetDefinition, RuleSet updatedRuleSetDefinition)
{
if (originalRuleSetDefinition == null)
throw new ArgumentNullException("originalRuleSetDefinition");
if (updatedRuleSetDefinition == null)
throw new ArgumentNullException("updatedRuleSetDefinition");
if (originalRuleSetDefinition.Name != updatedRuleSetDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, originalRuleSetDefinition.Name, updatedRuleSetDefinition.Name);
throw new ArgumentException(message);
}
original = originalRuleSetDefinition;
updated = updatedRuleSetDefinition;
}
public UpdatedRuleSetAction()
{
}
public override string RuleSetName
{
get { return original.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet OriginalRuleSetDefinition
{
get { return original; }
set
{
if (null == value)
throw new ArgumentNullException("value");
original = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet UpdatedRuleSetDefinition
{
get { return updated; }
set
{
if (null == value)
throw new ArgumentNullException("value");
updated = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
if (rules.RuleSets[RuleSetName] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Remove(RuleSetName);
rules.RuleSets.Add(updated);
}
finally
{
if (setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
}
|