public bool RunRule(Item outcomeItem) { if (outcomeItem == null) return false; string ruleXml = outcomeItem[RulesField]; if (String.IsNullOrEmpty(ruleXml)) return false; RuleList<RuleContext> rules = new RuleList<RuleContext> { Name = outcomeItem.Paths.Path }; RuleList<RuleContext> parsed = RuleFactory.ParseRules<RuleContext>( Context.Database, ruleXml); rules.AddRange(parsed.Rules); if (rules.Count < 1) return false; RuleContext ruleContext = new RuleContext { Item = Context.Item }; ruleContext.Parameters.Add("DefinitionItem",outcomeItem); rules.Run(ruleContext); return ruleContext.IsAborted; }
/// <summary> /// Invoke global device resolution rules. /// </summary> /// <returns>True if a global device resolution rule applied.</returns> protected bool RunModuleRules() { Item moduleRuleItem = Context.Database.GetItem("{143624D2-7C7F-460A-B97E-068283D646B9}"); if (moduleRuleItem == null) return false; string ruleXml = moduleRuleItem["Rule"]; if (String.IsNullOrEmpty(ruleXml) || moduleRuleItem["Disable"] == "1") return false; // parse the rule XML RuleList<RuleContext> rules = new RuleList<RuleContext> {Name = moduleRuleItem.Paths.Path}; RuleList<RuleContext> parsed = RuleFactory.ParseRules<RuleContext>( Context.Database, ruleXml); rules.AddRange(parsed.Rules); if (rules.Count < 1) return false; // invoke the rule RuleContext ruleContext = new RuleContext {Item = Context.Item}; rules.Run(ruleContext); // rule applied return ruleContext.IsAborted; }
protected override void Evaluate(Sitecore.Pipelines.InsertRenderings.InsertRenderingsArgs args, Sitecore.Data.Items.Item item) { RuleList <ConditionalRenderingsRuleContext> globalRules = this.GetGlobalRules(item); foreach (RenderingReference reference in new List <RenderingReference>((IEnumerable <RenderingReference>)args.Renderings)) { string conditions = reference.Settings.Conditions; if (!string.IsNullOrEmpty(conditions)) { List <Item> conditionItems = this.GetConditionItems(item.Database, conditions); if (conditionItems.Count > 0) { RuleList <ConditionalRenderingsRuleContext> rules = RuleFactory.GetRules <ConditionalRenderingsRuleContext>((IEnumerable <Item>)conditionItems, "Rule"); ConditionalRenderingsRuleContext renderingsRuleContext = new ConditionalRenderingsRuleContext(args.Renderings, reference); renderingsRuleContext.Item = item; ConditionalRenderingsRuleContext ruleContext = renderingsRuleContext; rules.Run(ruleContext); } } if (globalRules != null) { ConditionalRenderingsRuleContext renderingsRuleContext = new ConditionalRenderingsRuleContext(args.Renderings, reference); renderingsRuleContext.Item = item; ConditionalRenderingsRuleContext ruleContext = renderingsRuleContext; globalRules.Run(ruleContext); } GetCustomRules(args, item, reference); } }
/// <summary> Gets item renderings </summary> /// <param name="item">item to proceed</param> /// <returns>list of item renderings</returns> protected List <RenderingReference> GetRenderings(Item item) { RuleList <ConditionalRenderingsRuleContext> globalRules = this.GetGlobalRules(item); List <RenderingReference> resultCollection = new List <RenderingReference>(item.Visualization.GetRenderings(Sitecore.Context.Device, true)); foreach (RenderingReference reference in new List <RenderingReference>(resultCollection)) { string conditions = reference.Settings.Conditions; if (!string.IsNullOrEmpty(conditions)) { List <Item> conditionItems = this.GetConditionItems(item.Database, conditions); if (conditionItems.Count > 0) { RuleList <ConditionalRenderingsRuleContext> rules = RuleFactory.GetRules <ConditionalRenderingsRuleContext>(conditionItems, "Rule"); ConditionalRenderingsRuleContext ruleContext = new ConditionalRenderingsRuleContext(resultCollection, reference) { Item = item }; rules.Run(ruleContext); } } if (globalRules != null) { ConditionalRenderingsRuleContext globalRuleContext = new ConditionalRenderingsRuleContext(resultCollection, reference) { Item = item }; globalRules.Run(globalRuleContext); } } return(resultCollection); }
public bool Include(object item) { var visit = (item as IVisitAggregationContext).TryGet(v => v.Visit); if (visit != null) { var tracker = _trackerFactory(visit); TrackerSwitcher.Enter(tracker); try { var rulesContext = new RuleContext(); rulesContext.Item = RuleContextItem; _rules.Run(rulesContext); object addToSegment; var include = !rulesContext.IsAborted && rulesContext.Parameters.TryGetValue("addVisit", out addToSegment) && (bool)addToSegment; return(include); } finally { if (Tracker.Current == tracker) { TrackerSwitcher.Exit(); } } } return(false); }
public void RunEventRules(string eventName, Item pageItem = null, params string[] values) { Assert.IsNotNullOrEmpty(eventName, $"{nameof(RulesService)}.{nameof(RunEventRules)} parameter {nameof(eventName)} is required"); var ruleContext = new EventRuleContext() { EventName = eventName, Item = pageItem, Value1 = ParamUtil.GetValue(1, values), Value2 = ParamUtil.GetValue(2, values), Value3 = ParamUtil.GetValue(3, values) }; // Run Global Rules using (new SecurityDisabler()) { var root = Utils.ItemUtil.GetItemById(ItemIds.GlobalRules.EventRules); if (root == null) { return; // no root, exit } RuleList <EventRuleContext> rules = RuleFactory.GetRules <EventRuleContext>(root, "Rule"); if (rules != null) { rules.Run(ruleContext); } } }
public void OnItemAdded(object sender, EventArgs args) { var addedItem = ExtractItem(args); if (addedItem == null) { return; } var rulesFolderId = ID.Parse(ItemAddedRulesConstants.ItemAddedRules.ItemId); var itemAddedRules = addedItem.Database.GetItem(rulesFolderId); if (itemAddedRules == null) { return; } var ruleContext = new RuleContext(); ruleContext.Item = addedItem; RuleList <RuleContext> rules = RuleFactory.GetRules <RuleContext>(itemAddedRules, "Rule"); if (rules.Count > 0) { rules.Run(ruleContext); } }
private static void RunPromoRule(Sitecore.Pipelines.InsertRenderings.InsertRenderingsArgs args, Sitecore.Data.Items.Item item, RenderingReference reference, Item promo, string fieldName) { if (promo != null && !string.IsNullOrEmpty(fieldName)) { RuleList <ConditionalRenderingsRuleContext> rules = RuleFactory.GetRules <ConditionalRenderingsRuleContext>(promo.Fields[fieldName]); var ruleContext = new ConditionalRenderingsRuleContext(args.Renderings, reference); ruleContext.Item = item; rules.Run(ruleContext); } }
protected override ValidatorResult Evaluate() { Item item = this.GetItem(); Item validatorItem = item?.Database.GetItem(ValidatorID); if (validatorItem == null) { return(ValidatorResult.Valid); } RuleList <ValidatorsRuleContext> ruleList = (!validatorItem.HasChildren ? RuleFactory.GetRules <ValidatorsRuleContext>(validatorItem.Fields["Rule"]) : RuleFactory.GetRules <ValidatorsRuleContext>(validatorItem, "Rule")); if (ruleList == null) { return(ValidatorResult.Valid); } // -------------------------------------------------------- // ** Begin Customization // Force update certain fields from the values in the Content Editor even if they were standard values when loaded from the database string[] fieldIds = validatorItem.Fields["Load Fields"]?.Value.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries); if (fieldIds != null) { foreach (string fieldId in fieldIds) { Field field = item.Fields[fieldId]; if (field != null) { this.UpdateField(field); } } } // ** End Customization // -------------------------------------------------------- var validatorsRuleContext = new ValidatorsRuleContext { Item = item, Validator = this, Result = ValidatorResult.Valid, Text = string.Empty }; ruleList.Run(validatorsRuleContext); if (validatorsRuleContext.Result == ValidatorResult.Valid) { return(ValidatorResult.Valid); } this.Text = this.GetText(validatorsRuleContext.Text, item.DisplayName); return(GetFailedResult(validatorsRuleContext.Result)); }
protected override RenderingReference DoActivateCondition(RenderingDefinition rendering, ID conditionID, Language lang, Database database, Item item, SiteContext site) { // Copied from Sitecore Assert.ArgumentNotNull(rendering, "rendering"); Assert.ArgumentNotNull(conditionID, "conditionID"); Assert.ArgumentNotNull(lang, "lang"); Assert.ArgumentNotNull(database, "database"); Assert.ArgumentNotNull(item, "item"); Assert.ArgumentNotNull(site, "site"); RenderingReference renderingReference = new RenderingReference(rendering, lang, database); RuleList <ConditionalRenderingsRuleContext> rules = renderingReference.Settings.Rules; Rule <ConditionalRenderingsRuleContext> rule = rules.Rules.FirstOrDefault <Rule <ConditionalRenderingsRuleContext> >((Rule <ConditionalRenderingsRuleContext> r) => r.UniqueId == conditionID); if (rule == null) { return(renderingReference); } List <RenderingReference> renderingReferences = new List <RenderingReference>() { renderingReference }; ConditionalRenderingsRuleContext conditionalRenderingsRuleContext = new ConditionalRenderingsRuleContext(renderingReferences, renderingReference) { Item = item }; rule.SetCondition(new TrueCondition <ConditionalRenderingsRuleContext>()); rules = new RuleList <ConditionalRenderingsRuleContext>(rule); using (SiteContextSwitcher siteContextSwitcher = new SiteContextSwitcher(site)) { using (DatabaseSwitcher databaseSwitcher = new DatabaseSwitcher(item.Database)) { rules.Run(conditionalRenderingsRuleContext); } } Assert.IsTrue(conditionalRenderingsRuleContext.References.Count == 1, "The references count should equal 1"); RenderingReference renderingReference1 = conditionalRenderingsRuleContext.References[0]; Assert.IsNotNull(renderingReference1, "result"); rendering.Datasource = renderingReference1.Settings.DataSource; if (renderingReference1.RenderingItem != null) { rendering.ItemID = renderingReference1.RenderingItem.ID.ToString(); } // End copied from Sitecore // Apply Parameters Too rendering.Parameters = renderingReference1.Settings.Parameters; return(renderingReference1); }
public void RunProgram_r(RuleList <DesignBotRuleContext> rules, Item page, int depth) { if (depth < 0 || page == null) { return; } // skip datasource items if (page.TemplateID.Equals(SxaDataTemplateId)) { return; } BotLog.Log.Info($"Processing item {page.DisplayName}, {page.ID}..."); Log.Info($"DESIGNBOT:: Processing item {page.DisplayName}, {page.ID}...", this); try { var ruleContext = new DesignBotRuleContext(page); // Run conditions and actions rules.Run(ruleContext); if (ruleContext.HasLayoutChange) { // Create new version for easy undo (delete version) page = page.AsNewVersion(matchWorkflowState: true); ItemUtil.SetLayoutDetails(page, ruleContext.SharedLayout.ToXml(), ruleContext.FinalLayout.ToXml()); } } catch (Exception ex) { BotLog.Log.Error($"Error applying program to item {page?.ID}", ex); Log.Error($"DESIGNBOT:: Error applying program to item {page?.ID}", ex, this); } // Recursion depth--; if (depth < 0 || !page.HasChildren) { return; } var children = page.GetChildren(); foreach (Item child in children) { RunProgram_r(rules, child, depth); } }
/// <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); }
/// <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); }
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); }
public override void Process(DetermineChannelProcessorArgs args) { Assert.ArgumentNotNull(args, "args"); // Define context var ruleContext = new ChannelRulesContext() { ChannelId = null, Item = Sitecore.Context.Item }; Item ChannelRulesRoot; // Set root using (new SecurityDisabler()) { var db = Sitecore.Context.ContentDatabase??Sitecore.Context.Database; ChannelRulesRoot = db?.GetItem(RootId); if (ChannelRulesRoot == null) return; // no root, exit } RuleList<ChannelRulesContext> rules = RuleFactory.GetRules<ChannelRulesContext>(ChannelRulesRoot, "Rule");//"Rule" is the field name if (rules != null) { // Run rules rules.Run(ruleContext); } if (ruleContext.ChannelId != (ID)null) { args.ChannelId = ruleContext.ChannelId; args.AbortPipeline(); } }
public bool RunRule(Item outcomeItem) { if (outcomeItem == null) { return(false); } string ruleXml = outcomeItem[RulesField]; if (String.IsNullOrEmpty(ruleXml)) { return(false); } RuleList <RuleContext> rules = new RuleList <RuleContext> { Name = outcomeItem.Paths.Path }; RuleList <RuleContext> parsed = RuleFactory.ParseRules <RuleContext>( Context.Database, ruleXml); rules.AddRange(parsed.Rules); if (rules.Count < 1) { return(false); } RuleContext ruleContext = new RuleContext { Item = Context.Item }; ruleContext.Parameters.Add("DefinitionItem", outcomeItem); rules.Run(ruleContext); return(ruleContext.IsAborted); }
/// <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; }