Esempio n. 1
0
            private static RuleScope getRuleScope(SqlString objScope)
            {
                Debug.Assert(!objScope.IsNull);
                RuleScope fs = RuleScope.Unknown;

                if (objScope.IsNull)
                {
                    fs = RuleScope.Unknown;
                }
                else
                {
                    if (string.Compare(objScope.Value, Sql.Constants.RuleScopeAll, true) == 0)
                    {
                        fs = RuleScope.All;
                    }
                    else if (string.Compare(objScope.Value, Sql.Constants.RuleScopeSystem, true) == 0)
                    {
                        fs = RuleScope.System;
                    }
                    else if (string.Compare(objScope.Value, Sql.Constants.RuleScopeUser, true) == 0)
                    {
                        fs = RuleScope.User;
                    }
                    else
                    {
                        fs = RuleScope.Unknown;
                    }
                }

                return(fs);
            }
        public ActionResult AddRule(int ruleSetId, RuleScope scope, string ruleType)
        {
            var provider   = _ruleProvider(scope);
            var descriptor = provider.RuleDescriptors.FindDescriptor(ruleType);
            var op         = descriptor.Operators.First();

            var rule = new RuleEntity
            {
                RuleSetId = ruleSetId,
                RuleType  = ruleType,
                Operator  = op.Operator
            };

            if (op == RuleOperator.In || op == RuleOperator.NotIn)
            {
                // Avoid ArgumentException "The 'In' operator only supports non-null instances from types that implement 'ICollection<T>'."
                rule.Value = string.Empty;
            }

            _ruleStorage.InsertRule(rule);

            var expression = provider.VisitRule(rule);

            PrepareTemplateViewBag(ruleSetId);

            return(PartialView("_Rule", expression));
        }
        public ActionResult AddGroup(int ruleSetId, RuleScope scope)
        {
            var provider = _ruleProvider(scope);

            var group = new RuleSetEntity
            {
                IsActive   = true,
                IsSubGroup = true,
                Scope      = scope
            };

            _ruleStorage.InsertRuleSet(group);

            var groupRefRule = new RuleEntity
            {
                RuleSetId = ruleSetId,
                RuleType  = "Group",
                Operator  = RuleOperator.IsEqualTo,
                Value     = group.Id.ToString()
            };

            _ruleStorage.InsertRule(groupRefRule);

            var expression = provider.VisitRuleSet(group);

            expression.RefRuleId = groupRefRule.Id;

            return(PartialView("_RuleSet", expression));
        }
Esempio n. 4
0
        public static Type GetScopeType(this RuleScope scope)
        {
            if (scope.IsMultiple())
            {
                throw new InvalidOperationException("The provided RuleScope enum value has more than one flag set.");
            }

            switch (scope)
            {
            case RuleScope.Model: return(typeof(Model));

            case RuleScope.Table: return(typeof(Table));

            case RuleScope.Measure: return(typeof(Measure));

            case RuleScope.Hierarchy: return(typeof(Hierarchy));

            case RuleScope.Level: return(typeof(Level));

            case RuleScope.Relationship: return(typeof(SingleColumnRelationship));

            case RuleScope.Perspective: return(typeof(Perspective));

            case RuleScope.Culture: return(typeof(Culture));

            case RuleScope.Partition: return(typeof(Partition));

            case RuleScope.ProviderDataSource: return(typeof(ProviderDataSource));

            case RuleScope.StructuredDataSource: return(typeof(StructuredDataSource));

            case RuleScope.DataColumn: return(typeof(DataColumn));

            case RuleScope.CalculatedColumn: return(typeof(CalculatedColumn));

            case RuleScope.CalculatedTable: return(typeof(CalculatedTable));

            case RuleScope.CalculatedTableColumn: return(typeof(CalculatedTableColumn));

            case RuleScope.KPI: return(typeof(KPI));

            case RuleScope.Variation: return(typeof(Variation));

            case RuleScope.NamedExpression: return(typeof(NamedExpression));

            case RuleScope.ModelRole: return(typeof(ModelRole));

            case RuleScope.CalculationGroup: return(typeof(CalculationGroupTable));

            //case RuleScope.CalculationGroupAttribute: return typeof(CalculationGroupAttribute);
            case RuleScope.CalculationItem: return(typeof(CalculationItem));

            case RuleScope.TablePermission: return(typeof(TablePermission));

            case RuleScope.ModelRoleMember: return(typeof(ModelRoleMember));

            default:
                throw new InvalidOperationException("Unknown scope type");
            }
        }
