public ImmEvaluation Evaluate(IpMaturityMatrix imm, IEvaluationContext?context = null) { context ??= new Context(); var ruleEvaluations = new List <RuleEvaluation>(); long totalScore = 0; long maximumPossibleScore = 0; foreach (var rule in imm.Rules.Where(r => !r.OptOut)) { var ruleDefinition = this.ruleDefinitionRepository.GetDefinitionFor(rule); if (ruleDefinition != null) { var calculator = this.ruleCalculatorFactory.Create(ruleDefinition.DataType); var ruleEvaluation = new RuleEvaluation(rule, calculator.Percentage(rule, context), calculator.Score(rule, context)); ruleEvaluations.Add(ruleEvaluation); totalScore += ruleEvaluation.Score; maximumPossibleScore += GetMaximumScoreForRule(ruleDefinition, rule); } } return(new ImmEvaluation(ruleEvaluations, totalScore, maximumPossibleScore)); }
private static void Add(RuleEvaluation failure, IList<Result> failures) => failures.Add(new Result { Message = failure.Message, Mitigation = failure.Result<CommandReference>() .IfNotNull() .Then(r => r.ToString()) .ElseDefault() });
private static void Add(RuleEvaluation failure, IList <Result> failures) => failures.Add(new Result { Message = failure.Message, Mitigation = failure.Result <CommandReference>() .IfNotNull() .Then(r => r.ToString()) .ElseDefault() });
public void start() { //Reading incoming stream var getReqThread = Task.Run(() => readInputStream()); //Reading Rules from file var getRuleThread = Task.Run(() => readRulesFromFile()); Task.WhenAll(getReqThread, getRuleThread); //Pass through Rule Evaluation RuleEvaluation eval = new RuleEvaluation(); eval.Evaluate(getReqThread.Result, getRuleThread.Result); }
public void SetCurrentScope( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var term = new FuzzyTerm("Term", new MembershipFunction()); var var = new FuzzyVariable("Variable", null, term); var value = new FuzzyValue(var, new Dictionary<FuzzyTerm, double> { { term, 0.2 } }); var scope = new Scope(value); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = scope }; Assert.AreEqual(scope, sut.InputScope); }
/// <summary> /// Gets the message for the specified <see cref="RuleEvaluation" /> . /// </summary> /// <param name="evaluation"> The <see cref="RuleEvaluation" /> . </param> /// <returns> A validation failure message <see cref="string" /> . </returns> public string GetMessage(RuleEvaluation evaluation) { var template = evaluation.MessageTemplate; if (!string.IsNullOrEmpty(template)) { return(evaluation.Parameters != null ? MessageGenerator.Detokenize(template, evaluation.Parameters) : template); } var failure = evaluation as FailedEvaluation; return(failure != null ? failure.ErrorCode : string.Empty); }
public async Task <HttpResponseMessage> GitHubImmByRule( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "imm/github/{org}/{project}/rule/{ruleId}")] HttpRequest request, string org, string project, string ruleId) { var ruleIdAsGuid = Guid.Parse(ruleId); (string rulesObjectName, string projectObjectName) = this.GetGitHubBranchOrObjectNames(request); (IRuleDefinitionRepository ruleDefinitions, IpMaturityMatrix imm) = await this.GetImmRulesFromGitHubAsync(org, project, rulesObjectName, projectObjectName).ConfigureAwait(false); var evaluationEngine = new EvaluationEngine(ruleDefinitions); RuleEvaluation result = evaluationEngine.Evaluate(imm).RuleEvaluations.First(x => x.RuleAssertion.Id == ruleIdAsGuid); return(this.CreateUncacheResponse(new ByteArrayContent(Encoding.ASCII.GetBytes(BadgePainter.DrawSVG(WebUtility.HtmlEncode(result.RuleAssertion.Name !), $"{result.Percentage}%", GetColourSchemeForPercentage(result.Percentage), Style.Flat))), "image/svg+xml")); }
private void ctrl_cbRuleEvaluation_SelectedValueChanged(object sender, EventArgs e) { RuleEvaluation eval = (RuleEvaluation)Enum.Parse(typeof(RuleEvaluation), ctrl_cbRuleEvaluation.EditValue.ToString()); if (FormEditState == FormEditStates.Adding || FormEditState == FormEditStates.Editing) { ctrl_cboTargetEntityType.Visible = (eval == (RuleEvaluation.TargetOnly | RuleEvaluation.Both)); ctrl_frEdTargetEntityRule.Visible = (eval == (RuleEvaluation.TargetOnly | RuleEvaluation.Both)); ctrl_cboSourceEntityType.Visible = (eval == (RuleEvaluation.SourceOnly | RuleEvaluation.Both)); ctrl_frEdSourceEntityRule.Visible = (eval == (RuleEvaluation.SourceOnly | RuleEvaluation.Both)); } switch (eval) { case RuleEvaluation.SourceOnly: lo_TargetEntity.Visibility = LayoutVisibility.Never; lo_TargetCriteriaTree.Visibility = LayoutVisibility.Never; lo_SourceEntity.Visibility = LayoutVisibility.Always; lo_SourceCriteriaTree.Visibility = LayoutVisibility.Always; break; case RuleEvaluation.TargetOnly: lo_TargetEntity.Visibility = LayoutVisibility.Always; lo_TargetCriteriaTree.Visibility = LayoutVisibility.Always; lo_SourceEntity.Visibility = LayoutVisibility.Never; lo_SourceCriteriaTree.Visibility = LayoutVisibility.Never; break; case RuleEvaluation.Both: lo_TargetEntity.Visibility = LayoutVisibility.Always; lo_TargetCriteriaTree.Visibility = LayoutVisibility.Always; lo_SourceEntity.Visibility = LayoutVisibility.Always; lo_SourceCriteriaTree.Visibility = LayoutVisibility.Always; //dxValidator.GetValidationRule(ctrl_frEdTargetEntityRule); break; default: break; } }
public void Visit_Value_Expression_Fails_Variable_Not_Found( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA = new FuzzyTerm("Term A", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA); var termB = new FuzzyTerm("Term B", new MembershipFunction()); var varB = new FuzzyVariable("Variable B", null); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA, 0.2 } }); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = new Scope(value) }; Assert.Throws<UnresolvedVariableException>(() => sut.Visit(new ValueExpression(varB, termB))); }
public void Apply_Many_Implication_With_Value_Override( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA1 = new FuzzyTerm("TermA1", new MembershipFunction()); var termA2 = new FuzzyTerm("TermA1", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA1, termA2); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA1, 0.2 }, { termA2, 0.6 } }); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = new Scope(value) }; var impl1 = new FuzzyImplication(new AndExpression(new ValueExpression(varA, termA1), new ValueExpression(varA, termA2)), new ValueExpression(varA, termA1)); var result = sut.Apply(new Scope(value), new[] { impl1 }); var val = evaluationStrategy.And(0.2, 0.6); Assert.AreEqual(1, result.Count); Assert.AreEqual(varA, result[0].AssociatedVariable); Assert.AreEqual(2, result[0].Values.Count); // A = A1 got overridden: Assert.AreEqual(val, result[0].Values[termA1]); // A = A2 stays the same: Assert.AreEqual(0.6, result[0].Values[termA2]); }
public void Apply_Many_Implication_With_Value_Merging( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA1 = new FuzzyTerm("TermA1", new MembershipFunction()); var termA2 = new FuzzyTerm("TermA1", new MembershipFunction()); var termB1 = new FuzzyTerm("TermB1", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA1, termA2); var varB = new FuzzyVariable("Variable B", null, termB1); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA1, 0.5 }, { termA2, 0.6 } }); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = new Scope(value) }; var impl1 = new FuzzyImplication(new ValueExpression(varA, termA1), new ValueExpression(varB, termB1)); var impl2 = new FuzzyImplication(new ValueExpression(varA, termA2), new ValueExpression(varB, termB1)); var result = sut.Apply(new Scope(value), new[] { impl1, impl2 }); var mergedValue = merger.Apply(new FuzzyValue[] { new FuzzyValue(varB, new Dictionary<FuzzyTerm, double> { { termB1, 0.5 } }), new FuzzyValue(varB, new Dictionary<FuzzyTerm, double> { { termB1, 0.6 } }) }); Assert.AreEqual(2, result.Count); Assert.AreEqual(varA, result[0].AssociatedVariable); Assert.AreEqual(2, result[0].Values.Count); Assert.AreEqual(0.5, result[0].Values[termA1]); Assert.AreEqual(0.6, result[0].Values[termA2]); Assert.AreEqual(varB, result[1].AssociatedVariable); Assert.AreEqual(1, result[1].Values.Count); Assert.AreEqual(mergedValue[0].Values[termB1], result[1].Values[termB1]); }
public void Apply_Many_Implication( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA1 = new FuzzyTerm("TermA1", new MembershipFunction()); var termA2 = new FuzzyTerm("TermA1", new MembershipFunction()); var termB1 = new FuzzyTerm("TermB1", new MembershipFunction()); var termB2 = new FuzzyTerm("TermB2", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA1, termA2); var varB = new FuzzyVariable("Variable B", null, termB1, termB2); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA1, 0.4 }, { termA2, 0.6 } }); var sut = new RuleEvaluation(evaluationStrategy, merger); var impl1 = new FuzzyImplication(new ValueExpression(varA, termA1), new ValueExpression(varB, termB1)); var impl2 = new FuzzyImplication(new ValueExpression(varA, termA2), new ValueExpression(varB, termB2)); var result = sut.Apply(new Scope(value), new[] {impl1, impl2}).ToList(); Assert.AreEqual(2, result.Count); var valA = result.Find(val => val.AssociatedVariable.Equals(varA)); Assert.IsNotNull(valA); Assert.AreEqual(2, valA.Values.Count); Assert.AreEqual(0.4, valA.Values[termA1]); Assert.AreEqual(0.6, valA.Values[termA2]); var valB = result.Find(val => val.AssociatedVariable.Equals(varB)); Assert.IsNotNull(valB); Assert.AreEqual(2, valB.Values.Count); Assert.AreEqual(0.4, valB.Values[termB1]); Assert.AreEqual(0.6, valB.Values[termB2]); }
public void Apply_One_Implication( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA = new FuzzyTerm("TermA", new MembershipFunction()); var termB = new FuzzyTerm("TermB", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA); var varB = new FuzzyVariable("Variable B", null, termB); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA, 0.4 } }); var sut = new RuleEvaluation(evaluationStrategy, merger); var result = sut.Apply(new Scope(value), new[] {new FuzzyImplication(new ValueExpression(varA, termA), new ValueExpression(varB, termB))}); Assert.AreEqual(2, result.Count); Assert.AreEqual(varA, result[0].AssociatedVariable); Assert.AreEqual(1, result[0].Values.Count); Assert.AreEqual(0.4, result[0].Values[termA]); Assert.AreEqual(varB, result[1].AssociatedVariable); Assert.AreEqual(1, result[1].Values.Count); Assert.AreEqual(0.4, result[1].Values[termB]); }
public void Visit_Implication_Expression( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var termA = new FuzzyTerm("TermA", new MembershipFunction()); var termB = new FuzzyTerm("TermB", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA); var varB = new FuzzyVariable("Variable B", null, termB); var value = new FuzzyValue(varA, new Dictionary<FuzzyTerm, double> { { termA, 0.4 } }); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = new Scope(value) }; var result = sut.Visit(new FuzzyImplication(new ValueExpression(varA, termA), new ValueExpression(varB, termB))); Assert.AreEqual(0.4, result); }
public void Visit_Or_Expression( [Values("Algebraic", "Drastic", "Einstein", "Hamacher", "Lukasiewicz", "MinMax")] string evalStrategyName, [Values("Average", "Max", "Min", "Sum")] string mergeStrategy) { var evaluationStrategy = createEvaluationStrategy(evalStrategyName); var merger = createFuzzyValueMerger(mergeStrategy); var term1 = new FuzzyTerm("Term1", new MembershipFunction()); var term2 = new FuzzyTerm("Term2", new MembershipFunction()); var var = new FuzzyVariable("Variable", null, term1, term2); var value = new FuzzyValue(var, new Dictionary<FuzzyTerm, double> { { term1, 0.2 }, { term2, 0.8 } }); var sut = new RuleEvaluation(evaluationStrategy, merger) { InputScope = new Scope(value) }; var result = sut.Visit(new OrExpression(new ValueExpression(var, term1), new ValueExpression(var, term2))); Assert.AreEqual(evaluationStrategy.Or(value.Values[term1], value.Values[term2]), result); }
/// <summary> /// Validates the entity against rules set for the specific entity against itself. /// </summary> /// <param name="entityRules">This can be a list of all the rules or an already filtered list, the rules will be checked again.</param> /// <param name="theEntity">The entity that is being used to look up rules against its own type and its specific record</param> /// <param name="ruleApplicator">The event or process the event is applied to.</param> /// <returns>Returns the rule that was matched or null if nothing matched</returns> public IJarsRule EvaluateEntityOwnRules(List <IJarsRule> entityRules, IEntityBase theEntity, RuleRunsOn ruleApplicator, RuleEvaluation ruleEvaluation = RuleEvaluation.Both) { var fullFilterList = new List <IJarsRule>(); if (ruleEvaluation == RuleEvaluation.Both) { fullFilterList = entityRules.FindAll(r => r.SourceTypeName == theEntity.GetType().Name&& r.TargetTypeName == theEntity.GetType().Name&& r.RuleEvaluation == ruleEvaluation && r.RuleRunsOn.Contains(ruleApplicator.ToString())); } if (ruleEvaluation == RuleEvaluation.SourceOnly) { fullFilterList = entityRules.FindAll(r => r.SourceTypeName == theEntity.GetType().Name&& r.RuleEvaluation == ruleEvaluation && r.RuleRunsOn.Contains(ruleApplicator.ToString())); } if (ruleEvaluation == RuleEvaluation.TargetOnly) { fullFilterList = entityRules.FindAll(r => r.TargetTypeName == theEntity.GetType().Name&& r.RuleEvaluation == ruleEvaluation && r.RuleRunsOn.Contains(ruleApplicator.ToString())); } //does the entity type meet the its own conditions? //var entityFilterList = fullFilterList.FindAll(rules => rules.TargetEntityId == $"{theEntity.Id}"); if (!fullFilterList.Any()) { return(null); } DataTable entityTable = theEntity.ConvertToDataTable(); foreach (var rule in fullFilterList) { if (ruleEvaluation == RuleEvaluation.Both) { if (!EvaluateRule(entityTable, null, rule)) { return(rule); } if (!EvaluateRule(null, entityTable, rule)) { return(rule); } } else { if (!EvaluateRule(entityTable, null, rule)) { return(rule); } } } return(null); }