protected async Task BindPlacementAsync(IBuildShapeContext context) { var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme.Id); context.FindPlacement = (partShapeType, differentiator, displayType) => { ShapeDescriptor descriptor; if (shapeTable.Descriptors.TryGetValue(partShapeType, out descriptor)) { var placementContext = new ShapePlacementContext { Shape = context.Shape }; var placement = descriptor.Placement(placementContext); if (placement != null) { placement.Source = placementContext.Source; return(placement); } } return(null); }; }
protected async Task BindPlacementAsync(IBuildShapeContext context) { var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme.Id); context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => FindPlacementImpl(shapeTable, shapeType, differentiator, displayType, context); }
public async Task PopulateContextEntriesAsync(IEnumerable <string> contexts, List <CacheContextEntry> entries) { // Always vary by theme var theme = await _themeManager.GetThemeAsync(); entries.Add(new CacheContextEntry("theme", theme.Id)); }
private ShapeTable GetShapeTable() { if (_scopedShapeTable == null) { var theme = _themeManager.GetThemeAsync().GetAwaiter().GetResult(); _scopedShapeTable = _shapeTableManager.GetShapeTable(theme?.Id); } return(_scopedShapeTable); }
private async Task <ShapeTable> GetShapeTableAsync() { if (_scopedShapeTable == null) { var theme = await _themeManager.GetThemeAsync(); _scopedShapeTable = _shapeTableManager.GetShapeTable(theme?.Id); } return(_scopedShapeTable); }
protected async Task BindPlacementAsync(IBuildShapeContext context) { var theme = await _themeManager.GetThemeAsync(); // If there is no active theme, do nothing if (theme == null) { return; } var shapeTable = _shapeTableManager.GetShapeTable(theme.Id); context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => FindPlacementImpl(shapeTable, shapeType, differentiator, displayType, context); }
public async Task UpdateEditorAsync(IContent content, string groupInfoId) { if (content == null || content.ContentItem == null) { throw new ArgumentNullException(nameof(content)); } var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(content.ContentItem.ContentType); JToken stereotype; if (!contentTypeDefinition.Settings.TryGetValue("Stereotype", out stereotype)) { stereotype = "Content"; } var actualShapeType = stereotype + "_Edit"; dynamic itemShape = CreateContentShape(actualShapeType); itemShape.ContentItem = content.ContentItem; var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme.Id); // adding an alternate for [Stereotype]_Edit__[ContentType] e.g. Content-Menu.Edit ((IShape)itemShape).Metadata.Alternates.Add(actualShapeType + "__" + content.ContentItem.ContentType); var context = new UpdateEditorContext(itemShape, content, groupInfoId, _shapeFactory); await BindPlacementAsync(context, null, stereotype.Value <string>()); await _handlers.InvokeAsync(handler => handler.UpdateEditorAsync(context), Logger); return; }
private IEnumerable <TagHelperDescriptor> ResolveViewComponentTagHelperDescriptors(string prefix) { var resolvedDescriptors = new List <TagHelperDescriptor>(); var attributeDescriptors = new List <TagHelperAttributeDescriptor>(); var theme = _themeManager.GetThemeAsync().Result; foreach (var shape in _shapteTableManager.GetShapeTable(theme?.Id).Descriptors) { resolvedDescriptors.Add( new TagHelperDescriptor { Prefix = "", TagName = shape.Key, TypeName = ShapeTagHelperType.FullName, AssemblyName = ShapeTagHelperType.GetTypeInfo().Assembly.GetName().Name, Attributes = Enumerable.Empty <TagHelperAttributeDescriptor>(), RequiredAttributes = Enumerable.Empty <string>(), }); } return(resolvedDescriptors); }
public async Task <dynamic> UpdateEditorAsync(ContentItem contentItem, IUpdateModel updater, string groupInfoId) { if (contentItem == null) { throw new ArgumentNullException(nameof(contentItem)); } var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType); var stereotype = contentTypeDefinition.Settings.ToObject <ContentTypeSettings>().Stereotype; var actualShapeType = stereotype ?? "Content" + "_Edit"; dynamic itemShape = CreateContentShape(actualShapeType); itemShape.ContentItem = contentItem; var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme.Id); // adding an alternate for [Stereotype]_Edit__[ContentType] e.g. Content-Menu.Edit ((IShape)itemShape).Metadata.Alternates.Add(actualShapeType + "__" + contentItem.ContentType); var context = new UpdateEditorContext( itemShape, groupInfoId, _shapeFactory, _layoutAccessor.GetLayout(), updater ); await BindPlacementAsync(context); await _handlers.InvokeAsync(handler => handler.UpdateEditorAsync(contentItem, context), Logger); return(context.Shape); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // Should only run on the front-end for a full view if ((context.Result is ViewResult || context.Result is PageResult) && !AdminAttribute.IsApplied(context.HttpContext)) { // Even if the Admin attribute is not applied we might be using the admin theme, for instance in Login views. // In this case don't render Layers. var selectedTheme = (await _themeManager.GetThemeAsync())?.Id; var adminTheme = await _adminThemeService.GetAdminThemeNameAsync(); if (selectedTheme == adminTheme) { await next.Invoke(); return; } var widgets = await _memoryCache.GetOrCreateAsync("OrchardCore.Layers.LayerFilter:AllWidgets", entry => { entry.AddExpirationToken(_signal.GetToken(LayerMetadataHandler.LayerChangeToken)); return(_layerService.GetLayerWidgetsAsync(x => x.Published)); }); var layers = (await _layerService.GetLayersAsync()).Layers.ToDictionary(x => x.Name); dynamic layout = await _layoutAccessor.GetLayoutAsync(); var updater = _modelUpdaterAccessor.ModelUpdater; var engine = _scriptingManager.GetScriptingEngine("js"); var scope = engine.CreateScope(_scriptingManager.GlobalMethodProviders.SelectMany(x => x.GetMethods()), _serviceProvider, null, null); var layersCache = new Dictionary <string, bool>(); foreach (var widget in widgets) { var layer = layers[widget.Layer]; if (layer == null) { continue; } bool display; if (!layersCache.TryGetValue(layer.Name, out display)) { if (String.IsNullOrEmpty(layer.Rule)) { display = false; } else { display = Convert.ToBoolean(engine.Evaluate(scope, layer.Rule)); } layersCache[layer.Rule] = display; } if (!display) { continue; } var widgetContent = await _contentItemDisplayManager.BuildDisplayAsync(widget.ContentItem, updater); widgetContent.Classes.Add("widget"); widgetContent.Classes.Add("widget-" + widget.ContentItem.ContentType.HtmlClassify()); var wrapper = new WidgetWrapper { Widget = widget.ContentItem, Content = widgetContent }; wrapper.Metadata.Alternates.Add("Widget_Wrapper__" + widget.ContentItem.ContentType); wrapper.Metadata.Alternates.Add("Widget_Wrapper__Zone__" + widget.Zone); var contentZone = layout.Zones[widget.Zone]; contentZone.Add(wrapper); } } await next.Invoke(); }
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 displayContext = new ShapeDisplayContext { Shape = shape, ShapeMetadata = shapeMetadata, DisplayContext = context, ServiceProvider = _serviceProvider }; try { var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id); // 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 await _shapeDisplayEvents.InvokeAsync(sde => sde.DisplayingAsync(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)) { await shapeBinding.ShapeDescriptor.DisplayingAsync.InvokeAsync(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) { // 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); } // now find the actual binding to render, taking alternates into account ShapeBinding actualBinding; if (TryGetDescriptorBinding(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable, out actualBinding)) { // 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(); } await _shapeDisplayEvents.InvokeAsync(async sde => { var prior = displayContext.ChildContent = displayContext.ShapeMetadata.ChildContent; await sde.DisplayedAsync(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) { await shapeBinding.ShapeDescriptor.DisplayedAsync.InvokeAsync(async action => { var prior = displayContext.ChildContent = displayContext.ShapeMetadata.ChildContent; await 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; } finally { await _shapeDisplayEvents.InvokeAsync(sde => sde.DisplayingFinalizedAsync(displayContext), _logger); } return(shape.Metadata.ChildContent); }
public void PopulateContextEntries(IEnumerable <string> contexts, List <CacheContextEntry> entries) { // Always vary by theme entries.Add(new CacheContextEntry("theme", _themeManager.GetThemeAsync().Result.Name)); }
public IShape Create(string shapeType, INamedEnumerable <object> parameters, Func <dynamic> createShape) { var theme = _themeManager.GetThemeAsync().Result; var defaultShapeTable = _shapeTableManager.GetShapeTable(theme?.Id); ShapeDescriptor shapeDescriptor; defaultShapeTable.Descriptors.TryGetValue(shapeType, out shapeDescriptor); parameters = parameters ?? Arguments.Empty; var creatingContext = new ShapeCreatingContext { New = this, ShapeFactory = this, ShapeType = shapeType, OnCreated = new List <Action <ShapeCreatedContext> >() }; IEnumerable <object> positional = parameters.Positional.ToList(); var baseType = positional.FirstOrDefault() as Type; if (baseType == null) { // default to common base class creatingContext.Create = createShape ?? (() => new Shape()); } else { // consume the first argument positional = positional.Skip(1); creatingContext.Create = () => Activator.CreateInstance(baseType); } // "creating" events may add behaviors and alter base type) foreach (var ev in _events) { ev.Creating(creatingContext); } if (shapeDescriptor != null) { foreach (var ev in shapeDescriptor.Creating) { ev(creatingContext); } } // create the new instance var createdContext = new ShapeCreatedContext { New = creatingContext.New, ShapeFactory = creatingContext.ShapeFactory, ShapeType = creatingContext.ShapeType, Shape = creatingContext.Create() }; if (!(createdContext.Shape is IShape)) { throw new InvalidOperationException("Invalid base type for shape: " + createdContext.Shape.GetType().ToString()); } if (createdContext.Shape.Metadata == null) { createdContext.Shape.Metadata = new ShapeMetadata(); } ShapeMetadata shapeMetadata = createdContext.Shape.Metadata; createdContext.Shape.Metadata.Type = shapeType; // Concatenate wrappers if there are any if (shapeDescriptor != null && shapeMetadata.Wrappers.Count + shapeDescriptor.Wrappers.Count > 0) { shapeMetadata.Wrappers = shapeMetadata.Wrappers.Concat(shapeDescriptor.Wrappers).ToList(); } // only one non-Type, non-named argument is allowed var initializer = positional.SingleOrDefault(); if (initializer != null) { foreach (var prop in initializer.GetType().GetProperties()) { createdContext.Shape[prop.Name] = prop.GetValue(initializer, null); } } foreach (var kv in parameters.Named) { createdContext.Shape[kv.Key] = kv.Value; } // "created" events provides default values and new object initialization foreach (var ev in _events) { ev.Created(createdContext); } if (shapeDescriptor != null) { foreach (var ev in shapeDescriptor.Created) { ev(createdContext); } } foreach (var ev in creatingContext.OnCreated) { ev(createdContext); } return(createdContext.Shape); }
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)); } // Copy the current context such that the rendering can customize it if necessary // For instance to change the HtmlFieldPrefix var localContext = new DisplayContext(context); localContext.HtmlFieldPrefix = shapeMetadata.Prefix ?? ""; var displayContext = new ShapeDisplayContext { Shape = shape, DisplayContext = localContext, ServiceProvider = _serviceProvider }; try { var theme = await _themeManager.GetThemeAsync(); var shapeTable = _shapeTableManager.GetShapeTable(theme?.Id); // Evaluate global Shape Display Events await _shapeDisplayEvents.InvokeAsync((e, displayContext) => e.DisplayingAsync(displayContext), 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. var shapeDescriptor = GetShapeDescriptor(shapeMetadata.Type, shapeTable); if (shapeDescriptor != null) { await shapeDescriptor.DisplayingAsync.InvokeAsync((action, displayContext) => action(displayContext), displayContext, _logger); // copy all binding sources (all templates for this shape) in order to use them as Localization scopes shapeMetadata.BindingSources = shapeDescriptor.BindingSources.Where(x => x != null).ToList(); if (!shapeMetadata.BindingSources.Any()) { shapeMetadata.BindingSources.Add(shapeDescriptor.BindingSource); } } // invoking ShapeMetadata displaying events shapeMetadata.Displaying.Invoke(action => action(displayContext), _logger); // use pre-fetched content if available (e.g. coming from specific cache implementation) if (displayContext.ChildContent != null) { shape.Metadata.ChildContent = displayContext.ChildContent; } if (shape.Metadata.ChildContent == null) { // There might be no shape binding for the main shape, and only for its alternates. if (shapeDescriptor != null) { await shapeDescriptor.ProcessingAsync.InvokeAsync((action, displayContext) => action(displayContext), displayContext, _logger); } // now find the actual binding to render, taking alternates into account var actualBinding = await GetShapeBindingAsync(shapeMetadata.Type, shapeMetadata.Alternates, shapeTable); if (actualBinding != null) { await shapeMetadata.ProcessingAsync.InvokeAsync((action, displayContext) => action(displayContext.Shape), displayContext, _logger); shape.Metadata.ChildContent = await ProcessAsync(actualBinding, shape, localContext); } 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) { var frameBinding = await GetShapeBindingAsync(frameType, AlternatesCollection.Empty, shapeTable); if (frameBinding != null) { shape.Metadata.ChildContent = await ProcessAsync(frameBinding, shape, localContext); } } // Clear wrappers to prevent the child content from rendering them again shape.Metadata.Wrappers.Clear(); } await _shapeDisplayEvents.InvokeAsync(async (e, displayContext) => { var prior = displayContext.ChildContent = displayContext.Shape.Metadata.ChildContent; await e.DisplayedAsync(displayContext); // update the child content if the context variable has been reassigned if (prior != displayContext.ChildContent) { displayContext.Shape.Metadata.ChildContent = displayContext.ChildContent; } }, displayContext, _logger); if (shapeDescriptor != null) { await shapeDescriptor.DisplayedAsync.InvokeAsync(async (action, displayContext) => { var prior = displayContext.ChildContent = displayContext.Shape.Metadata.ChildContent; await action(displayContext); // update the child content if the context variable has been reassigned if (prior != displayContext.ChildContent) { displayContext.Shape.Metadata.ChildContent = displayContext.ChildContent; } }, displayContext, _logger); } // invoking ShapeMetadata displayed events shapeMetadata.Displayed.Invoke((action, displayContext) => action(displayContext), displayContext, _logger); } finally { await _shapeDisplayEvents.InvokeAsync((e, displayContext) => e.DisplayingFinalizedAsync(displayContext), displayContext, _logger); } return(shape.Metadata.ChildContent); }
public async Task OnResultExecutionAsync(ResultExecutingContext filterContext, ResultExecutionDelegate next) { // Should only run on a full view rendering result if (!(filterContext.Result is ViewResult || filterContext.Result is PageResult)) { await next(); return; } // Should only run on the Front End if (AdminAttribute.IsApplied(filterContext.HttpContext)) { await next(); return; } // // Should only run on the Admin Home Page // if (!(filterContext.HttpContext.GetRouteValue("area").ToString() == "OrchardCore.Admin" && filterContext.HttpContext.GetRouteValue("controller").ToString() == "Admin" && filterContext.HttpContext.GetRouteValue("action").ToString() == "Index")) // { // await next(); // return; // // } // Don't create the menu if the status code is 3xx var statusCode = filterContext.HttpContext.Response.StatusCode; if (statusCode >= 300 && statusCode < 400) { await next(); return; } //1. get content item alias from settings //2. Render content item by alias shapeFactory //3 Injects in Layout content shape // For instance accessing the BodyPart of a custom settings section named BlogSettings would be accessible using {{ Site.Properties.BlogSettings.BodyPart }}. if (_httpContextAccessor.HttpContext.User == null) { await next(); return; } if (!filterContext.HttpContext.Request.Query.ContainsKey("preview")) { await next(); return; } dynamic layout = await _layoutAccessor.GetLayoutAsync(); var zones = layout.Zones; var theme = await _themeManager.GetThemeAsync(); var siteSettings = await _siteService.GetSiteSettingsAsync(); /*TODO MOVE INTO SEPARATE ASSEMBLY TO NOT REFERENCE LAYER SETTINGS * var s = siteSettings.As<LayerSettings>().Zones ?? Array.Empty<string>(); * // var s = theme.Zones; * * // while (string.IsNullOrEmpty(s)) * // { * // theme = _extensionManager.GetExtension(theme.BaseTheme); * // s = theme.Zones; * // } * if (s.Length!=0 ) * { * // var arr = s.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()); * foreach (var item in s) * { * if (zones[item] == null && item != "Navigation") * zones[item].Add("ZoneEmpty"); * //zones[item].Add(Shape.ZoneEmpty()); * } * } * * // if (adminDashBoardContentItem == null) * // { * // layout.Content.Metadata.Alternates.Add("AdminContent_Empty"); //"AdminContent_MyAlternate1") * // } * // else * // { * // layout.Content.AdminDashBoardContentItem = adminDashBoardContentItem; * // layout.Content.Metadata.Alternates.Add("AdminContent_CustomAdmin"); * // } */ layout.Content.Add("PreviewContent"); await next(); }