Esempio n. 5
0
        public FilterObject(RuleObjectType type, RuleScope scope, string matchString)
        {
            m_objectScope           = scope;
            m_objectType            = type;
            m_objectMatchString     = matchString;
            m_objectMatchStringList = new List <string>();
            m_objectMatchStringList.Add(matchString);

            switch (type)
            {
            case RuleObjectType.Database:
            case RuleObjectType.Table:
            case RuleObjectType.StoredProcedure:
            case RuleObjectType.View:
            case RuleObjectType.Function:
            case RuleObjectType.ExtendedStoredProcedure:
                m_isChecked = true;
                break;

            default:
                m_isChecked = true;
                break;
            }

            InitializeAndUpdate();
        }
Esempio n. 6
0
        private void CompileQueries(Model model)
        {
            _queries     = new List <IQueryable>();
            ErrorMessage = null;

            if (CompatibilityLevel > model.Database.CompatibilityLevel)
            {
                invalidCompatibilityLevel = true;
                IsValid = false;
                return;
            }

            try
            {
                foreach (var scope in Scope.Enumerate())
                {
                    errorScope = scope;
                    var collection = Analyzer.GetCollection(model, scope);
                    _queries.Add(CompileQuery(collection));
                }
                IsValid = true;
            }
            catch (Exception ex)
            {
                IsValid      = false;
                ErrorMessage = ex.Message;
            }
        }
Esempio n. 7
0
        public ActionResult AddRule(int ruleSetId, RuleScope scope, string ruleType)
        {
            var provider   = _ruleProvider(scope);
            var descriptor = provider.RuleDescriptors.FindDescriptor(ruleType);
            var op         = descriptor.Operators.First();

            var rule = new RuleEntity
            {
                RuleSetId = ruleSetId,
                RuleType  = ruleType,
                Operator  = op.Operator
            };

            if (descriptor.RuleType == RuleType.Boolean)
            {
                // Do not store NULL. Irritating because UI indicates 'yes'.
                var val = op == RuleOperator.IsEqualTo;
                rule.Value = val.ToString(CultureInfo.InvariantCulture).ToLower();
            }
            else if (op == RuleOperator.In || op == RuleOperator.NotIn)
            {
                // Avoid ArgumentException "The 'In' operator only supports non-null instances from types that implement 'ICollection<T>'."
                rule.Value = string.Empty;
            }

            _ruleStorage.InsertRule(rule);

            var expression = provider.VisitRule(rule);

            PrepareTemplateViewBag(ruleSetId);

            return(PartialView("_Rule", expression));
        }
