/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it should return <c>null</c>.</para>
/// </remarks>
public virtual string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
if (!current.IsAbsoluteUri)
throw new ArgumentException("Current url must be absolute.", "current");
// will not use cache if previewing
var route = umbracoContext.ContentCache.GetRouteById(id);
if (string.IsNullOrWhiteSpace(route))
{
LogHelper.Warn<DefaultUrlProvider>(
"Couldn't find any page with nodeId={0}. This is most likely caused by the page not being published.",
() => id);
return null;
}
// extract domainUri and path
// route is /<path> or <domainRootId>/<path>
var pos = route.IndexOf('/');
var path = pos == 0 ? route : route.Substring(pos);
var domainUri = pos == 0 ? null : DomainHelper.DomainForNode(int.Parse(route.Substring(0, pos)), current);
// assemble the url from domainUri (maybe null) and path
return AssembleUrl(domainUri, path, current, mode).ToString();
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="content">The published content.</param>
/// <param name="mode">The url mode.</param>
/// <param name="culture">A culture.</param>
/// <param name="current">The current absolute url.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the published content is multi-lingual, gets the url for the specified culture or,
/// when no culture is specified, the current culture.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(IPublishedContent content, UrlProviderMode mode, string culture = null, Uri current = null)
{
if (content == null)
{
return("#");
}
// this the ONLY place where we deal with default culture - IUrlProvider always receive a culture
// be nice with tests, assume things can be null, ultimately fall back to invariant
// (but only for variant content of course)
if (content.ContentType.VariesByCulture())
{
if (culture == null)
{
culture = _variationContextAccessor?.VariationContext?.Culture ?? "";
}
}
if (current == null)
{
current = _umbracoContext.CleanedUmbracoUrl;
}
var url = _urlProviders.Select(provider => provider.GetUrl(_umbracoContext, content, mode, culture, current))
.FirstOrDefault(u => u != null);
return(url?.Text ?? "#"); // legacy wants this
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content.DocumentTypeAlias == "blogPost")
{
var model = new BlogPostViewModel(content);
if (model != null)
{
var date = model.PostCreation;
if (date != null)
{
//This will add the selected date before the node name.
//For example /blog/item1/ becomes /blog/28-07-2014/item1/.
var url = model.Content.Parent.Url;
if (!(url.EndsWith("/")))
{
url += "/";
}
var publishUrl = url + date.ToString("dd-MM-yyyy") + "/" + content.UrlName + "/";
return(publishUrl);
}
}
}
return(null);
}
private Uri AssembleUrl(string path, Uri current, UrlProviderMode mode)
{
if (string.IsNullOrEmpty(path))
{
return(null);
}
Uri uri;
if (current == null)
{
mode = UrlProviderMode.Relative; // best we can do
}
switch (mode)
{
case UrlProviderMode.Absolute:
uri = new Uri(current?.GetLeftPart(UriPartial.Authority) + path);
break;
case UrlProviderMode.Relative:
case UrlProviderMode.Auto:
uri = new Uri(path, UriKind.Relative);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode));
}
return(UriUtility.MediaUriFromUmbraco(uri));
}
/// <inheritdoc />
public virtual UrlInfo GetMediaUrl(UmbracoContext umbracoContext, IPublishedContent content,
string propertyAlias,
UrlProviderMode mode, string culture, Uri current)
{
var prop = content.GetProperty(propertyAlias);
var value = prop?.GetValue(culture);
if (value == null)
{
return(null);
}
var propType = prop.PropertyType;
string path = null;
switch (propType.EditorAlias)
{
case Constants.PropertyEditors.Aliases.UploadField:
path = value.ToString();
break;
case Constants.PropertyEditors.Aliases.ImageCropper:
//get the url from the json format
path = value is ImageCropperValue stronglyTyped ? stronglyTyped.Src : value.ToString();
break;
}
var url = AssembleUrl(path, current, mode);
return(url == null ? null : UrlInfo.Url(url.ToString(), culture));
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(int id, Uri current, UrlProviderMode mode)
{
var url = _urlProviders.Select(provider => provider.GetUrl(_umbracoContext, id, current, mode))
.FirstOrDefault(u => u != null);
return(url ?? "#"); // legacy wants this
}
/// <summary>
/// Initializes a new instance of the <see cref="UrlProvider"/> class with an Umbraco context and a list of url providers.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="urlProviders">The list of url providers.</param>
/// <param name="variationContextAccessor">The current variation accessor.</param>
/// <param name="mode">An optional provider mode.</param>
public UrlProvider(UmbracoContext umbracoContext, IEnumerable <IUrlProvider> urlProviders, IVariationContextAccessor variationContextAccessor, UrlProviderMode mode = UrlProviderMode.Auto)
{
_umbracoContext = umbracoContext ?? throw new ArgumentNullException(nameof(umbracoContext));
_urlProviders = urlProviders;
_variationContextAccessor = variationContextAccessor;
Mode = mode;
}
/// <summary>
/// Gets the localized URL.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <param name="id">The identifier.</param>
/// <param name="current">The current.</param>
/// <param name="mode">The mode.</param>
/// <param name="culture">The culture.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Current url must be absolute.;current</exception>
public string GetUrl(
UmbracoContext umbracoContext,
int id,
Uri current,
UrlProviderMode mode,
CultureInfo culture)
{
if (FindByUrlAliasEnabled /* && umbracoContext.IsFrontEndUmbracoRequest*/)
{
if (current.IsAbsoluteUri == false)
{
throw new ArgumentException("Current url must be absolute.", "current");
}
if (OnUrlGenerating != null)
{
OnUrlGeneratingEventArgs e = new OnUrlGeneratingEventArgs(umbracoContext, id, current, mode, culture);
OnUrlGenerating(this, e);
if (e.Cancel)
{
return(null);
}
}
string isoCode = culture.Name;
// will not use cache if previewing
bool anyLocalizedUrl;
string route = _routingHelper.GetRouteById(
umbracoContext,
umbracoContext.InPreviewMode,
id,
isoCode,
out anyLocalizedUrl);
// NO! We want to localize it because of Surface/Api Controller!
//if (anyLocalizedUrl == false) return null; // other provider should take care of it
if (string.IsNullOrWhiteSpace(route))
{
LogHelper.Debug <AliasUrlProvider>(
"Couldn't find any page with contentId={0}. This is most likely caused by the page not being published.",
() => id);
return(null);
}
// assemble the url from domainUri (maybe null) and path
return(_routingHelper.AssembleUrl(
route: route,
current: current,
mode: mode,
isoCode: isoCode));
}
else
{
return(null); // Other provider should take care of it.
}
}
/// <summary>
/// Gets the nice url of a custom routed published content item
/// </summary>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
if (umbracoContext.PublishedContentRequest == null) return null;
if (umbracoContext.PublishedContentRequest.PublishedContent == null) return null;
var virtualPage = umbracoContext.PublishedContentRequest.PublishedContent as DialogueVirtualPage;
if (virtualPage == null) return null;
//if the ids match, then return the assigned url
return id == virtualPage.Id ? virtualPage.Url : null;
}
/// <summary>
/// Initializes a new instance of the <see cref="UrlProvider"/> class with an Umbraco context and a list of url providers.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="urlProviders">The list of url providers.</param>
/// <param name="provider"></param>
public UrlProvider(UmbracoContext umbracoContext, IEnumerable<IUrlProvider> urlProviders, UrlProviderMode provider = UrlProviderMode.Auto)
{
if (umbracoContext == null) throw new ArgumentNullException("umbracoContext");
_umbracoContext = umbracoContext;
_urlProviders = urlProviders;
Mode = provider;
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == "Home" && content.Parent != null)
{
//The home node will have / instead of /home/.
return content.Parent.Url;
}
return null;
}
public async Task<string> GetUrlAsync(Guid id, Uri current, UrlProviderMode mode)
{
if (!current.IsAbsoluteUri)
throw new ArgumentException("Current url must be absolute.", "current");
// will not use cache if previewing
var route = await _contentCache.GetRouteByIdAsync(false, id);
if (route == null) return null;
return route;
}
/// <summary>
/// Initializes a new instance of the <see cref="UrlProvider"/> class with an Umbraco context and a list of url providers.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="urlProviders">The list of url providers.</param>
/// <param name="provider"></param>
public UrlProvider(UmbracoContext umbracoContext, IEnumerable <IUrlProvider> urlProviders, UrlProviderMode provider = UrlProviderMode.Auto)
{
if (umbracoContext == null)
{
throw new ArgumentNullException("umbracoContext");
}
_umbracoContext = umbracoContext;
_urlProviders = urlProviders;
Mode = provider;
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == "Home" && content.Parent != null)
{
//The home node will have / instead of /home/.
return(content.Parent.Url);
}
return(null);
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content == null)
{
LogHelper.Warn(MethodBase.GetCurrentMethod().DeclaringType, $"Couldn't find any page with nodeId={id}. This is most likely caused by the page not being published.");
return(null);
}
if (IsIgnored(content))
{
return(null);
}
var domain = UrlHelper.GetUmbracoDomain(current);
var domainUri = UrlHelper.GetUri(current, domain);
string cultureName = null;
if (CultureFromUrlService.Current.IsCultureFromUrlEnabled)
{
cultureName = CultureFromUrlService.Current.GetCultureInfo(current, VortoUrlService.Current.FallbackCultureName)?.Name;
}
else
{
cultureName = domain?.LanguageIsoCode ?? VortoUrlService.Current.FallbackCultureName;
}
var rootContentId = GetRootContentId(current, domain);
var ancestorsAndContent = content.Ancestors()
.Where(x => x.Parent != null)
.SortByParent()
.ToList();
if (content.Id != rootContentId)
{
ancestorsAndContent.Add(content);
}
var url = GetRelativeUrl(ancestorsAndContent, cultureName);
if (CultureFromUrlService.Current.IsCultureFromUrlEnabled)
{
url = $"/{cultureName}{url}";
}
var prefix = mode == UrlProviderMode.Relative ? string.Empty : domainUri;
return(UrlHelper.CombinePaths(prefix, url.ToLower(), VortoUrlService.Current.IsTrimUrlTrailingSlashEnabled));
}
/// <summary>
/// The get url.
/// </summary>
/// <param name="umbracoContext">
/// The umbraco context.
/// </param>
/// <param name="id">
/// The id.
/// </param>
/// <param name="current">
/// The current.
/// </param>
/// <param name="mode">
/// The mode.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
UmbracoContext.Current.Application.ApplicationCache.RequestCache.ClearCacheItem("MultilingualUrlProvider-GetUrl-" + id);
return(UmbracoContext.Current.Application.ApplicationCache.RequestCache.GetCacheItem <string>(
"MultilingualUrlProvider-GetUrl-" + id,
() =>
{
var content = umbracoContext.ContentCache.GetById(id) as Umbraco.Web.PublishedContentModels.Master;
if (content != null)
{
var domains =
ApplicationContext.Current.Services.DomainService.GetAll(true)
.OrderBy(x => x.Id)
.ToList();
if (domains.Any())
{
// Don't use umbracoContext.PublishedContentRequest.Culture because this code is also called in the backend.
//var currentCulture = Thread.CurrentThread.CurrentCulture.ToString();
var currentCulture = new UmbracoHelper(umbracoContext).CultureDictionary.Culture.Name;
// On the frontend get the domain that matches the current culture. We could also check the domain name, but for now the culture is enough.
// Otherwise just get the first domain. The urls for the other domains are generated in the GetOtherUrls method.
//var domain = UmbracoContext.Current.IsFrontEndUmbracoRequest
// ? domains.First(x => x.LanguageIsoCode.InvariantEquals(currentCulture))
// : domains.First();
var domain = domains.First(x => x.LanguageIsoCode.InvariantEquals(currentCulture));
if (content.DocumentTypeAlias.InvariantEquals(MainPage.ModelTypeAlias))
{
// Return the domain if we're on the homepage because on that node we've added the domains.
return domain.DomainName.EnsureEndsWith("/");
}
// Get the parent url and add the url segment of this culture.
if (content.Parent != null)
{
var parentUrl = umbracoContext.UrlProvider.GetUrl(content.Parent.Id);
var urlSegment = content.GetUrlSegment(domain.LanguageIsoCode);
return parentUrl.EnsureEndsWith("/") + urlSegment;
}
else
{
return domain.DomainName.EnsureEndsWith("/") + content.GetUrlSegment(domain.LanguageIsoCode);
}
}
}
return null;
}));
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public async Task <string> GetUrlAsync(Guid id, Uri current, UrlProviderMode mode)
{
foreach (var provider in _urlProviders)
{
var result = await provider.GetUrlAsync(id, current, mode);
if (result != null)
{
return(result);
}
}
return(null);
}
/// <summary>
/// Gets the localized URL by the thread's current ui culture.
/// </summary>
/// <param name="umbracoContext">The umbraco context.</param>
/// <param name="id">The identifier.</param>
/// <param name="current">The current.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Current url must be absolute.;current</exception>
public string GetUrl(
UmbracoContext umbracoContext,
int id,
Uri current,
UrlProviderMode mode)
{
return(this.GetUrl(
umbracoContext: umbracoContext,
id: id,
current: current,
mode: mode,
culture: Thread.CurrentThread.CurrentUICulture));
}
public OnUrlGeneratingEventArgs(
UmbracoContext umbracoContext,
int id,
Uri current,
UrlProviderMode mode = UrlProviderMode.Auto,
CultureInfo culture = null)
{
UmbracoContext = umbracoContext;
Id = id;
CurrentUri = current;
UrlProviderMode = mode;
Culture = culture;
Cancel = false;
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content == null)
{
return(null);
}
if (content.IsContainer())
{
return("#");
}
return(null);
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == "Home" && content.Parent != null)
{
//The home node will have / instead of /home/.
if (UrlProviderMode.Absolute == mode)
{
return current.GetLeftPart(UriPartial.Authority) + content.Parent.Url;
}
return content.Parent.Url;
}
return null;
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>
/// The url for the published content.
/// </returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it should return <c>null</c>.</para>
/// </remarks>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content == null || content.DocumentTypeAlias != "BlogPost" || content.Parent == null)
{
return(null);
}
var date = content.CreateDate;
//This will add the selected date before the node name.
//For example /news/item1/ becomes /news/28-07-2014/item1/.
var url = content.Parent.Url;
url.EnsureEndsWith('/');
return($"{url}{date.ToString("dd-MM-yyyy").EnsureEndsWith('/')}{content.UrlName.EnsureEndsWith('/')}");
}
public async Task <string> GetUrlAsync(Guid id, Uri current, UrlProviderMode mode)
{
if (!current.IsAbsoluteUri)
{
throw new ArgumentException("Current url must be absolute.", "current");
}
// will not use cache if previewing
var route = await _contentCache.GetRouteByIdAsync(false, id);
if (route == null)
{
return(null);
}
return(route);
}
/// <summary>
/// Gets the nice url of a custom routed published content item
/// </summary>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
if (umbracoContext.PublishedContentRequest == null)
{
return(null);
}
if (umbracoContext.PublishedContentRequest.PublishedContent == null)
{
return(null);
}
var virtualPage = umbracoContext.PublishedContentRequest.PublishedContent as ArticulateVirtualPage;
if (virtualPage == null)
{
return(null);
}
//if the ids match, then return the assigned url
return(id == virtualPage.Id ? virtualPage.Url : null);
}
/// <summary>
/// This will simply return the URL that is returned by the assigned IPublishedContent if this is a custom route
/// </summary>
/// <param name="umbracoContext"></param>
/// <param name="id"></param>
/// <param name="current"></param>
/// <param name="mode"></param>
/// <returns></returns>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
if (umbracoContext == null)
{
return(null);
}
if (umbracoContext.PublishedContentRequest == null)
{
return(null);
}
if (umbracoContext.PublishedContentRequest.PublishedContent == null)
{
return(null);
}
if (umbracoContext.HttpContext == null)
{
return(null);
}
if (umbracoContext.HttpContext.Request == null)
{
return(null);
}
if (umbracoContext.HttpContext.Request.RequestContext == null)
{
return(null);
}
if (umbracoContext.HttpContext.Request.RequestContext.RouteData == null)
{
return(null);
}
if (umbracoContext.HttpContext.Request.RequestContext.RouteData.DataTokens == null)
{
return(null);
}
if (umbracoContext.HttpContext.Request.RequestContext.RouteData.DataTokens.ContainsKey(Umbraco.Core.Constants.Web.CustomRouteDataToken) == false)
{
return(null);
}
//ok so it's a custom route with published content assigned, check if the id being requested for is the same id as the assigned published content
return(id == umbracoContext.PublishedContentRequest.PublishedContent.Id
? umbracoContext.PublishedContentRequest.PublishedContent.Url
: null);
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == "Newsitem" && content.Parent != null)
{
var date = content.GetPropertyValue<DateTime>("currentDate");
if(date != null)
{
//This will add the selected date before the node name.
//For example /news/item1/ becomes /news/28-07-2014/item1/.
var url = content.Parent.Url;
if (!(url.EndsWith("/")))
{
url += "/";
}
return url + date.ToString("dd-MM-yyyy") + "/" + content.UrlName + "/";
}
}
return null;
}
public override string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var node = umbracoContext.ContentCache.GetById(id);
if (node != null && node.ContentType.Alias.Equals("Fruit"))
{
if (node.HasVortoValue("fruitName"))
{
var v = new VortoApiController();
var lang = (List<Our.Umbraco.Vorto.Models.Language>)v.GetInstalledLanguages();
var primaryLang = string.Empty;
if (lang.Select(x => x.IsoCode).Contains("en-US"))
{
primaryLang = "en-US";
}
else
{
var firstOrDefault = lang.FirstOrDefault();
if (firstOrDefault != null)
{
primaryLang = firstOrDefault.IsoCode;
}
}
var vortoValue = node.GetVortoValue<string>("fruitName", primaryLang);
var culture = CultureInfo.GetCultureInfo(primaryLang);
var primaryBox = umbracoContext.ContentCache.GetAtRoot().DescendantsOrSelf("Box").FirstOrDefault(x => Equals(x.GetCulture(), culture));
if (primaryBox != null)
{
return string.Format("{0}{1}/", primaryBox.Url, vortoValue.ToUrlSegment());
}
}
}
return base.GetUrl(umbracoContext, id, current, mode);
}
/// <summary>
/// Assembles the URL with the found hostname.
/// </summary>
/// <param name="route">The route.</param>
/// <param name="current">The current.</param>
/// <param name="mode">The mode.</param>
/// <param name="isoCode">The iso code.</param>
/// <returns></returns>
internal string AssembleUrl(
string route,
Uri current,
UrlProviderMode mode,
string isoCode)
{
// extract domainUri and path
// route is /<path> or <domainRootId>/<path>
int pos = route.IndexOf('/');
string path = pos == 0 ? route : route.Substring(pos);
DomainAndUri domainUri = pos == 0 ? null : this.DomainForNode(
contentId: int.Parse(route.Substring(0, pos)),
current: current,
isoCode: isoCode);
return(UmbracoAssembleUrl(
domainUri: domainUri,
path: path,
current: current,
mode: mode).ToString());
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == "Newsitem" && content.Parent != null)
{
var date = content.GetPropertyValue <DateTime>("currentDate");
if (date != null)
{
//This will add the selected date before the node name.
//For example /news/item1/ becomes /news/28-07-2014/item1/.
var url = content.Parent.Url;
if (!(url.EndsWith("/")))
{
url += "/";
}
return(url + date.ToString("dd-MM-yyyy") + "/" + content.UrlName + "/");
}
}
return(null);
}
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content != null && content.DocumentTypeAlias == Blog.Presets.DocTypes.BlogPost)
{
var format = content.GetPropertyValue <string>
(Blog.Presets.Properties.Permalinks, true, "%year%/%monthnum%/%day%/%postname%/")
.Trim(new char[] { '-' });
var date = content.GetPropertyValue <DateTime>(Blog.Presets.Properties.PublishDate, content.CreateDate);
if (date != null && date > DateTime.MinValue)
{
var baseUrl = "";
var blogRoot = content.AncestorOrSelf(Blog.Presets.DocTypes.Blog);
if (blogRoot != null)
{
baseUrl = blogRoot.Url;
}
else
{
baseUrl = content.Parent.Url;
}
if (!baseUrl.EndsWith("/"))
{
baseUrl += "/";
}
var replacements = new Dictionary <string, string>();
replacements.Add("%postname%", content.UrlName);
replacements.Add("%post_id", content.Id.ToString());
return(baseUrl + FormatBlogUrl(format, date, replacements));
}
}
return(null);
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content identifier.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on the current url.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(Guid id, UrlProviderMode mode)
{
var intId = _umbracoContext.Application.Services.EntityService.GetIdForKey(id, UmbracoObjectTypes.Document);
return(GetUrl(intId.Success ? intId.Result : -1, mode));
}
// note - at the moment we seem to accept pretty much anything as an alias
// without any form of validation ... could even prob. kill the XPath ...
// ok, this is somewhat experimental and is NOT enabled by default
#region GetUrl
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on url indicated by <c>current</c> and settings, unless
/// <c>absolute</c> is true, in which case the url is always absolute.</para>
/// <para>If the provider is unable to provide a url, it should return <c>null</c>.</para>
/// </remarks>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
return null; // we have nothing to say
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content identifier.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on the current url.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(int id, UrlProviderMode mode)
{
return(GetUrl(id, _umbracoContext.CleanedUmbracoUrl, mode));
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public async Task<string> GetUrlAsync(Guid id, Uri current, UrlProviderMode mode)
{
foreach (var provider in _urlProviders)
{
var result = await provider.GetUrlAsync(id, current, mode);
if (result != null)
{
return result;
}
}
return null;
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content identifier.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on the current url.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(Guid id, UrlProviderMode mode)
{
return GetUrl(id, new Uri(_umbracoContext.RequestPath), mode);
}
/// <summary> /// Gets the nice url of a published content. /// </summary> /// <param name="id">The published content identifier.</param> /// <param name="mode">The url mode.</param> /// <param name="culture">A culture.</param> /// <param name="current">The current absolute url.</param> /// <returns>The url for the published content.</returns> public string GetUrl(int id, UrlProviderMode mode, string culture = null, Uri current = null) => GetUrl(GetDocument(id), mode, culture, current);
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content identifier.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on the current url.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public async Task<string> GetUrlAsync(Guid id, UrlProviderMode mode)
{
return await GetUrlAsync(id, _umbracoContext.OriginalRequestUri, mode);
}
/// <summary>
/// Gets the URL of the content.
/// </summary>
public override string GetUrl(Umbraco.Web.UmbracoContext umbracoContext, int id,
Uri current, UrlProviderMode mode) {
// Variables.
var url = base.GetUrl(umbracoContext, id, current, mode);
var alias = null as string;
// Avoid unnecessary work when possible by returning early.
if (string.IsNullOrWhiteSpace(url)) {
return url;
}
// Log errors.
try {
// Get the doctype alias from the cache or from the content service.
if (umbracoContext.PublishedContentRequest == null) {
// Get alias from content service.
var service = umbracoContext.Application.Services.ContentService;
var node = service.GetById(id);
if (node != null) {
alias = node.ContentType.Alias;
}
} else {
// Get alias from cache.
var node = umbracoContext.ContentCache.GetById(id);
if (node != null) {
alias = node.DocumentTypeAlias;
}
}
// For document fragments, convert the last part to a fragment identifier.
// Removes trailing slashes and the ".aspx" extension.
if (alias != null && "DocumentFragment".InvariantEquals(alias)) {
var originalUrl = url;
var hashReplace = "#";
if (url.EndsWith("/")) {
url = url.TrimEnd("/".ToCharArray());
hashReplace = "/#";
}
if (url.EndsWith(".aspx", StringComparison.InvariantCultureIgnoreCase)) {
url = url.Substring(0, url.Length - 5);
}
var pos = url.LastIndexOf('/');
if (pos >= 0) {
url = url.Substring(0, pos) + hashReplace + url.Substring(pos + 1);
if (url.StartsWith("#")) {
url = "/" + url;
}
} else {
url = originalUrl;
}
}
}
catch (Exception ex) {
LogHelper.Error<FragmentUrlProvider>(ErrorFragmentUrl, ex);
}
// Return URL.
return url;
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(int id, Uri current, UrlProviderMode mode)
{
var url = _urlProviders.Select(provider => provider.GetUrl(_umbracoContext, id, current, mode))
.FirstOrDefault(u => u != null);
return url ?? "#"; // legacy wants this
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="id">The published content identifier.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on the current url.</para>
/// <para>If the provider is unable to provide a url, it returns "#".</para>
/// </remarks>
public string GetUrl(int id, UrlProviderMode mode)
{
return GetUrl(id, _umbracoContext.CleanedUmbracoUrl, mode);
}
Uri AssembleUrl(DomainAndUri domainUri, string path, Uri current, UrlProviderMode mode)
{
Uri uri;
// ignore vdir at that point, UriFromUmbraco will do it
if (mode == UrlProviderMode.AutoLegacy)
{
mode = UmbracoConfig.For.UmbracoSettings().RequestHandler.UseDomainPrefixes
? UrlProviderMode.Absolute
: UrlProviderMode.Auto;
}
if (domainUri == null) // no domain was found
{
if (current == null)
mode = UrlProviderMode.Relative; // best we can do
switch (mode)
{
case UrlProviderMode.Absolute:
uri = new Uri(current.GetLeftPart(UriPartial.Authority) + path);
break;
case UrlProviderMode.Relative:
case UrlProviderMode.Auto:
uri = new Uri(path, UriKind.Relative);
break;
default:
throw new ArgumentOutOfRangeException("mode");
}
}
else // a domain was found
{
if (mode == UrlProviderMode.Auto)
{
if (current != null && domainUri.Uri.GetLeftPart(UriPartial.Authority) == current.GetLeftPart(UriPartial.Authority))
mode = UrlProviderMode.Relative;
else
mode = UrlProviderMode.Absolute;
}
switch (mode)
{
case UrlProviderMode.Absolute:
uri = new Uri(CombinePaths(domainUri.Uri.GetLeftPart(UriPartial.Path), path));
break;
case UrlProviderMode.Relative:
uri = new Uri(CombinePaths(domainUri.Uri.AbsolutePath, path), UriKind.Relative);
break;
default:
throw new ArgumentOutOfRangeException("mode");
}
}
// UriFromUmbraco will handle vdir
// meaning it will add vdir into domain urls too!
return UriUtility.UriFromUmbraco(uri);
}
Uri AssembleUrl(DomainAndUri domainUri, string path, Uri current, UrlProviderMode mode)
{
Uri uri;
// ignore vdir at that point, UriFromUmbraco will do it
if (mode == UrlProviderMode.AutoLegacy)
{
mode = _requestSettings.UseDomainPrefixes
? UrlProviderMode.Absolute
: UrlProviderMode.Auto;
}
if (domainUri == null) // no domain was found
{
if (current == null)
{
mode = UrlProviderMode.Relative; // best we can do
}
switch (mode)
{
case UrlProviderMode.Absolute:
uri = new Uri(current.GetLeftPart(UriPartial.Authority) + path);
break;
case UrlProviderMode.Relative:
case UrlProviderMode.Auto:
uri = new Uri(path, UriKind.Relative);
break;
default:
throw new ArgumentOutOfRangeException("mode");
}
}
else // a domain was found
{
if (mode == UrlProviderMode.Auto)
{
if (current != null && domainUri.Uri.GetLeftPart(UriPartial.Authority) == current.GetLeftPart(UriPartial.Authority))
{
mode = UrlProviderMode.Relative;
}
else
{
mode = UrlProviderMode.Absolute;
}
}
switch (mode)
{
case UrlProviderMode.Absolute:
uri = new Uri(CombinePaths(domainUri.Uri.GetLeftPart(UriPartial.Path), path));
break;
case UrlProviderMode.Relative:
uri = new Uri(CombinePaths(domainUri.Uri.AbsolutePath, path), UriKind.Relative);
break;
default:
throw new ArgumentOutOfRangeException("mode");
}
}
// UriFromUmbraco will handle vdir
// meaning it will add vdir into domain urls too!
return(UriUtility.UriFromUmbraco(uri));
}
private Uri UmbracoAssembleUrl(DomainAndUri domainUri, string path, Uri current, UrlProviderMode mode)
{
// This method is private in umbraco, but we want to use their!
DefaultUrlProvider provider = ActivatorHelper.CreateInstance <DefaultUrlProvider>();
return(ActivatorHelper.GetPrivateMethodReturnValueOfInstance <Uri>(
instance: provider,
methodName: "AssembleUrl",
methodArguments: new object[] { domainUri, path, current, mode }));
}
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on <c>mode</c> and on <c>current</c>.</para>
/// <para>If the provider is unable to provide a url, it should return <c>null</c>.</para>
/// </remarks>
public virtual string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
if (!current.IsAbsoluteUri)
{
throw new ArgumentException("Current url must be absolute.", "current");
}
// will not use cache if previewing
var route = umbracoContext.ContentCache.GetRouteById(id);
if (string.IsNullOrWhiteSpace(route))
{
LogHelper.Debug <DefaultUrlProvider>(
"Couldn't find any page with nodeId={0}. This is most likely caused by the page not being published.",
() => id);
return(null);
}
var domainHelper = new DomainHelper(umbracoContext.Application.Services.DomainService);
// extract domainUri and path
// route is /<path> or <domainRootId>/<path>
var pos = route.IndexOf('/');
var path = pos == 0 ? route : route.Substring(pos);
var domainUri = pos == 0
? null
: domainHelper.DomainForNode(int.Parse(route.Substring(0, pos)), current);
// assemble the url from domainUri (maybe null) and path
return(AssembleUrl(domainUri, path, current, mode).ToString());
}
// note - at the moment we seem to accept pretty much anything as an alias
// without any form of validation ... could even prob. kill the XPath ...
// ok, this is somewhat experimental and is NOT enabled by default
#region GetUrl
/// <summary>
/// Gets the nice url of a published content.
/// </summary>
/// <param name="umbracoContext">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute url.</param>
/// <param name="mode">The url mode.</param>
/// <returns>The url for the published content.</returns>
/// <remarks>
/// <para>The url is absolute or relative depending on url indicated by <c>current</c> and settings, unless
/// <c>absolute</c> is true, in which case the url is always absolute.</para>
/// <para>If the provider is unable to provide a url, it should return <c>null</c>.</para>
/// </remarks>
public string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
return(null); // we have nothing to say
}
/// <inheritdoc/>
public override string GetUrl(UmbracoContext umbracoContext, int id, Uri current, UrlProviderMode mode)
{
var content = umbracoContext.ContentCache.GetById(id);
if (content?.Parent == null)
{
return(null);
}
if (!current.IsAbsoluteUri)
{
throw new ArgumentException("Current url must be absolute.", "current");
}
if (content.DocumentTypeAlias == nameof(ErrorPageModel))
{
var parts = current.GetAbsolutePathDecoded().Split(
new[] { '/' },
StringSplitOptions.RemoveEmptyEntries);
var tmpUrl = "/";
// Lets try to get the content by using parts of the url until we find it.
for (var index = 0; index < parts.Length; index++)
{
tmpUrl += parts[index] + "/";
try
{
// Try to resolve it as a route.
content = UmbracoContext.Current.ContentCache.GetByRoute(tmpUrl);
if (content != null)
{
break;
}
}
catch (Exception)
{
// ignored
}
}
if (content?.Parent == null)
{
return(null);
}
}
if (content.DocumentTypeAlias == nameof(ProfilePageModel))
{
using (var container = DependencyResolver.Current.GetService <IContainer>().GetNestedContainer())
{
var membershipService = container.GetInstance <IMembershipService>();
var helper = new UmbracoHelper(umbracoContext);
// This will add the selected date before the node name. For example /news/item1/
// becomes /news/28-07-2014/item1/.
var url = content.Parent.Url;
if (!url.EndsWith("/"))
{
url += "/";
}
var currentUrl = current.AbsolutePath;
currentUrl = currentUrl.TrimStart('/');
var segments = currentUrl.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (!segments.Skip(1).Any())
{
var currentMember = helper.MembershipHelper.GetCurrentMember() as MemberPublishedContent;
if (currentMember != null)
{
var member = membershipService.MapMember(currentMember);
var u = string.Format(
"{0}/{1}/",
url + content.UrlName,
member.UserName.ToLower().ToUrlSegment());
return(u);
}
}
else
{
var username = segments.Skip(1).First();
var memberByUsername =
helper.MembershipHelper.GetByUsername(username) as MemberPublishedContent;
if (memberByUsername == null)
{
memberByUsername = ApplicationContext.Current.Services.MemberService
.GetMembersByGroup(nameof(MemberTypes.SiteMember))
.Select(x => helper.MembershipHelper.GetById(x.Id)).OfType <MemberPublishedContent>()
.FirstOrDefault(
x => x.UserName.ToUrlSegment().Equals(
username,
StringComparison.OrdinalIgnoreCase));
}
if (memberByUsername != null)
{
var member = membershipService.MapMember(memberByUsername);
var u = string.Format(
"{0}/{1}/",
url + content.UrlName,
member.UserName.ToLower().ToUrlSegment());
return(u);
}
}
}
}
return(null);
}
