示例#1
0
        private bool[,] GetRulePipelineResults()
        {
            bool[,] results = new bool[_board.Size, _board.Size];
            CellRule rule = new CellRule();
            rule.PipelineObject = rule.GetType();
            rule.PipelineObjectNamespaceName = true.GetType().FullName;
            var processes = new RuleFactory<IPipelineObject>().GetProcessors(rule).ToList();  //cast to avoid multiple enumerations

            for (int y = 0; y < _board.Size; y++)
            {
                for (int x = 0; x < _board.Size; x++)
                {
                    rule.Initialize(_board, x, y);

                    var result = Pipeline<IPipelineObject>.Execute(processes, rule) as CellRule;

                    if (result == null)
                    {
                        throw new Exception("The pipeline being executed for cell rules must return a cell rule object.");
                    }

                    results[x, y] = result.Status;
                }
            }
            return results;
        }
示例#2
0
        public bool RuleIsSatisfied()
        {
            RuleFactory   ruleFactory  = new RuleFactory();
            IRuleStrategy ruleStrategy = ruleFactory.GetRuleStrategy(_rule);

            Context ruleContext = new Context(ruleStrategy);

            if (ruleContext.Execute(_rule, _liveEventsThatFitIntoRule.ToList()))
            {
                ClearProcessedEvents();
                return(true);
            }

            return(false);
        }
示例#3
0
        public void Tests(TestCase test)
        {
            JsonSchema schema = SchemaReader.ReadSchema(test.SchemaText, TestUtil.TestFilePath);
            var        target = new Validator(schema);

            Result[] results = target.Validate(test.InstanceText, TestUtil.TestFilePath);

            results.Length.Should().Be(test.ExpectedMessages.Length);

            List <string> actualMessages = results.Select(
                r => r.FormatForVisualStudio(
                    RuleFactory.GetRuleFromRuleId(r.RuleId))).ToList();

            actualMessages.Should().ContainInOrder(test.ExpectedMessages);
        }
示例#4
0
        public async Task ProcessRuleAsyncPass()
        {
            await PopulateTodoItems(TotalItems);

            var request  = CreateRequest();
            var response = CreateResponse();

            var rule = new TodoItemNotFoundRule(Context);
            await rule.ProcessAsync(request, response, RuleFactory.CreateEmptyListOfUpdateRules());

            Assert.AreEqual(RuleStatusType.Passed, rule.Status);
            Assert.IsTrue(rule.ContinueProcessing);

            Assert.AreEqual(0, response.Notifications.Count);
        }
示例#5
0
        public IRule CopyRule(int ruleIndex, Strategy target)
        {
            IRule rule = rules[ruleIndex];

            IRule newRule = RuleFactory.GetInstance().CreateRuleInstance(rule.GetType());

            //we do not initialize rule here coz when str is added to rep, its
            //initialize method is called which calles init of its rules

            //newRule.Initialize(this);
            rule.CopyState(newRule);
            target.AddRule(newRule);

            return(newRule);
        }
示例#6
0
        private string FormatSchemaErrors(string path, IEnumerable <Result> errors)
        {
            string firstMessageLine = string.Format(CultureInfo.CurrentCulture, MultitoolResources.ErrorInvalidSarifLogFile, path);

            var sb = new StringBuilder(firstMessageLine);

            sb.AppendLine();

            foreach (Result error in errors)
            {
                sb.AppendLine(error.FormatForVisualStudio(RuleFactory.GetRuleFromRuleId(error.RuleId)));
            }

            return(sb.ToString());
        }
示例#7
0
        public static bool EvaluateRules(string strRules, Item contextItem, bool failEmpty = false)
        {
            if (string.IsNullOrEmpty(strRules) || strRules.Length < 70)
            {
                return(!failEmpty);
            }
            // hacking the rules xml
            var rules       = RuleFactory.ParseRules <RuleContext>(Factory.GetDatabase(ApplicationSettings.RulesDb), strRules);
            var ruleContext = new RuleContext
            {
                Item = contextItem
            };

            return(!rules.Rules.Any() || rules.Rules.Any(rule => rule.Evaluate(ruleContext)));
        }
