/// <summary>Unsupported INTERNAL API! Not covered by semantic versioning; might change without notice. Send an e-mail to user with information about changed pages. /// </summary> /// <param name="subscriptionRootPage">The root page for the subscription that this mail should be based on</param> /// <param name="changedPages">The changed pages to notify the user about</param> /// <remarks>Create the subscription part of the body by calling the <see cref="M:EPiServer.Personalization.Internal.SubscriptionMail.GenerateBody(EPiServer.Core.PageData,EPiServer.Core.PageDataCollection)" /> function. </remarks> /// <exclude /> public virtual void Send(PageData subscriptionRootPage, PageDataCollection changedPages) { string email = this.UserData.Email; if (!this.IsValidEmailAddress(email)) { SubscriptionMail.log.Warn((object)("4.3.1 Invalid email address found (skip mail): " + (email == null ? "NULL" : email))); } else { MailMessage message = new MailMessage("subscription@" + SiteDefinition.Current.SiteUrl.Host, email); message.Headers.Add("X-Mailer", "EPiServer CMS"); message.Headers.Add("Content-Base", SiteDefinition.Current.SiteUrl.GetLeftPart(UriPartial.Authority)); message.Body = this.GenerateBody(subscriptionRootPage, changedPages); message.IsBodyHtml = true; message.BodyEncoding = Encoding.UTF8; message.Subject = subscriptionRootPage["SubscriptionMailSubject"] == null?this.LocalizationService.GetStringByCulture("/subscription/mailsubject", "Subscription mail", ((ILocalizable)subscriptionRootPage).Language) : subscriptionRootPage["SubscriptionMailSubject"] as string; if (subscriptionRootPage["SubscriptionMailFrom"] != null) { message.From = new MailAddress(subscriptionRootPage["SubscriptionMailFrom"] as string); } new SmtpClient().Send(message); SubscriptionMail.log.Info((object)("4.3.2 Subscription mail sent to " + email)); } }
/// <summary> /// Updates the UsageStatistics property on the tag listing pages. /// Cleans up unused categories. /// </summary> /// <returns></returns> public static string Execute() { Dictionary <string, int> globalTagStats = CreateTagStats();; Dictionary <string, int> teamTagStats; PageDataCollection teamStartPages = GetPages(PageReference.RootPage, PageType.Load(BlogUtility.TeamStartPageTypeName).ID); foreach (PageData teamStartPage in teamStartPages) { teamTagStats = CreateTagStats(); foreach (PageData startPage in DataFactory.Instance.GetChildren(teamStartPage.PageLink).Where(page => String.Equals(page.PageTypeName, BlogUtility.PersonalStartPageTypeName, StringComparison.OrdinalIgnoreCase))) { CalculateCategoryStats(startPage, teamTagStats, globalTagStats); } //Add team level statistics SetStatsToPages(teamTagStats, teamStartPage, true); } //Special handling of personal blogs without a team blog as parent PageDataCollection personalStartPages = GetPages(PageReference.RootPage, PageType.Load(BlogUtility.PersonalStartPageTypeName).ID); var startPages = from page in personalStartPages where !String.Equals(DataFactory.Instance.GetPage(page.ParentLink).PageTypeName, BlogUtility.TeamStartPageTypeName, StringComparison.OrdinalIgnoreCase) select page; foreach (PageData startPage in startPages) { CalculateCategoryStats(startPage, CreateTagStats(), globalTagStats); } CleanUnusedCategories(globalTagStats); return("Job executed successfully"); }
/// <summary> /// Initializes the language link. /// Checks the number of available and enabled languages. If more than two, /// populates a dropdown-menu with the available and enabled languages. /// Otherwise sets the link to the not currently active language. /// </summary> private void SetLanguage() { PageDataCollection languageBranches = DataFactory.Instance.GetLanguageBranches(CurrentPage.PageLink); if (languageBranches == null) { return; } if (languageBranches.Count > 2) { LanguageList.Visible = LanguageListLabel.Visible = LanguageButton.Visible = LanguageList.Parent.Visible = true; foreach (PageData languageBranch in languageBranches) { if (languageBranch.LanguageID != CurrentPage.LanguageID && LanguageBranch.Load(languageBranch.LanguageID).Enabled) { LanguageList.Items.Add(new System.Web.UI.WebControls.ListItem(new CultureInfo(languageBranch.LanguageID).NativeName, languageBranch.LanguageID)); } } } else { foreach (PageData languageBranch in languageBranches) { if (languageBranch.LanguageID != CurrentPage.LanguageID && LanguageBranch.Load(languageBranch.LanguageID).Enabled) { Language.Visible = Language.Parent.Visible = true; Language.NavigateUrl = EPiServer.UriSupport.AddLanguageSelection(languageBranch.LinkURL, languageBranch.LanguageID); Language.Text = Translate(new CultureInfo(languageBranch.LanguageID).NativeName); break; } } } }
private PageDataCollection GetLanguageBranches(PageReference pageLink) { var languages = new PageDataCollection(); languages.Add(GetPage(pageLink)); return(languages); }
public PageDataCollection GetPagesByTag(Tag tag, PageReference rootPageReference) { if (tag == null || tag.PermanentLinks == null) { return(null); } IList <PageReference> descendantPageReferences = DataFactory.Instance.GetDescendents(rootPageReference); if (descendantPageReferences == null || descendantPageReferences.Count < 1) { return(null); } var pages = new PageDataCollection(); foreach (Guid pageGuid in tag.PermanentLinks) { var pageReference = TagsHelper.GetContentReference(pageGuid); if (descendantPageReferences.FirstOrDefault(p => p.ID == pageReference.ID) != null) { pages.Add(this._contentLoader.Get <PageData>(pageReference)); } } return(pages); }
public PageDataCollection GetPagesByTag(Tag tag) { if (tag == null) { return(null); } var pageLinks = new List <Guid>(); if (tag.PermanentLinks == null) { var tempTerm = this._tagService.GetTagByName(tag.Name); if (tempTerm != null) { pageLinks = tempTerm.PermanentLinks.ToList(); } } else { pageLinks = tag.PermanentLinks.ToList(); } var pages = new PageDataCollection(); foreach (Guid pageGuid in pageLinks) { pages.Add(this._contentLoader.Get <PageData>(TagsHelper.GetContentReference(pageGuid))); } return(pages); }
/// <summary> /// The find pages with criteria. /// </summary> /// <param name="pageLink"> /// The page link. /// </param> /// <param name="criterias"> /// The criterias. /// </param> /// <param name="languageBranch"> /// The language branch. /// </param> /// <param name="selector"> /// The selector. /// </param> /// <returns> /// The <see cref="PageDataCollection"/>. /// </returns> public PageDataCollection FindPagesWithCriteria( PageReference pageLink, PropertyCriteriaCollection criterias, string languageBranch, ILanguageSelector selector) { if (PageReference.IsNullOrEmpty(pageLink)) { return(new PageDataCollection()); } // Any search beneath the entry root should in fact be performed under the clone root as that's where the original content resides if (pageLink.CompareToIgnoreWorkID(this.EntryRoot)) { pageLink = this.CloneRoot; } else if (!string.IsNullOrWhiteSpace(pageLink.ProviderName)) { // Any search beneath a cloned page should in fact be performed under the original page, so we use a page link without any provider information pageLink = new PageReference(pageLink.ID); } PageDataCollection pages = DataFactory.Instance.FindPagesWithCriteria( pageLink, criterias, languageBranch, selector); // Return cloned search result set return(new PageDataCollection(pages.Select(this.ClonePage))); }
public static PageDataCollection GetPagesRelated(PageReference page, string ruleName, Rule.Direction direction) { Rule currentRule = RuleEngine.Instance.GetRule(ruleName); List <int> relations = new List <int>(); switch (direction) { case Rule.Direction.Both: relations = RelationEngine.Instance.GetRelationPagesForPage(page.ID, currentRule); break; case Rule.Direction.Left: case Rule.Direction.Right: relations = RelationEngine.Instance.GetRelationPagesForPage(page.ID, currentRule, direction); break; } FilterSortOrder sortOrder; PageDataCollection result = PageIDListToPages(relations); sortOrder = (FilterSortOrder)((direction == Rule.Direction.Left) ? currentRule.SortOrderLeft : currentRule.SortOrderRight); new EPiServer.Filters.FilterSort(sortOrder).Sort(result); return(result); }
/// <summary> /// Gets the latest updated threads. Will search through all the forums beneath the supplied root. /// </summary> /// <param name="pageRef">The root page to look for threads under.</param> /// <param name="nrOfThreads">The number of threads to return.</param> /// <returns>A PageDataCollection containing threads.</returns> public static PageDataCollection GetLatestUpdatedThreads(PageReference pageRef, int nrOfThreads) { PropertyCriteriaCollection criterias = new PropertyCriteriaCollection(); criterias.Add("PageTypeName", ThreadContainerPageTypeName, CompareCondition.Equal); PageDataCollection pages = DataFactory.Instance.FindPagesWithCriteria(pageRef, criterias); PageDataCollection threads = new PageDataCollection(); FilterPublished publishedFilter = new FilterPublished(); foreach (PageData threadContainer in pages) { foreach (PageData page in DataFactory.Instance.GetChildren(threadContainer.PageLink, LanguageSelector.AutoDetect(), 0, nrOfThreads)) { if (!publishedFilter.ShouldFilter(page)) { threads.Add(page); } } } new FilterPropertySort("PageChanged", FilterSortDirection.Descending).Filter(threads); new FilterCount(nrOfThreads).Filter(threads); return(threads); }
/// <summary> /// Called by the ASP.NET page framework to notify server controls that use composition-based implementation to create any child controls they contain in preparation for posting back or rendering. /// </summary> protected override void CreateChildControls() { if (this.EventTemplate != null) { this.SetCalendarInterval(); PageDataCollection pages = base.GetPages(); int num = 0; this.ValidatePages(pages); foreach (PageData data in pages) { DateTime _eventStartDate = (DateTime)data[EVENT_START_DATE_PROPERTY_NAME]; DateTime _eventStopDate = (DateTime)data[EVENT_STOP_DATE_PROPERTY_NAME]; if ((_eventStartDate.Date <= this.BeginDate.AddDays(this.NumberOfDaysToRender - 1) && (_eventStopDate.Date >= this.BeginDate.Date))) { this.CreateEventTemplate(data, _eventStartDate, _eventStopDate); num++; } if ((this.MaxCount > 0) && (num >= this.MaxCount)) { break; } } } }
protected PageDataCollection SearchRelations() { string CacheKey = CurrentRule.Id.ToString() + "_" + CurrentPage.PageLink.ID + "_" + PageTypesDropDown.SelectedValue + "_" + _ruleDirection.ToString(); PageDataCollection pages = EPiServer.CacheManager.Get(CacheKey) as PageDataCollection; PageDataCollection result = new PageDataCollection(); if (pages == null || 1 == 1) { pages = RuleEngine.Instance.SearchRelations(CurrentRule, CurrentPage.PageLink.ID, SearchKeyWord.Text, IsLeftRule); if (PageTypesDropDown.SelectedValue.Length > 2) { foreach (PageData pd in pages) { if (pd.PageTypeName == PageTypesDropDown.SelectedValue) { result.Add(pd); } } } else { result = pages; } EPiServer.CacheManager.Add(CacheKey, result); } return(result); }
public void Export(PageDataCollection pagesToExport, HttpResponse response) { using (var package = new ExcelPackage()) { ExcelWorksheet ws = package.Workbook.Worksheets.Add("pages"); ws.Cells[1, 1].Value = "PageId"; ws.Cells[1, 2].Value = "PageName"; ws.Cells[1, 3].Value = "PageUrl"; ws.Cells[1, 4].Value = "Published Date"; ws.Row(1).Style.Font.Bold = true; ws.Row(1).Style.Locked = true; int row = 2; foreach (var page in pagesToExport) { ws.Cells[row, 1].Value = page.ContentLink.ID; ws.Cells[row, 2].Value = page.PageName; ws.Cells[row, 3].Value = Url.ContentUrl(page.ContentLink); ws.Cells[row, 4].Value = page.StartPublish.HasValue ? page.StartPublish.Value.ToString("yyyy-MM-dd HH:mm") : "Not published"; ++row; } response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"; response.AddHeader("content-disposition", $"attachment; filename=pages{DateTime.Now:yyyyMMdd}.xlsx"); response.BinaryWrite(package.GetAsByteArray()); response.Flush(); response.End(); } }
/// <summary> /// Goes through Blog items and checks what categories are used adding them to a statistics dictionary. /// </summary> /// <param name="startPage">The start page used to search for blog item.</param> /// <param name="teamTagStats">The stats for team level.</param> /// <param name="globalTagStats">The stats for global level.</param> private static void CalculateCategoryStats(PageData startPage, Dictionary <string, int> teamTagStats, Dictionary <string, int> globalTagStats) { Dictionary <string, int> tagStats = CreateTagStats(); PageDataCollection blogItemPages = GetPages(startPage.PageLink, PageType.Load(BlogUtility.ItemPageTypeName).ID); Category currentPageCategory; Category blogRoot = Category.Find(BlogUtility.RootCategoryName); foreach (PageData blogItem in blogItemPages) { foreach (int catID in blogItem.Category) { currentPageCategory = Category.Find(catID); if (currentPageCategory != null && currentPageCategory.Parent.ID == blogRoot.ID) { //Update the stats on personl, team and global level. tagStats[currentPageCategory.Name]++; teamTagStats[currentPageCategory.Name]++; globalTagStats[currentPageCategory.Name]++; } } } SetStatsToPages(tagStats, startPage, false); }
/// <summary> /// Creates the collection for the main menu, adding the startpage /// </summary> private PageDataCollection LoadChildren(PageReference pageLink) { PageDataCollection pages = DataFactory.Instance.GetChildren(pageLink); pages.Insert(0, DataFactory.Instance.GetPage(pageLink)); return(pages); }
private bool IsBlockVisibleToVisitor(ContentReference contRef) { // TODO potential optimization, cache block ID and if it is visible true/false, can have big effect on high reuse or deep nesting if (ContentReference.IsNullOrEmpty(contRef)) { return(false); } IContent content = _contentRepository.Get <IContent>(contRef); if (content is PageData page) // is block on a page { PageDataCollection pdc = new PageDataCollection { page }; var filtered = FilterForVisitor.Filter(pdc); return(filtered.Count > 0); // is page published? } else if (content is BlockData) // is block in other block { IEnumerable <ReferenceInformation> usedOn = _contentRepository.GetReferencesToContent(content.ContentLink, false); return(usedOn.Any() && usedOn.Any(usage => IsBlockVisibleToVisitor(usage.OwnerID))); // check all usages of that block } else { return(false); } }
private string GetDefaultNewsSectionBody() { string defaultBody = String.Empty; PageReference currentWorkroomTemplate = WorkroomStartPage["WorkroomTemplate"] as PageReference; if (currentWorkroomTemplate == null) { return(defaultBody); } PageReference currentWorkroomNewsTemplate = DataFactory.Instance.GetPage(currentWorkroomTemplate)["NewsRoot"] as PageReference; if (currentWorkroomNewsTemplate == null) { return(defaultBody); } PageDataCollection templatePages = DataFactory.Instance.GetChildren(currentWorkroomNewsTemplate); if (templatePages.Count == 0) { return(defaultBody); } return(templatePages[0]["MainBody"] as string); }
/// <summary> /// Filters the specified pages. /// </summary> /// <param name="pages">The pages.</param> public void Filter(PageDataCollection pages) { var output = new PageDataCollection(); pages.Where(x => !this.notAllowedPageTypes.Any(k => k == x.PageTypeName)).ToList().ForEach(l => output.Add(l)); pages.Clear(); output.ToList().ForEach(x => pages.Add(x)); }
/// <summary> /// Initializes the language link. /// Checks the number of available and enabled languages. If more than two, /// populates a dropdown-menu with the available and enabled languages. /// Otherwise sets the link to the not currently active language. /// </summary> private void SetLanguage() { PageDataCollection languageBranches = DataFactory.Instance.GetLanguageBranches(CurrentPage.PageLink); //Filter so pages with Replacement language is filtered away. new FilterReplacementLanguage().Filter(languageBranches); if (languageBranches.Count > 2) { LanguageList.Visible = LanguageListLabel.Visible = LanguageButton.Visible = LanguageList.Parent.Visible = true; foreach (PageData languageBranch in languageBranches.Where(p => p.LanguageID != CurrentPage.LanguageID && LanguageBranch.Load(p.LanguageID).Enabled)) { LanguageList.Items.Add(new System.Web.UI.WebControls.ListItem(new CultureInfo(languageBranch.LanguageID).NativeName, languageBranch.LanguageID)); } } else { foreach (PageData languageBranch in languageBranches.Where(p => p.LanguageID != CurrentPage.LanguageID && LanguageBranch.Load(p.LanguageID).Enabled)) { Language.Visible = Language.Parent.Visible = true; Language.NavigateUrl = EPiServer.UriSupport.AddLanguageSelection(languageBranch.LinkURL, languageBranch.LanguageID); Language.Text = Translate(new CultureInfo(languageBranch.LanguageID).NativeName); break; } } }
public PageListBlockViewModel(PageListBlock currentBlock, PageDataCollection pageCollection, PageData rootPage) { CurrentBlock = currentBlock; PageCollection = pageCollection; RootPage = rootPage; }
private int GetRandomPageID() { Random rnd = new Random(); PageDataCollection pdc = AllPages; return(pdc[rnd.Next(0, pdc.Count - 1)].ContentLink.ID); }
private IEnumerable <PageData> Sort(IEnumerable <PageData> pages) { var asCollection = new PageDataCollection(pages); var sortFilter = new FilterSort(FilterSortOrder.PublishedDescending); sortFilter.Sort(asCollection); return(asCollection); }
private static PageData FindPageByName(PageReference rootPage, string pageName, string pageType) { PageDataCollection children = DataFactory.Instance.GetChildren(rootPage); children.Add(DataFactory.Instance.GetChildren(rootPage, LanguageSelector.MasterLanguage())); return(children.FirstOrDefault(page => page.PageName.Equals(pageName) && page.PageTypeName.Equals(pageType))); }
private IEnumerable <PageData> Sort(IEnumerable <PageData> pages, FilterSortOrder sortOrder) { var asCollection = new PageDataCollection(pages); var sortFilter = new FilterSort(sortOrder); sortFilter.Sort(asCollection); return(asCollection); }
public void GetRelations() { PageDataCollection relatedPages = PageHelper.GetPagesRelated(CurrentPage.PageLink, CurrentRule, CurrentDirection); EPiServer.Filters.FilterForVisitor.Filter(relatedPages); RelatedPagesRepeater.DataSource = relatedPages; RelatedPagesRepeater.DataBind(); }
/// <summary> /// Filters the specified collection, removing pages of types not specified in /// the constructor. /// </summary> /// <param name="pages"></param> public void Filter(PageDataCollection pages) { for (int i = pages.Count - 1; i > -1; i--) { if (ShouldFilter(pages[i])) pages.RemoveAt(i); } }
public override PageDataCollection SearchRelations(Rule rule, int pageID, string searchKeyWord, PageReference hierarchyStart, bool isLeftRule) { string pageTypes = HttpUtility.UrlDecode(isLeftRule ? rule.PageTypeRight : rule.PageTypeLeft); PageDataCollection result = new PageDataCollection(); if (!string.IsNullOrEmpty(pageTypes)) { string[] pageTypeCollection = pageTypes.Split(';'); PropertyCriteriaCollection pageTypeCriterias = new PropertyCriteriaCollection(); if (hierarchyStart == null || hierarchyStart == PageReference.EmptyReference) { hierarchyStart = PageReference.RootPage; } foreach (string s in pageTypeCollection) { if (!string.IsNullOrEmpty(s)) { PropertyCriteria criteria = new PropertyCriteria(); criteria.Condition = EPiServer.Filters.CompareCondition.Equal; criteria.Name = "PageTypeName"; criteria.Type = PropertyDataType.String; criteria.Value = s; pageTypeCriterias.Add(criteria); } } PageDataCollection pages = DataFactory.Instance.FindPagesWithCriteria(hierarchyStart, pageTypeCriterias); PageData rootPage = DataFactory.Instance.GetPage(hierarchyStart); if (pageTypeCollection.Contains <string>(rootPage.PageTypeName) && !pages.Contains(rootPage)) { pages.Add(rootPage); } new EPiServer.Filters.FilterSort(EPiServer.Filters.FilterSortOrder.Alphabetical).Sort(pages); if (!string.IsNullOrEmpty(searchKeyWord)) { for (int i = 0; i < pages.Count; i++) { if (pages[i].PageName.ToLower().Contains(searchKeyWord.ToLower())) { result.Add(pages[i]); } } } else { result = pages; } } return(result); }
private PageDataCollection GetNewsListPages() { IList <PageReference> newsItemReferences = DataFactory.Instance.GetDescendents((PageReference)CurrentPage["NewsRoot"]); PageDataCollection result = DataFactory.Instance.GetPages(newsItemReferences, LanguageSelector.AutoDetect(true)); new Filters.FilterCompareTo("PageTypeName", NewsItemPageTypeName).Filter(result); new Filters.FilterPropertySort("PageStartPublish", Filters.FilterSortDirection.Ascending).Filter(result); return(result); }
/// <summary> /// Removes any page not of the specified type from the page collection /// </summary> /// <param name="pages">The page collection to filter</param> /// <param name="pageTypeId">Page type ID of pages that should be left in the page collection</param> public static void FilterByPageType(this PageDataCollection pages, int pageTypeId) { for (var i = pages.Count - 1; i >= 0; i--) { if (pages[i].ContentTypeID != pageTypeId) { pages.RemoveAt(i); } } }
/// <summary> /// Returns the PageDataCollection which the PageReferenceCollection represents. /// Any non resolvable references will be skipped without errors. /// </summary> /// <param name="references"></param> /// <returns></returns> public static PageDataCollection ToPageDataCollection(this PageReferenceCollection references) { var retval = new PageDataCollection(); if (references != null) foreach (PageReference reference in references) retval.AddIfResolvable(reference); return retval; }
protected override IEnumerable <PageReference> GetContentReferences(string languageBranch) { var criterias = new PropertyCriteriaCollection() { PageIsInCategoryCriteria }; PageDataCollection pages = DataFactory.Instance.FindPagesWithCriteria(PageReference.StartPage, criterias, languageBranch); return(pages.Select(p => p.PageLink)); }
private static PageDataCollection GetAllPages(PageData parent, PageDataCollection allPages) { PageDataCollection children = DataFactory.Instance.GetChildren(parent.ContentLink.ToPageReference()); foreach (PageData pd in children) { allPages.Add(pd); GetAllPages(pd, allPages); } return(allPages); }
/// <summary> /// Filters the collection, leaving only the pages which /// correspond to the given page number and size. /// </summary> /// <param name="pages"></param> public void Filter(PageDataCollection pages) { for (int i = pages.Count - 1; i > -1; i--) { if (i >= _pageNumber * _pageSize) pages.RemoveAt(i); if (i < (_pageNumber - 1) * _pageSize) pages.RemoveAt(i); } }
/* public static PageDataCollection GetRelatedPagesRoundTripHierarchy(Rule rule, Relation relation, int pageID) { PageReference pr = new PageReference(pageID); PageData origPage = DataFactory.Instance.GetPage(pr); List<int> relationPages = RelationEngine.GetRelationsForPageRoundTripHierarchy(pageID, rule, relation); return PageIDListToPages(relationPages); }*/ /// <summary> /// Helper method for page relation getters to convert relations to pages. /// </summary> /// <param name="pageIDList">Collection of page IDs</param> /// <returns>Collection of pages</returns> public static PageDataCollection PageIDListToPages(List<int> pageIDList) { PageDataCollection pages = new PageDataCollection(); foreach (int pgid in pageIDList) { PageData pd = PageEngine.GetPage(pgid); if (pd != null && !pages.Contains(pd)) pages.Add(pd); } return pages; }
protected void SearchEvents() { var allEvents = ParticipantProviderManager.Provider.GetEventPages(); var upcomingEvents = (from PageData p in allEvents orderby((EventPageBase)p).EventDetails.EventStart where ((EventPageBase)p).EventDetails.EventStart >= FromDateTime && ((EventPageBase)p).EventDetails.EventEnd <= ToDateTime select p); var upcomingEventPages = new PageDataCollection(upcomingEvents); new EPiServer.Filters.FilterAccess(EPiServer.Security.AccessLevel.Publish).Filter(upcomingEventPages); (AttendParticipantList as ParticipantList).SetEventPageBaseList(upcomingEventPages.ToList <PageData>()); }
private IEnumerable <TemplatedBasePageType> GetFilteredChildPages(PageReference pageReference) { IEnumerable <TemplatedBasePageType> childPages = this._contentRepository.GetChildren <TemplatedBasePageType>(pageReference); PageDataCollection collection = new PageDataCollection(childPages); foreach (IPageFilter filter in this._navigationPageFilters) { filter.Filter(collection); } return(collection.OfType <TemplatedBasePageType>()); }
protected override IEnumerable<IContent> GetContent(ContentQueryParameters parameters) { if(HttpContext.Current.Session != null) HttpContext.Current.Session["ValidationResult"] = ""; bool isLeftRule = (HttpUtility.HtmlDecode(parameters.AllParameters["direction"]) == "left"); var queryText = HttpUtility.HtmlDecode(parameters.AllParameters["queryText"]); var relationPageLeft = HttpUtility.HtmlDecode(parameters.AllParameters["relationPageLeft"]); string relationPageRightUrl = HttpUtility.HtmlDecode(parameters.AllParameters["relationPageRight"]); //string relationPageRight = ""; /* if (!string.IsNullOrEmpty(relationPageRightUrl)) { Match match = regex.Match(HttpUtility.HtmlDecode(parameters.AllParameters["relationPageRight"])); if (match.Success) { relationPageRight = (match.Groups[1].Value); } }*/ var relationRule = HttpUtility.HtmlDecode(parameters.AllParameters["relationRule"]); var action = HttpUtility.HtmlDecode(parameters.AllParameters["action"]); PageReference contextPage = (relationPageLeft != null) ? new PageReference(relationPageLeft) : null; PageDataCollection result = new PageDataCollection(); if (contextPage != null && relationPageLeft != null) try { List<int> relations = new List<int>(); if(RuleEngine.Instance.GetRule(relationRule).RuleTextLeft == RuleEngine.Instance.GetRule(relationRule).RuleTextRight) relations = RelationEngine.Instance.GetRelationPagesForPage(contextPage.ID, RuleEngine.Instance.GetRule(relationRule)); else relations = isLeftRule ? RelationEngine.Instance.GetRelationPagesForPage(contextPage.ID, RuleEngine.Instance.GetRule(relationRule), Rule.Direction.Left).Distinct<int>().ToList<int>() : RelationEngine.Instance.GetRelationPagesForPage(contextPage.ID, RuleEngine.Instance.GetRule(relationRule), Rule.Direction.Right).Distinct<int>().ToList<int>(); foreach (int pageid in relations) { try { result.Add(PageEngine.GetPage(pageid)); } catch { Logging.Warning(string.Format("Error fetching page {0} related to {1}", pageid, contextPage.ID)); } } } catch { Logging.Warning(string.Format("Error fetching relations from page {0}", contextPage.ID)); } return result; }
public void PageType_Filter(object sender, FilterEventArgs e) { if (_pagesToShow == null || !_pagesToShow.Any()) { e.Pages.RemoveRange(0, e.Pages.Count); return; } var clone = new PageDataCollection(e.Pages); foreach (var page in clone.Where(p => !_pagesToShow.Contains(p.PageLink.ID))) { e.Pages.Remove(page); } }
/// <summary> /// Returns a <see cref="PageDataCollection"/> with the links that resolve to EPiServer pages. /// Other links are dropped without error. /// </summary> /// <param name="linkItemCollection"></param> /// <returns></returns> public static PageDataCollection ToPageDataCollection(this LinkItemCollection linkItemCollection) { var retval = new PageDataCollection(); if (linkItemCollection != null) foreach (var linkItem in linkItemCollection) { var url = new UrlBuilder(linkItem.Href); if (PermanentLinkMapStore.ToMapped(url)) retval.AddIfResolvable(PermanentLinkUtility.GetPageReference(url)); } return retval; }
public PageDataCollection List(PageReference pageLink) { IEnumerable<ContentReference> descendantContentLinks = _contentLoader.GetDescendents(pageLink); var standardPages = new PageDataCollection(); foreach (ContentReference contentLink in descendantContentLinks) { StandardPage standardPage = GetStandardPage(contentLink); if (standardPage != null) { standardPages.Add(standardPage); } } return standardPages; }
public PageDataCollection List(PageReference pageLink) { IEnumerable<ContentReference> descendantContentLinks = _contentLoader.GetDescendents(pageLink); IEnumerable<IContent> allDescendantContent = _contentLoader.GetItems(descendantContentLinks, new LoaderOptions()); var standardPages = new PageDataCollection(); foreach (IContent content in allDescendantContent) { if (IsStandardPage(content)) { standardPages.Add(content); } } return standardPages; }
protected override IEnumerable<IContent> GetContent(ContentQueryParameters parameters) { bool isLeftRule = (HttpUtility.HtmlDecode(parameters.AllParameters["direction"]) == "left"); var queryText = HttpUtility.HtmlDecode(parameters.AllParameters["queryText"]); var relationPageLeft = HttpUtility.HtmlDecode(parameters.AllParameters["relationPageLeft"]); var relationPageRight = HttpUtility.HtmlDecode(parameters.AllParameters["relationPageRight"]); var relationRule = HttpUtility.HtmlDecode(parameters.AllParameters["relationRule"]); PageReference contextPage = (relationPageLeft != null) ? new PageReference(relationPageLeft): null; IEnumerable<IContent> result = new PageDataCollection(); if (contextPage != null) result = RuleEngine.Instance.SearchRelations(RuleEngine.Instance.GetRule(relationRule), contextPage.ID, queryText, isLeftRule); return result as PageDataCollection; }
/// <summary> /// Convert a LinkItemCollection to a PageDataCollection. /// </summary> /// <remarks> /// Author: Frederik Vig /// Link: http://www.frederikvig.com/2009/06/episerver-extension-methods-part-2/ /// </remarks> /// <param name="linkItemCollection">The LinkItemCollection to convert.</param> /// <returns>The resulting PageDataCollection.</returns> public static PageDataCollection ToPageDataCollection(this LinkItemCollection linkItemCollection) { var pageDataCollection = new PageDataCollection(); foreach (var linkItem in linkItemCollection) { var url = new UrlBuilder(linkItem.Href); if (!PermanentLinkMapStore.ToMapped(url)) continue; var page = DataFactory.Instance.GetPage(PermanentLinkUtility.GetPageReference(url)); if (page != null) pageDataCollection.Add(page); } return pageDataCollection; }
private PageDataCollection GetStandardPageChildren(PageReference parent) { PageDataCollection standardPages = new PageDataCollection(); IEnumerable<PageData> children = _contentLoader.GetChildren<PageData>(parent); foreach (PageData child in children) { var standardPage = child as StandardPage; if (standardPage != null) { standardPages.Add(standardPage); } standardPages.AddRange(GetStandardPageChildren(child.PageLink)); } return standardPages; }
/// <summary> /// Called when a scheduled job executes /// </summary> /// <returns>A status message to be stored in the database log and visible from admin mode</returns> public override string Execute() { //Call OnStatusChanged to periodically notify progress of job for manually started jobs OnStatusChanged(String.Format("Starting execution of {0}", this.GetType())); PropertyCriteriaCollection criteria = new PropertyCriteriaCollection(); PropertyCriteria pageTypeCriteria = new PropertyCriteria(); pageTypeCriteria.Condition = CompareCondition.Equal; pageTypeCriteria.Value = ServiceLocator.Current.GetInstance<IContentTypeRepository>().Load<EventPage>().ID.ToString(); pageTypeCriteria.Type = PropertyDataType.PageType; pageTypeCriteria.Name = "PageTypeID"; pageTypeCriteria.Required = true; criteria.Add(pageTypeCriteria); PageDataCollection allEvents = new PageDataCollection(); PageDataCollection allLanguages = DataFactory.Instance.GetLanguageBranches(PageReference.StartPage); foreach (PageData pageData in allLanguages) { allEvents.Add(DataFactory.Instance.FindPagesWithCriteria(PageReference.RootPage, criteria, pageData.LanguageBranch)); } int cnt = 0; foreach (var eventPage in allEvents) { cnt += UpdateEvent(eventPage as EventPage); } return "Found " + allEvents.Count + " pages, converted "+cnt+"e-mail templates!"; //Add implementation //For long running jobs periodically check if stop is signaled and if so stop execution if (_stopSignaled) { return "Stop of job was called"; } return "Change to message that describes outcome of execution"; }
/// <summary> /// Returns a PageDataCollection with a distinct list of pages related through the given rule. Number of relations are added to PageName. /// </summary> /// <param name="allPages">PageDataCollection to create facets from</param> /// <param name="ruleName">Rule used for facet relations</param> /// <param name="direction">Direction of facet relations</param> /// <returns></returns> public static PageDataCollection FacetList(PageDataCollection allPages, string ruleName, Rule.Direction direction) { List<Relation> relations = RelationEngine.Instance.GetAllRelations(ruleName); List<int> facets; if (direction == Rule.Direction.Right) { facets = (from id in relations select id.PageIDRight).Distinct().ToList(); } else { facets = (from id in relations select id.PageIDLeft).Distinct().ToList(); } PageDataCollection facetPages = PageHelper.PageIDListToPages(facets); PageDataCollection facetsWithCount = new PageDataCollection(); foreach (PageData facetPage in facetPages) { PageData writableFacet = facetPage.CreateWritableClone(); if (direction == Rule.Direction.Right) { writableFacet.PageName = writableFacet.PageName + " (" + (from id in relations where id.PageIDRight == facetPage.PageLink.ID select id) .Count() + ")"; } else { writableFacet.PageName = writableFacet.PageName + " (" + (from id in relations where id.PageIDLeft == facetPage.PageLink.ID select id) .Count() + ")"; } facetsWithCount.Add(writableFacet); } new EPiServer.Filters.FilterSort(FilterSortOrder.Alphabetical).Sort(facetsWithCount); return facetsWithCount; }
protected void SearchEvents() { var allEvents = ParticipantProviderManager.Provider.GetEventPages(); var upcomingEvents = (from PageData p in allEvents orderby ((EventPageBase)p).EventDetails.EventStart where ((EventPageBase)p).EventDetails.EventStart >= FromDateTime && ((EventPageBase)p).EventDetails.EventEnd <= ToDateTime select p); var upcomingEventPages = new PageDataCollection(upcomingEvents); new EPiServer.Filters.FilterAccess(EPiServer.Security.AccessLevel.Publish).Filter(upcomingEventPages); (AttendParticipantList as ParticipantList).SetEventPageBaseList(upcomingEventPages.ToList<PageData>()); }
/// <summary> /// Gets the items to display in the control, applying sorting /// and filtering as required. /// </summary> /// <returns></returns> protected PageDataCollection GetItems() { var items = new PageDataCollection(); if (DataSource != null) if (DataSource is IEnumerable<PageData>) items = new PageDataCollection((IEnumerable<PageData>)DataSource); if (!ListRoot.IsNullOrEmpty()) items = ListRoot.ChildrenForVisitor(); if (Filter != null) Filter(this, new FilterEventArgs(items)); if (SortOrder != FilterSortOrder.None) items.Sort(SortOrder); if (!SortBy.NullOrEmpty()) new FilterPropertySort(SortBy, SortDirection).Filter(items); if (MaxCount > 0) new FilterCount(MaxCount).Filter(items); TotalItemCount = items.Count; ApplyPagingFilter(items); return items; }
private void ProcessEditionListFeed(PageDataCollection editions) { XmlDocument doc = new XmlDocument(); XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", null); doc.AppendChild(declaration); XmlNode outerNode = doc.CreateElement("editionList"); doc.AppendChild(outerNode); XmlNode pageIdNode = doc.CreateElement("pageId"); pageIdNode.InnerText = editionListPage.PageGuid.ToString(); outerNode.AppendChild(pageIdNode); XmlNode titleNode = doc.CreateElement("title"); titleNode.InnerText = editionListPage.PageName; outerNode.AppendChild(titleNode); XmlNode updatedNode = doc.CreateElement("updated"); updatedNode.InnerText = editions.Count == 0 ? "1970-01-01" : editions.Max(pd => pd.StartPublish).ToString("o"); outerNode.AppendChild(updatedNode); XmlNode authorNameNode = doc.CreateElement("authorname"); authorNameNode.InnerText = editionListPage.CreatedBy; outerNode.AppendChild(authorNameNode); XmlNode hrefNode = doc.CreateElement("href"); hrefNode.InnerText = string.Format("{0}/{1}.xml", Common.GetRootPublishLocationPath(), editionListPage.Name); outerNode.AppendChild(hrefNode); foreach (PageData edition in editions) { CreateEditionList(doc, edition, outerNode); } ApplyEditionListTransform(doc.InnerXml); ; }
public override List<EventPageBase> GetEventPages() { PropertyCriteriaCollection criteria = new PropertyCriteriaCollection(); var pageTypes = ServiceLocator.Current.GetInstance<IContentTypeRepository>().List(); foreach (var pageType in pageTypes) { if (pageType.ModelType != null && typeof(EventPageBase).IsAssignableFrom(pageType.ModelType)) { PropertyCriteria pageTypeCriteria = new PropertyCriteria(); pageTypeCriteria.Condition = CompareCondition.Equal; pageTypeCriteria.Value = pageType.ID.ToString(); pageTypeCriteria.Type = PropertyDataType.PageType; pageTypeCriteria.Name = "PageTypeID"; pageTypeCriteria.Required = false; criteria.Add(pageTypeCriteria); } } List<EventPageBase> eventList = new List<EventPageBase>(); var sites = EPiServer.ServiceLocation.ServiceLocator.Current.GetInstance<EPiServer.Web.SiteDefinitionRepository>().List(); foreach (SiteDefinition siteDefinition in sites) { PageDataCollection allEvents = new PageDataCollection(); var allLanguages = ServiceLocator.Current.GetInstance<ILanguageBranchRepository>().ListEnabled(); foreach (LanguageBranch languageBranch in allLanguages) { allEvents.Add(DataFactory.Instance.FindPagesWithCriteria(siteDefinition.StartPage.ToPageReference(), criteria, languageBranch.LanguageID)); } foreach (PageData currentEvent in allEvents) { if (currentEvent as EventPageBase != null) eventList.Add(currentEvent as EventPageBase); } } return eventList; }
public void GetChildren_Generic_WithTwoParameters_ShouldReturnAnEnumerableWOfRequestedType() { using(ShimsContext.Create()) { PageDataCollection pageDataCollection = new PageDataCollection(); int items = DateTime.Now.Millisecond; if(items%2 == 1) items++; for(int i = 0; i < items; i++) { Mock<PageData> pageDataMock = new Mock<PageData>(); if(i%2 == 0) pageDataMock.As<IContentData>(); pageDataCollection.Add(pageDataMock.Object); } ShimDataFactory.StaticConstructor = () => { }; Mock<DataFactoryWrapper> dataFactoryWrapperMock = new Mock<DataFactoryWrapper>(new object[] {new DataFactory(), Mock.Of<IPageDataCaster>(), Mock.Of<IPermanentLinkMapper>()}) {CallBase = true}; dataFactoryWrapperMock.Setup(dataFactoryWrapper => dataFactoryWrapper.GetChildren(It.IsAny<PageReference>(), It.IsAny<ILanguageSelector>())).Returns(pageDataCollection); IEnumerable<IContentData> children = dataFactoryWrapperMock.Object.GetChildren<IContentData>(new ContentReference(DateTime.Now.Millisecond), Mock.Of<ILanguageSelector>()); Assert.AreEqual(items/2, children.Count()); } }
/// <summary> /// Adds an item. /// </summary> /// <param name="item"></param> /// <param name="itemNumber"></param> /// <param name="level"></param> protected void AddItem(PageData item, int itemNumber, int level) { var children = new PageDataCollection(); bool isSelected = IsSelected(item); if (NumberOfLevels > level) if (ExpandSelectedOnly) { if (isSelected) children = GetChildrenItems(item.PageLink); } else children = GetChildrenItems(item.PageLink); if (isSelected) { if (SelectedItemTemplate != null) AddItemTemplate(SelectedItemTemplate, item, itemNumber, true, level, children.Count > 0); else if (ItemTemplate != null) AddItemTemplate(ItemTemplate, item, itemNumber, true, level, children.Count > 0); } else if (ItemTemplate != null) AddItemTemplate(ItemTemplate, item, itemNumber, false, level, children.Count > 0); AddLevel(children, level + 1); if (isSelected) { if (SelectedItemEndTemplate != null) AddItemTemplate(SelectedItemEndTemplate, item, itemNumber, true, level, children.Count > 0); else if (ItemEndTemplate != null) AddItemTemplate(ItemEndTemplate, item, itemNumber, true, level, children.Count > 0); } else if (ItemEndTemplate != null) AddItemTemplate(ItemEndTemplate, item, itemNumber, false, level, children.Count > 0); if (!AddedForLevel.ContainsKey(level)) AddedForLevel.Add(level, false); if (AddedForLevel[level]) { if (!AddSeparatorForLevel.ContainsKey(level)) AddSeparatorForLevel.Add(level, true); else AddSeparatorForLevel[level] = true; AddedForLevel[level] = false; } }
private static Int32 CreateSitemap(PageReference Start, String Path, String TimeFormat) { BaseURL = GetBaseUrl(); String sTimeFormat = TimeFormat != String.Empty ? TimeFormat : "yyyy-MM-dd"; PageDataCollection objCollection = new PageDataCollection(); // Add start page objCollection.Add(DataFactory.Instance.GetPage(Start)); foreach (PageData objPageData in GetPages()) { if (objPageData["PageShortcutType"] == null || (objPageData["PageShortcutType"] != null && ((EPiServer.Core.PageShortcutType)objPageData["PageShortcutType"]) != PageShortcutType.External)) { objCollection.Add(objPageData); } } XmlDocument xDoc = new XmlDocument(); XmlNode xNode = xDoc.CreateXmlDeclaration("1.0", "utf-8", null); xDoc.AppendChild(xNode); XmlNode xURLSet = xDoc.CreateElement("urlset"); XmlAttribute xXMLNS = xDoc.CreateAttribute("xmlns"); xXMLNS.Value = "http://www.sitemaps.org/schemas/sitemap/0.9"; xURLSet.Attributes.Append(xXMLNS); xDoc.AppendChild(xURLSet); Int32 iCounter = 0; foreach (PageData objPageData in objCollection) { foreach (String sLanguage in objPageData.PageLanguages) { XmlNode xURLNode = xDoc.CreateElement("url"); XmlNode xLoc = xDoc.CreateElement("loc"); XmlNode xURL = xDoc.CreateTextNode(GetFriendlyURL(objPageData, sLanguage)); xLoc.AppendChild(xURL); xURLNode.AppendChild(xLoc); XmlNode xLastMod = xDoc.CreateElement("lastmod"); xLastMod.AppendChild(xDoc.CreateTextNode(objPageData.Saved.ToString(sTimeFormat))); xURLNode.AppendChild(xLastMod); // Optional change frequency if (objPageData["ChangeFrequency"] != null && objPageData["ChangeFrequency"].ToString() != String.Empty) { XmlNode xChangeFrequency = xDoc.CreateElement("changefreq"); xChangeFrequency.AppendChild(xDoc.CreateTextNode(objPageData["ChangeFrequency"].ToString())); xURLNode.AppendChild(xChangeFrequency); } // Optional priority if (objPageData["Priority"] != null && objPageData["Priority"].ToString() != String.Empty) { XmlNode xPriority = xDoc.CreateElement("priority"); xPriority.AppendChild(xDoc.CreateTextNode(objPageData["Priority"].ToString())); xURLNode.AppendChild(xPriority); } xURLSet.AppendChild(xURLNode); iCounter++; } } xDoc.Save(Path); return iCounter; }
private void AddParentIfRequired(PageData child, PageDataCollection items) { if (child.PageLink.CompareToIgnoreWorkID(SiteRoot)) return; if (child.ParentLink.IsResolvable()) { if (child.ParentLink.CompareToIgnoreWorkID(Settings.Instance.PageRootId.ToPageReference())) return; items.Insert(0, child.ParentLink.ToPageData()); AddParentIfRequired(child.ParentLink.ToPageData(), items); } }
private PageDataCollection GetItems() { var items = new PageDataCollection(); PageData currentItem = CurrentPage.ToPageData(); AddParentIfRequired(currentItem, items); items.ForVisitor(); if (!ShowPagesNotVisibleInMenu) items.VisibleInMenu(); items.Add(currentItem); return items; }
protected override void because() { base.because(); _results = system_under_test.FindDescendantsOf(PageReference.StartPage).ToPageDataCollection(); }
protected override void establish_context() { base.establish_context(); _expected = new PageDataCollection() { new PageData() }; executor.Stub(e => e.FindPagesWithCriteria(null)).IgnoreArguments().Return(_expected); }
/// <summary> /// An empty method which can be overridden by descendants which /// implements paging. /// </summary> /// <param name="items"></param> protected virtual void ApplyPagingFilter(PageDataCollection items) { }
/// <summary> /// Adds a level. /// </summary> /// <param name="items"></param> /// <param name="level"></param> protected void AddLevel(PageDataCollection items, int level) { if (items.Count > 0) { AddLevelStartTemplate(level); for (int i = 0; i < items.Count; i++) { AddItem(items[i], i + 1, level); } AddLevelEndTemplate(level); } }
public void GetChildren_WithTwoParameters_ShouldCallGetChildrenWithTwoParametersOfTheWrappedDataFactory() { using(ShimsContext.Create()) { bool getChildrenIsCalled = false; PageReference pageLinkValue = null; ILanguageSelector selectorValue = null; PageDataCollection pageDataCollection = new PageDataCollection(); ShimDataFactory.StaticConstructor = () => { }; DataFactory dataFactory = new DataFactory(); new ShimDataFactory(dataFactory).GetChildrenPageReferenceILanguageSelector = delegate(PageReference pageLink, ILanguageSelector selector) { getChildrenIsCalled = true; pageLinkValue = pageLink; selectorValue = selector; return pageDataCollection; }; PageReference pageLinkParameter = new PageReference(); ILanguageSelector selectorParameter = Mock.Of<ILanguageSelector>(); Assert.IsFalse(getChildrenIsCalled); Assert.AreEqual(pageDataCollection, new DataFactoryWrapper(dataFactory, Mock.Of<IPageDataCaster>(), Mock.Of<IPermanentLinkMapper>()).GetChildren(pageLinkParameter, selectorParameter)); Assert.IsTrue(getChildrenIsCalled); Assert.AreEqual(pageLinkParameter, pageLinkValue); Assert.AreEqual(selectorParameter, selectorValue); } }
public void GetChildren_WithFourParameters_ShouldCallGetChildrenWithFourParametersOfTheWrappedDataFactory() { using(ShimsContext.Create()) { bool getChildrenIsCalled = false; PageReference pageLinkValue = null; ILanguageSelector selectorValue = null; int? startIndexValue = null; int? maxRowsValue = null; PageDataCollection pageDataCollection = new PageDataCollection(); ShimDataFactory.StaticConstructor = () => { }; DataFactory dataFactory = new DataFactory(); new ShimDataFactory(dataFactory).GetChildrenPageReferenceILanguageSelectorInt32Int32 = delegate(PageReference pageLink, ILanguageSelector selector, int startIndex, int maxRows) { getChildrenIsCalled = true; pageLinkValue = pageLink; selectorValue = selector; startIndexValue = startIndex; maxRowsValue = maxRows; return pageDataCollection; }; PageReference pageLinkParameter = new PageReference(); ILanguageSelector selectorParameter = Mock.Of<ILanguageSelector>(); int startIndexParameter = DateTime.Now.Second; int maxRowsParameter = DateTime.Now.Millisecond; Assert.IsFalse(getChildrenIsCalled); Assert.AreEqual(pageDataCollection, new DataFactoryWrapper(dataFactory, Mock.Of<IPageDataCaster>(), Mock.Of<IPermanentLinkMapper>()).GetChildren(pageLinkParameter, selectorParameter, startIndexParameter, maxRowsParameter)); Assert.IsTrue(getChildrenIsCalled); Assert.AreEqual(pageLinkParameter, pageLinkValue); Assert.AreEqual(selectorParameter, selectorValue); Assert.AreEqual(startIndexValue.Value, startIndexParameter); Assert.AreEqual(maxRowsValue.Value, maxRowsParameter); } }