/// <inheritdoc />
public virtual UrlInfo?GetMediaUrl(
IPublishedContent content,
string propertyAlias,
UrlMode mode,
string?culture,
Uri current)
{
IPublishedProperty?prop = content.GetProperty(propertyAlias);
// get the raw source value since this is what is used by IDataEditorWithMediaPath for processing
var value = prop?.GetSourceValue(culture);
if (value == null)
{
return(null);
}
IPublishedPropertyType?propType = prop?.PropertyType;
if (_mediaPathGenerators.TryGetMediaPath(propType?.EditorAlias, value, out var path))
{
Uri url = AssembleUrl(path !, current, mode);
return(UrlInfo.Url(url.ToString(), culture));
}
return(null);
}
public override UrlInfo GetUrl(UmbracoContext umbracoContext, IPublishedContent content, UrlMode mode, string culture, Uri current)
{
if (content != null && (content.ContentType.Alias == "ArticulateRichText" || content.ContentType.Alias == "ArticulateMarkdown") && content.Parent != null)
{
if (content.Parent.Parent != null)
{
var useDateFormat = content.Parent.Parent.Value <bool>("useDateFormatForUrl");
if (!useDateFormat)
{
return(null);
}
}
var date = content.Value <DateTime>("publishedDate");
if (date != null)
{
var parentPath = base.GetUrl(umbracoContext, content, mode, culture, current);
var urlFolder = string.Format("{0}/{1:d2}/{2:d2}", date.Year, date.Month, date.Day);
var newUrl = parentPath.Text.EnsureEndsWith("/") + urlFolder + "/" + content.Url;
return(UrlInfo.Url(newUrl, culture));
}
}
return(null);
}
public void Ensure_Image_Sources()
{
// setup a mock URL provider which we'll use for testing
var mediaType = new PublishedContentType(Guid.NewGuid(), 777, "image", PublishedItemType.Media, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var media = new Mock <IPublishedContent>();
media.Setup(x => x.ContentType).Returns(mediaType);
var mediaUrlProvider = new Mock <IMediaUrlProvider>();
mediaUrlProvider.Setup(x => x.GetMediaUrl(It.IsAny <IPublishedContent>(), It.IsAny <string>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/media/1001/my-image.jpg"));
var umbracoContextAccessor = new TestUmbracoContextAccessor();
IUmbracoContextFactory umbracoContextFactory = TestUmbracoContextFactory.Create(
umbracoContextAccessor: umbracoContextAccessor);
var webRoutingSettings = new WebRoutingSettings();
var publishedUrlProvider = new UrlProvider(
umbracoContextAccessor,
Options.Create(webRoutingSettings),
new UrlProviderCollection(() => Enumerable.Empty <IUrlProvider>()),
new MediaUrlProviderCollection(() => new[] { mediaUrlProvider.Object }),
Mock.Of <IVariationContextAccessor>());
using (UmbracoContextReference reference = umbracoContextFactory.EnsureUmbracoContext())
{
var mediaCache = Mock.Get(reference.UmbracoContext.Media);
mediaCache.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(media.Object);
var imageSourceParser = new HtmlImageSourceParser(publishedUrlProvider);
var result = imageSourceParser.EnsureImageSources(@"<p>
<div>
<img src="""" />
</div></p>
<p>
<div><img src="""" data-udi=""umb://media/81BB2036-034F-418B-B61F-C7160D68DCD4"" /></div>
</p>
<p>
<div><img src=""?width=100"" data-udi=""umb://media/81BB2036-034F-418B-B61F-C7160D68DCD4"" /></div>
</p>");
Assert.AreEqual(
@"<p>
<div>
<img src="""" />
</div></p>
<p>
<div><img src=""/media/1001/my-image.jpg"" data-udi=""umb://media/81BB2036-034F-418B-B61F-C7160D68DCD4"" /></div>
</p>
<p>
<div><img src=""/media/1001/my-image.jpg?width=100"" data-udi=""umb://media/81BB2036-034F-418B-B61F-C7160D68DCD4"" /></div>
</p>", result);
}
}
public void ParseLocalLinks(string input, string result)
{
// setup a mock URL provider which we'll use for testing
var contentUrlProvider = new Mock <IUrlProvider>();
contentUrlProvider
.Setup(x => x.GetUrl(It.IsAny <IPublishedContent>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/my-test-url"));
var contentType = new PublishedContentType(Guid.NewGuid(), 666, "alias", PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var publishedContent = new Mock <IPublishedContent>();
publishedContent.Setup(x => x.Id).Returns(1234);
publishedContent.Setup(x => x.ContentType).Returns(contentType);
var mediaType = new PublishedContentType(Guid.NewGuid(), 777, "image", PublishedItemType.Media, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var media = new Mock <IPublishedContent>();
media.Setup(x => x.ContentType).Returns(mediaType);
var mediaUrlProvider = new Mock <IMediaUrlProvider>();
mediaUrlProvider.Setup(x => x.GetMediaUrl(It.IsAny <IPublishedContent>(), It.IsAny <string>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/media/1001/my-image.jpg"));
var umbracoContextAccessor = new TestUmbracoContextAccessor();
IUmbracoContextFactory umbracoContextFactory = TestUmbracoContextFactory.Create(
umbracoContextAccessor: umbracoContextAccessor);
var webRoutingSettings = new WebRoutingSettings();
var publishedUrlProvider = new UrlProvider(
umbracoContextAccessor,
Microsoft.Extensions.Options.Options.Create(webRoutingSettings),
new UrlProviderCollection(() => new[] { contentUrlProvider.Object }),
new MediaUrlProviderCollection(() => new[] { mediaUrlProvider.Object }),
Mock.Of <IVariationContextAccessor>());
using (UmbracoContextReference reference = umbracoContextFactory.EnsureUmbracoContext())
{
var contentCache = Mock.Get(reference.UmbracoContext.Content);
contentCache.Setup(x => x.GetById(It.IsAny <int>())).Returns(publishedContent.Object);
contentCache.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(publishedContent.Object);
var mediaCache = Mock.Get(reference.UmbracoContext.Media);
mediaCache.Setup(x => x.GetById(It.IsAny <int>())).Returns(media.Object);
mediaCache.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(media.Object);
var linkParser = new HtmlLocalLinkParser(umbracoContextAccessor, publishedUrlProvider);
var output = linkParser.EnsureInternalLinks(input);
Assert.AreEqual(result, output);
}
}
/// <summary>
/// Gets the other URLs of a published content.
/// </summary>
/// <param name="umbracoContextAccessor">The Umbraco context.</param>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute URL.</param>
/// <returns>The other URLs for the published content.</returns>
/// <remarks>
/// <para>
/// Other URLs are those that <c>GetUrl</c> would not return in the current context, but would be valid
/// URLs for the node in other contexts (different domain for current request, umbracoUrlAlias...).
/// </para>
/// </remarks>
public virtual IEnumerable <UrlInfo> GetOtherUrls(int id, Uri current)
{
IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
IPublishedContent?node = umbracoContext.Content?.GetById(id);
if (node == null)
{
yield break;
}
// look for domains, walking up the tree
IPublishedContent? n = node;
IEnumerable <DomainAndUri>?domainUris =
DomainUtilities.DomainsForNode(umbracoContext.PublishedSnapshot.Domains, _siteDomainMapper, n.Id, current, false);
// n is null at root
while (domainUris == null && n != null)
{
n = n.Parent; // move to parent node
domainUris = n == null
? null
: DomainUtilities.DomainsForNode(umbracoContext.PublishedSnapshot.Domains, _siteDomainMapper, n.Id, current);
}
// no domains = exit
if (domainUris == null)
{
yield break;
}
foreach (DomainAndUri d in domainUris)
{
var culture = d.Culture;
// although we are passing in culture here, if any node in this path is invariant, it ignores the culture anyways so this is ok
var route = umbracoContext.Content?.GetRouteById(id, culture);
if (route == null)
{
continue;
}
// need to strip off the leading ID for the route if it exists (occurs if the route is for a node with a domain assigned)
var pos = route.IndexOf('/');
var path = pos == 0 ? route : route.Substring(pos);
var uri = new Uri(CombinePaths(d.Uri.GetLeftPart(UriPartial.Path), path));
uri = _uriUtility.UriFromUmbraco(uri, _requestSettings);
yield return(UrlInfo.Url(uri.ToString(), culture));
}
}
public void ParseLocalLinks(string input, string result)
{
//setup a mock url provider which we'll use for testing
var contentUrlProvider = new Mock <IUrlProvider>();
contentUrlProvider
.Setup(x => x.GetUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/my-test-url"));
var contentType = new PublishedContentType(666, "alias", PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var publishedContent = new Mock <IPublishedContent>();
publishedContent.Setup(x => x.Id).Returns(1234);
publishedContent.Setup(x => x.ContentType).Returns(contentType);
var mediaType = new PublishedContentType(777, "image", PublishedItemType.Media, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var media = new Mock <IPublishedContent>();
media.Setup(x => x.ContentType).Returns(mediaType);
var mediaUrlProvider = new Mock <IMediaUrlProvider>();
mediaUrlProvider.Setup(x => x.GetMediaUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <string>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/media/1001/my-image.jpg"));
var umbracoContextAccessor = new TestUmbracoContextAccessor();
var umbracoContextFactory = TestUmbracoContextFactory.Create(
urlProvider: contentUrlProvider.Object,
mediaUrlProvider: mediaUrlProvider.Object,
umbracoContextAccessor: umbracoContextAccessor);
using (var reference = umbracoContextFactory.EnsureUmbracoContext(Mock.Of <HttpContextBase>()))
{
var contentCache = Mock.Get(reference.UmbracoContext.Content);
contentCache.Setup(x => x.GetById(It.IsAny <int>())).Returns(publishedContent.Object);
contentCache.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(publishedContent.Object);
var mediaCache = Mock.Get(reference.UmbracoContext.Media);
mediaCache.Setup(x => x.GetById(It.IsAny <int>())).Returns(media.Object);
mediaCache.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(media.Object);
var linkParser = new HtmlLocalLinkParser(umbracoContextAccessor);
var output = linkParser.EnsureInternalLinks(input);
Assert.AreEqual(result, output);
}
}
public void Can_Mock_UrlProvider()
{
var umbracoContext = TestObjects.GetUmbracoContextMock();
var urlProviderMock = new Mock <IUrlProvider>();
urlProviderMock.Setup(provider => provider.GetUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/hello/world/1234"));
var urlProvider = urlProviderMock.Object;
var theUrlProvider = new UrlProvider(umbracoContext, new [] { urlProvider }, Enumerable.Empty <IMediaUrlProvider>(), umbracoContext.VariationContextAccessor);
var contentType = new PublishedContentType(Guid.NewGuid(), 666, "alias", PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var publishedContent = Mock.Of <IPublishedContent>();
Mock.Get(publishedContent).Setup(x => x.ContentType).Returns(contentType);
Assert.AreEqual("/hello/world/1234", theUrlProvider.GetUrl(publishedContent));
}
/// <inheritdoc />
public UrlInfo GetUrl(UmbracoContext umbracoContext, IPublishedContent content, UrlMode mode, string culture, Uri current)
{
string url;
switch (content.ContentType.Alias)
{
case "robotsTxt":
url = "/robots.txt";
break;
case "sitemapXml":
url = $"/sitemap-{culture}.xml";
break;
default:
return(null);
}
return(UrlInfo.Url(mode == UrlMode.Absolute ? new Uri(current, url).ToString() : url));
}
/// <summary>
/// Gets the nice url of a custom routed published content item
/// </summary>
public UrlInfo GetUrl(UmbracoContext umbracoContext, IPublishedContent content, UrlProviderMode mode, string culture, Uri current)
{
if (umbracoContext.PublishedRequest == null)
{
return(null);
}
if (umbracoContext.PublishedRequest.PublishedContent == null)
{
return(null);
}
var virtualPage = umbracoContext.PublishedRequest.PublishedContent as ArticulateVirtualPage;
if (virtualPage == null)
{
return(null);
}
//if the ids match, then return the assigned url
return(content.Id == virtualPage.Id ? UrlInfo.Url(virtualPage.Url, culture) : null);
}
protected UrlInfo GetHeadRestUrl(UmbracoContext umbracoContext, int id, string culture, HeadRestEndpointMode endpointMode)
{
var content = umbracoContext.Content.GetById(id);
foreach (var headRestConfig in HeadRest.Configs.Values.Where(x => x.Mode == endpointMode))
{
var rootNode = umbracoContext.Content.GetSingleByXPath(headRestConfig.RootNodeXPath);
if (content.Path.StartsWith(rootNode.Path))
{
var subUrl = string.Join("/", content.AncestorsOrSelf(true, x => x.Level > rootNode.Level)
.Select(x => x.UrlSegment)
.Reverse());
var url = (headRestConfig.BasePath
.EnsureStartsWith("/")
.EnsureEndsWith("/") + subUrl).EnsureEndsWith('/');
return(UrlInfo.Url(url, culture));;
}
}
return(null);
}
/// <summary>
/// Tries to return a <see cref="UrlInfo" /> for each culture for the content while detecting collisions/errors
/// </summary>
private static async Task <IEnumerable <UrlInfo> > GetContentUrlsByCultureAsync(
IContent content,
IEnumerable <string> cultures,
IPublishedRouter publishedRouter,
IUmbracoContext umbracoContext,
IContentService contentService,
ILocalizedTextService textService,
IVariationContextAccessor variationContextAccessor,
ILogger logger,
UriUtility uriUtility,
IPublishedUrlProvider publishedUrlProvider)
{
var result = new List <UrlInfo>();
foreach (var culture in cultures)
{
// if content is variant, and culture is not published, skip
if (content.ContentType.VariesByCulture() && !content.IsCulturePublished(culture))
{
continue;
}
// if it's variant and culture is published, or if it's invariant, proceed
string url;
try
{
url = publishedUrlProvider.GetUrl(content.Id, culture: culture);
}
catch (Exception ex)
{
logger.LogError(ex, "GetUrl exception.");
url = "#ex";
}
switch (url)
{
// deal with 'could not get the URL'
case "#":
result.Add(HandleCouldNotGetUrl(content, culture, contentService, textService));
break;
// deal with exceptions
case "#ex":
result.Add(UrlInfo.Message(textService.Localize("content", "getUrlException"), culture));
break;
// got a URL, deal with collisions, add URL
default:
// detect collisions, etc
Attempt <UrlInfo?> hasCollision = await DetectCollisionAsync(logger, content, url, culture, umbracoContext, publishedRouter, textService, variationContextAccessor, uriUtility);
if (hasCollision.Success && hasCollision.Result is not null)
{
result.Add(hasCollision.Result);
}
else
{
result.Add(UrlInfo.Url(url, culture));
}
break;
}
}
return(result);
}
IHttpController IHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
{
// default
if (!typeof(UmbracoApiControllerBase).IsAssignableFrom(controllerType))
{
return(base.Create(request, controllerDescriptor, controllerType));
}
var owinContext = request.TryGetOwinContext().Result;
var mockedUserService = Mock.Of <IUserService>();
var mockedContentService = Mock.Of <IContentService>();
var mockedMediaService = Mock.Of <IMediaService>();
var mockedEntityService = Mock.Of <IEntityService>();
var mockedMemberService = Mock.Of <IMemberService>();
var mockedMemberTypeService = Mock.Of <IMemberTypeService>();
var mockedDataTypeService = Mock.Of <IDataTypeService>();
var mockedContentTypeService = Mock.Of <IContentTypeService>();
var serviceContext = ServiceContext.CreatePartial(
userService: mockedUserService,
contentService: mockedContentService,
mediaService: mockedMediaService,
entityService: mockedEntityService,
memberService: mockedMemberService,
memberTypeService: mockedMemberTypeService,
dataTypeService: mockedDataTypeService,
contentTypeService: mockedContentTypeService,
localizedTextService: Mock.Of <ILocalizedTextService>());
var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
// FIXME: v8?
////new app context
//var dbCtx = new Mock<DatabaseContext>(Mock.Of<IDatabaseFactory>(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), "test");
////ensure these are set so that the appctx is 'Configured'
//dbCtx.Setup(x => x.CanConnect).Returns(true);
//dbCtx.Setup(x => x.IsDatabaseConfigured).Returns(true);
//var appCtx = ApplicationContext.EnsureContext(
// dbCtx.Object,
// //pass in mocked services
// serviceContext,
// CacheHelper.CreateDisabledCacheHelper(),
// new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()),
// true);
var httpContextItems = new Dictionary <string, object>
{
//add the special owin environment to the httpcontext items, this is how the GetOwinContext works
["owin.Environment"] = new Dictionary <string, object>()
};
//httpcontext with an auth'd user
var httpContext = Mock.Of <HttpContextBase>(
http => http.User == owinContext.Authentication.User
//ensure the request exists with a cookies collection
&& http.Request == Mock.Of <HttpRequestBase>(r => r.Cookies == new HttpCookieCollection() &&
r.RequestContext == new System.Web.Routing.RequestContext
{
RouteData = new System.Web.Routing.RouteData()
})
//ensure the request exists with an items collection
&& http.Items == httpContextItems);
//chuck it into the props since this is what MS does when hosted and it's needed there
request.Properties["MS_HttpContext"] = httpContext;
var backofficeIdentity = (UmbracoBackOfficeIdentity)owinContext.Authentication.User.Identity;
var webSecurity = new Mock <WebSecurity>(null, null, globalSettings);
//mock CurrentUser
var groups = new List <ReadOnlyUserGroup>();
for (var index = 0; index < backofficeIdentity.Roles.Length; index++)
{
var role = backofficeIdentity.Roles[index];
groups.Add(new ReadOnlyUserGroup(index + 1, role, "icon-user", null, null, role, new string[0], new string[0]));
}
webSecurity.Setup(x => x.CurrentUser)
.Returns(Mock.Of <IUser>(u => u.IsApproved == true &&
u.IsLockedOut == false &&
u.AllowedSections == backofficeIdentity.AllowedApplications &&
u.Groups == groups &&
u.Email == "*****@*****.**" &&
u.Id == (int)backofficeIdentity.Id &&
u.Language == "en" &&
u.Name == backofficeIdentity.RealName &&
u.StartContentIds == backofficeIdentity.StartContentNodes &&
u.StartMediaIds == backofficeIdentity.StartMediaNodes &&
u.Username == backofficeIdentity.Username));
//mock Validate
webSecurity.Setup(x => x.ValidateCurrentUser())
.Returns(() => true);
webSecurity.Setup(x => x.UserHasSectionAccess(It.IsAny <string>(), It.IsAny <IUser>()))
.Returns(() => true);
var publishedSnapshot = new Mock <IPublishedSnapshot>();
publishedSnapshot.Setup(x => x.Members).Returns(Mock.Of <IPublishedMemberCache>());
var publishedSnapshotService = new Mock <IPublishedSnapshotService>();
publishedSnapshotService.Setup(x => x.CreatePublishedSnapshot(It.IsAny <string>())).Returns(publishedSnapshot.Object);
var umbracoContextAccessor = Umbraco.Web.Composing.Current.UmbracoContextAccessor;
var umbCtx = new UmbracoContext(httpContext,
publishedSnapshotService.Object,
webSecurity.Object,
Mock.Of <IUmbracoSettingsSection>(section => section.WebRouting == Mock.Of <IWebRoutingSection>(routingSection => routingSection.UrlProviderMode == "Auto")),
Enumerable.Empty <IUrlProvider>(),
Enumerable.Empty <IMediaUrlProvider>(),
globalSettings,
new TestVariationContextAccessor());
//replace it
umbracoContextAccessor.UmbracoContext = umbCtx;
var urlHelper = new Mock <IUrlProvider>();
urlHelper.Setup(provider => provider.GetUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <UrlProviderMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns(UrlInfo.Url("/hello/world/1234"));
var membershipHelper = new MembershipHelper(umbCtx.HttpContext, Mock.Of <IPublishedMemberCache>(), Mock.Of <MembershipProvider>(), Mock.Of <RoleProvider>(), Mock.Of <IMemberService>(), Mock.Of <IMemberTypeService>(), Mock.Of <IUserService>(), Mock.Of <IPublicAccessService>(), Mock.Of <AppCaches>(), Mock.Of <ILogger>());
var umbHelper = new UmbracoHelper(Mock.Of <IPublishedContent>(),
Mock.Of <ITagQuery>(),
Mock.Of <ICultureDictionaryFactory>(),
Mock.Of <IUmbracoComponentRenderer>(),
Mock.Of <IPublishedContentQuery>(),
membershipHelper);
return(CreateController(controllerType, request, umbracoContextAccessor, umbHelper));
}
public void ParseLocalLinks(string input, string result)
{
var serviceCtxMock = new TestObjects(null).GetServiceContextMock();
//setup a mock entity service from the service context to return an integer for a GUID
var entityService = Mock.Get(serviceCtxMock.EntityService);
//entityService.Setup(x => x.GetId(It.IsAny<Guid>(), It.IsAny<UmbracoObjectTypes>()))
// .Returns((Guid id, UmbracoObjectTypes objType) =>
// {
// return Attempt.Succeed(1234);
// });
//setup a mock url provider which we'll use fo rtesting
var testUrlProvider = new Mock <IUrlProvider>();
testUrlProvider
.Setup(x => x.GetUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <UrlProviderMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns((UmbracoContext umbCtx, IPublishedContent content, UrlProviderMode mode, string culture, Uri url) => UrlInfo.Url("/my-test-url"));
var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
var contentType = new PublishedContentType(666, "alias", PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var publishedContent = Mock.Of <IPublishedContent>();
Mock.Get(publishedContent).Setup(x => x.Id).Returns(1234);
Mock.Get(publishedContent).Setup(x => x.ContentType).Returns(contentType);
var contentCache = Mock.Of <IPublishedContentCache>();
Mock.Get(contentCache).Setup(x => x.GetById(It.IsAny <int>())).Returns(publishedContent);
Mock.Get(contentCache).Setup(x => x.GetById(It.IsAny <Guid>())).Returns(publishedContent);
var snapshot = Mock.Of <IPublishedSnapshot>();
Mock.Get(snapshot).Setup(x => x.Content).Returns(contentCache);
var snapshotService = Mock.Of <IPublishedSnapshotService>();
Mock.Get(snapshotService).Setup(x => x.CreatePublishedSnapshot(It.IsAny <string>())).Returns(snapshot);
var umbracoContextFactory = new UmbracoContextFactory(
Umbraco.Web.Composing.Current.UmbracoContextAccessor,
snapshotService,
new TestVariationContextAccessor(),
new TestDefaultCultureAccessor(),
Mock.Of <IUmbracoSettingsSection>(section => section.WebRouting == Mock.Of <IWebRoutingSection>(routingSection => routingSection.UrlProviderMode == "Auto")),
globalSettings,
new UrlProviderCollection(new[] { testUrlProvider.Object }),
Mock.Of <IUserService>());
using (var reference = umbracoContextFactory.EnsureUmbracoContext(Mock.Of <HttpContextBase>()))
{
var output = TemplateUtilities.ParseInternalLinks(input, reference.UmbracoContext.UrlProvider);
Assert.AreEqual(result, output);
}
}
public void ParseLocalLinks(string input, string result)
{
//setup a mock url provider which we'll use for testing
var testUrlProvider = new Mock <IUrlProvider>();
testUrlProvider
.Setup(x => x.GetUrl(It.IsAny <UmbracoContext>(), It.IsAny <IPublishedContent>(), It.IsAny <UrlMode>(), It.IsAny <string>(), It.IsAny <Uri>()))
.Returns((UmbracoContext umbCtx, IPublishedContent content, UrlMode mode, string culture, Uri url) => UrlInfo.Url("/my-test-url"));
var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
var contentType = new PublishedContentType(666, "alias", PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing);
var publishedContent = Mock.Of <IPublishedContent>();
Mock.Get(publishedContent).Setup(x => x.Id).Returns(1234);
Mock.Get(publishedContent).Setup(x => x.ContentType).Returns(contentType);
var contentCache = Mock.Of <IPublishedContentCache>();
Mock.Get(contentCache).Setup(x => x.GetById(It.IsAny <int>())).Returns(publishedContent);
Mock.Get(contentCache).Setup(x => x.GetById(It.IsAny <Guid>())).Returns(publishedContent);
var snapshot = Mock.Of <IPublishedSnapshot>();
Mock.Get(snapshot).Setup(x => x.Content).Returns(contentCache);
var snapshotService = Mock.Of <IPublishedSnapshotService>();
Mock.Get(snapshotService).Setup(x => x.CreatePublishedSnapshot(It.IsAny <string>())).Returns(snapshot);
var media = Mock.Of <IPublishedContent>();
Mock.Get(media).Setup(x => x.Url).Returns("/media/1001/my-image.jpg");
var mediaCache = Mock.Of <IPublishedMediaCache>();
Mock.Get(mediaCache).Setup(x => x.GetById(It.IsAny <Guid>())).Returns(media);
var umbracoContextAccessor = new TestUmbracoContextAccessor();
var umbracoContextFactory = new UmbracoContextFactory(
umbracoContextAccessor,
snapshotService,
new TestVariationContextAccessor(),
new TestDefaultCultureAccessor(),
Mock.Of <IUmbracoSettingsSection>(section => section.WebRouting == Mock.Of <IWebRoutingSection>(routingSection => routingSection.UrlProviderMode == "Auto")),
globalSettings,
new UrlProviderCollection(new[] { testUrlProvider.Object }),
new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()),
Mock.Of <IUserService>());
using (var reference = umbracoContextFactory.EnsureUmbracoContext(Mock.Of <HttpContextBase>()))
{
var output = TemplateUtilities.ParseInternalLinks(input, reference.UmbracoContext.UrlProvider, mediaCache);
Assert.AreEqual(result, output);
}
}
null; // we have nothing to say
#endregion
#region GetOtherUrls
/// <summary>
/// Gets the other URLs of a published content.
/// </summary>
/// <param name="id">The published content id.</param>
/// <param name="current">The current absolute URL.</param>
/// <returns>The other URLs for the published content.</returns>
/// <remarks>
/// <para>
/// Other URLs are those that <c>GetUrl</c> would not return in the current context, but would be valid
/// URLs for the node in other contexts (different domain for current request, umbracoUrlAlias...).
/// </para>
/// </remarks>
public IEnumerable <UrlInfo> GetOtherUrls(int id, Uri current)
{
IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
IPublishedContent?node = umbracoContext.Content?.GetById(id);
if (node == null)
{
yield break;
}
if (!node.HasProperty(Constants.Conventions.Content.UrlAlias))
{
yield break;
}
// look for domains, walking up the tree
IPublishedContent? n = node;
IEnumerable <DomainAndUri>?domainUris = DomainUtilities.DomainsForNode(umbracoContext.PublishedSnapshot.Domains, _siteDomainMapper, n.Id, current, false);
// n is null at root
while (domainUris == null && n != null)
{
// move to parent node
n = n.Parent;
domainUris = n == null
? null
: DomainUtilities.DomainsForNode(umbracoContext.PublishedSnapshot.Domains, _siteDomainMapper, n.Id, current, false);
}
// determine whether the alias property varies
var varies = node.GetProperty(Constants.Conventions.Content.UrlAlias) !.PropertyType.VariesByCulture();
if (domainUris == null)
{
// no domain
// if the property is invariant, then URL "/<alias>" is ok
// if the property varies, then what are we supposed to do?
// the content finder may work, depending on the 'current' culture,
// but there's no way we can return something meaningful here
if (varies)
{
yield break;
}
var umbracoUrlName = node.Value <string>(_publishedValueFallback, Constants.Conventions.Content.UrlAlias);
var aliases = umbracoUrlName?.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries);
if (aliases == null || aliases.Any() == false)
{
yield break;
}
foreach (var alias in aliases.Distinct())
{
var path = "/" + alias;
var uri = new Uri(path, UriKind.Relative);
yield return(UrlInfo.Url(_uriUtility.UriFromUmbraco(uri, _requestConfig).ToString()));
}
}
else
{
// some domains: one URL per domain, which is "<domain>/<alias>"
foreach (DomainAndUri domainUri in domainUris)
{
// if the property is invariant, get the invariant value, URL is "<domain>/<invariant-alias>"
// if the property varies, get the variant value, URL is "<domain>/<variant-alias>"
// but! only if the culture is published, else ignore
if (varies && !node.HasCulture(domainUri.Culture))
{
continue;
}
var umbracoUrlName = varies
? node.Value <string>(_publishedValueFallback, Constants.Conventions.Content.UrlAlias, domainUri.Culture)
: node.Value <string>(_publishedValueFallback, Constants.Conventions.Content.UrlAlias);
var aliases = umbracoUrlName?.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries);
if (aliases == null || aliases.Any() == false)
{
continue;
}
foreach (var alias in aliases.Distinct())
{
var path = "/" + alias;
var uri = new Uri(CombinePaths(domainUri.Uri.GetLeftPart(UriPartial.Path), path));
yield return(UrlInfo.Url(
_uriUtility.UriFromUmbraco(uri, _requestConfig).ToString(),
domainUri.Culture));
}
}
}
}
