/// <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);
}
}
