public Domain GetDomain(Uri domainUri)
{
string host = domainUri.Host;
if (string.IsNullOrEmpty(host))
{
return(null);
}
var parts = host
.Split('.')
.Reverse()
.ToList();
if (parts.Count == 0 || parts.Any(x => x.Equals(string.Empty)))
{
return(null);
}
IEnumerable <DomainRule> rules = DomainsCache <DomainRule> .GetRules();
DomainRule matchedDomain = null;
string domain = host;
while (matchedDomain == null || domain.IndexOf('.') != -1)
{
domain = domain.Remove(0, domain.IndexOf('.') + 1).Trim();
matchedDomain = rules.FirstOrDefault(x => x.Name == domain);
}
return(new Domain(host, matchedDomain));
}
public void Load()
{
try
{
if (!File.Exists(FilePath))
{
return;
}
var rules = XDocument.Load(FilePath).Root;
mDomainRules.Clear();
foreach (var rule in GetAllRules())
{
Debug.Assert(!(rule is DomainRule), "No domain rules should be present at this point, as mDomainRules should be emptied.");
DeserializeRule(rule, rules);
}
foreach (var element in rules.Elements(new DomainRule().ElementName))
{
var domainRule = new DomainRule();
domainRule.Deserialize(element);
mDomainRules.Add(domainRule);
}
}
catch (FileNotFoundException)
{
}
catch (SecurityException)
{
}
}
private void mAdd_Click(object sender, EventArgs e)
{
var newRule = new DomainRule();
if (newRule.ShowEditorDialog(this) == DialogResult.OK)
{
Rules.Instance.AddDomainRule(newRule);
SaveAndUpdateList();
mRules.SelectedObject = newRule;
}
}
internal static void ShowAddDomainRule(string url)
{
var newRule = new DomainRule
{
DomainSuffix = Rules.GetDomain(url),
Language = InputLanguage.CurrentInputLanguage
};
if (newRule.ShowEditorDialog(sCurrentConfigDialog) == DialogResult.OK)
{
Rules.Instance.AddDomainRule(newRule);
if (sCurrentConfigDialog != null)
{
sCurrentConfigDialog.SaveAndUpdateList();
}
else
{
Rules.Instance.Save();
}
}
}
public Domain(string domain, DomainRule rule)
{
string tld = string.Empty;
string name = string.Empty;
string subDomain = string.Empty;
string mainDomain = string.Empty;
string host = string.Empty;
//www.example.com.ua
IList <string> parts = domain.Split('.').Select(x => x.Trim()).Reverse().ToList();
if (parts.Count() == rule.LabelCount)
{
}
//com.ua
tld = rule.Name;
//example
name = parts.Skip(rule.LabelCount).Take(1).Single();
//example.com.ua
mainDomain = name + '.' + tld;
//www
if (parts.Count != rule.LabelCount + 1)
{
subDomain = parts.Skip(rule.LabelCount + 1).Take(1).Single();
}
//host
host = domain;
this.DomainRule = rule;
this.Name = name;
this.SubDomain = subDomain;
this.MainDomain = mainDomain;
this.Tld = tld;
this.Host = host;
}
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);
}
}
public static void AddNewRule(this WonkaBizRuleSet poRuleSet,
WonkaRefEnvironment poRefEnv,
string psAddRuleDesc,
string psAddRuleTargetAttr,
string psAddRuleTypeNum,
string psAddRuleValue1,
string psAddRuleValue2,
bool pbAddRuleNotOp = false)
{
int nRuleTypeNum = Int32.Parse(psAddRuleTypeNum);
WonkaBizRule NewRule = null;
WonkaRefAttr targetAttr = poRefEnv.GetAttributeByAttrName(psAddRuleTargetAttr);
if (nRuleTypeNum == 1)
{
if (!targetAttr.IsNumeric && !targetAttr.IsDecimal)
{
throw new DataException("ERROR! Cannot perform arithmetic limit on a non-numeric value.");
}
double dMinVal = 0;
double dMaxVal = 0;
Double.TryParse(psAddRuleValue1, out dMinVal);
Double.TryParse(psAddRuleValue2, out dMaxVal);
NewRule =
new ArithmeticLimitRule(mnRuleCounter++, TARGET_RECORD.TRID_NEW_RECORD, targetAttr.AttrId, dMinVal, dMaxVal);
}
else if (nRuleTypeNum == 2)
{
/*
* NOTE: Will handle ArithmeticRule later
* string[] asParamArray = new string[0];
*/
}
else if (nRuleTypeNum == 3)
{
if (!String.IsNullOrEmpty(psAddRuleValue1))
{
NewRule =
new AssignmentRule(mnRuleCounter++, TARGET_RECORD.TRID_NEW_RECORD, targetAttr.AttrId, psAddRuleValue1);
}
}
else if (nRuleTypeNum == 4)
{
/*
* NOTE: Will handle CustomOperatorRule later
*/
}
else if (nRuleTypeNum == 5)
{
if (!targetAttr.IsDate)
{
throw new DataException("ERROR! Cannot perform date limit on a non-date value.");
}
if ((!String.IsNullOrEmpty(psAddRuleValue1)) || (!String.IsNullOrEmpty(psAddRuleValue2)))
{
DateTime dtMinTime = DateTime.MinValue;
DateTime dtMaxTime = DateTime.MaxValue;
if (!String.IsNullOrEmpty(psAddRuleValue1))
{
DateTime.TryParse(psAddRuleValue1, out dtMinTime);
}
if (!String.IsNullOrEmpty(psAddRuleValue2))
{
DateTime.TryParse(psAddRuleValue2, out dtMaxTime);
}
var DtLimitRule =
new DateLimitRule(mnRuleCounter++)
{
MinValue = dtMinTime, MaxValue = dtMaxTime, TargetAttribute = targetAttr
};
NewRule = DtLimitRule;
}
}
else if (nRuleTypeNum == 6)
{
if ((!String.IsNullOrEmpty(psAddRuleValue1)) || (!String.IsNullOrEmpty(psAddRuleValue2)))
{
HashSet <string> RuleDomain = new HashSet <string>();
if (!String.IsNullOrEmpty(psAddRuleValue1))
{
if (psAddRuleValue1.Contains(","))
{
var DomainVals = psAddRuleValue1.Split(new char[1] {
','
});
DomainVals.ToList().ForEach(x => DomainVals.Append(x));
}
else
{
RuleDomain.Add(psAddRuleValue1);
}
}
if (!String.IsNullOrEmpty(psAddRuleValue2))
{
if (psAddRuleValue2.Contains(","))
{
var DomainVals = psAddRuleValue2.Split(new char[1] {
','
});
DomainVals.ToList().ForEach(x => DomainVals.Append(x));
}
else
{
RuleDomain.Add(psAddRuleValue2);
}
}
var DmnRule =
new DomainRule(mnRuleCounter++, TARGET_RECORD.TRID_NEW_RECORD, targetAttr.AttrId, false);
DmnRule.DomainCache = RuleDomain;
foreach (string sTmpValue in RuleDomain)
{
DmnRule.DomainValueProps.Add(sTmpValue, new WonkaBizRuleValueProps()
{
IsLiteralValue = true
});
}
NewRule = DmnRule;
}
}
else if (nRuleTypeNum == 7)
{
NewRule = new PopulatedRule(mnRuleCounter++, TARGET_RECORD.TRID_NEW_RECORD, targetAttr.AttrId);
}
if (NewRule != null)
{
if (!String.IsNullOrEmpty(psAddRuleDesc))
{
NewRule.DescRuleId = psAddRuleDesc;
}
NewRule.ParentRuleSetId = poRuleSet.RuleSetId;
NewRule.NotOperator = pbAddRuleNotOp;
poRuleSet.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);
}
}
public void RemoveDomainRule(DomainRule rule)
{
var result = mDomainRules.Remove(rule);
Debug.Assert(result, "Domain rule was not found");
}
public void AddDomainRule(DomainRule rule)
{
mDomainRules.Add(rule);
}
