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 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);
}
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 EntityToken TryGetEntityToken(string url)
{
UrlKind urlKind;
PageUrlData pageUrlData = PageUrls.ParseUrl(url, out urlKind);
if (pageUrlData == null)
{
return(null);
}
if (pageUrlData.PublicationScope == PublicationScope.Published)
{
pageUrlData.PublicationScope = PublicationScope.Unpublished;
}
if (!string.IsNullOrEmpty(pageUrlData.PathInfo) || pageUrlData.HasQueryParameters)
{
IData data;
var dataReference = DataUrls.TryGetData(pageUrlData);
if (dataReference != null && (data = dataReference.Data) != null)
{
return(data.GetDataEntityToken());
}
}
IPage page = pageUrlData.GetPage();
if (page == null)
{
return(null);
}
return(page.GetDataEntityToken());
}
public RoutedDataModel GetRouteDataModel(PageUrlData pageUrlData)
{
if (pageUrlData.PageId != _pageId)
{
return(null);
}
string pathInfo = pageUrlData.PathInfo;
bool pathIsEmpty = string.IsNullOrEmpty(pathInfo);
if (pathIsEmpty && !pageUrlData.HasQueryParameters)
{
return(new RoutedDataModel(GetDataQueryable));
}
int totalSegments = _mapper.PathSegmentsCount;
if (pathIsEmpty != (totalSegments == 0))
{
return(null);
}
string[] segments = !pathIsEmpty
? pathInfo.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
: new string[0];
if (segments.Length != totalSegments)
{
return(null);
}
var relativeRoute = new RelativeRoute
{
PathSegments = segments,
QueryString = pageUrlData.QueryParameters
};
var filterExpression = GetPredicate(_pageId, relativeRoute);
if (filterExpression == null)
{
return(null);
}
var dataSet = (IReadOnlyCollection <IData>)_getFilteredDataMethodInfo.MakeGenericMethod(_dataType)
.Invoke(null, new object[] { filterExpression });
if (dataSet.Count == 0)
{
return(null);
}
if (dataSet.Count > 1)
{
throw new DataUrlCollisionException(_dataType, relativeRoute);
}
return(new RoutedDataModel(dataSet.First()));
}
public static Guid GetWebsiteIdFromPageUrlData(PageUrlData pageUrlData)
{
if (pageUrlData == null)
{
return(Guid.Empty);
}
return(PageStructureInfo.GetAssociatedPageIds(pageUrlData.PageId, SitemapScope.AncestorsAndCurrent).LastOrDefault());
}
/// <exclude />
public static IPage GetPage(this PageUrlData pageUrlData)
{
Verify.ArgumentNotNull(pageUrlData, "pageUrlData");
using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope))
{
return(PageManager.GetPageById(pageUrlData.PageId));
}
}
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>
/// Returns localized URL. It was changed from original implementation to fix 6520: Previewing unpublished category pages is C1 console shows error in the preview, and on frontend once the page is published
/// </summary>
/// <param name="pageId"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public virtual string GetRendererPageUrl(Guid pageId, CultureInfo cultureInfo = null)
{
if (cultureInfo == null)
{
cultureInfo = DataLocalizationFacade.DefaultLocalizationCulture;
}
var pageUrlData = new PageUrlData(pageId, PublicationScope.Published, cultureInfo);
return(PageUrls.BuildUrl(pageUrlData, UrlKind.Renderer));
}
public static PageUrlData GetPageUrlDataFromUrl(string urlStr)
{
PageUrlData pageUrlData = null;
while (pageUrlData == null && urlStr.LastIndexOf('/') > 0)
{
urlStr = urlStr.Substring(0, urlStr.LastIndexOf('/'));
pageUrlData = PageUrls.ParseUrl(urlStr);
}
return(pageUrlData);
}
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);
}
/// <exclude />
public static IPage GetPage(this PageUrlData pageUrlData)
{
Verify.ArgumentNotNull(pageUrlData, nameof(pageUrlData));
using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope))
{
if (pageUrlData.VersionId != null)
{
return(PageManager.GetPageById(pageUrlData.PageId, pageUrlData.VersionId.Value));
}
return(PageManager.GetPageById(pageUrlData.PageId));
}
}
/// <summary>
/// Looks for a friendly URL and set pageUrl if found.
/// </summary>
/// <param name="relativeUrl">The string to match to a friendly URL</param>
/// <param name="pageUrl">The matching page, if a match was found. Otherwise null.</param>
/// <returns>True if a friendly URL match was found</returns>
public static bool TryParseFriendlyUrl(string relativeUrl, out PageUrl pageUrl)
{
UrlKind urlKind;
PageUrlData pageUrlData = PageUrls.ParseUrl(relativeUrl, new UrlSpace(), out urlKind);
if (pageUrlData == null || urlKind != UrlKind.Friendly)
{
pageUrl = null;
return(false);
}
pageUrl = new PageUrl(pageUrlData.PublicationScope, pageUrlData.LocalizationScope, pageUrlData.PageId, PageUrlType.Friendly);
return(true);
}
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 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);
}
protected override void OnPreInit(EventArgs e)
{
_pageId = Guid.Parse(Request.QueryString["pageId"]);
using (new DataScope(PublicationScope.Published, new CultureInfo("en-GB")))
{
using (var data = new DataConnection())
{
PageRenderer.CurrentPage = data.Get <IPage>().Single(p => p.Id == _pageId);
var urlData = new PageUrlData(PageRenderer.CurrentPage);
urlData.PathInfo = Request.QueryString["pathInfo"];
Context.Items["C1_PageUrl"] = urlData;
}
}
base.OnPreInit(e);
}
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));
}
internal static PageUrl ParsePublicUrl(UrlBuilder urlBuilder, out NameValueCollection notUsedQueryParameters)
{
UrlKind urlKind;
PageUrlData pageUrlData = PageUrls.ParseUrl(urlBuilder.ToString(), out urlKind);
if (pageUrlData == null || urlKind != UrlKind.Public)
{
notUsedQueryParameters = null;
return(null);
}
notUsedQueryParameters = pageUrlData.QueryParameters;
return(new PageUrl(pageUrlData.PublicationScope, pageUrlData.LocalizationScope, pageUrlData.PageId, PageUrlType.Public));
}
/// <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 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);
}
public void HandleConsoleCommand(string consoleId, string commandPayload)
{
string url = commandPayload;
var entityToken = UrlToEntityTokenFacade.TryGetEntityToken(url);
if (entityToken == null)
{
PageUrlData pageUrlData = PageUrls.ParseUrl(url);
var page = pageUrlData?.GetPage();
if (page == null)
{
return;
}
entityToken = page.GetDataEntityToken();
}
ConsoleCommandHelper.SelectConsoleElement(consoleId, entityToken);
}
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 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.");
}
public C1PageRouteHandler(PageUrlData pageUrlData)
{
_pageUrlData = pageUrlData;
}
public PageUrlData ParseUrl(string relativeUrl, UrlSpace urlSpace, out UrlKind urlKind)
{
if (IsInternalUrl(relativeUrl))
{
return(ParseInternalUrl(relativeUrl, out urlKind));
}
var urlBuilder = new UrlBuilder(relativeUrl);
// Structure of a public url:
// http://<hostname>[/ApplicationVirtualPath]{/languageCode}[/Path to a page][/c1mode(unpublished)][/c1mode(relative)][UrlSuffix]{/PathInfo}
string filePathAndPathInfo = HttpUtility.UrlDecode(urlBuilder.FullPath);
filePathAndPathInfo = RemoveUrlMarkers(filePathAndPathInfo, urlSpace);
string pathWithoutLanguageCode;
IHostnameBinding hostnameBinding = urlSpace.ForceRelativeUrls ? null : GetHostnameBindings().FirstOrDefault(b => b.Hostname == urlSpace.Hostname);
CultureInfo locale = GetCultureInfo(filePathAndPathInfo, hostnameBinding, out pathWithoutLanguageCode);
if (locale == null)
{
urlKind = UrlKind.Undefined;
return(null);
}
var publicationScope = PublicationScope.Published;
if (filePathAndPathInfo.Contains(UrlMarker_Unpublished))
{
publicationScope = PublicationScope.Unpublished;
pathWithoutLanguageCode = pathWithoutLanguageCode.Replace(UrlMarker_Unpublished, string.Empty);
if (pathWithoutLanguageCode == string.Empty)
{
pathWithoutLanguageCode = "/";
}
}
using (new DataScope(publicationScope, locale))
{
bool isObsolete = false;
string pathToResolve = pathWithoutLanguageCode;
// Supporting obsolete "*.aspx" urls
if (!string.Equals(UrlSuffix, ".aspx", StringComparison.OrdinalIgnoreCase) &&
(pathToResolve.Contains(".aspx/") || pathToResolve.EndsWith(".aspx")))
{
pathToResolve = pathToResolve.Replace(".aspx", UrlSuffix);
isObsolete = true;
}
PageUrlData data = ParsePagePath(pathToResolve, publicationScope, locale, hostnameBinding);
if (data != null)
{
urlKind = !isObsolete ? UrlKind.Public : UrlKind.Redirect;
data.QueryParameters = urlBuilder.GetQueryParameters();
return(data);
}
Guid friendlyUrlPageId = ParseFriendlyUrlPath(pathWithoutLanguageCode);
if (friendlyUrlPageId != Guid.Empty)
{
urlKind = UrlKind.Friendly;
return(new PageUrlData(friendlyUrlPageId, publicationScope, locale)
{
QueryParameters = urlBuilder.GetQueryParameters()
});
}
}
urlKind = UrlKind.Undefined;
return(null);
}
/// <summary>
/// Pasres the url, and checks if the urls can be validated without making an http request (for internal urls=.
/// </summary>
private UrlPreprocessResult PreprocessUrl(
string url,
string pageUrl,
string serverUrl,
out BrokenLinkType brokenLinkType,
out RequestValidationInfo requestValidationInfo)
{
BrokenLinkType cachedResult;
requestValidationInfo = null;
if (_brokenLinks.TryGetValue(url, out cachedResult))
{
brokenLinkType = cachedResult;
return(brokenLinkType == BrokenLinkType.None ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
// Trying to parse as a page url first
PageUrlData pageUrlData = null;
try
{
if (IsKnownHostname(url)) // Workaround "if" for early vesrions of 4.0 beta
{
pageUrlData = PageUrls.ParseUrl(url);
}
}
catch (UriFormatException)
{
}
if (pageUrlData != null)
{
Guid linkedPageId = pageUrlData.PageId;
IPage page;
using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope))
{
page = PageManager.GetPageById(linkedPageId);
}
if (page == null)
{
if (pageUrlData.PublicationScope == PublicationScope.Published)
{
using (new DataScope(PublicationScope.Unpublished, pageUrlData.LocalizationScope))
{
if (PageManager.GetPageById(linkedPageId) != null)
{
brokenLinkType = BrokenLinkType.PageNotPublished;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
}
}
brokenLinkType = BrokenLinkType.Page;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
// If no PathInfo - page link is already valid
if (string.IsNullOrEmpty(pageUrlData.PathInfo))
{
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.Valid);
}
// If there's pathInfo -> making a request to check whether the link is actually broken
requestValidationInfo = GetRequestValidationInfo(url, pageUrl, serverUrl, BrokenLinkType.Page);
if (requestValidationInfo == null)
{
brokenLinkType = BrokenLinkType.Page;
return(UrlPreprocessResult.Broken);
}
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.NeedToBeValidatedByRequest);
}
MediaUrlData mediaUrlData = MediaUrls.ParseUrl(url);
if (mediaUrlData != null)
{
Guid mediaId = mediaUrlData.MediaId;
string mediastore = mediaUrlData.MediaStore;
bool mediaExist = DataFacade.GetData <IMediaFile>().Any(f => f.StoreId == mediastore && f.Id == mediaId);
brokenLinkType = mediaExist ? BrokenLinkType.None : BrokenLinkType.MediaLibrary;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
var linkType = UrlHelper.IsAbsoluteLink(url) ? BrokenLinkType.External : BrokenLinkType.Relative;
requestValidationInfo = GetRequestValidationInfo(url, pageUrl, serverUrl, linkType);
if (requestValidationInfo == null)
{
brokenLinkType = linkType;
return(UrlPreprocessResult.Broken);
}
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.NeedToBeValidatedByRequest);
}
public C1PageRouteHandler(PageUrlData pageUrlData)
{
_pageUrlData = pageUrlData;
}
private void InitializeFromHttpContextInternal()
{
HttpContext httpContext = HttpContext.Current;
var request = httpContext.Request;
var response = httpContext.Response;
ProfilingEnabled = request.Url.OriginalString.Contains("c1mode=perf");
if (ProfilingEnabled)
{
if (!UserValidationFacade.IsLoggedIn())
{
string loginUrl = GetLoginRedirectUrl(request.RawUrl);
response.Write(@"You must be logged into <a href=""" + loginUrl + @""">C1 console</a> to have the performance view enabled");
response.End(); // throws ThreadAbortException
return;
}
Profiler.BeginProfiling();
_pagePerfMeasuring = Profiler.Measure("C1 Page");
}
_previewKey = request.QueryString["previewKey"];
PreviewMode = !_previewKey.IsNullOrEmpty();
if (PreviewMode)
{
Page = (IPage)HttpRuntime.Cache.Get(_previewKey + "_SelectedPage");
C1PageRoute.PageUrlData = new PageUrlData(Page);
PageRenderer.RenderingReason = (RenderingReason)HttpRuntime.Cache.Get(_previewKey + "_RenderingReason");
}
else
{
PageUrlData pageUrl = C1PageRoute.PageUrlData ?? PageUrls.UrlProvider.ParseInternalUrl(request.Url.OriginalString);
Page = pageUrl.GetPage();
_cachedUrl = request.Url.PathAndQuery;
PageRenderer.RenderingReason = new UrlSpace(httpContext).ForceRelativeUrls
? RenderingReason.C1ConsoleBrowserPageView
: RenderingReason.PageView;
}
ValidateViewUnpublishedRequest(httpContext);
if (Page == null)
{
throw new HttpException(404, "Page not found - either this page has not been published yet or it has been deleted.");
}
if (Page.DataSourceId.PublicationScope != PublicationScope.Published)
{
response.Cache.SetCacheability(HttpCacheability.NoCache);
CachingDisabled = true;
}
PageRenderer.CurrentPage = Page;
_dataScope = new DataScope(Page.DataSourceId.PublicationScope, Page.DataSourceId.LocaleScope);
var pagePlaceholderContents = GetPagePlaceholderContents();
var pageRenderingJob = new PageContentToRender(Page, pagePlaceholderContents, PreviewMode);
Verify.IsNotNull(httpContext.Handler, "HttpHandler isn't defined");
var aspnetPage = (System.Web.UI.Page)httpContext.Handler;
var pageRenderer = PageTemplateFacade.BuildPageRenderer(Page.TemplateId);
pageRenderer.AttachToPage(aspnetPage, pageRenderingJob);
}
public IDataReference GetData(PageUrlData pageUrlData)
{
var model = _mapper.GetRouteDataModel(pageUrlData);
return(model.IsRouteResolved && model.IsItem ? model.Item.ToDataReference() : null);
}
/// <exclude />
public override RouteData GetRouteData(HttpContextBase context)
{
if (!SystemSetupFacade.IsSystemFirstTimeInitialized)
{
return(null);
}
string localPath = context.Request.Url.LocalPath;
var urlProvider = PageUrls.UrlProvider;
if (UrlUtils.IsAdminConsoleRequest(localPath) || IsRenderersPath(localPath))
{
return(null);
}
string currentUrl = context.Request.Url.OriginalString;
UrlKind urlKind;
PageUrlData pageUrlData = urlProvider.ParseUrl(currentUrl, out urlKind);
if (pageUrlData == null || urlKind == UrlKind.Renderer)
{
return(null);
}
var urlSpace = new UrlSpace(context);
// Redirecting friendly urls to public urls
if (urlKind == UrlKind.Friendly || urlKind == UrlKind.Redirect || urlKind == UrlKind.Internal)
{
if (pageUrlData.PathInfo == "/")
{
pageUrlData.PathInfo = null;
}
string publicUrl = urlProvider.BuildUrl(pageUrlData, UrlKind.Public, urlSpace);
if (publicUrl == null)
{
if (urlKind != UrlKind.Internal)
{
return(null);
}
// Rendering internal url if public url is missing
}
else
{
return(GetRedirectRoute(publicUrl));
}
}
Verify.That(urlKind == UrlKind.Public || urlKind == UrlKind.Internal, "Unexpected url kind '{0}", urlKind);
bool isPublicUrl = urlKind == UrlKind.Public;
if (isPublicUrl)
{
// If url ends with a trailing slash - doing a redirect. F.e. http://localhost/a/ -> http://localhost/a
if (pageUrlData.PathInfo == "/")
{
pageUrlData.PathInfo = null;
return(GetRedirectRoute(urlProvider.BuildUrl(pageUrlData, UrlKind.Public, urlSpace)));
}
// Checking casing in url, so the same page will not appear as a few pages by a crawler
string correctUrl = urlProvider.BuildUrl(pageUrlData, UrlKind.Public, urlSpace);
Verify.IsNotNull(correctUrl, "Failed to rebuild a public url from url '{0}'", currentUrl);
string originalFilePath = new UrlBuilder(currentUrl).RelativeFilePath;
string correctFilePath = new UrlBuilder(correctUrl).RelativeFilePath;
string decodedOriginalPath = HttpUtility.UrlDecode(originalFilePath);
string decodedCorrectFilePath = HttpUtility.UrlDecode(correctFilePath);
if (!urlSpace.ForceRelativeUrls &&
(originalFilePath.Length != correctFilePath.Length &&
decodedOriginalPath != correctFilePath &&
decodedOriginalPath != decodedCorrectFilePath) ||
(string.Compare(originalFilePath, correctFilePath, false, CultureInfo.InvariantCulture) != 0 &&
string.Compare(originalFilePath, correctFilePath, true, CultureInfo.InvariantCulture) == 0) &&
decodedOriginalPath != decodedCorrectFilePath)
{
// redirect to a url with right casing
return(GetRedirectRoute(correctUrl));
}
}
// GetRouteData may be executed multiple times
if (!context.Items.Contains(HttpContextItem_C1PageUrl))
{
PageUrlData = pageUrlData;
}
var data = new RouteData(this, new C1PageRouteHandler(pageUrlData));
data.Values.Add(RouteData_PageUrl, pageUrlData);
return(data);
}
public RoutedDataModel GetRouteDataModel(PageUrlData pageUrlData)
{
string pathInfo = pageUrlData.PathInfo;
if (pathInfo.IsNullOrEmpty())
{
return(new RoutedDataModel(GetListQueryable));
}
switch (_dataRouteKind)
{
case DataRouteKind.Key:
case DataRouteKind.KeyAndLabel:
{
string key;
string label = null;
if (_dataRouteKind == DataRouteKind.KeyAndLabel)
{
string[] parts = pathInfo.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 2)
{
return(new RoutedDataModel());
}
key = parts[0];
label = parts.Length == 2 ? parts[1] : null;
}
else
{
if (pathInfo.Length < 2 || pathInfo.LastIndexOf('/') > 0)
{
return(new RoutedDataModel());
}
key = pathInfo.Substring(1);
}
var keyType = _keyPropertyInfo.PropertyType;
object keyValue = ValueTypeConverter.Convert(key, keyType);
if (keyValue == null ||
(keyValue is Guid && (Guid)keyValue == Guid.Empty && key != Guid.Empty.ToString()))
{
return(new RoutedDataModel());
}
var data = DataFacade.TryGetDataByUniqueKey <T>(keyValue);
return(new RoutedDataModel(data));
}
case DataRouteKind.Label:
{
if (pathInfo.Length < 2 || pathInfo.LastIndexOf('/') > 0)
{
return(new RoutedDataModel());
}
string label = UrlUtils.DecodeUrlInvalidCharacters(pathInfo.Substring(1));
var data = GetDataByLabel(label);
return(new RoutedDataModel(data));
}
default:
throw new InvalidOperationException("Not supported data url kind: " + _dataRouteKind);
}
}
