/// <summary>
/// Compiles the rule described by the specified XML element, which must be a "validation-rule" element.
/// </summary>
/// <param name="ruleNode"></param>
/// <returns></returns>
public IValidationRule CompileRule(XmlElement ruleNode)
{
string property = ruleNode.GetAttribute("boundProperty");
ISpecification spec = _specCompiler.Compile(ruleNode);
return(new ValidationRule(property, spec));
}
private static ValidationRuleSet CompileRuleset(XmlElement rulesetNode)
{
var compiler = new XmlSpecificationCompiler(ScriptLanguage);
var rules = CollectionUtils.Map<XmlElement, ISpecification>(
rulesetNode.GetElementsByTagName(TagValidationRule), compiler.Compile);
var applicabilityRuleNode = CollectionUtils.FirstElement(rulesetNode.GetElementsByTagName(TagApplicabililtyRule));
return applicabilityRuleNode != null ?
new ValidationRuleSet(rules, compiler.Compile((XmlElement)applicabilityRuleNode))
: new ValidationRuleSet(rules);
}
private static ValidationRuleSet CompileRuleset(XmlElement rulesetNode)
{
var compiler = new XmlSpecificationCompiler(ScriptLanguage);
var rules = CollectionUtils.Map <XmlElement, ISpecification>(
rulesetNode.GetElementsByTagName(TagValidationRule), compiler.Compile);
var applicabilityRuleNode = CollectionUtils.FirstElement(rulesetNode.GetElementsByTagName(TagApplicabililtyRule));
return(applicabilityRuleNode != null ?
new ValidationRuleSet(rules, compiler.Compile((XmlElement)applicabilityRuleNode))
: new ValidationRuleSet(rules));
}
/// <summary>
/// Compile the rule.
/// </summary>
/// <param name="ruleNode">XML representation of the rule.</param>
/// <param name="ruleType">The type of the rule.</param>
/// <param name="specCompiler">An <see cref="XmlSpecificationCompiler"/>.</param>
/// <param name="actionCompiler">An <see cref="XmlActionCompiler{TActionContext,TTypeEnum}"/>.</param>
public void Compile(XmlNode ruleNode, TTypeEnum ruleType, XmlSpecificationCompiler specCompiler,
XmlActionCompiler <TActionContext, TTypeEnum> actionCompiler)
{
var conditionNode =
CollectionUtils.SelectFirst(ruleNode.ChildNodes,
(XmlNode child) => child.Name.Equals("condition"));
if (conditionNode != null)
{
_conditions = specCompiler.Compile(conditionNode as XmlElement, true);
}
else if (!IsDefault)
{
throw new ApplicationException("No condition element defined for the rule.");
}
else
{
_conditions = new AndSpecification();
}
var actionNode =
CollectionUtils.SelectFirst(ruleNode.ChildNodes,
(XmlNode child) => child.Name.Equals("action"));
if (actionNode != null)
{
_actions = actionCompiler.Compile(actionNode as XmlElement, ruleType, true);
}
else if (!IsExempt)
{
throw new ApplicationException("No action element defined for the rule.");
}
else
{
_actions = new ActionSet <TActionContext>(new List <IActionItem <TActionContext> >());
}
}
public bool Apply(XmlElement ruleNode, object item)
{
XmlElement conditionNode = ruleNode.SelectSingleNode("condition") as XmlElement;
if (conditionNode != null)
{
ISpecification specification = _compiler.Compile(conditionNode, true);
if (specification != null)
{
if (specification.Test(item).Success)
{
XmlElement actionsNode = ruleNode.SelectSingleNode("actions") as XmlElement;
if (actionsNode != null)
{
foreach (XmlNode actionNode in actionsNode.ChildNodes)
{
if (actionNode is XmlElement)
{
if (_actions.ContainsKey(actionNode.Name))
{
IXmlAction action = _actions[actionNode.Name];
if (action != null)
{
action.Apply((XmlElement)actionNode, item);
}
}
}
}
}
return(true);
}
}
}
return(false);
}
