public void RunGlobalRules <T>(Item rulesFolder, T context) where T : EnhancedRuleContext
{
if (rulesFolder == null)
{
Log.SingleError("Rules folder not found:\r\n" + Environment.StackTrace, this);
return;
}
foreach (var ruleItem in rulesFolder.Axes.GetDescendants())
{
var ruleXml = ruleItem["Rule"];
if (string.IsNullOrWhiteSpace(ruleXml) || ruleItem["Disabled"] == "1")
{
continue;
}
var rules = new EnhancedRuleList <T>(RuleFactory.ParseRules <T>(ruleItem.Database, ruleXml).Rules);
rules.Run(context);
if (context.IsAborted)
{
break;
}
if (context.StopProcessingAfterThisRuleset)
{
context.StopProcessingAfterThisRuleset = false;
break;
}
}
}
// GET: ResortLocator
public ActionResult ResortSection()
{
DebugUtils.StartLogEvent("ResortController.ResortSection");
var model = GetLayoutItem <ResortSections>();
foreach (Models.Resort.Section section in model.AllSections)
{
bool showUsingRules = true;
if (section.InnerItem.Fields["{85B5A4F7-0974-4455-85FA-B33FFAF397E0}"] != null)
{
String rule = section.InnerItem.Fields["{85B5A4F7-0974-4455-85FA-B33FFAF397E0}"].Value;
if (!string.IsNullOrEmpty(rule))
{
var rules = RuleFactory.ParseRules <RuleContext>(section.InnerItem.Database, XElement.Parse(rule));
var ruleContext = new RuleContext()
{
Item = section.InnerItem
};
if (rule.Any() && rules.Rules.Count() > 0)
{
showUsingRules = rules.Rules.First().Evaluate(ruleContext);
}
}
}
section.HideSection = !showUsingRules;
DebugUtils.EndLogEvent("ResortController.ResortSection");
}
return(View(model));
}
public ActionResult OwnerProxySection()
{
var model = GetLayoutItem <OwnerProxySections>();
// var isValidVotingPeriod = Components.DBManager.isValidVotingPeriod();
//TODO mode this code in central place to evaluate rules
foreach (OwnerProxySection section in model.AllSections)
{
bool showUsingRules = true;
if (section.InnerItem.Fields["{85B5A4F7-0974-4455-85FA-B33FFAF397E0}"] != null)
{
string rule = section.InnerItem.Fields["{85B5A4F7-0974-4455-85FA-B33FFAF397E0}"].Value;
if (!string.IsNullOrEmpty(rule))
{
var rules = RuleFactory.ParseRules <RuleContext>(section.InnerItem.Database, XElement.Parse(rule));
var ruleContext = new RuleContext()
{
Item = section.InnerItem
};
if (rule.Any() && rules.Rules.Count() > 0)
{
showUsingRules = rules.Rules.First().Evaluate(ruleContext);
}
}
}
section.HideSection = !showUsingRules;
}
return(View(model));
}
public ActionResult RewardsSection()
{
var model = GetLayoutItem <RewardsSections>();
//TODO make it as Rule at later time
CheckForTravelerPlusMembershipAndRedirect(model);
//TODO mode this code in central place to evaluate rules
foreach (Models.Reward.Section section in model.AllSections)
{
bool showUsingRules = true;
if (section.InnerItem.Fields[BaseComponent.RestrictionRuleId] != null)
{
string rule = section.InnerItem.Fields[BaseComponent.RestrictionRuleId].Value;
if (!string.IsNullOrEmpty(rule))
{
var rules = RuleFactory.ParseRules <RuleContext>(section.InnerItem.Database, XElement.Parse(rule));
var ruleContext = new RuleContext()
{
Item = section.InnerItem
};
if (rule.Any() && rules.Rules.Count() > 0)
{
showUsingRules = rules.Rules.First().Evaluate(ruleContext);
}
}
}
section.HideSection = !showUsingRules;
//Evaluate Rules For any rich text If Any
if (section.AllRichText != null && section.AllRichText.Any())
{
List <RichText> allRichTextItems = section.AllRichText.Select(x => x).ToList();
section.AllRichText = FilterRichTextBasedOnRules(allRichTextItems);
}
// Evaluate Rules For any Section Gallery Items If Any
if (section.AllImages != null && section.AllImages.Any())
{
List <FeaturedItem> allGalleryImages = section.AllImages.Select(x => x).ToList();
section.AllImages = RemoveUnwantedImagesBasedOnRules(allGalleryImages);
}
// Evaluate Rules For any Section Featured Folder Items If Any
if (section.FolderWithFeaturedItems != null && section.FolderWithFeaturedItems.AllFeaturedItems.Any())
{
List <FeaturedItem> allFeaturedItems = section.FolderWithFeaturedItems.AllFeaturedItems.Select(x => x).ToList();
section.FolderWithFeaturedItems.AllFeaturedItems = RemoveUnwantedImagesBasedOnRules(allFeaturedItems);
}
}
return(View(model));
}
public ActionResult RedeemSection()
{
BlueGreenContext bgContext = new BlueGreenContext();
//Just make it Null always when page loads
if (Session["ConfirmedRewards"] != null)
{
Session["ConfirmedRewards"] = null;
}
var model = GetLayoutItem <RewardsSections>();
if (model != null)
{
model.cartItemsList = GetAllCartItems();
var encoreAvailRewards = (bgContext != null && bgContext.bxgOwner != null && bgContext.bxgOwner.EncoreBenefits != null) ? bgContext.bxgOwner.EncoreBenefits.DividendsBalance : 0;
model.CartTotal = new CartTotal()
{
AvailableRewards = encoreAvailRewards,
TotalRewardsinCart = (model.cartItemsList.Count > 0) ? model.cartItemsList.Select(t => t.SubTotal).Sum() : 0,
AvailablePoints = encoreAvailRewards - ((model.cartItemsList.Count > 0) ? model.cartItemsList.Select(t => t.SubTotal).Sum() : 0)
};
}
//TODO mode this code in central place to evaluate rules
foreach (Models.Reward.Section section in model.AllSections)
{
bool showUsingRules = true;
if (bgContext.bxgOwner != null)
{
section.MaintenanceFee = string.Format("{0:c}", bgContext.bxgOwner.PaymentBalance);
section.BalanceDue = string.Format("{0:c}", bgContext.bxgOwner.PaymentBalance);
}
if (section.InnerItem.Fields[BaseComponent.RestrictionRuleId] != null)
{
string rule = section.InnerItem.Fields[BaseComponent.RestrictionRuleId].Value;
if (!string.IsNullOrEmpty(rule))
{
var rules = RuleFactory.ParseRules <RuleContext>(section.InnerItem.Database, XElement.Parse(rule));
var ruleContext = new RuleContext()
{
Item = section.InnerItem
};
if (rule.Any() && rules.Rules.Count() > 0)
{
showUsingRules = rules.Rules.First().Evaluate(ruleContext);
}
}
}
section.HideSection = !showUsingRules;
}
return(View(model));
}
public static bool EvaluateRules(string strRules, RuleContext ruleContext, 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);
return(!rules.Rules.Any() || rules.Rules.Any(rule => rule.Evaluate(ruleContext)));
}
/// <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);
}
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);
}
/// <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 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);
}
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);
}
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)));
}
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);
}
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());
}
public bool Evaluate(ISerializableItem item)
{
var scDatabase = item.Database as ScDatabase;
if (scDatabase == null)
{
return(false);
}
if (!Enabled)
{
return(true);
}
var rules = RuleFactory.ParseRules <SerializationRuleContext>(scDatabase.InnerDatabase, Filter);
var context = new SerializationRuleContext {
SerializationDefinition = this
};
item.InitializeSerializationRuleContext(context);
return(rules.Rules.All(rule => rule.Evaluate(context)));
}
public static List <SearchRule <TContext> > ParseRules(ISitecoreService db, string p_RulesXml)
{
List <SearchRule <TContext> > list = new List <SearchRule <TContext> >();
if (!string.IsNullOrEmpty(p_RulesXml))
{
Dictionary <string, string> dictionary = ParseRuleNames(p_RulesXml);
foreach (Rule <TContext> rule in RuleFactory.ParseRules <TContext>(db.Database, p_RulesXml).Rules)
{
if (rule.Condition != null)
{
var p_Condition = SearchConditionFactory.GetCondition(rule.Condition);
string p_Id = rule.UniqueId.ToString();
list.Add(new SearchRule <TContext>(p_Id, dictionary[p_Id], p_Condition, rule.Actions));
}
}
}
return(list);
}
public ActionResult GetRightPanel()
{
var rightPanel = GetLayoutItem <RightPanel>();
foreach (RightSection section in rightPanel.RightSections)
{
bool showUsingRules = true;
if (section.InnerItem.Fields[BaseComponent.RestrictionRuleId] != null)
{
string rule = section.InnerItem.Fields[BaseComponent.RestrictionRuleId].Value;
if (!string.IsNullOrEmpty(rule))
{
var rules = RuleFactory.ParseRules <RuleContext>(section.InnerItem.Database, XElement.Parse(rule));
var ruleContext = new RuleContext()
{
Item = section.InnerItem
};
if (rule.Any() && rules.Rules.Count() > 0)
{
showUsingRules = rules.Rules.First().Evaluate(ruleContext);
}
}
}
section.HideSection = !showUsingRules;
if (showUsingRules)
{
BlueGreenContext bgContext = new BlueGreenContext();
if (bgContext != null && bgContext.bxgOwner != null && bgContext.IsAuthenticated)
{
int cartItemsQuantityCount = DBManager.GetAllCartItems(bgContext.bxgOwner.Arvact).AsEnumerable().Sum(x => x.Field <int>("Quantity"));
rightPanel.RewardCartItemCount = cartItemsQuantityCount;
}
else
{
rightPanel.RewardCartItemCount = 0;
}
}
}
return(View(rightPanel));
}
private IEnumerable <object> GetRules(XElement rules)
{
if (rules == null)
{
return(null);
}
var ruleList = RuleFactory.ParseRules <RuleContext>(database, rules);
var result = new List <object>();
foreach (var rule in ruleList.Rules)
{
result.Add(new
{
name = rule.Name,
uniqueId = rule.UniqueId.Guid
});
}
return(result);
}
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);
}
