protected void assertAreEqual(DirectoryObject dir1, DirectoryObject dir2) { Assert.IsNotNull(dir1); Assert.IsNotNull(dir2); Assert.AreEqual<DateTime>(dir1.Created, dir2.Created); Assert.AreEqual<DateTime>(dir1.LastEdited, dir2.LastEdited); Assert.AreEqual<string>(dir1.Name, dir2.Name); Assert.AreEqual<string>(dir1.Path, dir2.Path); Assert.IsFalse(dir1.Name.IsNullOrEmpty()); var dir1Dirs = dir1.Directories.ToList<DirectoryObject>(); var dir2Dirs = dir2.Directories.ToList<DirectoryObject>(); Assert.AreEqual<int>(dir1Dirs.Count, dir2Dirs.Count); for (int i = 0; i < dir1Dirs.Count; i++) { assertAreEqual(dir1Dirs[i], dir2Dirs[i]); } var dir1Files = dir1.Files.ToList<FileObject>(); var dir2Files = dir2.Files.ToList<FileObject>(); Assert.AreEqual<int>(dir1Files.Count, dir2Files.Count); for (int i = 0; i < dir1Files.Count; i++) { assertAreEqual(dir1Files[i], dir2Files[i]); } }
public static DirectoryObjectDiff CompareDirectories(DirectoryObject left, DirectoryObject right, string leftName = "", string rightName = "") { var result = new DirectoryObjectDiff() { LeftName = leftName, RightName = rightName }; compareDirectoriesHelper(left, right, result); return result; }
public void TestDirectoryObjectSerialization() { var dir = new DirectoryObject() { LocalPath = ".." }; dir.LoadFromDisk(); dir.Path = "/"; var xml = dir.Serialize(); var roundTrip = new DirectoryObject(); Assert.IsTrue(roundTrip.Validate(xml)); roundTrip.Deserialize(xml); assertAreEqual(dir, roundTrip); }
private void removeUnpermittedDirs(DirectoryObject dir) { bool childPermitted = false; foreach (DirectoryObject item in dir.Directories.ToList<DirectoryObject>()) { bool itemPermitted = checkPermission(item.Path) || anyChildPermitted(item.Path); childPermitted = childPermitted || itemPermitted; if (!itemPermitted) { dir.RemoveDirectory(item.Name); } else { removeUnpermittedDirs(item); } } if (!checkPermission(dir.Path)) { dir.ClearFiles(); } }
private DirectoryObject loadVirtualPath(string virtualPath, int depth = -1) { var localPath = getLocalPath(virtualPath); if (localPath.IsNullOrEmpty()) { throw new DirectoryNotFoundException(); } var dir = new DirectoryObject(); dir.LocalPath = localPath; dir.LoadFromDisk(depth); //load files and directories from other mounts that match the specified path var subMounts = mounts.Where(x => x.MountPoint.ToLower().StartsWith(virtualPath.ToLower())); foreach (var item in subMounts) { var itemMountPoint = item.MountPoint.Remove(0, virtualPath.Length); if (itemMountPoint.IsNullOrEmpty()) continue; if (itemMountPoint.StartsWith("/")) itemMountPoint = itemMountPoint.RemoveFirstChar(); if (itemMountPoint.Split('/').Length > depth && depth >= 0) { continue; } var subDir = new DirectoryObject(); subDir.LocalPath = item.LocalPath; int scanDepth = (depth < 0) ? -1 : Math.Max(0, (depth - itemMountPoint.Split('/').Length)); subDir.LoadFromDisk(scanDepth); var parent = dir.GetDirectory(Path.GetDirectoryName(itemMountPoint)); if (parent.Directories.Any(x => x.Name.ToLower() == subDir.Name.ToLower())) parent.RemoveDirectory(subDir.Name); parent.AddDirectory(subDir); } return dir; }
private void printDirectoryObject(DirectoryObject dir) { if (dir == null) { Program.ErrorLine(this, "DirectoryObject NULL"); return; } if (!dir.Directories.Any() && !dir.Files.Any()) { Program.OutputLine(this, ""); return; } foreach (DirectoryObject item in dir.Directories) { Program.OutputLine(this, " <DIR> {0}", item.Name.FormatEscape()); } foreach (FileObject item in dir.Files) { Program.OutputLine(this, " {0}", item.Name.FormatEscape()); } }
private static void compareDirectoriesHelper(DirectoryObject left, DirectoryObject right, DirectoryObjectDiff result) { // ## Items missing in left Directory ## //find directories that exist in right but not in left var dirsMissingLeft = right.Directories.Where(x => !left.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => getAllSubdirectories(x)) .Aggregate((l1, l2) => l1.Union<DirectoryObject>(l2)); //find files that exist in right but not in left var filesMissingLeft = right.Files.Where(x => !left.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())); //add all files from all the directories missing from left filesMissingLeft = filesMissingLeft.Union(dirsMissingLeft.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2))); //copy directories in the list and remove the files dirsMissingLeft = dirsMissingLeft.Select(x => { var copy = x.Clone(0); copy.ClearFiles(); return copy; }); // ## Items missing in right Directory ## //find directories that exist in left but not in right var dirsMissingRight = left.Directories.Where(x => !right.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => getAllSubdirectories(x)) .Aggregate((l1, l2) => l1.Union<DirectoryObject>(l2)); //find files that exist in left but not in right var filesMissingRight = left.Files.Where(x => !right.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())); //add all files from all the directories missing from right filesMissingRight = filesMissingRight.Union(dirsMissingRight.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2))); //make dirsMissingLeft (list of trees) to a simple list of directories (minus files) dirsMissingRight = dirsMissingRight.Select(x => { var copy = x.Clone(0); copy.ClearFiles(); return copy; }); // ## Conflicts ## //find files that exist in both directories but are not equal var fileConflicts = right.Files.Where(x => left.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => new Tuple<FileObject, FileObject>(left.GetFile(x.Name), x)) .Where(x => !compareFileObject(x.Item1, x.Item2)); //add the newy-found conflicts to the existing result result.DirectoriesMissigFromLeft = result.DirectoriesMissigFromLeft.Union<DirectoryObject>(dirsMissingLeft).ToList<DirectoryObject>(); result.DirectoriesMissingFromRight = result.DirectoriesMissingFromRight.Union<DirectoryObject>(dirsMissingRight).ToList<DirectoryObject>(); result.FilesMissingFromLeft = result.FilesMissingFromLeft.Union<FileObject>(filesMissingLeft); result.FilesMissingFromRight = result.FilesMissingFromRight.Union<FileObject>(filesMissingRight); // ## Recursion ## foreach (var item in left.Directories.Where(x => right.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower()))) { compareDirectoriesHelper(item, right.GetDirectory(item.Name), result); } }
private static IEnumerable<FileObject> getAllFiles(DirectoryObject dir) { var dirs = getAllSubdirectories(dir); return dirs.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2)); }
private static IEnumerable<DirectoryObject> getAllSubdirectories(DirectoryObject dir) { var result = new List<DirectoryObject>(); result.Add(dir); for (int i = 0; i < result.Count; i++) { foreach (var item in result[i].Directories) { result.Add(item); } } return result; }
private static void compareDirectoriesHelper(DirectoryObject left, DirectoryObject right, DirectoryObjectDiff result) { // ## Items missing in left Directory ## //find directories that exist in right but not in left var dirsMissingLeft = right.Directories.Where(x => !left.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => getAllSubdirectories(x)) .Aggregate((l1, l2) => l1.Union <DirectoryObject>(l2)); //find files that exist in right but not in left var filesMissingLeft = right.Files.Where(x => !left.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())); //add all files from all the directories missing from left filesMissingLeft = filesMissingLeft.Union(dirsMissingLeft.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2))); //copy directories in the list and remove the files dirsMissingLeft = dirsMissingLeft.Select(x => { var copy = x.Clone(0); copy.ClearFiles(); return(copy); }); // ## Items missing in right Directory ## //find directories that exist in left but not in right var dirsMissingRight = left.Directories.Where(x => !right.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => getAllSubdirectories(x)) .Aggregate((l1, l2) => l1.Union <DirectoryObject>(l2)); //find files that exist in left but not in right var filesMissingRight = left.Files.Where(x => !right.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())); //add all files from all the directories missing from right filesMissingRight = filesMissingRight.Union(dirsMissingRight.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2))); //make dirsMissingLeft (list of trees) to a simple list of directories (minus files) dirsMissingRight = dirsMissingRight.Select(x => { var copy = x.Clone(0); copy.ClearFiles(); return(copy); }); // ## Conflicts ## //find files that exist in both directories but are not equal var fileConflicts = right.Files.Where(x => left.Files.Any(y => y.Name.ToLower() == x.Name.ToLower())) .Select(x => new Tuple <FileObject, FileObject>(left.GetFile(x.Name), x)) .Where(x => !compareFileObject(x.Item1, x.Item2)); //add the newy-found conflicts to the existing result result.DirectoriesMissigFromLeft = result.DirectoriesMissigFromLeft.Union <DirectoryObject>(dirsMissingLeft).ToList <DirectoryObject>(); result.DirectoriesMissingFromRight = result.DirectoriesMissingFromRight.Union <DirectoryObject>(dirsMissingRight).ToList <DirectoryObject>(); result.FilesMissingFromLeft = result.FilesMissingFromLeft.Union <FileObject>(filesMissingLeft); result.FilesMissingFromRight = result.FilesMissingFromRight.Union <FileObject>(filesMissingRight); // ## Recursion ## foreach (var item in left.Directories.Where(x => right.Directories.Any(y => y.Name.ToLower() == x.Name.ToLower()))) { compareDirectoriesHelper(item, right.GetDirectory(item.Name), result); } }
private static IEnumerable <FileObject> getAllFiles(DirectoryObject dir) { var dirs = getAllSubdirectories(dir); return(dirs.Select(x => x.Files).Aggregate((l1, l2) => l1.Union(l2))); }
public virtual void LoadFromDisk(int depth = -1) { logger.Info("Loading Directory {0}", LocalPath); if (!Directory.Exists(this.LocalPath)) throw new DirectoryNotFoundException(String.Format("Directory '{0}' not found", LocalPath)); DirectoryInfo info = new DirectoryInfo(LocalPath); this.Name = info.Name; this.Created = info.CreationTimeUtc; this.LastEdited = info.LastWriteTimeUtc; // ## Update files ## try { foreach (string item in Directory.GetFiles(LocalPath)) { string fileName = System.IO.Path.GetFileName(item); if (files.ContainsKey(fileName)) { files[fileName].LoadFromDisk(); } else { FileObject newFile = new FileObject(); newFile.Name = fileName; newFile.LocalPath = item; AddFile(newFile); newFile.LoadFromDisk(); } } } catch (DirectoryNotFoundException) { files = new Dictionary<string, FileObject>(); } //TODO test if this really works! files.Values.Where(x => !File.Exists(LocalPath)).Select(x => files.Remove(x.Name)); // ## Update directories ## try { foreach (string item in Directory.GetDirectories(LocalPath)) { try { string dirName = ExtendedPath.GetDirectoryName(item); if (!directories.ContainsKey(dirName)) { DirectoryObject newDir = new DirectoryObject(); newDir.Name = dirName; newDir.LocalPath = item; if (depth > 1 || depth < 0) { newDir.LoadFromDisk(depth - 1); } AddDirectory(newDir); } } catch (IOException) { } } } catch (DirectoryNotFoundException) { directories = new Dictionary<string, DirectoryObject>(); } directories.Values.Where(x => !Directory.Exists(x.LocalPath)).Select(x => directories.Remove(x.Name)); directories.Values.Select(x => { x.LoadFromDisk(); return x; }); }
public override void Deserialize(XElement xmlData) { base.Deserialize(xmlData); files = new Dictionary<string, FileObject>(); foreach (XElement item in xmlData.Element(XmlNamesExtended.Files).Elements(XmlNamesExtended.FileObject)) { FileObject newFile = new FileObject(); newFile.Deserialize(item); files.Add(newFile.Name.ToLower(), newFile); } directories = new Dictionary<string, DirectoryObject>(); foreach (XElement item in xmlData.Element(XmlNamesExtended.Directories).Elements(XmlNamesExtended.DirectoryObject)) { DirectoryObject newDir = new DirectoryObject(); newDir.Deserialize(item); directories.Add(newDir.Name.ToLower(), newDir); } }
/// <summary> /// Clones the directory and all it's files and directoris to a certain depth /// </summary> /// <param name="depth">Specifies how many levels to go down (items deeper in the hierachy will neither be cloned nor be referenced uncloned)</param> /// <returns>Returns a new DirectoryObjects which's member are all copies of this DirectoryObject</returns> public DirectoryObject Clone(int depth) { DirectoryObject copy = new DirectoryObject(); //Clone ServiceName values copy.Created = this.Created; copy.LastEdited = this.LastEdited; copy.LocalPath = this.LocalPath; copy.Name = this.Name; copy.Parent = this.Parent; //Clone all child directories if (depth > 0) { foreach (DirectoryObject dir in directories.Values) { copy.AddDirectory(dir.Clone(depth-1)); } } //Clones files in this directory foreach (FileObject file in files.Values) { copy.AddFile(file.Clone()); } return copy; }
/// <summary> /// Adds a directory to the data-structure /// </summary> /// <param name="dir"></param> public void AddDirectory(DirectoryObject dir) { if (!files.ContainsKey(dir.Name.ToLower()) && !directories.ContainsKey(dir.Name.ToLower())) { directories.Add(dir.Name.ToLower(), dir); dir.Parent = this; } }