Exemple #1
0
        private static RuleInfo ReadRule(SqlDataReader reader)
        {
            try
            {
                IMetadataManager  iMetadataManager = new MetadataManager.Contracts.MetadataManager();
                List <SourceInfo> lstSource        = reader.IsDBNull(4) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <List <SourceInfo> >(reader.GetString(4));
                List <TargetInfo> lstTarget        = reader.IsDBNull(5) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <List <TargetInfo> >(reader.GetString(5));
                RuleTypeEnum      ruleType         = reader.IsDBNull(3) ? RuleTypeEnum.Visibility : (RuleTypeEnum)reader.GetInt32(3);
                string            strRuleTypeName  = ruleType.ToString();
                string            entityId         = reader.IsDBNull(8) ? string.Empty : reader.GetString(8);
                string            entityName       = (entityId == null) ? string.Empty : iMetadataManager.GetEntityNameByEntityContext(entityId);

                var rule = new RuleInfo
                {
                    TenantId     = reader.IsDBNull(0) ? Guid.Empty : reader.GetGuid(0),
                    Id           = reader.IsDBNull(1) ? Guid.Empty : reader.GetGuid(1),
                    RuleName     = reader.IsDBNull(2) ? string.Empty : reader.GetString(2),
                    RuleType     = reader.IsDBNull(3) ? RuleTypeEnum.Visibility : (RuleTypeEnum)reader.GetInt32(3),
                    Source       = reader.IsDBNull(4) ? string.Empty : reader.GetString(4),
                    Target       = reader.IsDBNull(5) ? string.Empty : reader.GetString(5),
                    SourceList   = lstSource,
                    TargetList   = lstTarget,
                    UpdatedBy    = reader.IsDBNull(7) ? Guid.Empty : reader.GetGuid(7),
                    RuleTypeName = strRuleTypeName,
                    EntityId     = entityId,
                    EntityName   = entityName
                };
                return(rule);
            }
            catch (System.Exception ex)
            {
                throw ex.InnerException;
            }
        }
Exemple #2
0
        private RuleInfo GenerateRule(
            string displayName,
            int value,
            int scoreId,
            string ruleCondition,
            RuleTypeEnum ruleType,
            string ruleParameter  = null,
            bool belongsToPersona = true)
        {
            var codeName = ValidationHelper.GetCodeName(displayName, 100);
            var ruleInfo = RuleInfoProvider.GetRules().WithCodeName(codeName).FirstOrDefault();

            if (ruleInfo != null)
            {
                return(ruleInfo);
            }

            var ruleObj = new RuleInfo
            {
                RuleScoreID          = scoreId,
                RuleDisplayName      = displayName,
                RuleName             = codeName,
                RuleValue            = value,
                RuleType             = ruleType,
                RuleParameter        = ruleParameter,
                RuleCondition        = ruleCondition,
                RuleBelongsToPersona = belongsToPersona
            };

            RuleInfoProvider.SetRuleInfo(ruleObj);
            return(ruleObj);
        }
Exemple #3
0
        public Rule AddRule(RuleTypeEnum ruleType)
        {
            Rule rule = SchemaFactory.CreateRule(ruleType);

            this.Add(rule);
            return(rule);
        }
Exemple #4
0
        public Rule AddRule(RuleTypeEnum ruleType, string value)
        {
            Rule rule = SchemaFactory.CreateRule(ruleType);

            rule.Value = value;
            this.Add(rule);
            return(rule);
        }
Exemple #5
0
        public Rule AddRule(RuleTypeEnum ruleType, string value, string exProperty)
        {
            Rule rule = SchemaFactory.CreateRule(ruleType);

            rule.Value      = value;
            rule.ExProperty = exProperty;
            this.Add(rule);
            return(rule);
        }
