public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
// working on GDPRPart
if (builder.Name != "GDPRPart")
{
yield break;
}
var vm = new GDPRPartTypeSchedulingSettingsViewModel();
if (updateModel.TryUpdateModel(vm, "GDPRPartTypeSchedulingSettingsViewModel", null, null))
{
var ok = true;
if (vm.Settings.ScheduleAnonymization && vm.Settings.AnonymizationDaysToWait <= 0)
{
// days must be positive
_notifier.Error(T("Days to wait before anonymization must be greater than zero. Scheduler configuration failed."));
ok = false;
}
if (vm.Settings.ScheduleErasure && vm.Settings.ErasureDaysToWait <= 0)
{
// days must be positive
_notifier.Error(T("Days to wait before erasure must be greater than zero. Scheduler configuration failed."));
ok = false;
}
if (ok)
{
var settings = vm.Settings;
GDPRPartTypeSchedulingSettings.SetValues(builder, settings);
// update scheduled tasks
_GDPRScheduleManager.UpdateSchedule(builder.TypeName, settings);
}
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(
ContentTypePartDefinitionBuilder builder,
IUpdateModel updateModel)
{
if (builder.Name == "SeoPart")
{
var model = new SeoPartSettings();
updateModel.TryUpdateModel(model, "SeoPartSettings", null, null);
builder.WithSetting("SeoPartSettings.RobotsNoIndex", model.RobotsNoIndex.ToString());
builder.WithSetting("SeoPartSettings.RobotsNoFollow", model.RobotsNoFollow.ToString());
builder.WithSetting("SeoPartSettings.RobotsNoSnippet", model.RobotsNoSnippet.ToString());
builder.WithSetting("SeoPartSettings.RobotsNoOdp", model.RobotsNoOdp.ToString());
builder.WithSetting("SeoPartSettings.RobotsNoArchive", model.RobotsNoArchive.ToString());
builder.WithSetting("SeoPartSettings.RobotsUnavailableAfter", model.RobotsUnavailableAfter.ToString());
builder.WithSetting("SeoPartSettings.RobotsNoImageIndex", model.RobotsNoImageIndex.ToString());
builder.WithSetting("SeoPartSettings.GoogleNoSiteLinkSearchBox", model.GoogleNoSiteLinkSearchBox.ToString());
builder.WithSetting("SeoPartSettings.GoogleNoTranslate", model.GoogleNoTranslate.ToString());
if (model.CanonicalUrl != null)
{
builder.WithSetting("SeoPartSettings.CanonicalUrl", model.CanonicalUrl.ToString());
}
else
{
builder.WithSetting("SeoPartSettings.CanonicalUrl", "");
}
builder.WithSetting("SeoPartSettings.JsonLd", model.JsonLd != null ? model.JsonLd.ToString() : "");
builder.WithSetting("SeoPartSettings.ShowAggregatedMicrodata", model.ShowAggregatedMicrodata.ToString());
yield return(DefinitionTemplate(model));
}
yield break;
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "BundlePart")
{
yield break;
}
if (ShouldProcessSettings(_contentDefinitionManager.GetTypeDefinition(builder.TypeName)))
{
var settings = new BundleProductLocalizationSettings();
if (updateModel.TryUpdateModel(settings, "BundleProductLocalizationSettings", null, null))
{
builder
.WithSetting("BundleProductLocalizationSettings.TryToLocalizeProducts",
settings.TryToLocalizeProducts.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("BundleProductLocalizationSettings.RemoveProductsWithoutLocalization",
settings.RemoveProductsWithoutLocalization.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("BundleProductLocalizationSettings.AddProductQuantitiesWhenLocalizing",
settings.AddProductQuantitiesWhenLocalizing.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("BundleProductLocalizationSettings.AssertProductsHaveSameCulture",
settings.AssertProductsHaveSameCulture.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("BundleProductLocalizationSettings.HideProductsFromEditor",
settings.HideProductsFromEditor.ToString(CultureInfo.InvariantCulture));
}
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != TerritoryHierarchyPart.PartName)
{
yield break;
}
var vm = new TerritoryHierarchyPartSettingsViewModel();
if (updateModel.TryUpdateModel(vm, "TerritoryHierarchyPartSettingsViewModel", null, null))
{
var settings = vm.Settings;
if (!_territoriesService.GetTerritoryTypes().Select(tt => tt.Name).Contains(settings.TerritoryType))
{
// we are not allowed to manage the type we are trying to assign so error things out
updateModel.AddModelError("TerritoryType", T("The type {0} is not allowed.", settings.TerritoryType));
}
else
{
builder
.WithSetting("TerritoryHierarchyPartSettings.TerritoryType",
settings.TerritoryType);
}
builder
.WithSetting("TerritoryHierarchyPartSettings.MayChangeTerritoryTypeOnItem",
settings.MayChangeTerritoryTypeOnItem.ToString(CultureInfo.InvariantCulture));
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(
ContentTypePartDefinitionBuilder builder,
IUpdateModel updateModel)
{
if (builder.Name != "ActivityPart")
{
yield break;
}
var model = new ActivityPartSettings();
updateModel.TryUpdateModel(model, "ActivityPartSettings", null, null);
builder.WithSetting("ActivityPartSettings.UseRecurrences",
((bool)model.UseRecurrences).ToString());
builder.WithSetting("ActivityPartSettings.SingleDate",
((bool)model.SingleDate).ToString());
builder.WithSetting("ActivityPartSettings.DateTimeType",
((DateTimeTypes)model.DateTimeType).ToString());
builder.WithSetting("ActivityPartSettings.DateStartLabel",
model.DateStartLabel != null ? model.DateStartLabel.ToString() : "");
builder.WithSetting("ActivityPartSettings.DateEndLabel",
model.DateEndLabel != null ? model.DateEndLabel.ToString() : "");
builder.WithSetting("ActivityPartSettings.ActivityPartLabel",
model.ActivityPartLabel != null ? model.ActivityPartLabel.ToString() : "");
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "OutputCachePart")
{
yield break;
}
var settings = new OutputCachePartSettings
{
};
if (updateModel.TryUpdateModel(settings, "OutputCachePartSettings", null, null))
{
builder.WithSetting("OutputCachePartSettings.EnableCache", settings.EnableCache.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.CacheDuration", settings.CacheDuration.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.CacheGraceTime", settings.CacheGraceTime.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.AllowOverride", settings.AllowOverride.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.VaryByQueryStringParameters", settings.VaryByQueryStringParameters);
builder.WithSetting("OutputCachePartSettings.VaryByRequestHeaders", settings.VaryByRequestHeaders);
builder.WithSetting("OutputCachePartSettings.VaryByCulture", settings.VaryByCulture.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.VaryByAuthenticationState", settings.VaryByAuthenticationState.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.VaryByUser", settings.VaryByUser.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("OutputCachePartSettings.VaryByUrl", settings.VaryByUrl.ToString(CultureInfo.InvariantCulture));
}
yield return(DefinitionTemplate(settings));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(
ContentTypePartDefinitionBuilder builder,
IUpdateModel updateModel)
{
if (builder.Name != "MailchimpSubscriptionPart")
{
yield break;
}
var model = new MailchimpSubscriptionPartSettings();
updateModel.TryUpdateModel(model, PREFIX, null, null);
builder.WithSetting("MailchimpSubscriptionPartSettings.AudienceId",
model.AudienceId);
builder.WithSetting("MailchimpSubscriptionPartSettings.PutPayload",
model.PutPayload);
builder.WithSetting("MailchimpSubscriptionPartSettings.MemberEmail",
model.MemberEmail);
builder.WithSetting("MailchimpSubscriptionPartSettings.PolicyTextReferences",
model.PolicyTextReferences != null && model.PolicyTextReferences.Count() > 0 ? string.Join(",", model.PolicyTextReferences) : null);
builder.WithSetting("MailchimpSubscriptionPartSettings.NotifySubscriptionResult",
model.NotifySubscriptionResult.ToString());
yield return(DefinitionTemplate(model, TEMPLATE_NAME, PREFIX));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(
ContentTypePartDefinitionBuilder builder,
IUpdateModel updateModel)
{
if (builder.Name != "PolicyPart")
{
yield break;
}
var model = new PolicyPartSettings();
updateModel.TryUpdateModel(model, "PolicyPartSettings", null, null);
if (model.PolicyTextReferences == null || model.PolicyTextReferences.Length == 0)
{
model.PolicyTextReferences = new string[] { "{All}" };
}
else if (model.PolicyTextReferences.Contains("{All}"))
{
model.PolicyTextReferences = new string[] { "{All}" };
}
else if (model.PolicyTextReferences.Contains("{DependsOnContent}"))
{
model.PolicyTextReferences = new string[] { "{DependsOnContent}" };
}
builder.WithSetting("PolicyPartSettings.IncludePendingPolicy",
((IncludePendingPolicyOptions)model.IncludePendingPolicy).ToString());
builder.WithSetting("PolicyPartSettings.PolicyTextReferences",
String.Join(",", model.PolicyTextReferences));
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "ProductAttributesPart")
{
yield break;
}
if (ShouldProcessSettings(_contentDefinitionManager.GetTypeDefinition(builder.TypeName)))
{
var settings = new ProductAttributeLocalizationSettings();
if (updateModel.TryUpdateModel(settings, "ProductAttributeLocalizationSettings", null, null))
{
builder
.WithSetting("ProductAttributeLocalizationSettings.TryToLocalizeAttributes",
settings.TryToLocalizeAttributes.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("ProductAttributeLocalizationSettings.RemoveAttributesWithoutLocalization",
settings.RemoveAttributesWithoutLocalization.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("ProductAttributeLocalizationSettings.AssertAttributesHaveSameCulture",
settings.AssertAttributesHaveSameCulture.ToString(CultureInfo.InvariantCulture));
builder
.WithSetting("ProductAttributeLocalizationSettings.HideAttributesFromEditor",
settings.HideAttributesFromEditor.ToString(CultureInfo.InvariantCulture));
}
yield return(DefinitionTemplate(settings));
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(
ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(builder.TypeName);
if (_typeHasConfigPart ||
typeDefinition.Parts.Any(ctpd => ctpd.PartDefinition.Name == "FrontendEditConfigurationPart"))
{
_typeHasConfigPart = true;
var settings = new FrontendEditorConfigurationSettings();
if (updateModel.TryUpdateModel(settings, "FrontendEditorConfigurationSettings", null, null))
{
FrontendEditorConfigurationSettings.SetValues(builder, settings.AllowFrontEndEdit);
// Update the type settings
var partDefinition = typeDefinition.Parts
.FirstOrDefault(ctpd => ctpd.PartDefinition.Name == builder.Name)?.PartDefinition;
if (partDefinition != null) // sanity check
// At this stage, the settings in the PartDefinition are not updated, so the IFrontEndProfileService
// has no way of knowing whether the value of settings.AllowFrontEndEdit has changed. We need to
// pass it along to be used.
{
var partPlacements = GetEditorPlacement(typeDefinition, partDefinition, settings.AllowFrontEndEdit);
if (partPlacements.Any())
{
UpdateFrontEndPlacements(typeDefinition, partPlacements);
//// schedules a re-evaluation of the shell
//_settingsManagerEventHandlers.Value.Invoke(x => x.Saved(_shellSettings), Logger);
}
}
}
yield return(DefinitionTemplate(settings));
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "ConnectorPart")
{
yield break;
}
var model = new ConnectorTypePartSettings();
updateModel.TryUpdateModel(model, "ConnectorTypePartSettings", null, null);
builder.WithSetting("ConnectorTypePartSettings.AllowMany", model.AllowMany.ToString());
builder.WithSetting("ConnectorTypePartSettings.AllowNone", model.AllowNone.ToString());
builder.WithSetting("ConnectorTypePartSettings.AllowDuplicates", model.AllowDuplicates.ToString());
builder.WithSetting("ConnectorTypePartSettings.AllowedContentLeft", model.AllowedContentLeft);
builder.WithSetting("ConnectorTypePartSettings.AllowedContentRight", model.AllowedContentRight);
builder.WithSetting("ConnectorTypePartSettings.InverseConnectorType", model.InverseConnectorType);
builder.WithSetting("ConnectorTypePartSettings.DefaultParadigms", model.DefaultParadigms);
builder.WithSetting("ConnectorTypePartSettings.SocketDisplayName", model.SocketDisplayName);
builder.WithSetting("ConnectorTypePartSettings.SocketEditorHint", model.SocketEditorHint);
builder.WithSetting("ConnectorTypePartSettings.SocketDisplayHint", model.SocketDisplayHint);
builder.WithSetting("ConnectorTypePartSettings.SocketDisplayType", model.SocketDisplayType);
builder.WithSetting("ConnectorTypePartSettings.SocketGroupName", model.SocketGroupName);
builder.WithSetting("ConnectorTypePartSettings.ConnectorDisplayType", model.ConnectorDisplayType);
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != mPartName)
{
yield break;
}
var vm = new ItemLevelCacheContentDefinitionSettingsVm();
if (updateModel.TryUpdateModel(vm, Constants.ContentTypeDefinitionSettingsKey, null, null))
{
if (!String.IsNullOrWhiteSpace(vm.NewDisplayType))
{
if (vm.Settings.ContainsKey(vm.NewDisplayType))
{
mNotifier.Warning(T("The display type {0} has already been configured for {1}.", vm.NewDisplayType, builder.TypeName));
yield return(GetTemplateViewModel(vm));
}
vm.Settings[vm.NewDisplayType] = new ItemLevelCacheSettings();
}
BuildSettings(vm, builder);
}
yield return(GetTemplateViewModel(vm));
}
public override void TypePartEditorUpdating(ContentTypePartDefinitionBuilder builder)
{
var contentTypeDefinition = _contentDefinitionService.GetType(builder.TypeName);
var contentPart = contentTypeDefinition.Parts.Single(x => x.PartDefinition.Name == builder.Name);
_oldContentTypePartSettings = contentPart.Settings;
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
// we have to do stuff only if the type has a GDPRPart, and we are not processing
// the GDPRPart right now
if (builder.Name == "GDPRPart")
{
yield break;
}
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(builder.TypeName);
if (!typeDefinition.Parts.Any(ctpd =>
ctpd.PartDefinition.Name == "GDPRPart"))
{
yield break;
}
// If the update fails for any part, it will be marked as failed for all of them, because the
// UpdateModel will contain errors. The issue is of course with the dictionaries that contain
// the Property-Value pairs for the handlers that use reflection.
var vm = new GDPRPartPartSettingsViewModel();
if (updateModel.TryUpdateModel(vm, "GDPRPartPartSettingsViewModel", null, null))
{
var settings = vm.Settings;
GDPRPartPartSettings.SetValues(builder, settings);
}
else
{
_notifier.Error(T("There was an issue updating the GDPR configuration for {0}.", builder.Name));
yield break;
}
}
public static ContentTypePartDefinitionBuilder ContainedContentTypes(this ContentTypePartDefinitionBuilder builder, string[] containedContentTypes)
{
//return builder.WithSetting("ContainedContentTypes", containedContentTypes);
return(builder.WithSettings(new ProjectionPartSettings()
{
ContainedContentTypes = containedContentTypes
}));
}
public void Build(ContentTypePartDefinitionBuilder builder)
{
builder.WithSetting("AutorouteSettings.PerItemConfiguration", PerItemConfiguration.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("AutorouteSettings.AllowCustomPattern", AllowCustomPattern.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("AutorouteSettings.AutomaticAdjustmentOnEdit", AutomaticAdjustmentOnEdit.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("AutorouteSettings.PatternDefinitions", PatternDefinitions);
builder.WithSetting("AutorouteSettings.DefaultPatternIndex", DefaultPatternIndex.ToString(CultureInfo.InvariantCulture));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name == "UserReactionsPart")
{
_notifier.Warning(T("Please verify authorization for UserReactions on this Content Type."));
}
return(base.TypePartEditorUpdate(builder, updateModel));
}
public static ContentTypePartDefinitionBuilder ContainedContentTypes(this ContentTypePartDefinitionBuilder builder, string[] containedContentTypes, bool keepExistingTypes = true)
{
return(keepExistingTypes
? builder.MergeSettings(new JObject()
{
["ContainedContentTypes"] = new JArray(containedContentTypes)
})
: builder.WithSetting("ContainedContentTypes", containedContentTypes));
}
public static void SetValues(ContentTypePartDefinitionBuilder builder, GDPRPartTypeSettings settings)
{
builder.WithSetting(
"GDPRPartTypeSettings.IsProfileItemType",
settings.IsProfileItemType.ToString(CultureInfo.InvariantCulture));
builder.WithSetting(
"GDPRPartTypeSettings.DeleteItemsAfterErasure",
settings.DeleteItemsAfterErasure.ToString(CultureInfo.InvariantCulture));
}
public void Build(ContentTypePartDefinitionBuilder builder)
{
builder.WithSetting("FileUploadPartSettings.FileCountLimit", FileCountLimit.HasValue ? FileCountLimit.ToString() : string.Empty);
builder.WithSetting("FileUploadPartSettings.FileSizeLimit", FileSizeLimit.HasValue ? FileSizeLimit.ToString() : string.Empty);
builder.WithSetting("FileUploadPartSettings.FileTypes", FileTypes);
builder.WithSetting("FileUploadPartSettings.PublicMediaPath", PublicMediaPath);
builder.WithSetting("FileUploadPartSettings.DisplayFileUploadInDisplayMode", DisplayFileUploadInDisplayMode.ToString(CultureInfo.InvariantCulture));
builder.WithSetting("FileUploadPartSettings.HideFileUploadInEditModel", HideFileUploadInEditModel.ToString(CultureInfo.InvariantCulture));
}
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) {
if (builder.Name != "AuditTrailPart")
yield break;
var settings = new AuditTrailPartSettings();
updateModel.TryUpdateModel(settings, "AuditTrailPartSettings", null, null);
settings.Build(builder);
yield return DefinitionTemplate(settings);
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "AutoroutePart")
{
yield break;
}
var settings = new AutorouteSettings {
Patterns = new List <RoutePattern>()
};
//get cultures
settings.SiteCultures = _cultureManager.ListCultures().ToList();
if (updateModel.TryUpdateModel(settings, "AutorouteSettings", null, null))
{
//TODO need to add validations client and/or server side here
// remove empty patterns
var patterns = settings.Patterns;
patterns.RemoveAll(p => String.IsNullOrWhiteSpace(p.Name) && String.IsNullOrWhiteSpace(p.Pattern) && String.IsNullOrWhiteSpace(p.Description));
//If there is no default pattern for each culture we set default ones
List <RoutePattern> newPatterns = new List <RoutePattern>();
int current = 0;
foreach (string culture in settings.SiteCultures)
{
if (settings.Patterns.Any(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)))
{
foreach (RoutePattern routePattern in settings.Patterns.Where(x => String.Equals(x.Culture, culture, StringComparison.OrdinalIgnoreCase)))
{
newPatterns.Add(settings.Patterns[current]);
current++;
}
}
else
{
newPatterns.Add(new RoutePattern {
Name = "Title",
Description = "my-title",
Pattern = "{Content.Slug}",
Culture = culture
});
_notifier.Warning(T("A default pattern has been added to AutoroutePart"));
}
}
settings.Patterns = newPatterns;
// update the settings builder
settings.Build(builder);
}
yield return(DefinitionTemplate(settings));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name == "CommonPart")
{
var model = new DateEditorSettings();
if (updateModel.TryUpdateModel(model, "DateEditorSettings", null, null))
{
builder.WithSetting("DateEditorSettings.ShowDateEditor", model.ShowDateEditor.ToString());
}
yield return(DefinitionTemplate(model));
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "CacheEvictorPart")
{
yield break;
}
var model = new CacheEvictorPartSettings();
updateModel.TryUpdateModel(model, "CacheEvictorPartSettings", null, null);
// validate the inserted id
if (!string.IsNullOrEmpty(model.EvictItem))
{
int id;
string identityItems = string.Empty;
foreach (var item in model.EvictItem.Split(';'))
{
if (!string.IsNullOrWhiteSpace(item))
{
if (int.TryParse(item, out id))
{
var content = _contentManager.Get(id);
if (content != null)
{
var identity = _contentManager.GetItemMetadata(content).Identity;
if (identity != null)
{
identityItems += identity.ToString() + ";";
}
else
{
Services.Notifier.Error(T("CacheEvictorPart - The loaded id {0} does not exist", item));
}
}
else
{
Services.Notifier.Error(T("CacheEvictorPart - The loaded id {0} does not exist", item));
}
}
else
{
Services.Notifier.Error(T("CacheEvictorPart - {0} is not an id", item));
}
}
}
// if the validation was successful check the property the identity list
model.IdentityEvictItem = identityItems;
}
// loads each settings field
builder.WithSetting("CacheEvictorPartSettings.EvictItem", model.EvictItem);
builder.WithSetting("CacheEvictorPartSettings.IdentityEvictItem", model.IdentityEvictItem);
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "BodyPart")
{
yield break;
}
var model = new BodyTypePartSettings();
updateModel.TryUpdateModel(model, "BodyTypePartSettings", null, null);
builder.WithSetting("BodyTypePartSettings.Flavor", !string.IsNullOrWhiteSpace(model.Flavor) ? model.Flavor : null);
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "SeoSitemapPart")
{
yield break;
}
var model = new SeoSitemapPartSettings();
updateModel.TryUpdateModel(model, "SeoSitemapPartSettings", null, null);
builder.WithSetting("SeoSitemapPartSettings.Exclude", model.Exclude.ToString());
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel upOwnerModel)
{
if (builder.Name == "TicketsForContentItemPart")
{
var model = new TicketsForContentItemPartSettings();
if (upOwnerModel.TryUpdateModel(model, "TicketsForContentItemPartSettings", null, null))
{
builder.WithSetting("TicketsForContentItemPartSettings.DoNotRenderTicketsFlipFlop", model.DoNotRenderTicketsFlipFlop.ToString());
}
yield return(DefinitionTemplate(model));
}
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "BodyPart")
{
yield break;
}
var model = new ContentShortCodeSettings();
updateModel.TryUpdateModel(model, "ContentShortCodeSettings", null, null);
builder.WithSetting("ContentShortCodeSettings.DisplayedContentTypes", model.DisplayedContentTypes);
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "ElementWrapperPart")
{
yield break;
}
var model = new ElementWrapperPartSettings();
updateModel.TryUpdateModel(model, "ElementWrapperPartSettings", null, null);
builder.WithSetting("ElementWrapperPartSettings.ElementTypeName", model.ElementTypeName);
yield return(DefinitionTemplate(model));
}
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel)
{
if (builder.Name != "BodyPart")
{
yield break;
}
var model = new ShortCodesSettingsViewModel();
updateModel.TryUpdateModel(model, "ShortCodesSettings", null, null);
builder.WithSetting("ShortCodesSettings.EnabledShortCodes", string.Join(",", model.EnabledShortCodes));
yield return(DefinitionTemplate(model));
}