Esempio n. 8
0
            private static string getRuleScope(RuleScope objScope)
            {
                string rs = string.Empty;

                switch (objScope)
                {
                case RuleScope.All:
                    rs = Constants.RuleScopeAll;
                    break;

                case RuleScope.System:
                    rs = Constants.RuleScopeSystem;
                    break;

                case RuleScope.User:
                    rs = Constants.RuleScopeUser;
                    break;

                case RuleScope.Unknown:
                default:
                    Debug.Assert(false);
                    rs = string.Empty;
                    break;
                }
                return(rs);
            }
        private void SaveRuleData(RuleEditItem[] ruleData, RuleScope ruleScope)
        {
            var rules = _ruleStorage.GetRulesByIds(ruleData?.Select(x => x.RuleId)?.ToArray(), true);

            if (!rules.Any())
            {
                return;
            }

            using (var scope = new DbContextScope(ctx: Services.DbContext, autoCommit: false))
            {
                var rulesDic = rules.ToDictionarySafe(x => x.Id);
                var provider = _ruleProvider(ruleScope);

                foreach (var data in ruleData)
                {
                    if (rulesDic.TryGetValue(data.RuleId, out var entity))
                    {
                        // TODO? Ugly. There should be a better way. Do not store culture variant values.
                        if (data.Value.HasValue())
                        {
                            var descriptor = provider.RuleDescriptors.FindDescriptor(entity.RuleType);

                            if (descriptor.RuleType == RuleType.Money)
                            {
                                data.Value = data.Value.Convert <decimal>(CultureInfo.CurrentCulture).ToString(CultureInfo.InvariantCulture);
                            }
                            else if (descriptor.RuleType == RuleType.Float || descriptor.RuleType == RuleType.NullableFloat)
                            {
                                data.Value = data.Value.Convert <float>(CultureInfo.CurrentCulture).ToString(CultureInfo.InvariantCulture);
                            }
                            else if (descriptor.RuleType == RuleType.DateTime || descriptor.RuleType == RuleType.NullableDateTime)
                            {
                                data.Value = data.Value.Convert <DateTime>(CultureInfo.CurrentCulture).ToString(CultureInfo.InvariantCulture);
                            }
                        }
                        //if (data.Value?.Contains(',') ?? false)
                        //{
                        //    var provider = _ruleProvider(ruleScope);
                        //    var descriptor = provider.RuleDescriptors.FindDescriptor(entity.RuleType);
                        //    var floatingPointTypes = new Type[] { typeof(decimal), typeof(decimal?), typeof(float), typeof(float?), typeof(double), typeof(double?) };

                        //    if (floatingPointTypes.Contains(descriptor.RuleType.ClrType))
                        //    {
                        //        data.Value = data.Value.Replace(",", ".");
                        //    }
                        //}

                        entity.Operator = data.Op;
                        entity.Value    = data.Value;

                        _ruleStorage.UpdateRule(entity);
                    }
                }

                scope.Commit();
            }
        }
Esempio n. 10
0
 public void RuleScopeMatchResult(RuleScope scope, ScopeMatchResult result)
 {
     this.logger.Log(
         LogLevel.Diagnostic,
         "Rule scope {0} {1} {2}",
         scope.DisplayName,
         result.Success ? "matches" : "does not match",
         result.Arguments);
 }
Esempio n. 11
0
 /// <summary>
 /// Enumerates the currently set flags on this Enum as individual Enum values.
 /// </summary>
 /// <param name="input"></param>
 /// <returns></returns>
 public static IEnumerable <RuleScope> Enumerate(this RuleScope input)
 {
     foreach (RuleScope value in Enum.GetValues(input.GetType()))
     {
         if (input.HasFlag(value))
         {
             yield return(value);
         }
     }
 }
Esempio n. 12
0
 public Rule(
     RuleObjectType objectType,
     RuleScope objectScope,
     string matchString
     )
 {
     m_ObjectType  = objectType;
     m_ObjectScope = objectScope;
     m_MatchString = matchString;
 }
Esempio n. 13
0
 protected virtual IEnumerable <Rule> GetRulesByScope(RuleScope scope, bool includeGlobalScope, Func <Rule, RuleScope, bool> scopeEvaluator)
 {
     if (scopeEvaluator == null)
     {
         return(_rules.Where(x => (x.Scope == scope || (includeGlobalScope && x.Scope == RuleScope.Global))).OrderBy(x => x.Order).ToList());
     }
     else
     {
         return(_rules.Where(x => scopeEvaluator(x, scope) || (includeGlobalScope && x.Scope == RuleScope.Global)).OrderBy(x => x.Order).ToList());
     }
 }
        public ActionResult UpdateRules(RuleEditItem[] ruleData, RuleScope ruleScope)
        {
            try
            {
                SaveRuleData(ruleData, ruleScope);
            }
            catch (Exception ex)
            {
                return(Json(new { Success = false, ex.Message }));
            }

            return(Json(new { Success = true }));
        }
Esempio n. 15
0
        public void InvalidRegexPatternMustFailOnObjectInitialization(
            RuleScope scope)
        {
            var invalidPattern = "[";

            var ex = Assert.Throws <ArgumentException>(
                () => new RegexRule(invalidPattern, scope));

            Assert.Equal("Given pattern \"[\" was invalid regular expression.",
                         ex.Message);
            Assert.NotNull(ex.InnerException);
            Assert.IsType <ArgumentException>(ex.InnerException);
        }
