public static ContentPartDefinitionBuilder WithTaxonomyField(
this ContentPartDefinitionBuilder builder,
string fieldName,
string taxonomyName,
bool required = false,
bool leavesOnly = false,
bool singleChoice = false,
bool autocomplete = false,
bool allowCustomTerms = false,
string hint = "")
{
var displayName = fieldName.SplitCamel();
// default implementation of Media library picker field - create overloads for more options
return(builder.WithField(
fieldName,
fieldBuilder =>
fieldBuilder.OfType("TaxonomyField")
.WithDisplayName(displayName)
.WithSetting("TaxonomyFieldSettings.Taxonomy", taxonomyName)
.WithSetting("TaxonomyFieldSettings.Required", required.ToString(CultureInfo.InvariantCulture))
.WithSetting("TaxonomyFieldSettings.LeavesOnly", leavesOnly.ToString(CultureInfo.InvariantCulture))
.WithSetting("TaxonomyFieldSettings.SingleChoice", singleChoice.ToString(CultureInfo.InvariantCulture))
.WithSetting("TaxonomyFieldSettings.Autocomplete", autocomplete.ToString(CultureInfo.InvariantCulture))
.WithSetting("TaxonomyFieldSettings.AllowCustomTerms", allowCustomTerms.ToString(CultureInfo.InvariantCulture))
.WithSetting("TaxonomyFieldSettings.Hint", hint)));
}
public static ContentPartDefinitionBuilder WithTextField(this ContentPartDefinitionBuilder p, string name, string displayName, string position)
{
return(p.WithField(name, f => f
.OfType(nameof(TextField))
.WithDisplayName(displayName)
.WithPosition(position)
));
}
public static ContentPartDefinitionBuilder WithSwitchBooleanField(this ContentPartDefinitionBuilder p, string name, string displayName, string position)
{
return(p.WithField(name, f => f
.OfType(nameof(BooleanField))
.WithEditor("Switch")
.WithDisplayName(displayName)
.WithPosition(position)
));
}
public static ContentPartDefinitionBuilder WithBooleanField(this ContentPartDefinitionBuilder p, string name, string displayName, string position, BooleanFieldSettings settings)
{
return(p.WithField(name, f => f
.OfType(nameof(BooleanField))
.WithDisplayName(displayName)
.WithPosition(position)
.WithSettings(settings)
));
}
public static ContentPartDefinitionBuilder WithTextFieldPredefinedList(this ContentPartDefinitionBuilder p, string name, string displayName, string position, TextFieldPredefinedListEditorSettings settings)
{
return(p.WithField(name, f => f
.OfType(nameof(TextField))
.WithDisplayName(displayName)
.WithEditor("PredefinedList")
.WithPosition(position)
.WithSettings(settings)
));
}
public static ContentPartDefinitionBuilder WithTeamCaptainField(this ContentPartDefinitionBuilder p, string position)
{
return(p.WithField("TeamCaptain", f => f
.OfType(nameof(UserPickerField))
.WithDisplayName("Team Captain")
.WithPosition(position)
.WithSettings(new UserPickerFieldSettings()
{
DisplayedRoles = new string[] { "Hacker" }
})
));
}
public static ContentPartDefinitionBuilder WithChallengeField(this ContentPartDefinitionBuilder p, string position)
{
return(p.WithField("Challenge", f => f
.OfType(nameof(ContentPickerField))
.WithDisplayName("Challenge")
.WithPosition(position)
.WithSettings(new ContentPickerFieldSettings()
{
DisplayedContentTypes = new string[] { "Challenge" }
})
));
}
public static ContentPartDefinitionBuilder WithMarkdownField(this ContentPartDefinitionBuilder p, string name, string displayName, string hint, string position)
{
return(p.WithField(name, f => f
.OfType(nameof(MarkdownField))
.WithEditor("Wysiwyg")
.WithDisplayName(displayName)
.WithPosition(position)
.WithSettings(new MarkdownFieldSettings()
{
Hint = hint
})
));
}
public static ContentPartDefinitionBuilder WithBooleanField(
this ContentPartDefinitionBuilder builder,
string name,
bool @default,
string hint = "")
{
return(builder.WithField(
name,
fieldBuilder =>
fieldBuilder.OfType("BooleanField")
.WithSetting("BooleanFieldSettings.Hint", hint)
.WithSetting("BooleanFieldSettings.DefaultValue", @default.ToString(CultureInfo.InvariantCulture))));
}
public static ContentPartDefinitionBuilder WithMultiValueTextField(this ContentPartDefinitionBuilder p, string name, string displayName, string position, ListValueOption[] options, MultiValueEditorOption editor = MultiValueEditorOption.Dropdown)
{
return(p.WithField(name, field => field
.OfType("MultiValueTextField")
.WithDisplayName(displayName)
.WithEditor("PredefinedList")
.WithPosition(position)
.WithSettings(new MultiValueTextFieldEditorSettings
{
Options = options,
Editor = editor
})
));
}
public static ContentPartDefinitionBuilder WithTextField(
this ContentPartDefinitionBuilder builder,
string name,
Flavour flavor,
bool required = true,
string hint = "")
{
var strFlavor = flavor.ToString().SplitCamel();
return(builder.WithField(
name,
fieldBuilder =>
fieldBuilder.OfType("TextField")
.WithSetting("TextFieldSettings.Required", required.ToString(CultureInfo.InvariantCulture))
.WithSetting("TextFieldSettings.Flavor", strFlavor)
.WithSetting("TextFieldSettings.Hint", hint)));
}
/// <summary>
/// Merges a given content part definition provided in a XML format into a content part definition builder.
/// </summary>
/// <param name="element">The XML content type definition.</param>
/// <param name="contentPartDefinitionBuilder">The content part definition builder.</param>
public void Merge(XElement element, ContentPartDefinitionBuilder contentPartDefinitionBuilder)
{
Argument.ThrowIfNull(element, nameof(element));
Argument.ThrowIfNull(contentPartDefinitionBuilder, nameof(contentPartDefinitionBuilder));
// Merge name
contentPartDefinitionBuilder.Named(XmlConvert.DecodeName(element.Name.LocalName));
// Merge settings
foreach (var setting in _settingsFormatter.Map(element))
{
contentPartDefinitionBuilder.WithSetting(setting.Key, setting.Value);
}
// Merge fields
foreach (var iter in element.Elements())
{
var fieldElement = iter;
var fieldParameters = XmlConvert.DecodeName(fieldElement.Name.LocalName).Split(new[] { '.' }, 2);
var fieldName = fieldParameters.FirstOrDefault();
var fieldType = fieldParameters.Skip(1).FirstOrDefault();
if (fieldName == "remove")
{
var nameAttribute = fieldElement.Attribute("name");
if (nameAttribute != null)
{
contentPartDefinitionBuilder.RemoveField(nameAttribute.Value);
}
}
else
{
contentPartDefinitionBuilder.WithField(
fieldName,
fieldBuilder =>
{
fieldBuilder.OfType(fieldType);
foreach (var setting in _settingsFormatter.Map(fieldElement))
{
fieldBuilder.WithSetting(setting.Key, setting.Value);
}
});
}
}
}
public static ContentPartDefinitionBuilder WithMediaLibraryPickerField(
this ContentPartDefinitionBuilder builder,
string name,
bool required = true,
bool multiple = false,
string hint = "",
string displayedContentTypes = "jpg jpeg png gif")
{
var displayName = name.SplitCamel();
// default implementation of Media library picker field - create overloads for more options
return(builder.WithField(
name,
fieldBuilder =>
fieldBuilder.OfType("MediaLibraryPickerField")
.WithDisplayName(displayName)
.WithSetting("MediaLibraryPickerFieldSettings.Required", required.ToString(CultureInfo.InvariantCulture))
.WithSetting("MediaLibraryPickerFieldSettings.DisplayedContentTypes", displayedContentTypes)
.WithSetting("MediaLibraryPickerFieldSettings.Multiple", multiple.ToString(CultureInfo.InvariantCulture))
.WithSetting("MediaLibraryPickerFieldSettings.Hint", hint)));
}
public static ContentPartDefinitionBuilder WithContentPickerField(
this ContentPartDefinitionBuilder builder,
string name,
string hint = null,
bool isRequired = false,
bool allowMultiple = false,
bool showContentTab = true,
string[] displayedContentTypes = null)
{
var displayName = name.SplitCamel();
var contentTypes = displayedContentTypes != null?string.Join(",", displayedContentTypes) : null;
return(builder.WithField(
name,
cfg => cfg.OfType(typeof(ContentPickerField).Name)
.WithDisplayName(displayName)
.WithSetting("ContentPickerFieldSettings.Hint", hint)
.WithSetting("ContentPickerFieldSettings.Required", isRequired.ToString(CultureInfo.InvariantCulture))
.WithSetting("ContentPickerFieldSettings.Multiple", allowMultiple.ToString(CultureInfo.InvariantCulture))
.WithSetting("ContentPickerFieldSettings.ShowContentTab", showContentTab.ToString(CultureInfo.InvariantCulture))
.WithSetting("ContentPickerFieldSettings.DisplayedContentTypes", contentTypes)));
}
public static ContentPartDefinitionBuilder WithLinkField(
this ContentPartDefinitionBuilder builder,
string fieldName,
string displayName = null,
bool required = false,
TargetMode targetMode = TargetMode.None,
LinkTextMode linkTextMode = LinkTextMode.Optional,
string hint = "")
{
return(builder.WithField(
fieldName,
fieldBuilder => {
fieldBuilder.OfType("LinkField")
.WithSetting("LinkFieldSettings.Hint", hint)
.WithSetting("LinkFieldSettings.Required", required.ToString(CultureInfo.InvariantCulture))
.WithSetting("LinkFieldSettings.TargetMode", targetMode.ToString())
.WithSetting("LinkFieldSettings.LinkTextMode", linkTextMode.ToString());
if (displayName.HasValue())
{
fieldBuilder.WithDisplayName(displayName);
}
}));
}
