Exemplo n.º 1
0
        public void FilteredItem_DoesNotContainExpectedSharedField()
        {
            Guid fieldId = Guid.NewGuid();

            var filter   = new TestFieldFilter(fieldId);
            var testItem = new FakeItem(sharedFields: new[] { new FakeFieldValue("Fake", fieldId: fieldId), });

            var filteredItem = new FilteredItem(testItem, filter);

            Assert.False(filteredItem.SharedFields.Any(field => field.FieldId == fieldId));
        }
Exemplo n.º 2
0
        public void FilteredItem_ContainsExpectedVersionedField()
        {
            Guid fieldId = Guid.NewGuid();

            var filter   = new TestFieldFilter();
            var testItem = new FakeItem(versions: new[] { new FakeItemVersion(fields: new FakeFieldValue("Fake", fieldId: fieldId)) });

            var filteredItem = new FilteredItem(testItem, filter);

            Assert.True(filteredItem.Versions.First().Fields.Any(field => field.FieldId == fieldId));
        }
        protected virtual bool ShouldUpdateExisting(IItemData sourceItem, IItemData targetItem, DeferredLogWriter <ISerializedAsMasterEvaluatorLogger> deferredUpdateLog)
        {
            Assert.ArgumentNotNull(targetItem, "targetItem");
            Assert.ArgumentNotNull(sourceItem, "sourceItem");

            if (sourceItem.Id == RootId)
            {
                return(false);                                     // we never want to update the Sitecore root item
            }
            // filter out ignored fields before we do the comparison
            var filteredTargetItem = new FilteredItem(targetItem, _fieldFilter);
            var filteredSourceItem = new FilteredItem(sourceItem, _fieldFilter);

            var comparison = _itemComparer.FastCompare(filteredSourceItem, filteredTargetItem);

            if (comparison.IsRenamed || comparison.IsMoved)
            {
                deferredUpdateLog.AddEntry(log => log.Renamed(sourceItem, targetItem));
            }
            if (comparison.IsTemplateChanged)
            {
                deferredUpdateLog.AddEntry(log => log.TemplateChanged(sourceItem, targetItem));
            }
            foreach (var sharedChange in comparison.ChangedSharedFields)
            {
                deferredUpdateLog.AddEntry(log => log.SharedFieldIsChanged(targetItem, (sharedChange.TargetField ?? sharedChange.SourceField).FieldId, ((sharedChange.TargetField != null) ? sharedChange.TargetField.Value : null), ((sharedChange.SourceField != null) ? sharedChange.SourceField.Value : null)));
            }
            foreach (var versionChange in comparison.ChangedVersions)
            {
                if (versionChange.SourceVersion == null)
                {
                    deferredUpdateLog.AddEntry(log => log.NewTargetVersion(versionChange.TargetVersion, targetItem, sourceItem));
                }
                else if (versionChange.TargetVersion == null)
                {
                    deferredUpdateLog.AddEntry(log => log.OrphanSourceVersion(sourceItem, targetItem, new[] { versionChange.SourceVersion }));
                }
                else
                {
                    foreach (var field in versionChange.ChangedFields)
                    {
                        var sourceFieldValue = field.SourceField == null ? null : field.SourceField.Value;
                        var targetFieldValue = field.TargetField == null ? null : field.TargetField.Value;
                        var fieldId          = (field.SourceField ?? field.TargetField).FieldId;

                        deferredUpdateLog.AddEntry(log => log.VersionedFieldIsChanged(targetItem, versionChange.SourceVersion ?? versionChange.TargetVersion, fieldId, targetFieldValue, sourceFieldValue));
                    }
                }
            }

            return(!comparison.AreEqual);
        }
Exemplo n.º 4
0
        public virtual void WriteSerializedItem(IItemData itemData, Stream outputStream)
        {
            Assert.ArgumentNotNull(itemData, "item");
            Assert.ArgumentNotNull(outputStream, "outputStream");

            if (_fieldFilter != null)
            {
                itemData = new FilteredItem(itemData, _fieldFilter);
            }

            var itemToSerialize = new YamlItem();

            itemToSerialize.LoadFrom(itemData, FieldFormatters.ToArray());

            using (var writer = new YamlWriter(outputStream, 4096, true))
            {
                itemToSerialize.WriteYaml(writer);
            }
        }
Exemplo n.º 5
0
        protected virtual bool ShouldUpdateExisting(IItemData sourceItem, IItemData targetItem, DeferredLogWriter <ISerializedAsMasterEvaluatorLogger> deferredUpdateLog, IFieldValueManipulator fieldValueManipulator)
        {
            Assert.ArgumentNotNull(targetItem, "targetItem");
            Assert.ArgumentNotNull(sourceItem, "sourceItem");

            if (sourceItem.Id == RootId)
            {
                return(false);                                     // we never want to update the Sitecore root item
            }
            // Taking a shortcut for now. If there is a dynamic field value manipiulator, it's true result can only really be obtained when doing the _actual_ write, not when trying to second guess if a write is needed
            if (fieldValueManipulator != null)
            {
                return(true);
            }

            // filter out ignored fields before we do the comparison
            var filteredTargetItem = new FilteredItem(targetItem, _fieldFilter);
            var filteredSourceItem = new FilteredItem(sourceItem, _fieldFilter);

            var comparison = _itemComparer.FastCompare(filteredSourceItem, filteredTargetItem);

            if (comparison.IsRenamed || comparison.IsMoved)
            {
                deferredUpdateLog.AddEntry(log => log.Renamed(sourceItem, targetItem));
            }

            if (comparison.IsTemplateChanged)
            {
                deferredUpdateLog.AddEntry(log => log.TemplateChanged(sourceItem, targetItem));
            }

            foreach (var sharedChange in comparison.ChangedSharedFields)
            {
                deferredUpdateLog.AddEntry(log => log.SharedFieldIsChanged(
                                               targetItem,
                                               (sharedChange.TargetField ?? sharedChange.SourceField).FieldId,
                                               sharedChange.TargetField?.Value,
                                               sharedChange.SourceField?.Value));
            }

            foreach (var unversionedChange in comparison.ChangedUnversionedFields)
            {
                foreach (var uvField in unversionedChange.ChangedFields)
                {
                    deferredUpdateLog.AddEntry(log => log.UnversionedFieldIsChanged(
                                                   targetItem,
                                                   unversionedChange.Language.Language,
                                                   (uvField.TargetField ?? uvField.SourceField).FieldId,
                                                   uvField.TargetField?.Value,
                                                   uvField.SourceField?.Value));
                }
            }

            foreach (var versionChange in comparison.ChangedVersions)
            {
                if (versionChange.SourceVersion == null)
                {
                    deferredUpdateLog.AddEntry(log => log.NewTargetVersion(versionChange.TargetVersion, targetItem, sourceItem));
                }
                else if (versionChange.TargetVersion == null)
                {
                    deferredUpdateLog.AddEntry(log => log.OrphanSourceVersion(sourceItem, targetItem, new[] { versionChange.SourceVersion }));
                }
                else
                {
                    foreach (var field in versionChange.ChangedFields)
                    {
                        var sourceFieldValue = field.SourceField?.Value;
                        var targetFieldValue = field.TargetField?.Value;
                        var fieldId          = (field.SourceField ?? field.TargetField).FieldId;

                        deferredUpdateLog.AddEntry(log => log.VersionedFieldIsChanged(targetItem, versionChange.SourceVersion ?? versionChange.TargetVersion, fieldId, targetFieldValue, sourceFieldValue));
                    }
                }
            }

            return(!comparison.AreEqual);
        }