public Rule(string name, RuleCondition condition, IList<RuleAction> thenActions, IList<RuleAction> elseActions)
{
this.name = name;
this.condition = condition;
this.thenActions = thenActions;
this.elseActions = elseActions;
}
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (null == addedConditionDefinition)
throw new ArgumentNullException("addedConditionDefinition");
_conditionDefinition = addedConditionDefinition;
}
// Methods
public override bool Evaluate(Activity activity, IServiceProvider provider)
{
Activity parent = activity;
RuleDefinitions definitions = null;
while (parent != null)
{
definitions = (RuleDefinitions)parent.GetValue(RuleDefinitions.RuleDefinitionsProperty);
if (definitions != null)
{
break;
}
parent = parent.Parent;
}
if (definitions == null)
{
Console.WriteLine("No definition");
return(false);
}
//Console.WriteLine ("Definition {0} at {1}", definitions, parent);
RuleValidation validation = new RuleValidation(activity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, parent);
RuleCondition condition = definitions.Conditions [ConditionName];
//Console.WriteLine ("Condition {0}", condition);
return(condition.Evaluate(execution));
}
public Rule(string name, RuleCondition condition, IList <RuleAction> thenActions, IList <RuleAction> elseActions)
{
this.name = name;
this.condition = condition;
this.thenActions = thenActions;
this.elseActions = elseActions;
}
public RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (removedConditionDefinition == null)
{
throw new ArgumentNullException("removedConditionDefinition");
}
this._conditionDefinition = removedConditionDefinition;
}
public Rule(string name, RuleCondition condition, IList <RuleAction> thenActions)
{
this.behavior = RuleReevaluationBehavior.Always;
this.active = true;
this.name = name;
this.condition = condition;
this.thenActions = thenActions;
}
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (addedConditionDefinition == null)
{
throw new ArgumentNullException("addedConditionDefinition");
}
this._conditionDefinition = addedConditionDefinition;
}
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (addedConditionDefinition == null)
{
throw new ArgumentNullException("addedConditionDefinition");
}
this._conditionDefinition = addedConditionDefinition;
}
public RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (removedConditionDefinition == null)
{
throw new ArgumentNullException("removedConditionDefinition");
}
this._conditionDefinition = removedConditionDefinition;
}
public Rule(string name, RuleCondition condition, IList<RuleAction> thenActions)
{
this.behavior = RuleReevaluationBehavior.Always;
this.active = true;
this.name = name;
this.condition = condition;
this.thenActions = thenActions;
}
public override bool Evaluate(Activity activity, IServiceProvider provider)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (string.IsNullOrEmpty(this._condition))
{
throw new InvalidOperationException(SR.GetString(SR.Error_MissingConditionName, activity.Name));
}
RuleDefinitions defs = null;
if (string.IsNullOrEmpty(this.declaringActivityId))
{
// No Runtime Initialization.
CompositeActivity declaringActivity = null;
defs = RuleConditionReference.GetRuleDefinitions(activity, out declaringActivity);
}
else
{
// Runtime Initialized.
defs = (RuleDefinitions)activity.GetActivityByName(declaringActivityId).GetValue(RuleDefinitions.RuleDefinitionsProperty);
}
if ((defs == null) || (defs.Conditions == null))
{
throw new InvalidOperationException(SR.GetString(SR.Error_MissingRuleConditions));
}
RuleCondition conditionDefinitionToEvaluate = defs.Conditions[this._condition];
if (conditionDefinitionToEvaluate != null)
{
Activity contextActivity = System.Workflow.Activities.Common.Helpers.GetEnclosingActivity(activity);
RuleValidation validation = new RuleValidation(contextActivity);
if (!conditionDefinitionToEvaluate.Validate(validation))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionValidationFailed, this._condition);
throw new InvalidOperationException(message);
}
RuleExecution context = new RuleExecution(validation, contextActivity, provider as ActivityExecutionContext);
return(conditionDefinitionToEvaluate.Evaluate(context));
}
else
{
// no condition, so defaults to true
return(true);
}
}
public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
{
if (conditionDefinition == null)
{
throw new ArgumentNullException("conditionDefinition");
}
if (newConditionDefinition == null)
{
throw new ArgumentNullException("newConditionDefinition");
}
if (newConditionDefinition.Name != conditionDefinition.Name)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, new object[] { newConditionDefinition.Name, conditionDefinition.Name }));
}
this._conditionDefinition = conditionDefinition;
this._newConditionDefinition = newConditionDefinition;
}
public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
{
if (conditionDefinition == null)
{
throw new ArgumentNullException("conditionDefinition");
}
if (newConditionDefinition == null)
{
throw new ArgumentNullException("newConditionDefinition");
}
if (newConditionDefinition.Name != conditionDefinition.Name)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, new object[] { newConditionDefinition.Name, conditionDefinition.Name }));
}
this._conditionDefinition = conditionDefinition;
this._newConditionDefinition = newConditionDefinition;
}
public override bool Evaluate(Activity activity, IServiceProvider provider)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (string.IsNullOrEmpty(this._condition))
{
throw new InvalidOperationException(SR.GetString("Error_MissingConditionName", new object[] { activity.Name }));
}
RuleDefinitions ruleDefinitions = null;
if (string.IsNullOrEmpty(this.declaringActivityId))
{
CompositeActivity declaringActivity = null;
ruleDefinitions = GetRuleDefinitions(activity, out declaringActivity);
}
else
{
ruleDefinitions = (RuleDefinitions)activity.GetActivityByName(this.declaringActivityId).GetValue(RuleDefinitions.RuleDefinitionsProperty);
}
if ((ruleDefinitions == null) || (ruleDefinitions.Conditions == null))
{
throw new InvalidOperationException(SR.GetString("Error_MissingRuleConditions"));
}
RuleCondition condition = ruleDefinitions.Conditions[this._condition];
if (condition == null)
{
return(true);
}
Activity enclosingActivity = Helpers.GetEnclosingActivity(activity);
RuleValidation validation = new RuleValidation(enclosingActivity);
if (!condition.Validate(validation))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ConditionValidationFailed, new object[] { this._condition }));
}
RuleExecution execution = new RuleExecution(validation, enclosingActivity, provider as ActivityExecutionContext);
return(condition.Evaluate(execution));
}
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 Rule(string name, RuleCondition condition, IList <RuleAction> thenActions)
{
}
public Rule (string name, RuleCondition condition, IList<RuleAction> thenActions)
{
}
public Rule (string name, RuleCondition condition, IList<RuleAction> thenActions, IList<RuleAction> elseActions) :
this (name, condition, thenActions)
{
}
public Rule(string name, RuleCondition condition, IList <RuleAction> thenActions, IList <RuleAction> elseActions) :
this(name, condition, thenActions)
{
}
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 RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (null == removedConditionDefinition)
throw new ArgumentNullException("removedConditionDefinition");
_conditionDefinition = removedConditionDefinition;
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (manager.Context == null)
{
throw new InvalidOperationException(Messages.ContextStackMissing);
}
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
RuleConditionReference declarativeCondition = obj as RuleConditionReference;
if (declarativeCondition == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, typeof(RuleConditionReference).FullName, "obj");
throw new ArgumentException(message, "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(Activity).Name);
throw new InvalidOperationException(message);
}
PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;
if (validationContext == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(PropertyValidationContext).Name);
throw new InvalidOperationException(message);
}
if (!string.IsNullOrEmpty(declarativeCondition.ConditionName))
{
RuleDefinitions rules = null;
RuleConditionCollection conditionDefinitions = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
rules = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
rules = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (rules != null)
{
conditionDefinitions = rules.Conditions;
}
if (conditionDefinitions == null || !conditionDefinitions.Contains(declarativeCondition.ConditionName))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, declarativeCondition.ConditionName);
ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_ConditionNotFound);
validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName";
validationErrors.Add(validationError);
}
else
{
RuleCondition actualCondition = conditionDefinitions[declarativeCondition.ConditionName];
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
IDisposable localContextScope = (WorkflowCompilationContext.Current == null ? WorkflowCompilationContext.CreateScope(manager) : null);
try
{
RuleValidation ruleValidator = new RuleValidation(activity, typeProvider, WorkflowCompilationContext.Current.CheckTypes);
actualCondition.Validate(ruleValidator);
ValidationErrorCollection actualConditionErrors = ruleValidator.Errors;
if (actualConditionErrors.Count > 0)
{
string expressionPropertyName = GetFullPropertyName(manager);
string genericErrorMsg = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionExpression, expressionPropertyName);
int errorNumber = ErrorNumbers.Error_InvalidConditionExpression;
if (activity.Site != null)
{
ValidationError validationError = new ValidationError(genericErrorMsg, errorNumber);
validationError.PropertyName = expressionPropertyName + "." + "Expression";
validationErrors.Add(validationError);
}
else
{
foreach (ValidationError actualError in actualConditionErrors)
{
ValidationError validationError = new ValidationError(genericErrorMsg + " " + actualError.ErrorText, errorNumber);
validationError.PropertyName = expressionPropertyName + "." + "Expression";
validationErrors.Add(validationError);
}
}
}
// Test duplicates
foreach (RuleCondition definition in conditionDefinitions)
{
if (definition.Name == declarativeCondition.ConditionName && definition != actualCondition)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.DuplicateConditions, declarativeCondition.ConditionName);
ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_DuplicateConditions);
validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName";
validationErrors.Add(validationError);
}
}
}
finally
{
if (localContextScope != null)
{
localContextScope.Dispose();
}
}
}
}
else
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionName, "ConditionName");
ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_InvalidConditionName);
validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName";
validationErrors.Add(validationError);
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (manager.Context == null)
{
throw new InvalidOperationException(Messages.ContextStackMissing);
}
ValidationErrorCollection errors = base.Validate(manager, obj);
RuleConditionReference reference = obj as RuleConditionReference;
if (reference == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleConditionReference).FullName, "obj" }), "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
}
if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
}
if (!string.IsNullOrEmpty(reference.ConditionName))
{
RuleDefinitions definitions = null;
RuleConditionCollection conditions = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (definitions != null)
{
conditions = definitions.Conditions;
}
if ((conditions == null) || !conditions.Contains(reference.ConditionName))
{
ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, new object[] { reference.ConditionName }), 0x53e)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(error);
return(errors);
}
RuleCondition condition = conditions[reference.ConditionName];
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
{
RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
condition.Validate(validation);
ValidationErrorCollection errors2 = validation.Errors;
if (errors2.Count > 0)
{
string fullPropertyName = base.GetFullPropertyName(manager);
string errorText = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionExpression, new object[] { fullPropertyName });
int errorNumber = 0x558;
if (activity.Site != null)
{
ValidationError error2 = new ValidationError(errorText, errorNumber)
{
PropertyName = fullPropertyName + ".Expression"
};
errors.Add(error2);
}
else
{
foreach (ValidationError error3 in errors2)
{
ValidationError error4 = new ValidationError(errorText + " " + error3.ErrorText, errorNumber)
{
PropertyName = fullPropertyName + ".Expression"
};
errors.Add(error4);
}
}
}
foreach (RuleCondition condition2 in conditions)
{
if ((condition2.Name == reference.ConditionName) && (condition2 != condition))
{
ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.DuplicateConditions, new object[] { reference.ConditionName }), 0x53f)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(error5);
}
}
return(errors);
}
}
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionName, new object[] { "ConditionName" }), 0x540)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(item);
return(errors);
}
