File: Rules\ConditionChanges.cs
Project: ndp\cdf\src\WF\Activities\System.Workflow.Activities.csproj (System.Workflow.Activities)
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
}