Exemple #6
0
    /// <summary>
    /// Initializes controls (and preselects rule type).
    /// </summary>
    private void InitControls()
    {
        if (!RequestHelper.IsPostBack())
        {
            radType.Items.Add(new ListItem(GetString("om.score.attribute"), ((int)RuleTypeEnum.Attribute).ToString()));
            radType.Items.Add(new ListItem(GetString("om.score.activity"), ((int)RuleTypeEnum.Activity).ToString()));

            RuleTypeEnum rt = RuleTypeEnum.Attribute;
            if (EditForm.EditedObject != null)
            {
                // Initialize attribute type from edited object (if any)
                RuleInfo ri = (RuleInfo)EditForm.EditedObject;
                rt = ri.RuleType;

                // Init rule validity controls
                if (EditForm.Data["RuleValidity"] != null)
                {
                    string strValidity = ValidationHelper.GetString(EditForm.Data["RuleValidity"], null);
                    validity.Validity = (ValidityEnum)Enum.Parse(typeof(ValidityEnum), strValidity);
                    if (validity.Validity == ValidityEnum.Until)
                    {
                        validity.ValidUntil = ValidationHelper.GetDateTime(EditForm.Data["RuleValidUntil"], DateTimeHelper.ZERO_TIME);
                    }
                    else
                    {
                        validity.ValidFor = ValidationHelper.GetInteger(EditForm.Data["RuleValidFor"], 0);
                    }
                }
            }

            radType.Items[0].Selected = radType.Items[1].Selected = false;
            for (int i = radType.Items.Count - 1; i >= 0; i--)
            {
                bool selected = ValidationHelper.GetInteger(radType.Items[i].Value, 0) == (int)rt;
                radType.Items[i].Selected = selected;
                if (selected)
                {
                    radType.SelectedValue = Convert.ToString((int)rt);
                }
            }
        }

        txtValue.MaxLength  = ValidationHelper.MAX_INT_LENGTH;
        txtValue.FilterType = AjaxControlToolkit.FilterTypes.Numbers | AjaxControlToolkit.FilterTypes.Custom;
        txtValue.ValidChars = "-";

        txtMaxPoints.MaxLength  = ValidationHelper.MAX_INT_LENGTH;
        txtMaxPoints.FilterType = AjaxControlToolkit.FilterTypes.Numbers | AjaxControlToolkit.FilterTypes.Custom;
        txtMaxPoints.ValidChars = "-";
        txtMaxPoints.Enabled    = ValidationHelper.GetBoolean(chkRecurring.Value, false);

        drpAttribute.SelectedIndexChanged += new EventHandler(drpAttribute_SelectedIndexChanged);
        pnlGeneral.GroupingText            = GetString("general.general");
        pnlActivity.GroupingText           = GetString("om.score.activityvalidity");
        pnlSettings.GroupingText           = GetString("om.score.rulesettings");
    }
Exemple #7
0
 public int Test3(RuleTypeEnum ruleTypeEnum)
 {
     if (ruleTypeEnum != RuleTypeEnum.Initial)
     {
         return((int)RuleTypeEnum.Initial);
     }
     else
     {
         return((int)RuleTypeEnum.ToChooseProcess);
     }
 }
 private RuleInfo GenerateBaseRule(RuleTypeEnum ruleType, int siteId)
 {
     return(new RuleInfo
     {
         RuleType = ruleType,
         RuleSiteID = siteId,
         RuleValue = StaticRandom.Next(10, 1000),
         RuleIsRecurring = false,
         RuleName = "Rule-" + Guid.NewGuid()
     });
 }
Exemple #9
0
 public static RuleTypeEnum GetEnum(string name)
 {
     string[] types = Enum.GetNames(typeof(RuleTypeEnum));
     foreach (var type in types)
     {
         RuleTypeEnum ruleTypeEnum = (RuleTypeEnum)Enum.Parse(typeof(RuleTypeEnum), type);
         if (name.Equals(ToType(ruleTypeEnum)))
         {
             return(ruleTypeEnum);
         }
     }
     return(RuleTypeEnum.UNKNOWN);
 }
Exemple #10
0
 public Rule AddIntervalRule(RuleTypeEnum ruleType, string ruleValue, bool isInclude)
 {
     Rule rule = SchemaFactory.CreateRule(ruleType);
     rule.Value = ruleValue;
     if (isInclude)
     {
         rule.ExProperty = "include";
     }
     else
     {
         rule.ExProperty = "not include";
     }
     this.Add(rule);
     return rule;
 }