示例#8
0
        public void PropertyRuleShouldBeConstructable()
        {
            // Arrange
            var data = new PropertyRuleData
            {
                Name = Guid.NewGuid().ToString()
            };
            var sut = new RuleFactory();

            // Act
            var actual = sut.Construct(data);

            // Assert
            Assert.NotNull(actual);
        }
        /// <summary>
        /// Invoke global device resolution rules.
        /// </summary>
        /// <returns>True if a global device resolution rule applied.</returns>
        protected bool InvokeGlobalRules()
        {
            Sitecore.Data.Items.Item ruleRoot = Sitecore.Context.Database.GetItem(
                "/sitecore/system/Settings/Rules/Determine Context Device/Rules");

            if (ruleRoot == null)
            {
                return(false);
            }

            // TODO: use descendants instead of children
            // for each possible global rule definition item
            foreach (Sitecore.Data.Items.Item child in ruleRoot.Children)
            {
                string ruleXml = child["Rule"];

                if (String.IsNullOrEmpty(ruleXml) || child["Disabled"] == "1")
                {
                    continue;
                }

                // parse the rule XML
                RuleList <RuleContext> rules = new RuleList <RuleContext>();
                rules.Name = child.Paths.Path;
                RuleList <RuleContext> parsed = RuleFactory.ParseRules <RuleContext>(
                    Sitecore.Context.Database,
                    ruleXml);
                rules.AddRange(parsed.Rules);

                if (rules == null || rules.Count < 1)
                {
                    continue;
                }

                // invoke the rule
                RuleContext ruleContext = new RuleContext();
                ruleContext.Item = Sitecore.Context.Item;
                rules.Run(ruleContext);

                // rule applied
                if (ruleContext.IsAborted)
                {
                    return(true);
                }
            }

            return(false);
        }
示例#10
0
        /// <summary> Gets global conditional rules </summary>
        /// <param name="item">item to proceed</param>
        /// <returns>rulles collection</returns>
        protected RuleList <ConditionalRenderingsRuleContext> GetGlobalRules(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            RuleList <ConditionalRenderingsRuleContext> rules = null;

            using (new SecurityDisabler())
            {
                Item parentItem = item.Database.GetItem(ItemIDs.ConditionalRenderingsGlobalRules);
                if (parentItem != null)
                {
                    rules = RuleFactory.GetRules <ConditionalRenderingsRuleContext>(parentItem, "Rule");
                }
            }

            return(rules);
        }
        public void CreateRule_GivenNullRuleDataModel_ThrowsArgumentNullException()
        {
            // Arrange
            RuleDataModel ruleDataModel = null;

            IContentSerializationProvider <ContentType> contentSerializationProvider = Mock.Of <IContentSerializationProvider <ContentType> >();

            RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>(contentSerializationProvider);

            // Act
            ArgumentNullException argumentNullException = Assert.Throws <ArgumentNullException>(() => ruleFactory.CreateRule(ruleDataModel));

            // Assert
            argumentNullException.Should().NotBeNull();
            argumentNullException.ParamName.Should().Be(nameof(ruleDataModel));
        }
示例#12
0
        public async Task ProcessRuleAsyncPass(string scenario, object expectedItem)
        {
            var expectedTodoItemEntity = (TodoItemEntity)expectedItem;
            var request  = CreateRequest((int)expectedTodoItemEntity.Id);
            var response = CreateResponse();

            var rule = new ResponseRule();
            await rule.ProcessAsync(request, response, RuleFactory.CreateEmptyListOfSaveRules());

            VerifyTodoItem.AssertTodoItem(expectedTodoItemEntity, response.Item);

            Assert.AreEqual(RuleStatusType.Passed, rule.Status);
            Assert.IsTrue(rule.ContinueProcessing);

            Assert.AreEqual(0, response.Notifications.Count);
        }
