/// <summary> /// Generates a URL based on the current Umbraco URL with a custom query string that will route to the specified /// SurfaceController /// </summary> /// <returns></returns> public static string SurfaceAction( this IUrlHelper url, IUmbracoContext umbracoContext, IDataProtectionProvider dataProtectionProvider, string action, string controllerName) => url.SurfaceAction(umbracoContext, dataProtectionProvider, action, controllerName, null);
/// <summary> /// Outputs and caches a partial view in MVC /// </summary> /// <param name="appCaches"></param> /// <param name="hostingEnvironment"></param> /// <param name="umbracoContext"></param> /// <param name="htmlHelper"></param> /// <param name="partialViewName"></param> /// <param name="model"></param> /// <param name="cacheTimeout"></param> /// <param name="cacheKey">used to cache the partial view, this key could change if it is cached by page or by member</param> /// <param name="viewData"></param> /// <returns></returns> public static IHtmlContent CachedPartialView( this AppCaches appCaches, IHostingEnvironment hostingEnvironment, IUmbracoContext umbracoContext, IHtmlHelper htmlHelper, string partialViewName, object model, TimeSpan cacheTimeout, string cacheKey, ViewDataDictionary viewData = null ) { //disable cached partials in debug mode: http://issues.umbraco.org/issue/U4-5940 //disable cached partials in preview mode: https://github.com/umbraco/Umbraco-CMS/issues/10384 if (hostingEnvironment.IsDebugMode || (umbracoContext?.InPreviewMode == true)) { // just return a normal partial view instead return(htmlHelper.Partial(partialViewName, model, viewData)); } var result = appCaches.RuntimeCache.GetCacheItem <IHtmlContent>( CoreCacheHelperExtensions.PartialViewCacheKey + cacheKey, () => new HtmlString(htmlHelper.Partial(partialViewName, model, viewData).ToHtmlString()), timeout: cacheTimeout); return(result); }
/// <summary> /// Gets the 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, UrlMode mode = UrlMode.Default, string?culture = null, Uri?current = null) { if (content == null || content.ContentType.ItemType == PublishedItemType.Element) { return("#"); } if (mode == UrlMode.Default) { mode = Mode; } // 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) // We need to check all ancestors because urls are variant even for invariant content, if an ancestor is variant. if (culture == null && content.AncestorsOrSelf().Any(x => x.ContentType.VariesByCulture())) { culture = _variationContextAccessor?.VariationContext?.Culture ?? string.Empty; } if (current == null) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); current = umbracoContext.CleanedUmbracoUrl; } UrlInfo?url = _urlProviders.Select(provider => provider.GetUrl(content, mode, culture, current)) .FirstOrDefault(u => u is not null); return(url?.Text ?? "#"); // legacy wants this }
/// <summary> /// Generates a URL based on the current Umbraco URL with a custom query string that will route to the specified SurfaceController /// </summary> /// <param name="url"></param> /// <param name="action"></param> /// <param name="controllerName"></param> /// <param name="area"></param> /// <param name="additionalRouteVals"></param> /// <returns></returns> public static string SurfaceAction(this IUrlHelper url, IUmbracoContext umbracoContext, IDataProtectionProvider dataProtectionProvider, string action, string controllerName, string area, object?additionalRouteVals) { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (string.IsNullOrEmpty(action)) { throw new ArgumentException("Value can't be empty.", nameof(action)); } if (controllerName == null) { throw new ArgumentNullException(nameof(controllerName)); } if (string.IsNullOrEmpty(controllerName)) { throw new ArgumentException("Value can't be empty.", nameof(controllerName)); } var encryptedRoute = EncryptionHelper.CreateEncryptedRouteString(dataProtectionProvider, controllerName, action, area, additionalRouteVals); var result = umbracoContext.OriginalRequestUrl.AbsolutePath.EnsureEndsWith('?') + "ufprt=" + encryptedRoute; return(result); }
public PageService( IProfileLogger profileLogger, IUmbracoContext umbracoContext) { _profileLogger = profileLogger; _umbracoContext = umbracoContext; }
internal UrlInfo GetUrlFromRoute( string route, IUmbracoContext umbracoContext, int id, Uri current, UrlMode mode, string culture) { if (string.IsNullOrWhiteSpace(route)) { _logger.LogDebug( "Couldn't find any page with nodeId={NodeId}. 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); DomainAndUri domainUri = pos == 0 ? null : DomainUtilities.DomainForNode(umbracoContext.PublishedSnapshot.Domains, _siteDomainMapper, int.Parse(route.Substring(0, pos), CultureInfo.InvariantCulture), current, culture); var defaultCulture = _localizationService.GetDefaultLanguageIsoCode(); if (domainUri is not null || string.IsNullOrEmpty(culture) || culture.Equals(defaultCulture, StringComparison.InvariantCultureIgnoreCase)) { var url = AssembleUrl(domainUri, path, current, mode).ToString(); return(UrlInfo.Url(url, culture)); } return(null); }
private bool _readonly; // after prepared /// <summary> /// Initializes a new instance of the <see cref="PublishedRequest" /> class. /// </summary> public PublishedRequestOld(IPublishedRouter publishedRouter, IUmbracoContext umbracoContext, IOptions <WebRoutingSettings> webRoutingSettings, Uri?uri = null) { UmbracoContext = umbracoContext ?? throw new ArgumentNullException(nameof(umbracoContext)); _publishedRouter = publishedRouter ?? throw new ArgumentNullException(nameof(publishedRouter)); _webRoutingSettings = webRoutingSettings.Value; Uri = uri ?? umbracoContext.CleanedUmbracoUrl; }
/// <summary> /// Initializes a new instance of the <see cref="UmbracoContextReference"/> class. /// </summary> public UmbracoContextReference(IUmbracoContext umbracoContext, bool isRoot, IUmbracoContextAccessor umbracoContextAccessor) { IsRoot = isRoot; UmbracoContext = umbracoContext; _umbracoContextAccessor = umbracoContextAccessor; }
private static async Task <Attempt <UrlInfo?> > DetectCollisionAsync( ILogger logger, IContent content, string url, string culture, IUmbracoContext umbracoContext, IPublishedRouter publishedRouter, ILocalizedTextService textService, IVariationContextAccessor variationContextAccessor, UriUtility uriUtility) { // test for collisions on the 'main' URL var uri = new Uri(url.TrimEnd(Constants.CharArrays.ForwardSlash), UriKind.RelativeOrAbsolute); if (uri.IsAbsoluteUri == false) { uri = uri.MakeAbsolute(umbracoContext.CleanedUmbracoUrl); } uri = uriUtility.UriToUmbraco(uri); IPublishedRequestBuilder builder = await publishedRouter.CreateRequestAsync(uri); IPublishedRequest pcr = await publishedRouter.RouteRequestAsync(builder, new RouteRequestOptions(RouteDirection.Outbound)); if (!pcr.HasPublishedContent()) { const string logMsg = nameof(DetectCollisionAsync) + " did not resolve a content item for original url: {Url}, translated to {TranslatedUrl} and culture: {Culture}"; logger.LogDebug(logMsg, url, uri, culture); var urlInfo = UrlInfo.Message(textService.Localize("content", "routeErrorCannotRoute"), culture); return(Attempt.Succeed(urlInfo)); } if (pcr.IgnorePublishedContentCollisions) { return(Attempt <UrlInfo?> .Fail()); } if (pcr.PublishedContent?.Id != content.Id) { IPublishedContent?o = pcr.PublishedContent; var l = new List <string>(); while (o != null) { l.Add(o.Name(variationContextAccessor) !); o = o.Parent; } l.Reverse(); var s = "/" + string.Join("/", l) + " (id=" + pcr.PublishedContent?.Id + ")"; var urlInfo = UrlInfo.Message(textService.Localize("content", "routeError", new[] { s }), culture); return(Attempt.Succeed(urlInfo)); } // no collision return(Attempt <UrlInfo?> .Fail()); }
// TODO: I feel like we need to do more than this, pretty sure we need to replace the UmbracoRouteValues // HttpRequest feature too while this renders. private void SetNewItemsOnContextObjects(IPublishedRequest request) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); // now, set the new ones for this page execution umbracoContext.PublishedRequest = request; }
// NOT thread-safe over a request because it modifies the // global UmbracoContext.Current.InPreviewMode status. So it // should never execute in // over the same UmbracoContext with // different preview modes. private string RenderRteMacros(string source, bool preview) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); using (umbracoContext.ForcedPreview(preview)) // force for macro rendering { var sb = new StringBuilder(); MacroTagParser.ParseMacros( source, // callback for when text block is found textBlock => sb.Append(textBlock), // callback for when macro syntax is found (macroAlias, macroAttributes) => sb.Append(_macroRenderer.RenderAsync( macroAlias, umbracoContext.PublishedRequest?.PublishedContent, // needs to be explicitly casted to Dictionary<string, object> macroAttributes.ConvertTo(x => (string)x, x => x) !).GetAwaiter().GetResult().Text)); return(sb.ToString()); } }
// stores macro content into the cache private async Task AddMacroContentToCacheAsync(MacroModel model, MacroContent macroContent) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); // only if cache is enabled if (umbracoContext.InPreviewMode || model.CacheDuration <= 0) { return; } // do not cache if it should cache by member and there's not member if (model.CacheByMember) { IMemberManager?memberManager = _httpContextAccessor.HttpContext?.RequestServices.GetRequiredService <IMemberManager>(); MemberIdentityUser?member = await memberManager?.GetCurrentMemberAsync() !; if (member is null) { return; } } // remember when we cache the content macroContent.Date = DateTime.Now; IAppPolicyCache cache = _appCaches.RuntimeCache; cache.Insert( CacheKeys.MacroContentCacheKey + model.CacheIdentifier, () => macroContent, new TimeSpan(0, 0, model.CacheDuration)); _logger.LogDebug("Macro content saved to cache '{MacroCacheId}'", model.CacheIdentifier); }
public async Task Lookup_By_Url_Alias( string relativeUrl, int nodeMatch, [Frozen] IPublishedContentCache publishedContentCache, [Frozen] IUmbracoContextAccessor umbracoContextAccessor, [Frozen] IUmbracoContext umbracoContext, [Frozen] IVariationContextAccessor variationContextAccessor, IFileService fileService, ContentFinderByUrlAlias sut, IPublishedContent[] rootContents, IPublishedProperty urlProperty) { // Arrange var absoluteUrl = "http://localhost" + relativeUrl; var variationContext = new VariationContext(); var contentItem = rootContents[0]; Mock.Get(umbracoContextAccessor).Setup(x => x.TryGetUmbracoContext(out umbracoContext)).Returns(true); Mock.Get(umbracoContext).Setup(x => x.Content).Returns(publishedContentCache); Mock.Get(publishedContentCache).Setup(x => x.GetAtRoot(null)).Returns(rootContents); Mock.Get(contentItem).Setup(x => x.Id).Returns(nodeMatch); Mock.Get(contentItem).Setup(x => x.GetProperty(Constants.Conventions.Content.UrlAlias)).Returns(urlProperty); Mock.Get(urlProperty).Setup(x => x.GetValue(null, null)).Returns(relativeUrl); Mock.Get(variationContextAccessor).Setup(x => x.VariationContext).Returns(variationContext); var publishedRequestBuilder = new PublishedRequestBuilder(new Uri(absoluteUrl, UriKind.Absolute), fileService); // Act var result = await sut.TryFindContent(publishedRequestBuilder); Assert.IsTrue(result); Assert.AreEqual(publishedRequestBuilder.PublishedContent.Id, nodeMatch); }
public void Can_Lookup_Content() { var publishedSnapshot = new Mock <IPublishedSnapshot>(); publishedSnapshot.Setup(x => x.Members).Returns(Mock.Of <IPublishedMemberCache>()); var content = new Mock <IPublishedContent>(); content.Setup(x => x.Id).Returns(2); IBackOfficeSecurityAccessor backofficeSecurityAccessor = Mock.Of <IBackOfficeSecurityAccessor>(); Mock.Get(backofficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(Mock.Of <IBackOfficeSecurity>()); var publishedSnapshotService = new Mock <IPublishedSnapshotService>(); IHostingEnvironment hostingEnvironment = Mock.Of <IHostingEnvironment>(); var globalSettings = new GlobalSettings(); var umbracoContextFactory = TestUmbracoContextFactory.Create(globalSettings, _umbracoContextAccessor); UmbracoContextReference umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext(); IUmbracoContext umbracoContext = umbracoContextReference.UmbracoContext; var umbracoContextAccessor = new TestUmbracoContextAccessor(umbracoContext); IPublishedContentQuery publishedContentQuery = Mock.Of <IPublishedContentQuery>(query => query.Content(2) == content.Object); var ctrl = new TestSurfaceController(umbracoContextAccessor, publishedContentQuery, Mock.Of <IPublishedUrlProvider>()); var result = ctrl.GetContent(2) as PublishedContentResult; Assert.IsNotNull(result); Assert.IsNotNull(result.Content); Assert.AreEqual(2, result.Content.Id); }
/// <summary> /// Save all items that we know are used for rendering execution to variables so we can restore after rendering /// </summary> private void SaveExistingItems(out IPublishedRequest?oldPublishedRequest) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); // Many objects require that these legacy items are in the http context items... before we render this template we need to first // save the values in them so that we can re-set them after we render so the rest of the execution works as per normal oldPublishedRequest = umbracoContext.PublishedRequest; }
/// <summary> /// Shared with PublishMediaStoreTests /// </summary> /// <param name="id"></param> /// <param name="umbracoContext"></param> /// <returns></returns> internal IPublishedContent GetNode(int id, IUmbracoContext umbracoContext) { var cache = new PublishedMediaCache(new XmlStore((XmlDocument)null, null, null, null, HostingEnvironment), ServiceContext.MediaService, ServiceContext.UserService, new DictionaryAppCache(), ContentTypesCache, Factory.GetRequiredService <IEntityXmlSerializer>(), Factory.GetRequiredService <IUmbracoContextAccessor>(), VariationContextAccessor); var doc = cache.GetById(id); Assert.IsNotNull(doc); return(doc); }
public string GetUrlFromRoute(int id, string?route, string?culture) { IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); DefaultUrlProvider?provider = _urlProviders.OfType <DefaultUrlProvider>().FirstOrDefault(); var url = provider == null ? route // what else? : provider.GetUrlFromRoute(route, umbracoContext, id, umbracoContext.CleanedUmbracoUrl, Mode, culture)?.Text; return(url ?? "#"); }
/// <summary> /// Gets the culture assigned to a document by domains, in the context of a current Uri. /// </summary> /// <param name="content">The document.</param> /// <param name="umbracoContextAccessor"></param> /// <param name="siteDomainHelper"></param> /// <param name="current">An optional current Uri.</param> /// <returns>The culture assigned to the document by domains.</returns> /// <remarks> /// <para> /// In 1:1 multilingual setup, a document contains several cultures (there is not /// one document per culture), and domains, withing the context of a current Uri, assign /// a culture to that document. /// </para> /// </remarks> public static string?GetCultureFromDomains( this IPublishedContent content, IUmbracoContextAccessor umbracoContextAccessor, ISiteDomainMapper siteDomainHelper, Uri?current = null) { IUmbracoContext umbracoContext = umbracoContextAccessor.GetRequiredUmbracoContext(); return(DomainUtilities.GetCultureFromDomains(content.Id, content.Path, current, umbracoContext, siteDomainHelper)); }
private IPublishedUrlProvider GetPublishedUrlProvider(IUmbracoContext umbracoContext, DefaultUrlProvider urlProvider) { var webRoutingSettings = new WebRoutingSettings(); return(new UrlProvider( new TestUmbracoContextAccessor(umbracoContext), Options.Create(webRoutingSettings), new UrlProviderCollection(() => new[] { urlProvider }), new MediaUrlProviderCollection(() => Enumerable.Empty <IMediaUrlProvider>()), Mock.Of <IVariationContextAccessor>())); }
private IPublishedUrlProvider GetPublishedUrlProvider(IUmbracoContext umbracoContext) { var webRoutingSettings = new WebRoutingSettings(); return(new UrlProvider( new TestUmbracoContextAccessor(umbracoContext), Microsoft.Extensions.Options.Options.Create(webRoutingSettings), new UrlProviderCollection(Enumerable.Empty <IUrlProvider>()), new MediaUrlProviderCollection(new [] { _mediaUrlProvider }), Mock.Of <IVariationContextAccessor>() )); }
/// <inheritdoc /> public UmbracoContextReference EnsureUmbracoContext() { if (_umbracoContextAccessor.TryGetUmbracoContext(out var umbracoContext)) { return(new UmbracoContextReference(umbracoContext, false, _umbracoContextAccessor)); } IUmbracoContext createdUmbracoContext = CreateUmbracoContext(); _umbracoContextAccessor.Set(createdUmbracoContext); return(new UmbracoContextReference(createdUmbracoContext, true, _umbracoContextAccessor)); }
private async Task <IActionResult> GetMacroResultAsHtml(string?macroAlias, int pageId, IDictionary <string, object>?macroParams) { IMacro?m = macroAlias is null ? null : _macroService.GetByAlias(macroAlias); if (m == null) { return(NotFound()); } IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); IPublishedContent?publishedContent = umbracoContext.Content?.GetById(true, pageId); //if it isn't supposed to be rendered in the editor then return an empty string //currently we cannot render a macro if the page doesn't yet exist if (pageId == -1 || publishedContent == null || m.DontRender) { //need to create a specific content result formatted as HTML since this controller has been configured //with only json formatters. return(Content(string.Empty, "text/html", Encoding.UTF8)); } // When rendering the macro in the backoffice the default setting would be to use the Culture of the logged in user. // Since a Macro might contain thing thats related to the culture of the "IPublishedContent" (ie Dictionary keys) we want // to set the current culture to the culture related to the content item. This is hacky but it works. // fixme // in a 1:1 situation we do not handle the language being edited // so the macro renders in the wrong language var culture = DomainUtilities.GetCultureFromDomains(publishedContent.Id, publishedContent.Path, null, umbracoContext, _siteDomainHelper); if (culture != null) { Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(culture); } // must have an active variation context! _variationContextAccessor.VariationContext = new VariationContext(culture); using (umbracoContext.ForcedPreview(true)) { //need to create a specific content result formatted as HTML since this controller has been configured //with only json formatters. return(Content( (await _componentRenderer.RenderMacroForContent(publishedContent, m.Alias, macroParams)).ToString() ?? string.Empty, "text/html", Encoding.UTF8)); } }
private IUmbracoContext GetUmbracoContext(bool hasContent) { IPublishedContentCache publishedContent = Mock.Of <IPublishedContentCache>(x => x.HasContent() == hasContent); var uri = new Uri("http://example.com"); IUmbracoContext umbracoContext = Mock.Of <IUmbracoContext>(x => x.Content == publishedContent && x.OriginalRequestUrl == uri && x.CleanedUmbracoUrl == uri); return(umbracoContext); }
/// <inheritdoc /> public virtual UrlInfo GetUrl(IPublishedContent content, UrlMode mode, string culture, Uri current) { if (!current.IsAbsoluteUri) { throw new ArgumentException("Current URL must be absolute.", nameof(current)); } IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); // will not use cache if previewing var route = umbracoContext.Content.GetRouteById(content.Id, culture); return(GetUrlFromRoute(route, umbracoContext, content.Id, current, mode, culture)); }
public async Task NoContentController_Values_When_No_Content() { IUmbracoContext umbracoContext = GetUmbracoContext(false); UmbracoRouteValueTransformer transformer = GetTransformerWithRunState( Mock.Of <IUmbracoContextAccessor>(x => x.TryGetUmbracoContext(out umbracoContext))); RouteValueDictionary result = await transformer.TransformAsync(new DefaultHttpContext(), new RouteValueDictionary()); Assert.AreEqual(2, result.Count); Assert.AreEqual(ControllerExtensions.GetControllerName <RenderNoContentController>(), result[ControllerToken]); Assert.AreEqual(nameof(RenderNoContentController.Index), result[ActionToken]); }
/// <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); while (domainUris == null && n != null) // n is null at root { 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)); } }
/// <summary> /// Generates a URL based on the current Umbraco URL with a custom query string that will route to the specified /// SurfaceController /// </summary> /// <returns></returns> public static string SurfaceAction( this IUrlHelper url, IUmbracoContext umbracoContext, IDataProtectionProvider dataProtectionProvider, string action, string controllerName, object?additionalRouteVals) => url.SurfaceAction( umbracoContext, dataProtectionProvider, action, controllerName, string.Empty, additionalRouteVals);
public async Task Assigns_PublishedRequest_To_UmbracoContext() { IUmbracoContext umbracoContext = GetUmbracoContext(true); IPublishedRequest request = Mock.Of <IPublishedRequest>(); UmbracoRouteValueTransformer transformer = GetTransformerWithRunState( Mock.Of <IUmbracoContextAccessor>(x => x.TryGetUmbracoContext(out umbracoContext)), router: GetRouter(request), routeValuesFactory: GetRouteValuesFactory(request)); RouteValueDictionary result = await transformer.TransformAsync(new DefaultHttpContext(), new RouteValueDictionary()); Assert.AreEqual(request, umbracoContext.PublishedRequest); }
public async Task Returns_Null_RouteValueDictionary_When_No_Content() { IUmbracoContext umbracoContext = GetUmbracoContext(true); IPublishedRequest request = Mock.Of <IPublishedRequest>(x => x.PublishedContent == null); UmbracoRouteValues routeValues = GetRouteValues(request); UmbracoRouteValueTransformer transformer = GetTransformerWithRunState( Mock.Of <IUmbracoContextAccessor>(x => x.TryGetUmbracoContext(out umbracoContext)), router: GetRouter(request), routeValuesFactory: GetRouteValuesFactory(request)); RouteValueDictionary result = await transformer.TransformAsync(new DefaultHttpContext(), new RouteValueDictionary()); Assert.IsNull(result); }
public async Task Assigns_Values_To_RouteValueDictionary_When_Content() { IUmbracoContext umbracoContext = GetUmbracoContext(true); IPublishedRequest request = Mock.Of <IPublishedRequest>(x => x.PublishedContent == Mock.Of <IPublishedContent>()); UmbracoRouteValues routeValues = GetRouteValues(request); UmbracoRouteValueTransformer transformer = GetTransformerWithRunState( Mock.Of <IUmbracoContextAccessor>(x => x.TryGetUmbracoContext(out umbracoContext)), router: GetRouter(request), routeValuesFactory: GetRouteValuesFactory(request)); RouteValueDictionary result = await transformer.TransformAsync(new DefaultHttpContext(), new RouteValueDictionary()); Assert.AreEqual(routeValues.ControllerName, result[ControllerToken]); Assert.AreEqual(routeValues.ActionName, result[ActionToken]); }
public GlassRenderMvcController(IUmbracoContext umbracoContext) { UmbracoContext = umbracoContext; }