|
public GetQueryParameters ( ) : |
||
| return | ||
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);
}
