ClearEdgeCacheHandler

public class ClearEdgeCacheHandler
    {
        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private const string LastUpdateTimeKey = "ItemsPublishedEventHandler_LastUpdateTimeKey";

        public void ItemsPublished(object sender, EventArgs args)
        {
            var now = DateTime.UtcNow;
            var database = Factory.GetDatabase("web");
            var fromDate = database.PropertyStore.GetDateValue(LastUpdateTimeKey, DateTime.MinValue.ToUniversalTime());

            var historyEntries = HistoryManager.GetHistory(database, fromDate, now).Where(x => x.Category == HistoryCategory.Item);

            var publishedItems = new Dictionary<ID, List<Language>>();

            foreach (var historyEntry in historyEntries)
            {
                if (!publishedItems.ContainsKey(historyEntry.ItemId))
                {
                    publishedItems.Add(historyEntry.ItemId, new List<Language>());
                }
                if (!publishedItems[historyEntry.ItemId].Contains(historyEntry.ItemLanguage))
                {
                    publishedItems[historyEntry.ItemId].Add(historyEntry.ItemLanguage);
                }
            }

            var jobName = GetJobName(publishedItems);
            if (publishedItems.Any() && !JobManager.IsJobRunning(jobName))
            {
                var jobOptions = GetJobOptions(publishedItems);
                JobManager.Start(jobOptions);
                database.PropertyStore.SetDateValue(LastUpdateTimeKey, now);
            }
        }

        private JobOptions GetJobOptions(Dictionary<ID, List<Language>> publishedItems)
        {
            return new JobOptions(GetJobName(publishedItems), "ItemPublished", "scheduler", this, "ClearEdgeCache", new object[] { publishedItems });
        }
        private string GetJobName(Dictionary<ID, List<Language>> publishedItems)
        {
            var jobName = "ClearEdgeCacheFor";
            foreach (var entry in publishedItems)
            {
                jobName += $"_{entry.Key}:{string.Join("_", entry.Value)}";
            }
            return jobName.ToLower();
        }
        
        private Dictionary<string,List<string>> GetUrls(Dictionary<ID, List<Language>> publishedItems)
        {
            var result = new Dictionary<string, List<string>>();
                       
            var itemDatabase = Factory.GetDatabase("web");         
           
            var sites = Factory.GetSiteInfoList();
            foreach (var site in sites)
            {
                var cloudflareZoneIdentifier = site.Properties["cloudflareZoneIdentifier"];
                if (!string.IsNullOrWhiteSpace(site.TargetHostName) && !string.IsNullOrWhiteSpace(cloudflareZoneIdentifier))
                {
                    var siteContext = SiteContext.GetSite(site.Name);

                    foreach (var entry in publishedItems)
                    {
                        var item = itemDatabase.GetItem(entry.Key);
                        if (item != null && item.Paths.Path.StartsWith(site.RootPath))
                        {
                            var marketItem = ItemGetter.GetMarketItem(item);
                            if (marketItem != null)
                            {
                                var marketLanguages = CultureHelper.GetLanguageItemsForMarket(marketItem);
                                entry.Value.RemoveAll(x => !marketLanguages.Contains(x));

                                var urls = GetUrls(item, entry.Value, siteContext);
                                if (urls != null && urls.Any())
                                {
                                    if (!result.ContainsKey(cloudflareZoneIdentifier))
                                    {
                                        result.Add(cloudflareZoneIdentifier, new List<string>());
                                    }
                                    result[cloudflareZoneIdentifier].AddRange(urls);
                                }
                            }
                        }
                    }
                }
            }
            return result;
        }
        private List<Item> GetPageItemsFromDatasources(Item item)
        {
            var pageItems = new List<Item>();

            var linkDB = Factory.GetLinkDatabase();

            var firstLevelReferrers = linkDB.GetItemReferrers(item, true);           
            if (firstLevelReferrers != null && firstLevelReferrers.Any())
            {
                foreach (var firstLevelReferrer in firstLevelReferrers)
                {
                    if (firstLevelReferrer.SourceDatabaseName == item.Database.Name)
                    {
                        if (!pageItems.Exists(x =>x.ID.Equals(firstLevelReferrer.SourceItemID)))
                        {
                            var firstLevelpageItemCandidate = item.Database.GetItem(firstLevelReferrer.SourceItemID);
                            if (firstLevelpageItemCandidate != null)
                            {
                                if (Constants.ValidTemplateIds.Contains(firstLevelpageItemCandidate.TemplateID))
                                {
                                    pageItems.Add(firstLevelpageItemCandidate);
                                }
                                else if (firstLevelpageItemCandidate.Visualization.Layout == null)
                                {
                                    var secondLevelReferrers = linkDB.GetItemReferrers(firstLevelpageItemCandidate, true);
                                    if (secondLevelReferrers != null && secondLevelReferrers.Any())
                                    {
                                        foreach (var secondLevelReferrer in secondLevelReferrers)
                                        {
                                            if (secondLevelReferrer.SourceDatabaseName == item.Database.Name)
                                            {
                                                if (!pageItems.Exists(x => x.ID.Equals(secondLevelReferrer.SourceItemID)))
                                                {
                                                    var secondLevelpageItemCandidate = item.Database.GetItem(secondLevelReferrer.SourceItemID);
                                                    if (secondLevelpageItemCandidate != null && Constants.ValidTemplateIds.Contains(secondLevelpageItemCandidate.TemplateID))
                                                    {
                                                        pageItems.Add(secondLevelpageItemCandidate);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return pageItems;

        }
        private List<string> GetUrls(Item item, IEnumerable<Language> languages, SiteContext sitecontext)
        {
            var result = new List<string>();

            if (!languages.Any())
            {
                return result;
            }

            var urlOptions = LinkManager.GetDefaultUrlOptions();
            urlOptions.AlwaysIncludeServerUrl = true;
            urlOptions.Site = sitecontext;

            var pageItems = new List<Item>();
            if (Constants.ValidTemplateIds.Contains(item.TemplateID))
            {
                pageItems.Add(item);
            }
            else
            {
                pageItems = GetPageItemsFromDatasources(item);
            }
            if(pageItems.Any())
            {
                foreach (var pageItem in pageItems)
                {
                    foreach (var lang in languages)
                    {
                        var languageVersion = item.Database.GetItem(pageItem.ID, lang);
                        if (languageVersion != null && languageVersion.Versions.Count > 0)
                        {
                            urlOptions.Language = lang;
                            var uri = new UriBuilder(LinkManager.GetItemUrl(languageVersion, urlOptions)) { Scheme = Uri.UriSchemeHttps}.Uri;
                            var url = uri.GetComponents(UriComponents.AbsoluteUri & ~UriComponents.Port,
                               UriFormat.UriEscaped);
                            result.Add(url);
                        }
                    }
                }
            }

            return result;
        }
    }