Esempio n. 16
0
        /** Return the scope containing name */
        public virtual AttributeScope GetAttributeScope(string name)
        {
            AttributeScope scope = GetLocalAttributeScope(name);

            if (scope != null)
            {
                return(scope);
            }
            if (RuleScope != null && RuleScope.GetAttribute(name) != null)
            {
                scope = RuleScope;
            }
            return(scope);
        }
Esempio n. 17
0
            public Rule(
                SqlInt32 ruleId,
                SqlInt32 objType,
                SqlString objScope,
                SqlString matchString
                )
            {
                Debug.Assert(!ruleId.IsNull);
                Debug.Assert(!objType.IsNull);

                m_RuleId      = ruleId.IsNull ? Constants.InvalidId : ruleId.Value;
                m_ObjectType  = getRuleObjectType(objType);
                m_ObjectScope = getRuleScope(objScope);
                m_MatchString = matchString.IsNull ? string.Empty : matchString.Value;
            }
Esempio n. 18
0
        /// <summary>
        /// The abstract rule constructor
        /// </summary>
        /// <param name="name">The name of this rule. Must be globally unique among all rules.</param>
        /// <param name="number">The number of this rule in format [D]D.DD[.DD]. Must be globally unique among all rules.</param>
        /// <param name="scope">The scope that this rule applies. Direct matches are searched for when applying rule logic</param>
        /// <param name="order">The order in which a rule should run relative to it's scope. Rules are ordered ascending by this value.</param>
        public Rule(string name, string number, RuleScope scope, int order = 100) {

            if (String.IsNullOrEmpty(name) || name.Trim().Length == 0) {
                throw new RuleException("Rules must be provided with a rule name.");
            }
            if (String.IsNullOrEmpty(number)) {
                throw new RuleException("Rules must be provided with a rule number.");
            }
            if (!Regex.IsMatch(number, @"^[1-9]{1}(?:\d{1})?((\.\d{1,2}){0,2})?$")) {
                throw new RuleException("Rule numbers must be in the form ##.##[.##]. Number can not start with a 0 (zero).");
            }
            _name = name.Trim();
            _scope = scope;
            _number = number;
            _order = order;
        }
Esempio n. 19
0
        public override RuleOutcome EvaluateRuleSet(RuleScope scope, bool includeGlobalScope = true, Func <Rule, RuleScope, bool> scopeEvaluator = null)
        {
            Debug.Print("~~~~~ RULE SET EVAL ~~~~~~~");
            Debug.Print("Scope: {0}", scope.ToString());
            Debug.Print("PRE EVAL CONTEXT ----------");
            Debug.Print(Context.ToString());
            Debug.Print("-");
            var outcome = base.EvaluateRuleSet(scope, includeGlobalScope, scopeEvaluator);

            Debug.Print("POST EVAL CONTEXT  --------");
            Debug.Print(Context.ToString());
            Debug.Print("Outcome: {0}", outcome.Result.ToString());
            Debug.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            Debug.Print("");

            return(outcome);
        }
Esempio n. 20
0
        public virtual RuleOutcome EvaluateRuleSet(RuleScope scope, bool includeGlobalScope = true, Func <Rule, RuleScope, bool> scopeEvaluator = null)
        {
            List <Rule> rules = GetRulesByScope(scope, includeGlobalScope, scopeEvaluator);

            if (rules != null && rules.Count > 0)
            {
                foreach (var rule in rules)
                {
                    RuleOutcome outcome = rule.Evaluate();
                    if (!outcome.IsAllowed)
                    {
                        //rule pipeline failed :(
                        return(outcome);
                    }
                }
            }

            return(RuleOutcome.Allowed);
        }
Esempio n. 21
0
        public static string GetTypeName(this RuleScope scope)
        {
            if (scope.IsMultiple())
            {
                throw new InvalidOperationException("The provided RuleScope enum value has more than one flag set.");
            }

            var x = scope.ToString().SplitCamelCase();

            if (scope == RuleScope.Hierarchy)
            {
                x = "Hierarchies";
            }
            else if (scope != RuleScope.Model)
            {
                x += "s";
            }
            return(x);
        }
