public ProductAttributeTests()
{
parser = new ProductAttributeProvider();
partDefinition = new ContentPartDefinition("Product");
boolFieldDefinition = new ContentPartFieldDefinition(
new ContentFieldDefinition(nameof(BooleanProductAttributeField)),
"BooleanField", new JObject())
{
PartDefinition = partDefinition
};
numericFieldDefinition = new ContentPartFieldDefinition(
new ContentFieldDefinition(nameof(NumericProductAttributeField)),
"NumericField", new JObject())
{
PartDefinition = partDefinition
};
textFieldDefinition = new ContentPartFieldDefinition(
new ContentFieldDefinition(nameof(TextProductAttributeField)),
"TextField", new JObject())
{
PartDefinition = partDefinition
};
partTypeDefinition = new ContentTypePartDefinition("product", partDefinition, new JObject());
}
public override IEnumerable <TemplateViewModel> TypePartEditor(ContentTypePartDefinition definition)
{
if (definition.PartDefinition.Name == "WidgetsContainerPart")
{
var model = definition.Settings.GetModel <WidgetsContainerSettings>();
var currentTheme = _siteThemeService.GetSiteTheme();
var allowedViewModel = new WidgetsContainerSettingsViewModel();
allowedViewModel.SelectedZones = model.AllowedZones != null?model.AllowedZones.Split(',') : new string[]
{
};
allowedViewModel.Zones = _widgetsService.GetZones(currentTheme).ToList();
allowedViewModel.SelectedWidgets = model.AllowedWidgets != null?model.AllowedWidgets.Split(',') : new string[]
{
};
allowedViewModel.Widgets = _widgetsService.GetWidgetTypeNames().OrderBy(o => o).ToList();
allowedViewModel.UseHierarchicalAssociation = model.UseHierarchicalAssociation;
allowedViewModel.HierarchicalAssociationJson = model.HierarchicalAssociationJson;
allowedViewModel.TryToLocalizeItems = model.TryToLocalizeItems;
yield return(DefinitionTemplate(allowedViewModel));
}
}
async Task <IDisplayResult> IContentPartDisplayDriver.UpdateEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(null);
}
using (BuildPrefix(typePartDefinition, context.HtmlFieldPrefix))
{
var updateEditorContext = new UpdatePartEditorContext(typePartDefinition, context);
_typePartDefinition = typePartDefinition;
var result = await UpdateAsync(part, context.Updater, updateEditorContext);
part.ContentItem.Apply(typePartDefinition.Name, part);
_typePartDefinition = null;
return(result);
}
}
public PartConfigurerImpl(ContentTypePartDefinition part)
: base(part)
{
Current = part;
_partDefinition = part.PartDefinition;
}
public UpdatePartEditorContext(ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
: base(typePartDefinition, context)
{
}
protected ContentTypePartDefinitionBuilder(ContentTypePartDefinition part)
{
Name = part.PartDefinition.Name;
_settings = new SettingsDictionary(part.Settings.ToDictionary(kv => kv.Key, kv => kv.Value));
}
public virtual IEnumerable <TemplateViewModel> TypePartEditor(ContentTypePartDefinition definition)
{
return(Enumerable.Empty <TemplateViewModel>());
}
protected string GetEditorShapeType(ContentTypePartDefinition typePartDefinition)
{
return(GetEditorShapeType(typeof(TPart).Name + "_Edit", typePartDefinition));
}
public override IEnumerable <TemplateViewModel> TypePartEditor(ContentTypePartDefinition definition)
{
if (definition.PartDefinition.Name != "AutoroutePart")
{
yield break;
}
var settings = definition.Settings.GetModel <AutorouteSettings>();
// Get cultures
settings.SiteCultures = _cultureManager.ListCultures().ToList();
// Get default site culture
settings.DefaultSiteCulture = _cultureManager.GetSiteCulture();
// Adding Patterns for the UI
List <RoutePattern> newPatterns = new List <RoutePattern>();
// Adding a null culture for the culture neutral pattern
var cultures = new List <string>();
cultures.Add(null);
cultures.AddRange(settings.SiteCultures);
foreach (string culture in cultures)
{
// Adding all existing patterns for the culture
newPatterns.AddRange(
settings.Patterns.Where(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase))
);
// Adding a pattern for each culture if there is none
if (!settings.Patterns.Where(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)).Any())
{
newPatterns.Add(new RoutePattern {
Culture = culture, Name = "Title", Description = "my-title", Pattern = "{Content.Slug}"
});
}
// Adding a new empty line for each culture
newPatterns.Add(new RoutePattern {
Culture = culture, Name = null, Description = null, Pattern = null
});
// If the content type has no defaultPattern for autoroute, assign one
var defaultPatternExists = false;
if (String.IsNullOrEmpty(culture))
{
defaultPatternExists = settings.DefaultPatterns.Any(x => String.IsNullOrEmpty(x.Culture));
}
else
{
defaultPatternExists = settings.DefaultPatterns.Any(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase));
}
if (!defaultPatternExists)
{
// If in the default culture check the old setting
if (String.Equals(culture, _cultureManager.GetSiteCulture(), StringComparison.OrdinalIgnoreCase))
{
var defaultPatternIndex = settings.DefaultPatternIndex;
if (!String.IsNullOrWhiteSpace(defaultPatternIndex))
{
var patternIndex = defaultPatternIndex;
settings.DefaultPatterns.Add(new DefaultPattern {
Culture = settings.DefaultSiteCulture, PatternIndex = patternIndex
});
}
else
{
settings.DefaultPatterns.Add(new DefaultPattern {
PatternIndex = "0", Culture = culture
});
}
}
else
{
settings.DefaultPatterns.Add(new DefaultPattern {
PatternIndex = "0", Culture = culture
});
}
}
}
settings.Patterns = newPatterns;
yield return(DefinitionTemplate(settings));
}
private RelationshipDataModel TransformContentTypePartDefinitionToRelationship(ContentTypePartDefinition contentTypePartDefinition, string linkFromName, string linkToName)
{
var relationshipDataModel = new RelationshipDataModel
{
Id = linkToName,
Label = contentTypePartDefinition.PartDefinition.GetSettings <ContentPartSettings>()?.Description ?? contentTypePartDefinition.Name,
Domain = linkFromName,
Range = linkToName,
};
return(relationshipDataModel);
}
public EditTypePartViewModel(int index, ContentTypePartDefinition part)
{
PartName = part.PartName;
}
public override IDisplayResult Edit(ContentTypePartDefinition model, IUpdateModel updater)
{
return(Shape("ContentTypePartSettings_Edit", new ShapeViewModel <ContentTypePartDefinition>(model)).Location("Content"));
}
private IEnumerable <ContentTypeDefinition> GetContainedContentTypes(ContentTypePartDefinition typePartDefinition)
{
var settings = typePartDefinition.GetSettings <BagPartSettings>();
return(settings.ContainedContentTypes.Select(contentType => _contentDefinitionManager.GetTypeDefinition(contentType)));
}
public override IEnumerable <TemplateViewModel> TypePartEditor(ContentTypePartDefinition definition)
{
if (definition.PartDefinition.Name != "AutoroutePart")
{
yield break;
}
var settings = definition.Settings.GetModel <AutorouteSettings>();
//get cultures
settings.SiteCultures = _cultureManager.ListCultures().ToList();
//get default site culture
settings.DefaultSiteCulture = _cultureManager.GetSiteCulture();
//if a culture is not set on the pattern we set it to the default site culture for backward compatibility
if (!settings.Patterns.Any(x => String.Equals(x.Culture, settings.DefaultSiteCulture, StringComparison.OrdinalIgnoreCase)))
{
foreach (RoutePattern pattern in settings.Patterns.Where(x => String.IsNullOrWhiteSpace(x.Culture)))
{
settings.Patterns.Where(x => x.GetHashCode() == pattern.GetHashCode()).FirstOrDefault().Culture = settings.DefaultSiteCulture;
}
}
//Adding Patterns for the UI
List <RoutePattern> newPatterns = new List <RoutePattern>();
int current = 0;
foreach (string culture in settings.SiteCultures)
{
foreach (RoutePattern routePattern in settings.Patterns.Where(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)))
{
if (settings.Patterns.Any(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)))
{
newPatterns.Add(settings.Patterns[current]);
}
else
{
newPatterns.Add(new RoutePattern {
Name = "Title",
Description = "my-title",
Pattern = "{Content.Slug}",
Culture = settings.DefaultSiteCulture
});
}
current++;
}
//We add a pattern for each culture if there is none
if (!settings.Patterns.Where(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)).Any())
{
newPatterns.Add(new RoutePattern {
Culture = culture, Name = "Title", Description = "my-title", Pattern = "{Content.Slug}"
});
}
//we add a new empty line for each culture
newPatterns.Add(new RoutePattern {
Culture = culture, Name = null, Description = null, Pattern = null
});
// if the content type has no defaultPattern for autoroute, then assign one
if (!settings.DefaultPatterns.Any(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)))
{
//if we are in the default culture check the old setting
if (String.Equals(culture, _cultureManager.GetSiteCulture(), StringComparison.OrdinalIgnoreCase))
{
var defaultPatternIndex = settings.DefaultPatternIndex;
if (!String.IsNullOrWhiteSpace(defaultPatternIndex))
{
var patternIndex = defaultPatternIndex;
settings.DefaultPatterns.Add(new DefaultPattern {
Culture = settings.DefaultSiteCulture, PatternIndex = patternIndex
});
}
else
{
settings.DefaultPatterns.Add(new DefaultPattern {
PatternIndex = "0", Culture = culture
});
}
}
else
{
settings.DefaultPatterns.Add(new DefaultPattern {
PatternIndex = "0", Culture = culture
});
}
}
}
settings.Patterns = newPatterns;
yield return(DefinitionTemplate(settings));
}
Task <IDisplayResult> IContentFieldDisplayDriver.BuildDisplayAsync(ContentPart contentPart, ContentPartFieldDefinition partFieldDefinition, ContentTypePartDefinition typePartDefinition, BuildDisplayContext context)
{
if (!string.Equals(typeof(TField).Name, partFieldDefinition.FieldDefinition.Name) &&
!string.Equals(nameof(ContentField), partFieldDefinition.FieldDefinition.Name))
{
return(Task.FromResult(default(IDisplayResult)));
}
var field = contentPart.Get <TField>(partFieldDefinition.Name);
if (field != null)
{
BuildPrefix(typePartDefinition, partFieldDefinition, context.HtmlFieldPrefix);
var fieldDisplayContext = new BuildFieldDisplayContext(contentPart, typePartDefinition, partFieldDefinition, context);
_typePartDefinition = typePartDefinition;
_partFieldDefinition = partFieldDefinition;
var result = DisplayAsync(field, fieldDisplayContext);
_typePartDefinition = null;
_partFieldDefinition = null;
return(result);
}
return(Task.FromResult(default(IDisplayResult)));
}
protected ContentTypePartDefinitionBuilder(ContentTypePartDefinition part)
{
Name = part.PartDefinition.Name;
TypeName = part.ContentTypeDefinition != null ? part.ContentTypeDefinition.Name : default(string);
_settings = new SettingsDictionary(part.Settings.ToDictionary(kv => kv.Key, kv => kv.Value));
}
private async Task <IEnumerable <ContentTypeDefinition> > GetContainedContentTypesAsync(IContentDefinitionManager contentDefinitionManager, ContentTypePartDefinition typePartDefinition)
{
var settings = typePartDefinition.GetSettings <BagPartSettings>();
var contentTypes = settings.ContainedContentTypes
.Select(contentType => _contentDefinitionManager.GetTypeDefinition(contentType))
.Where(contentType => contentType != null);
var accessibleContentTypes = new List <ContentTypeDefinition>();
foreach (var contentType in contentTypes)
{
var dummyContent = await _contentManager.NewAsync(contentType.Name);
dummyContent.Owner = GetCurrentOwner();
if (!await AuthorizeAsync(contentDefinitionManager, CommonPermissions.EditContent, dummyContent))
{
continue;
}
accessibleContentTypes.Add(contentType);
}
return(accessibleContentTypes);
}
private async Task BuildViewModel(MarkdownBodyPartViewModel model, MarkdownBodyPart MarkdownBodyPart, ContentTypePartDefinition definition)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(MarkdownBodyPart.ContentItem.ContentType);
var contentTypePartDefinition = contentTypeDefinition.Parts.FirstOrDefault(p => p.PartDefinition.Name == nameof(MarkdownBodyPart));
var settings = contentTypePartDefinition.GetSettings <MarkdownBodyPartSettings>();
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", MarkdownBodyPart.ContentItem);
templateContext.MemberAccessStrategy.Register <MarkdownBodyPartViewModel>();
var markdown = await _liquidTemplatemanager.RenderAsync(MarkdownBodyPart.Markdown, System.Text.Encodings.Web.HtmlEncoder.Default, templateContext);
model.Html = Markdig.Markdown.ToHtml(markdown ?? "");
model.ContentItem = MarkdownBodyPart.ContentItem;
model.Source = MarkdownBodyPart.Markdown;
model.MarkdownBodyPart = MarkdownBodyPart;
model.TypePartDefinition = definition;
}
private Task BuildViewModel(TaxonomyMenuItemPartEditViewModel model, TaxonomyMenuItemPart part, ContentTypePartDefinition definition)
{
model.Name = part.Name;
model.TaxonomyContentItemId = part.TaxonomyContentItemId;
model.TaxonomyMenuItemPart = part;
model.TypePartDefinition = definition;
return(Task.CompletedTask);
}
async Task <IDisplayResult> IContentPartDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, BuildEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(null);
}
using (BuildPrefix(typePartDefinition, context.HtmlFieldPrefix))
{
_typePartDefinition = typePartDefinition;
var buildEditorContext = new BuildPartEditorContext(typePartDefinition, context);
var result = await EditAsync(part, buildEditorContext);
_typePartDefinition = null;
return(result);
}
}
public ContentTypePartDefinitionBuilderMock(ContentTypePartDefinition part)
: base(part)
{
}
private void Apply(ContentTypePartDefinition model, ContentTypePartDefinitionRecord record)
{
record.Settings = Compose(_settingsFormatter.Map(model.Settings));
}
public UpdateFieldEditorContext(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, ContentPartFieldDefinition partFieldDefinition, UpdateEditorContext context)
: base(contentPart, typePartDefinition, partFieldDefinition, context)
{
}
private static ShapeResult CreateShapeResult(string groupId, string partTypeName, string contentType, ContentTypePartDefinition typePartDefinition, string partPosition)
{
var shapeType = "ContentPart_Edit";
var partName = typePartDefinition.Name;
var typePartShapeResult = new ShapeResult(shapeType, ctx => ctx.ShapeFactory.CreateAsync(shapeType));
typePartShapeResult.Differentiator($"{contentType}-{partName}");
typePartShapeResult.Name(partName);
typePartShapeResult.Location($"Parts:{partPosition}");
typePartShapeResult.OnGroup(groupId);
typePartShapeResult.Displaying(ctx =>
{
// ContentPart_Edit__[PartType]
// eg ContentPart-ServicePart.Edit
ctx.Shape.Metadata.Alternates.Add($"{shapeType}__{partTypeName}");
// ContentPart_Edit__[ContentType]__[PartType]
// e.g. ContentPart-LandingPage-ServicePart.Edit
ctx.Shape.Metadata.Alternates.Add($"{shapeType}__{contentType}__{partTypeName}");
var isNamedPart = typePartDefinition.PartDefinition.IsReusable() && partName != partTypeName;
if (isNamedPart)
{
// ContentPart_Edit__[ContentType]__[PartName]
// e.g. ContentPart-LandingPage-BillingService.Edit ContentPart-LandingPage-HelplineService.Edit
ctx.Shape.Metadata.Alternates.Add($"{shapeType}__{contentType}__{partName}");
}
});
return(typePartShapeResult);
}
Task <IDisplayResult> IContentPartDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, BuildEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
BuildPrefix(typePartDefinition, context.HtmlFieldPrefix);
var buildEditorContext = new BuildPartEditorContext(typePartDefinition, context);
return(EditAsync(part, buildEditorContext));
}
public BuildPartEditorContext(ContentTypePartDefinition typePartDefinition, BuildEditorContext context)
: base(context.Shape, context.GroupId, "", context.ShapeFactory, context.Layout, context.Updater)
{
TypePartDefinition = typePartDefinition;
}
Task <IDisplayResult> IContentPartDisplayDriver.UpdateEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
BuildPrefix(typePartDefinition, context.HtmlFieldPrefix);
var updateEditorContext = new UpdatePartEditorContext(typePartDefinition, context);
var result = UpdateAsync(part, context.Updater, updateEditorContext);
part.ContentItem.Apply(typePartDefinition.Name, part);
return(result);
}
public BuildPartDisplayContext(ContentTypePartDefinition typePartDefinition, BuildDisplayContext context)
: base(context.Shape, context.DisplayType, context.GroupId, context.ShapeFactory, context.Layout, context.Updater)
{
TypePartDefinition = typePartDefinition;
}
public EditTypePartViewModel(int index, ContentTypePartDefinition part) {
Index = index;
PartDefinition = new EditPartViewModel(part.PartDefinition);
Settings = part.Settings;
_Definition = part;
}
private void Apply(ContentTypePartDefinition model, ContentTypePartDefinitionRecord record)
{
record.Settings = model.Settings;
}
private async Task BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart HtmlBodyPart, ContentTypePartDefinition definition)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(HtmlBodyPart.ContentItem.ContentType);
var contentTypePartDefinition = contentTypeDefinition.Parts.FirstOrDefault(p => p.Name == nameof(HtmlBodyPart));
var settings = contentTypePartDefinition.GetSettings <HtmlBodyPartSettings>();
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", HtmlBodyPart.ContentItem);
templateContext.MemberAccessStrategy.Register <HtmlBodyPartViewModel>();
model.Html = await _liquidTemplatemanager.RenderAsync(HtmlBodyPart.Html, HtmlEncoder.Default, templateContext);
model.ContentItem = HtmlBodyPart.ContentItem;
model.Source = HtmlBodyPart.Html;
model.HtmlBodyPart = HtmlBodyPart;
model.TypePartDefinition = definition;
}
