public override void Process(MediaGenerateMarkupArgs args) { Assert.ArgumentNotNull(args, "args"); Assert.ArgumentNotNull(args.MediaItem, "args.PlayerProperties"); Assert.ArgumentNotNull(args.AccountItem, "args.PlayerProperties"); if (!this.CheckState(args)) { return; } Field eventsField = AccountManager.GetSettingsField(args.AccountItem, FieldIDs.AccountSettings.PlaybackEventsRules); if (eventsField != null) { var ruleList = RuleFactory.GetRules <PlaybackRuleContext>(eventsField); var context = new PlaybackRuleContext { Item = args.MediaItem }; ruleList.Run(context); args.PlaybackEvents = context.PlaybackEvents; } }
private static string GetFilter(Item item) { ID id; Field filterField = item.Fields["Filter"]; if (filterField == null) { return(null); } if (string.IsNullOrEmpty(filterField.Value)) { return(null); } if (!ID.TryParse(filterField.Value, out id)) { return(null); } var filter = item.Database.GetItem(id); if (filter == null) { return(null); } var ruleField = filter.Fields["Rule"]; if (ruleField == null) { return(null); } return(JsonConvert.SerializeObject(RuleFactory.GetRules <RuleContext>(ruleField), new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All })); }
public void Run(Payment payment) { var rules = RuleFactory.GetRules(payment); var evaaluator = new RuleEvaluator(rules); evaaluator.ExecuteRules(); }
/// <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 string ApplyDesign(Item ruleProgram, Item page, string crawlDepth = null) { BotLog.Log.Info($"::START:: program {ruleProgram?.DisplayName} on page {page.DisplayName}, {page.ID}, crawl depth {crawlDepth}"); Log.Info($"DESIGNBOT::START:: program {ruleProgram?.DisplayName} on page {page.DisplayName}, {page.ID}, crawl depth {crawlDepth}", this); // Get design rules RuleList <DesignBotRuleContext> rules = RuleFactory.GetRules <DesignBotRuleContext>(ruleProgram, "Rule"); if (rules != null) { // Apply design program int depth; if (!int.TryParse(crawlDepth ?? "0", out depth)) { depth = 0; } depth = Math.Max(0, depth); using (new SecurityDisabler()) { using (new ScreenshotGenerationDisabler()) { RunProgram_r(rules, page, depth); } } } BotLog.Log.Info($"::END:: program {ruleProgram?.DisplayName} on page {page.DisplayName}, {page.ID}, crawl depth {crawlDepth}"); Log.Info($"DESIGNBOT::END:: program {ruleProgram?.DisplayName} on page {page.DisplayName}, {page.ID}, crawl depth {crawlDepth}", this); return("Success"); // item.Editing.BeginEdit(); // item.Editing.EndEdit(updateStatistics: true, silent: false); // item.Editing.CancelEdit(); }
public void Process(PipelineArgs args) { try { var rulesField = Context.Item?.Fields[PageRulesFieldName]; if (rulesField == null || string.IsNullOrWhiteSpace(rulesField.Value)) { return; } var rules = RuleFactory.GetRules <PageRulesRuleContext>(rulesField); if (rules == null || rules.Count == 0) { return; } var ruleContext = new PageRulesRuleContext(); rules.Run(ruleContext); } catch (Exception exc) { Log.Error("Exception while running page rules", exc, this); } }
/// <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); }
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); } }
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); }
public List <string> Classify(Item itemToTag, string text) { var tags = new List <string>(); if (string.IsNullOrWhiteSpace(text)) { return(tags); } //get all the tags var tagItems = ContentSearchService.GetTagsByTemplate(TaxonomyFolderId, InnerItem.Language.Name, InnerItem.Database.Name, TaxonomyItemTemplateIds); //loop through and pull out the rules foreach (var t in tagItems) { var rulesField = t.GetItem().Fields[Settings.RulesFieldId]; if (rulesField == null) { continue; } var rules = RuleFactory.GetRules <RuleContext>(rulesField); //run rule against the content var ruleContext = new RuleContext { Item = itemToTag }; if (EvaluateRules(rules, ruleContext)) { tags.Add(t.Name); } } return(tags); }
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); } }
public void Process(GetMastersArgs args) { Assert.ArgumentNotNull(args, nameof(args)); var database = args.Item.Database; var insertOptionRules = new List <Item>(); foreach (var folder in Folders) { var rulesInFolder = GetInsertOptionsRules(database, folder); insertOptionRules.AddRange(rulesInFolder); } var rules = RuleFactory.GetRules <InsertOptionsRuleContext>(insertOptionRules, "Rule"); if (rules == null) { return; } var ruleContext = new InsertOptionsRuleContext { Item = args.Item, InsertOptions = args.Masters }; rules.Run(ruleContext); }
/// <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); } } }
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 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); } } }
/// <summary> /// Runs the rules in the given rules folder /// </summary> /// <param name="ruleContext"></param> /// <param name="rulesFolderId">The rules folder.</param> public static void RunRules <TRuleContext>(TRuleContext ruleContext, Item rulesFolderItem) where TRuleContext : RuleContext { try { Assert.ArgumentNotNull(ruleContext, "ruleContext is null"); Assert.ArgumentNotNull(rulesFolderItem, "rulesFolderItem is null"); Assert.IsNotNull(rulesFolderItem.Database, "rulesFolderItem.Database is null"); if (!Sitecore.Configuration.Settings.Rules.ItemEventHandlers.RulesSupported(rulesFolderItem.Database)) { return; } var rules = RuleFactory.GetRules <TRuleContext>(rulesFolderItem, "Rule"); if (rules == null || rules.Count == 0) { return; } rules.Run(ruleContext); } catch (Exception exception) { Log.Error(exception.Message, exception, typeof(RuleManager)); } }
public void Process(WorkflowPipelineArgs args) { Assert.ArgumentNotNull(args, "args"); if (args.DataItem == null) { return; } var context = new WorkflowRuleContext(args); var actionItem = args.ProcessorItem.InnerItem; if (actionItem == null) { return; } if (actionItem["execute global rules"] == "1") { RunGlobalRules(args.DataItem.Database, context); } var rules = RuleFactory.GetRules <WorkflowRuleContext>(actionItem.Fields["rules"]); rules.Run(context); }
private static void RunRules(Item item, string path) { Item item2; Assert.ArgumentNotNull(path, "path"); using (new SecurityDisabler()) { item2 = item.Database.GetItem(path); if (item2 == null) { return; } var context2 = new RuleContext { Item = item }; var ruleContext = context2; var rules = RuleFactory.GetRules <RuleContext>(item2, "Rule"); if (rules != null) { rules.Run(ruleContext); } } }
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); } } }
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 RuleList <PlaceholderRuleContext> CreateRuleList(GetPlaceholderRenderingsArgs args) { var ruleFolder = args.ContentDatabase.GetItem(FolderId); if (ruleFolder == null) { throw new InvalidOperationException("Placeholder settings rule folder could not be found."); } return(RuleFactory.GetRules <PlaceholderRuleContext>(ruleFolder, "Rule")); }
public IDataFilter Parse(JobParser parser, ParseState state) { using (new SecurityDisabler()) { var ruleContextItem = parser.Database.GetRootItem(parser.DefaultLanguage); var json = state.TryGet <string>("Rule"); if (!string.IsNullOrEmpty(json)) { var filter = RulesFilter.FromString(json); filter.RuleContextItem = ruleContextItem; return(filter); } var ruleItem = state.Require <string>("Item", true); Item item; ID id; if (!ID.TryParse(ruleItem, out id)) { if (!ruleItem.StartsWith("/")) { var rootItem = state.Parser.Database.GetItem( ExperienceExtractorApiContainer.ItemPaths.GetOrDefault("experienceAnalyticsFilters") ?? "/sitecore/system/Marketing Control Panel/Experience Analytics/Filters"); ruleItem = rootItem.Paths.FullPath + "/" + ruleItem; } item = parser.Database.GetItem(ruleItem, parser.DefaultLanguage); } else { item = parser.Database.GetItem(id, parser.DefaultLanguage); } if (item == null) { throw ParseException.AttributeError(state, string.Format("Rule item not found '{0}'", ruleItem)); } var rules = RuleFactory.GetRules <RuleContext>(item.Fields["Rule"]); return(new RulesFilter(rules) { RuleContextItem = ruleContextItem }); } }
protected virtual RuleList <TrackingRuleContext> GetProfilingRules(Item item) { Assert.ArgumentNotNull(item, "item"); using (var context = ContentSearchManager.CreateSearchContext(new SitecoreIndexableItem(item))) { var results = context.GetQueryable <ConfigItem>() .Where(i => i.Paths.Contains(DefaultRulesFolderID)) .Where(i => !i.Disabled) .Select(i => i.GetItem()) .ToArray(); var rules = RuleFactory.GetRules <TrackingRuleContext>(results, "Rules"); return(rules); } }
private static void RunGlobalRules(Database database, WorkflowRuleContext context) { //TODO: Replace with GUID ? var rulesFolder = database.GetItem("/sitecore/system/Settings/Rules/Workflow/Rules"); if (rulesFolder == null) { return; } var rules = RuleFactory.GetRules <WorkflowRuleContext>(rulesFolder, "rules"); rules.Run(context); }
public static bool EvaluateRule(Field field) { var ruleContext = new RuleContext(); foreach (Rule <RuleContext> rule in RuleFactory.GetRules <RuleContext>(field).Rules) { if (!EvaluateSingleRule(rule, ruleContext)) { return(false); } } return(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); }
/// <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); }
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); }
/// <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); }
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()); }