示例#13
0
        private void Execute(XmlTextWriter output, string databaseName, string itemId, string rules)
        {
            var database = Factory.GetDatabase(databaseName);

            if (database == null)
            {
                output.WriteElementString("entry", "Database not found.");
                return;
            }

            var item = database.GetItem(itemId);

            if (item == null)
            {
                output.WriteElementString("entry", "Source item not found.");
                return;
            }

            XElement root;

            try
            {
                var doc = XDocument.Parse(rules);
                root = doc.Root;
            }
            catch
            {
                output.WriteElementString("entry", "Rules Xml is not welformed.");
                return;
            }

            if (root == null)
            {
                output.WriteElementString("entry", "There are no rules defined.");
                return;
            }

            var ruleList = RuleFactory.ParseRules <RuleContext>(database, rules);

            if (!ruleList.Rules.Any())
            {
                output.WriteElementString("entry", "There are no rules defined.");
                return;
            }

            Evaluate(output, item, root, ruleList);
        }
示例#14
0
        /// <summary>
        /// Overrides the base class implementation and adds execution of rules to determine allowed renderings.
        /// </summary>
        protected override List <Sitecore.Data.Items.Item> GetRenderings(Sitecore.Data.Items.Item placeholderItem, out bool allowedControlsSpecified)
        {
            // Get the initial list of renderings from the base implementation.
            var list = base.GetRenderings(placeholderItem, out allowedControlsSpecified);

            // Get the rules from the placeholder item.
            string rulesXml = placeholderItem[Constants.RulesFieldId];

            if (string.IsNullOrWhiteSpace(rulesXml))
            {
                return(list);
            }

            // Parse the rules.
            var parsedRules = RuleFactory.ParseRules <PlaceholderSettingsRuleContext>(placeholderItem.Database, rulesXml);

            // Construct the context.
            PlaceholderSettingsRuleContext context = new PlaceholderSettingsRuleContext();

            context.Item = placeholderItem;
            context.AllowedRenderingItems = list;
            context.DeviceId         = DeviceId;
            context.PlaceholderKey   = PlaceholderKey;
            context.ContentDatabase  = ContentDatabase;
            context.LayoutDefinition = LayoutDefinition;

            // Execute the rules.
            RuleList <PlaceholderSettingsRuleContext> rules = new RuleList <PlaceholderSettingsRuleContext>();

            rules.Name = placeholderItem.Paths.Path;
            rules.AddRange(parsedRules.Rules);
            rules.Run(context);

            // Did the rules specify if the selection tree should be displayed?
            if (context.DisplaySelectionTree.HasValue)
            {
                allowedControlsSpecified = !context.DisplaySelectionTree.Value;
            }
            // If not, only display the tree if there are no allowed renderings.
            else
            {
                allowedControlsSpecified = context.AllowedRenderingItems.Count > 0;
            }

            // Return the list.
            return(context.AllowedRenderingItems);
        }
示例#15
0
        public async Task ProcessRuleAsyncNotSameId()
        {
            var request = CreateRequest();

            request.Id = NotSameId;

            var response = CreateResponse();

            var rule = new TodoItemNotSameIdRule();
            await rule.ProcessAsync(request, response, RuleFactory.CreateEmptyListOfUpdateRules());

            Assert.IsInstanceOfType(rule, typeof(BaseRule <UpdateTodoItemRequest, Response <TodoItemEntity> >));
            Assert.AreEqual(RuleStatusType.Failed, rule.Status);
            Assert.IsFalse(rule.ContinueProcessing);

            VerifyNotification.AssertResponseNotifications(CreateExpectedResponse(), response);
        }
示例#16
0
        protected override void BeginProcessing()
        {
            Item currentItem = InputObject.BaseObject() as Item;

            string ruleDatabaseName = RuleDatabase;

            if (!string.IsNullOrEmpty(ruleDatabaseName))
            {
                ruleDatabaseName = currentItem != null
                    ? currentItem.Database.Name
                    : ApplicationSettings.RulesDb;
            }

            Database ruleDatabase = Factory.GetDatabase(ruleDatabaseName);

            rules = RuleFactory.ParseRules <RuleContext>(ruleDatabase, Rule);
        }
