public RuleExpressionResult Evaluate(RuleExecution execution)
{
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _logicalAndExpression, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _logicalAndExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
// left and right true
return(resultTrue);
}
else
{
//either left or right or both are false
return(resultFalse);
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var ruleSetService = context.GetService <RuleSetService>();
if (ruleSetService != null)
{
RuleSet ruleSet = ruleSetService.GetRuleSet(this.RuleSetName);
if (ruleSet != null)
{
Activity targetActivity = this.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
try
{
ruleSet.Execute(execution);
}
catch (RuleSetValidationException ex)
{
string str = ex.Message;
}
}
}
else
{
throw new InvalidOperationException("A RuleSetService must be configured on the host to use the PolicyFromService activity.");
}
return(ActivityExecutionStatus.Closed);
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _singleExpression, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _singleExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
bool negatedSingleResult = !boolSingleResult;
if (negatedSingleResult)
{
// return negated value
return(resultTrue);
}
else
{
//return negated value
return(resultFalse);
}
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
//StringComparer.CurrentCultureIgnoreCase;
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _binaryExpressionBasedOnComparisonType, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _binaryExpressionBasedOnComparisonType);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
return(resultTrue);
}
else
{
return(resultFalse);
}
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
//StringComparer.CurrentCultureIgnoreCase;
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _containsMethodInvocationExpression, false);
RuleExpressionResult singleResult = Evaluate(execution, _containsMethodInvocationExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
return(resultTrue);
}
else
{
return(resultFalse);
}
}
public override void Execute(RuleExecution context)
{
//we passed in at definition time what the code expressions for various properties are
//then they are evaluated so this.PropertyName for example would now be "the value of the property" if we passed
//in a CodePrimitiveExpression like "true" or "false" or "1" etc those values would now be here
RuleExpressionResult applicationIDResult = RuleExpressionWalker.Evaluate(context, _applicationID);
RuleExpressionResult typeIDResult = RuleExpressionWalker.Evaluate(context, _typeID);
RuleExpressionResult ruleIDResult = RuleExpressionWalker.Evaluate(context, _ruleID);
RuleExpressionResult ruleNameResult = RuleExpressionWalker.Evaluate(context, _ruleName);
RuleExpressionResult resultResult = RuleExpressionWalker.Evaluate(context, _result);
RuleExpressionResult createDateResult = RuleExpressionWalker.Evaluate(context, _createDate);
RuleExpressionResult referenceIDResult = RuleExpressionWalker.Evaluate(context, _referenceID);
//this is where the work is actually done
if (applicationIDResult != null && ruleIDResult != null && ruleNameResult != null && resultResult != null &&
createDateResult != null)
{
RuleStats ruleStats = new RuleStats();
ruleStats.Insert((Guid)applicationIDResult.Value, (Guid)typeIDResult.Value, (Guid)ruleIDResult.Value, (string)ruleNameResult.Value, (bool)resultResult.Value, (DateTime)createDateResult.Value,
(Guid)referenceIDResult.Value);
}
}
public void Execute<T>(RuleSet ruleSet, PolicyExecutionContext<T> context)
{
Guard.ArgumentNotNull(ruleSet, "ruleSet");
RuleValidation validation = new RuleValidation(context.GetType(),null);
RuleExecution execution = new RuleExecution(validation, context);
ruleSet.Execute(execution);
}
public async Task <bool> Handle(RunADTMessageRulesCommand message, CancellationToken cancellationToken)
{
RuleEngineInRule ruleEngine = new RuleEngineInRule();
ruleEngine._authorizationKey = _settings.Value.AuthorizationKey;
ruleEngine._password = _settings.Value.Password;
ruleEngine._restClient = _settings.Value.RestClient;
ruleEngine._ruleRepository = _settings.Value.RegistrationRuleRepository;
ruleEngine._userName = _settings.Value.UserName;
string entity = JsonConvert.SerializeObject(message);
QAExecutionResult results = ruleEngine.ExecuteRules("Patient", entity);
var ruleExecution = new RuleExecution();
ruleExecution.AccountId = 1;
ruleExecution.ClientId = 1;
ruleExecution.Event = "RegistrationReceived";
foreach (var item in results.RuleErrors)
{
ruleExecution.RuleExecutionErrors
.Add(new RuleExecutionError()
{
RuleId = item.RuleId,
RuleErrorDescription = item.RuleErrorDescription,
RuleType = item.RuleType
}
);
}
_ruleExecutionContext.Add(ruleExecution);
return(await _ruleExecutionContext.SaveEntitiesAsync(cancellationToken));
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ExternalRuleSetService.ExternalRuleSetService ruleSetService = context.GetService <ExternalRuleSetService.ExternalRuleSetService>();
if (ruleSetService != null)
{
RuleSet ruleSet = ruleSetService.GetRuleSet(new RuleSetInfo(this.RuleSetName, this.MajorVersion, this.MinorVersion));
if (ruleSet != null)
{
Activity targetActivity = this.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
ruleSet.Execute(execution);
}
}
else
{
throw new InvalidOperationException("A RuleSetService must be configured on the host to use the PolicyFromService activity.");
}
return(ActivityExecutionStatus.Closed);
}
/// <summary>
/// BaseRuleSetFilterExpressionProvider must interpret all collection expression to string call
/// one of methods ( ValidateAll, ValidateAny, ConditionCollectionCount ) with CodeExpression for one of collection item
/// Example: ConditionCollectionAll(this.CustomerAccount.Addresses, "this.Organization == "Org1" && this.Line1 = "line"")
/// exactly second parameter must be converted to CodeExpression statement by Parser in provider.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="codeExpr">The code expr.</param>
/// <example>ConditionCollectionAll(this.CustomerAccount.Addresses, "this.Organization == \"Org1\" && this.Line1 = \"line\"");</example>
/// <returns></returns>
private static bool PredicateFunction(object item, System.CodeDom.CodeExpression codeExpr)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (codeExpr == null)
{
throw new ArgumentNullException("codeExpr");
}
bool retVal = false;
RuleSet rs = new RuleSet();
Rule rule = new Rule("collection expression rule");
RuleExpressionCondition cond = new RuleExpressionCondition(codeExpr);
RuleValidation validation = new RuleValidation(item.GetType(), null);
rule.Condition = cond;
rs.Rules.Add(rule);
rs.Validate(validation);
if (validation.Errors.Count > 0)
{
throw new Exception("Error count " + validation.Errors.Count);
}
RuleExecution execution = new RuleExecution(validation, item);
retVal = cond.Evaluate(execution);
return(retVal);
}
private void ExecuteRuleSet(System.Workflow.Activities.Rules.RuleSet ruleSet,
RuleValidation rv,
ref MSRuleSetExecutionResult ruleSetExecutionResult)
{
RuleExecution re = new RuleExecution(rv, _instanceOfObject);
ruleSet.Execute(re);
ruleSetExecutionResult.AddExecutionResult(ruleSet.Name, re);
}
public override void Execute(RuleExecution context)
{
RuleExpressionResult result = RuleExpressionWalker.Evaluate(context, _message);
if (result != null)
{
Console.WriteLine(result.Value);
}
}
public void AddExecutionResult(string ruleName, RuleExecution result)
{
if (_translatedRuleSet)
{
_evaluatedRules.Add(ruleName, result);
}
else
{
_nonTranslatedRulesExecutedRules.Add(ruleName, result);
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.RaiseEvent(PolicyFromService.BeforePolicyAppliedEvent, this, new EventArgs());
ExternalRuleSetService ruleSetService = context.GetService <ExternalRuleSetService>();
if (ruleSetService != null)
{
RuleSet ruleSet = Cache.Instance.Bag[this.RuleSetName + this.MajorVersion + this.MinorVersion] as RuleSet;
if (ruleSet == null)
{
ruleSet = ruleSetService.GetRuleSet(new RuleSetInfo(this.RuleSetName, this.MajorVersion, this.MinorVersion));
Cache.Instance.Bag.Add(this.RuleSetName + this.MajorVersion + this.MinorVersion, ruleSet);
}
if (ruleSet != null)
{
Activity targetActivity = this.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
try
{
Dictionary <string, object> param = new Dictionary <string, object>();
param.Add("rulesetname", string.Format("{0}.{1}.{2}", ruleSet.Name, this.MajorVersion, this.MinorVersion));
ruleSet.Execute(execution);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine + ex.InnerException);
if (!Information.IsSilientBusinessRuleError)
{
throw new Exception(ex.Message, ex.InnerException);
}
string mapId = Guid.NewGuid().ToString();
this.ErrorMessage = string.Format("A critical error occurred while executing rule {0}. MapId:{1}", ruleSet.Name, mapId);
PrintRuleSetTraceInformation(mapId, ruleSet, validation);
}
base.RaiseEvent(PolicyFromService.AfterPolicyAppliedEvent, this, EventArgs.Empty);
}
}
else
{
throw new InvalidOperationException("A RuleSetService must be configured on the host to use the PolicyFromService activity.");
}
return(ActivityExecutionStatus.Closed);
}
public KeyProcess RegisterKeys(ref KeyRegistrar keyRegistrar, RuleSet profile)
{
_keyHandlerState = new keyHandlerState()
{
current = null, previous = null
};
_keyHandlerState.keyRegistrar = keyRegistrar;
RuleValidation validation = new RuleValidation(typeof(keyHandlerState), null);
RuleExecution execution = new RuleExecution(validation, _keyHandlerState);
profile.Execute(execution);
return(Start);
}
/// <summary>
/// Execute a RuleSet definition read from
/// a file
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void codeExecuteRuleSet_ExecuteCode(
object sender, EventArgs e)
{
//get a stream from the embedded .rules resource
Assembly assembly = Assembly.GetAssembly(typeof(SellItemWorkflow));
Stream stream = assembly.GetManifestResourceStream(
"SharedWorkflows.SellItemMethods2Workflow.rules");
//get a stream from an externally saved .rules file
//Stream stream
// = new FileStream(@"SerializedSellItem.rules",
// FileMode.Open, FileAccess.Read, FileShare.Read);
using (XmlReader xmlReader = XmlReader.Create(
new StreamReader(stream)))
{
WorkflowMarkupSerializer markupSerializer
= new WorkflowMarkupSerializer();
//deserialize the rule definitions
RuleDefinitions ruleDefinitions
= markupSerializer.Deserialize(xmlReader) as RuleDefinitions;
if (ruleDefinitions != null)
{
if (ruleDefinitions.RuleSets.Contains("CalculateItemTotals"))
{
RuleSet rs
= ruleDefinitions.RuleSets["CalculateItemTotals"];
//validate and execute the RuleSet against this
//workflow instance
RuleValidation validation = new RuleValidation(
typeof(SellItemSerializedWorkflow), null);
if (rs.Validate(validation))
{
RuleExecution execution
= new RuleExecution(validation, this);
rs.Execute(execution);
}
else
{
foreach (ValidationError error in validation.Errors)
{
Console.WriteLine(error.ErrorText);
}
}
}
}
}
}
public void Load(Stream stream)
{
XmlReader reader = XmlReader.Create(stream);
try
{
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = serializer.Deserialize(reader) as RuleSet;
ruleExecution = null;
context = null;
}
finally
{
reader.Close();
}
}
public void ExecuteRuleSet(RulesetRequest request)
{
//if (request == null || string.IsNullOrEmpty(request.Name) || request.Entity == null) return;
var cacheKey = string.Format("Rules_{0}", request.Name);
var ruleSet = _cacheStorage.Retrieve(cacheKey, () =>
{
var extRuleService = new ExternalRuleSetService();
return(extRuleService.GetRuleSet(new RuleSetInfo {
Name = request.Name
}));
});
if (ruleSet == null)
{
throw new ApplicationException("Could not retrieve rule set for rule name: " + request.Name);
}
var entity = request.GetEntity();
var ruleValidation = new RuleValidation(entity.GetType(), null);
if (ruleSet.Validate(ruleValidation))
{
var ruleExecution = new RuleExecution(ruleValidation, entity);
ruleSet.Execute(ruleExecution);
}
else
{
var sb = new StringBuilder();
foreach (var error in ruleValidation.Errors)
{
sb.AppendLine(string.Format("{0}:{1}", error.ErrorNumber, error.ErrorText));
}
throw new ApplicationException(sb.ToString());
}
}
private void EvaluateRule(Rule rule, ref MSRuleSetEvaluationResult ruleSetEvaluationResult, ref RuleValidation rv)
{
rv.Errors.Clear();
IRuleExpression ruleExpression = (IRuleExpression)((RuleExpressionCondition)rule.Condition).Expression;
RuleExecution re = new RuleExecution(rv, _instanceOfObject);
RuleExpressionInfo info = RuleExpressionWalker.Validate(rv, (CodeExpression)ruleExpression, true);
if (rv.Errors.Count > 0)
{
//string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
ruleSetEvaluationResult.AddValidationError(rule.Name, rule.Description, rv.Errors);
}
else
{
RuleExpressionResult result = RuleExpressionWalker.Evaluate(re, (CodeExpression)ruleExpression);
ruleSetEvaluationResult.AddEvaluationResult(rule.Name, rule.Description, result);
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
string sFullURL = this.SourceSiteURL + @"/" + this.DocumentLibrary + @"/" + this.RuleSetName + ".ruleset";
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlUrlResolver resolver = new XmlUrlResolver();
System.Net.NetworkCredential myCredentials = new System.Net.NetworkCredential("Administrator", "password", "Mossb2tr");
resolver.Credentials = myCredentials;
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = resolver;
XmlReader reader = XmlReader.Create(sFullURL, settings);
RuleSet ruleSet = (RuleSet)serializer.Deserialize(reader);
reader.Close();
Activity targetActivity = Utility.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
ruleSet.Execute(execution);
return(ActivityExecutionStatus.Closed);
}
public async Task <bool> Handle(RecordQAResultsCommand message, CancellationToken cancellationToken)
{
var ruleExecution = new RuleExecution();
ruleExecution.AccountId = message.AccountId;
ruleExecution.ClientId = message.ClientId;
ruleExecution.Event = message.Event;
foreach (var item in message.ExecutionErrors)
{
ruleExecution.RuleExecutionErrors
.Add(new RuleExecutionError()
{
RuleId = item.RuleId,
RuleErrorDescription = item.RuleErrorDescription,
RuleType = item.RuleType
}
);
}
_ruleExecutionContext.Add(ruleExecution);
return(await _ruleExecutionContext.SaveEntitiesAsync(cancellationToken));
}
private RuleExpressionResult Evaluate(RuleExecution execution, CodeExpression expression)
{
return(RuleExpressionWalker.Evaluate(execution, expression));
}
public RuleExecution Update(RuleExecution ruleExecution)
{
throw new NotImplementedException();
}
public void Start(ConcurrentQueue <QueueMessage> queue, Process process, IntPtr id, BackgroundWorker backgroundWorker, RuleSet profile)
{
bool previousSendingKeys = false;
DateTime notify = DateTime.Now;
TimeSpan delay = new TimeSpan(0, 0, 1);
QueueMessage qm;
while (backgroundWorker.CancellationPending == false)
{
_keyHandlerState.previous = _keyHandlerState.current;
_keyHandlerState.current = _game.RetrieveStats(process, id);
if (_keyHandlerState.current == null)
{
_log.Error("Unable to load game stats");
Thread.Sleep(500);
continue;
}
bool keySent = _keyHandlerState.previous != null && _keyHandlerState.previous.onCD == false && _keyHandlerState.current.onCD == true;
if (keySent)
{
if (_keyHandlerState.calculatedKey == _keyHandlerState.queued)
{
_keyHandlerState.queued = null;
}
var trackedKeyHistory = _keyHandlerState.history.Where(x => x.Key == _keyHandlerState.calculatedKey).SingleOrDefault();
if (trackedKeyHistory.Value != null)
{
trackedKeyHistory.Value.lastSent = DateTime.Now;
}
if (_keyHandlerState.calculatedKey.HasValue)
{
_keyHandlerState.sent.Insert(0, _keyHandlerState.calculatedKey.Value);
if (_keyHandlerState.sent.Count > 30)
{
_keyHandlerState.sent.RemoveAt(30);
}
}
_keyHandlerState.calculatedKey = null;
}
if (queue.TryDequeue(out qm))
{
_keyHandlerState.queued = qm.keyEvent.Key;
}
foreach (var x in _keyHandlerState.history.Where(y => y.Value.lastSent != null))
{
var y = x.Value.lastSent.Add(x.Value.frequency).Subtract(DateTime.Now);
x.Value.remaining = y.TotalSeconds > 0 ? y : new TimeSpan();
}
RuleValidation validation = new RuleValidation(typeof(keyHandlerState), null);
RuleExecution execution = new RuleExecution(validation, _keyHandlerState);
profile.Execute(execution);
_keyHandlerState.first = false;
if (_keyHandlerState.sendingKeys != previousSendingKeys)
{
backgroundWorker.ReportProgress(0, _keyHandlerState.sendingKeys ? KeyHandlerProgress.processing : KeyHandlerProgress.idle);
if (_keyHandlerState.sendingKeys)
{
_enable.Play();
}
else
{
_disable.Play();
}
}
previousSendingKeys = _keyHandlerState.sendingKeys;
if (_keyHandlerState.calculatedKey != null && _keyHandlerState.sendingKeys)
{
if (DateTime.Now > notify.Add(delay))
{
_fire.Play();
_log.Debug("sending key {0}", Enum.GetName(typeof(Keys), _keyHandlerState.calculatedKey));
}
_windowTools.SendKey(process, (Keys)_keyHandlerState.calculatedKey);
}
Thread.Sleep(200);
}
}
/// <summary>
/// Execute a RuleSet in code
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void codeExecuteRuleSet_ExecuteCode(
object sender, EventArgs e)
{
//create references to properties
CodeThisReferenceExpression codeThis
= new CodeThisReferenceExpression();
CodePropertyReferenceExpression quantityRef
= new CodePropertyReferenceExpression(codeThis, "Quantity");
CodePropertyReferenceExpression itemPriceRef
= new CodePropertyReferenceExpression(codeThis, "ItemPrice");
CodePropertyReferenceExpression orderTotalRef
= new CodePropertyReferenceExpression(codeThis, "OrderTotal");
//create the ruleset
RuleSet rs = new RuleSet("CalculateItemTotals");
//
//define the CalcTotal rule
//
Rule rule = new Rule("CalcTotal");
//IF this.SalesItem.Quantity > 10
CodeBinaryOperatorExpression condition
= new CodeBinaryOperatorExpression(
quantityRef, CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(10));
rule.Condition = new RuleExpressionCondition(condition);
//THEN this.SalesItem.OrderTotal = this.SalesItem.Quantity *
// (this.SalesItem.ItemPrice * 0.95)
CodeAssignStatement assignWithDiscount
= new CodeAssignStatement(orderTotalRef,
new CodeBinaryOperatorExpression(
quantityRef, CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression(itemPriceRef,
CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(0.95))));
rule.ThenActions.Add(new RuleStatementAction(assignWithDiscount));
//ELSE this.SalesItem.OrderTotal = this.SalesItem.Quantity *
// this.SalesItem.ItemPrice
CodeAssignStatement assignWithoutDiscount
= new CodeAssignStatement(orderTotalRef,
new CodeBinaryOperatorExpression(
quantityRef, CodeBinaryOperatorType.Multiply,
itemPriceRef));
rule.ElseActions.Add(new RuleStatementAction(assignWithoutDiscount));
//add rule to ruleset
rs.Rules.Add(rule);
//validate and execute the RuleSet against the
//SalesItem property
RuleValidation validation
= new RuleValidation(typeof(SalesItem), null);
if (rs.Validate(validation))
{
RuleExecution execution = new RuleExecution(validation, SalesItem);
rs.Execute(execution);
}
else
{
foreach (ValidationError error in validation.Errors)
{
Console.WriteLine(error.ErrorText);
}
}
}
