public void ShouldExcludeChildrenExcludedByPredicate()
{
var child = new FakeItem();
var parent = new FakeItem(children: new[] { child });
var predicate = Substitute.For<IPredicate>();
predicate.Includes(child).Returns(new PredicateResult(false));
Assert.NotEmpty(parent.GetChildren());
var filtered = new PredicateFilteredItemData(parent, predicate);
Assert.Empty(filtered.GetChildren());
}
public void SaveItem(ItemDefinition itemDefinition, ItemChanges changes, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(changes, "changes");
var sourceItem = GetSourceFromId(changes.Item.ID);
if (sourceItem == null) return;
if (!_predicate.Includes(sourceItem).IsIncluded) return;
string oldName = changes.Renamed ? changes.Properties["name"].OriginalValue.ToString() : string.Empty;
if (changes.Renamed && !oldName.Equals(sourceItem.Name, StringComparison.Ordinal))
// it's a rename, in which the name actually changed (template builder will cause 'renames' for the same name!!!)
{
using (new DatabaseCacheDisabler())
{
// disabling the DB caches while running this ensures that any children of the renamed item are retrieved with their proper post-rename paths and thus are not saved at their old location
// this allows us to filter out any excluded children by predicate when the data store moves children
var predicatedItem = new PredicateFilteredItemData(sourceItem, _predicate);
_targetDataStore.MoveOrRenameItem(predicatedItem, changes.Item.Paths.ParentPath + "/" + oldName);
}
_logger.RenamedItem(_targetDataStore.FriendlyName, sourceItem, oldName);
}
else if (HasConsequentialChanges(changes))
// it's a simple update - but we reject it if only inconsequential fields (last updated, revision) were changed - again, template builder FTW
{
_targetDataStore.Save(sourceItem);
AddBlobsToCache(sourceItem);
_logger.SavedItem(_targetDataStore.FriendlyName, sourceItem, "Saved");
}
}
public void MoveItem(ItemDefinition itemDefinition, ItemDefinition destination, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
var oldSourceItem = GetSourceFromId(itemDefinition.ID, true); // we use cache here because we want the old path
var oldPath = oldSourceItem.Path; // NOTE: we cap the path here, because once we enter the cache-disabled section - to get the new paths for parent and children - the path cache updates and the old path is lost in oldSourceItem because it is reevaluated each time.
var destinationItem = GetSourceFromId(destination.ID);
if (!_predicate.Includes(destinationItem).IsIncluded) // if the destination we are moving to is NOT included for serialization, we delete the existing item
{
var existingItem = _targetDataStore.GetByPathAndId(oldSourceItem.Path, oldSourceItem.Id, oldSourceItem.DatabaseName);
if (existingItem != null)
{
_targetDataStore.Remove(existingItem);
_logger.MovedItemToNonIncludedLocation(_targetDataStore.FriendlyName, existingItem);
}
return;
}
using (new DatabaseCacheDisabler())
{
// disabling the DB caches while running this ensures that any children of the moved item are retrieved with their proper post-rename paths and thus are not saved at their old location
var sourceItem = GetSourceFromId(itemDefinition.ID); // re-get the item with cache disabled
// this allows us to filter out any excluded children by predicate when the data store moves children
var predicatedItem = new PredicateFilteredItemData(sourceItem, _predicate);
_targetDataStore.MoveOrRenameItem(predicatedItem, oldPath);
_logger.MovedItem(_targetDataStore.FriendlyName, sourceItem, destinationItem);
}
}
public void MoveItem(ItemDefinition itemDefinition, ItemDefinition destination, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
var sourceItem = GetSourceFromId(itemDefinition.ID, true); // we use cache here because we want the old path (no cache would have the new path); TpSync always has old path
var oldPath = sourceItem.Path; // NOTE: we cap the path here, because Sitecore can change the item's path value as we're updating stuff.
var destinationItem = GetSourceFromId(destination.ID);
if (destinationItem == null) return; // can occur with TpSync on, when this isn't the configuration we're moving for the data store will return null
if (!_predicate.Includes(destinationItem).IsIncluded) // if the destination we are moving to is NOT included for serialization, we delete the existing item
{
var existingItem = _targetDataStore.GetByPathAndId(sourceItem.Path, sourceItem.Id, sourceItem.DatabaseName);
if (existingItem != null)
{
_targetDataStore.Remove(existingItem);
_logger.MovedItemToNonIncludedLocation(_targetDataStore.FriendlyName, existingItem);
}
return;
}
// rebase the path to the new destination path (this handles children too)
var rebasedSourceItem = new PathRebasingItemData(sourceItem, destinationItem.Path, destinationItem.Id);
// this allows us to filter out any excluded children by predicate when the data store moves children
var predicatedItem = new PredicateFilteredItemData(rebasedSourceItem, _predicate);
_targetDataStore.MoveOrRenameItem(predicatedItem, oldPath);
_logger.MovedItem(_targetDataStore.FriendlyName, predicatedItem, destinationItem);
}
public virtual void SaveItem(ItemDefinition itemDefinition, ItemChanges changes, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(changes, "changes");
// get the item we're saving to evaluate with the predicate
// NOTE: the item in this state may be incomplete as Sitecore can sometimes send partial item data and rely on changes to do the save
// e.g. during package installations. So we have to merge the changes with any existing item data if we save it later, to keep it consistent.
IItemData sourceItem = new ItemData(changes.Item);
if (!_predicate.Includes(sourceItem).IsIncluded) return;
string oldName = changes.Renamed ? changes.Properties["name"].OriginalValue.ToString() : string.Empty;
if (changes.Renamed && !oldName.Equals(sourceItem.Name, StringComparison.Ordinal))
// it's a rename, in which the name actually changed (template builder will cause 'renames' for the same name!!!)
{
using (new DatabaseCacheDisabler())
{
// disabling the DB caches while running this ensures that any children of the renamed item are retrieved with their proper post-rename paths and thus are not saved at their old location
// this allows us to filter out any excluded children by predicate when the data store moves children
var predicatedItem = new PredicateFilteredItemData(sourceItem, _predicate);
_targetDataStore.MoveOrRenameItem(predicatedItem, changes.Item.Paths.ParentPath + "/" + oldName);
}
_logger.RenamedItem(_targetDataStore.FriendlyName, sourceItem, oldName);
}
else if (HasConsequentialChanges(changes))
// it's a simple update - but we reject it if only inconsequential fields (last updated, revision) were changed - again, template builder FTW
{
var existingSerializedItem = _targetDataStore.GetByPathAndId(sourceItem.Path, sourceItem.Id, sourceItem.DatabaseName);
// generated an IItemData from the item changes we received, and apply those changes to the existing serialized item if any
if (existingSerializedItem != null) sourceItem = new ItemChangeApplyingItemData(existingSerializedItem, changes);
else sourceItem = new ItemChangeApplyingItemData(changes);
_targetDataStore.Save(sourceItem);
AddBlobsToCache(sourceItem);
_logger.SavedItem(_targetDataStore.FriendlyName, sourceItem, "Saved");
}
}