Exemple #11
0
        public Rule AddIntervalRule(RuleTypeEnum ruleType, string ruleValue, bool isInclude)
        {
            Rule rule = SchemaFactory.CreateRule(ruleType);

            rule.Value = ruleValue;
            if (isInclude)
            {
                rule.ExProperty = "include";
            }
            else
            {
                rule.ExProperty = "not include";
            }
            this.Add(rule);
            return(rule);
        }
Exemple #12
0
 public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
 {
     System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
     this.RuleType                      = ((RuleTypeEnum)(binaryReader.ReadInt16()));
     this.Squad                         = binaryReader.ReadShortBlockIndex1();
     this.SquadGroup                    = binaryReader.ReadShortBlockIndex1();
     this.A                             = binaryReader.ReadInt16();
     this.X                             = binaryReader.ReadSingle();
     this.TriggerVolume                 = binaryReader.ReadShortBlockIndex1();
     this.fieldpad                      = binaryReader.ReadBytes(2);
     this.ExitConditionScript           = binaryReader.ReadString32();
     this.FieldShortInteger             = binaryReader.ReadInt16();
     this.fieldpad0                     = binaryReader.ReadBytes(2);
     this.OrderCompletionConditionFlags = ((Flags)(binaryReader.ReadInt32()));
     return(pointerQueue);
 }
        private RuleInfo GenerateRule(int siteId)
        {
            var          random   = StaticRandom.NextDouble();
            RuleTypeEnum ruleType = random < 0.166 ?
                                    RuleTypeEnum.Attribute : random < 0.333 ?
                                    RuleTypeEnum.Macro : RuleTypeEnum.Activity;

            switch (ruleType)
            {
            case RuleTypeEnum.Activity:
                return(GenerateActivityRule(siteId));

            case RuleTypeEnum.Attribute:
                return(GenerateAttributeRule(siteId));

            case RuleTypeEnum.Macro:
                return(GenerateMacroRule(siteId));
            }

            return(null);
        }
Exemple #14
0
 public static Rule CreateRule(RuleTypeEnum ruleType)
 {
     Rule rule = null;
     switch (ruleType)
     {
         case RuleTypeEnum.MAX_LENGTH_RULE:
             rule = new MaxLengthRule();
             break;
         case RuleTypeEnum.MIN_LENGTH_RULE:
             rule = new MinLengthRule();
             break;
         case RuleTypeEnum.MAX_VALUE_RULE:
             rule = new MaxValueRule();
             break;
         case RuleTypeEnum.MIN_VALUE_RULE:
             rule = new MinValueRule();
             break;
         case RuleTypeEnum.MAX_INPUT_NUM_RULE:
             rule = new MaxInputNumRule();
             break;
         case RuleTypeEnum.MIN_INPUT_NUM_RULE:
             rule = new MinInputNumRule();
             break;
         case RuleTypeEnum.VALUE_TYPE_RULE:
             rule = new ValueTypeRule();
             break;
         case RuleTypeEnum.REQUIRED_RULE:
             rule = new RequiredRule();
             break;
         case RuleTypeEnum.DISABLE_RULE:
             rule = new DisableRule();
             break;
         case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE:
             rule = new MaxDecimalDigitsRule();
             break;
         case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE:
             rule = new MinDecimalDigitsRule();
             break;
         case RuleTypeEnum.REGEX_RULE:
             rule = new RegexRule();
             break;
         case RuleTypeEnum.SET_RULE:
             rule = new SetRule();
             break;
         case RuleTypeEnum.TIP_RULE:
             rule = new TipRule();
             break;
         case RuleTypeEnum.DEV_TIP_RULE:
             rule = new DevTipRule();
             break;
         case RuleTypeEnum.READ_ONLY_RULE:
             rule = new ReadOnlyRule();
             break;
         case RuleTypeEnum.MAX_TARGET_SIZE_RULE:
             rule = new MaxTargetSizeRule();
             break;
         case RuleTypeEnum.MIN_TARGET_SIZE_RULE:
             rule = new MinTargetSizeRule();
             break;
         case RuleTypeEnum.MAX_IMAGE_SIZE_RULE:
             rule = new MaxImageSizeRule();
             break;
         case RuleTypeEnum.MIN_IMAGE_SIZE_RULE:
             rule = new MinImageSizeRule();
             break;
     }
     return rule;
 }