Esempio n. 22
0
 /// <summary>
 /// The abstract rule constructor
 /// </summary>
 /// <param name="name">The name of this rule. Must be globally unique among all rules.</param>
 /// <param name="number">The number of this rule in format [D]D.DD[.DD]. Must be globally unique among all rules.</param>
 /// <param name="scope">The scope that this rule applies. Direct matches are searched for when applying rule logic</param>
 /// <param name="order">The order in which a rule should run relative to it's scope. Rules are ordered ascending by this value.</param>
 public Rule(string name, string number, RuleScope scope, int order = 100)
 {
     if (String.IsNullOrEmpty(name) || name.Trim().Length == 0)
     {
         throw new RuleException("Rules must be provided with a rule name.");
     }
     if (String.IsNullOrEmpty(number))
     {
         throw new RuleException("Rules must be provided with a rule number.");
     }
     if (!Regex.IsMatch(number, @"^[1-9]{1}(?:\d{1})?((\.\d{1,2}){0,2})?$"))
     {
         throw new RuleException("Rule numbers must be in the form ##.##[.##]. Number can not start with a 0 (zero).");
     }
     _name   = name.Trim();
     _scope  = scope;
     _number = number;
     _order  = order;
 }
Esempio n. 23
0
        internal SpamRuleBlobPackage FindSpamRulesBlob(RuleScope scopeId, RuleStatusType publishingState, ref string pageCookie)
        {
            List <SpamRuleBlob> list = this.FindPagedSpamRules(scopeId, publishingState, ref pageCookie).ToList <SpamRuleBlob>();

            if (list.Any <SpamRuleBlob>())
            {
                HashSet <string> hashSet = new HashSet <string>();
                foreach (SpamRuleBlob spamRuleBlob in list)
                {
                    hashSet.AddRange(SpamRuleBlobUtils.GetProcessorIds(spamRuleBlob.ProcessorData));
                }
                List <SpamRuleProcessorBlob> spamRuleProcessorBlobs = this.ReadSpamRuleProcessorsByProcessorIds <SpamRuleProcessorBlob>(hashSet).ToList <SpamRuleProcessorBlob>();
                return(new SpamRuleBlobPackage
                {
                    SpamRuleBlobs = list,
                    SpamRuleProcessorBlobs = spamRuleProcessorBlobs
                });
            }
            return(null);
        }
Esempio n. 24
0
        internal IEnumerable <SpamRuleBlob> FindPagedSpamRules(RuleScope scopeId, RuleStatusType publishingState, ref string pageCookie)
        {
            List <SpamRuleBlob> list            = new List <SpamRuleBlob>();
            QueryFilter         baseQueryFilter = QueryFilter.AndTogether(new QueryFilter[]
            {
                new ComparisonFilter(ComparisonOperator.Equal, SpamRuleBlobSchema.ScopeIdProperty, (byte)scopeId),
                new ComparisonFilter(ComparisonOperator.Equal, SpamRuleBlobSchema.PublishingStateProperty, (byte)publishingState),
                base.BuildVersionParam
            });
            bool flag = false;

            while (!flag)
            {
                QueryFilter pagingQueryFilter         = PagingHelper.GetPagingQueryFilter(baseQueryFilter, pageCookie);
                IEnumerable <SpamRuleBlob> collection = base.DataProvider.FindPaged <SpamRuleBlob>(pagingQueryFilter, null, true, null, 1000);
                list.AddRange(collection);
                pageCookie = PagingHelper.GetProcessedCookie(pagingQueryFilter, out flag);
            }
            return(list);
        }
Esempio n. 25
0
        /// <summary>
        /// Creates a new rule instance requiring naming to match given
        /// pattern on certain scope.
        /// </summary>
        /// <param name="regexPattern">
        /// Regular expression pattern which must be met on scope given by
        /// parameter <paramref name="scope"/>.
        /// </param>
        /// <param name="scope">
        /// Scope of the rule.
        /// </param>
        /// <param name="excludedSchemaNames">
        /// List of schema names which are exluded from the rule.
        /// </param>
        public RegexRule(string regexPattern,
                         RuleScope scope,
                         ICollection <string> excludedSchemaNames)
        {
            if (excludedSchemaNames == null)
            {
                throw new ArgumentNullException(nameof(excludedSchemaNames));
            }

            try {
                Pattern = new Regex(regexPattern);
            }
            catch (ArgumentException ex) {
                throw new ArgumentException(
                          $"Given pattern \"{regexPattern}\" was invalid regular expression.",
                          ex);
            }

            Scope = scope;

            _excludedSchemaNames = excludedSchemaNames;
        }
