protected override bool preTest(IRuleContext context, out bool result){
if (0 == Extractions.Count){
result = false;
return false;
}
return base.preTest(context, out result);
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch<string>(context, instance))
{
if (!_actualRegex.IsMatch((string)instance)) context.Fail(this, instance, NotConformingToExpression);
}
}
public virtual void Execute(IRuleContext context, int steps){
//@"context".contract_NotNull(context);
//(0 < steps).contract_True("„исло шагов должно быть больше 0");
context.RuleData[this, Constants.Context.RuleData.EngineMaxSteps] = steps;
Execute(context);
}
public override bool Evaluate(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var result = XPathExpression.Evaluate(ruleContext.Object);
if (result == null)
{
return false;
}
if (result is bool)
{
return (bool)result;
}
if (result is int)
{
return (int)result != 0;
}
if (result is string)
{
return !string.IsNullOrEmpty(result as string);
}
return true;
}
public void ExecuteThen(IRuleContext context)
{
foreach (var clause in Then)
{
clause.Action.Execute(context, clause.Parameters);
}
}
public RuleActivationState GetActivationState(IRuleContext context, IRule rule){
if (AlwaysPassive.Contains(rule.Module())){
return RuleActivationState.Never();
}
if (AlwaysActive.Contains(rule.Module())){
return RuleActivationState.Always();
}
var modules = context.modules();
if (null == modules){
if (rule.Module() == "default"){
return RuleActivationState.Always();
}
else{
return RuleActivationState.Never();
}
}
else{
if (modules.IsActive(rule.Module())){
return RuleActivationState.ActiveVersion(GetVersion(context));
}
else{
return RuleActivationState.PassiveVersion(GetVersion(context));
}
}
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch<string>(context, instance))
{
if (!_regex.IsMatch((string)instance)) context.Fail(this, instance, InvalidEMailReason);
}
}
public override void Execute(IRuleContext context, IDictionary<string, object> parameters)
{
var text = GetParameterValue(parameters, "text", context.Object);
if (string.IsNullOrEmpty(text))
{
text = GetParameterValue(parameters, "value", context.Object) ?? string.Empty;
}
var details = GetParameterValue(parameters, "details", context.Object);
int msg;
int.TryParse(GetParameterValue(parameters, "msg", context.Object), out msg);
ITextNode textNode = null;
ISnapshot snapshot = null;
var itemBase = context.Object as DatabaseProjectItem;
if (itemBase != null)
{
textNode = itemBase.SourceTextNodes.FirstOrDefault();
}
var projectItem = context.Object as IProjectItem;
if (projectItem != null)
{
snapshot = projectItem.Snapshots.FirstOrDefault();
}
TraceLine(context.Trace, msg, text, textNode, snapshot, details ?? string.Empty);
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch<string>(context, instance))
{
var length = ((string)instance).Length;
if (length > Length) context.Fail(this, instance, Reasons.LengthIsTooLong);
}
}
protected override void innerInitContext(IRuleContext context){
IModuleService s = context.modules();
if (null == s && context is IWithServices){
ModuleService service = new ModuleService();
((IWithServices) context).Services.RegisterService<IModuleService>(service);
}
base.innerInitContext(context);
}
public static IRuleContext CreateRuleContext(IRuleContext ruleContext, int promotionId)
{
return(new SimpleRuleContext(ruleContext)
{
PromotionId = promotionId,
MultiShipEnabled = AppLogic.AppConfigBool("AllowMultipleShippingAddressPerOrder") || AppLogic.AppConfigBool("ShowGiftRegistryButtons"),
AddItemToCart = ruleContext.AddItemToCart
});
}
protected override async void Execute(IRuleContext context)
{
context.AddDirtyProperty(null);
// This method should have an error
// because we are not inheriting from BusinessRuleAsync.
await DummyAsync();
context.Complete();
}
/// <summary>
/// Business or validation rule implementation.
/// </summary>
/// <param name="context">Rule context object.</param>
protected override void Execute(IRuleContext context)
{
// Use linq Sum to calculate the sum value
dynamic sum = context.InputPropertyValues.Aggregate <KeyValuePair <IPropertyInfo, object>, dynamic>(0, (current, item) => current + (dynamic)item.Value);
// add calculated value to OutValues
// When rule is completed the RuleEngine will update businessobject
context.AddOutValue(PrimaryProperty, sum);
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
protected override void Execute(IRuleContext context)
{
var target = (Csla.Core.ITrackStatus)context.Target;
if (!target.IsNew)
{
context.AddSuccessResult(true);
}
}
protected override void Execute(IRuleContext context)
{
var target = (Foo)context.Target;
if (target.Name == "2")
{
context.AddErrorResult("Name can not be 2");
}
}
protected override void Execute(IRuleContext context)
{
if (context.Target != null)
{
throw new ArgumentOutOfRangeException("context.Target must be null");
}
((IBusinessRule)_innerRule).Execute(context.GetChainedContext(_innerRule));
}
protected override void Execute(IRuleContext context)
{
var name = (string)context.InputPropertyValues[PrimaryProperty];
if (!name.Trim().Contains(" "))
{
context.AddWarningResult("You should enter a full name");
}
}
/// <inheritdoc/>
public void Evaluate(IRuleContext context, object instance)
{
var result = _method();
if (!result.IsSuccess)
{
result.Causes.ForEach(_ => context.Fail(this, instance, _));
}
}
protected bool FailIfValueTypeMismatch <TDesired>(IRuleContext context, object value)
{
if (value.GetType() != typeof(TDesired))
{
context.Fail(this, value, ValueTypeMismatch);
return(false);
}
return(true);
}
protected override void Execute(IRuleContext context)
{
// Use linq Sum to calculate the sum value
var sum = context.InputPropertyValues.Sum(property => (dynamic)property.Value);
// add calculated value to OutValues
// When rule is completed the RuleEngig will update businessobject
context.AddOutValue(PrimaryProperty, sum);
}
public int GetVersion(IRuleContext context){
var modules = context.modules();
if (null == modules){
return -1;
}
else{
return modules.Version;
}
}
protected override void Execute(IRuleContext context)
{
var text = (string)ReadProperty(context.Target, PrimaryProperty);
if (text.ToLower().Contains("z"))
{
context.AddErrorResult("No letter Z allowed");
}
}
protected override void Execute(IRuleContext context)
{
//modify property value, to upper
var val1 = (string)context.InputPropertyValues[PrimaryProperty];
if (!string.IsNullOrEmpty(val1))
{
context.AddOutValue(PrimaryProperty, val1.ToUpper());
}
}
public object ExportData(IRuleContext context, object dataTargetDescriptor){
object result = null;
foreach (var exporter in Exporters){
result = exporter.ExportData(context, dataTargetDescriptor);
if (null != result){
break;
}
}
return result;
}
/// <summary>
/// Method to call if value type mismatch - produces a failture in the <see cref="IRuleContext"/>.
/// </summary>
/// <param name="context">The <see cref="IRuleContext"/>.</param>
/// <param name="value">The value to check.</param>
/// <typeparam name="TDesired">Desired type.</typeparam>
/// <returns>true if its ok, false if it failed.</returns>
protected bool FailIfValueTypeMismatch <TDesired>(IRuleContext context, object value)
{
if (value.GetType() != typeof(TDesired))
{
context.Fail(this, value, ValueTypeMismatch.WithArgs(new { Expected = typeof(TDesired), Types = value.GetType() }));
return(false);
}
return(true);
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch <string>(context, instance))
{
if (!_actualRegex.IsMatch((string)instance))
{
context.Fail(this, instance, NotConformingToExpression);
}
}
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch <string>(context, instance))
{
if (!_regex.IsMatch((string)instance))
{
context.Fail(this, instance, InvalidEMailReason);
}
}
}
/// <summary>
/// Executes the rule
/// </summary>
/// <param name="context">
/// The rule context.
/// </param>
protected override void Execute(IRuleContext context)
{
var target = (Csla.Core.ITrackStatus)context.Target;
if (target.IsNew)
{
var chainedContext = context.GetChainedContext(InnerRule);
InnerRule.Execute(chainedContext);
}
}
public StateToImpulsRule(IRuleContext context) : base(context)
{
_context = context;
_output1 = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == StateToImpulsRuleFactory.RuleOutput);
_paramDelay = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == StateToImpulsRuleFactory.DelayParameter);
}
public TimerRule(IRuleContext context) : base(context)
{
_timerProperty = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == TimerRuleFactory.RuleTimerParameter);
_output = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == TimerRuleFactory.RuleOutput);
_timer = new System.Timers.Timer();
}
/// <summary>
/// Does the check for primary propert less than compareTo property
/// </summary>
/// <param name="context">Rule context object.</param>
protected override void Execute(IRuleContext context)
{
var value1 = (dynamic)context.InputPropertyValues[PrimaryProperty];
var value2 = (dynamic)context.InputPropertyValues[CompareTo];
if (value1 > value2)
{
context.AddErrorResult(string.Format("{0} must be less than or equal {1}", PrimaryProperty.FriendlyName, CompareTo.FriendlyName));
}
}
protected override bool innerTest(IRuleContext context){
Extractions.Reset();
Extractions.Apply(GetDocumentForContext(context).Text);
var result = Extractions.GetActiveResultList();
if (0 == result.Count){
return false;
}
context.RuleData[this, "ta.activatedExtractions"] = result;
return true;
}
protected override void Execute(IRuleContext context)
{
// TODO: Add actual rule code here.
var country = (string)context.InputPropertyValues[_countryProperty];
if (country == CountryNVL.UnitedStates)
{
_innerRule.Execute(context.GetChainedContext(_innerRule));
}
}
protected override async Task ExecuteAsync(IRuleContext context)
{
int role = (int)context.InputPropertyValues[PrimaryProperty];
var roles = await RoleList.CacheListAsync();
if (!roles.ContainsKey(role))
{
context.AddErrorResult("Role must be in RoleList");
}
}
/// <summary>
/// Executes the rule
/// </summary>
/// <param name="context">
/// The rule context.
/// </param>
protected override void Execute(IRuleContext context)
{
var target = (Csla.Core.BusinessBase)context.Target;
if (target.CanWriteProperty(PrimaryProperty))
{
var chainedContext = context.GetChainedContext(InnerRule);
InnerRule.Execute(chainedContext);
}
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
protected override void Execute(IRuleContext context)
{
var target = (Csla.Core.BusinessBase)context.Target;
// Short circuit rule processing for this property if user is not allowed to edit field.
if (!target.CanWriteProperty(PrimaryProperty))
{
context.AddSuccessResult(true);
}
}
public IList<IRule> Filter(IRuleContext context, IList<IRule> rules){
//@"rules".contract_NotNull(rules);
if (rules == null || rules.Count == 0){
return null;
}
if (rules.Count == 1){
return new[]{rules[0]};
}
IRule mainTarget = null;
IList<IRule> obligations = SupportSafeProduction ? new List<IRule>() : null;
IList<IRule> friendship = SupportFriendship ? new List<IRule>() : null;
foreach (var rule in rules){
var safer = CheckSafeProduction(rule, obligations);
if (safer){
continue;
}
var oldMainTarget = mainTarget;
mainTarget = GetMainTarget(rule, mainTarget);
if (SupportFriendship){
if (SupportFriendshipMatching(rule)){
friendship.Add(rule);
}
}
}
if (SupportFriendship && friendship.Count != 0){
IList<IRule> realFriendship = new List<IRule>();
foreach (var rule in friendship){
if (mainTarget == rule){
continue;
}
var matcher_ = GetFriendshipMatcher(rule);
var matcher = matcher_ is IFriendshipMatcher
? (IFriendshipMatcher) matcher_
: new RegularExpressionBasedFriendshipMatcher(matcher_.ToString());
rule.Params[Constants.Meta.CRFriendshipMatcher] = matcher;
if (matcher.IsFirend(rule, mainTarget)){
realFriendship.Add(rule);
}
}
friendship = realFriendship;
}
var result = new List<IRule>();
result.Add(mainTarget);
if (SupportFriendship){
result.AddRange(friendship);
}
if (SupportSafeProduction){
result.AddRange(obligations);
}
return result.ToArray();
}
protected override void innerInitContext(IRuleContext context){
if (null != InitDelegate){
InitDelegate(this, context);
return;
}
if (null != InitModule){
InitModule.InitContext(context);
return;
}
base.innerInitContext(context);
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch <T>(context, instance))
{
var comparison = ((IComparable <T>)instance).CompareTo(Value);
if (comparison < 0)
{
context.Fail(this, instance, Reasons.ValueIsLessThan);
}
}
}
private async void RunAsyncRule(IBusinessRuleAsync asyncRule, IRuleContext context)
{
try
{
await asyncRule.ExecuteAsync(context);
}
finally
{
context.Complete();
}
}
public override IList<IRule> Filter(IRuleContext context, IList<IRule> ruleset){
//@"context".contract_NotNull(context);
// @"ruleset".contract_NotNull(ruleset);
foreach (var i in GetIndexes(index, ruleset)){
if (ruleset[i].Test(context)){
return new[]{ruleset[i]};
}
}
return null;
}
protected override string GetValue(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var item = ruleContext.Object as Item;
if (item == null)
{
return string.Empty;
}
var parentItem = item.GetParent();
return parentItem?.ItemIdOrPath ?? string.Empty;
}
public IfRule(IRuleContext context) : base(context)
{
_paramTrueValue = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == IfRuleFactory.RuleParamTrue);
_paramFalseValue = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == IfRuleFactory.RuleParamFalse);
_output1 = context.RuleInstance.RuleInterfaceInstance.SingleOrDefault(a =>
a.This2RuleInterfaceTemplate == IfRuleFactory.RuleOutput);
}
protected override int GetValue(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
object language;
if (!parameters.TryGetValue("language", out language))
{
throw new InvalidOperationException("Language missing");
}
var item = ruleContext.Object as Item;
return item == null ? 0 : item.GetVersions(language.ToString()).Count();
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch <string>(context, instance))
{
var length = ((string)instance).Length;
if (length > Length)
{
context.Fail(this, instance, Reasons.LengthIsTooLong);
}
}
}
/// <inheritdoc/>
public override void Evaluate(IRuleContext context, object instance)
{
if (FailIfValueTypeMismatch <T>(context, instance))
{
var comparison = ((IComparable <T>)instance).CompareTo(Value);
if (comparison > 0)
{
context.Fail(this, instance, Reasons.ValueIsGreaterThan.WithArgs(new { LeftHand = instance, RightHand = Value }));
}
}
}
#pragma warning disable CSLA0017 // Find Business Rules That Do Not Use Add() Methods on the Context
protected override void Execute(IRuleContext context)
#pragma warning restore CSLA0017 // Find Business Rules That Do Not Use Add() Methods on the Context
{
// TODO: Add actual rule code here.
var country = (string)context.InputPropertyValues[_countryProperty];
if (country == CountryNVL.UnitedStates)
{
_innerRule.Execute(context.GetChainedContext(_innerRule));
}
}
protected override void Execute(IRuleContext context)
{
if (context.InputPropertyValues[PrimaryProperty] != null)
{
var val = (T)context.InputPropertyValues[PrimaryProperty];
if (!ListOfValues.Contains(val))
{
context.AddErrorResult(string.Format("'{0}' is not in the list of expected values.", PrimaryProperty.FriendlyName));
}
}
}
public bool Execute(IRuleContext context)
{
if (EvaluateIf(context))
{
ExecuteThen(context);
return true;
}
ExecuteElse(context);
return false;
}
protected override bool innerTest(IRuleContext context){
var baseResult = base.innerTest(context);
if (baseResult){
return true;
}
if (Missing.Value == DefaultResult){
return false;
}
SetRawActivations(context, null);
return true;
}
protected override void innerExecute(IRuleContext context){
var activations = ExtractActivations(context);
if (null == activations){
var result = DefaultResult;
if (CustomDefaultResultRetriever.yes()){
result = CustomDefaultResultRetriever(context.Descriptor(), this);
}
context.SetControllerRuleResult(result);
}
else{
base.innerExecute(context);
}
}
RuleFailed RuleFailed(IRuleContext ruleContext, Dictionary<IRule, BrokenRule> brokenRules)
{
return (rule, instance, reason) =>
{
BrokenRule brokenRule;
if (brokenRules.ContainsKey(rule)) brokenRule = brokenRules[rule];
else
{
brokenRule = new BrokenRule(rule, instance, ruleContext);
brokenRules[rule] = brokenRule;
}
brokenRule.AddReason(reason);
};
}
#pragma warning disable 1591 // Xml Comments
public override void Evaluate(IRuleContext context, object instance)
{
if (instance == null) context.Fail(this, instance, ValueIsNull);
if (instance is string && ((string)instance) == string.Empty) context.Fail(this, instance, StringIsEmpty);
if (instance != null)
{
var type = instance.GetType();
if (type.HasDefaultConstructor())
{
if (Activator.CreateInstance(type).Equals(instance)) context.Fail(this, instance, ValueNotSpecified);
}
}
}
public override bool Test(IRuleContext context){
////@"context".contract_NotNull(context);
lock (testLock){
Logger.Rule.Debug("START TEST {0}",Uid);
context.addTest(this);
var result = false;
var proceed = preTest(context, out result);
if (proceed)
result = innerTest(context);
postTest(context, result);
if (!result) context.addBadTest(this);
Logger.Rule.Debug("END TEST {0} - {1}", Uid,result);
return result;
}
}
public override void Execute(IRuleContext context){
//@"context".contract_NotNull(context);
lock (execLock){
Logger.Rule.Debug("START EXEC {0}", Uid);
var result = false;
var proceed = preExecute(context);
if (proceed){
context.addExec(this);
innerExecute(context);
}
postExecute(context, result);
Logger.Rule.Debug("END EXEC {0}", Uid);
}
}
public override bool Evaluate(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var value = GetValue(ruleContext, parameters);
var val = GetParameterValue(parameters, "value", ruleContext.Object);
if (val != null)
{
return value == Parse(val);
}
var equals = GetParameterValue(parameters, "=", ruleContext.Object);
if (equals != null)
{
return value == Parse(equals);
}
var notequals = GetParameterValue(parameters, "!=", ruleContext.Object);
if (notequals != null)
{
return value == Parse(notequals);
}
var largerThan = GetParameterValue(parameters, ">", ruleContext.Object);
if (largerThan != null)
{
return value > Parse(largerThan);
}
var largerThanOrEqual = GetParameterValue(parameters, ">=", ruleContext.Object);
if (largerThanOrEqual != null)
{
return value == Parse(largerThanOrEqual);
}
var lessThanOrEqual = GetParameterValue(parameters, "<=", ruleContext.Object);
if (lessThanOrEqual != null)
{
return value == Parse(lessThanOrEqual);
}
var lessThan = GetParameterValue(parameters, "<", ruleContext.Object);
if (lessThan != null)
{
return value == Parse(lessThan);
}
throw new ConfigurationException(Texts.String_operator_not_found);
}
public override bool Evaluate(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var value = GetValue(ruleContext, parameters);
var val = GetParameterValue(parameters, "value", ruleContext.Object);
if (val != null)
{
return string.Equals(value, val, StringComparison.OrdinalIgnoreCase);
}
var equals = GetParameterValue(parameters, "=", ruleContext.Object);
if (equals != null)
{
return string.Equals(value, equals, StringComparison.OrdinalIgnoreCase);
}
var notequals = GetParameterValue(parameters, "!=", ruleContext.Object);
if (notequals != null)
{
return !string.Equals(value, notequals, StringComparison.OrdinalIgnoreCase);
}
var contains = GetParameterValue(parameters, "contains", ruleContext.Object);
if (contains != null)
{
return value.IndexOf(contains, StringComparison.OrdinalIgnoreCase) >= 0;
}
var startsWith = GetParameterValue(parameters, "starts-with", ruleContext.Object);
if (startsWith != null)
{
return value.StartsWith(startsWith, StringComparison.OrdinalIgnoreCase);
}
var endsWith = GetParameterValue(parameters, "ends-with", ruleContext.Object);
if (endsWith != null)
{
return value.EndsWith(endsWith, StringComparison.OrdinalIgnoreCase);
}
var matches = GetParameterValue(parameters, "matches", ruleContext.Object);
if (matches != null)
{
return Regex.IsMatch(value, matches, RegexOptions.IgnoreCase);
}
throw new ConfigurationException(Texts.String_operator_not_found);
}
public override bool Evaluate(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var template = ruleContext.Object as Template;
if (template == null)
{
return false;
}
object sectionName;
if (!parameters.TryGetValue("name", out sectionName))
{
return false;
}
return template.Sections.Any(s => string.Equals(s.SectionName, sectionName as string, StringComparison.OrdinalIgnoreCase));
}
protected override string GetValue(IRuleContext ruleContext, IDictionary<string, object> parameters)
{
var item = ruleContext.Object as Item;
if (item == null)
{
return string.Empty;
}
var fieldName = GetParameterValue(parameters, "name", ruleContext.Object);
if (fieldName == null)
{
throw new ConfigurationException(Texts.Field_name_expected);
}
return item[fieldName];
}
public RuleActivationState GetActivationState(IRuleContext context, IRule rule){
if (!rule.IsWithCountHints()){
return RuleActivationState.Always();
}
if (-1 != rule.GetMaxExecCountHint()){
if (context.execCount(rule) == rule.GetMaxExecCountHint()){
return RuleActivationState.Never();
}
}
if (-1 != rule.GetMaxBadTestCountHint()){
if (context.badCount(rule) == rule.GetMaxBadTestCountHint()){
return RuleActivationState.Never();
}
}
return new RuleActivationState(RuleActivationStateType.Active);
}
