public virtual void AddEvaluator(LogicDefine.Evaluator toAdd) { LogicDefine.Evaluator match = this.GetEvaluator(toAdd.Id); if (match == null) { this.WorkFlow.Evaluators.Add(toAdd); } }
private ArticulateEvaluator ArticulateEvaluator(LogicDefine.Rule x) { ArticulateEvaluator toBuild = new ArticulateEvaluator() { Id = x.Id }; LogicDefine.Evaluator ev = this.workflow.Evaluators.FirstOrDefault(g => g.Id == x.Id); toBuild.Literal = ev.Description; toBuild.TrueCondition = x.TrueCondition; if (x.Context != null) { ContextDefinition ctxDef = this.workflow.ContextDefinitions.FirstOrDefault(g => g.Name.Equals(x.Context.Name, StringComparison.OrdinalIgnoreCase)); string ctxLit = string.Join(",", (from i in ctxDef.Items where x.Context.Keys.Contains(i.Key) select i.Literal)); ArticulateContext articulateContext = new ArticulateContext() { Literal = ctxDef.Literal, Value = ctxLit }; //var intent = this.logicIntents.FirstOrDefault(g => g.evaluatorId == x.Id); //if (intent != null && intent.Context != null) //{ // articulateContext.Literal = intent.Context.Literal; // if (intent.Context.Values != null) // { // ContextItem match = intent.Context.Values.FirstOrDefault(k => k.Key == ctx.Key); // if (!string.IsNullOrEmpty(match.Key)) // { // ctx.Literal = match.Literal; // } // } //} //if (string.IsNullOrEmpty(ctx.Literal)) { ctx.Literal = "Inferred"; } //if (string.IsNullOrEmpty(articulateContext.Literal)) { articulateContext.Literal = "Inferred"; } //articulateContext.Context = ctx; toBuild.Context = articulateContext; } return(toBuild); }
private IRule <TModel> LoadLogic(string equationId) { StepTracer <LintTrace> trace = new StepTracer <LintTrace>(); StepTraceNode <LintTrace> root = trace.TraceFirst(new LintTrace(LintStatusOptions.Loading, "Loading Logic", equationId)); //Lint.... make sure we have everything we need first. Func <LogicDefine.Rule, StepTraceNode <LintTrace>, bool, IRule <TModel> > LoadRule = null; LoadRule = (rule, parentStep, inner) => { StepTraceNode <LintTrace> step = trace.TraceNext(parentStep, new LintTrace(LintStatusOptions.Inspecting, "Inspecting Rule", rule.Id)); IRule <TModel> toReturn = null; //if id is an equation, we are creating an expression //since we've formalized convention, we can just check that if (ConventionHelper.MatchesConvention(NamePrefixOptions.Equation, rule.Id, this.Configuration.Convention)) { LogicDefine.Equation eq = this.WorkflowManager.GetEquation(rule.Id); IRule <TModel> first = LoadRule(eq.First, step, true); IRule <TModel> second = LoadRule(eq.Second, step, true); toReturn = new Expression <TModel>(rule, eq.Condition, first, second, this, inner); } else { LogicDefine.Evaluator ev = this.WorkflowManager.GetEvaluator(rule.Id); toReturn = new Rule <TModel>(rule, this, inner); } return(toReturn); }; LogicDefine.Rule eqRule = equationId; IRule <TModel> loaded = LoadRule(eqRule, root, false); return(loaded); }
public IRuleEvaluatorX <TModel> GetRuleEvaluator(LogicDefine.Evaluator def) { LogicDefine.Evaluator withoutConvention = new LogicDefine.Evaluator() { Id = ConventionHelper.RemoveConvention(def.Id, this.Configuration.Convention), Description = def.Description }; IRuleEvaluatorX <TModel> toReturn = default(IRuleEvaluatorX <TModel>); if (this.evaluators.ContainsKey(withoutConvention.Id)) { toReturn = this.evaluators[withoutConvention.Id]; } else { toReturn = this.evaluators[def.Id]; } return(toReturn); }
//this needs to // * ensure reaction rule is an equation // * ensure that any evaluators exist in the evaluators list private string LoadLogic(WorkDefine.Workflow workFlow, string equationId) { StepTraceNode <LintTrace> root = this.tracer.Root; //load conventions LogicDefine.Evaluator trueDef = workFlow.Evaluators.FirstOrDefault(z => z.Id == ConventionHelper.TrueEvaluator(this.config.Convention)); if (null == trueDef) { trueDef = new LogicDefine.Evaluator() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Description = "Always True" }; workFlow.Evaluators.Add(trueDef); } LogicDefine.Equation trueEqDef = workFlow.Equations.FirstOrDefault(z => z.Id == ConventionHelper.TrueEquation(this.config.Convention)); if (null == trueEqDef) { trueEqDef = new LogicDefine.Equation() { Condition = Logic.Operand.Or, First = trueDef.Id, Second = trueDef.Id, Id = ConventionHelper.TrueEquation(this.config.Convention) }; workFlow.Equations.Add(trueEqDef); } //Lint.... make sure we have everything we need first. Action <LogicDefine.Rule, StepTraceNode <LintTrace>, bool> LoadRule = null; LoadRule = (rule, parentStep, isRoot) => { StepTraceNode <LintTrace> step = this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.Inspecting, "Inspecting Rule", rule.Id)); //if id is an equation, we are creating an expression LogicDefine.Equation eq = workFlow.Equations.FirstOrDefault(g => g.Id.Equals(rule.Id)); if (null != eq) { if (null != eq.First) { LoadRule(eq.First, step, false); } else { eq.First = new LogicDefine.Rule() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Context = string.Empty, TrueCondition = true }; } if (null != eq.Second) { LoadRule(eq.Second.Id, step, false); } else { eq.Second = new LogicDefine.Rule() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Context = string.Empty, TrueCondition = true }; } if (!rule.TrueCondition) { //create a negation equation. string negationId = ConventionHelper.NegateEquationName(rule.Id, this.config.Convention); LogicDefine.Rule negated = (LogicDefine.Rule)rule.Clone(); //negated.TrueCondition = false; if (workFlow.Equations.Count(g => g.Id == negationId) == 0) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.InferringEquation, string.Format("Inferring negation equation from {0}", rule.Id), negationId)); LogicDefine.Equation toAdd = new LogicDefine.Equation() { First = negated, Id = negationId, Condition = Logic.Operand.And, Second = ConventionHelper.TrueEvaluator(this.config.Convention) }; workFlow.Equations.Add(toAdd); rule.TrueCondition = true; rule.Id = negationId; } } } else { //if reaction ruleid is not an equation, create an equation and update reaction LogicDefine.Evaluator ev = workFlow.Evaluators.FirstOrDefault(g => g.Id.Equals(rule.Id)); if (null == ev) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.LazyDefinition, "No definition found for evaluator", rule.Id)); ev = new LogicDefine.Evaluator() { Id = rule.Id, Description = string.Empty }; workFlow.Evaluators.Add(ev); } //if this is the rule referenced by the reaction, then create an equation also, //and update the equation. This isn't necessary, but consistent. if (isRoot) { LogicDefine.Rule cloned = (LogicDefine.Rule)rule.Clone(); string newId = string.Empty; Logic.Operand condition = Logic.Operand.And; if (rule.Id == ConventionHelper.TrueEquation(this.config.Convention)) { newId = ConventionHelper.TrueEquation(this.config.Convention); condition = Logic.Operand.Or; } else { newId = ConventionHelper.ChangePrefix(NamePrefixOptions.Evaluator, NamePrefixOptions.Equation, rule.Id, this.config.Convention); } if (!rule.TrueCondition) { newId = ConventionHelper.NegateEquationName(newId, this.config.Convention); } if (workFlow.Equations.Count(g => g.Id == newId) == 0) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.InferringEquation, string.Format("Inferring equation from {0}", rule.Id), newId)); workFlow.Equations.Add(new LogicDefine.Equation() { Condition = condition, First = cloned, Second = ConventionHelper.TrueEvaluator(this.config.Convention), Id = newId }); } rule.Id = newId; } } }; LogicDefine.Rule eqRule = equationId; LoadRule(eqRule, root, true); return(eqRule.Id); }
public IRuleEvaluatorX <TModel> GetEvaluator(LogicDefine.Evaluator def) { return(this.ef.GetRuleEvaluator <TModel>(def)); }
public virtual IRuleEvaluatorX <TModel> GetEvaluator(LogicDefine.Evaluator def) { return(this.EvaluatorFactory.GetRuleEvaluator(def)); }
public virtual LogicDefine.Evaluator GetEvaluator(string id) { LogicDefine.Evaluator ev = this.WorkFlow.Evaluators.FirstOrDefault(g => g.Id.Equals(id)); return(ev); }