public override bool ChangeFieldSharing(
[NotNull] TemplateField fieldDefinition,
TemplateFieldSharing sharing,
[NotNull] CallContext context)
{
var converter = GetFieldSharingConverter();
bool result;
switch (sharing)
{
case TemplateFieldSharing.None:
result = converter.MakeVersioned(fieldDefinition);
break;
case TemplateFieldSharing.Shared:
result = converter.MakeShared(fieldDefinition);
break;
case TemplateFieldSharing.Unversioned:
result = converter.MakeUnversioned(fieldDefinition);
break;
default:
Log.Warn("Unknown sharing type in ChangeFieldSharing: " + sharing, this);
return(false);
}
if (result)
{
CacheManager.ClearAllCaches();
}
return(result);
}
/// <summary>
/// When you change a template field from versioned to shared or unversioned (or vice versa), the conversion of the values
/// in existing items with that field is NOT automatic. This method causes the requisite field updates (moving the values between db tables)
/// </summary>
protected void UpdateFieldSharingIfNeeded(IItemData serializedItemData, Item targetItem)
{
// This is what Sitecore's internal deserializer does instead. Will investigate if this is a better option. Also depends on which Sitecore version introduced this.
//if (EventDisabler.IsActive)
// ReflectionUtil.CallMethod(targetItem.Database.Engines.TemplateEngine, "HandleItemSaved", new object[] {targetItem, (ItemChanges) ReflectionUtil.CallMethod(targetItem, "GetFullChanges"), false});
//return;
Assert.ArgumentNotNull(serializedItemData, nameof(serializedItemData));
Assert.ArgumentNotNull(targetItem, nameof(targetItem));
if (serializedItemData.TemplateId != TemplateIDs.TemplateField.Guid)
{
return;
}
var shared = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Shared.Guid);
var unversioned = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Unversioned.Guid);
TemplateFieldSharing sharedness = TemplateFieldSharing.None;
if (shared != null && shared.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Shared;
}
else if (unversioned != null && unversioned.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Unversioned;
}
var templateField = TemplateManager.GetTemplateField(targetItem.ID, targetItem.Parent.Parent.ID, targetItem.Database);
if (templateField == null)
{
// BOMB WIG
CacheManager.ClearAllCaches();
targetItem.Database.Engines.TemplateEngine.Reset();
templateField = TemplateManager.GetTemplateField(targetItem.ID, targetItem.Parent.Parent.ID, targetItem.Database);
}
Assert.IsNotNull(templateField, $"Unable to find template field {targetItem.ID} in {targetItem.Database.Name}, even after resetting the engine.");
TemplateFieldSharing templateSharedness = TemplateFieldSharing.None;
if (templateField.IsShared)
{
templateSharedness = TemplateFieldSharing.Shared;
}
else if (templateField.IsUnversioned)
{
templateSharedness = TemplateFieldSharing.Unversioned;
}
if (templateSharedness == sharedness)
{
return;
}
TemplateManager.ChangeFieldSharing(templateField, sharedness, targetItem.Database);
}
/// <summary>
/// When you change a template field from versioned to shared or unversioned (or vice versa), the conversion of the values
/// in existing items with that field is NOT automatic. This method causes the requisite field updates (moving the values between db tables)
/// </summary>
protected void UpdateFieldSharingIfNeeded(IItemData serializedItemData, Item targetItem)
{
Assert.ArgumentNotNull(serializedItemData, nameof(serializedItemData));
Assert.ArgumentNotNull(targetItem, nameof(targetItem));
if (serializedItemData.TemplateId != TemplateIDs.TemplateField.Guid)
{
return;
}
var shared = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Shared.Guid);
var unversioned = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Unversioned.Guid);
TemplateFieldSharing sharedness = TemplateFieldSharing.None;
if (shared != null && shared.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Shared;
}
else if (unversioned != null && unversioned.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Unversioned;
}
var templateField = TemplateManager.GetTemplateField(targetItem.ID, targetItem.Parent.Parent.ID, targetItem.Database);
if (templateField == null)
{
// BOMB WIG
CacheManager.ClearAllCaches();
targetItem.Database.Engines.TemplateEngine.Reset();
templateField = TemplateManager.GetTemplateField(targetItem.ID, targetItem.Parent.Parent.ID, targetItem.Database);
}
Assert.IsNotNull(templateField, $"Unable to find template field {targetItem.ID} in {targetItem.Database.Name}, even after resetting the engine.");
TemplateFieldSharing templateSharedness = TemplateFieldSharing.None;
if (templateField.IsShared)
{
templateSharedness = TemplateFieldSharing.Shared;
}
else if (templateField.IsUnversioned)
{
templateSharedness = TemplateFieldSharing.Unversioned;
}
if (templateSharedness == sharedness)
{
return;
}
TemplateManager.ChangeFieldSharing(templateField, sharedness, targetItem.Database);
}
public override bool ChangeFieldSharing(TemplateField fieldDefinition, TemplateFieldSharing sharing, CallContext context)
{
if (HeadProvider.ChangeFieldSharing(fieldDefinition, sharing, context))
{
this.Trace(true, null, context);
return(true);
}
throw new NotImplementedException();
}
/// <summary>
/// When you change a template field from versioned to shared or unversioned (or vice versa), the conversion of the values
/// in existing items with that field is NOT automatic. This method causes the requisite field updates (moving the values between db tables)
/// </summary>
protected void UpdateFieldSharingIfNeeded(IItemData serializedItemData, Item targetItem)
{
if (serializedItemData.TemplateId != TemplateIDs.TemplateField.Guid)
{
return;
}
var shared = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Shared.Guid);
var unversioned = serializedItemData.SharedFields.FirstOrDefault(field => field.FieldId == TemplateFieldIDs.Unversioned.Guid);
TemplateFieldSharing sharedness = TemplateFieldSharing.None;
if (shared != null && shared.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Shared;
}
else if (unversioned != null && unversioned.Value.Equals("1"))
{
sharedness = TemplateFieldSharing.Unversioned;
}
var templateField = TemplateManager.GetTemplateField(targetItem.ID, targetItem.Parent.Parent.ID, targetItem.Database);
TemplateFieldSharing templateSharedness = TemplateFieldSharing.None;
if (templateField.IsShared)
{
templateSharedness = TemplateFieldSharing.Shared;
}
else if (templateField.IsUnversioned)
{
templateSharedness = TemplateFieldSharing.Unversioned;
}
if (templateSharedness == sharedness)
{
return;
}
TemplateManager.ChangeFieldSharing(templateField, sharedness, targetItem.Database);
}
public sealed override bool ChangeFieldSharing(TemplateField fieldDefinition, TemplateFieldSharing sharing, CallContext context)
{
throw new NotSupportedException(MustNotBeCalled);
}
public override bool ChangeFieldSharing(TemplateField fieldDefinition, TemplateFieldSharing sharing, CallContext context)
{
return base.ChangeFieldSharing(fieldDefinition, sharing, context);
}
public override bool ChangeFieldSharing(TemplateField fieldDefinition, TemplateFieldSharing sharing, CallContext context)
{
return(base.ChangeFieldSharing(fieldDefinition, sharing, context));
}
public void ChangeFieldSharing(ID fieldID, TemplateFieldSharing sharing)
{
Assert.ArgumentNotNull(fieldID, nameof(fieldID));
if (this.ReadOnly)
{
return;
}
Lock.EnterWriteLock();
try
{
foreach (var item in this.ItemsCache.Values)
{
if (item == null)
{
continue;
}
switch (sharing)
{
case TemplateFieldSharing.None:
this.ChangeFieldSharingToVersioned(item, fieldID);
break;
case TemplateFieldSharing.Unversioned:
this.ChangeFieldSharingToUnversioned(item, fieldID);
break;
case TemplateFieldSharing.Shared:
this.ChangeFieldSharingToShared(item, fieldID);
break;
}
}
}
finally
{
Lock.ExitWriteLock();
}
this.Commit();
}
