public static AnimationPart GetAnimationPart(this ContentItem contentItem)
{
return(new AnimationPart
{
Delay = contentItem.Get <ContentPart>("AnimationPart").Get <NumericField>("Delay").Value,
Duration = contentItem.Get <ContentPart>("AnimationPart").Get <NumericField>("Duration").Value,
Repeat = contentItem.Get <ContentPart>("AnimationPart").Get <BooleanField>("Repeat").Value,
Timing = contentItem.Get <ContentPart>("AnimationPart").Get <TextField>("Timing").Text,
Type = contentItem.Get <ContentPart>("AnimationPart").Get <TextField>("Type").Text,
});
}
public static string CasePostAcquier(this UrlHelper urlHelper, ContentItem cAsePostPart1, string returnurl)
{
CasePostPart cAsePostPart = cAsePostPart1.Get <CasePostPart>();
return(urlHelper.Action("Acquier", "CasePostAdmin", new { cAseId = cAsePostPart.CasePart.Id, postId = cAsePostPart.Id, returnUrl = returnurl, area = "LawBookCases.Module" }));
// return urlHelper.Action("Publish", "CasePostAdmin", new { cAseId = cAsePostPart.CasePart.Id, postId = cAsePostPart.Id, area = "LawBookCases.Module" });
}
public IEnumerable <ProductAttributeDescription> GetProductAttributeFields(ContentItem product)
{
var productAttributeTypes = GetProductAttributeFieldTypes();
ProductAttributeField GetContentField(ContentTypePartDefinition typePartDefinition, ContentPartFieldDefinition partFieldDefinition)
=> product.Get <ContentPart>(typePartDefinition.Name)
?.Get(productAttributeTypes[partFieldDefinition.FieldDefinition.Name], partFieldDefinition.Name) as ProductAttributeField;
return(_contentDefinitionManager
.GetTypeDefinition(product.ContentType)
.Parts
.SelectMany(typePartDefinition => typePartDefinition.PartDefinition.Fields
.Where(partFieldDefinition => productAttributeTypes.ContainsKey(partFieldDefinition.FieldDefinition.Name))
.Select(partFieldDefinition =>
{
var field = GetContentField(typePartDefinition, partFieldDefinition);
var settings = GetFieldSettings(partFieldDefinition, field);
return new ProductAttributeDescription(
name: partFieldDefinition.Name,
partName: typePartDefinition.Name,
field: field,
settings: settings);
}))
.Where(description => description.Field != null));
}
private async Task BuildContentPartDisplaysAsync(
ContentItem contentItem,
ContentTypePartDefinition contentTypePartDefinition,
BuildDisplayContext context)
{
var partName = contentTypePartDefinition.Name;
var partTypeName = contentTypePartDefinition.Part.Name;
var partType = _contentParts.FirstOrDefault(x => x.GetType().Name == partTypeName)?.GetType() ??
typeof(ContentPart);
if (partType == null)
{
return;
}
if (!(contentItem.Get(partType, partName) is ContentPart contentPart))
{
return;
}
var drivers = _contentPartDisplayDrivers.Where(x => x.PartType == partType);
var partDisplayContext = new BuildPartDisplayContext(contentTypePartDefinition, context)
{
DefaultPosition = contentTypePartDefinition.GetSettings <ContentTypePartSettings>().Position
};
foreach (var driver in drivers)
{
var result = await driver.BuildDisplayAsync(contentPart, partDisplayContext);
await ApplyDisplayResultAsync(result, context);
}
await BuildContentFieldsDisplaysAsync(contentItem, contentPart, contentTypePartDefinition, context);
}
private void SetupTagCloudLoader(ContentItem item)
{
var cloudPart = (TagCloudPart)item.Get(typeof(TagCloudPart));
cloudPart._tagCounts.Loader(tags =>
_tagCloudService.GetPopularTags(cloudPart.Buckets, cloudPart.Slug).ToList());
}
public void GetReflectsChangesToFieldMadeByApply()
{
// arrange
var value = "changed value";
var contentItem = new ContentItem();
contentItem.Weld <CustomPart>();
var part = contentItem.Get <CustomPart>(nameof(CustomPart));
var field = part.GetOrCreate <TextField>(nameof(CustomPart.Field));
field.Text = value;
// act
part.Apply(nameof(CustomPart.Field), field);
// assert
var actual = contentItem.Get <CustomPart>(nameof(CustomPart));
Assert.Equal(actual.Field?.Text, value);
}
public async Task UpdateUserIdentifier(ContentItem contentItem, IUser user)
{
var profilePart = contentItem.Get <ProfilePart>("ProfilePart");
profilePart.UserIdentifier = await _userManager.GetUserIdAsync(user);
contentItem.Apply("ProfilePart", profilePart);
ContentExtensions.Apply(contentItem, contentItem);
await _contentManager.UpdateAsync(contentItem);
}
private static string GetUniqueIdentifier(ContentItem item)
{
string slug = null;
if (item.Has <AutoroutePart>())
{
var route = item.Get <AutoroutePart>();
slug = route.Path;
}
return(string.Format("{0} {1}", item.Id, slug));
}
public string GetUniqueIdentifier(ContentItem item)
{
string slug = null;
if (item.Has <RoutePart>())
{
var route = item.Get <RoutePart>();
slug = route.Slug;
}
return(string.Format("{0} {1}", item.Id, slug));
}
public JToken ToJson(ContentItem contentItem)
{
var json = new JObject();
var part = contentItem.Get <ContentPart>(ContentType);
json["name"] = part.Get <TextField>("Name")?.Text;
json["label"] = part.Get <TextField>("Label")?.Text;
json["description"] = part.Get <TextField>("Description")?.Text;
json["cookies"] = new JArray(part.Get <ValuesField>("Cookies")?.Data);
json["onAccept"] = new JRaw($"function () {{ {part.Get<CodeField>("Accept")?.Value} }}");
json["onRevoke"] = new JRaw($"function () {{ {part.Get<CodeField>("Revoke")?.Value} }}");
return(json);
}
public async Task <XDocument> CreateFeedAsync(ContentItem contentItem, ActionContext actionContext)
{
var contentPart = contentItem.Get <ContentPart>(Constants.RssFeed.ContentType);
var query = await _queryManager.GetQueryAsync(contentPart?.Get <QueryField>(Constants.RssFeed.SourceFieldName)?.Value);
var results = await _queryManager.ExecuteQueryAsync(query, new Dictionary <string, object>());
var rss = new XElement("rss", new XAttribute("version", "2.0"), new XAttribute(XNamespace.Xmlns + "atom", "http://www.w3.org/2005/Atom"));
rss.Add(CreateChannelMeta(contentItem));
rss.Add(await CreateItemsAsync(contentItem, results.Items.Cast <ContentItem>(), actionContext));
return(new XDocument(new XDeclaration("1.0", "utf-8", "yes"), rss));
}
private XElement GetEnclosure(ContentItem contentItem)
{
string path = string.Empty;
if (contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart) != null)
{
path = contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart).Get <MediaField>(Constants.RssFeedItem.EnclosureFieldName).Paths.FirstOrDefault();
}
if (string.IsNullOrWhiteSpace(path) && contentItem.Has <MetaTagsPart>())
{
path = contentItem.As <MetaTagsPart>().Images.FirstOrDefault();
}
if (string.IsNullOrWhiteSpace(path))
{
return(null);
}
return(new XElement("enclosure", new XAttribute[] {
new XAttribute("url", GetMediaUrl(path)),
new XAttribute("type", GetMimeType(path)),
}));
}
public static string GetDescription(this ContentItem contentItem, BodyAspect bodyAspect)
{
var rssFeedItemPart = contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart);
if (rssFeedItemPart != null && !string.IsNullOrWhiteSpace(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.DescriptionFieldName).Text))
{
return(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.DescriptionFieldName).Text);
}
if (contentItem.Has <MetaTagsPart>() && !string.IsNullOrWhiteSpace(contentItem.As <MetaTagsPart>()?.Description))
{
return(contentItem.As <MetaTagsPart>()?.Description);
}
return(bodyAspect.Body != null ? $"<![CDATA[{bodyAspect.Body?.ToString()}]]>" : string.Empty);
}
public static string GetTitle(this ContentItem contentItem)
{
var rssFeedItemPart = contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart);
if (rssFeedItemPart != null && !string.IsNullOrWhiteSpace(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.TitleFieldName).Text))
{
return(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.TitleFieldName).Text);
}
if (contentItem.Has <MetaTagsPart>() && !string.IsNullOrWhiteSpace(contentItem.As <MetaTagsPart>()?.Title))
{
return(contentItem.As <MetaTagsPart>()?.Title);
}
return(contentItem.DisplayText);
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
// Optimized implementation for display
// For each field on the content item, invoke all IContentFieldDisplayDriver instances
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
var partInfos = _contentPartDrivers.Select(x => x.GetPartInfo()).ToDictionary(x => x.PartName);
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.PartDefinition.Name;
var partType = partInfos.ContainsKey(partName) ? partInfos[partName].Factory(contentTypePartDefinition).GetType() : null;
var part = contentItem.Get(partType ?? typeof(ContentPart), partName) as ContentPart;
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
var fieldName = contentPartFieldDefinition.Name;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(fieldName, part, contentPartFieldDefinition, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
}
}
}
public void GetReflectsChangesMadeByApply()
{
// arrange
var value = "changed value";
var contentItem = new ContentItem();
contentItem.Weld <CustomPart>();
var part = new CustomPart {
Value = value
};
// act
contentItem.Apply(nameof(CustomPart), part);
// assert
var actual = contentItem.Get <CustomPart>(nameof(CustomPart));
Assert.Equal(actual.Value, value);
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
// Optimized implementation for display
// For each field on the content item, invoke all IContentFieldDisplayDriver instances
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if(contentTypeDefinition == null)
{
return;
}
var partInfos = _contentPartDrivers.Select(x => x.GetPartInfo()).ToDictionary(x => x.PartName);
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.PartDefinition.Name;
var partType = partInfos.ContainsKey(partName) ? partInfos[partName].Factory(contentTypePartDefinition).GetType() : null;
var part = contentItem.Get(partType ?? typeof(ContentPart), partName) as ContentPart;
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
var fieldName = contentPartFieldDefinition.Name;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(fieldName, part, contentPartFieldDefinition, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
}
}
}
public Task Process(ContentItem contentItem, Func <ContentPartFieldDefinition, ContentPart, string, Task> action)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return(Task.CompletedTask);
}
var partInfos = _contentPartDrivers.Select(x => x.GetPartInfo()).ToDictionary(x => x.PartName);
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
// Abort if there are not fields in this part
if (!typePartDefinition.PartDefinition.Fields.Any())
{
continue;
}
var partName = typePartDefinition.PartDefinition.Name;
ContentPartInfo partInfo;
ContentPart part = partInfos.TryGetValue(partName, out partInfo)
? partInfo.Factory(typePartDefinition)
: new ContentPart();
part = contentItem.Get(part.GetType(), partName) as ContentPart;
if (part == null)
{
return(Task.CompletedTask);
}
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
action(partFieldDefinition, part, fieldName);
}
}
return(Task.CompletedTask);
}
protected IList <XElement> CreateChannelMeta(ContentItem contentItem)
{
var contentPart = contentItem.Get <ContentPart>(Constants.RssFeed.ContentType);
var request = _httpContextAccessor.HttpContext.Request;
XNamespace atom = "http://www.w3.org/2005/Atom";
var atomLink = new XElement(atom + "link");
atomLink.SetAttributeValue("href", $"{request.Scheme}://{request.Host}{request.Path}");
atomLink.SetAttributeValue("rel", "self");
atomLink.SetAttributeValue("type", "application/rss+xml");
return(new List <XElement>
{
atomLink,
new XElement("title", contentItem.DisplayText),
new XElement("link", contentPart?.Get <TextField>(Constants.RssFeed.LinkFieldName)?.Text),
new XElement("description", contentPart?.Get <TextField>(Constants.RssFeed.DescriptionFieldName)?.Text)
});
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(contentItem, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.Name;
var partTypeName = contentTypePartDefinition.PartDefinition.Name;
var partActivator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = contentItem.Get(partActivator.Type, partName) as ContentPart;
if (part != null)
{
foreach (var displayDriver in _partDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentTypePartDefinition, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
}
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
foreach (var displayDriver in _fieldDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentPartFieldDefinition, contentTypePartDefinition, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
}
}
}
public async Task UpdateEditorAsync(ContentItem contentItem, UpdateEditorContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
dynamic contentShape = context.Shape;
dynamic partsShape = context.ShapeFactory.Create("Zone", Arguments.Empty);
contentShape.Zones["Parts"] = partsShape;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.UpdateEditorAsync(contentItem, context);
if (result != null)
{
result.Apply(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(UpdateEditorAsync));
}
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var activator = _contentPartFactory.GetTypeActivator(typePartDefinition.Name);
var part = (ContentPart)contentItem.Get(activator.Type, typePartDefinition.Name) ?? activator.CreateInstance();
part.ContentItem = contentItem;
// Create a custom shape to render all the part shapes into it
dynamic typePartShape = context.ShapeFactory.Create("ContentPart_Edit", Arguments.Empty);
typePartShape.ContentPart = part;
typePartShape.ContentTypePartDefinition = typePartDefinition;
var partPosition = typePartDefinition.Settings["Position"]?.ToString() ?? "before";
partsShape.Add(typePartShape, partPosition);
partsShape[typePartDefinition.Name] = typePartShape;
context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => new PlacementInfo {
Location = $"Parts.{typePartDefinition.Name}"
};
await _partDisplayDrivers.InvokeAsync(async contentDisplay =>
{
var result = await contentDisplay.UpdateEditorAsync(part, typePartDefinition, context);
if (result != null)
{
result.Apply(context);
}
}, Logger);
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
var fieldPosition = partFieldDefinition.Settings["Position"]?.ToString() ?? "before";
context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => new PlacementInfo {
Location = $"Parts.{typePartDefinition.Name}:{fieldPosition}"
};
await _fieldDisplayDrivers.InvokeAsync(async contentDisplay =>
{
var result = await contentDisplay.UpdateEditorAsync(part, partFieldDefinition, typePartDefinition, context);
if (result != null)
{
result.Apply(context);
}
}, Logger);
}
}
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, _logger, displayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
var settings = contentTypeDefinition?.GetSettings <ContentTypeSettings>();
var stereotype = settings?.Stereotype ?? String.Empty;
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.Name;
var partTypeName = contentTypePartDefinition.PartDefinition.Name;
var partActivator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = contentItem.Get(partActivator.Type, partName) as ContentPart;
if (part == null)
{
continue;
}
var contentType = contentTypePartDefinition.ContentTypeDefinition.Name;
var partDisplayDrivers = _contentPartDisplayDriverResolver.GetDisplayModeDrivers(partTypeName, contentTypePartDefinition.DisplayMode());
foreach (var partDisplayDriver in partDisplayDrivers)
{
try
{
var result = await partDisplayDriver.BuildDisplayAsync(part, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, _logger, partDisplayDrivers.GetType().Name, nameof(BuildDisplayAsync));
}
}
var tempContext = context;
// Create a custom ContentPart shape that will hold the fields for dynamic content part (not implicit parts)
// This allows its fields to be grouped and templated
if (part.GetType() == typeof(ContentPart) && partTypeName != contentTypePartDefinition.ContentTypeDefinition.Name)
{
var shapeType = context.DisplayType != "Detail" ? "ContentPart_" + context.DisplayType : "ContentPart";
var shapeResult = new ShapeResult(shapeType, ctx => ctx.ShapeFactory.CreateAsync(shapeType, () => new ValueTask <IShape>(new ZoneHolding(() => ctx.ShapeFactory.CreateAsync("Zone")))));
shapeResult.Differentiator(partName);
shapeResult.Name(partName);
shapeResult.Location("Content");
shapeResult.OnGroup(context.GroupId);
shapeResult.Displaying(ctx =>
{
var displayTypes = new[] { String.Empty, "_" + ctx.Shape.Metadata.DisplayType };
foreach (var displayType in displayTypes)
{
// eg. ServicePart, ServicePart.Summary
ctx.Shape.Metadata.Alternates.Add($"{partTypeName}{displayType}");
// [ContentType]_[DisplayType]__[PartType]
// e.g. LandingPage-ServicePart, LandingPage-ServicePart.Summary
ctx.Shape.Metadata.Alternates.Add($"{contentType}{displayType}__{partTypeName}");
if (!String.IsNullOrEmpty(stereotype))
{
// [Stereotype]_[DisplayType]__[PartType],
// e.g. Widget-ServicePart
ctx.Shape.Metadata.Alternates.Add($"{stereotype}{displayType}__{partTypeName}");
}
}
if (partTypeName == partName)
{
return;
}
foreach (var displayType in displayTypes)
{
// [ContentType]_[DisplayType]__[PartName]
// e.g. Employee-Address1, Employee-Address2
ctx.Shape.Metadata.Alternates.Add($"{contentType}{displayType}__{partName}");
if (!String.IsNullOrEmpty(stereotype))
{
// [Stereotype]_[DisplayType]__[PartType]__[PartName]
// e.g. Widget-Services
ctx.Shape.Metadata.Alternates.Add($"{stereotype}{displayType}__{partTypeName}__{partName}");
}
}
});
await shapeResult.ApplyAsync(context);
var contentPartShape = shapeResult.Shape;
// Make the ContentPart name property available on the shape
contentPartShape.Properties[partTypeName] = part.Content;
contentPartShape.Properties["ContentItem"] = part.ContentItem;
context = new BuildDisplayContext(shapeResult.Shape, context.DisplayType, context.GroupId, context.ShapeFactory, context.Layout, context.Updater)
{
// With a new display context we have the default FindPlacementDelegate that returns null, so we reuse the delegate from the temp context.
FindPlacement = tempContext.FindPlacement,
};
}
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
var fieldDisplayDrivers = _contentFieldDisplayDriverResolver.GetDisplayModeDrivers(contentPartFieldDefinition.FieldDefinition.Name, contentPartFieldDefinition.DisplayMode());
foreach (var fieldDisplayDriver in fieldDisplayDrivers)
{
try
{
var result = await fieldDisplayDriver.BuildDisplayAsync(part, contentPartFieldDefinition, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, _logger, fieldDisplayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
}
context = tempContext;
}
}
public async Task UpdateEditorAsync(ContentItem contentItem, UpdateEditorContext context)
{
var contentTypeDefinition = _contentDefinitionManager.LoadTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
var contentShape = context.Shape as IZoneHolding;
var partsShape = await context.ShapeFactory.CreateAsync("ContentZone",
Arguments.From(new
{
Identifier = contentItem.ContentItemId
}));
contentShape.Zones["Parts"] = partsShape;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.UpdateEditorAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, _logger, displayDriver.GetType().Name, nameof(UpdateEditorAsync));
}
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var partTypeName = typePartDefinition.PartDefinition.Name;
var partName = typePartDefinition.Name;
var contentType = typePartDefinition.ContentTypeDefinition.Name;
var activator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = (ContentPart)contentItem.Get(activator.Type, partName) ?? activator.CreateInstance();
var partPosition = typePartDefinition.GetSettings <ContentTypePartSettings>().Position ?? "before";
part.ContentItem = contentItem;
// Create a custom shape to render all the part shapes into it
var typePartShapeResult = CreateShapeResult(context.GroupId, partTypeName, contentType, typePartDefinition, partPosition);
await typePartShapeResult.ApplyAsync(context);
var typePartShape = typePartShapeResult.Shape;
if (typePartShape == null)
{
// Part is explicitly hidden in placement then stop rendering it
continue;
}
typePartShape.Properties["ContentPart"] = part;
typePartShape.Properties["ContentTypePartDefinition"] = typePartDefinition;
partsShape.Properties[partName] = typePartShape;
context.DefaultZone = $"Parts.{partName}:{partPosition}";
var partDisplayDrivers = _contentPartDisplayDriverResolver.GetEditorDrivers(partTypeName, typePartDefinition.Editor());
await partDisplayDrivers.InvokeAsync(async (driver, part, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, typePartDefinition, context, _logger);
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
var fieldPosition = partFieldDefinition.GetSettings <ContentPartFieldSettings>().Position ?? "before";
context.DefaultZone = $"Parts.{partName}:{fieldPosition}";
var fieldDisplayDrivers = _contentFieldDisplayDriverResolver.GetEditorDrivers(partFieldDefinition.FieldDefinition.Name, partFieldDefinition.Editor());
await fieldDisplayDrivers.InvokeAsync(async (driver, part, partFieldDefinition, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, partFieldDefinition, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, partFieldDefinition, typePartDefinition, context, _logger);
}
}
}
protected async Task <IList <XElement> > CreateItemsAsync(ContentItem contentItem, IEnumerable <ContentItem> contentItems, ActionContext actionContext)
{
var delay = contentItem.Get <ContentPart>(Constants.RssFeed.ContentType)?.Get <NumericField>(Constants.RssFeed.DelayFieldName)?.Value ?? 0;
return(await Task.WhenAll(contentItems.Where(x => ShouldInclude(x, delay)).Select(x => CreateItemAsync(x, actionContext))));
}
private async Task <bool> ImportRowAsync(ImportRedirectRow row)
{
if (!ValidateRow(row))
{
return(false);
}
var existing = await _session.Query <ContentItem>()
.With <RedirectPartIndex>(x => x.Url == row.FromUrl)
.ListAsync();
ContentItem redirectItem = null;
var newItem = false;
if (existing.Any())
{
redirectItem = existing.FirstOrDefault(x => x.Published);
}
if (redirectItem == null)
{
redirectItem = await _contentManager.NewAsync(Constants.RedirectContentType);
redirectItem.Owner = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.CreatedUtc = DateTime.UtcNow;
newItem = true;
}
if (redirectItem == null)
{
return(false);
}
var redirectPart = redirectItem.Get <RedirectPart>(nameof(RedirectPart));
if (redirectPart == null)
{
return(false);
}
redirectItem.Author = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.DisplayText = row.Title;
redirectPart.FromUrl = row.FromUrl?.Trim();
redirectPart.ToUrl = row.ToUrl?.Trim();
redirectPart.IsPermanent = true;
redirectPart.Apply();
redirectItem.Apply(nameof(RedirectPart), redirectPart);
ContentExtensions.Apply(redirectItem, redirectItem);
if (newItem)
{
await _contentManager.CreateAsync(redirectItem);
}
else
{
await _contentManager.UpdateAsync(redirectItem);
}
await _contentManager.PublishAsync(redirectItem);
return(true);
}
private void SetupTagCloudLoader(ContentItem item)
{
var cloudPart = (LocalizedTagCloudPart)item.Get(typeof(LocalizedTagCloudPart));
cloudPart._tags.Loader(() => _tagsService.GetLocalizedTags().ToList());
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.Name;
var partTypeName = contentTypePartDefinition.PartDefinition.Name;
var contentType = contentTypePartDefinition.ContentTypeDefinition.Name;
var partActivator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = contentItem.Get(partActivator.Type, partName) as ContentPart;
if (part != null)
{
var partDisplayDrivers = _contentPartDisplayDriverResolver.GetDisplayModeDrivers(partTypeName, contentTypePartDefinition.DisplayMode());
foreach (var partDisplayDriver in partDisplayDrivers)
{
try
{
var result = await partDisplayDriver.BuildDisplayAsync(part, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, partDisplayDrivers.GetType().Name, nameof(BuildDisplayAsync));
}
}
// TODO: This can be removed in a future release as the recommended way is to use ContentOptions.
// Iteratate existing driver registrations as multiple drivers maybe not be registered with ContentOptions.
foreach (var displayDriver in _partDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
var tempContext = context;
// Create a custom ContentPart shape that will hold the fields for dynamic content part (not implicit parts)
// This allows its fields to be grouped and templated
if (part.GetType() == typeof(ContentPart) && partTypeName != contentTypePartDefinition.ContentTypeDefinition.Name)
{
var shapeType = context.DisplayType != "Detail" ? "ContentPart_" + context.DisplayType : "ContentPart";
var shapeResult = new ShapeResult(shapeType, ctx => ctx.ShapeFactory.CreateAsync(shapeType, () => new ValueTask <IShape>(new ZoneHolding(() => ctx.ShapeFactory.CreateAsync("Zone")))));
shapeResult.Differentiator(partName);
shapeResult.Location("Content");
await shapeResult.ApplyAsync(context);
var contentPartShape = shapeResult.Shape;
// Make the ContentPart name property available on the shape
dynamic dynamicContentPartShape = contentPartShape;
dynamicContentPartShape[partTypeName] = part.Content;
dynamicContentPartShape["ContentItem"] = part.ContentItem;
contentPartShape.Metadata.Alternates.Add(partTypeName);
contentPartShape.Metadata.Alternates.Add($"{contentType}__{partTypeName}");
if (context.DisplayType != "Detail")
{
contentPartShape.Metadata.Alternates.Add($"{partTypeName}_{context.DisplayType}");
contentPartShape.Metadata.Alternates.Add($"{contentType}_{context.DisplayType}__{partTypeName}");
}
if (partName != partTypeName)
{
contentPartShape.Metadata.Alternates.Add($"{contentType}__{partName}");
if (context.DisplayType != "Detail")
{
contentPartShape.Metadata.Alternates.Add($"{contentType}_{context.DisplayType}__{partName}");
}
}
context = new BuildDisplayContext(shapeResult.Shape, context.DisplayType, context.GroupId, context.ShapeFactory, context.Layout, context.Updater);
}
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
var fieldDisplayDrivers = _contentFieldDisplayDriverResolver.GetDisplayModeDrivers(contentPartFieldDefinition.FieldDefinition.Name, contentPartFieldDefinition.DisplayMode());
foreach (var fieldDisplayDriver in fieldDisplayDrivers)
{
try
{
var result = await fieldDisplayDriver.BuildDisplayAsync(part, contentPartFieldDefinition, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, fieldDisplayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
// TODO: This can be removed in a future release as the recommended way is to use ContentOptions.
// Iteratate existing driver registrations as multiple drivers maybe not be registered with ContentOptions.
foreach (var displayDriver in _fieldDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentPartFieldDefinition, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(BuildDisplayAsync));
}
}
}
context = tempContext;
}
}
}
public async Task UpdateEditorAsync(ContentItem contentItem, UpdateEditorContext context)
{
var contentTypeDefinition = _contentDefinitionManager.LoadTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
dynamic contentShape = context.Shape;
dynamic partsShape = await context.ShapeFactory.CreateAsync("ContentZone",
Arguments.From(new
{
ContentItem = contentItem
}));
contentShape.Zones["Parts"] = partsShape;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.UpdateEditorAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(UpdateEditorAsync));
}
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var partTypeName = typePartDefinition.PartDefinition.Name;
var activator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = (ContentPart)contentItem.Get(activator.Type, typePartDefinition.Name) ?? activator.CreateInstance();
part.ContentItem = contentItem;
// Create a custom shape to render all the part shapes into it
dynamic typePartShape = await context.ShapeFactory.CreateAsync("ContentPart_Edit");
typePartShape.ContentPart = part;
typePartShape.ContentTypePartDefinition = typePartDefinition;
var partPosition = typePartDefinition.GetSettings <ContentTypePartSettings>().Position ?? "before";
partsShape.Add(typePartShape, partPosition);
partsShape[typePartDefinition.Name] = typePartShape;
context.DefaultZone = $"Parts.{typePartDefinition.Name}:{partPosition}";
var partDisplayDrivers = _contentPartDisplayDriverResolver.GetEditorDrivers(partTypeName, typePartDefinition.Editor());
await partDisplayDrivers.InvokeAsync(async (driver, part, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, typePartDefinition, context, Logger);
// TODO: This can be removed in a future release as the recommended way is to use ContentOptions.
// Iteratate existing driver registrations as multiple drivers maybe not be registered with ContentOptions.
await _partDisplayDrivers.InvokeAsync(async (driver, part, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, typePartDefinition, context, Logger);
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
var fieldPosition = partFieldDefinition.GetSettings <ContentPartFieldSettings>().Position ?? "before";
context.DefaultZone = $"Parts.{typePartDefinition.Name}:{fieldPosition}";
var fieldDisplayDrivers = _contentFieldDisplayDriverResolver.GetEditorDrivers(partFieldDefinition.FieldDefinition.Name, partFieldDefinition.Editor());
await fieldDisplayDrivers.InvokeAsync(async (driver, part, partFieldDefinition, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, partFieldDefinition, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, partFieldDefinition, typePartDefinition, context, Logger);
// TODO: This can be removed in a future release as the recommended way is to use ContentOptions.
// Iteratate existing driver registrations as multiple drivers maybe not be registered with ContentOptions.
await _fieldDisplayDrivers.InvokeAsync(async (driver, part, partFieldDefinition, typePartDefinition, context) =>
{
var result = await driver.UpdateEditorAsync(part, partFieldDefinition, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, partFieldDefinition, typePartDefinition, context, Logger);
}
}
}
public Task Process(ContentItem contentItem, Func<ContentPart, string, Task> action)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
return Task.CompletedTask;
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
// Abort if there are not fields in this part
if (!typePartDefinition.PartDefinition.Fields.Any())
{
continue;
}
var partName = typePartDefinition.PartDefinition.Name;
ContentPartInfo partInfo;
_partInfos.TryGetValue(partName, out partInfo);
ContentPart part = partInfo != null
? partInfo.Factory(typePartDefinition)
: new ContentPart();
part = contentItem.Get(part.GetType(), partName) as ContentPart;
if(part == null)
{
return Task.CompletedTask;
}
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
return action(part, fieldName);
}
}
return Task.CompletedTask;
}
public async Task BuildDisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
foreach (var contentTypePartDefinition in contentTypeDefinition.Parts)
{
var partName = contentTypePartDefinition.Name;
var partTypeName = contentTypePartDefinition.PartDefinition.Name;
var partActivator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = contentItem.Get(partActivator.Type, partName) as ContentPart;
if (part != null)
{
foreach (var displayDriver in _partDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
var tempContext = context;
// Create a custom ContentPart shape that will hold the fields for dynamic content part (not implicit parts)
// This allows its fields to be grouped and templated
if (part.GetType() == typeof(ContentPart) && contentTypePartDefinition.PartDefinition.Name != contentTypePartDefinition.ContentTypeDefinition.Name)
{
var shapeType = context.DisplayType != "Detail" ? "ContentPart_" + context.DisplayType : "ContentPart";
var shapeResult = new ShapeResult(shapeType, ctx => ctx.ShapeFactory.CreateAsync(shapeType, () => Task.FromResult <IShape>(new ZoneHolding(() => ctx.ShapeFactory.CreateAsync("Zone", Arguments.Empty)))));
shapeResult.Differentiator(contentTypePartDefinition.PartDefinition.Name);
shapeResult.Location("Content");
await shapeResult.ApplyAsync(context);
var contentPartShape = shapeResult.Shape;
// Make the ContentPart name property available on the shape
dynamic dynamicContentPartShape = contentPartShape;
dynamicContentPartShape[contentTypePartDefinition.PartDefinition.Name] = part.Content;
dynamicContentPartShape["ContentItem"] = part.ContentItem;
contentPartShape.Metadata.Alternates.Add(contentTypePartDefinition.PartDefinition.Name);
if (context.DisplayType != "Detail")
{
contentPartShape.Metadata.Alternates.Add($"{contentTypePartDefinition.PartDefinition.Name}_{context.DisplayType}");
}
context = new BuildDisplayContext(shapeResult.Shape, context.DisplayType, context.GroupId, context.ShapeFactory, context.Layout, context.Updater);
}
foreach (var contentPartFieldDefinition in contentTypePartDefinition.PartDefinition.Fields)
{
foreach (var displayDriver in _fieldDisplayDrivers)
{
try
{
var result = await displayDriver.BuildDisplayAsync(part, contentPartFieldDefinition, contentTypePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, "BuildDisplayAsync");
}
}
}
context = tempContext;
}
}
}
public async Task BuildEditorAsync(ContentItem contentItem, BuildEditorContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
dynamic contentShape = context.Shape;
dynamic partsShape = await context.ShapeFactory.CreateAsync("ContentZone",
Arguments.From(new
{
ContentItem = contentItem
}));
contentShape.Zones["Parts"] = partsShape;
foreach (var displayDriver in _displayDrivers)
{
try
{
var result = await displayDriver.BuildEditorAsync(contentItem, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}
catch (Exception ex)
{
InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(BuildEditorAsync));
}
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var partTypeName = typePartDefinition.PartDefinition.Name;
var activator = _contentPartFactory.GetTypeActivator(partTypeName);
var part = (ContentPart)contentItem.Get(activator.Type, typePartDefinition.Name) ?? activator.CreateInstance();
part.ContentItem = contentItem;
// Create a custom shape to render all the part shapes into it
dynamic typePartShape = await context.ShapeFactory.CreateAsync("ContentPart_Edit");
typePartShape.ContentPart = part;
typePartShape.ContentTypePartDefinition = typePartDefinition;
var partPosition = typePartDefinition.GetSettings <ContentTypePartSettings>().Position ?? "before";
partsShape.Add(typePartShape, partPosition);
partsShape[typePartDefinition.Name] = typePartShape;
context.DefaultZone = $"Parts.{typePartDefinition.Name}";
context.DefaultPosition = partPosition;
await _partDisplayDrivers.InvokeAsync(async (driver, part, typePartDefinition, context) =>
{
var result = await driver.BuildEditorAsync(part, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, typePartDefinition, context, Logger);
foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields)
{
var fieldName = partFieldDefinition.Name;
var fieldPosition = partFieldDefinition.GetSettings <ContentPartFieldSettings>().Position ?? "before";
context.DefaultZone = $"Parts.{typePartDefinition.Name}:{fieldPosition}";
await _fieldDisplayDrivers.InvokeAsync(async (driver, part, partFieldDefinition, typePartDefinition, context) =>
{
var result = await driver.BuildEditorAsync(part, partFieldDefinition, typePartDefinition, context);
if (result != null)
{
await result.ApplyAsync(context);
}
}, part, partFieldDefinition, typePartDefinition, context, Logger);
}
}
}
