protected virtual bool HasConsequentialChanges(ItemChanges changes)
{
// properties, e.g. template, etc are always consequential
if (changes.HasPropertiesChanged)
{
return(true);
}
foreach (FieldChange change in changes.FieldChanges)
{
if (change.OriginalValue == change.Value)
{
continue;
}
if (change.FieldID == FieldIDs.Revision)
{
continue;
}
if (change.FieldID == FieldIDs.Updated)
{
continue;
}
if (!_fieldPredicate.Includes(change.FieldID).IsIncluded)
{
continue;
}
return(true);
}
_logger.SaveRejectedAsInconsequential(_serializationProvider.LogName, changes);
return(false);
}
private IList <FieldDesynchronization> GetFieldSyncStatus(SitecoreSourceItem item, ISerializedItem serializedItem, IFieldPredicate fieldPredicate)
{
var desyncs = new List <FieldDesynchronization>();
var serializedVersion = serializedItem.Versions.FirstOrDefault(x => x.VersionNumber == item.InnerItem.Version.Number && x.Language == item.InnerItem.Language.Name);
if (serializedVersion == null)
{
desyncs.Add(new FieldDesynchronization("Version"));
return(desyncs);
}
item.InnerItem.Fields.ReadAll();
foreach (Field field in item.InnerItem.Fields)
{
if (field.ID == FieldIDs.Revision ||
field.ID == FieldIDs.Updated ||
field.ID == FieldIDs.Created ||
field.ID == FieldIDs.CreatedBy ||
field.ID == FieldIDs.UpdatedBy ||
field.Type.Equals("attachment", StringComparison.OrdinalIgnoreCase) ||
!fieldPredicate.Includes(field.ID).IsIncluded)
{
continue;
}
// we're doing a data comparison here - revision, created (by), updated (by) don't matter
// skipping these fields allows us to ignore spurious saves the template builder makes to unchanged items being conflicts
// find the field in the serialized item in either versioned or shared fields
string serializedField;
if (!serializedVersion.Fields.TryGetValue(field.ID.ToString(), out serializedField))
{
serializedItem.SharedFields.TryGetValue(field.ID.ToString(), out serializedField);
}
// we ignore if the field doesn't exist in the serialized item. This is because if you added a field to a template,
// that does not immediately re-serialize all items based on that template so it's likely innocuous - we're not overwriting anything.
if (serializedField == null)
{
continue;
}
if (!serializedField.Equals(field.Value, StringComparison.Ordinal))
{
desyncs.Add(new FieldDesynchronization(field.Name));
}
}
return(desyncs);
}
/// <summary>
/// Inserts field value into item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="field">The field.</param>
/// <param name="ignoreMissingTemplateFields">Whether to ignore fields in the serialized item that do not exist on the Sitecore template</param>
/// <param name="creatingNewItem">Whether the item under update is new or not (controls logging verbosity)</param>
/// <exception cref="T:Sitecore.Data.Serialization.Exceptions.FieldIsMissingFromTemplateException"/>
protected virtual void PasteSyncField(Item item, SyncField field, bool ignoreMissingTemplateFields, bool creatingNewItem)
{
if (!_fieldPredicate.Includes(field.FieldID).IsIncluded)
{
_logger.SkippedPastingIgnoredField(item, field);
return;
}
Template template = AssertTemplate(item.Database, item.TemplateID, item.Paths.Path);
if (template.GetField(field.FieldID) == null)
{
item.Database.Engines.TemplateEngine.Reset();
template = AssertTemplate(item.Database, item.TemplateID, item.Paths.Path);
}
if (template.GetField(field.FieldID) == null)
{
if (!ignoreMissingTemplateFields)
{
#if SITECORE_7
throw new FieldIsMissingFromTemplateException("Field '" + field.FieldName + "' (" + field.FieldID + ") does not exist in template '" + template.Name + "'", FileUtil.MakePath(item.Template.InnerItem.Database.Name, item.Template.InnerItem.Paths.FullPath), FileUtil.MakePath(item.Database.Name, item.Paths.FullPath), item.ID);
#else
throw new Exception("Field '" + field.FieldName + "' (" + field.FieldID + ") does not exist in template '" + template.Name + "'");
#endif
}
_logger.SkippedMissingTemplateField(item, field);
return;
}
Field itemField = item.Fields[ID.Parse(field.FieldID)];
if (itemField.IsBlobField && !ID.IsID(field.FieldValue))
{
byte[] buffer = System.Convert.FromBase64String(field.FieldValue);
itemField.SetBlobStream(new MemoryStream(buffer, false));
if (!creatingNewItem)
{
_logger.WroteBlobStream(item, field);
}
}
else if (!field.FieldValue.Equals(itemField.Value))
{
var oldValue = itemField.Value;
itemField.SetValue(field.FieldValue, true);
if (!creatingNewItem)
{
_logger.UpdatedChangedFieldValue(item, field, oldValue);
}
}
}
protected virtual bool HasConsequentialChanges(ItemChanges changes)
{
// properties, e.g. template, etc are always consequential
// NOTE: sometimes you can get spurious 'changes' where the old and new value are the same. We reject those.
if (changes.HasPropertiesChanged && changes.Properties.Any(x => !x.Value.OriginalValue.Equals(x.Value.Value)))
{
return(true);
}
foreach (FieldChange change in changes.FieldChanges)
{
if (change.OriginalValue == change.Value)
{
continue;
}
if (change.FieldID == FieldIDs.Revision)
{
continue;
}
if (change.FieldID == FieldIDs.Updated)
{
continue;
}
if (change.FieldID == FieldIDs.UpdatedBy)
{
continue;
}
if (change.FieldID == FieldIDs.Originator)
{
continue;
}
if (!_fieldPredicate.Includes(change.FieldID).IsIncluded)
{
continue;
}
return(true);
}
_logger.SaveRejectedAsInconsequential(_serializationProvider.LogName, changes);
return(false);
}
protected virtual bool AnyFieldMatch(FieldDictionary sourceFields, FieldDictionary targetFields, ISourceItem existingItem, ISerializedItem serializedItem, DeferredLogWriter <ISerializedAsMasterEvaluatorLogger> deferredUpdateLog, ItemVersion version = null)
{
if (sourceFields == null)
{
return(false);
}
return(sourceFields.Any(x =>
{
if (!_fieldPredicate.Includes(x.Key).IsIncluded)
{
return false;
}
if (!existingItem.IsFieldComparable(x.Key))
{
return false;
}
bool isMatch = IsFieldMatch(x.Value, targetFields, x.Key);
if (isMatch)
{
deferredUpdateLog.AddEntry(logger =>
{
string sourceFieldValue;
targetFields.TryGetValue(x.Key, out sourceFieldValue);
if (version == null)
{
logger.IsSharedFieldMatch(serializedItem, x.Key, x.Value, sourceFieldValue);
}
else
{
logger.IsVersionedFieldMatch(serializedItem, version, x.Key, x.Value, sourceFieldValue);
}
});
}
return isMatch;
}));
}
private IList<FieldDesynchronization> GetFieldSyncStatus(SitecoreSourceItem item, ISerializedItem serializedItem, IFieldPredicate fieldPredicate)
{
var desyncs = new List<FieldDesynchronization>();
var serializedVersion = serializedItem.Versions.FirstOrDefault(x => x.VersionNumber == item.InnerItem.Version.Number && x.Language == item.InnerItem.Language.Name);
if (serializedVersion == null)
{
desyncs.Add(new FieldDesynchronization("Version"));
return desyncs;
}
item.InnerItem.Fields.ReadAll();
foreach (Field field in item.InnerItem.Fields)
{
if (field.ID == FieldIDs.Revision ||
field.ID == FieldIDs.Updated ||
field.ID == FieldIDs.Created ||
field.ID == FieldIDs.CreatedBy ||
field.ID == FieldIDs.UpdatedBy ||
field.Type.Equals("attachment", StringComparison.OrdinalIgnoreCase) ||
!fieldPredicate.Includes(field.ID).IsIncluded) continue;
// we're doing a data comparison here - revision, created (by), updated (by) don't matter
// skipping these fields allows us to ignore spurious saves the template builder makes to unchanged items being conflicts
// find the field in the serialized item in either versioned or shared fields
string serializedField;
if(!serializedVersion.Fields.TryGetValue(field.ID.ToString(), out serializedField))
serializedItem.SharedFields.TryGetValue(field.ID.ToString(), out serializedField);
// we ignore if the field doesn't exist in the serialized item. This is because if you added a field to a template,
// that does not immediately re-serialize all items based on that template so it's likely innocuous - we're not overwriting anything.
if (serializedField == null) continue;
if (!serializedField.Equals(field.Value, StringComparison.Ordinal))
{
desyncs.Add(new FieldDesynchronization(field.Name));
}
}
return desyncs;
}