Exemple #15
0
        public static string ToType(RuleTypeEnum ruleTypeEnum)
        {
            switch (ruleTypeEnum)
            {
            case RuleTypeEnum.MAX_LENGTH_RULE:
                return("maxLengthRule");

            case RuleTypeEnum.MIN_LENGTH_RULE:
                return("minLengthRule");

            case RuleTypeEnum.MAX_VALUE_RULE:
                return("maxValueRule");

            case RuleTypeEnum.MIN_VALUE_RULE:
                return("minValueRule");

            case RuleTypeEnum.MAX_INPUT_NUM_RULE:
                return("maxInputNumRule");

            case RuleTypeEnum.MIN_INPUT_NUM_RULE:
                return("minInputNumRule");

            case RuleTypeEnum.VALUE_TYPE_RULE:
                return("valueTypeRule");

            case RuleTypeEnum.REQUIRED_RULE:
                return("requiredRule");

            case RuleTypeEnum.DISABLE_RULE:
                return("disableRule");

            case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE:
                return("maxDecimalDigitsRule");

            case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE:
                return("minDecimalDigitsRule");

            case RuleTypeEnum.REGEX_RULE:
                return("regexRule");

            case RuleTypeEnum.SET_RULE:
                return("setRule");

            case RuleTypeEnum.TIP_RULE:
                return("tipRule");

            case RuleTypeEnum.DEV_TIP_RULE:
                return("devTipRule");

            case RuleTypeEnum.READ_ONLY_RULE:
                return("readOnlyRule");

            case RuleTypeEnum.MAX_TARGET_SIZE_RULE:
                return("maxTargetSizeRule");

            case RuleTypeEnum.MIN_TARGET_SIZE_RULE:
                return("minTargetSizeRule");

            case RuleTypeEnum.MAX_IMAGE_SIZE_RULE:
                return("maxImageSizeRule");

            case RuleTypeEnum.MIN_IMAGE_SIZE_RULE:
                return("minImageSizeRule");

            default:
                return("");
            }
        }
Exemple #16
0
        public static Rule CreateRule(RuleTypeEnum ruleType)
        {
            Rule rule = null;

            switch (ruleType)
            {
            case RuleTypeEnum.MAX_LENGTH_RULE:
                rule = new MaxLengthRule();
                break;

            case RuleTypeEnum.MIN_LENGTH_RULE:
                rule = new MinLengthRule();
                break;

            case RuleTypeEnum.MAX_VALUE_RULE:
                rule = new MaxValueRule();
                break;

            case RuleTypeEnum.MIN_VALUE_RULE:
                rule = new MinValueRule();
                break;

            case RuleTypeEnum.MAX_INPUT_NUM_RULE:
                rule = new MaxInputNumRule();
                break;

            case RuleTypeEnum.MIN_INPUT_NUM_RULE:
                rule = new MinInputNumRule();
                break;

            case RuleTypeEnum.VALUE_TYPE_RULE:
                rule = new ValueTypeRule();
                break;

            case RuleTypeEnum.REQUIRED_RULE:
                rule = new RequiredRule();
                break;

            case RuleTypeEnum.DISABLE_RULE:
                rule = new DisableRule();
                break;

            case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE:
                rule = new MaxDecimalDigitsRule();
                break;

            case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE:
                rule = new MinDecimalDigitsRule();
                break;

            case RuleTypeEnum.REGEX_RULE:
                rule = new RegexRule();
                break;

            case RuleTypeEnum.SET_RULE:
                rule = new SetRule();
                break;

            case RuleTypeEnum.TIP_RULE:
                rule = new TipRule();
                break;

            case RuleTypeEnum.DEV_TIP_RULE:
                rule = new DevTipRule();
                break;

            case RuleTypeEnum.READ_ONLY_RULE:
                rule = new ReadOnlyRule();
                break;

            case RuleTypeEnum.MAX_TARGET_SIZE_RULE:
                rule = new MaxTargetSizeRule();
                break;

            case RuleTypeEnum.MIN_TARGET_SIZE_RULE:
                rule = new MinTargetSizeRule();
                break;

            case RuleTypeEnum.MAX_IMAGE_SIZE_RULE:
                rule = new MaxImageSizeRule();
                break;

            case RuleTypeEnum.MIN_IMAGE_SIZE_RULE:
                rule = new MinImageSizeRule();
                break;
            }
            return(rule);
        }
 private RuleInfo GenerateBaseRule(RuleTypeEnum ruleType, int siteId)
 {
     return new RuleInfo
     {
         RuleType = ruleType,
         RuleSiteID = siteId,
         RuleValue = StaticRandom.Next(10, 1000),
         RuleIsRecurring = false,
         RuleName = "Rule-" + Guid.NewGuid()
     };
 }
    private static RuleInfo GenerateBasicScoringRule(ScoreInfo score, string displayName, int ruleValue, RuleTypeEnum ruleType, string ruleCondition, string ruleParameter = null)
    {
        var rule = new RuleInfo
        {
            RuleScoreID = score.ScoreID,
            RuleDisplayName = displayName,
            RuleName = "Rule-" + Guid.NewGuid(),
            RuleValue = ruleValue,
            RuleType = ruleType,
            RuleParameter = ruleParameter,
            RuleCondition = ruleCondition,
            RuleSiteID = score.ScoreSiteID,
            RuleBelongsToPersona = false,
            RuleIsRecurring = false
        };
        rule.Insert();

        return rule;
    }
