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 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); }
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 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, }; }
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 }; }
internal static PageUrl ParseInternalUrl(UrlBuilder urlBuilder, out NameValueCollection notUsedQueryStringParameters) { return ParseQueryString(urlBuilder.GetQueryParameters(), out notUsedQueryStringParameters); }