protected virtual string GetMostSuitableRootItemUrl(WildcardRouteItem routeItem, UrlOptions options)
{
string url = string.Empty;
IEnumerable <Item> rootItems = routeItem.WildcardItems;
Item currentSiteItem = rootItems.FirstOrDefault(x => x.Paths.FullPath.StartsWith(Context.Site.RootPath, StringComparison.InvariantCultureIgnoreCase));
return(currentSiteItem != null?base.GetItemUrl(currentSiteItem, options) : url);
}
protected virtual Item ResolveItem(GetPageItemArgs args)
{
if (args.Result == null)
{
return(null);
}
WildcardRouteItem route = WildcardManager.Current.GetWildcardRouteForItemResolver(args.Result, Context.Site);
return(WildcardItemResolver.Current.ResolveItem(args.Result, route));
}
public override Item ResolveItem(Item item, WildcardRouteItem routeItem)
{
if (routeItem == null)
{
return(item);
}
var tokenValues = this.GetTokenValues(item, routeItem);
var rootItem = routeItem.ItemSearchRootNode;
using (var searchContext = ContentSearchManager.CreateSearchContext((SitecoreIndexableItem)item))
{
var queryable = searchContext.GetQueryable <SearchResultItem>();
var predicate = PredicateBuilder.True <SearchResultItem>();
foreach (var itemTemplateId in routeItem.ItemTemplates)
{
predicate = predicate.Or(p => p.TemplateId == itemTemplateId.ID);
}
queryable = queryable
.Where(predicate)
.Where(resultItem => resultItem.Language == Context.Language.Name);
if (rootItem != null)
{
queryable = queryable.Where(resultItem => resultItem.Paths.Contains(rootItem.ID));
}
foreach (var tokenRule in tokenValues)
{
queryable = this.AddTokenPredicates(tokenRule, queryable);
}
var result = queryable.FirstOrDefault();
if (result == null)
{
return(item);
}
var resolvedItem = result.GetItem();
if (resolvedItem != null)
{
return(resolvedItem);
}
}
return(item);
}
public override Item ResolveItem(Item item, WildcardRouteItem routeItem)
{
if (routeItem == null)
{
return item;
}
var tokenValues = this.GetTokenValues(item, routeItem);
var rootItem = routeItem.ItemSearchRootNode;
using (var searchContext = ContentSearchManager.CreateSearchContext((SitecoreIndexableItem) item))
{
var queryable = searchContext.GetQueryable<SearchResultItem>();
var predicate = PredicateBuilder.True<SearchResultItem>();
foreach (var itemTemplateId in routeItem.ItemTemplates)
{
predicate = predicate.Or(p => p.TemplateId == itemTemplateId.ID);
}
queryable = queryable
.Where(predicate)
.Where(resultItem => resultItem.Language == Context.Language.Name);
if (rootItem != null)
{
queryable = queryable.Where(resultItem => resultItem.Paths.Contains(rootItem.ID));
}
foreach (var tokenRule in tokenValues)
{
queryable = this.AddTokenPredicates(tokenRule, queryable);
}
var result = queryable.FirstOrDefault();
if (result == null)
{
return item;
}
var resolvedItem = result.GetItem();
if (resolvedItem != null)
{
return resolvedItem;
}
}
return item;
}
protected virtual string GetMostSuitableRootItemUrl(WildcardRouteItem routeItem, UrlOptions options)
{
var url = string.Empty;
var rootItems = routeItem.WildcardItems;
var currentSiteItem = rootItems.FirstOrDefault(x => x.Paths.FullPath.StartsWith(Context.Site.RootPath, StringComparison.InvariantCultureIgnoreCase));
if (currentSiteItem != null)
{
return base.GetItemUrl(currentSiteItem, options);
}
return url;
}
protected virtual IDictionary <string, string> GetTokenValues(Item item, WildcardRouteItem routeItem)
{
var ret = new Dictionary <string, string>();
string[] itemUrl;
using (new SiteContextSwitcher(Context.Site))
{
var options = UrlOptions.DefaultOptions;
options.AlwaysIncludeServerUrl = false;
var url = LinkManager.GetItemUrl(item, options);
itemUrl = url.Split('/');
}
var requestUrl = HttpContext.Current.Request.Url.LocalPath.Split('/');
var rules = routeItem.ItemResolvingRules;
int ruleIndex = 0;
int index = 0;
foreach (var rurl in requestUrl)
{
if (itemUrl[index] == this.WildcardTokenizedString)
{
if (rules.ContainsKey(ruleIndex))
{
var mapping = rules[ruleIndex];
if (mapping == null)
{
throw new WildcardException("Can't resolve wildcards by index " + (ruleIndex));
}
mapping = HttpUtility.UrlDecode(mapping);
if (!string.IsNullOrEmpty(mapping))
{
if (!ret.ContainsKey(mapping))
{
ret.Add(mapping, rurl);
}
}
}
ruleIndex++;
}
index++;
}
return(ret);
}
protected virtual IDictionary<string, string> GetTokenValues(Item item, WildcardRouteItem routeItem)
{
var ret = new Dictionary<string, string>();
string[] itemUrl;
using (new SiteContextSwitcher(Context.Site))
{
var options = UrlOptions.DefaultOptions;
options.AlwaysIncludeServerUrl = false;
var url = LinkManager.GetItemUrl(item, options);
itemUrl = url.Split('/');
}
var requestUrl = HttpContext.Current.Request.Url.LocalPath.Split('/');
var rules = routeItem.ItemResolvingRules;
int ruleIndex = 0;
int index = 0;
foreach (var rurl in requestUrl)
{
if (itemUrl[index] == this.WildcardTokenizedString)
{
if (rules.ContainsKey(ruleIndex))
{
var mapping = rules[ruleIndex];
if (mapping == null)
{
throw new WildcardException("Can't resolve wildcards by index " + (ruleIndex));
}
mapping = HttpUtility.UrlDecode(mapping);
if (!string.IsNullOrEmpty(mapping))
{
if (!ret.ContainsKey(mapping))
{
ret.Add(mapping, rurl);
}
}
}
ruleIndex++;
}
index++;
}
return ret;
}
public override string GetItemUrl(Item item, UrlOptions options)
{
if (item == null || options == null)
{
return(base.GetItemUrl(item, options));
}
WildcardRouteItem route = WildcardManager.Current.GetWildcardRouteForLinkProvider(item, Context.Site);
if (route == null || route.WildcardItemIds.Any(x => x == item.ID))
{
return(base.GetItemUrl(item, options));
}
string url = base.GetItemUrl(item, options);
string routeUrl = GetMostSuitableRootItemUrl(route, options);
return(string.IsNullOrEmpty(routeUrl) ? url : ReplaceUrlTokens(routeUrl, item, route, options));
}
public override Item ResolveItem(Item item, WildcardRouteItem routeItem)
{
if (routeItem == null)
{
return(item);
}
IDictionary <string, string> tokenValues = GetTokenValues(item, routeItem);
Item rootItem = routeItem.ItemSearchRootNode;
using (IProviderSearchContext searchContext = ContentSearchManager.CreateSearchContext((SitecoreIndexableItem)item)) {
IQueryable <SearchResultItem> queryable = searchContext.GetQueryable <SearchResultItem>();
Expression <Func <SearchResultItem, bool> > predicate = PredicateBuilder.True <SearchResultItem>();
predicate = routeItem.ItemTemplates.Aggregate(predicate, (current, itemTemplateId) => current.Or(p => p.TemplateId == itemTemplateId.ID));
queryable = queryable
.Where(predicate)
.Where(resultItem => resultItem.Language == Context.Language.Name);
if (rootItem != null)
{
queryable = queryable.Where(resultItem => resultItem.Paths.Contains(rootItem.ID));
}
queryable = tokenValues.Aggregate(queryable, (current, tokenRule) => AddTokenPredicates(tokenRule, current));
SearchResultItem result = queryable.FirstOrDefault();
if (result == null)
{
return(item);
}
Item resolvedItem = result.GetItem();
if (resolvedItem != null)
{
return(resolvedItem);
}
}
return(item);
}
protected virtual IDictionary <int, string> GetTokenValues(Item item, WildcardRouteItem routeItem, UrlOptions options)
{
Dictionary <int, string> ret = new Dictionary <int, string>();
IDictionary <int, string> rules = routeItem.UrlGenerationRules;
foreach (KeyValuePair <int, string> rule in rules)
{
string mapping = rule.Value.Trim();
string tokenValue = UrlGenerationTokenValueExtractor.Current.ExtractTokenValue(mapping, item);
if (options.LowercaseUrls)
{
tokenValue = tokenValue.ToLower();
}
tokenValue = tokenValue.Replace(" ", "-");
ret.Add(rule.Key, tokenValue);
}
return(ret);
}
protected virtual string ReplaceUrlTokens(string routeUrl, Item item, WildcardRouteItem routeItem, UrlOptions options)
{
var resultUrl = new List<string>();
var tokenValues = this.GetTokenValues(item, routeItem, options);
var urlPattern = routeUrl.Split(new[] { '/' });
var tokenCounter = 0;
foreach (var segment in urlPattern)
{
var resultSegment = segment;
if (segment.ToLower() == WildcardTokenizedString)
{
resultSegment = tokenValues[tokenCounter++];
}
resultUrl.Add(resultSegment);
}
return string.Join("/", resultUrl);
}
protected virtual string ReplaceUrlTokens(string routeUrl, Item item, WildcardRouteItem routeItem, UrlOptions options)
{
var resultUrl = new List <string>();
var tokenValues = this.GetTokenValues(item, routeItem, options);
var urlPattern = routeUrl.Split(new[] { '/' });
var tokenCounter = 0;
foreach (var segment in urlPattern)
{
var resultSegment = segment;
if (segment.ToLower() == this.WildcardTokenizedString)
{
resultSegment = tokenValues[tokenCounter++];
}
resultUrl.Add(resultSegment);
}
return(string.Join("/", resultUrl));
}
protected virtual string ReplaceUrlTokens(string routeUrl, Item item, WildcardRouteItem routeItem, UrlOptions options)
{
List <string> resultUrl = new List <string>();
IDictionary <int, string> tokenValues = GetTokenValues(item, routeItem, options);
string[] urlPattern = routeUrl.Split('/');
int tokenCounter = 0;
foreach (string segment in urlPattern)
{
string resultSegment = segment;
if (segment.ToLower() == WildcardTokenizedString)
{
resultSegment = tokenValues[tokenCounter++];
}
resultUrl.Add(resultSegment);
}
return(string.Join("/", resultUrl));
}
protected virtual IDictionary<int, string> GetTokenValues(Item item, WildcardRouteItem routeItem, UrlOptions options)
{
var ret = new Dictionary<int, string>();
var rules = routeItem.UrlGenerationRules;
foreach (var rule in rules)
{
var mapping = rule.Value.Trim();
var tokenValue = UrlGenerationTokenValueExtractor.Current.ExtractTokenValue(mapping, item);
if (options.LowercaseUrls)
{
tokenValue = tokenValue.ToLower();
}
tokenValue = tokenValue.Replace(" ", "-");
ret.Add(rule.Key, tokenValue);
}
return ret;
}
public virtual Item ResolveItem(Item item, WildcardRouteItem routeItem)
{
return null;
}
public virtual Item ResolveItem(Item item, WildcardRouteItem routeItem)
{
return(null);
}
public virtual Item ResolveItem(Item item, WildcardRouteItem routeItem) => null;