Exemple #19
0
        //public void AddRule(string ruleName, Type entityType, string condition, LuaFunction action)
        //{
        //	AddRuleData(ruleName, entityType, condition, action, RuleTypeEnum.Lambda);
        //}

        private void AddRuleData(string ruleName, Type entityType, object condition, object action, RuleTypeEnum type)
        {
            var ruleData = new RuleData()
            {
                IsEnabled     = true,
                EntityType    = entityType,
                RuleCondition = condition,
                RuleName      = ruleName,
                RuleType      = type
            };

            //if (action is LuaFunction)
            //{
            //	ruleData.Action = entity => { ((LuaFunction)action).Call(entity); };
            //}

            if (action is Action <INeonIoTEntity> action1)
            {
                ruleData.Action = action1;
            }

            _logger.LogInformation($"Adding rule {ruleName} for entity {entityType.Name} [Type: {type}]");

            Rules.Add(ruleData);

            AddRuleExecution(ruleData);
        }
Exemple #20
0
 public Rule AddRule(RuleTypeEnum ruleType, string value)
 {
     Rule rule = SchemaFactory.CreateRule(ruleType);
     rule.Value = value;
     this.Add(rule);
     return rule;
 }
Exemple #21
0
 public static Rule CreateRule(RuleTypeEnum ruleType)
 {
     return(RuleTypeEnumHelper.CreateRule(ruleType));
 }
Exemple #22
0
 public static Rule CreateRule(RuleTypeEnum ruleType)
 {
     return RuleTypeEnumHelper.CreateRule(ruleType);
 }
Exemple #23
0
 public Rule AddRule(RuleTypeEnum ruleType, string value, string exProperty)
 {
     Rule rule = SchemaFactory.CreateRule(ruleType);
     rule.Value = value;
     rule.ExProperty = exProperty;
     this.Add(rule);
     return rule;
 }
