public IDataReference GetData(PageUrlData pageUrlData)
{
string pathInfo = pageUrlData.PathInfo;
if (pathInfo == null)
{
return null;
}
string[] pathInfoParts = pathInfo.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (pathInfoParts.Length != 4) return null;
if (string.IsNullOrEmpty(pathInfo)) return null;
int year, month, day;
if (int.TryParse(pathInfoParts[0], out year)
&& int.TryParse(pathInfoParts[1], out month)
&& int.TryParse(pathInfoParts[2], out day)
&& DateTimeUtils.IsValidDate(year, month, day))
{
Guid pageId = pageUrlData.PageId;
string titleUrl = pathInfoParts[3];
var date = new DateTime(year, month, day);
var data = DataFacade.GetData<NewsItem>()
.FirstOrDefault(n => n.PageId == pageId && n.Date.Date == date && n.TitleUrl == titleUrl);
return data != null ? data.ToDataReference() : null;
}
return null;
}
public string TryGetUrl(EntityToken entityToken)
{
var dataEntityToken = entityToken as DataEntityToken;
if (dataEntityToken == null)
{
return null;
}
var data = dataEntityToken.Data;
if (data == null)
{
return null;
}
PageUrlData pageUrlData;
var page = data as IPage;
if (page != null)
{
pageUrlData = new PageUrlData(page);
}
else
{
pageUrlData = DataUrls.TryGetPageUrlData(data.ToDataReference());
}
return pageUrlData != null ? GetPagePreviewUrl(pageUrlData) : null;
}
private static string GetPagePreviewUrl(PageUrlData pageUrlData)
{
var httpContext = HttpContext.Current;
var urlSpace = new UrlSpace();
if (HostnameBindingsFacade.GetBindingForCurrentRequest() != null
|| HostnameBindingsFacade.GetAliasBinding(httpContext) != null)
{
urlSpace.ForceRelativeUrls = true;
}
return PageUrls.BuildUrl(pageUrlData, UrlKind.Public, urlSpace)
?? PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer, urlSpace);
}
/// <summary>
/// Gets the data item by page url data; returns <value>null</value> if no data url mappers found.
/// </summary>
/// <param name="pageUrlData"></param>
/// <returns></returns>
public static IDataReference TryGetData(PageUrlData pageUrlData)
{
Verify.ArgumentNotNull(pageUrlData, "pageUrlData");
if (string.IsNullOrEmpty(pageUrlData.PathInfo) && !pageUrlData.HasQueryParameters)
{
return(null);
}
foreach (var globalDataUrlMapper in _globalDataUrlMappers)
{
try
{
var data = globalDataUrlMapper.Value.GetData(pageUrlData);
if (data != null)
{
return(data);
}
}
catch (Exception ex)
{
Log.LogError(LogTitle, ex);
}
}
var page = pageUrlData.GetPage();
if (page == null)
{
return(null);
}
foreach (var mapper in GetMappersForPage(page.Id))
{
try
{
var data = mapper.GetData(pageUrlData);
if (data != null)
{
return(data);
}
}
catch (Exception ex)
{
Log.LogError(LogTitle, ex);
}
}
return(null);
}
public IDataReference GetData(PageUrlData pageUrlData)
{
string pathInfo = pageUrlData.PathInfo;
if(string.IsNullOrEmpty(pathInfo)) return null;
string[] pathInfoParts = pathInfo.Split('/');
if (pathInfoParts.Length != 5) return null;
var filter = BlogFacade.GetBlogFilter(pageUrlData.PageId, pathInfoParts);
if (filter == null) return null;
var entry = DataFacade.GetData<Entries>().Where(filter).FirstOrDefault();
return entry != null ? entry.ToDataReference() : null;
}
public IDataReference GetData(PageUrlData pageUrlData)
{
if (_pageId.HasValue && pageUrlData.PageId != _pageId.Value)
{
return null;
}
string pathInfo = pageUrlData.PathInfo;
if(string.IsNullOrEmpty(pathInfo)) return null;
string fieldUrlFragment;
string[] urlParts = pathInfo.Split(new []{'/'}, StringSplitOptions.RemoveEmptyEntries);
if (_actionName != null)
{
if (urlParts.Length != 2 || !_actionName.Equals(urlParts[0], StringComparison.OrdinalIgnoreCase))
{
return null;
}
fieldUrlFragment = urlParts[1];
}
else
{
if (urlParts.Length != 1) return null;
fieldUrlFragment = urlParts[0];
}
var fieldType = _propertyInfo.PropertyType;
object keyValue = ValueTypeConverter.Convert(fieldUrlFragment, fieldType);
if (keyValue == null
|| (keyValue is Guid && (Guid)keyValue == Guid.Empty && fieldUrlFragment != Guid.Empty.ToString()))
{
return null;
}
IData data = _isKeyField
? DataFacade.TryGetDataByUniqueKey(_dataType, keyValue)
: GetDataByLabel(fieldUrlFragment);
return data != null ? data.ToDataReference() : null;
}
public string BuildUrl(PageUrlData pageUrlData, UrlKind urlKind, UrlSpace urlSpace)
{
Verify.ArgumentCondition(urlKind != UrlKind.Undefined, "urlKind", "Url kind is undefined");
/*var page = pageUrlData.Data;
Verify.ArgumentCondition(page != null, "urlData", "Failed to get page from UrlData<IPage>");*/
if (urlKind == UrlKind.Public)
{
return BuildPublicUrl(pageUrlData, urlSpace);
}
if (urlKind == UrlKind.Renderer)
{
return BuildRenderUrl(pageUrlData);
}
if (urlKind == UrlKind.Internal)
{
return BuildInternalUrl(pageUrlData);
}
throw new NotImplementedException("Only 'Public' and 'Internal' url types are supported.");
}
/// <summary>
/// Fixes up the hostname when using the preview-tab in the Console, since the requested page can belong to
/// a different domain than the console was opened in
/// </summary>
/// <param name="uri">The URI.</param>
/// <returns></returns>
protected Uri ProcessUrl(Uri uri)
{
PageUrlData urlData;
var context = HttpContext.Current;
var overriddenContext = SiteMapContext.Current;
if (overriddenContext != null)
{
urlData = new PageUrlData(overriddenContext.RootPage);
}
else
{
string currentUrl = context.Request.Url.ToString();
string _previewKey = context.Request.QueryString["previewKey"];
if (!String.IsNullOrEmpty(_previewKey))
{
var page = (IPage)context.Cache.Get(_previewKey + "_SelectedPage");
urlData = new PageUrlData(page);
}
else
{
urlData = PageUrls.ParseUrl(currentUrl);
}
}
if (urlData != null)
{
var publicUrl = PageUrls.BuildUrl(urlData, UrlKind.Public, new UrlSpace { Hostname = uri.Host, ForceRelativeUrls = false });
if (Uri.IsWellFormedUriString(publicUrl, UriKind.Absolute))
{
var newHost = new Uri(publicUrl).Host;
uri = new Uri(ReplaceFirstOccurrence(uri.ToString(), uri.Host, newHost));
}
}
return uri;
}
private static string BuildInternalUrl(PageUrlData pageUrlData)
{
var cultureInfo = pageUrlData.LocalizationScope;
var publicationScope = pageUrlData.PublicationScope;
var result = new UrlBuilder("~/page(" + pageUrlData.PageId + ")");
string pathInfo = string.Empty;
if (publicationScope == PublicationScope.Unpublished)
{
pathInfo = UrlMarker_Unpublished;
}
if (!pageUrlData.PathInfo.IsNullOrEmpty())
{
pathInfo += pageUrlData.PathInfo;
}
result.PathInfo = pathInfo;
result["cultureInfo"] = cultureInfo.ToString();
if (pageUrlData.QueryParameters != null)
{
result.AddQueryParameters(pageUrlData.QueryParameters);
}
return result;
}
private static string BuildRenderUrl(PageUrlData pageUrlData)
{
var cultureInfo = pageUrlData.LocalizationScope;
string legacyScopeName = GetLegacyPublicationScopeIdentifier(pageUrlData.PublicationScope);
string basePath = UrlUtils.ResolvePublicUrl("Renderers/Page.aspx");
var result = new UrlBuilder(basePath);
result["pageId"] = pageUrlData.PageId.ToString();
result["cultureInfo"] = cultureInfo.ToString();
result["dataScope"] = legacyScopeName;
result.PathInfo = pageUrlData.PathInfo;
if (pageUrlData.QueryParameters != null)
{
result.AddQueryParameters(pageUrlData.QueryParameters);
}
return result;
}
private string BuildPublicUrl(PageUrlData pageUrlData, UrlSpace urlSpace)
{
var cultureInfo = pageUrlData.LocalizationScope;
var publicationScope = pageUrlData.PublicationScope;
var pageUrlPath = new StringBuilder();
using (new DataScope(publicationScope, cultureInfo))
{
if (!BuildPageUrlPath(pageUrlData.PageId, cultureInfo, urlSpace, pageUrlPath))
{
return null;
}
}
if (publicationScope == PublicationScope.Unpublished)
{
AppendUrlPart(pageUrlPath, UrlMarker_Unpublished);
}
if (urlSpace.ForceRelativeUrls)
{
AppendUrlPart(pageUrlPath, UrlMarker_RelativeUrl);
}
if (!string.IsNullOrEmpty(UrlSuffix)
&& pageUrlPath[pageUrlPath.Length - 1] != '/')
{
pageUrlPath.Append(UrlSuffix);
}
if (!string.IsNullOrEmpty(pageUrlData.PathInfo))
{
AppendPathInfo(pageUrlPath, pageUrlData.PathInfo);
}
string url = pageUrlPath.ToString();
if (pageUrlData.QueryParameters != null)
{
var urlWithQuery = new UrlBuilder(url);
urlWithQuery.AddQueryParameters(pageUrlData.QueryParameters);
return urlWithQuery;
}
return url;
}
/// <summary>
/// Builds the URL.
/// </summary>
/// <param name="pageUrlData">The page URL data.</param>
/// <param name="urlKind">Kind of the URL.</param>
/// <param name="urlSpace">The URL space.</param>
/// <returns></returns>
public static string BuildUrl(PageUrlData pageUrlData, UrlKind urlKind = UrlKind.Public, UrlSpace urlSpace = null)
{
Verify.ArgumentNotNull(pageUrlData, "pageUrlData");
return(UrlProvider.BuildUrl(pageUrlData, urlKind, urlSpace ?? new UrlSpace()));
}
private static string GetPagePreviewUrl(PageUrlData pageUrlData)
{
var urlSpace = new UrlSpace {ForceRelativeUrls = true};
return PageUrls.BuildUrl(pageUrlData, UrlKind.Public, urlSpace)
?? PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer, urlSpace);
}
/// <summary>
/// Builds a url of the the specified URL type.
/// </summary>
/// <param name="urlType">Type of the URL.</param>
/// <returns></returns>
public UrlBuilder Build(PageUrlType urlType)
{
IPage page = GetPage();
if(page == null)
{
return null;
}
PageUrlData pageUrlData = new PageUrlData(page);
string url = PageUrls.BuildUrl(pageUrlData, ToUrlKind(urlType), new UrlSpace());
return url != null ? new UrlBuilder(url) : null;
}
/// <summary>
/// Builds the URL.
/// </summary>
/// <param name="pageUrlData">The page URL data.</param>
/// <param name="urlKind">Kind of the URL.</param>
/// <param name="urlSpace">The URL space.</param>
/// <returns></returns>
public static string BuildUrl(PageUrlData pageUrlData, UrlKind urlKind = UrlKind.Public, UrlSpace urlSpace = null)
{
Verify.ArgumentNotNull(pageUrlData, "pageUrlData");
return UrlProvider.BuildUrl(pageUrlData, urlKind, urlSpace ?? new UrlSpace());
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/xml";
CultureInfo culture = DataLocalizationFacade.DefaultLocalizationCulture;
string pathInfo = context.Request.PathInfo;
if (pathInfo.Length > 1)
{
culture = new CultureInfo(pathInfo.Substring(1));
}
using (var con = new DataConnection(culture))
{
var feed = new SyndicationFeed
{
Title = new TextSyndicationContent("News List")
};
var items = new List<SyndicationItem>();
IQueryable<NewsItem> allNews = con.Get<NewsItem>();
string hostname = context.Request.Url.Host;
var hostnameBinding = con.Get<IHostnameBinding>().FirstOrDefault(h => h.Hostname == hostname);
if (hostnameBinding != null)
{
Guid homepageId = hostnameBinding.HomePageId;
var sm = new SitemapNavigator(con);
var pagesFilter = new HashSet<Guid>(
sm.GetPageNodeById(homepageId)
.GetPageNodes(SitemapScope.DescendantsAndCurrent)
.Select(p => p.Id));
allNews = allNews.Evaluate().Where(n => pagesFilter.Contains(n.PageId)).ToList().AsQueryable();
}
IEnumerable<NewsItem> latestNews = allNews.OrderByDescending(d => d.Date).Take(10);
foreach (var news in latestNews.Evaluate())
{
var page = PageManager.GetPageById(news.PageId);
if (page == null)
{
continue;
}
var pageUrlData = new PageUrlData(page) {PathInfo = NewsFacade.GetPathInfo(news.TitleUrl, news.Date)};
string pageUrl = PageUrls.BuildUrl(pageUrlData);
if (pageUrl == null)
{
continue;
}
var item = new SyndicationItem(
news.Title,
news.Teaser,
context.GetPath(pageUrl),
news.Id.ToString(),
news.Date
);
item.Categories.Add( new SyndicationCategory(news.PageId.ToString()) );
items.Add(item);
}
feed.Items = items;
var writer = new XmlTextWriter(context.Response.Output);
feed.SaveAsRss20(writer);
}
}
