A RuleSet instance contains a collection of validation rules that can be tested against a XmlDocument in a single operation.
Inheritance: Validator
Exemplo n.º 1
0
        /// <summary>
        /// Parse the <b>RuleSet</b> definitions in the configuration file
        /// indicated by the URI.
        /// </summary>
        /// <param name="uri">The URI of the business rule configuration file.</param>
        private static void ParseRuleSets(string uri)
        {
            RuleSet         ruleSet     = null;
            XmlReader		reader		= XmlReader.Create (uri);

            while (reader.Read ()) {
                switch (reader.NodeType) {
                case XmlNodeType.Element:
                    {
                        if (reader.LocalName.Equals ("forceLoad")) {
                            string platform = reader ["platform"];
                            string implementation = reader ["class"];

                            if (platform.Equals (".Net")) {
                                try {
                                    Type		type = Type.GetType (implementation);

                                    if (type != null) {
                                        // Access each member to ensure it has a chance to initialise
                                        MemberInfo [] members = type.GetMembers ();
                                        if (members != null) {
                                            foreach (MemberInfo member in members) {
                                                if (member.MemberType == MemberTypes.Field) {
                                                    type.InvokeMember (member.Name, BindingFlags.GetField, null, null, null);
                                                }
                                            }
                                        }
                                        break;
                                    }
                                    else
                                        logger.Error ("Could not find load rule class '" + implementation + "'");
                                }
                                catch (Exception error) {
                                    logger.Error ("Could not force load rule class '" + implementation + "'", error);
                                }
                            }
                        } else	if (reader.LocalName.Equals ("ruleSet")) {
                            string		name	= reader ["name"];

                            ruleSet = new RuleSet (name);
                        }
                        else if (reader.LocalName.Equals ("addRule")) {
                            string		name	= reader ["name"];
                            Rule        rule    = Rule.ForName (name);

                            if (rule != null) {
                                if (ruleSet != null)
                                    ruleSet.Add (rule);
                                else
                                    logger.Error ("Syntax error in rule file - addRule outside of RuleSet");
                            }
                            else
                                logger.Error ("Reference to undefined rule '" + name + "' in addRule");
                        }
                        else if (reader.LocalName.Equals ("removeRule")) {
                            string name = reader ["name"];
                            Rule rule = Rule.ForName (name);

                            if (rule != null) {
                                if (ruleSet != null)
                                    ruleSet.Remove (rule);
                                else
                                    logger.Error ("Syntax error in rule file - removeRule outside of RuleSet");
                            }
                            else
                                logger.Error ("Reference to undefined rule '" + name + "' in addRule");
                        }
                        else if (reader.LocalName.Equals ("addRuleSet")) {
                            string name = reader ["name"];
                            RuleSet rules = ForName (name);

                            if (rules != null) {
                                if (ruleSet != null) {
                                    if (rules != ruleSet)
                                        ruleSet.Add (rules);
                                    else
                                        logger.Error ("Attempt to recursively define ruleset '" + name + "'");
                                }
                                else
                                    logger.Error ("Syntax error in rule file - addRuleSet outside of RuleSet");
                            }
                            else
                                logger.Error ("Reference to undefined rule '" + name + "' in addRule");
                        }
                        break;
                    }
                case XmlNodeType.EndElement:
                    {
                        if (reader.LocalName.Equals ("ruleSet"))
                            ruleSet = null;

                        break;
                    }
                }
            }
            reader.Close ();
        }
Exemplo n.º 2
0
 /// <summary>
 /// Adds the <see cref="Rule"/> instances that comprise another
 /// <B>RuleSet</B> to this one.
 /// </summary>
 /// <param name="ruleSet">The <B>RuleSet</B> to be added.</param>
 public void Add(RuleSet ruleSet)
 {
     foreach (Rule rule in ruleSet.rules.Values)
         rules.Add (rule.Name, rule);
 }
Exemplo n.º 3
0
        /// <summary>
        /// Attempts to parse an XML document from a <see cref="Stream"/> and then
        /// pass it though the specified validation rule set.
        /// </summary>
        /// <param name="schemaOnly">Indicates only schema based documents to be processed.</param>
        /// <param name="stream">The <see cref="Stream"/> to process XML from.</param>
        /// <param name="rules">The <see cref="RuleSet"/> used for validation.</param>
        /// <param name="eventHandler">A <see cref="ValidationEventHandler"/> used to report parser errors.</param>
        /// <param name="errorHandler">An <see cref="ValidationErrorHandler"/> used to report validation errors.</param>
        /// <returns></returns>
        public static bool ParseAndValidate(bool schemaOnly, Stream stream, RuleSet rules, ValidationEventHandler eventHandler, ValidationErrorHandler errorHandler)
        {
            XmlDocument		document = Parse (schemaOnly, stream, eventHandler);

            return ((document != null) ? Validate (document, errorHandler) : false);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Uses the indicated <see cref="RuleSet"/> to perform a semantic validation of
 /// the <see cref="XmlDocument"/> and reports errors (if any). 
 /// </summary>
 /// <param name="document">The <see cref="XmlDocument"/> to be validated.</param>
 /// <param name="rules">The <see cref="RuleSet"/> to use.</param>
 /// <param name="errorHandler">The <see cref="ValidationErrorHandler"/> used to report issues.</param>
 /// <returns><b>true</b> if the <see cref="XmlDocument"/> successfully passed all
 /// applicable rules, <b>false</b> if one or more rules failed.</returns>
 public static bool Validate(XmlDocument document, RuleSet rules, ValidationErrorHandler errorHandler)
 {
     return (rules.Validate (document, errorHandler));
 }
Exemplo n.º 5
0
        /// <summary>
        /// Attempts to parse an XML document from a string and then pass it through
        /// the specified validation rule set.
        /// </summary>
        /// <param name="xml">The XML string to be parsed.</param>
        /// <param name="rules">The <see cref="RuleSet"/> used for validation.</param>
        /// <param name="eventHandler">A <see cref="ValidationEventHandler"/> used to report parser errors.</param>
        /// <param name="errorHandler">An <see cref="ValidationErrorHandler"/> used to report validation errors.</param>
        /// <returns></returns>
        public static bool ParseAndValidate(string xml, RuleSet rules, ValidationEventHandler eventHandler, ValidationErrorHandler errorHandler)
        {
            XmlDocument		document = Parse (xml, eventHandler);

            return ((document != null) ? Validate (document, rules, errorHandler) : false);
        }