public static WonkaBizRule FindRuleById(this WonkaBizRuleSet poTargetSet, string psSoughtId)
{
WonkaBizRule FoundRule = new ArithmeticRule();
foreach (var TmpChildSet in poTargetSet.ChildRuleSets)
{
foreach (var TmpRule in TmpChildSet.EvaluativeRules)
{
if (TmpRule.DescRuleId == psSoughtId)
{
return(TmpRule);
}
}
foreach (var TmpRule in TmpChildSet.AssertiveRules)
{
if (TmpRule.DescRuleId == psSoughtId)
{
return(TmpRule);
}
}
FoundRule = FindRuleById(TmpChildSet, psSoughtId);
if (FoundRule.RuleId > 0)
{
return(FoundRule);
}
}
return(FoundRule);
}
public static string GetOpTypeDesc(this ArithmeticRule poTargetRule)
{
string sOpTypeDesc = "";
if (poTargetRule.OpType == ARITH_OP_TYPE.AOT_SUM)
{
sOpTypeDesc = "ADD";
}
else if (poTargetRule.OpType == ARITH_OP_TYPE.AOT_DIFF)
{
sOpTypeDesc = "MINUS";
}
else if (poTargetRule.OpType == ARITH_OP_TYPE.AOT_PROD)
{
sOpTypeDesc = "MULTIPLY";
}
else if (poTargetRule.OpType == ARITH_OP_TYPE.AOT_QUOT)
{
sOpTypeDesc = "DIVIDE";
}
return(sOpTypeDesc);
}
private void SetRuleValues(WonkaBizRule poTargetRule, string psRuleExpression)
{
char[] acRuleValuesDelim = new char[1] {
','
};
int nValueStartIdx = psRuleExpression.LastIndexOf(CONST_RULE_TOKEN_START_DELIM);
if (nValueStartIdx >= 0)
{
int nValueEndIdx =
psRuleExpression.IndexOf(CONST_RULE_TOKEN_END_DELIM, nValueStartIdx + 1);
if (nValueEndIdx > 0)
{
string sValues =
psRuleExpression.Substring(nValueStartIdx + 1, (nValueEndIdx - nValueStartIdx - 1));
string[] asValueSet = sValues.Split(acRuleValuesDelim);
if (poTargetRule.RuleType == RULE_TYPE.RT_DOMAIN)
{
DomainRule Rule = (DomainRule)poTargetRule;
Rule.SetDomain(asValueSet);
}
else if (poTargetRule.RuleType == RULE_TYPE.RT_ARITHMETIC)
{
ArithmeticRule Rule = (ArithmeticRule)poTargetRule;
Rule.SetDomain(asValueSet);
}
else if (poTargetRule.RuleType == RULE_TYPE.RT_ARITH_LIMIT)
{
ArithmeticLimitRule Rule = (ArithmeticLimitRule)poTargetRule;
Rule.SetMinAndMax(psRuleExpression, asValueSet);
}
else if (poTargetRule.RuleType == RULE_TYPE.RT_ASSIGNMENT)
{
AssignmentRule Rule = (AssignmentRule)poTargetRule;
Rule.SetAssignValue(asValueSet);
}
else if (poTargetRule.RuleType == RULE_TYPE.RT_DATE_LIMIT)
{
DateLimitRule Rule = (DateLimitRule)poTargetRule;
Rule.SetMinAndMax(psRuleExpression, asValueSet);
}
else if (poTargetRule.RuleType == RULE_TYPE.RT_CUSTOM_OP)
{
CustomOperatorRule Rule = (CustomOperatorRule)poTargetRule;
string sCustomOpKey = CustomOpSources.Keys.Where(s => psRuleExpression.Contains(s)).FirstOrDefault();
if (!string.IsNullOrEmpty(sCustomOpKey))
{
Rule.SetDomain(asValueSet);
Rule.CustomOpName = sCustomOpKey;
Rule.CustomOpSource = CustomOpSources[sCustomOpKey];
}
}
}
}
}
private void ParseSingleRule(XmlNode poRuleXmlNode, WonkaBizRuleSet poTargetRuleSet)
{
int nNewRuleId = ++(this.RuleIdCounter);
string sRuleExpression = poRuleXmlNode.InnerText;
WonkaBizRule NewRule = null;
if (this.CustomOpSources.Keys.Any(s => sRuleExpression.Contains(s)))
{
string sFoundKey = this.CustomOpSources.Keys.FirstOrDefault(s => sRuleExpression.Contains(s));
if (!String.IsNullOrEmpty(sFoundKey) && (this.CustomOpSources[sFoundKey].CustomOpRuleBuilder != null))
{
WonkaBizSource CustomOpSource = this.CustomOpSources[sFoundKey];
NewRule = CustomOpSource.CustomOpRuleBuilder.Invoke(CustomOpSource, nNewRuleId);
}
else
{
NewRule = new CustomOperatorRule()
{
RuleId = nNewRuleId
};
}
}
else if (this.ArithmeticLimitOps.Any(s => sRuleExpression.Contains(s)))
{
NewRule = new ArithmeticLimitRule()
{
RuleId = nNewRuleId
};
}
else if (this.DateLimitOps.Any(s => sRuleExpression.Contains(s)))
{
NewRule = new DateLimitRule()
{
RuleId = nNewRuleId
};
}
else if (sRuleExpression.Contains("NOT POPULATED"))
{
NewRule = new PopulatedRule()
{
RuleId = nNewRuleId, NotOperator = true
};
}
else if (sRuleExpression.Contains("POPULATED"))
{
NewRule = new PopulatedRule()
{
RuleId = nNewRuleId, NotOperator = false
};
}
else if (sRuleExpression.Contains("!="))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = true
};
}
else if (sRuleExpression.Contains("=="))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false
};
}
else if (sRuleExpression.Contains("NOT IN"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = true
};
}
else if (sRuleExpression.Contains("IN"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false
};
}
else if (sRuleExpression.Contains("EXISTS AS"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false, SearchAllDataRows = true
};
}
else if (sRuleExpression.Contains("DEFAULT"))
{
NewRule = new AssignmentRule()
{
RuleId = nNewRuleId, NotOperator = false, DefaultAssignment = true
};
}
else if (sRuleExpression.Contains("ASSIGN_SUM"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_SUM
};
}
else if (sRuleExpression.Contains("ASSIGN_DIFF"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_DIFF
};
}
else if (sRuleExpression.Contains("ASSIGN_PROD"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_PROD
};
}
else if (sRuleExpression.Contains("ASSIGN_QUOT"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_QUOT
};
}
else if (sRuleExpression.Contains("ASSIGN"))
{
NewRule = new AssignmentRule()
{
RuleId = nNewRuleId, NotOperator = false
};
}
if (NewRule != null)
{
var RuleId = poRuleXmlNode.Attributes.GetNamedItem(CONST_RULE_ID_ATTR);
if (RuleId != null)
{
NewRule.DescRuleId = RuleId.Value;
}
NewRule.ParentRuleSetId = poTargetRuleSet.RuleSetId;
SetTargetAttribute(NewRule, sRuleExpression);
if (NewRule.RuleType != RULE_TYPE.RT_POPULATED)
{
SetRuleValues(NewRule, sRuleExpression);
}
if (RulesHostEngine != null)
{
NewRule.RulesHostEngine = RulesHostEngine;
if (RulesHostEngine.StdOpMap != null)
{
if ((NewRule is ArithmeticLimitRule) && RulesHostEngine.StdOpMap.ContainsKey(STD_OP_TYPE.STD_OP_BLOCK_NUM))
{
((ArithmeticLimitRule)NewRule).BlockNumDelegate = RulesHostEngine.StdOpMap[STD_OP_TYPE.STD_OP_BLOCK_NUM];
}
}
}
}
if (NewRule != null)
{
poTargetRuleSet.AddRule(NewRule);
}
}
///
/// <summary>
///
/// This method will write the XML (i.e., Wonka rules markup) of a Rule.
///
/// NOTE: Currently, we use a StringBuilder class to build the XML Document. In the future, we should transition to
/// using a XmlDocument and a XmlWriter.
///
/// <returns>Returns the XML payload that represents a Rule</returns>
/// </summary>
public string ExportXmlString(WonkaBizRule poRule, StringBuilder poSpaces)
{
string sOpName = string.Empty;
string sRuleValue = "";
string sDelim = WonkaBizRulesXmlReader.CONST_RULE_TOKEN_VAL_DELIM;
string sSingleQuote = "'";
string sRuleTagFormat =
"{0}<" + WonkaBizRulesXmlReader.CONST_RULE_TAG + " " + WonkaBizRulesXmlReader.CONST_RULE_ID_ATTR + "=\"{1}\">(N.{2}) {3} {4}</eval>\n";
if (poRule.RuleType == RULE_TYPE.RT_ARITH_LIMIT)
{
ArithmeticLimitRule ArithLimitRule = (ArithmeticLimitRule)poRule;
if (ArithLimitRule.MinValue == Double.MinValue)
{
sOpName = !poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_AL_LT : WonkaBizRulesXmlReader.CONST_AL_NOT_LT;
sRuleValue = Convert.ToString(ArithLimitRule.MaxValue);
}
else if (ArithLimitRule.MaxValue == Double.MaxValue)
{
sOpName = !poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_AL_GT : WonkaBizRulesXmlReader.CONST_AL_NOT_GT;
sRuleValue = Convert.ToString(ArithLimitRule.MinValue);
}
else
{
sOpName = !poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_AL_EQ : WonkaBizRulesXmlReader.CONST_AL_NOT_EQ;
sRuleValue = Convert.ToString(ArithLimitRule.MinValue);
}
}
else if (poRule.RuleType == RULE_TYPE.RT_DATE_LIMIT)
{
DateLimitRule DtLimitRule = (DateLimitRule)poRule;
if (DtLimitRule.MinValue == DateTime.MinValue)
{
sOpName = !poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_DL_IA : WonkaBizRulesXmlReader.CONST_DL_NOT_IA;
sRuleValue = DtLimitRule.MaxValue.ToString("MM/dd/yyyy");
}
else if (DtLimitRule.MaxValue == DateTime.MaxValue)
{
sOpName = !poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_DL_IB : WonkaBizRulesXmlReader.CONST_DL_NOT_IB;
sRuleValue = DtLimitRule.MinValue.ToString("MM/dd/yyyy");
}
else
{
sOpName = WonkaBizRulesXmlReader.CONST_DL_AROUND;
sRuleValue = DtLimitRule.MinValue.ToString("MM/dd/yyyy");
}
}
else if (poRule.RuleType == RULE_TYPE.RT_POPULATED)
{
sOpName =
!poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_BASIC_OP_POP : WonkaBizRulesXmlReader.CONST_BASIC_OP_NOT_POP;
}
else if (poRule.RuleType == RULE_TYPE.RT_DOMAIN)
{
StringBuilder DomainVals = new StringBuilder();
DomainRule DmnRule = (DomainRule)poRule;
sOpName =
!poRule.NotOperator ? WonkaBizRulesXmlReader.CONST_BASIC_OP_IN : WonkaBizRulesXmlReader.CONST_BASIC_OP_NOT_IN;
sRuleValue = BuildDomainValues(DmnRule.DomainValueProps, sDelim, sSingleQuote);
}
else if (poRule.RuleType == RULE_TYPE.RT_ASSIGNMENT)
{
StringBuilder DomainVals = new StringBuilder();
AssignmentRule AssignRule = (AssignmentRule)poRule;
sOpName = WonkaBizRulesXmlReader.CONST_BASIC_OP_ASSIGN;
var ValueProps = new Dictionary <string, WonkaBizRuleValueProps>();
ValueProps[AssignRule.AssignValue] = AssignRule.AssignValueProps;
sRuleValue = BuildDomainValues(ValueProps, sDelim, sSingleQuote);
}
else if (poRule.RuleType == RULE_TYPE.RT_ARITHMETIC)
{
ArithmeticRule ArithRule = (ArithmeticRule)poRule;
if (ArithRule.OpType == ARITH_OP_TYPE.AOT_SUM)
{
sOpName = WonkaBizRulesXmlReader.CONST_BASIC_OP_ASSIGN_SUM;
}
else if (ArithRule.OpType == ARITH_OP_TYPE.AOT_DIFF)
{
sOpName = WonkaBizRulesXmlReader.CONST_BASIC_OP_ASSIGN_DIFF;
}
else if (ArithRule.OpType == ARITH_OP_TYPE.AOT_PROD)
{
sOpName = WonkaBizRulesXmlReader.CONST_BASIC_OP_ASSIGN_PROD;
}
else if (ArithRule.OpType == ARITH_OP_TYPE.AOT_QUOT)
{
sOpName = WonkaBizRulesXmlReader.CONST_BASIC_OP_ASSIGN_QUOT;
}
sRuleValue = BuildDomainValues(ArithRule.DomainValueProps, sDelim, sSingleQuote);
}
else if (poRule.RuleType == RULE_TYPE.RT_CUSTOM_OP)
{
CustomOperatorRule CustomOpRule = (CustomOperatorRule)poRule;
sOpName = CustomOpRule.CustomOpName;
sRuleValue = BuildDomainValues(CustomOpRule.DomainValueProps, sDelim, sSingleQuote);
}
else
{
throw new WonkaBizRuleException("ERROR! Unsupported Rule Type when writing out the Wonka RuleTree.");
}
if (!String.IsNullOrEmpty(sRuleValue))
{
sRuleValue = "(" + sRuleValue + ")";
}
return(String.Format(sRuleTagFormat, poSpaces.ToString(), poRule.DescRuleId, poRule.TargetAttribute.AttrName, sOpName, sRuleValue));
}
private void ParseSingleRule(XmlNode poRuleXmlNode, WonkaBreRuleSet poTargetRuleSet)
{
int nNewRuleId = ++(this.RuleIdCounter);
string sRuleExpression = poRuleXmlNode.InnerText;
WonkaBreRule NewRule = null;
if (this.CustomOpSources.Keys.Any(s => sRuleExpression.Contains(s)))
{
NewRule = new CustomOperatorRule()
{
RuleId = nNewRuleId
}
}
;
else if (this.ArithmeticLimitOps.Any(s => sRuleExpression.Contains(s)))
{
NewRule = new ArithmeticLimitRule()
{
RuleId = nNewRuleId
}
}
;
else if (this.DateLimitOps.Any(s => sRuleExpression.Contains(s)))
{
NewRule = new DateLimitRule()
{
RuleId = nNewRuleId
}
}
;
else if (sRuleExpression.Contains("NOT POPULATED"))
{
NewRule = new PopulatedRule()
{
RuleId = nNewRuleId, NotOperator = true
}
}
;
else if (sRuleExpression.Contains("POPULATED"))
{
NewRule = new PopulatedRule()
{
RuleId = nNewRuleId, NotOperator = false
}
}
;
else if (sRuleExpression.Contains("!="))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = true
}
}
;
else if (sRuleExpression.Contains("=="))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false
}
}
;
else if (sRuleExpression.Contains("NOT IN"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = true
}
}
;
else if (sRuleExpression.Contains("IN"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false
}
}
;
else if (sRuleExpression.Contains("EXISTS AS"))
{
NewRule = new DomainRule()
{
RuleId = nNewRuleId, NotOperator = false, SearchAllDataRows = true
}
}
;
else if (sRuleExpression.Contains("DEFAULT"))
{
NewRule = new AssignmentRule()
{
RuleId = nNewRuleId, NotOperator = false, DefaultAssignment = true
}
}
;
else if (sRuleExpression.Contains("ASSIGN_SUM"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_SUM
}
}
;
else if (sRuleExpression.Contains("ASSIGN_DIFF"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_DIFF
}
}
;
else if (sRuleExpression.Contains("ASSIGN_PROD"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_PROD
}
}
;
else if (sRuleExpression.Contains("ASSIGN_QUOT"))
{
NewRule = new ArithmeticRule()
{
RuleId = nNewRuleId, NotOperator = false, OpType = ARITH_OP_TYPE.AOT_QUOT
}
}
;
else if (sRuleExpression.Contains("ASSIGN"))
{
NewRule = new AssignmentRule()
{
RuleId = nNewRuleId, NotOperator = false
}
}
;
if (NewRule != null)
{
var RuleId = poRuleXmlNode.Attributes.GetNamedItem(CONST_RULE_ID_ATTR);
if (RuleId != null)
{
NewRule.DescRuleId = RuleId.Value;
}
NewRule.ParentRuleSetId = poTargetRuleSet.RuleSetId;
SetTargetAttribute(NewRule, sRuleExpression);
if (NewRule.RuleType != RULE_TYPE.RT_POPULATED)
{
SetRuleValues(NewRule, sRuleExpression);
}
}
if (NewRule != null)
{
poTargetRuleSet.AddRule(NewRule);
}
}
