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