示例#17
0
        public virtual Item GetRulesBasedSnippetDataSource(Item rulesBasedSnippetSnippetItem, Item contextItem)
        {
            var rulesValue = rulesBasedSnippetSnippetItem[Templates.RulesBasedSnippetSnippet.Fields.SnippetRules];

            if (string.IsNullOrWhiteSpace(rulesValue))
            {
                return(null);
            }

            var commerceContextItem = siteContext.CurrentCatalogItem ?? contextItem;
            var rules       = RuleFactory.ParseRules <RuleContext>(contextItem.Database, XElement.Parse(rulesValue));
            var ruleContext = new RuleContext()
            {
                Item = commerceContextItem
            };

            if (rules.Rules.Any())
            {
                foreach (var rule in rules.Rules)
                {
                    if (rule.Condition != null)
                    {
                        var stack = new RuleStack();
                        rule.Condition.Evaluate(ruleContext, stack);

                        if (ruleContext.IsAborted)
                        {
                            continue;
                        }
                        if ((stack.Count != 0) && ((bool)stack.Pop()))
                        {
                            rule.Execute(ruleContext);
                            var action    = rule.Actions.FirstOrDefault();
                            var snippetId = action is SelectSnippet <RuleContext>?((SelectSnippet <RuleContext>)action)?.SnippetId : string.Empty;
                            return(!string.IsNullOrEmpty(snippetId) ? contextItem.Database.GetItem(ID.Parse(snippetId)) : null);
                        }
                    }
                    else
                    {
                        rule.Execute(ruleContext);
                    }
                }
            }

            return(null);
        }
        private static Rule CreateRandomCrossRule() // Generate a random Cross Rule.
        {
            int rndNum = RandomHolder.Instance.Next(3);

            if (rndNum == 0) // Create a Cross( Overlay, Overlay) rule.
            {
                return(RuleFactory.createCrossRule(IndicatorFactory.getRandomPriceOverlayIndicator(), IndicatorFactory.getRandomPriceOverlayIndicator()));
            }
            else if (rndNum == 1) // Create a Cross( Overlay, PriceArray) rule.
            {
                return(RuleFactory.createCrossRule(IndicatorFactory.getRandomPriceOverlayIndicator(), IndicatorFactory.createRandomABPriceArray()));
            }
            else // Create a Cross( PriceArray, Overlay) rule.
            {
                return(RuleFactory.createCrossRule(IndicatorFactory.createRandomABPriceArray(), IndicatorFactory.getRandomPriceOverlayIndicator()));
            }
        }
示例#19
0
        private void InitializeControl()
        {
            var contextMenuHandler = new ContextMenuHandler();
            var displayHandler     = new DisplayHandler();
            var downloadLogger     = logger.CloneFor($"{nameof(DownloadHandler)} {Id}");
            var downloadHandler    = new DownloadHandler(appConfig, settings, downloadLogger);
            var keyboardHandler    = new KeyboardHandler();
            var lifeSpanHandler    = new LifeSpanHandler();
            var requestFilter      = new RequestFilter();
            var requestLogger      = logger.CloneFor($"{nameof(RequestHandler)} {Id}");
            var requestHandler     = new RequestHandler(appConfig, settings.Filter, requestFilter, requestLogger, text);

            displayHandler.FaviconChanged  += DisplayHandler_FaviconChanged;
            displayHandler.ProgressChanged += DisplayHandler_ProgressChanged;
            downloadHandler.ConfigurationDownloadRequested += DownloadHandler_ConfigurationDownloadRequested;
            keyboardHandler.ReloadRequested    += ReloadRequested;
            keyboardHandler.ZoomInRequested    += ZoomInRequested;
            keyboardHandler.ZoomOutRequested   += ZoomOutRequested;
            keyboardHandler.ZoomResetRequested += ZoomResetRequested;
            lifeSpanHandler.PopupRequested     += LifeSpanHandler_PopupRequested;
            requestHandler.RequestBlocked      += RequestHandler_RequestBlocked;

            if (settings.Filter.ProcessContentRequests || settings.Filter.ProcessMainRequests)
            {
                var factory = new RuleFactory();

                foreach (var settings in settings.Filter.Rules)
                {
                    var rule = factory.CreateRule(settings.Type);

                    rule.Initialize(settings);
                    requestFilter.Load(rule);
                }

                logger.Debug($"Initialized request filter with {settings.Filter.Rules.Count} rule(s).");
            }

            control = new BrowserControl(contextMenuHandler, displayHandler, downloadHandler, keyboardHandler, lifeSpanHandler, requestHandler, url);
            control.AddressChanged      += Control_AddressChanged;
            control.LoadingStateChanged += Control_LoadingStateChanged;
            control.TitleChanged        += Control_TitleChanged;

            control.Initialize();
            logger.Debug("Initialized browser control.");
        }
