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;
}