Esempio n. 26
0
 public static bool IsMultiple(this RuleScope scope)
 {
     return((scope & (scope - 1)) != 0);
 }
Esempio n. 27
0
 public BaseSubverseMinCCPRule(string name, string number, RuleScope scope)
     : base(name, number, scope) {
 }
Esempio n. 28
0
 public SubmissionBannedDomainRule(string name, string number, RuleScope scope)
     : base(name, number, scope)
 {
 }
Esempio n. 29
0
        private IQueryable GetCollection(RuleScope scope)
        {
            switch (scope)
            {
            case RuleScope.KPI:
                return(Model.AllMeasures.Where(m => m.KPI != null).Select(m => m.KPI).AsQueryable());

            case RuleScope.CalculatedColumn:
                return(Model.AllColumns.OfType <CalculatedColumn>().AsQueryable());

            case RuleScope.CalculatedTable:
                return(Model.Tables.OfType <CalculatedTable>().AsQueryable());

            case RuleScope.CalculatedTableColumn:
                return(Model.Tables.OfType <CalculatedTable>().SelectMany(t => t.Columns).OfType <CalculatedTableColumn>().AsQueryable());

            case RuleScope.Culture:
                return(Model.Cultures.AsQueryable());

            case RuleScope.DataColumn:
                return(Model.AllColumns.OfType <DataColumn>().AsQueryable());

            case RuleScope.ProviderDataSource:
                return(Model.DataSources.OfType <ProviderDataSource>().AsQueryable());

            case RuleScope.StructuredDataSource:
                return(Model.DataSources.OfType <StructuredDataSource>().AsQueryable());

            case RuleScope.Hierarchy:
                return(Model.AllHierarchies.AsQueryable());

            case RuleScope.Level:
                return(Model.AllLevels.AsQueryable());

            case RuleScope.Measure:
                return(Model.AllMeasures.AsQueryable());

            case RuleScope.Model:
                return(Enumerable.Repeat(Model, 1).AsQueryable());

            case RuleScope.Partition:
                return(Model.AllPartitions.AsQueryable());

            case RuleScope.Perspective:
                return(Model.Perspectives.AsQueryable());

            case RuleScope.Relationship:
                return(Model.Relationships.OfType <SingleColumnRelationship>().AsQueryable());

            case RuleScope.Table:
                return(Model.Tables.Where(t => !(t is CalculatedTable)).AsQueryable());

            case RuleScope.ModelRole:
                return(Model.Roles.AsQueryable());

            case RuleScope.NamedExpression:
                return(Model.Expressions.AsQueryable());

            case RuleScope.Variation:
                return(Model.AllColumns.SelectMany(c => c.Variations).AsQueryable());

            default:
                return(Enumerable.Empty <TabularNamedObject>().AsQueryable());
            }
        }
Esempio n. 30
0
 public MinCCPRule(string name, string number, int minCCP, RuleScope scope)
     : base(name, number, scope) {
     MinCCP = minCCP;
 }
Esempio n. 31
0
 private IQueryable GetCollection(RuleScope scope)
 {
     return(GetCollection(Model, scope));
 }
Esempio n. 32
0
 public TestRule(string name, string number, RuleScope scope) : base(name, number, scope)
 {
 }
Esempio n. 33
0
 public BaseVoatRule(string name, string number, RuleScope scope, int order = 100) : base(name, number, scope, order)
 {
     /*no-op*/
 }
Esempio n. 34
0
 public BaseVoatRule(string name, string number, RuleScope scope, int order = 100) : base(name, number, scope, order) { 
     /*no-op*/
 }
Esempio n. 35
0
 public BaseCCPVote(string name, string number, int minCCP, RuleScope scope)
     : base(name, number, minCCP, scope) {
 }
Esempio n. 36
0
 /// <summary>
 /// 判断当前规则是否与指定的范围有重叠。
 /// </summary>
 /// <param name="scope"></param>
 /// <returns></returns>
 public bool HasScope(RuleScope scope)
 {
     return (this.Scope & scope) != 0;
 }