//public override RuleParameterSet GetEmptyParameterSet() {
// return new RuleParameterSet(new RuleParameter[] {
// new RuleStringParameter("FieldName"),
// new RuleStringParameter("RegExp")});
//}
public override bool IsCompatibleParameterSet(RuleParameterSet parameterSet)
{
RuleStringParameter param1 = parameterSet["FieldName"] as RuleStringParameter;
RuleStringParameter param2 = parameterSet["RegExp"] as RuleStringParameter;
return(param1 != null && param2 != null && param1.Value.Length > 0 && param2.Value.Length > 0);
}
//public override RuleParameterSet GetEmptyParameterSet() {
// return new RuleParameterSet(new RuleParameter[] {
// new RuleStringParameter("LeftValueFieldName"),
// new RuleComparisonOperatorParameter("ComparisonOperator", RuleComparisonOperatorParameter.Operator.Equal),
// new RuleDecimalParameter("RightValueNumerical", 0),
// new RuleInvariantDateTimeParameter("RightValueDateTime", DateTime.Now),
// new RuleStringParameter("RightValueFieldName"),
// new RuleBoolParameter("RightValueUseDateTime", false),
// new RuleBoolParameter("RightValueUseFieldName", false)
// });
//}
public override bool IsCompatibleParameterSet(RuleParameterSet parameterSet)
{
RuleStringParameter leftValueFieldName = parameterSet["LeftValueFieldName"] as RuleStringParameter;
RuleComparisonOperatorParameter comparisonOperator = parameterSet["ComparisonOperator"] as RuleComparisonOperatorParameter;
if (leftValueFieldName == null || String.IsNullOrEmpty(leftValueFieldName.Value))
{
return(false);
}
if (comparisonOperator == null || comparisonOperator.Value == RuleComparisonOperatorParameter.Operator.Unknown)
{
return(false);
}
var rightValueParameter = parameterSet["RightValue"];
var rightValueFieldParameter = parameterSet["RightValueFieldName"] as RuleStringParameter;
var extractionClassParameter = parameterSet["ExtractionFunctionClass"] as RuleStringParameter;
var extractionFunctionParameter = parameterSet["ExtractionFunctionName"] as RuleStringParameter;
// everything's fine if we have either a right value OR a right value field name,
// we can't have both.
// plus, if we have an extraction function class, we also need a function name
return(((rightValueParameter != null) ^
(rightValueFieldParameter != null && (!String.IsNullOrEmpty(rightValueFieldParameter.Value)))) &&
((extractionClassParameter == null && extractionFunctionParameter == null) ||
(extractionClassParameter != null && extractionFunctionParameter != null &&
!String.IsNullOrEmpty(extractionClassParameter.Value) &&
!String.IsNullOrEmpty(extractionFunctionParameter.Value))));
}
public static IEnumerable <Rule> Load(TextReader reader)
{
var doc = XDocument.Load(reader);
foreach (var ruleNode in doc.Element("rules").Elements("rule"))
{
var rule = new Rule {
RuleChecker = BizRulezChecker.RuleCheckers.FromCheckerId(ruleNode.Element("checkerId").Value),
ObjectTypeId = ruleNode.Element("objectTypeId").Value,
ViewName = ruleNode.Element("viewName").Value,
Key = ruleNode.Element("key").Value,
TechnicalComment = ruleNode.Element("technicalComment").Value,
ErrorInfoTemplate = ruleNode.Element("errorInfoTemplate").Value,
Parameters = new RuleParameterSet(
from paramNode in ruleNode.Element("parameters").Elements("parameter")
select RuleParameterSet.CreateParameter(
paramNode.Attribute("typeId").Value,
paramNode.Attribute("name").Value,
paramNode.Value))
};
if (rule.RuleChecker == null)
{
throw new InvalidRuleCheckerException(String.Format("Unknown rule checker id {0} found", ruleNode.Element("checkerId").Value));
}
var contextAttribute = ruleNode.Attribute("context");
if (contextAttribute != null)
{
rule.Contexts = new List <string> {
contextAttribute.Value
};
}
else
{
var contexts = ruleNode.Element("contexts");
if (contexts != null)
{
rule.Contexts = new List <string>(
from contextNode in contexts.Elements("context")
select contextNode.Value);
}
}
var affectedFieldNames = ruleNode.Element("affectedFieldNames");
if (affectedFieldNames != null)
{
rule.AffectedFieldNames = new List <string>(
from fieldNameNode in affectedFieldNames.Elements("fieldName")
select fieldNameNode.Value);
}
yield return(rule);
}
}
///// <summary>
///// Return an empty set of parameters as needed by this rule checker.
///// </summary>
///// <returns></returns>
//public abstract RuleParameterSet GetEmptyParameterSet();
/// <summary>
/// Find out if the given parameter set can be used with this rule
/// checker to actually check a rule. All needed parameters must be
/// available and of the correct type and must contain usable
/// values.
/// </summary>
/// <param name="parameterSet">The parameter set to check.</param>
/// <returns>true if the parameter set is compatible</returns>
public abstract bool IsCompatibleParameterSet(RuleParameterSet parameterSet);
