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