private string ActivateAndRenderTemplate(IRazorTemplateBase obj, DisplayContext displayContext, string templateVirtualPath, object model) { var buffer = new StringBuilder(1024); using (var writer = new StringWriter(buffer)) { using (var htmlWriter = new HtmlTextWriter(writer)) { if (displayContext != null && displayContext.ViewContext.Controller != null) { var shapeViewContext = new ViewContext( displayContext.ViewContext.Controller.ControllerContext, displayContext.ViewContext.View, displayContext.ViewContext.ViewData, displayContext.ViewContext.TempData, htmlWriter ); obj.WebPageContext = new WebPageContext(displayContext.ViewContext.HttpContext, obj as WebPageRenderingBase, model); obj.ViewContext = shapeViewContext; obj.ViewData = new ViewDataDictionary(displayContext.ViewDataContainer.ViewData) {Model = model}; obj.InitHelpers(); } else { obj.ViewData = new ViewDataDictionary(model); obj.WebPageContext = new WebPageContext(_httpContextBase, obj as WebPageRenderingBase, model); } obj.VirtualPath = templateVirtualPath ?? "~/Themes/Orchard.Templates"; obj.Render(htmlWriter); } } return buffer.ToString(); }
public string Process(string template, string name, DisplayContext context = null, dynamic model = null) { try { var renderingContext = new TemplateRenderingContext { TemplateType = TemplateType.TemplateContentItem, TemplatePath = name }; return _templateService.ExecuteTemplate(template, model, renderingContext); } catch (Exception ex) { if (ex.IsFatal()) throw; Logger.Error(ex, "An unexpected exception was caught during rendering the \"" + name + "\" Liquid template."); var reportActivityName = T("Liquid template errors: {0} shape", name).Text; var liquidReport = _reportsManager .GetReports().FirstOrDefault(report => report.ActivityName == reportActivityName); var liquidReportId = liquidReport == null ? _reportsManager .CreateReport( T("Errors caught in the Liquid template of the {0} shape.", name).Text, reportActivityName) : liquidReport.ReportId; _reportsManager.Add(liquidReportId, ReportEntryType.Error, ex.Message); return T("<strong style=\"color:red;font-weight:bold;\">An unexpected exception was caught during rendering \"{0}\" Liquid template. {1}</strong>", name, ex.Message).Text; } }
public object ShapeExecute(object shape) { if (shape == null) { return new HtmlString(string.Empty); } var context = new DisplayContext { Display = this, Value = shape, ViewContext = ViewContext, ViewDataContainer = ViewDataContainer }; return _displayManager.Execute(context); }
public override string Process(string template, string name, DisplayContext context = null, dynamic model = null) { if (String.IsNullOrEmpty(template)) return string.Empty; var compiledTemplate = _compiler.CompileRazor(template, name, new Dictionary<string, object>()); var result = ActivateAndRenderTemplate(compiledTemplate, context, null, model); return result; }
static IHtmlString Process(ShapeBinding shapeBinding, IShape shape, DisplayContext context) { if (shapeBinding == null || shapeBinding.Binding == null) { // todo: create result from all child shapes return(shape.Metadata.ChildContent ?? new HtmlString("")); } return(CoerceHtmlString(shapeBinding.Binding(context))); }
private IHtmlString PerformInvoke(DisplayContext displayContext, MethodInfo methodInfo, object serviceInstance) { var output = new HtmlStringWriter(); var arguments = methodInfo.GetParameters() .Select(parameter => BindParameter(displayContext, parameter, output)); var returnValue = methodInfo.Invoke(serviceInstance, arguments.ToArray()); if (methodInfo.ReturnType != typeof(void)) { output.Write(CoerceHtmlString(returnValue)); } return output; }
public IHtmlString ShapeExecute(object shape) { if (shape == null) { return(new HtmlString(string.Empty)); } var context = new DisplayContext { Display = this, Value = shape, ViewContext = ViewContext, ViewDataContainer = ViewDataContainer }; return(_displayManager.Execute(context)); }
public async Task <IHtmlContent> ShapeExecuteAsync(object shape) { if (shape == null) { return(new HtmlString(string.Empty)); } var context = new DisplayContext { Display = this, Value = shape, ViewContext = ViewContext }; return(await _displayManager.ExecuteAsync(context)); }
//https://core.trac.wordpress.org/browser/tags/3.8.1/src/wp-includes/shortcodes.php public string ProcessContent(string text, string flavor) { //dynamic foo = factory.Create("Foo", ArgsUtility.Named(new { one = 1, two = "dos" })); var args = new RouteValueDictionary(new Dictionary<string, object>{}); var shape = _shapeFactory.Create("ShortCodeName", Arguments.FromT(args.Values, args.Keys)); var context = new DisplayContext { Value = shape, ViewContext = new ViewContext() }; var shortCodeText = _displayManager.Execute(context); }
private Task<IHtmlContent> PerformInvokeAsync(DisplayContext displayContext, MethodInfo methodInfo, object serviceInstance) { var parameters = _parameters.GetOrAdd(methodInfo, m => m.GetParameters()); var arguments = parameters.Select(parameter => BindParameter(displayContext, parameter)); // Resolve the service the method is declared on var returnValue = methodInfo.Invoke(serviceInstance, arguments.ToArray()); // If the shape returns a value, write it to the stream if (methodInfo.ReturnType != typeof(void)) { return Task.FromResult(CoerceHtmlContent(returnValue)); } return Task.FromResult<IHtmlContent>(null); }
private string ActivateAndRenderTemplate(IRazorTemplateBase obj, DisplayContext displayContext, string templateVirtualPath, object model) { var buffer = new StringBuilder(1024); using (var writer = new StringWriter(buffer)) { using (var htmlWriter = new HtmlTextWriter(writer)) { if (displayContext != null && displayContext.ViewContext.Controller != null) { var shapeViewContext = new ViewContext( displayContext.ViewContext.Controller.ControllerContext, displayContext.ViewContext.View, displayContext.ViewContext.ViewData, displayContext.ViewContext.TempData, htmlWriter ); obj.WebPageContext = new WebPageContext(displayContext.ViewContext.HttpContext, obj as WebPageRenderingBase, model); obj.ViewContext = shapeViewContext; obj.ViewData = new ViewDataDictionary(displayContext.ViewDataContainer.ViewData) { Model = model }; obj.InitHelpers(); } else { // Setup a fake view context in order to support razor syntax inside of HTML attributes, // for instance: <a href="@WorkContext.CurrentSite.BaseUrl">Homepage</a>. var viewData = new ViewDataDictionary(model); var httpContext = _wca.GetContext().HttpContext; obj.ViewContext = new ViewContext( new ControllerContext( httpContext.Request.RequestContext, new StubController()), new StubView(), viewData, new TempDataDictionary(), htmlWriter); obj.ViewData = viewData; obj.WebPageContext = new WebPageContext(httpContext, obj as WebPageRenderingBase, model); obj.WorkContext = _wca.GetContext(); } obj.VirtualPath = templateVirtualPath ?? "~/Themes/Orchard.Templates"; obj.Render(htmlWriter); } } return buffer.ToString(); }
public Task <IHtmlContent> ShapeExecuteAsync(object shape) { if (shape == null) { return(Task.FromResult <IHtmlContent>(HtmlString.Empty)); } var context = new DisplayContext { DisplayAsync = this, Value = shape, ViewContext = ViewContext, ServiceProvider = _serviceProvider }; return(_displayManager.ExecuteAsync(context)); }
private object BindParameter(DisplayContext displayContext, ParameterInfo parameter, TextWriter output) { if (parameter.Name == "Shape") return displayContext.Value; if (parameter.Name == "Display") return displayContext.Display; if (parameter.Name == "Output" && parameter.ParameterType == typeof(TextWriter)) return output; if (parameter.Name == "Output" && parameter.ParameterType == typeof(Action<object>)) return new Action<object>(output.Write); // meh-- if (parameter.Name == "Html") { return new HtmlHelper( displayContext.ViewContext, displayContext.ViewDataContainer, _routeCollection); } if (parameter.Name == "Url" && parameter.ParameterType.IsAssignableFrom(typeof(UrlHelper))) { return new UrlHelper(displayContext.ViewContext.RequestContext, _routeCollection); } var getter = _getters.GetOrAdd(parameter.Name, n => CallSite<Func<CallSite, object, dynamic>>.Create( Microsoft.CSharp.RuntimeBinder.Binder.GetMember( CSharpBinderFlags.None, n, null, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }))); var result = getter.Target(getter, displayContext.Value); if (result == null) return null; var converter = _converters.GetOrAdd(parameter.ParameterType, CompileConverter); var argument = converter.Invoke(result); return argument; }
public new IHtmlString Execute(DisplayContext context) { ContentPart part; var shape = ((dynamic)context.Value); try { part = (ContentPart)shape.ContentPart; } catch (Exception ex) { //this means that this is not a content part being displayed return base.Execute(context); } if (part == null) { return base.Execute(context); } return _outputCachedPartsService.BuildAndCacheOutput(() => base.Execute(context), part); }
private async Task<IHtmlContent> RenderAsync(ShapeDescriptor shapeDescriptor, DisplayContext displayContext, HarvestShapeInfo harvestShapeInfo, HarvestShapeHit harvestShapeHit) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); } IHtmlContent result; if (displayContext.ViewContext.View != null) { var htmlHelper = MakeHtmlHelper(displayContext.ViewContext, displayContext.ViewContext.ViewData); result = htmlHelper.Partial(harvestShapeInfo.TemplateVirtualPath, displayContext.Value); } else { // If the View is null, it means that the shape is being executed from a non-view origin / where no ViewContext was established by the view engine, but manually. // Manually creating a ViewContext works when working with Shape methods, but not when the shape is implemented as a Razor view template. // Horrible, but it will have to do for now. result = await RenderRazorViewAsync(harvestShapeInfo.TemplateVirtualPath, displayContext); } if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Done rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); } return result; }
static IHtmlString Process(ShapeBinding shapeBinding, IShape shape, DisplayContext context) { if (shapeBinding == null || shapeBinding.Binding == null) { // todo: create result from all child shapes return shape.Metadata.ChildContent ?? new HtmlString(""); } return CoerceHtmlString(shapeBinding.Binding(context)); }
private bool TryGetDescriptorBinding(string shapeType, IEnumerable<string> shapeAlternates, ShapeTable shapeTable, DisplayContext displayContext, out ShapeBinding shapeBinding) { // shape alternates are optional, fully qualified binding names // the earliest added alternates have the lowest priority // the descriptor returned is based on the binding that is matched, so it may be an entirely // different descriptor if the alternate has a different base name foreach (var shapeAlternate in shapeAlternates.Reverse()) { foreach (var shapeBindingResolver in _shapeBindingResolvers) { if (shapeBindingResolver.TryGetDescriptorBinding(shapeAlternate, out shapeBinding)) { return true; } } if (shapeTable.Bindings.TryGetValue(string.Concat(displayContext.BindingType, "|", shapeAlternate), out shapeBinding)) { return true; } } // when no alternates match, the shapeType is used to find the longest matching binding // the shapetype name can break itself into shorter fallbacks at double-underscore marks // so the shapetype itself may contain a longer alternate forms that falls back to a shorter one var shapeTypeScan = shapeType; for (; ; ) { foreach (var shapeBindingResolver in _shapeBindingResolvers) { if (shapeBindingResolver.TryGetDescriptorBinding(shapeTypeScan, out shapeBinding)) { return true; } } if (shapeTable.Bindings.TryGetValue(string.Concat(displayContext.BindingType, "|", shapeTypeScan), out shapeBinding)) { return true; } var delimiterIndex = shapeTypeScan.LastIndexOf("__"); if (delimiterIndex < 0) { shapeBinding = null; return false; } shapeTypeScan = shapeTypeScan.Substring(0, delimiterIndex); } }
static async Task <IHtmlContent> ProcessAsync(ShapeBinding shapeBinding, IShape shape, DisplayContext context) { if (shapeBinding == null || shapeBinding.BindingAsync == null) { // todo: create result from all child shapes return(shape.Metadata.ChildContent ?? HtmlString.Empty); } return(CoerceHtmlString(await shapeBinding.BindingAsync(context))); }
private IHtmlString Render(ShapeDescriptor shapeDescriptor, DisplayContext displayContext, HarvestShapeInfo harvestShapeInfo, HarvestShapeHit harvestShapeHit) { Logger.Information("Rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); var htmlHelper = new HtmlHelper(displayContext.ViewContext, displayContext.ViewDataContainer); var result = htmlHelper.Partial(harvestShapeInfo.TemplateVirtualPath, displayContext.Value); Logger.Information("Done rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); return result; }
private IHtmlString RenderRazorViewToString(string path, DisplayContext context) { using (var sw = new StringWriter()) { var controllerContext = CreateControllerContext(); var viewResult = _viewEngine.Value.FindPartialView(controllerContext, path, false); context.ViewContext.ViewData = new ViewDataDictionary(context.Value); context.ViewContext.TempData = new TempDataDictionary(); viewResult.View.Render(context.ViewContext, sw); viewResult.ViewEngine.ReleaseView(controllerContext, viewResult.View); return new HtmlString(sw.GetStringBuilder().ToString()); } }
private IHtmlString Render(ShapeDescriptor shapeDescriptor, DisplayContext displayContext, HarvestShapeInfo harvestShapeInfo, HarvestShapeHit harvestShapeHit) { Logger.Information("Rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); IHtmlString result; if (displayContext.ViewContext.View != null) { var htmlHelper = new HtmlHelper(displayContext.ViewContext, displayContext.ViewDataContainer); result = htmlHelper.Partial(harvestShapeInfo.TemplateVirtualPath, displayContext.Value); } else { // If the View is null, it means that the shape is being executed from a non-view origin / where no ViewContext was established by the view engine, but manually. // Manually creating a ViewContext works when working with Shape methods, but not when the shape is implemented as a Razor view template. // Horrible, but it will have to do for now. result = RenderRazorViewToString(harvestShapeInfo.TemplateVirtualPath, displayContext); } Logger.Information("Done rendering template file '{0}'", harvestShapeInfo.TemplateVirtualPath); return result; }
public object ShapeExecute(object shape) { var context = new DisplayContext { Display = this, Value = shape, ViewContext = ViewContext, ViewDataContainer = ViewDataContainer }; return _displayManager.Execute(context); }
private object BindParameter(DisplayContext displayContext, ParameterInfo parameter, TextWriter output) { if (String.Equals(parameter.Name, "Shape", StringComparison.OrdinalIgnoreCase)) { return displayContext.Value; } if (String.Equals(parameter.Name, "Display", StringComparison.OrdinalIgnoreCase)) { return displayContext.Display; } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(TextWriter)) { return output; } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(Action<object>)) { return new Action<object>(output.Write); } if (String.Equals(parameter.Name, "Html", StringComparison.OrdinalIgnoreCase)) { return MakeHtmlHelper(displayContext.ViewContext, displayContext.ViewContext.ViewData); } if (String.Equals(parameter.Name, "Url", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType.IsAssignableFrom(typeof(UrlHelper))) { return _componentContext.GetService<IUrlHelper>(); } var getter = _getters.GetOrAdd(parameter.Name.ToLowerInvariant(), n => CallSite<Func<CallSite, object, dynamic>>.Create( Binder.GetMember( CSharpBinderFlags.None, n, null, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }))); var result = getter.Target(getter, displayContext.Value); if (result == null) return null; //var converter = _converters.GetOrAdd(parameter.ParameterType, CompileConverter); //var argument = converter.Invoke(result); //return argument; return Convert.ChangeType(result, parameter.ParameterType); }
private async Task<IHtmlContent> RenderRazorViewAsync(string path, DisplayContext context) { var viewEngineResult = _viewEngine.Value.ViewEngines.First().FindView(context.ViewContext, path, isMainPage: false); if (viewEngineResult.Success) { var bufferScope = context.ViewContext.HttpContext.RequestServices.GetRequiredService<IViewBufferScope>(); var viewBuffer = new ViewBuffer(bufferScope, viewEngineResult.ViewName, ViewBuffer.PartialViewPageSize); using (var writer = new ViewBufferTextWriter(viewBuffer, context.ViewContext.Writer.Encoding)) { // Forcing synchronous behavior so users don't have to await templates. var view = viewEngineResult.View; using (view as IDisposable) { var viewContext = new ViewContext(context.ViewContext, viewEngineResult.View, context.ViewContext.ViewData, writer); await viewEngineResult.View.RenderAsync(viewContext); return viewBuffer; } } } return null; }
private IHtmlContent PerformInvoke(DisplayContext displayContext, MethodInfo methodInfo, object serviceInstance) { using (var output = new StringCollectionTextWriter(System.Text.Encoding.UTF8)) { var arguments = methodInfo .GetParameters() .Select(parameter => BindParameter(displayContext, parameter, output)); // Resolve the service the method is declared on var returnValue = methodInfo.Invoke(serviceInstance, arguments.ToArray()); // If the shape returns a value, write it to the stream if (methodInfo.ReturnType != typeof(void)) { output.Write(CoerceHtmlString(returnValue)); } return output.Content; } }
private async Task<IHtmlContent> RenderRazorViewAsync(string path, DisplayContext context) { var viewEngineResult = _viewEngine.Value.ViewEngines.First().FindPartialView(_actionContextAccessor.ActionContext, path); if (viewEngineResult.Success) { using (var writer = new StringCollectionTextWriter(context.ViewContext.Writer.Encoding)) { // Forcing synchronous behavior so users don't have to await templates. var view = viewEngineResult.View; using (view as IDisposable) { var viewContext = new ViewContext(context.ViewContext, viewEngineResult.View, context.ViewContext.ViewData, writer); await viewEngineResult.View.RenderAsync(viewContext); return writer.Content; } } } return null; }
static async Task<IHtmlContent> ProcessAsync(ShapeBinding shapeBinding, IShape shape, DisplayContext context) { if (shapeBinding == null || shapeBinding.BindingAsync == null) { // todo: create result from all child shapes return shape.Metadata.ChildContent ?? HtmlString.Empty; } return CoerceHtmlString(await shapeBinding.BindingAsync(context)); }
private object BindParameter(DisplayContext displayContext, ParameterInfo parameter) { if (String.Equals(parameter.Name, "Shape", StringComparison.OrdinalIgnoreCase)) { return displayContext.Value; } if (String.Equals(parameter.Name, "Display", StringComparison.OrdinalIgnoreCase)) { return displayContext.Display; } if (String.Equals(parameter.Name, "New", StringComparison.OrdinalIgnoreCase)) { var httpContext = _httpContextAccessor.HttpContext; return httpContext.RequestServices.GetService<IShapeFactory>(); } if (String.Equals(parameter.Name, "Html", StringComparison.OrdinalIgnoreCase)) { return MakeHtmlHelper(displayContext.ViewContext, displayContext.ViewContext.ViewData); } if (String.Equals(parameter.Name, "Url", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType.IsAssignableFrom(typeof(UrlHelper))) { var httpContext = _httpContextAccessor.HttpContext; var urlHelperFactory = httpContext.RequestServices.GetService<IUrlHelperFactory>(); return urlHelperFactory.GetUrlHelper(displayContext.ViewContext); } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(TextWriter)) { throw new InvalidOperationException("Output is no more a valid Shape method parameter. Return an IHtmlContent instead."); } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(Action<object>)) { throw new InvalidOperationException("Output is no more a valid Shape method parameter. Return an IHtmlContent instead."); } var getter = _getters.GetOrAdd(parameter.Name, n => CallSite<Func<CallSite, object, dynamic>>.Create( Binder.GetMember( CSharpBinderFlags.None, n, null, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }))); object result = getter.Target(getter, displayContext.Value); if (result == null) return null; if(parameter.ParameterType.IsAssignableFrom(result.GetType())) { return result; } return Convert.ChangeType(result, parameter.ParameterType); }
public async Task<IHtmlContent> ShapeExecuteAsync(object shape) { if (shape == null) { return new HtmlString(string.Empty); } var context = new DisplayContext { Display = this, Value = shape, ViewContext = ViewContext }; return await _displayManager.ExecuteAsync(context); }
private object BindParameter(DisplayContext displayContext, ParameterInfo parameter) { if (String.Equals(parameter.Name, "Shape", StringComparison.OrdinalIgnoreCase)) { return displayContext.Value; } if (String.Equals(parameter.Name, "Display", StringComparison.OrdinalIgnoreCase)) { return displayContext.Display; } if (String.Equals(parameter.Name, "Html", StringComparison.OrdinalIgnoreCase)) { return MakeHtmlHelper(displayContext.ViewContext, displayContext.ViewContext.ViewData); } if (String.Equals(parameter.Name, "Url", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType.IsAssignableFrom(typeof(UrlHelper))) { return _componentContext.GetService<IUrlHelper>(); } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(TextWriter)) { throw new InvalidOperationException("Output is no more a valid Shape method parameter"); } if (String.Equals(parameter.Name, "Output", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(Action<object>)) { throw new InvalidOperationException("Output is no more a valid Shape method parameter"); } var getter = _getters.GetOrAdd(parameter.Name, n => CallSite<Func<CallSite, object, dynamic>>.Create( Binder.GetMember( CSharpBinderFlags.None, n, null, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }))); var result = getter.Target(getter, displayContext.Value); if (result == null) return null; return Convert.ChangeType(result, parameter.ParameterType); }
public async Task <IHtmlContent> ExecuteAsync(DisplayContext context) { var shape = context.Value as IShape; // non-shape arguments are returned as a no-op if (shape == null) { return(CoerceHtmlString(context.Value)); } var shapeMetadata = shape.Metadata; // can't really cope with a shape that has no type information if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type)) { return(CoerceHtmlString(context.Value)); } var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id); var displayingContext = new ShapeDisplayingContext { Shape = shape, ShapeMetadata = shapeMetadata, DisplayContext = context }; // Evaluate global Shape Display Events _shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), _logger); // Find base shape association using only the fundamental shape type. // Alternates that may already be registered do not affect the "displaying" event calls. ShapeBinding shapeBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty <string>(), shapeTable, out shapeBinding)) { shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), _logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayingContext), _logger); // use pre-fectched content if available (e.g. coming from specific cache implementation) if (displayingContext.ChildContent != null) { shape.Metadata.ChildContent = displayingContext.ChildContent; } else { // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding)) { shapeBinding.ShapeDescriptor.Processing.Invoke(action => action(displayingContext), _logger); // invoking ShapeMetadata processing events await shapeMetadata.Processing.InvokeAsync(processing => processing(shape), _logger); shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, context); } else { throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type)); } } foreach (var frameType in shape.Metadata.Wrappers) { ShapeBinding frameBinding; if (TryGetDescriptorBinding(frameType, Enumerable.Empty <string>(), shapeTable, out frameBinding)) { shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, context); } } var displayedContext = new ShapeDisplayedContext { Shape = shape, ShapeMetadata = shape.Metadata, ChildContent = shape.Metadata.ChildContent, DisplayContext = context }; _shapeDisplayEvents.Invoke(sde => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; sde.Displayed(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) { displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; } }, _logger); if (shapeBinding != null) { shapeBinding.ShapeDescriptor.Displayed.Invoke(action => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; action(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) { displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; } }, _logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke(action => action(displayedContext), _logger); return(shape.Metadata.ChildContent); }
public async Task <IHtmlContent> ExecuteAsync(DisplayContext context) { var shape = context.Value as IShape; // non-shape arguments are returned as a no-op if (shape == null) { return(CoerceHtmlString(context.Value)); } var shapeMetadata = shape.Metadata; // can't really cope with a shape that has no type information if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type)) { return(CoerceHtmlString(context.Value)); } var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id); var displayContext = new ShapeDisplayContext { Shape = shape, ShapeMetadata = shapeMetadata, DisplayContext = context, ServiceProvider = _serviceProvider }; // Use the same prefix as the shape var originalHtmlFieldPrefix = context.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix; context.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = shapeMetadata.Prefix ?? ""; // Evaluate global Shape Display Events _shapeDisplayEvents.Invoke(sde => sde.Displaying(displayContext), _logger); // Find base shape association using only the fundamental shape type. // Alternates that may already be registered do not affect the "displaying" event calls. ShapeBinding shapeBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty <string>(), shapeTable, out shapeBinding)) { shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayContext), _logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayContext), _logger); // use pre-fectched content if available (e.g. coming from specific cache implementation) if (displayContext.ChildContent != null) { shape.Metadata.ChildContent = displayContext.ChildContent; } if (shape.Metadata.ChildContent == null) { // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding)) { // There might be no shape binding for the main shape, and only for its alternates. if (shapeBinding != null) { await shapeBinding.ShapeDescriptor.ProcessingAsync.InvokeAsync(action => action(displayContext), _logger); } // invoking ShapeMetadata processing events, this includes the Drivers results await shapeMetadata.ProcessingAsync.InvokeAsync(processing => processing(displayContext.Shape), _logger); shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, context); } else { throw new Exception($"Shape type '{shapeMetadata.Type}' not found"); } } // Process wrappers if (shape.Metadata.Wrappers.Count > 0) { foreach (var frameType in shape.Metadata.Wrappers) { ShapeBinding frameBinding; if (TryGetDescriptorBinding(frameType, Enumerable.Empty <string>(), shapeTable, out frameBinding)) { shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, context); } } // Clear wrappers to prevent the child content from rendering them again shape.Metadata.Wrappers.Clear(); } _shapeDisplayEvents.Invoke(sde => { var prior = displayContext.ChildContent = displayContext.ShapeMetadata.ChildContent; sde.Displayed(displayContext); // update the child content if the context variable has been reassigned if (prior != displayContext.ChildContent) { displayContext.ShapeMetadata.ChildContent = displayContext.ChildContent; } }, _logger); if (shapeBinding != null) { shapeBinding.ShapeDescriptor.Displayed.Invoke(action => { var prior = displayContext.ChildContent = displayContext.ShapeMetadata.ChildContent; action(displayContext); // update the child content if the context variable has been reassigned if (prior != displayContext.ChildContent) { displayContext.ShapeMetadata.ChildContent = displayContext.ChildContent; } }, _logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke(action => action(displayContext), _logger); //restore original HtmlFieldPrefix context.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = originalHtmlFieldPrefix; return(shape.Metadata.ChildContent); }
public string Process(string template, string name, DisplayContext context = null, dynamic model = null) { return _templateService.ExecuteTemplate(template, model); }
public async Task<IHtmlContent> ExecuteAsync(DisplayContext context) { var shape = context.Value as IShape; // non-shape arguments are returned as a no-op if (shape == null) return CoerceHtmlString(context.Value); var shapeMetadata = shape.Metadata; // can't really cope with a shape that has no type information if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type)) return CoerceHtmlString(context.Value); var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id); var displayingContext = new ShapeDisplayingContext { Shape = shape, ShapeMetadata = shapeMetadata, DisplayContext = context }; // Evaluate global Shape Display Events _shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), _logger); // Find base shape association using only the fundamental shape type. // Alternates that may already be registered do not affect the "displaying" event calls. ShapeBinding shapeBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty<string>(), shapeTable, out shapeBinding)) { shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), _logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayingContext), _logger); // use pre-fectched content if available (e.g. coming from specific cache implementation) if (displayingContext.ChildContent != null) { shape.Metadata.ChildContent = displayingContext.ChildContent; } else { // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding)) { shapeBinding.ShapeDescriptor.Processing.Invoke(action => action(displayingContext), _logger); // invoking ShapeMetadata processing events await shapeMetadata.Processing.InvokeAsync(processing => processing(shape), _logger); shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, context); } else { throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type)); } } foreach (var frameType in shape.Metadata.Wrappers) { ShapeBinding frameBinding; if (TryGetDescriptorBinding(frameType, Enumerable.Empty<string>(), shapeTable, out frameBinding)) { shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, context); } } var displayedContext = new ShapeDisplayedContext { Shape = shape, ShapeMetadata = shape.Metadata, ChildContent = shape.Metadata.ChildContent, DisplayContext = context }; _shapeDisplayEvents.Invoke(sde => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; sde.Displayed(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; }, _logger); if (shapeBinding != null) { shapeBinding.ShapeDescriptor.Displayed.Invoke(action => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; action(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; }, _logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke(action => action(displayedContext), _logger); return shape.Metadata.ChildContent; }
public IHtmlString Execute(DisplayContext context) { var shape = _convertAsShapeCallsite.Target(_convertAsShapeCallsite, context.Value); // non-shape arguments are returned as a no-op if (shape == null) { return(CoerceHtmlString(context.Value)); } var shapeMetadata = shape.Metadata; // can't really cope with a shape that has no type information if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type)) { return(CoerceHtmlString(context.Value)); } var workContext = _workContextAccessor.GetContext(); // CurrentTheme is now available in the background, so here we no longer use IsBackgroundContext(). // We only do a null check, so we can render in the background a view that only exists in the theme. var shapeTable = _httpContextAccessor.Current() != null ? _shapeTableLocator.Value.Lookup(workContext.CurrentTheme.Id) : _shapeTableLocator.Value.Lookup(null); var displayingContext = new ShapeDisplayingContext { Shape = shape, ShapeMetadata = shapeMetadata }; _shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), Logger); // find base shape association using only the fundamental shape type. // alternates that may already be registered do not affect the "displaying" event calls ShapeBinding shapeBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty <string>(), shapeTable, shapeMetadata.BindingType, out shapeBinding)) { shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), Logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayingContext), Logger); // use pre-fectched content if available (e.g. coming from specific cache implmentation) if (displayingContext.ChildContent != null) { shape.Metadata.ChildContent = displayingContext.ChildContent; } else { // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, shapeMetadata.BindingType, out actualBinding)) { shape.Metadata.ChildContent = Process(actualBinding, shape, context); } else { throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type)); } } foreach (var frameType in shape.Metadata.Wrappers) { ShapeBinding frameBinding; if (TryGetDescriptorBinding(frameType, Enumerable.Empty <string>(), shapeTable, shapeMetadata.BindingType, out frameBinding)) { shape.Metadata.ChildContent = Process(frameBinding, shape, context); } } var displayedContext = new ShapeDisplayedContext { Shape = shape, ShapeMetadata = shape.Metadata, ChildContent = shape.Metadata.ChildContent, }; _shapeDisplayEvents.Invoke(sde => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; sde.Displayed(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) { displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; } }, Logger); if (shapeBinding != null) { shapeBinding.ShapeDescriptor.Displayed.Invoke(action => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; action(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) { displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; } }, Logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke(action => action(displayedContext), Logger); return(shape.Metadata.ChildContent); }
public void BindingProvidedByStrategyInvokesMethod() { var initializers = GetAlterationBuilders(_container.Resolve<IShapeTableProvider>()); var shapeDescriptor = initializers.Where(i => i.ShapeType == "Simple") .Aggregate(new ShapeDescriptor { ShapeType = "Simple" }, (d, i) => { i.Alter(d); return d; }); var displayContext = new DisplayContext(); var result = shapeDescriptor.Binding(displayContext); var result2 = shapeDescriptor.Binding.Invoke(displayContext); Assert.That(result.ToString(), Is.StringContaining("Simple")); Assert.That(result2.ToString(), Is.StringContaining("Simple")); }
public IHtmlString Execute(DisplayContext context) { var shape = _convertAsShapeCallsite.Target(_convertAsShapeCallsite, context.Value); // non-shape arguments are returned as a no-op if (shape == null) return CoerceHtmlString(context.Value); var shapeMetadata = shape.Metadata; // can't really cope with a shape that has no type information if (shapeMetadata == null || string.IsNullOrEmpty(shapeMetadata.Type)) return CoerceHtmlString(context.Value); var workContext = _workContextAccessor.GetContext(); // CurrentTheme is now available in the background, so here we no longer use IsBackgroundContext(). // We only do a null check, so we can render in the background a view that only exists in the theme. var shapeTable = _httpContextAccessor.Current() != null ? _shapeTableLocator.Value.Lookup(workContext.CurrentTheme.Id) : _shapeTableLocator.Value.Lookup(null); var displayingContext = new ShapeDisplayingContext { Shape = shape, ShapeMetadata = shapeMetadata }; _shapeDisplayEvents.Invoke(sde => sde.Displaying(displayingContext), Logger); // find base shape association using only the fundamental shape type. // alternates that may already be registered do not affect the "displaying" event calls ShapeBinding shapeBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, Enumerable.Empty<string>(), shapeTable, out shapeBinding)) { shapeBinding.ShapeDescriptor.Displaying.Invoke(action => action(displayingContext), Logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeBinding.ShapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeBinding.ShapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayingContext), Logger); // use pre-fectched content if available (e.g. coming from specific cache implmentation) if ( displayingContext.ChildContent != null ) { shape.Metadata.ChildContent = displayingContext.ChildContent; } else { // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if ( TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding) ) { shape.Metadata.ChildContent = Process(actualBinding, shape, context); } else { throw new OrchardException(T("Shape type {0} not found", shapeMetadata.Type)); } } foreach (var frameType in shape.Metadata.Wrappers) { ShapeBinding frameBinding; if (TryGetDescriptorBinding(frameType, Enumerable.Empty<string>(), shapeTable, out frameBinding)) { shape.Metadata.ChildContent = Process(frameBinding, shape, context); } } var displayedContext = new ShapeDisplayedContext { Shape = shape, ShapeMetadata = shape.Metadata, ChildContent = shape.Metadata.ChildContent, }; _shapeDisplayEvents.Invoke(sde => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; sde.Displayed(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; }, Logger); if (shapeBinding != null) { shapeBinding.ShapeDescriptor.Displayed.Invoke(action => { var prior = displayedContext.ChildContent = displayedContext.ShapeMetadata.ChildContent; action(displayedContext); // update the child content if the context variable has been reassigned if (prior != displayedContext.ChildContent) displayedContext.ShapeMetadata.ChildContent = displayedContext.ChildContent; }, Logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke(action => action(displayedContext), Logger); return shape.Metadata.ChildContent; }
public abstract string Process(string template, string name, DisplayContext context = null, dynamic model = null);