/// <summary>
/// Replace all non-alphanumeric characters with hyphens, ignoring slashes
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private static string Normalize(string path)
{
if (string.IsNullOrEmpty(path))
{
return(path);
}
// Decode the path.
path = WebUtility.HtmlDecode(path);
path = MainUtil.DecodeName(path);
var segments = path.Split(Constants.UrlSeparator, StringSplitOptions.RemoveEmptyEntries);
var name = segments?.Length != 0 ? segments.Last() : null;
if (!string.IsNullOrEmpty(name))
{
var replaced = ItemUtil.ProposeValidItemName(name).ToLower();
path = path.Replace(name, replaced);
}
// Replace characters that Sitecore doesn't allow and lower case the rest.
path = path.Replace(Constants.Blank, Constants.Hyphen);
return(path);
}
public override void Process(HttpRequestArgs args)
{
if (Context.Item != null || args.Url.FilePath.StartsWith("/sitecore") || args.LocalPath.StartsWith("/sitecore"))
{
return;
}
var requestUrl = args.Url.ItemPath;
if (requestUrl.Length > 1 && requestUrl.EndsWith("/"))
{
requestUrl = requestUrl.Substring(0, requestUrl.Length - 1);
}
// remove last element from path and see if resulting path is a bucket
var index = requestUrl.LastIndexOf('/');
if (index <= 0)
{
return;
}
// take the front of the url, looking for /bucket-name
var bucketPath = MainUtil.DecodeName(requestUrl.Substring(0, index));
var bucketItem = args.GetItem(bucketPath);
// was the item a bucket?
if (bucketItem == null || !BucketManager.IsBucket(bucketItem))
{
return;
}
// get the name of the item ion the bucket
var itemName = requestUrl.Substring(index + 1);
// locate item in bucket by name
using (var searchContext = ContentSearchManager.GetIndex(Context.Site.GetIndexName()).CreateSearchContext())
{
// this returns the First matching item found. If user has added several
// items of the same name into the bucket it may return the wrong item.
var result = searchContext.GetQueryable <BucketItemSearchResult>()
.Where(x => x.Name == itemName && x.IsLatestVersion)
.Filter(x => x.Paths.Contains(bucketItem.ID));
var count = result.Count();
if (count == 0)
{
return;
}
if (count > 1)
{
Log.Warn(
$"DSP.Foundation.Pipelines.HttpRequestBegin.BucketItemResolver - Process - found {count} items for '{requestUrl}'", this);
}
Context.Item = result.First().GetItem();
}
}
/// <summary>
/// Resolves the display name of the using.
/// </summary>
/// <param name="itemPath">The item path.</param>
/// <returns>The resolved item.</returns>
protected virtual Item ResolveUsingDisplayName(string itemPath)
{
Assert.ArgumentNotNull(itemPath, "UrlItemPath");
using (new SecurityDisabler())
{
if (string.IsNullOrEmpty(itemPath) || (itemPath[0] != '/'))
{
return(null);
}
int index = itemPath.IndexOf('/', 1);
if (index < 0)
{
return(null);
}
Item root = ItemManager.GetItem(itemPath.Substring(0, index), Language.Current, Sitecore.Data.Version.Latest, Sitecore.Context.Database, SecurityCheck.Disable);
if (root == null)
{
return(null);
}
string path = MainUtil.DecodeName(itemPath.Substring(index));
Item child = root;
foreach (string itemName in path.Split(new[] { '/' }))
{
if (itemName.Length == 0)
{
continue;
}
child = this.GetChildFromNameOrDisplayName(child, itemName);
if (child == null)
{
return(null);
}
}
return(child);
}
}
/// <summary>
/// Replace all non-alphanumeric characters with hyphens, ignoring slashes
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static string Normalize(string path)
{
if (path == null)
{
return(null);
}
// Decode the path.
path = WebUtility.HtmlDecode(path);
path = MainUtil.DecodeName(path);
// Replace characters that we don't allow and lower case the rest.
string replaced = new string(path.Select(x => char.IsLetterOrDigit(x) || x == '/' || x == '-'
? char.ToLower(x)
: '-').ToArray());
replaced = Undouble(replaced, "-");
replaced = Undouble(replaced, "/");
return(replaced);
}
public override void Process(HttpRequestArgs args)
{
try
{
if (Context.Item == null)
{
var requestUrl = args.Url.ItemPath;
// remove last element from path and see if resulting pathis a bucket
var index = requestUrl.LastIndexOf('/');
if (index > 0)
{
var bucketPath = requestUrl.Substring(0, index);
var bucketItem = args.GetItem(bucketPath);
if (bucketItem != null && BucketManager.IsBucket(bucketItem))
{
string itemName = requestUrl.Substring(index + 1);
if (!string.IsNullOrEmpty(itemName))
{
itemName = MainUtil.DecodeName(itemName);
}
// locate item in bucket by name
using (var context = ContentSearchManager.GetIndex(Constants.CustomIndex).CreateSearchContext())
{
var result = context.GetQueryable <SearchResultItem>().Where(x => x.Name == itemName).FirstOrDefault();
if (result != null)
{
Context.Item = args.GetItem(result.ItemId);
}
}
}
}
}
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error(ex.Message, ex, this);
}
}
/// <summary>
/// checks url for a certain pattern, returns string value if found
/// Example - www.url.com/blog/category/apples if pattern {0}/category/{1} then returns apples
/// </summary>
/// <returns></returns>
public static string GetUrlValByPattern(string url, string urlPattern)
{
char[] delimiterChars = { '?' };
string[] splitUrl = url.Split(delimiterChars);
string decodedItemName = MainUtil.DecodeName(splitUrl[0]);
try
{
string pattern = urlPattern.FormatWith(@"(^.+)", @"(.+)/$");
Match match = Regex.Match(StringUtil.EnsurePostfix('/', decodedItemName), @pattern, RegexOptions.IgnoreCase);
if (match.Success)
{
return(WebUtility.UrlDecode(match.Groups[2].Value));
}
}
catch (Exception ex)
{
Log.Error("XBlog could not resolve url to a blog item", ex, new object());
}
return(string.Empty);
}
protected virtual Item DoResolveItem(List <string> pathParts, Item root)
{
if (!pathParts.Any() || root == null)
{
return(root);
}
string str = pathParts.First();
List <string> range = pathParts.GetRange(1, pathParts.Count - 1);
Item child1 = GetChild(root, str);
Item obj = DoResolveItem(range, child1);
if (obj == null)
{
string itemName = MainUtil.DecodeName(str);
if (str != itemName)
{
Item child2 = GetChild(root, itemName);
obj = DoResolveItem(range, child2);
}
}
return(obj);
}
private static Item GetParent()
{
var url = System.Web.HttpContext.Current.Request.UrlReferrer;
var siteContext = Sitecore.Sites.SiteContextFactory.GetSiteContext(url.Host, url.PathAndQuery);
var homePath = siteContext.StartPath;
if (!homePath.EndsWith("/"))
{
homePath += "/";
}
var itemPath = MainUtil.DecodeName(url.AbsolutePath);
if (itemPath.StartsWith(siteContext.VirtualFolder))
{
itemPath = itemPath.Remove(0, siteContext.VirtualFolder.Length);
}
var fullPath = homePath + "/" + itemPath;
return(siteContext.Database.GetItem(fullPath));
}
/// <summary>
/// Gets the parent item from item path.
/// </summary>
/// <param name="path">The item path.</param>
/// <returns>The the parent item from item path.</returns>
protected virtual Item GetParentItemFromItemPath(string path)
{
int indexOfSlash = path.LastIndexOf("/");
path = path.Substring(0, indexOfSlash);
Item item = Sitecore.Context.Database.GetItem(path);
if (item == null)
{
string path1 = MainUtil.DecodeName(path);
item = Sitecore.Context.Database.GetItem(path1);
}
SiteContext site = Sitecore.Context.Site;
string str2 = (site != null) ? site.RootPath : string.Empty;
if (item == null)
{
string path1 = FileUtil.MakePath(str2, path, '/');
item = Sitecore.Context.Database.GetItem(path1);
}
if (item == null)
{
string path1 = MainUtil.DecodeName(FileUtil.MakePath(str2, path, '/'));
item = Sitecore.Context.Database.GetItem(path1);
}
if (item == null)
{
item = this.ResolveUsingDisplayName(path);
}
return(item);
}
private static IEnumerable <string> ParseFinalSegment(string segment)
{
var r = new Regex(@"(?<start>.*)\/(?<itemname>.*)-(?<datefolders>(?<year>\d{4})(?<month>\d{2})(?<day>\d{2})(?<hour>\d{2})(?<minute>\d{2}))$");
var matches = r.Matches(segment);
if (matches.Count > 0)
{
var m = matches[0];
yield return(m.Groups["start"].Value);
yield return(m.Groups["year"].Value);
yield return(m.Groups["month"].Value);
yield return(m.Groups["day"].Value);
yield return(m.Groups["hour"].Value);
yield return(m.Groups["minute"].Value);
yield return(MainUtil.DecodeName(m.Groups["itemname"].Value));
}
}
/// <summary>
/// The main method for the processor. It simply overrides the Process method.
/// </summary>
public override void Process(HttpRequestArgs args)
{
// This processer is added to the pipeline after the Sitecore Item Resolver. We want to skip everything if the item resolved successfully.
// Also, skip processing for the visitor identification items related to DMS.
Assert.ArgumentNotNull(args, "args");
if ((Context.Item == null || AllowRedirectsOnFoundItem(Context.Database)) && args.LocalPath != Constants.Paths.VisitorIdentification && Context.Database != null)
{
// Grab the actual requested path for use in both the item and pattern match sections.
var requestedUrl = HttpContext.Current.Request.Url.ToString();
var requestedPath = HttpContext.Current.Request.Url.AbsolutePath;
var requestedPathAndQuery = HttpContext.Current.Request.Url.PathAndQuery;
var db = Context.Database;
// First, we check for exact matches because those take priority over pattern matches.
if (Sitecore.Configuration.Settings.GetBoolSetting(Constants.Settings.RedirExactMatch, true))
{
// Loop through the exact match entries to look for a match.
foreach (Item possibleRedirect in GetRedirects(db, Constants.Templates.RedirectUrl, Constants.Templates.VersionedRedirectUrl, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch)))
{
if (requestedUrl.Equals(possibleRedirect[Constants.Fields.RequestedUrl], StringComparison.OrdinalIgnoreCase) ||
requestedPath.Equals(possibleRedirect[Constants.Fields.RequestedUrl], StringComparison.OrdinalIgnoreCase))
{
var redirectToItem = db.GetItem(ID.Parse(possibleRedirect.Fields[Constants.Fields.RedirectTo]));
if (redirectToItem != null)
{
SendResponse(redirectToItem, HttpContext.Current.Request.Url.Query, args);
}
}
}
}
// Second, we check for pattern matches because we didn't hit on an exact match.
if (Sitecore.Configuration.Settings.GetBoolSetting(Constants.Settings.RedirPatternMatch, true))
{
// Loop through the pattern match items to find a match
foreach (Item possibleRedirectPattern in GetRedirects(db, Constants.Templates.RedirectPattern, Constants.Templates.VersionedRedirectPattern, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch)))
{
var redirectPath = string.Empty;
if (Regex.IsMatch(requestedUrl, possibleRedirectPattern[Constants.Fields.RequestedExpression], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedUrl, possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
else if (Regex.IsMatch(requestedPathAndQuery, possibleRedirectPattern[Constants.Fields.RequestedExpression], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
if (string.IsNullOrEmpty(redirectPath))
{
continue;
}
// Query portion gets in the way of getting the sitecore item.
var pathAndQuery = redirectPath.Split('?');
var path = pathAndQuery[0];
if (LinkManager.Provider != null &&
LinkManager.Provider.GetDefaultUrlOptions() != null &&
LinkManager.Provider.GetDefaultUrlOptions().EncodeNames)
{
path = MainUtil.DecodeName(path);
}
var redirectToItem = db.GetItem(path);
if (redirectToItem != null)
{
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
SendResponse(redirectToItem, query, args);
}
}
}
}
}
public override void Process(HttpRequestArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (((Context.Item == null) && (Context.Database != null)) && !string.IsNullOrWhiteSpace(args.Url.ItemPath))
{
Profiler.StartOperation("Resolve blog item.");
string qsValue = string.Empty;
string decodedItemName = MainUtil.DecodeName(args.Url.ItemPath);
string blogItemPath = ResolveBlogItemPath(decodedItemName, XBSettings.XBCategoryUrlPattern, out qsValue);
BlogFilterType filter = BlogFilterType.None;
if (!string.IsNullOrEmpty(blogItemPath))
{
filter = BlogFilterType.Category;
}
else
{
blogItemPath = ResolveBlogItemPath(decodedItemName, XBSettings.XBAuthorUrlPattern, out qsValue);
if (!string.IsNullOrEmpty(blogItemPath))
{
filter = BlogFilterType.Author;
}
else
{
blogItemPath = ResolveBlogItemPath(decodedItemName, XBSettings.XBTagsUrlPattern, out qsValue);
if (!string.IsNullOrEmpty(blogItemPath))
{
filter = BlogFilterType.Tag;
}
else
{
blogItemPath = ResolveBlogItemPath(decodedItemName, XBSettings.XBAuthorViewUrlPattern, out qsValue);
if (!string.IsNullOrEmpty(blogItemPath))
{
filter = BlogFilterType.AuthorView;
}
else
{
blogItemPath = ResolveBlogItemPath(decodedItemName, XBSettings.XBSearchURLPattern, out qsValue);
if (!string.IsNullOrEmpty(blogItemPath))
{
filter = BlogFilterType.Search;
}
}
}
}
}
if (!string.IsNullOrEmpty(blogItemPath) && filter != BlogFilterType.None)
{
Item blogRoot = args.GetItem(blogItemPath);
if (blogRoot != null)
{
Context.Item = blogRoot;
NameValueCollection nv = StringUtil.ParseNameValueCollection(args.Url.QueryString, '&', '=');
switch (filter)
{
case BlogFilterType.Category: nv.Add(XBSettings.XBCategoryQS, qsValue);
break;
case BlogFilterType.Author: nv.Add(XBSettings.XBAuthorQS, qsValue);
break;
case BlogFilterType.AuthorView: nv.Add(XBSettings.XBAuthorViewQS, qsValue);
break;
case BlogFilterType.Tag: nv.Add(XBSettings.XBTagQS, qsValue);
break;
case BlogFilterType.Search: nv.Add(XBSettings.XBSearchQS, qsValue);
break;
case BlogFilterType.None:
default:
break;
}
args.Url.QueryString = StringUtil.NameValuesToString(nv, "&");
}
}
Profiler.EndOperation();
}
}
/// <summary>
/// The main method for the processor. It simply overrides the Process method.
/// </summary>
public override void Process(HttpRequestArgs args)
{
// This processer is added to the pipeline after the Sitecore Item Resolver. We want to skip everything if the item resolved successfully.
// Also, skip processing for the visitor identification items related to DMS.
Assert.ArgumentNotNull(args, "args");
var allowExternalHost = AllowExternalHost(HttpContext.Current.Request.Url.Host);
if ((allowExternalHost || Context.Item == null || AllowRedirectsOnFoundItem(Context.Database)) && args.LocalPath != Constants.Paths.VisitorIdentification && Context.Database != null)
{
// Grab the actual requested path for use in both the item and pattern match sections.
var requestedUrl = HttpContext.Current.Request.Url.ToString().TrimEnd('/');
var requestedPath = HttpContext.Current.Request.Url.AbsolutePath;
var requestedPathAndQuery = HttpContext.Current.Request.Url.PathAndQuery;
var currentIpAddress = GetClientIPAddress();
var db = Context.Database;
// First, we check for exact matches because those take priority over pattern matches.
if (Sitecore.Configuration.Settings.GetBoolSetting(Constants.Settings.RedirExactMatch, true))
{
// Loop through the exact match entries to look for a match.
foreach (Item possibleRedirect in GetRedirects(db, Constants.Templates.RedirectUrl, Constants.Templates.VersionedRedirectUrl, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch)))
{
var trimmedItemRequestedUrl = possibleRedirect[Constants.Fields.RequestedUrl].TrimEnd('/');
if (requestedUrl.Equals(trimmedItemRequestedUrl, StringComparison.OrdinalIgnoreCase) ||
requestedPath.Equals(trimmedItemRequestedUrl, StringComparison.OrdinalIgnoreCase))
{
var redirectToItemId = possibleRedirect.Fields[Constants.Fields.RedirectToItem];
var redirectToUrl = possibleRedirect.Fields[Constants.Fields.RedirectToUrl];
var redirectFromCode = possibleRedirect.Fields[Constants.Fields.RedirectCode];
var maxMind = Sitecore.Configuration.Settings.GetSetting(Constants.Settings.MaxMindType);
if (redirectToItemId.HasValue && !string.IsNullOrEmpty(redirectToItemId.ToString()))
{
var redirectToItem = db.GetItem(ID.Parse(redirectToItemId));
if (redirectToItem != null)
{
var responseStatus = GetResponseStatus(possibleRedirect);
switch (maxMind)
{
case "0":
{
SendResponse(redirectToItem, HttpContext.Current.Request.Url.Query, responseStatus, args);
break;
}
case "1":
{
if (!redirectFromCode.HasValue || string.IsNullOrEmpty(redirectFromCode.ToString()))
{
goto case "0";
}
if (redirectFromCode.HasValue && !string.IsNullOrEmpty(redirectFromCode.ToString()) &&
HaveCodeMatch(redirectFromCode.Value, DatabaseHelper.GetCodeFromIP(currentIpAddress)))
{
goto case "0";
}
break;
}
case "2":
{
if (!redirectFromCode.HasValue || string.IsNullOrEmpty(redirectFromCode.ToString()))
{
goto case "0";
}
if (redirectFromCode.HasValue && !string.IsNullOrEmpty(redirectFromCode.ToString()) &&
HaveCodeMatch(redirectFromCode.Value, WebServiceHelper.GetCodeFromIP(currentIpAddress)))
{
goto case "0";
}
break;
}
default:
{
goto case "0";
}
}
}
}
else if (redirectToUrl.HasValue && !string.IsNullOrEmpty(redirectToUrl.ToString()))
{
var responseStatus = GetResponseStatus(possibleRedirect);
switch (maxMind)
{
case "0":
{
SendResponse(redirectToUrl.Value, HttpContext.Current.Request.Url.Query, responseStatus, args);
break;
}
case "1":
{
if (!redirectFromCode.HasValue || string.IsNullOrEmpty(redirectFromCode.ToString()))
{
goto case "0";
}
if (redirectFromCode.HasValue && !string.IsNullOrEmpty(redirectFromCode.ToString()) &&
HaveCodeMatch(redirectFromCode.Value, DatabaseHelper.GetCodeFromIP(currentIpAddress)))
{
goto case "0";
}
break;
}
case "2":
{
if (!redirectFromCode.HasValue || string.IsNullOrEmpty(redirectFromCode.ToString()))
{
goto case "0";
}
if (redirectFromCode.HasValue && !string.IsNullOrEmpty(redirectFromCode.ToString()) &&
HaveCodeMatch(redirectFromCode.Value, DatabaseHelper.GetCodeFromIP(currentIpAddress)))
{
goto case "0";
}
break;
}
default:
{
goto case "0";
}
}
}
}
}
}
// Finally, we check for pattern matches because we didn't hit on an exact match.
if (Sitecore.Configuration.Settings.GetBoolSetting(Constants.Settings.RedirPatternMatch, true))
{
// Loop through the pattern match items to find a match
foreach (Item possibleRedirectPattern in GetRedirects(db, Constants.Templates.RedirectPattern, Constants.Templates.VersionedRedirectPattern, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch)))
{
var redirectPath = string.Empty;
var relativePathMatch = false;
if (Regex.IsMatch(requestedUrl, possibleRedirectPattern[Constants.Fields.RequestedExpression],
RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedUrl,
possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
else if (Regex.IsMatch(requestedPathAndQuery,
possibleRedirectPattern[Constants.Fields.RequestedExpression], RegexOptions.IgnoreCase))
{
if (!string.IsNullOrEmpty(possibleRedirectPattern[Constants.Fields.SourceItem]))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
else if (
!string.IsNullOrEmpty(
possibleRedirectPattern[Constants.Fields.RelativeDestinationPath]))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.RelativeDestinationPath],
RegexOptions.IgnoreCase);
relativePathMatch = true;
}
}
if (string.IsNullOrEmpty(redirectPath))
{
continue;
}
// Query portion gets in the way of getting the sitecore item.
var pathAndQuery = redirectPath.Split('?');
var path = pathAndQuery[0];
if (LinkManager.Provider != null &&
LinkManager.Provider.GetDefaultUrlOptions() != null &&
LinkManager.Provider.GetDefaultUrlOptions().EncodeNames)
{
path = MainUtil.DecodeName(path);
}
var redirectToItem = db.GetItem(path);
var responseStatus = GetResponseStatus(redirectToItem);
if (redirectToItem != null)
{
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
SendResponse(redirectToItem, query, responseStatus, args);
}
else if (relativePathMatch)
{
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
SendResponse(redirectPath, query, responseStatus, args);
}
}
}
if (!allowExternalHost)
{
return;
}
//Couldn't find a mapping based on settings. For non-Sitecore hostnames
var notFoundUrl = Sitecore.Configuration.Settings.GetSetting(Constants.Settings.ExternalHostsNotFoundUrl);
SendTempResponse(notFoundUrl, HttpContext.Current.Request.Url.Query, args);
}
}
public override void Process(HttpRequestArgs args)
{
var site = Sitecore.Context.Site.GetMultiSiteContext();
// only do redirects if no item is found or if request parameters match the configuration settings
if (ProcessUrl() && Context.Database != null && site != null)
{
// Grab the actual requested path for use in both the item and pattern match sections.
var requestedUrl = HttpContext.Current.Request.Url.ToString();
var requestedUrlOnly = requestedUrl.IndexOf("?") > 0 ? requestedUrl.Substring(0, requestedUrl.IndexOf("?")) : requestedUrl;
requestedUrl = requestedUrl.EndsWith("/") ? requestedUrl.Substring(0, requestedUrl.Length - 1) : requestedUrl;
var requestedPath = HttpContext.Current.Request.Url.AbsolutePath;
var requestedPathAndQuery = HttpContext.Current.Request.Url.PathAndQuery;
var db = Context.Database;
// In case allowed extensions are defined, only process pipeline when the extension of the request in included in the list
// of allowed extensions.
// If the request does not contain an extension, pipeline will always be processed
if (allowedExtensions != null && allowedExtensions.Count() > 0)
{
var extensionWithDot = Path.GetExtension(requestedPath);
if (string.IsNullOrEmpty(extensionWithDot) == false)
{
if (allowedExtensions.Contains(extensionWithDot.Substring(1).ToLower()) == false)
{
return;
}
}
}
var ruleFolder = db.GetItem(new Sitecore.Data.ID(site.SiteId)).Children.Where(a => a.DisplayName == "Redirection Rules").FirstOrDefault();
if (ruleFolder == null)
{
return;
}
// Loop through the exact match entries to look for a match.
foreach (Item possibleRedirect in GetRedirects(ruleFolder, "Redirect Url"))
{
if (possibleRedirect.HasField("Enabled"))
{
var enabled = ((CheckboxField)possibleRedirect.Fields["Enabled"]).Checked;
if (!enabled)
{
continue;
}
}
bool Is302 = false;
bool IsVanity = false;
if (possibleRedirect.HasField("Type"))
{
string type = possibleRedirect["Type"];
if (type.StartsWith("302"))
{
Is302 = true;
IsVanity = false;
}
if (type.ToLower().StartsWith("vanity"))
{
Is302 = false;
IsVanity = true;
}
}
if (requestedUrl.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase) ||
requestedPath.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase) ||
requestedUrlOnly.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase))
{
var redirectToItemId = possibleRedirect.Fields["Target Item"];
if (redirectToItemId.HasValue && !string.IsNullOrEmpty(redirectToItemId.ToString()))
{
var redirectToItem = Context.Database.GetItem(ID.Parse(redirectToItemId));
var redirectToUrl = GetRedirectToUrl(redirectToItem);
if (possibleRedirect.HasField("Goal") && possibleRedirect.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirect.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
if (Is302)
{
SendTemporaryResponse(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
else
{
//default is 301 permanent
SendResponse(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
}
}
}
// Loop through the pattern match items to find a match
foreach (Item possibleRedirectPattern in GetRedirects(ruleFolder, "Redirect Pattern"))
{
if (possibleRedirectPattern.HasField("Enabled"))
{
var enabled = ((CheckboxField)possibleRedirectPattern.Fields["Enabled"]).Checked;
if (!enabled)
{
continue;
}
}
bool Is302 = false;
bool IsVanity = false;
if (possibleRedirectPattern.HasField("Type"))
{
string type = possibleRedirectPattern["Type"];
if (type.StartsWith("302"))
{
Is302 = true;
IsVanity = false;
}
if (type.ToLower().StartsWith("vanity"))
{
Is302 = false;
IsVanity = true;
}
}
var redirectPath = string.Empty;
if (Regex.IsMatch(requestedUrl, possibleRedirectPattern["Source Expression"], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedUrl, possibleRedirectPattern["Source Expression"],
possibleRedirectPattern["Target Expression"], RegexOptions.IgnoreCase);
}
else if (Regex.IsMatch(requestedPathAndQuery, possibleRedirectPattern["Source Expression"], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern["Source Expression"],
possibleRedirectPattern["Target Expression"], RegexOptions.IgnoreCase);
}
if (string.IsNullOrEmpty(redirectPath))
{
continue;
}
if (redirectPath.ToLower().StartsWith("/sitecore"))
{
// Query portion gets in the way of getting the sitecore item.
var pathAndQuery = redirectPath.Split(new char[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
var path = pathAndQuery[0];
if (LinkManager.GetDefaultUrlOptions() != null &&
LinkManager.GetDefaultUrlOptions().EncodeNames)
{
path = MainUtil.DecodeName(path);
}
var redirectToItem = db.GetItem(path);
if (redirectToItem != null)
{
var redirectToUrl = GetRedirectToUrl(redirectToItem);
if (possibleRedirectPattern.HasField("Goal") && possibleRedirectPattern.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirectPattern.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
if (Is302)
{
SendTemporaryResponse(redirectToUrl, query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, query, args);
}
else
{
SendResponse(redirectToUrl, query, args);
}
}
}
else
{
//validate it's a URI
Uri outUri = null;
if (Uri.TryCreate(redirectPath, UriKind.Absolute, out outUri) &&
(outUri.Scheme == Uri.UriSchemeHttp || outUri.Scheme == Uri.UriSchemeHttps))
{
var redirectToUrl = outUri.GetLeftPart(UriPartial.Path);
if (possibleRedirectPattern.HasField("Goal") && possibleRedirectPattern.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirectPattern.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
var query = outUri.Query;
if (Is302)
{
SendTemporaryResponse(redirectToUrl, query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, query, args);
}
else
{
SendResponse(redirectToUrl, query, args);
}
}
}
}
}
}
public override void Process(HttpRequestArgs args)
{
//don't do backend
if (Sitecore.Context.Domain.Name.ToLower().Contains("sitecore") || !Sitecore.Context.PageMode.IsNormal)
{
return;
}
// Get the site context
SiteContext site = Sitecore.Context.Site;
// Check if the current user has sufficient rights to enter this page
if (!SiteManager.CanEnter(site.Name, Sitecore.Context.User))
{
return;
}
string prefix = args.StartPath;
if (args.LocalPath.Contains(Sitecore.Context.Site.StartPath))
{
prefix = String.Empty;
}
if (Sitecore.Context.Database == null)
{
return;
}
// Get the item using securityDisabler for restricted items such as permission denied items
Item contextItem = null;
using (new SecurityDisabler())
{
if (Context.Database == null || args.Url.ItemPath.Length == 0)
{
return;
}
string path = MainUtil.DecodeName(args.Url.ItemPath);
Item item = args.GetItem(path);
if (item == null)
{
path = args.LocalPath;
item = args.GetItem(path);
}
if (item == null)
{
path = MainUtil.DecodeName(args.LocalPath);
item = args.GetItem(path);
}
string str2 = (site != null) ? site.RootPath : string.Empty;
if (item == null)
{
path = FileUtil.MakePath(str2, args.LocalPath, '/');
item = args.GetItem(path);
}
if (item == null)
{
path = MainUtil.DecodeName(FileUtil.MakePath(str2, args.LocalPath, '/'));
item = args.GetItem(path);
}
if (item == null)
{
Item root = ItemManager.GetItem(site.RootPath, Language.Current, Sitecore.Data.Version.Latest, Context.Database, SecurityCheck.Disable);
if (root != null)
{
string path2 = MainUtil.DecodeName(args.LocalPath);
item = this.GetSubItem(path2, root);
}
}
if (item == null)
{
int index = args.Url.ItemPath.IndexOf('/', 1);
if (index >= 0)
{
Item root = ItemManager.GetItem(args.Url.ItemPath.Substring(0, index), Language.Current, Sitecore.Data.Version.Latest, Context.Database, SecurityCheck.Disable);
if (root != null)
{
string path3 = MainUtil.DecodeName(args.Url.ItemPath.Substring(index));
item = this.GetSubItem(path3, root);
}
}
}
if (((item == null) && args.UseSiteStartPath) && (site != null))
{
item = args.GetItem(site.StartPath);
}
contextItem = item;
}
//Item contextItem = Sitecore.Context.Item;
if (contextItem == null)
{
return;
}
User u = Sitecore.Context.User;
bool isAllowed = AuthorizationManager.IsAllowed(contextItem, AccessRight.ItemRead, u);
if (isAllowed)
{
return;
}
string rawURL = HttpContext.Current.Server.HtmlEncode(HttpContext.Current.Request.RawUrl);
if (site.LoginPage.Length > 0) // Redirect the user
{
WebUtil.Redirect(string.Format("{0}?returnUrl={1}", site.LoginPage, rawURL));
}
}