示例#20
0
        private static Task <int> Main(string[] args)
        {
            var rootCommand = new RootCommand
            {
                new Option <FileInfo>("--config", "Path to a configuration that defines how validation will occur.")
                {
                    IsRequired = true,
                    AllowMultipleArgumentsPerToken = false,
                    Argument = new Argument <FileInfo>
                    {
                        Arity = ArgumentArity.ExactlyOne
                    }
                }.ExistingOnly(),
                new Option <FileInfo[]>("--project",
                                        "Path to a Visual Studio solution or project files that should be validated. Can be specified multiple times")
                {
                    IsRequired = true,
                    AllowMultipleArgumentsPerToken = true,
                    Argument = new Argument <FileInfo[]>
                    {
                        Arity = ArgumentArity.OneOrMore
                    }
                }.ExistingOnly(),
                new Option <bool>("--verbose", description: "Verbose output of progress", getDefaultValue: () => false),
                new Option <bool>("--silent", description: "Don't output anything on stdout", getDefaultValue: () => false)
            };

            rootCommand.Description = "Validator for Visual Studio projects";
            rootCommand.Handler     = CommandHandler.Create(
                async(FileInfo config, FileInfo[] project, bool verbose, bool silent, IConsole console) =>
            {
                var logger = new Output(console, silent, verbose);

                var rulesFactory = new RuleFactory();
                var rulesLoader  = new RulesLoader(rulesFactory, logger);
                var rules        = await rulesLoader.LoadRules(config).ToListAsync();

                var projectLoader = new ProjectLoader(logger);
                var validator     = new Validator(rules, projectLoader, logger);

                return(await validator.Validate(project));
            });

            return(rootCommand.InvokeAsync(args));
        }
示例#21
0
        public static bool EvaluateRulesForView(string strRules, RuleContext ruleContext, bool failNonSpecific = false)
        {
            if (string.IsNullOrEmpty(strRules) || strRules.Length < 70)
            {
                return(!failNonSpecific);
            }
            var viewName = ruleContext.Parameters["ViewName"];

            if (failNonSpecific &&
                (!"ValidViewName".IsSubstringOf(strRules) || !$"\"{viewName}\"".IsSubstringOf(strRules)))
            {
                return(false);
            }

            var rules = RuleFactory.ParseRules <RuleContext>(Factory.GetDatabase(ApplicationSettings.RulesDb), strRules);

            return(!rules.Rules.Any() || rules.Rules.Any(rule => rule.Evaluate(ruleContext)));
        }
