public Task <IHtmlContent> DisplayAsync(object shape)
{
var viewContext = new ViewContext
{
HttpContext = _httpContextAccessor.HttpContext,
};
var display = _displayHelperFactory.CreateHelper(viewContext);
return(((DisplayHelper)display).ShapeExecuteAsync(shape));
}
public Task <IHtmlContent> DisplayAsync(object shape)
{
if (shape == null)
{
return(Task.FromResult <IHtmlContent>(HtmlString.Empty));
}
var viewContext = new ViewContext
{
HttpContext = _httpContextAccessor.HttpContext,
};
var display = _displayHelperFactory.CreateHelper(viewContext);
return(((DisplayHelper)display).ShapeExecuteAsync(shape));
}
private void EnsureDisplayHelper()
{
if (_displayHelper == null)
{
IDisplayHelperFactory _factory = ViewContext.HttpContext.RequestServices.GetService <IDisplayHelperFactory>();
_displayHelper = _factory.CreateHelper(ViewContext);
}
}
public string Display(object shape)
{
var viewContext = new ViewContext
{
HttpContext = _httpContextAccessor.HttpContext,
};
var display = _displayHelperFactory.CreateHelper(viewContext);
return(((DisplayHelper)display).ShapeExecute(shape).ToString());
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var display = (DisplayHelper)_displayHelperFactory.CreateHelper(ViewContext);
// Extract all attributes from the tag helper to
var properties = output.Attributes
.Where(x => x.Name != "type")
.ToDictionary(x => x.Name, x => (object)x.Value.ToString())
;
var shape = _shapeFactory.Create(Type ?? output.TagName, Arguments.From(properties));
output.Content.SetContent(await display.ShapeExecuteAsync(shape));
// We don't want any encapsulating tag around the shape
output.TagName = null;
}
protected override DriverResult Display(DynamicProjectionPart part, string displayType, dynamic shapeHelper)
{
var query = part.Record.QueryPartRecord;
// retrieving paging parameters
var queryString = _orchardServices.WorkContext.HttpContext.Request.QueryString;
var pageKey = String.IsNullOrWhiteSpace(part.Record.PagerSuffix) ? "page" : "page-" + part.Record.PagerSuffix;
var page = 0;
// default page size
int pageSize = part.Record.Items;
// don't try to page if not necessary
if (part.Record.DisplayPager && queryString.AllKeys.Contains(pageKey))
{
Int32.TryParse(queryString[pageKey], out page);
}
// if 0, then assume "All", limit to 128 by default
if (pageSize == 128)
{
pageSize = Int32.MaxValue;
}
// if pageSize is provided on the query string, ensure it is compatible with allowed limits
var pageSizeKey = "pageSize" + part.Record.PagerSuffix;
if (queryString.AllKeys.Contains(pageSizeKey))
{
int qsPageSize;
if (Int32.TryParse(queryString[pageSizeKey], out qsPageSize))
{
if (part.Record.MaxItems == 0 || qsPageSize <= part.Record.MaxItems)
{
pageSize = qsPageSize;
}
}
}
var pager = new Pager(_orchardServices.WorkContext.CurrentSite, page, pageSize);
var pagerShape = shapeHelper.Pager(pager)
.ContentPart(part)
.PagerId(pageKey);
return(Combined(
ContentShape("Parts_ProjectionPart_Pager", shape => {
if (!part.Record.DisplayPager)
{
return null;
}
return pagerShape;
}),
ContentShape("Parts_ProjectionPart_List", shape => {
// generates a link to the RSS feed for this term
var metaData = _orchardServices.ContentManager.GetItemMetadata(part.ContentItem);
// _feedManager.Register(metaData.DisplayText, "rss", new RouteValueDictionary { { "projection", part.Id } });
// execute the query
var contentItems = _projectionManager.GetContentItems(query.Id, part, pager.GetStartIndex() + part.Record.Skip, pager.PageSize).ToList();
// sanity check so that content items with ProjectionPart can't be added here, or it will result in an infinite loop
contentItems = contentItems.Where(x => !x.Has <ProjectionPart>()).ToList();
// applying layout
var layout = part.Record.LayoutRecord;
LayoutDescriptor layoutDescriptor = layout == null ? null : _projectionManager.DescribeLayouts().SelectMany(x => x.Descriptors).FirstOrDefault(x => x.Category == layout.Category && x.Type == layout.Type);
// create pager shape
if (part.Record.DisplayPager)
{
var contentItemsCount = _projectionManager.GetCount(query.Id, part) - part.Record.Skip;
contentItemsCount = Math.Max(0, contentItemsCount);
pagerShape.TotalItemCount(contentItemsCount);
}
// renders in a standard List shape if no specific layout could be found
if (layoutDescriptor == null)
{
var list = _orchardServices.New.List();
var contentShapes = contentItems.Select(item => _orchardServices.ContentManager.BuildDisplay(item, "Summary"));
list.AddRange(contentShapes);
return list;
}
var allFielDescriptors = _projectionManager.DescribeProperties().ToList();
var fieldDescriptors = layout.Properties.OrderBy(p => p.Position).Select(p => allFielDescriptors.SelectMany(x => x.Descriptors).Select(d => new { Descriptor = d, Property = p }).FirstOrDefault(x => x.Descriptor.Category == p.Category && x.Descriptor.Type == p.Type)).ToList();
var layoutComponents = contentItems.Select(
contentItem => {
var contentItemMetadata = _orchardServices.ContentManager.GetItemMetadata(contentItem);
var propertyDescriptors = fieldDescriptors.Select(
d => {
var fieldContext = new PropertyContext {
State = FormParametersHelper.ToDynamic(d.Property.State),
Tokens = new Dictionary <string, object> {
{ "Content", contentItem }
}
};
return new { d.Property, Shape = d.Descriptor.Property(fieldContext, contentItem) };
});
// apply all settings to the field content, wrapping it in a FieldWrapper shape
var properties = _orchardServices.New.Properties(
Items: propertyDescriptors.Select(
pd => _orchardServices.New.PropertyWrapper(
Item: pd.Shape,
Property: pd.Property,
ContentItem: contentItem,
ContentItemMetadata: contentItemMetadata
)
)
);
return new LayoutComponentResult {
ContentItem = contentItem,
ContentItemMetadata = contentItemMetadata,
Properties = properties
};
}).ToList();
var tokenizedState = _tokenizer.Replace(layout.State, new Dictionary <string, object> {
{ "Content", part.ContentItem }
});
var renderLayoutContext = new LayoutContext {
State = FormParametersHelper.ToDynamic(tokenizedState),
LayoutRecord = layout,
};
if (layout.GroupProperty != null)
{
var groupPropertyId = layout.GroupProperty.Id;
var display = _displayHelperFactory.CreateHelper(new ViewContext {
HttpContext = _workContextAccessor.GetContext().HttpContext
}, new ViewDataContainer());
// index by PropertyWrapper shape
var groups = layoutComponents.GroupBy(
x => {
var propertyShape = ((IEnumerable <dynamic>)x.Properties.Items).First(p => ((PropertyRecord)p.Property).Id == groupPropertyId);
// clear the wrappers, as they shouldn't be needed to generate the grouping key itself
// otherwise the DisplayContext.View is null, and throws an exception if a wrapper is rendered (#18558)
((IShape)propertyShape).Metadata.Wrappers.Clear();
string key = Convert.ToString(display(propertyShape));
return key;
}).Select(x => new { Key = x.Key, Components = x });
var list = _orchardServices.New.List();
foreach (var group in groups)
{
var localResult = layoutDescriptor.Render(renderLayoutContext, group.Components);
// add the Context to the shape
localResult.Context(renderLayoutContext);
list.Add(_orchardServices.New.LayoutGroup(Key: new MvcHtmlString(group.Key), List: localResult));
}
return list;
}
var layoutResult = layoutDescriptor.Render(renderLayoutContext, layoutComponents);
// add the Context to the shape
layoutResult.Context(renderLayoutContext);
return layoutResult;
})));
}
public override async Task ProcessAsync(TagHelperContext tagHelperContext, TagHelperOutput output)
{
var display = (DisplayHelper)_displayHelperFactory.CreateHelper(ViewContext);
// Extract all attributes from the tag helper to
var properties = output.Attributes
.Where(x => !InternalProperties.Contains(x.Name))
.ToDictionary(x => LowerKebabToPascalCase(x.Name), x => (object)x.Value.ToString())
;
if (string.IsNullOrWhiteSpace(Type))
{
Type = output.TagName;
}
if (string.IsNullOrWhiteSpace(Cache) && output.Attributes.ContainsName("cache-id"))
{
Cache = Convert.ToString(output.Attributes["cache-id"].Value);
}
if (string.IsNullOrWhiteSpace(Context) && output.Attributes.ContainsName("cache-context"))
{
Context = Convert.ToString(output.Attributes["cache-context"].Value);
}
if (string.IsNullOrWhiteSpace(Dependency) && output.Attributes.ContainsName("cache-dependency"))
{
Dependency = Convert.ToString(output.Attributes["cache-dependency"].Value);
}
if (string.IsNullOrWhiteSpace(Tag) && output.Attributes.ContainsName("cache-tag"))
{
Tag = Convert.ToString(output.Attributes["cache-tag"].Value);
}
if (!Duration.HasValue && output.Attributes.ContainsName("cache-duration"))
{
TimeSpan timespan;
if (TimeSpan.TryParse(Convert.ToString(output.Attributes["cache-duration"].Value), out timespan))
{
Duration = timespan;
}
}
var shape = await _shapeFactory.CreateAsync(Type, Arguments.From(properties));
if (output.Attributes.ContainsName("id"))
{
shape.Id = Convert.ToString(output.Attributes["id"].Value);
}
tagHelperContext.Items.Add(typeof(IShape), shape);
if (!string.IsNullOrWhiteSpace(Cache))
{
var metadata = shape.Metadata;
metadata.Cache(Cache);
if (Duration.HasValue)
{
metadata.Cache().During(Duration.Value);
}
if (!string.IsNullOrWhiteSpace(Context))
{
var contexts = Context.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
metadata.Cache().AddContext(contexts);
}
if (!string.IsNullOrWhiteSpace(Tag))
{
var tags = Tag.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
metadata.Cache().AddTag(tags);
}
if (!string.IsNullOrWhiteSpace(Dependency))
{
var dependency = Dependency.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
metadata.Cache().AddDependency(dependency);
}
}
await output.GetChildContentAsync();
output.Content.SetHtmlContent(await display.ShapeExecuteAsync(shape));
// We don't want any encapsulating tag around the shape
output.TagName = null;
}
