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();
}
