예제 #1
0
        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];
                        }
                    }
                }
            }
        }
예제 #2
0
        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);
            }
        }
예제 #3
0
        ///
        /// <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));
        }
예제 #4
0
        public static void AddNewNethereumRule(this WonkaBizRuleSet poRuleSet,
                                               WonkaRefEnvironment poRefEnv,
                                               string psAddRuleDesc,
                                               string psAddRuleTargetAttr,
                                               string psAddRuleTypeNum,
                                               string psAddRuleEthAddress,
                                               string psAddRuleValue1,
                                               string psAddRuleValue2)
        {
            if (String.IsNullOrEmpty(psAddRuleTypeNum))
            {
                psAddRuleTypeNum = "1";
            }

            int nRuleTypeNum = Int32.Parse(psAddRuleTypeNum);

            WonkaBizRule NewRule = null;

            WonkaRefAttr targetAttr = poRefEnv.GetAttributeByAttrName(psAddRuleTargetAttr);

            if ((nRuleTypeNum == 1) | (nRuleTypeNum == 2) || (nRuleTypeNum == 5))
            {
                if (targetAttr.IsNumeric || targetAttr.IsDecimal)
                {
                    throw new DataException("ERROR!  Cannot perform offered Nethereum rules on a numeric value.");
                }

                if (String.IsNullOrEmpty(psAddRuleEthAddress))
                {
                    psAddRuleEthAddress = BlazorAppNethereumExtensions.CONST_ETH_FNDTN_EOA_ADDRESS;
                }
            }

            if (nRuleTypeNum == 1)
            {
                if (targetAttr.AttrName != "AccountStatus")
                {
                    throw new Exception("ERROR!  Cannot add BALANCE_WITHIN_RANGE rule with any attribute target other than AccountStatus.");
                }

                WonkaBizSource DummySource =
                    new WonkaBizSource("EF_EOA", psAddRuleEthAddress, "", "", "", "", "", null);

                CustomOperatorRule CustomOpRule =
                    new CustomOperatorRule(mnRuleCounter++,
                                           TARGET_RECORD.TRID_NEW_RECORD,
                                           targetAttr.AttrId,
                                           "BALANCE_WITHIN_RANGE",
                                           BlazorAppNethereumExtensions.CheckBalanceIsWithinRange,
                                           DummySource);

                CustomOpRule.AddDomainValue(psAddRuleEthAddress, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(psAddRuleValue1, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(psAddRuleValue2, true, TARGET_RECORD.TRID_NONE);

                NewRule = CustomOpRule;
            }
            else if (nRuleTypeNum == 2)
            {
                if (targetAttr.AttrName != "AuditReviewFlag")
                {
                    throw new Exception("ERROR!  Cannot add ANY_EVENTS_IN_BLOCK_RANGE rule with any attribute target other than AuditReviewFlag.");
                }

                WonkaBizSource DummySource =
                    new WonkaBizSource("ERC20", psAddRuleEthAddress, "", "", "", "", "", null);

                CustomOperatorRule CustomOpRule =
                    new CustomOperatorRule(mnRuleCounter++,
                                           TARGET_RECORD.TRID_NEW_RECORD,
                                           targetAttr.AttrId,
                                           "ANY_EVENTS_IN_BLOCK_RANGE",
                                           BlazorAppNethereumExtensions.AnyEventsInBlockRange,
                                           DummySource);

                if (String.IsNullOrEmpty(psAddRuleValue1))
                {
                    psAddRuleValue1 = "8450678";
                }

                if (String.IsNullOrEmpty(psAddRuleValue2))
                {
                    psAddRuleValue2 = "8450698";
                }

                CustomOpRule.AddDomainValue(psAddRuleEthAddress, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(psAddRuleValue1, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(psAddRuleValue2, true, TARGET_RECORD.TRID_NONE);

                NewRule = CustomOpRule;
            }
            else if (nRuleTypeNum == 3)
            {
                if (!targetAttr.IsNumeric && !targetAttr.IsDecimal)
                {
                    throw new DataException("ERROR!  Cannot perform arithmetic limit on a non-numeric value.");
                }

                WonkaBizSource DummySource =
                    new WonkaBizSource("ERC20", psAddRuleEthAddress, "", "", "", "", "", null);

                CustomOperatorRule CustomOpRule =
                    new CustomOperatorRule(mnRuleCounter++,
                                           TARGET_RECORD.TRID_NEW_RECORD,
                                           targetAttr.AttrId,
                                           "GET_ERC20_BALANCE",
                                           BlazorAppNethereumExtensions.GetERC20Balance,
                                           DummySource);

                CustomOpRule.AddDomainValue(psAddRuleEthAddress, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(psAddRuleValue1, true, TARGET_RECORD.TRID_NONE);

                NewRule = CustomOpRule;
            }
            else if (nRuleTypeNum == 4)
            {
                if (!targetAttr.IsNumeric && !targetAttr.IsDecimal)
                {
                    throw new DataException("ERROR!  Cannot perform arithmetic limit on a non-numeric value.");
                }

                WonkaBizSource DummySource =
                    new WonkaBizSource("ContractName", psAddRuleEthAddress, "", "", "", "", "", null);

                CustomOperatorRule CustomOpRule =
                    new CustomOperatorRule(mnRuleCounter++,
                                           TARGET_RECORD.TRID_NEW_RECORD,
                                           targetAttr.AttrId,
                                           "CALL_SIMPLE_CONTRACT_METHOD",
                                           BlazorAppNethereumExtensions.GetContractSimpleMethodValue,
                                           DummySource);

                var sAltConfigIpfsUrl = psAddRuleValue1;
                var sFunctionName     = psAddRuleValue2;

                if (String.IsNullOrEmpty(sAltConfigIpfsUrl))
                {
                    sAltConfigIpfsUrl = BlazorAppNethereumExtensions.CONST_INFURA_IPFS_GATEWAY_URL + "/QmYDp4ocbF1AVSuY1zBhXa6P4c2oaPkHi2jaSE3HU6bQnQ";
                }

                using (var client = new System.Net.Http.HttpClient())
                {
                    var sConfigDataXml = client.GetStringAsync(sAltConfigIpfsUrl).Result;

                    var configData = ReadConfigXml(sConfigDataXml);

                    if (!String.IsNullOrEmpty(configData.HostUrl))
                    {
                        CustomOpRule.AddDomainValue(configData.HostUrl, true, TARGET_RECORD.TRID_NONE);
                    }
                    else
                    {
                        CustomOpRule.AddDomainValue(BlazorAppNethereumExtensions.CONST_TEST_INFURA_URL, true, TARGET_RECORD.TRID_NONE);
                    }

                    CustomOpRule.AddDomainValue(configData.ContractABI, true, TARGET_RECORD.TRID_NONE);

                    if (!String.IsNullOrEmpty(psAddRuleEthAddress))
                    {
                        CustomOpRule.AddDomainValue(psAddRuleEthAddress, true, TARGET_RECORD.TRID_NONE);
                    }
                    else
                    {
                        CustomOpRule.AddDomainValue(configData.ContractAddress, true, TARGET_RECORD.TRID_NONE);
                    }

                    CustomOpRule.AddDomainValue(sFunctionName, true, TARGET_RECORD.TRID_NONE);

                    NewRule = CustomOpRule;
                }
            }
            else if (nRuleTypeNum == 5)
            {
                if (targetAttr.AttrName != "AccountStatus")
                {
                    throw new Exception("ERROR!  Cannot add V rule with any attribute target other than AccountStatus.");
                }

                WonkaBizSource DummySource =
                    new WonkaBizSource("ContractName", psAddRuleEthAddress, "", "", "", "", "", null);

                CustomOperatorRule CustomOpRule =
                    new CustomOperatorRule(mnRuleCounter++,
                                           TARGET_RECORD.TRID_NEW_RECORD,
                                           targetAttr.AttrId,
                                           "VALIDATE_SIGNATURE",
                                           BlazorAppNethereumExtensions.DetermineStatusByValidatingSignature,
                                           DummySource);

                var sAttrTarget = psAddRuleValue1;
                var sSignature  = psAddRuleValue2;

                var TargetAttr = poRefEnv.GetAttributeByAttrName(sAttrTarget);
                if (TargetAttr == null)
                {
                    throw new Exception("ERROR!  Cannot add rule since attribute(" + sAttrTarget + ") does not exist!");
                }

                CustomOpRule.AddDomainValue(psAddRuleEthAddress, true, TARGET_RECORD.TRID_NONE);
                CustomOpRule.AddDomainValue(sAttrTarget, false, TARGET_RECORD.TRID_NEW_RECORD);
                CustomOpRule.AddDomainValue(sSignature, true, TARGET_RECORD.TRID_NONE);

                NewRule = CustomOpRule;
            }

            if (NewRule != null)
            {
                if (!String.IsNullOrEmpty(psAddRuleDesc))
                {
                    NewRule.DescRuleId = psAddRuleDesc;
                }

                poRuleSet.AddRule(NewRule);
            }
        }
예제 #5
0
        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);
            }
        }