public void ReturnsFalseForNullQuery() { using (var db = new Db() { new DbItem("page1"), new DbItem("page2") }) { var page1 = db.GetItem("/sitecore/content/page1"); var args = new GetLookupSourceItemsArgs() { Item = page1 }; var context = new GetLookupsourceItemsRuleContext(args); var condition = new QueryContainsTokenCondition <GetLookupsourceItemsRuleContext>() { Token = "ItemField" }; var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(false); } }
public void MatchesToken() { using (var db = new Db() { new DbItem("page1"), new DbItem("page2") }) { var page1 = db.GetItem("/sitecore/content/page1"); var page2 = db.GetItem("/sitecore/content/page2"); var args = new GetLookupSourceItemsArgs() { Item = page1, Source = "{Home}/page1" }; var context = new GetLookupsourceItemsRuleContext(args); var condition = new QueryContainsTokenCondition <GetLookupsourceItemsRuleContext>() { Token = "Home" }; var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(true); } }
public Expression <Func <SearchResultItem, bool> > GetPredicatesFromRules(IProviderSearchContext context, string rawRules, Database db) { Assert.ArgumentNotNull(db, nameof(db)); var expression = PredicateBuilder.True <SearchResultItem>(); Sitecore.ContentSearch.Rules.QueryableRuleFactory ruleFactory = new Sitecore.ContentSearch.Rules.QueryableRuleFactory(); var rules = ruleFactory.ParseRules <Sitecore.ContentSearch.Rules.QueryableRuleContext <SearchResultItem> >(db, rawRules); if (!rules.Rules.Any()) { return(null); } foreach (var rule in rules.Rules) { if (rule.Condition != null) { var ruleContext = new Sitecore.ContentSearch.Rules.QueryableRuleContext <SearchResultItem>(context); var stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); rule.Execute(ruleContext); if (stack.Any()) { expression = ruleContext.Where; } } } return(expression); }
public static string GenerateMetaTags() { StringBuilder sb = new StringBuilder(); RuleStack stack = new RuleStack(); var references = Sitecore.Context.Item.Visualization.GetRenderings(Sitecore.Context.Device, false); try { foreach (RenderingReference reference in references) { ConditionalRenderingsRuleContext context = new ConditionalRenderingsRuleContext(references.ToList(), reference); foreach (Rule <ConditionalRenderingsRuleContext> rule in reference.Settings.Rules.Rules) { rule.Condition.Evaluate(context, stack); if ((stack.Count != 0) && (bool)stack.Pop() && rule.UniqueId != ID.Null) { sb.Append(",").Append(rule.Name); break; } } } } catch (Exception e) { Log.Warn("Problem aggregating rules for personalization context, metatag may be incorrect", e, e); } return(sb.Length > 0 ? $@"<meta name=""sitecorePersonalization"" content=""{sb.ToString(1, sb.Length - 1)}"">" : ""); }
static void ProcessSinglePatient(int id) { //DbMapper db = new DbMapper(); LocalDb db = new LocalDb(); Patient p = new Patient(); p = db.GetPatientTSD(id); Console.WriteLine("Patient : {0}", p.ToString()); Console.WriteLine("Patient result count: {0}", p.TSDataPoints.Count()); RuleStack rs = new RuleStack(); rs.Execute(p); Console.WriteLine("Age calc done: {3},Patient Age: {0}, Invalid Age Flag:{1}, Alive: {2}", p.Age, p.Status.FlagInvalidAge, p.Status.Alive, p.Status.FlagCalculatedAge); foreach (var n in p.Notifications) { Console.WriteLine("--> {0}: {1} |", n.TimeStamp, n.Message); } Console.WriteLine("--------------------------------------------------"); // rules //write back to reporting //db.InsertPatientReport(p); }
public void DoesUserAgentContainValueCondition(string userAgent, string containsUserAgentValue, bool expectedResult, Db database) { SetupDb(database); RuleContext ruleContext = new RuleContext(); PoorMansDeviceDetectorCondition<RuleContext> customUserAgentCondition = new PoorMansDeviceDetectorCondition<RuleContext>() { OperatorId = Constants.StringOperations.Contains.ItemID.ToString(), Value = containsUserAgentValue, UserAgent = userAgent }; var ruleStack = new RuleStack(); // act customUserAgentCondition.Evaluate(ruleContext, ruleStack); // assert ruleStack.Should().HaveCount(1); object value = ruleStack.Pop(); value.Should().Be(expectedResult); }
public void MatchesTargetId() { var sourceRenderingId = ID.NewID; var targetRenderingId = ID.NewID; using (var db = new Db { new DbItem("rendering", targetRenderingId) }) { var targetRenderingItem = db.GetItem(targetRenderingId); var context = new ReplaceRenderingRuleContext(new RenderingDefinition() { ItemID = sourceRenderingId.ToString() }, targetRenderingItem, new DeviceDefinition()); var condition = new TargetRenderingIsAnyOfCondition <ReplaceRenderingRuleContext> { CompareRenderingItemIds = targetRenderingId.ToString() }; var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(true); } }
public void FailsButDoesNotErrorWhenCompareIdNotSet() { var sourceRenderingId = ID.NewID; var targetRenderingId = ID.NewID; using (var db = new Db { new DbItem("rendering", targetRenderingId) }) { var targetRenderingItem = db.GetItem(targetRenderingId); var context = new ReplaceRenderingRuleContext(new RenderingDefinition() { ItemID = sourceRenderingId.ToString() }, targetRenderingItem, new DeviceDefinition()); var condition = new TargetRenderingIsAnyOfCondition <ReplaceRenderingRuleContext>(); var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(false); } }
/// <summary> /// runs the set of rules and checks for any matches, if it finds a match it will run the rule's associated action /// </summary> /// <param name="root">Item which holds the field</param> /// <param name="field">the rule field name</param> /// <param name="ruleContext"></param> /// <returns></returns> public static void RunRules <T>(this Item root, string field, T ruleContext) where T : RuleContext { foreach (Rule <T> rule in RuleFactory.GetRules <T>(new[] { root }, field).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); } } else { rule.Execute(ruleContext); } } }
/// <summary> /// Gets the rules device. /// </summary> /// <param name="database">The database.</param> /// <returns>Resolved device</returns> private static DeviceItem GetRulesDevice(Database database) { DeviceItem[] all = database.Resources.Devices.GetAll(); foreach (var device in all) { var ruleContext = new RuleContext(); var rules = RuleFactory.GetRules <RuleContext>( device.InnerItem, "Conditions").Rules; foreach (Rule <RuleContext> rule in 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())) { return(device); } } } } return(null); }
private static DeviceItem ExecuteDeviceConditions() { var devices = Context.Database.Resources.Devices.GetAll(); foreach (var device in devices) { var ruleContext = new RuleContext(); foreach (var rule in RuleFactory.GetRules <RuleContext>(new[] { device.InnerItem }, "Rule").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())) { return(device); } } } } return(null); }
private void CheckForRulesMatch(Database db, string domain, string requestedUrl, string requestedPathAndQuery, HttpRequestArgs args) { // Loop through the pattern match items to find a match foreach (Item possibleRedirectRule in GetRedirects(db, domain, Constants.Templates.RedirectRule, Constants.Templates.VersionedRedirectRule, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch))) { var ruleContext = new RuleContext(); ruleContext.Parameters.Add("newUrl", requestedUrl); foreach (Rule <RuleContext> rule in RuleFactory.GetRules <RuleContext>((IEnumerable <Item>) new Item[1] { possibleRedirectRule }, "Redirect Rule").Rules) { if (rule.Condition != null) { RuleStack stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (!ruleContext.IsAborted && (stack.Count != 0 && (bool)stack.Pop())) { foreach (var action in rule.Actions) { action.Apply(ruleContext); } } } } if (ruleContext.Parameters["newUrl"] != null && ruleContext.Parameters["newUrl"].ToString() != string.Empty && ruleContext.Parameters["newUrl"].ToString() != requestedUrl) { var responseStatus = GetResponseStatus(possibleRedirectRule); // The query string will be in the URL already, so don't break it apart. SendResponse(ruleContext.Parameters["newUrl"].ToString(), string.Empty, responseStatus, args); } } }
public void DetectsItemFieldTokenWithoutFieldName() { using (var db = new Db() { new DbItem("page1"), new DbItem("page2") }) { var page1 = db.GetItem("/sitecore/content/page1"); var args = new GetLookupSourceItemsArgs() { Item = page1, Source = "{ItemField:FullName}" }; var context = new GetLookupsourceItemsRuleContext(args); var condition = new QueryContainsTokenCondition <GetLookupsourceItemsRuleContext>() { Token = "ItemField" }; var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(true); } }
public TrackingField Evaluate(Item mapItem, Item contextItem) { var context = new RuleContext { Item = contextItem }; foreach (Rule <RuleContext> rule in RuleFactory.GetRules <RuleContext>(new[] { mapItem }, Templates.RulesProfileMap.Fields.Rules.ToString()).Rules) { if (rule.Condition != null) { var stack = new RuleStack(); rule.Condition.Evaluate(context, stack); if (context.IsAborted) { continue; } if ((stack.Count != 0) && ((bool)stack.Pop())) { return(GetTrackingField(mapItem)); } } } return(null); }
public override void Evaluate([CanBeNull] object parameter, [NotNull] RuleStack stack) { Assert.ArgumentNotNull(parameter, nameof(parameter)); Assert.ArgumentNotNull(stack, nameof(stack)); LeftOperand.Evaluate(parameter, stack); RightOperand.Evaluate(parameter, stack); }
public override void Evaluate([CanBeNull] object parameter, [NotNull] RuleStack stack) { Assert.ArgumentNotNull(stack, nameof(stack)); Operand.Evaluate(parameter, stack); var result = (bool)stack.Pop(); stack.Push(!result); }
protected virtual RuleCondition <T> GetCondition(T ruleContext, RuleStack stack) { var type = GetDataType(ruleContext); if (type == null) { return(null); } var condition = AdaptiveManager.Provider.GetRuleCondition <T>(type, this, ruleContext); return(condition); }
public override void Evaluate(T ruleContext, RuleStack stack) { var condition = GetCondition(ruleContext, stack); if (condition == null) { stack.Push(false); return; } condition.UniqueId = this.UniqueId; condition.Evaluate(ruleContext, stack); }
public static bool EvaluateSingleRule(Rule<RuleContext> rule, RuleContext ruleContext) { if (rule.Condition == null) return true; var stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (ruleContext.IsAborted) { return false; } return (stack.Count != 0) && ((bool)stack.Pop()); }
public override void Evaluate(T ruleContext, RuleStack stack) { var predicate = GetPredicate(ruleContext); if (predicate == null) { this.ApplyFilter(ruleContext, (Expression <Func <IndexedContact, bool> >)(c => false)); stack.Push(false); return; } this.ApplyFilter(ruleContext, predicate); stack.Push(true); }
/// <summary> /// Gets the rules device. /// </summary> /// <param name="database">The database.</param> /// <returns>Resolved device</returns> private static DeviceItem GetRulesDevice(Database database) { const string defaultLanguageName = "en"; var savedLanguage = Context.Language; if (savedLanguage.Name != defaultLanguageName) { Context.Language = LanguageManager.GetLanguage(defaultLanguageName); } DeviceItem[] all = database.Resources.Devices.GetAll(); foreach (var device in all) { var ruleContext = new RuleContext(); foreach (Rule <RuleContext> rule in RuleFactory.GetRules <RuleContext>(new[] { device.InnerItem }, "Conditions").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())) { if (savedLanguage.Name != defaultLanguageName) { Context.Language = savedLanguage; } return(device); } } } } if (savedLanguage.Name != defaultLanguageName) { Context.Language = savedLanguage; } return(null); }
public static bool ValidateRule(RuleList<RuleContext> rules, Item ruleItem, Item checkItem) { var ruleContext = new RuleContext { Item = checkItem }; var result = false; using ( new LongRunningOperationWatcher(Settings.Profiling.RenderFieldThreshold, "Long running rule set: {0}", new string[1] { ruleItem.Name ?? string.Empty })) { foreach (var rule in rules.Rules) { if (rule.Condition == null) continue; var stack = new RuleStack(); try { rule.Condition.Evaluate(ruleContext, stack); } catch (Exception ex) { Log.Error( string.Format("Evaluation of condition failed. Rule item ID: {0}, condition item ID: {1}", rule.UniqueId != (ID)null ? rule.UniqueId.ToString() : "Unknown", rule.Condition.UniqueId != ID.Null.ToString() ? rule.Condition.UniqueId : "Unknown"), ex, typeof(RuleProcessor)); ruleContext.Abort(); } if (ruleContext.IsAborted) break; if (stack.Count != 0 && (bool)stack.Pop()) result = true; else { result = false; break; } } } return result; }
public override void Evaluate([CanBeNull] object parameter, [NotNull] RuleStack stack) { Assert.ArgumentNotNull(stack, nameof(stack)); LeftOperand.Evaluate(parameter, stack); var left = (bool)stack.Pop(); if (!left) { stack.Push(false); return; } RightOperand.Evaluate(parameter, stack); }
private void Evaluate(XmlTextWriter output, Item item, XElement root, RuleList <RuleContext> ruleList) { var ruleContext = new RuleContext { Item = item }; var index = 0; foreach (var rule in ruleList.Rules) { var ruleElement = root.Element(index); index++; output.WriteElementString("entry", string.Format("Evaluating rule {0} of {1}.", index, ruleList.Rules.Count())); if (rule.Condition == null) { output.WriteElementString("entry", string.Format(" There are no conditions and the rule is skipped.", index)); continue; } output.WriteElementString("entry", " Evaluating conditions"); var stack = new RuleStack(); var conditionsElement = ruleElement.Element("conditions"); Evaluate(output, rule.Condition, ruleContext, stack, item.Database, conditionsElement.Element(0)); if (ruleContext.IsAborted) { output.WriteElementString("entry", string.Format(" Evaluation is aborted by a condition.", index)); break; } var result = stack.Count != 0 && (bool)stack.Pop(); output.WriteElementString("entry", string.Format(" The evaluation result is {0}.", result ? "True" : "False")); if (result) { RenderActions(output, item, ruleElement, 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 EvaluateSingleRule(Rule <RuleContext> rule, RuleContext ruleContext) { if (rule.Condition == null) { return(true); } var stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (ruleContext.IsAborted) { return(false); } return((stack.Count != 0) && ((bool)stack.Pop())); }
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()); }
public void StartTurn(Game game) { foreach (var card in PlayedCards) { if (card.Card is IDuration d) { d.NumberOfTurnsActive++; foreach (var ability in d.GetOnTurnStartAbilities(d.NumberOfTurnsActive)) { RuleStack.Push(ability); } } } NumberOfActions = 1; NumberOfBuys = 1; MoneyPlayed = 0; PlayStatus = HasActionInHand() ? PlayStatus.ActionPhase : PlayStatus.BuyPhase; }
public static Expression <Func <SearchResultItem, bool> > ProcessQueryRules(IProviderSearchContext context, string queryFilter, SearchOperation operation) { var predicate = operation == SearchOperation.Or ? PredicateBuilder.False <SearchResultItem>() : PredicateBuilder.True <SearchResultItem>(); var crawler = context.Index.Crawlers.FirstOrDefault(c => c is SitecoreItemCrawler); if (crawler == null) { return(predicate); } var database = ((SitecoreItemCrawler)crawler).Database; if (string.IsNullOrEmpty(database)) { return(predicate); } var ruleFactory = new Sitecore.ContentSearch.Rules.QueryableRuleFactory(); var rules = ruleFactory.ParseRules <Sitecore.ContentSearch.Rules.QueryableRuleContext <SearchResultItem> >(Factory.GetDatabase(database), queryFilter); foreach (var rule in rules.Rules) { if (rule.Condition == null) { continue; } var ruleContext = new Sitecore.ContentSearch.Rules.QueryableRuleContext <SearchResultItem>(context); var stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); rule.Execute(ruleContext); if (stack.Any()) { predicate = ruleContext.Where; } } return(predicate); }
public bool Evaluate([CanBeNull] object ruleContext) { var c = Condition; if (c == null) { return(true); } var stack = new RuleStack(); c.Evaluate(ruleContext, stack); if (stack.Count == 0) { return(false); } return((bool)stack.Pop()); }
///<summary> /// runs the set of rules and checks for any matches, if it finds a match it will run the rule's associated action /// </summary> /// <param name="ruleContext">Rule context that holds log parameters</param> /// <returns></returns> public static void RunRules(LoggerRuleContext ruleContext) { using (new SecurityDisabler()) { Item rootRulesFolder = webDb.GetItem(Constants.IDs.RulesRootFolderId); if (rootRulesFolder == null) { return; } var rulesItems = rootRulesFolder.Children.Where(i => i.TemplateID.Equals(Constants.Templates.LoggingRule)); if (!rulesItems.Any()) { return; } foreach (var ruleItem in rulesItems) { foreach (Rule <LoggerRuleContext> rule in RuleFactory.GetRules <LoggerRuleContext>(new[] { ruleItem }, Constants.Fields.Rule).Rules) { ruleContext.ItemId = ruleItem.ID; 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); } } else { rule.Execute(ruleContext); } } } } }
//this may need to be updated for future triggered abilities //this only works for simple triggered abilities public void RunTriggeredAbilities(PlayerAction playerAction, Card card) { foreach (var triggeredAbility in TriggeredAbilities.ToList()) { if (triggeredAbility.Trigger.IsMet(playerAction, card)) { if (triggeredAbility.TriggeredAbilityDurationType != TriggeredAbilityDurationType.Once) { triggeredAbility.Ability.Resolved = false; } RuleStack.Push(triggeredAbility.Ability); //we may not need this since resolved abilities won't play 2 times anyway // if (triggeredAbility.TriggeredAbilityDurationType == TriggeredAbilityDurationType.Once) // { // TriggeredAbilities.Remove(triggeredAbility); // } } } }
public void ExecCorrectlyDetectsChild(string parentPath, string childPath, bool expectedResult, string message) { using (var db = GetFakeDb()) { var item = db.GetItem(childPath); var root = db.GetItem(parentPath); var context = new RuleContext { Item = item }; var condition = new IsDescendentOfCondition <RuleContext> { PotentialParent = root }; var ruleStack = new RuleStack(); condition.Evaluate(context, ruleStack); ruleStack.Should().HaveCount(1); ruleStack.Pop().Should().Be(expectedResult, message); } }
private bool SatisfiesConditions(RuleList<RuleContext> ruleList, RuleContext ruleContext) { foreach (Rule<RuleContext> rule in ruleList.Rules) { if (rule.Condition == null) continue; RuleStack stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (ruleContext.IsAborted) continue; if (stack.Count == 0) continue; if (!(bool)stack.Pop()) continue; return true; } return false; }
private List<ActionResponse> GetActionResponses(Item rootItem, string selectedValue) { List<ActionResponse> actions = new List<ActionResponse>(); if (rootItem != null) { Item[] fieldListWithSection = rootItem.Axes.GetDescendants(); List<Item> allDescendants = new List<Item>(); //Doing that in case of sections foreach (Item item in fieldListWithSection) { allDescendants.AddRange(item.Children); } allDescendants.AddRange(fieldListWithSection); foreach (Item fieldItem in allDescendants) { RuleContext ruleContext = new RuleContext(); IEnumerable<Rule<RuleContext>> rules = RuleFactory.GetRules<RuleContext>(new[] { fieldItem }, "Rules").Rules; foreach (Rule<RuleContext> rule in rules) { // Adding selectedValue every time so condition gets value, // also when AND-condition or OR-condition added by user in Rule Editor. // Since AND-condition or OR-condition puts Custom Conditions in nesting object hierarchy ruleContext.Parameters.Add("selectedValue", selectedValue); RuleStack stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (ruleContext.IsAborted) { continue; } string fieldClass = fieldItem.Name; ControlType controlType = fieldItem.TemplateID == Constants.WffmSectionTemplateId ? ControlType.Section : ControlType.Field; if (controlType == ControlType.Section) { Item firstCildItem = fieldItem.Children.FirstOrDefault(); if (firstCildItem != null) { fieldClass = firstCildItem.Name; } } if (rule.Condition.GetType() == typeof(ConditionalHide<RuleContext>)) { ConditionalHide<RuleContext> condHide = (ConditionalHide<RuleContext>)rule.Condition; SessionUtil.SetSessionValue(condHide.SessionVariable, selectedValue); } var resultFromConditionExecution = (stack.Count != 0) && ((bool)stack.Pop()); actions.Add(new ActionResponse { ControlType = controlType, CssClassSelector = fieldClass.Replace(" ", "+"), HideControl = resultFromConditionExecution }); if (resultFromConditionExecution) { rule.Execute(ruleContext); } } } } return actions; }
private void CheckForRulesMatch(Database db, string requestedUrl, string requestedPathAndQuery, HttpRequestArgs args) { // Loop through the pattern match items to find a match foreach (Item possibleRedirectRule in GetRedirects(db, Constants.Templates.RedirectRule, Constants.Templates.VersionedRedirectRule, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch))) { var ruleContext = new RuleContext(); ruleContext.Parameters.Add("newUrl", requestedUrl); foreach (Rule<RuleContext> rule in RuleFactory.GetRules<RuleContext>((IEnumerable<Item>)new Item[1] { possibleRedirectRule }, "Redirect Rule").Rules) { if (rule.Condition != null) { RuleStack stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (!ruleContext.IsAborted && (stack.Count != 0 && (bool)stack.Pop())) { foreach (var action in rule.Actions) { action.Apply(ruleContext); } } } } if (ruleContext.Parameters["newUrl"] != null && ruleContext.Parameters["newUrl"].ToString() != string.Empty && ruleContext.Parameters["newUrl"].ToString() != requestedUrl) { var responseStatus = GetResponseStatus(possibleRedirectRule); // The query string will be in the URL already, so don't break it apart. SendResponse(ruleContext.Parameters["newUrl"].ToString(), string.Empty, responseStatus, args); } } }
/// <summary> /// Gets the rules device. /// </summary> /// <param name="database">The database.</param> /// <returns>Resolved device</returns> private static DeviceItem GetRulesDevice(Database database) { DeviceItem[] all = database.Resources.Devices.GetAll(); foreach (var device in all) { var ruleContext = new RuleContext(); foreach (Rule<RuleContext> rule in RuleFactory.GetRules<RuleContext>(new[] { device.InnerItem }, "Conditions").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())) { return device; } } } } return null; }
/// <summary> /// Evaluates if rule is active. /// </summary> /// <param name="ruleItem">The rule item.</param> /// <param name="contextItem">The context item.</param> /// <returns></returns> private static bool RuleIsActive(Item ruleItem, Item contextItem) { var personaHelper = PersonaHelper.GetHelper(); personaHelper.SetAnalyticsContext(); foreach (Rule<ConditionalRenderingsRuleContext> rule in RuleFactory.GetRules<ConditionalRenderingsRuleContext>(new[] { ruleItem }, "Rule").Rules) { if (rule.Condition != null) { var ruleContext = new ConditionalRenderingsRuleContext(new List<RenderingReference>(), new RenderingReference(new Control())) { Item = contextItem }; var stack = new RuleStack(); rule.Condition.Evaluate(ruleContext, stack); if (ruleContext.IsAborted) { return false; } bool ruleOutcome = false; if ((stack.Count != 0) && ((bool)stack.Pop())) { ruleOutcome = true; } if (rule.Condition.GetType() == typeof(VisitorIdentificationCondition<ConditionalRenderingsRuleContext>)) { ruleOutcome = !ruleOutcome; } return ruleOutcome; } } return false; }
/// <summary> /// Gets the rules device. /// </summary> /// <param name="database">The database.</param> /// <returns>Resolved device</returns> private static DeviceItem GetRulesDevice(Database database) { const string defaultLanguageName = "en"; var savedLanguage = Context.Language; if (savedLanguage.Name != defaultLanguageName) Context.Language = LanguageManager.GetLanguage(defaultLanguageName); DeviceItem[] all = database.Resources.Devices.GetAll(); foreach (var device in all) { var ruleContext = new RuleContext(); foreach (Rule<RuleContext> rule in RuleFactory.GetRules<RuleContext>(new[] { device.InnerItem }, "Conditions").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())) { if (savedLanguage.Name != defaultLanguageName) Context.Language = savedLanguage; return device; } } } } if (savedLanguage.Name != defaultLanguageName) Context.Language = savedLanguage; return null; }