public string CompositeUrlBuilder() { HttpContext context = System.Web.HttpContext.Current; UrlBuilder urlBuilder = new UrlBuilder(context.Request.RawUrl); urlBuilder.ServerUrl = new UrlBuilder(context.Request.Url.ToString()).ServerUrl; return urlBuilder.ToString(); }
public string ToPublicUrl(string internalMediaUrl, UrlSpace urlSpace) { int openBracketIndex = internalMediaUrl.IndexOf("(", StringComparison.Ordinal); if (openBracketIndex < 0) { return null; } int closingBracketOffset = internalMediaUrl.IndexOf(")", openBracketIndex + 1, StringComparison.Ordinal); if (closingBracketOffset < 0) { return null; } Guid mediaId; string mediaStore; string mediaIdStr = internalMediaUrl.Substring(openBracketIndex + 1, closingBracketOffset - openBracketIndex - 1); int semicolonOffset = mediaIdStr.IndexOf(":", StringComparison.Ordinal); if (semicolonOffset > 0) { mediaStore = mediaIdStr.Substring(0, semicolonOffset); mediaIdStr = mediaIdStr.Substring(semicolonOffset + 1); } else { mediaStore = DefaultMediaStore; } if (!Guid.TryParse(mediaIdStr, out mediaId)) { return null; } UrlBuilder parsedOldUrl; try { parsedOldUrl = new UrlBuilder(internalMediaUrl); } catch { Log.LogWarning(LogTitle, "Failed to parse url '{0}'".FormatWith(internalMediaUrl)); return null; } NameValueCollection queryParams = parsedOldUrl.GetQueryParameters(); return MediaUrls.BuildUrl( new MediaUrlData { MediaId = mediaId, MediaStore = mediaStore, QueryParameters = queryParams }, UrlKind.Public); }
/// <exclude /> public string GetResizedImageUrl(string storeId, Guid mediaId, ResizingOptions resizingOptions) { IMediaFile file = GetFileById(storeId, mediaId); if (file == null) { return null; } string pathToFile = UrlUtils.Combine(file.FolderPath, file.FileName); pathToFile = RemoveForbiddenCharactersAndNormalize(pathToFile); // IIS6 doesn't have wildcard mapping by default, so removing image extension if running in "classic" app pool if (!HttpRuntime.UsingIntegratedPipeline) { int dotOffset = pathToFile.IndexOf(".", StringComparison.Ordinal); if (dotOffset >= 0) { pathToFile = pathToFile.Substring(0, dotOffset); } } string mediaStore = string.Empty; if (!storeId.Equals(DefaultMediaStore, StringComparison.InvariantCultureIgnoreCase)) { mediaStore = storeId + "/"; } var url = new UrlBuilder(UrlUtils.PublicRootPath + "/media/" + mediaStore + /* UrlUtils.CompressGuid(*/ mediaId /*)*/) { PathInfo = file.LastWriteTime != null ? "/" + GetDateTimeHash(file.LastWriteTime.Value.ToUniversalTime()) : string.Empty }; if (pathToFile.Length > 0) { url.PathInfo += pathToFile; } if (resizingOptions != null && !resizingOptions.IsEmpty) { return url + "?" + resizingOptions; } return url.ToString(); }
/// <summary> /// Redirect to page with query string parameter returnUrl /// </summary> /// <param name="pageId"></param> /// <param name="returnUrl"></param> public static bool Redirect(Guid pageId, string returnUrl) { string pageUrl; PageStructureInfo.TryGetPageUrl(pageId, out pageUrl); if (!string.IsNullOrEmpty(pageUrl)) { if (!string.IsNullOrEmpty(returnUrl)) { var urlBuilder = new UrlBuilder(pageUrl); var queryParameters = new NameValueCollection(); queryParameters.Add("returnUrl", returnUrl); urlBuilder.AddQueryParameters(queryParameters); pageUrl = urlBuilder.ToString(); } HttpContext.Current.Response.Redirect(pageUrl, false); return true; } return false; }
public string ToPublicUrl(string internalPageUrl, UrlSpace urlSpace) { PageUrlData pageUrlData; string anchor; try { anchor = new UrlBuilder(internalPageUrl).Anchor; pageUrlData = PageUrls.UrlProvider.ParseInternalUrl(internalPageUrl); } catch { Log.LogWarning(LogTitle, "Failed to parse url '{0}'", internalPageUrl); return null; } if (pageUrlData == null) { return null; } // While viewing pages in "unpublished" scope, all the links should also be in the same scope if (DataScopeManager.CurrentDataScope == DataScopeIdentifier.Administrated) { pageUrlData.PublicationScope = PublicationScope.Unpublished; } string publicPageUrl = PageUrls.BuildUrl(pageUrlData, UrlKind.Public, urlSpace); if (publicPageUrl == null) { // We have this situation if page does not exist return null; } if (!anchor.IsNullOrEmpty()) { publicPageUrl += "#" + anchor; } return publicPageUrl; }
public static string ConvertActionLink(string link, RequestContext requestContext, RouteCollection routeCollection) { var urlBuilder = new UrlBuilder(link); var parameters = urlBuilder.GetQueryParameters(); string actionName = parameters["action"]; string controllerName = parameters["controller"]; if (string.IsNullOrEmpty(actionName) || string.IsNullOrEmpty(controllerName)) { return null; } parameters.Remove("action"); parameters.Remove("controller"); var routeValueDictionary = new RouteValueDictionary(); foreach (var key in parameters.AllKeys) { routeValueDictionary.Add(key, parameters[key]); } return UrlHelper.GenerateUrl(null, actionName, controllerName, routeValueDictionary, routeCollection, requestContext, false); }
public BrokenLinksReport(HttpContext context) { _serverUrl = new UrlBuilder(context.Request.Url.ToString()).ServerUrl; _bindedHostnames = new HashSet<string>(DataFacade.GetData<IHostnameBinding>().AsEnumerable().Select(h => h.Hostname.ToLowerInvariant())); }
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 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 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; }
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; }
private static PageUrlData ParseRendererUrl(UrlBuilder urlBuilder) { NameValueCollection queryString = urlBuilder.GetQueryParameters(); Verify.That(!string.IsNullOrEmpty(queryString["pageId"]), "Invalid query string. The 'pageId' parameter of the GUID type is expected."); string dataScopeName = queryString["dataScope"]; PublicationScope publicationScope = PublicationScope.Published; if (dataScopeName != null && string.Compare(dataScopeName, DataScopeIdentifier.AdministratedName, StringComparison.OrdinalIgnoreCase) == 0) { publicationScope = PublicationScope.Unpublished; } string cultureInfoStr = queryString["cultureInfo"]; if (cultureInfoStr.IsNullOrEmpty()) { cultureInfoStr = queryString["CultureInfo"]; } CultureInfo cultureInfo; if (!cultureInfoStr.IsNullOrEmpty()) { cultureInfo = new CultureInfo(cultureInfoStr); } else { cultureInfo = LocalizationScopeManager.CurrentLocalizationScope; if (cultureInfo.Equals(CultureInfo.InvariantCulture)) { cultureInfo = DataLocalizationFacade.DefaultLocalizationCulture; } } Guid pageId = new Guid(queryString["pageId"]); var queryParameters = new NameValueCollection(); var queryKeys = new[] { "pageId", "dataScope", "cultureInfo", "CultureInfo" }; var notUsedKeys = queryString.AllKeys.Where(key => !queryKeys.Contains(key, StringComparer.OrdinalIgnoreCase)); foreach (string key in notUsedKeys) { queryParameters.Add(key, queryString[key]); } string pathInfo = urlBuilder.PathInfo != null ? HttpUtility.UrlDecode(urlBuilder.PathInfo) : null; return new PageUrlData(pageId, publicationScope, cultureInfo) { PathInfo = pathInfo, QueryParameters = queryParameters, }; }
public PageUrlData ParseUrl(string absoluteUrl, out UrlKind urlKind) { Verify.ArgumentNotNullOrEmpty(absoluteUrl, "absoluteUrl"); // Converting links // "http://localhost" to "http://localhost/" // "http://localhost?..." to "http://localhost/?..." if((absoluteUrl.Count(c => c == '/') == 2) && absoluteUrl.Contains("//")) { int questionMarkIndex = absoluteUrl.IndexOf('?'); if(questionMarkIndex > 0) { absoluteUrl = absoluteUrl.Insert(questionMarkIndex, "/"); } else { absoluteUrl += "/"; } } Uri uri = new Uri(absoluteUrl); string hostname = uri.DnsSafeHost; if(!IsKnownHostname(hostname)) { urlKind = UrlKind.Undefined; return null; } string serverUrl = new UrlBuilder(absoluteUrl).ServerUrl; string relativeUrl = absoluteUrl.Substring(serverUrl.Length - 1); var urlSpace = new UrlSpace(hostname, relativeUrl); return ParseUrl(relativeUrl, urlSpace, out urlKind); }
public bool BuildBrokenLinksReport(XElement infoDocumentRoot) { using (new DataScope(PublicationScope.Published)) { bool noInvalidLinksFound = true; // Get all pages present in the console List<IPage> actionRequiredPages = DataFacade.GetData<IPage>().ToList(); // Check security for each page (does the user have access - no need to bother the user with pages they do not have access to) UserToken userToken = UserValidationFacade.GetUserToken(); var userPermissions = PermissionTypeFacade.GetUserPermissionDefinitions(userToken.Username).ToList(); var userGroupPermissions = PermissionTypeFacade.GetUserGroupPermissionDefinitions(userToken.Username).ToList(); // Loop all pages and remove the ones the user has no access to actionRequiredPages = actionRequiredPages.Where(page => PermissionTypeFacade.GetCurrentPermissionTypes(userToken, page.GetDataEntityToken(), userPermissions, userGroupPermissions) .Contains(PermissionType.Read)).ToList(); var pageIdsWithAccessTo = new HashSet<Guid>(actionRequiredPages.Select(p => p.Id)); var allSitemapElements = PageStructureInfo.GetSiteMap().DescendantsAndSelf(); var relevantElements = allSitemapElements.Where(f => pageIdsWithAccessTo.Contains(new Guid(f.Attribute("Id").Value))); var minimalTree = relevantElements.AncestorsAndSelf().Where(f => f.Name.LocalName == "Page").Distinct().ToList(); var reportElements = new Hashtable<Guid, XElement>(); var linksToCheck = new List<LinkToCheck>(); // Rendering all the C1 pages and collecting links foreach (XElement pageElement in minimalTree) { Guid pageId = new Guid(pageElement.Attribute("Id").Value); IPage page = PageManager.GetPageById(pageId); Verify.IsNotNull(page, "Failed to get the page"); string pageTitle = pageElement.Attribute("MenuTitle") != null ? pageElement.Attribute("MenuTitle").Value : pageElement.Attribute("Title").Value; var resultPageElement = new XElement(PageElementName, new XAttribute("Id", pageId), new XAttribute("Title", pageTitle)); reportElements[pageId] = resultPageElement; string htmlDocument, errorCode; string url = pageElement.Attribute("URL").Value; string pageServerUrl = null; if (url.StartsWith("http://") || (url.StartsWith("https://"))) { pageServerUrl = new UrlBuilder(url).ServerUrl; if (pageServerUrl == string.Empty) pageServerUrl = url; /* Bug in versions < C1 4.0 beta 2 */ } pageServerUrl = pageServerUrl ?? _serverUrl; PageRenderingResult result = RenderPage(url, out htmlDocument, out errorCode); if (result == PageRenderingResult.Failed) { resultPageElement.Add(GetRenderingErrorNode(errorCode)); continue; } if (result == PageRenderingResult.Redirect || result == PageRenderingResult.NotFound) { continue; } XDocument document; try { document = XDocument.Parse(htmlDocument); } catch (Exception) { resultPageElement.Add(GetRenderingErrorNode(Localization.BrokenLinkReport_NotValidXhml)); continue; } linksToCheck.AddRange(CollectLinksToCheck(document, resultPageElement, url, pageServerUrl)); } linksToCheck = linksToCheck.OrderBy(o => Guid.NewGuid()).ToList(); // Shuffling links // Checking external and internall links in parrallel tasks - one per hostname var linksGroupedByHostname = linksToCheck.Where(l => l.RequestValidationInfo != null) .GroupBy(link => link.RequestValidationInfo.Hostname).ToList(); ParallelFacade.ForEach(linksGroupedByHostname, linkGroup => { foreach (var linkToCheck in linkGroup) { linkToCheck.BrokenLinkType = ValidateByRequest(linkToCheck.RequestValidationInfo); // linkToCheck.RequestValidationInfo = null; } }); // Having 100 tasks running in parallel would fill the app pool and make the site unresponsive foreach(var link in linksToCheck) { if (!link.BrokenLinkType.HasValue) { Log.LogWarning(LogTitle, "Incorrectly processed link: " + link.Href); link.BrokenLinkType = BrokenLinkType.Relative; } BrokenLinkType brokenLinkType = link.BrokenLinkType.Value; if (brokenLinkType == BrokenLinkType.None) { continue; } var brokenLinkDescriptionElement = DescribeBrokenLink(link.LinkNode, link.Href, brokenLinkType); link.ReportPageNode.Add(brokenLinkDescriptionElement); noInvalidLinksFound = false; } BuildReportTreeRec(infoDocumentRoot, Guid.Empty, reportElements); return noInvalidLinksFound; } }
private PageUrlData ParseInternalUrl(string relativeUrl, out UrlKind urlKind) { var urlBuilder = new UrlBuilder(relativeUrl); if (IsPageRendererRequest(urlBuilder.FilePath)) { urlKind = UrlKind.Renderer; return ParseRendererUrl(urlBuilder); } urlKind = UrlKind.Undefined; string decodedPath = HttpUtility.UrlDecode(urlBuilder.FullPath); string prefix = InternalUrlPrefix; if (!decodedPath.StartsWith(prefix, true)) { prefix = InternalUrlPrefixResolved; if (!decodedPath.StartsWith(prefix, true)) { return null; } } int closingBracketOffset = decodedPath.IndexOf(')'); if (closingBracketOffset < 0) { return null; } Guid pageId; if (!Guid.TryParse(decodedPath.Substring(prefix.Length, closingBracketOffset - prefix.Length), out pageId)) { return null; } string pathInfo = decodedPath.Substring(closingBracketOffset + 1); if (pathInfo.Length > 0 && pathInfo[0] != '/') { return null; } bool isUnpublished = pathInfo.Contains(UrlMarker_Unpublished); if (isUnpublished) { pathInfo = pathInfo.Replace(UrlMarker_Unpublished, string.Empty); } NameValueCollection queryString = urlBuilder.GetQueryParameters(); string cultureInfoStr = queryString["cultureInfo"]; CultureInfo cultureInfo; if (!cultureInfoStr.IsNullOrEmpty()) { cultureInfo = new CultureInfo(cultureInfoStr); } else { cultureInfo = LocalizationScopeManager.CurrentLocalizationScope; if (cultureInfo.Equals(CultureInfo.InvariantCulture)) { cultureInfo = DataLocalizationFacade.DefaultLocalizationCulture; } } queryString.Remove("cultureInfo"); urlKind = UrlKind.Internal; return new PageUrlData(pageId, isUnpublished ? PublicationScope.Unpublished : PublicationScope.Published, cultureInfo) { PathInfo = pathInfo, QueryParameters = queryString }; }
private static void RenderPage(IPage page) { var context = HttpContext.Current; if (context == null) { return; } var urlSpace = new UrlSpace(context) { ForceRelativeUrls = true }; var url = PageUrls.BuildUrl(page, UrlKind.Public, urlSpace) ?? PageUrls.BuildUrl(page, UrlKind.Renderer, urlSpace); if (string.IsNullOrEmpty(url)) { return; } var requestUrl = context.Request.Url; string hostName = requestUrl.Host; if (!url.StartsWith("http", StringComparison.InvariantCultureIgnoreCase)) { string serverUrl = new UrlBuilder(requestUrl.ToString()).ServerUrl; url = UrlUtils.Combine(serverUrl, url); } string cookies = context.Request.Headers["Cookie"]; string responseBody, errorMessage; var result = RenderPage(hostName, url, cookies, out responseBody, out errorMessage); // TODO: log errors if any }
public static PageUrl Parse(string url, out NameValueCollection queryParameters) { Verify.ArgumentNotNull(url, "url"); var urlBuilder = new UrlBuilder(url); return IsInternalUrl(urlBuilder) ? ParseInternalUrl(urlBuilder, out queryParameters) : ParsePublicUrl(urlBuilder, out queryParameters); }
internal static bool IsInternalUrl(UrlBuilder url) { return url.FilePath.EndsWith("Renderers/Page.aspx", true); }
internal static PageUrl ParseInternalUrl(UrlBuilder urlBuilder, out NameValueCollection notUsedQueryStringParameters) { return ParseQueryString(urlBuilder.GetQueryParameters(), out notUsedQueryStringParameters); }
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); }