示例#22
0
文件: Md.cs 项目: lgnv/clean-code
        public static string Render(string markdown)
        {
            var rules         = RuleFactory.CreateAllRules();
            var sourceTags    = rules.Select(rule => rule.SourceTag);
            var renderedLines = new List <string>();
            var parser        = new MainParser(sourceTags);
            var render        = new Render(rules);
            var escapedText   = EscapeSpecialSymbols(markdown);

            foreach (var line in Regex.Split(escapedText, Environment.NewLine))
            {
                var tokens       = parser.ParseLine(line);
                var renderedLine = render.RenderLine(line, tokens);
                renderedLines.Add(renderedLine);
            }

            return(string.Join(Environment.NewLine, renderedLines));
        }
        public void ExecuteNotEqualRuleOnFlatNullablePropertyPassed()
        {
            var rule = new RuleFactory().Create(RuleOperator.NotEqual);

            rule.LeftNode          = "BirthDate";
            rule.RightNode         = null;
            rule.ValidationMessage = "Nullable Date must not be empty or null";

            var person = new Person {
                Name = "Faenor"
            };

            var engine       = new RuleEngine();
            var compiledRule = engine.CompileRules <Person>(rule);
            var result       = engine.Validate(person, compiledRule);

            Assert.AreEqual(false, result.Passed);
            Assert.AreEqual(0, result.ValidationMessageSummary.Length);
        }
        public void ExecuteEqualRuleOnFlatPropertyPassed()
        {
            var rule = new RuleFactory().Create(RuleOperator.Equal);

            rule.LeftNode          = "Name";
            rule.RightNode         = "Faenor";
            rule.ValidationMessage = "Name should be equal to Faenor.";

            var person = new Person {
                Name = "Faenor"
            };

            var engine       = new RuleEngine();
            var compiledRule = engine.CompileRules <Person>(rule);
            var result       = engine.Validate(person, compiledRule);

            Assert.AreEqual(true, result.Passed);
            Assert.AreEqual(0, result.ValidationMessageSummary.Length);
        }
