public static ContentTypeDefinition Import(this IContentDefinitionReader reader, XElement source)
{
var target = new ContentTypeDefinitionBuilder();
reader.Merge(source, target);
return(target.Build());
}
public override void TypeEditorUpdating(ContentTypeDefinitionBuilder definition)
{
var contentType = _contentDefinitionService.GetType(definition.Current.Name);
_oldContentTypeDisplayName = contentType.DisplayName;
_oldContentTypeSettings = new SettingsDictionary(contentType.Settings);
}
public void ExistingTypeAndPartDefinitionShouldBeUsed()
{
var alphaType = new ContentTypeDefinitionBuilder()
.Named(DefaultAlphaName)
.WithSetting("x", "1")
.WithPart("foo")
.WithPart("FlavoredPart", part => part.WithSetting("spin", "clockwise"))
.Build();
_contentDefinitionManager
.Setup(x => x.GetTypeDefinition(DefaultAlphaName))
.Returns(alphaType);
var contentItem = _manager.New(DefaultAlphaName);
Assert.That(contentItem.ContentType, Is.EqualTo(DefaultAlphaName));
Assert.That(contentItem.TypeDefinition, Is.Not.Null);
Assert.That(contentItem.TypeDefinition, Is.SameAs(alphaType));
var flavored = contentItem.As <FlavoredPart>();
Assert.That(flavored, Is.Not.Null);
Assert.That(flavored.TypePartDefinition, Is.Not.Null);
Assert.That(flavored.TypePartDefinition.Settings["spin"], Is.EqualTo("clockwise"));
}
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new ContentTypeSettings();
updateModel.TryUpdateModel(model, "ContentTypeSettings", null, null);
yield return(DefinitionTemplate(model));
}
public void GetContentTypesShouldReturnAllTypes()
{
// Register the types and obtain them
ContentTypeDefinition alphaType = new ContentTypeDefinitionBuilder()
.Named(DefaultAlphaName)
.Build();
ContentTypeDefinition betaType = new ContentTypeDefinitionBuilder()
.Named(DefaultBetaName)
.Build();
ContentTypeDefinition gammaType = new ContentTypeDefinitionBuilder()
.Named(DefaultGammaName)
.Build();
ContentTypeDefinition deltaType = new ContentTypeDefinitionBuilder()
.Named(DefaultDeltaName)
.Build();
_contentDefinitionManager.Setup(contentDefinitionManager => contentDefinitionManager.ListTypeDefinitions())
.Returns(new List <ContentTypeDefinition> {
alphaType, betaType, gammaType, deltaType
});
var types = _manager.GetContentTypeDefinitions();
// Validate that the expected types were obtained
Assert.That(types.Count(), Is.EqualTo(4));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultAlphaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultBetaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultGammaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultDeltaName));
}
public override void TypeEditorUpdated(ContentTypeDefinitionBuilder builder)
{
var contentTypeDefinition = builder.Build();
var newDisplayName = contentTypeDefinition.DisplayName;
var newSettings = contentTypeDefinition.Settings;
if (newDisplayName != _oldContentTypeDisplayName)
{
var eventData = new Dictionary <string, object> {
{ "ContentTypeName", builder.Current.Name },
{ "OldDisplayName", _oldContentTypeDisplayName },
{ "NewDisplayName", newDisplayName }
};
RecordContentTypeAuditTrail(ContentTypeAuditTrailEventProvider.TypeDisplayNameUpdated, eventData, contentTypeDefinition.Name);
}
if (!AreEqual(newSettings, _oldContentTypeSettings))
{
var eventData = new Dictionary <string, object> {
{ "ContentTypeName", builder.Current.Name },
{ "OldSettings", ToXml(_oldContentTypeSettings) },
{ "NewSettings", ToXml(newSettings) }
};
RecordContentTypeAuditTrail(ContentTypeAuditTrailEventProvider.TypeSettingsUpdated, eventData, contentTypeDefinition.Name);
}
}
private ContentPart CreateContentItemPart()
{
var partDefinition = FooPartDefinition();
var typeDefinition = new ContentTypeDefinitionBuilder()
.WithPart(partDefinition, part => { })
.Build();
_contentItem = new ContentItem {
VersionRecord = new ContentItemVersionRecord {
ContentItemRecord = new ContentItemRecord(),
Published = false
}
};
var contentPart = new ContentPart {
TypePartDefinition = typeDefinition.Parts.Single()
};
_contentItem.Weld(contentPart);
_contentItem.Weld(new InfosetPart {
Infoset = _contentItem.Record.Infoset,
VersionInfoset = _contentItem.VersionRecord.Infoset
});
_contentItem.Weld(new FieldIndexPart {
Record = new FieldIndexPartRecord()
});
return(contentPart);
}
public override void TypeEditorUpdating(ContentTypeDefinitionBuilder builder)
{
if (!TypeHasIdentity(builder.Current))
{
builder.WithPart("IdentityPart");
}
}
public void CanAlterPartSettingsByNameDuringRebuild()
{
var contentTypeDefinition1 = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithPart("foo", pb => pb.WithSetting("x", "10").WithSetting("y", "11"))
.Build();
var contentTypeDefinition2 = new ContentTypeDefinitionBuilder(contentTypeDefinition1)
.WithPart("foo", pb => pb.WithSetting("x", "12").WithSetting("z", "13"))
.Build();
Assert.That(contentTypeDefinition1.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition1.Parts.Count(), Is.EqualTo(1));
Assert.That(contentTypeDefinition1.Parts.Single().PartDefinition.Name, Is.EqualTo("foo"));
Assert.That(contentTypeDefinition1.Parts.Single().Settings.Count(), Is.EqualTo(2));
Assert.That(contentTypeDefinition1.Parts.Single().Settings["x"], Is.EqualTo("10"));
Assert.That(contentTypeDefinition1.Parts.Single().Settings["y"], Is.EqualTo("11"));
Assert.That(contentTypeDefinition2.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition2.Parts.Count(), Is.EqualTo(1));
Assert.That(contentTypeDefinition2.Parts.Single().PartDefinition.Name, Is.EqualTo("foo"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings.Count(), Is.EqualTo(3));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["x"], Is.EqualTo("12"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["y"], Is.EqualTo("11"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["z"], Is.EqualTo("13"));
}
public async Task <ContentItem> NewAsync(string contentType)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentType);
if (contentTypeDefinition == null)
{
contentTypeDefinition = new ContentTypeDefinitionBuilder().Named(contentType).Build();
}
// create a new kernel for the model instance
var context = new ActivatingContentContext
{
ContentType = contentTypeDefinition.Name,
Definition = contentTypeDefinition,
Builder = new ContentItemBuilder(contentTypeDefinition)
};
// invoke handlers to weld aspects onto kernel
await Handlers.InvokeAsync((handler, context) => handler.ActivatingAsync(context), context, _logger);
var context2 = new ActivatedContentContext(context.Builder.Build());
context2.ContentItem.ContentItemId = _idGenerator.GenerateUniqueId(context2.ContentItem);
await ReversedHandlers.InvokeAsync((handler, context2) => handler.ActivatedAsync(context2), context2, _logger);
var context3 = new InitializingContentContext(context2.ContentItem);
await Handlers.InvokeAsync((handler, context3) => handler.InitializingAsync(context3), context3, _logger);
await ReversedHandlers.InvokeAsync((handler, context3) => handler.InitializedAsync(context3), context3, _logger);
// composite result is returned
return(context3.ContentItem);
}
/// <summary>
/// This extension method can be used for easy widget creation. Adds all necessary parts and settings to the part.
/// </summary>
/// <returns>The ContentTypeDefinitionBuilder object on which this method is called.</returns>
public static ContentTypeDefinitionBuilder AsWidget(this ContentTypeDefinitionBuilder builder)
{
return(builder
.WithPart("CommonPart")
.WithPart("WidgetPart")
.WithSetting("Stereotype", "Widget"));
}
public static void AlterTypeDefinition(this IContentDefinitionManager manager, string name, Action <ContentTypeDefinitionBuilder> alteration)
{
var typeDefinition = manager.LoadTypeDefinition(name) ?? new ContentTypeDefinition(name, name.CamelFriendly());
var builder = new ContentTypeDefinitionBuilder(typeDefinition);
alteration(builder);
manager.StoreTypeDefinition(builder.Build());
}
public static ContentTypeDefinitionBuilder WithMarkdownBody(this ContentTypeDefinitionBuilder t, string position)
{
return(t.WithPart(nameof(MarkdownBodyPart), p => {
p.WithPosition(position);
p.WithDisplayName("Markdown Body");
p.WithEditor("Wysiwyg");
}));
}
public static ContentTypeDefinitionBuilder WithContainablePart(this ContentTypeDefinitionBuilder builder, bool showContainerPicker = false, bool showPositionEditor = false)
{
return(builder.WithPart(
typeof(ContainablePart).Name,
cfg => cfg
.WithSetting("ContainableTypePartSettings.ShowContainerPicker", showContainerPicker.ToString())
.WithSetting("ContainableTypePartSettings.ShowPositionEditor", showPositionEditor.ToString())));
}
public static ContentTypeDefinitionBuilder WithBodyPart(
this ContentTypeDefinitionBuilder builder,
Flavour defaultFlavour = Flavour.Html)
{
return(builder.WithPart(
typeof(BodyPart).Name,
partBuilder => partBuilder.WithSetting("BodyTypePartSettings.Flavor", defaultFlavour.ToString())));
}
/// <summary>
/// This extension method can be used for easy media part creation. Adds all necessary parts and settings to the part.
/// </summary>
public static ContentTypeDefinitionBuilder AsMedia(this ContentTypeDefinitionBuilder builder)
{
return(builder
.WithSetting("Stereotype", "Media")
.WithPart("CommonPart")
.WithPart("MediaPart")
.WithPart("TitlePart"));
}
public virtual ContentItem Get(int id, VersionOptions options, QueryHints hints, string contentType)
{
ContentItem contentItem;
ContentItemVersionRecord versionRecord = null;
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentType);
if (contentTypeDefinition == null)
{
contentTypeDefinition = new ContentTypeDefinitionBuilder().Named(contentType).Build();
}
if (hints == QueryHints.Empty)
{
hints = new QueryHints();
}
hints = hints.ExpandRecords(contentTypeDefinition.Parts.Select(c => c.PartDefinition.Name + "Record"));
// do a query to load the records in case Get is called directly
contentItem = GetContentItem(hints, contentTypeDefinition,
(contentItemCriteria, contentItemVersionCriteria) =>
{
contentItemCriteria.Add(Restrictions.Eq("Id", id));
if (options.IsPublished)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Published", true));
}
else if (options.IsLatest)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItemVersionCriteria.Add(
Restrictions.And(Restrictions.Eq("Published", false),
Restrictions.Eq("Latest", true)));
}
else if (options.IsDraft || options.IsDraftRequired)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
if (options.VersionNumber != default(int))
{
contentItemVersionCriteria.Add(Restrictions.Eq("VersionNumber", options.VersionNumber));
}
contentItemVersionCriteria.SetFetchMode("ContentItemRecord", FetchMode.Eager);
contentItemVersionCriteria.SetFetchMode("ContentItemRecord.ContentType", FetchMode.Eager);
contentItemVersionCriteria.SetMaxResults(1);
});
FinalizeContentItem(contentItem, options, contentType);
return(contentItem);
}
public void AttributesAreAppliedAsSettings()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo", new XAttribute("x", "1")), builder);
var type = builder.Build();
Assert.That(type.Settings["x"], Is.EqualTo("1"));
}
public void ReadingElementSetsName()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo"), builder);
var type = builder.Build();
Assert.That(type.Name, Is.EqualTo("foo"));
}
public static IUser Create(string role) {
var simulationType = new ContentTypeDefinitionBuilder().Named("User").Build();
var simulation = new ContentItemBuilder(simulationType)
.Weld<SimulatedUser>()
.Weld<SimulatedUserRoles>()
.Build();
simulation.As<SimulatedUserRoles>().Roles = new[] {role};
return simulation.As<IUser>();
}
public static async Task AlterTypeDefinitionAsync(this IContentDefinitionManager manager, string name, Func <ContentTypeDefinitionBuilder, Task> alterationAsync)
{
var typeDefinition = manager.LoadTypeDefinition(name) ?? new ContentTypeDefinition(name, name.CamelFriendly());
var builder = new ContentTypeDefinitionBuilder(typeDefinition);
await alterationAsync(builder);
manager.StoreTypeDefinition(builder.Build());
}
public ISite GetSiteSettings()
{
var siteType = new ContentTypeDefinitionBuilder().Named("Site").Build();
var site = new ContentItemBuilder(siteType)
.Weld <SafeModeSite>()
.Build();
return(site.As <ISite>());
}
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new ExperimentalSettings();
updateModel.TryUpdateModel(model, "ExperimentalSettings", null, null);
builder
.WithSetting("ExperimentalSettings.ShowDebugLinks", model.ShowDebugLinks ? true.ToString() : null);
yield return(DefinitionTemplate(model));
}
public void ChildElementsAreAddedAsPartsWithSettings()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo", new XElement("bar", new XAttribute("y", "2"))), builder);
var type = builder.Build();
Assert.That(type.Parts.Single().PartDefinition.Name, Is.EqualTo("bar"));
Assert.That(type.Parts.Single().Settings["y"], Is.EqualTo("2"));
}
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new SecurableContentItemsSettingsViewModel();
updateModel.TryUpdateModel(model, "SecurableContentItemsSettingsViewModel", null, null);
builder.WithSetting("ContentPermissionsTypeSettings.SecurableContentItems", model.SecurableContentItems.ToString());
yield return(DefinitionTemplate(model));
}
public static ContentTypeDefinitionBuilder WithTitlePart(this ContentTypeDefinitionBuilder t, string position, TitlePartOptions options = TitlePartOptions.Editable, string pattern = "")
{
return(t.WithPart(nameof(TitlePart), p => p
.WithPosition(position)
.WithSettings(new TitlePartSettings()
{
Options = options, Pattern = pattern
})
));
}
/// <summary>
/// Removes any custom placement for a specific shape
/// </summary>
public static ContentTypeDefinitionBuilder ResetPlacement(this ContentTypeDefinitionBuilder builder, PlacementType placementType, string shapeType, string differentiator)
{
var serializer = new JavaScriptSerializer();
var placementSettings = GetPlacement(builder.Build(), placementType).ToList();
placementSettings = placementSettings.Where(x => x.ShapeType != shapeType && x.Differentiator != differentiator).ToList();
var placement = serializer.Serialize(placementSettings.ToArray());
return(builder.WithSetting("ContentTypeSettings.Placement." + placementType, placement));
}
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new TypeIndexing();
updateModel.TryUpdateModel(model, "TypeIndexing", null, null);
builder.WithSetting("TypeIndexing.Indexes", model.Indexes);
CreateIndexingTasks();
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new ContentTypeSettingsViewModel();
updateModel.TryUpdateModel(model, "ContentTypeSettingsViewModel", null, null);
builder.Creatable(model.Creatable);
builder.Draftable(model.Draftable);
builder.WithSetting("Stereotype", model.Stereotype);
yield return(DefinitionTemplate(model));
}
public static ContentTypeDefinitionBuilder WithContentPermission(this ContentTypeDefinitionBuilder t, string position, string redirectUrl = null)
{
return(t.WithPart(nameof(ContentPermissionsPart), p => {
p.WithPosition(position);
if (redirectUrl != null)
{
p.WithSettings(new ContentPermissionsPartSettings()
{
RedirectUrl = redirectUrl
});
}
}));
}
