public virtual ISerializedItem[] GetChildItems(ISerializedReference parent)
{
Assert.ArgumentNotNull(parent, "parent");
var path = SerializationPathUtility.GetReferenceDirectoryPath(parent);
var shortPath = SerializationPathUtility.GetShortSerializedReferencePath(_rootPath, parent);
var fileNames = new List <string>();
bool longPathExists = Directory.Exists(path);
bool shortPathExists = Directory.Exists(shortPath);
if (!longPathExists && !shortPathExists)
{
return(new ISerializedItem[0]);
}
if (longPathExists)
{
fileNames.AddRange(Directory.GetFiles(path, "*" + PathUtils.Extension));
}
if (shortPathExists)
{
fileNames.AddRange(Directory.GetFiles(shortPath, "*" + PathUtils.Extension));
}
return(fileNames.Select(ReadItemFromDisk).ToArray());
}
protected virtual void DeleteItemRecursive(ISerializedReference reference)
{
foreach (var child in reference.GetChildReferences(false))
{
DeleteItemRecursive(child);
}
// kill the serialized file
var fileItem = reference.GetItem();
if (fileItem != null && File.Exists(fileItem.ProviderId))
{
File.Delete(fileItem.ProviderId);
}
// remove any serialized children
var directory = SerializationPathUtility.GetReferenceDirectoryPath(reference);
if (Directory.Exists(directory))
{
Directory.Delete(directory, true);
}
// clean up any hashpaths for this item
var shortDirectory = SerializationPathUtility.GetShortSerializedReferencePath(_rootPath, reference);
if (Directory.Exists(shortDirectory))
{
Directory.Delete(shortDirectory, true);
}
// clean up empty parent folder(s)
var parentDirectory = Directory.GetParent(directory);
if (!parentDirectory.Exists)
{
return;
}
do
{
if (parentDirectory.GetFileSystemInfos().Length > 0)
{
break;
}
parentDirectory.Delete(true);
parentDirectory = parentDirectory.Parent;
} while (parentDirectory != null && parentDirectory.Exists);
}
public virtual void RenameSerializedItem(ISourceItem renamedItem, string oldName)
{
if (renamedItem == null || oldName == null)
{
return;
}
var typed = renamedItem as SitecoreSourceItem;
if (typed == null)
{
throw new ArgumentException("Renamed item must be a SitecoreSourceItem", "renamedItem");
}
// write the serialized item under its new name
var updatedItem = SerializeItem(renamedItem);
// find the children directory path of the previous item name, if it exists, and move them to the new child path
var oldItemPath = renamedItem.ItemPath.Substring(0, renamedItem.ItemPath.Length - renamedItem.Name.Length) + oldName;
var oldSerializedChildrenDirectoryPath = SerializationPathUtility.GetSerializedReferencePath(_rootPath, renamedItem.DatabaseName, oldItemPath);
var oldSerializedChildrenReference = new SitecoreSerializedReference(oldSerializedChildrenDirectoryPath, this);
var shortOldSerializedChildrenPath = SerializationPathUtility.GetShortSerializedReferencePath(_rootPath, oldSerializedChildrenReference);
var shortOldSerializedChildrenReference = new SitecoreSerializedReference(shortOldSerializedChildrenPath, this);
if (Directory.Exists(oldSerializedChildrenReference.ProviderId))
{
MoveDescendants(oldSerializedChildrenReference, updatedItem, renamedItem, true);
}
if (Directory.Exists(shortOldSerializedChildrenPath))
{
MoveDescendants(shortOldSerializedChildrenReference, updatedItem, renamedItem, true);
}
// delete the original serialized item from pre-rename (unless the names only differ by case, in which case we'd delete the item entirely because NTFS is case insensitive!)
if (!renamedItem.Name.Equals(oldName, StringComparison.OrdinalIgnoreCase))
{
// note that we don't have to worry about short paths here because DeleteSerializedItem() knows how to find them
DeleteSerializedItem(oldSerializedChildrenReference);
}
}
public virtual ISerializedReference[] GetChildReferences(ISerializedReference parent, bool recursive)
{
Assert.ArgumentNotNull(parent, "parent");
var longPath = SerializationPathUtility.GetReferenceDirectoryPath(parent);
var shortPath = SerializationPathUtility.GetShortSerializedReferencePath(_rootPath, parent);
Func <string, string[]> parseDirectory = path =>
{
if (!Directory.Exists(path))
{
return(new string[0]);
}
var resultSet = new HashSet <string>();
try
{
string[] files = Directory.GetFiles(path, "*" + PathUtils.Extension);
foreach (var file in files)
{
resultSet.Add(file);
}
string[] directories = SerializationPathUtility.GetDirectories(path, this);
// add directories that aren't already ref'd indirectly by a file
foreach (var directory in directories)
{
if (CommonUtils.IsDirectoryHidden(directory))
{
continue;
}
if (!resultSet.Contains(directory + PathUtils.Extension))
{
resultSet.Add(directory);
}
}
string[] resultArray = resultSet.ToArray();
// make sure if a "templates" item exists in the current set, it goes first
if (resultArray.Length > 1)
{
for (int i = 1; i < resultArray.Length; i++)
{
if ("templates".Equals(Path.GetFileName(resultArray[i]), StringComparison.OrdinalIgnoreCase))
{
string text = resultArray[0];
resultArray[0] = resultArray[i];
resultArray[i] = text;
}
}
}
return(resultArray);
}
catch (DirectoryNotFoundException)
{
// it seems like occasionally, even though we use Directory.Exists() to make sure the parent dir exists, that when we actually call Directory.GetFiles()
// it throws an error that the directory does not exist during recursive deletes. If the directory does not exist, then we can safely assume no children are present.
return(new string[0]);
}
};
var results = Enumerable.Concat(parseDirectory(longPath), parseDirectory(shortPath));
List <ISerializedReference> referenceResults = results.Select(x => (ISerializedReference) new SitecoreSerializedReference(x, this)).ToList();
if (recursive)
{
var localReferenceResults = referenceResults.ToArray();
foreach (var child in localReferenceResults)
{
referenceResults.AddRange(GetChildReferences(child, true));
}
}
return(referenceResults.ToArray());
}