示例#25
0
        private static IEnumerable <object[]> SetupProcessRuleAsyncSkipped()
        {
            var rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();

            yield return(new object[] { "Rules: 0 of 3 required rules, 0 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            yield return(new object[] { "Rules: 0 of 3 required rules, 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <RequestRule>());
            yield return(new object[] { "Rules: 1 of 3 required rules (RequestRule), 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <ResponseRule>());
            yield return(new object[] { "Rules: 1 of 3 required rules (ResponseRule), 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <TodoItemPriorityRule>());
            yield return(new object[] { "Rules: 1 of 3 required rules (TodoItemPriorityRule), 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <RequestRule>());
            rules.Add(RuleFactory.CreatePassedRule <ResponseRule>());
            yield return(new object[] { "Rules: 2 of 3 required rules (RequestRule, ResponseRule), 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <RequestRule>());
            rules.Add(RuleFactory.CreatePassedRule <TodoItemPriorityRule>());
            yield return(new object[] { "Rules: 2 of 3 required rules (RequestRule, TodoItemPriorityRule), 1 MockRule", rules });

            rules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
            rules.Add(RuleFactory.CreateMockSaveRule());
            rules.Add(RuleFactory.CreatePassedRule <ResponseRule>());
            rules.Add(RuleFactory.CreatePassedRule <TodoItemPriorityRule>());
            yield return(new object[] { "Rules: 2 of 3 required rules (ResponseRule, TodoItemPriorityRule), 1 MockRule", rules });
        }
        protected bool ApplyDeviceRules()
        {
            // for each device
            foreach (DeviceItem device in
                     Sitecore.Context.Database.Resources.Devices.GetAll())
            {
                // for each field of the device
                foreach (Field field in device.InnerItem.Fields)
                {
                    // ignore empty fields and fields of type other than rules.
                    if (field.TypeKey != "rules" || String.IsNullOrEmpty(field.Value))
                    {
                        continue;
                    }

                    // parse the rule definition XML in the field.
                    RuleList <SetContextDeviceRuleContext> rules =
                        new RuleList <SetContextDeviceRuleContext>();
                    rules.Name = field.Item.Paths.Path;
                    RuleList <SetContextDeviceRuleContext> parsed =
                        RuleFactory.ParseRules <SetContextDeviceRuleContext>(field.Database, field.Value);
                    rules.AddRange(parsed.Rules);

                    if (rules == null || rules.Count < 1)
                    {
                        continue;
                    }

                    // invoke the rule.
                    SetContextDeviceRuleContext ruleContext = new SetContextDeviceRuleContext(
                        device);
                    rules.Run(ruleContext);

                    // rule applied.
                    if (ruleContext.IsAborted)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
示例#27
0
        /// <summary>
        /// Returns rules of a landing workflow action.
        /// </summary>
        /// <param name="processorItem">
        /// The processor item.
        /// </param>
        /// <returns>
        /// Returns RuleList of landing workflow.
        /// </returns>
        protected RuleList <WorkflowRuleContext> BuildRuleList(ProcessorItem processorItem)
        {
            Assert.ArgumentNotNull(processorItem, "processorItem");
            Item actionItem = processorItem.InnerItem;
            RuleList <WorkflowRuleContext> ruleList = new RuleList <WorkflowRuleContext>();

            if (!string.IsNullOrEmpty(actionItem["Rule"]))
            {
                ruleList.AddRange(RuleFactory.GetRules <WorkflowRuleContext>(actionItem.Fields["Rule"]).Rules);
            }

            if (!string.IsNullOrEmpty(actionItem["Rules"]))
            {
                Item[] rules = ((MultilistField)actionItem.Fields["Rules"]).GetItems();
                ruleList.AddRange(RuleFactory.GetRules <WorkflowRuleContext>(rules, "Rule").Rules);
            }

            return(ruleList);
        }
示例#28
0
        public static bool EvaluateConditions <T>(this Item root, string field, T ruleContext)
            where T : RuleContext
        {
            var stack = new RuleStack();

            foreach (Rule <T> rule in RuleFactory.GetRules <T>(new[] { root }, field).Rules)
            {
                if (rule.Condition != null)
                {
                    rule.Condition.Evaluate(ruleContext, stack);

                    if (ruleContext.IsAborted)
                    {
                        continue;
                    }
                }
            }
            return(stack.Count != 0 && (bool)stack.Pop());
        }
        private PlaceholderSettingsRuleContext EvaluateRules(Item placeholder)
        {
            PlaceholderSettingsRuleContext ruleContext = new PlaceholderSettingsRuleContext();

            ruleContext.Item = _contextItem;
            foreach (Rule <PlaceholderSettingsRuleContext> rule in RuleFactory.GetRules <PlaceholderSettingsRuleContext>(new[] { placeholder }, AllowedModulesRulesField).Rules)
            {
                if (rule.Condition != null)
                {
                    var passed = rule.Evaluate(ruleContext);
                    if (passed)
                    {
                        rule.Execute(ruleContext);
                    }
                }
            }

            return(ruleContext);
        }
示例#30
0
        public override void Process(ProcessItemArgs args)
        {
            Assert.ArgumentNotNull((object)args, "args");

            var obj = Context.Item;
            if (obj == null)
                return;
            var parentItem = obj.Database.GetItem(Constants.ProcessItemRules);
            if (parentItem == null)
                return;
            var rules = RuleFactory.GetRules<RuleContext>(parentItem, "Rule");
            if (rules == null)
                return;
            var ruleContext = new RuleContext()
            {
                Item = obj
            };
            rules.Run(ruleContext);
        }
示例#31
0
        protected virtual IEnumerable <string> GetDataSoursesForLayout(Item pageItem, ID layoutFieldId)
        {
            if (pageItem == null)
            {
                return(Enumerable.Empty <string>());
            }

            var datasourses = new List <string>();

            var renderings = pageItem
                             .GetLayoutDefinition(layoutFieldId)?
                             .Devices?
                             .ToArray()?
                             .Select(x => (DeviceDefinition)x)?
                             .SelectMany(d => d.Renderings.Cast <RenderingDefinition>())?
                             .ToArray()
                             ?? new RenderingDefinition[0];

            foreach (var rendering in renderings)
            {
                datasourses.Add(rendering.Datasource);

                if (rendering.Rules != null && rendering.Rules.HasElements)
                {
                    var rules   = RuleFactory.ParseRules <ConditionalRenderingsRuleContext>(pageItem.Database, rendering.Rules);
                    var actions = rules.Rules?
                                  .SelectMany(x => x.Actions)
                                  .Select(x => x as SetDataSourceAction <ConditionalRenderingsRuleContext>)
                                  .Where(x => x != null)
                                  .ToArray();

                    foreach (var action in actions ?? Enumerable.Empty <SetDataSourceAction <ConditionalRenderingsRuleContext> >())
                    {
                        datasourses.Add(action.DataSource);
                    }
                }
            }

            return(datasourses
                   .Where(x => !string.IsNullOrWhiteSpace(x))
                   .Distinct()
                   .ToList());
        }