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; }