Exemple #24
0
        /**
         * xml Element to Rule
         * @param ruleEle
         * @param fieldId
         * @return
         * @throws TopSchemaException
         */
        private static Rule ElementToRule(XmlElement ruleEle, string fieldId)
        {
            if (ruleEle == null)
            {
                return(null);
            }
            String ruleName = XmlUtils.GetAttributeValue(ruleEle, "name");

            if (StringUtil.IsEmpty(ruleName))
            {
                throw new TopSchemaException(TopSchemaErrorCodeEnum.ERROR_CODE_31001, fieldId);
            }
            String ruleValue = XmlUtils.GetAttributeValue(ruleEle, "value");

            if (StringUtil.IsEmpty(ruleValue))
            {
                throw new TopSchemaException(TopSchemaErrorCodeEnum.ERROR_CODE_31002, fieldId);
            }

            Rule         rule     = null;
            RuleTypeEnum ruleEnum = RuleTypeEnumHelper.GetEnum(ruleName);

            if (ruleEnum != RuleTypeEnum.UNKNOWN)
            {
                rule = SchemaFactory.CreateRule(ruleEnum);
            }
            else
            {
                rule = SchemaFactory.CreateCustomRule(ruleName, ruleValue);
            }

            if (ruleName.Equals(RuleTypeEnumHelper.ToType(RuleTypeEnum.TIP_RULE)) && !StringUtil.IsEmpty(ruleValue))
            {
                String url = XmlUtils.GetAttributeValue(ruleEle, "url");
                ((TipRule)rule).Url = url;
            }
            if (ruleName.Equals(RuleTypeEnumHelper.ToType(RuleTypeEnum.DEV_TIP_RULE)) && !StringUtil.IsEmpty(ruleValue))
            {
                String url = XmlUtils.GetAttributeValue(ruleEle, "url");
                ((DevTipRule)rule).Url = url;
            }

            String unit = XmlUtils.GetAttributeValue(ruleEle, "unit");

            if (ruleName.Equals(RuleTypeEnumHelper.ToType(RuleTypeEnum.MAX_TARGET_SIZE_RULE)) &&
                !StringUtil.IsEmpty(ruleValue))
            {
                MaxTargetSizeRule mtsRule = (MaxTargetSizeRule)rule;
                mtsRule.Unit = unit;
            }
            else if (ruleName.Equals(RuleTypeEnumHelper.ToType(RuleTypeEnum.MIN_TARGET_SIZE_RULE)) &&
                     !StringUtil.IsEmpty(ruleValue))
            {
                MinTargetSizeRule misRule = (MinTargetSizeRule)rule;
                misRule.Unit = unit;
            }

            String exProperty = XmlUtils.GetAttributeValue(ruleEle, "exProperty");

            if (!StringUtil.IsEmpty(exProperty))
            {
                rule.ExProperty = exProperty;
            }
            rule.Value = ruleValue;
            XmlElement  dependGroupEle = XmlUtils.GetChildElement(ruleEle, "depend-group");
            DependGroup dependGroup    = ElementToDependGroup(dependGroupEle, fieldId);

            rule.DependGroup = dependGroup;
            return(rule);
        }
Exemple #25
0
 public Rule AddRule(RuleTypeEnum ruleType)
 {
     Rule rule = SchemaFactory.CreateRule(ruleType);
     this.Add(rule);
     return rule;
 }
Exemple #26
0
 public static string ToType(RuleTypeEnum ruleTypeEnum)
 {
     switch (ruleTypeEnum)
     {
         case RuleTypeEnum.MAX_LENGTH_RULE:
             return "maxLengthRule";
         case RuleTypeEnum.MIN_LENGTH_RULE:
             return "minLengthRule";
         case RuleTypeEnum.MAX_VALUE_RULE:
             return "maxValueRule";
         case RuleTypeEnum.MIN_VALUE_RULE:
             return "minValueRule";
         case RuleTypeEnum.MAX_INPUT_NUM_RULE:
             return "maxInputNumRule";
         case RuleTypeEnum.MIN_INPUT_NUM_RULE:
             return "minInputNumRule";
         case RuleTypeEnum.VALUE_TYPE_RULE:
             return "valueTypeRule";
         case RuleTypeEnum.REQUIRED_RULE:
             return "requiredRule";
         case RuleTypeEnum.DISABLE_RULE:
             return "disableRule";
         case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE:
             return "maxDecimalDigitsRule";
         case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE:
             return "minDecimalDigitsRule";
         case RuleTypeEnum.REGEX_RULE:
             return "regexRule";
         case RuleTypeEnum.SET_RULE:
             return "setRule";
         case RuleTypeEnum.TIP_RULE:
             return "tipRule";
         case RuleTypeEnum.DEV_TIP_RULE:
             return "devTipRule";
         case RuleTypeEnum.READ_ONLY_RULE:
             return "readOnlyRule";
         case RuleTypeEnum.MAX_TARGET_SIZE_RULE:
             return "maxTargetSizeRule";
         case RuleTypeEnum.MIN_TARGET_SIZE_RULE:
             return "minTargetSizeRule";
         case RuleTypeEnum.MAX_IMAGE_SIZE_RULE:
             return "maxImageSizeRule";
         case RuleTypeEnum.MIN_IMAGE_SIZE_RULE:
             return "minImageSizeRule";
         default:
             return "";
     }
 }