public static string GetBaseTraktImagesPath() { string filePath = Path.Combine(GetBaseImagesPath(), "Trakt"); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public static string GetTraktImagePath() { string filePath = GetBaseTraktImagesPath(); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public static string GetImagesTempFolder() { string filePath = Path.Combine(GetBaseImagesPath(), "_Temp_"); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public static string GetBaseAniDBCreatorImagesPath() { string filePath = Path.Combine(GetBaseImagesPath(), "AniDB_Creator"); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public static string GetTraktImagePath_Avatars() { string filePath = Path.Combine(GetTraktImagePath(), "Avatars"); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public static bool CheckAccessToPath(string iPath) { string UniqueDirName = iPath + "kumo@Path@Check@Dir"; try { Directory.CreateDirectory(UniqueDirName); Directory.Delete(UniqueDirName); return(true); } catch (Exception e) { return(false); } }
public void TestCreateWithFileSecurity() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); try { Directory.CreateDirectory(tempLongPathFilename, new DirectorySecurity()); Assert.IsTrue(Directory.Exists(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public IResult <Result.InternalTypes.Void> CreateDirectory(string path) { try { ValidateNameLength(path); Directory.CreateDirectory(path); return(new SuccessResult()); } catch (Exception e) { return(new FailureResult(e)); } }
public void SetUp() { rootTestDir = TestContext.CurrentContext.TestDirectory; longPathDirectory = Util.MakeLongPath(rootTestDir); longPathRoot = longPathDirectory.Substring(0, TestContext.CurrentContext.TestDirectory.Length + 1 + longPathDirectory.Substring(rootTestDir.Length + 1).IndexOf('\\')); Directory.CreateDirectory(longPathDirectory); Debug.Assert(Directory.Exists(longPathDirectory)); longPathFilename = new StringBuilder(longPathDirectory).Append(@"\").Append(Filename).ToString(); using (var writer = File.CreateText(longPathFilename)) { writer.WriteLine("test"); } Debug.Assert(File.Exists(longPathFilename)); }
public static void CopyFile(string from, string to) { string directoryName = Path.GetDirectoryName(to); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } // FileUtil.CopyFileOrDirectory(from, to); try { File.Copy(from, to, true); } catch (Exception ex) { //Debug.LogError (string.Format ("{0}: {1}", ex.Message, ex.StackTrace)); } }
public void TestCreateDirectoryThatEndsWithSlash() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName() + @"\"); var di = Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsNotNull(di); Assert.IsTrue(Directory.Exists(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestGetCreationTime() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { var dateTime = Directory.GetCreationTime(tempLongPathFilename); var fi = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(fi.CreationTime, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestSetLastAccessTime() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { DateTime dateTime = DateTime.Now.AddDays(1); Directory.SetLastAccessTime(tempLongPathFilename, dateTime); var fi = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(fi.LastAccessTime, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestEnumerateDirectoriesWithSearch() { var randomFileName = Path.GetRandomFileName(); var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.EnumerateDirectories(uncDirectory, "*").ToArray(); Assert.AreEqual(1, dirs.Length); Assert.IsTrue(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestGetDirectoriesWithSearchWithNoResults() { var randomFileName = Path.GetRandomFileName(); var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.GetDirectories(uncDirectory, "gibberish").ToArray(); Assert.AreEqual(0, dirs.Length); Assert.IsFalse(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestSetCreationTimeUtc() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { DateTime dateTime = DateTime.UtcNow.AddDays(1); Directory.SetCreationTimeUtc(tempLongPathFilename, dateTime); var di = new DirectoryInfo(tempLongPathFilename); Assert.AreEqual(di.CreationTimeUtc, dateTime); } finally { Directory.Delete(tempLongPathFilename); } }
public void TestRecursiveEnumerateDirectoriesWithSingleSubsetSearch() { var randomFileName = "TestRecursiveEnumerateDirectoriesWithSubsetSearch"; var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName); Directory.CreateDirectory(tempLongPathFilename); try { var dirs = Directory.EnumerateDirectories(uncDirectory, "T*", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(1, dirs.Length); Assert.IsTrue(dirs.Contains(tempLongPathFilename)); } finally { Directory.Delete(tempLongPathFilename); } }
//Source: https://github.com/WindowsNotifications/desktop-toasts public static async Task <Option <Uri> > DownloadImageToDisk(Some <Uri> httpImage) { // Toasts can live for up to 3 days, so we cache images for up to 3 days. // Note that this is a very simple cache that doesn't account for space usage, so // this could easily consume a lot of space within the span of 3 days. try { if (DesktopNotificationManagerCompat.CanUseHttpImages) { return(httpImage.Value); } var directory = Directory.CreateDirectory(Path.GetTempPath() + "github.com.trondr.FiveChecks"); foreach (var d in directory.EnumerateDirectories()) { if (d.CreationTimeUtc.Date < DateTime.UtcNow.Date.AddDays(-3)) { d.Delete(true); } } var dayDirectory = directory.CreateSubdirectory($"{DateTime.UtcNow.Day}"); string imagePath = dayDirectory.FullName + "\\" + (uint)httpImage.Value.GetHashCode() + ".jpg"; if (File.Exists(imagePath)) { return(new Uri("file://" + imagePath)); } using (var c = new HttpClient()) { using (var stream = await c.GetStreamAsync(httpImage.Value).ConfigureAwait(false)) { using (var fileStream = File.OpenWrite(imagePath)) { stream.CopyTo(fileStream); } } } return(new Uri("file://" + imagePath)); } catch (HttpRequestException) { return(Option <Uri> .None); } }
public void TestGetRecursiveDirectoriesWithSubsetSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, "TestGetRecursiveDirectoriesWithSubsetSearch"); Directory.CreateDirectory(tempLongPathFilename); var tempLongPathFilename2 = Path.Combine(tempLongPathFilename, "ATestGetRecursiveDirectoriesWithSubsetSearch"); Directory.CreateDirectory(tempLongPathFilename2); try { Assert.AreEqual(1, Directory.GetDirectories(uncDirectory, "A*", System.IO.SearchOption.AllDirectories).Count()); } finally { Directory.Delete(tempLongPathFilename2); Directory.Delete(tempLongPathFilename); } }
public void TestGetDirectoriesWithAnySearch() { var tempLongPathFilename = Path.Combine(uncDirectory, "TestGetDirectoriesWithAnySearch"); Directory.CreateDirectory(tempLongPathFilename); var tempLongPathFilename2 = Path.Combine(uncDirectory, "ATestGetDirectoriesWithAnySearch"); Directory.CreateDirectory(tempLongPathFilename2); try { Assert.AreEqual(2, Directory.GetDirectories(uncDirectory, "*").Count()); } finally { Directory.Delete(tempLongPathFilename); Directory.Delete(tempLongPathFilename2); } }
public void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs) { if (destDirName.StartsWith(sourceDirName)) { throw new Exception("Could not copy parent folder into child folder. This will cause infinite recursive copy"); } // Get the subdirectories for the specified directory. DirectoryInfo dir = new DirectoryInfo(sourceDirName); if (!dir.Exists) { throw new DirectoryNotFoundException( "Source directory does not exist or could not be found: " + sourceDirName); } DirectoryInfo[] dirs = dir.GetDirectories(); // If the destination directory doesn't exist, create it. if (!Directory.Exists(destDirName)) { Directory.CreateDirectory(destDirName); } // Get the files in the directory and copy them to the new location. var files = dir.GetFiles(); foreach (var file in files) { string temppath = _pathManager.Combine(destDirName, file.Name); file.CopyTo(temppath, false); } // If copying subdirectories, copy them and their contents to new location. if (!copySubDirs) { return; } foreach (DirectoryInfo subdir in dirs) { string temppath = _pathManager.Combine(destDirName, subdir.Name); DirectoryCopy(subdir.FullName, temppath, true); } }
static void CopyFiles(string source, string dest, bool move, bool includeArchives = true) { if (move) { MarkFolderWritable(source); } MarkFolderWritable(dest); Console.WriteLine("{0} {1} => {2}", move ? "Moving" : "Copying", source, dest); source = source.TrimEnd('\\'); dest = dest.TrimEnd('\\'); if (!Directory.Exists(dest)) { Directory.CreateDirectory(dest); } Directory.EnumerateDirectories(source, "*", SearchOption.AllDirectories).Select(d => d.Replace(source, dest)).ForEach(path => Directory.CreateDirectory(path)); foreach (var file in Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories).Where(f => Path.GetExtension(f) != ".nfo" && !Regex.IsMatch(Path.GetFileName(f), "All.Collection.Upload|WareZ-Audio", RegexOptions.IgnoreCase)).ToArray()) { if (Path.GetExtension(file) == ".sfv") { continue; } //if (!includeArchives && Regex.IsMatch(Path.GetExtension(file), @"\.(rar|r\d+|zip|iso)")) if (!includeArchives && Path.GetDirectoryName(file) == source && Regex.IsMatch(Path.GetExtension(file), @"\.(rar|r\d+|zip)")) { continue; } var newFile = file.Replace(source, dest); if (move) { if (File.Exists(newFile)) { File.Delete(newFile); } File.Move(file, newFile); } else { File.Copy(file, newFile, true); } } }
public static string GetBaseImagesPath() { lock (assemblyLock) { if (Directory.Exists(AppSettings.ImagesPath)) { return(AppSettings.ImagesPath); } string serverpath = AppSettings.JMMServerImagePath; if (Directory.Exists(serverpath)) { return(serverpath); } serverpath = AppSettings.DefaultImagePath; if (!Directory.Exists(serverpath)) { Directory.CreateDirectory(serverpath); } return(serverpath); } }
public void TestGetFileSystemEntriesRecursiveWithSearchWithNoResults() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var files = Directory.GetFileSystemEntries(uncDirectory, "gibberish", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(0, files.Length); Assert.IsFalse(files.Contains(uncFilePath)); Assert.IsFalse(files.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
public void TestEnumerateRecursiveFileSystemEntriesWithSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var entries = Directory.EnumerateFileSystemEntries(uncDirectory, "*", SearchOption.AllDirectories).ToArray(); Assert.AreEqual(3, entries.Length); Assert.IsTrue(entries.Contains(uncFilePath)); Assert.IsTrue(entries.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
public static FileStream saveFile(string fileName, JSONObject node = null) { string directoryName = Path.GetDirectoryName(fileName); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } FileStream fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write); if (node == null) { return(fileStream); } StreamWriter streamWriter = new StreamWriter(fileStream); string value = node.Print(true); streamWriter.Write(value); streamWriter.Close(); return(fileStream); }
public void TestDirectoryEnumerateDirectoriesNearMaxPathLimit() { var uncPathNearMaxPathLimit = Path.Combine(uncDirectory, new string('x', Pri.LongPath.NativeMethods.MAX_PATH - uncDirectory.Length - 2)); Directory.CreateDirectory(uncPathNearMaxPathLimit.Replace(uncDirectory, directory)); var uncPathAboveMaxPathLimit = Path.Combine(uncPathNearMaxPathLimit, "wibble"); Directory.CreateDirectory(uncPathAboveMaxPathLimit); Assert.That(Directory.Exists(uncPathNearMaxPathLimit)); Assert.That(Directory.Exists(uncPathAboveMaxPathLimit)); // there should be one subdirectory inside almostLongPath var subDirs = Directory.EnumerateDirectories(uncPathNearMaxPathLimit).ToArray(); Directory.Delete(uncPathAboveMaxPathLimit); Directory.Delete(uncPathNearMaxPathLimit); Assert.That(subDirs.Length, Is.EqualTo(1)); }
public static string GetAniDBImagePath(int animeID) { string subFolder = ""; string sid = animeID.ToString(); if (sid.Length == 1) { subFolder = sid; } else { subFolder = sid.Substring(0, 2); } string filePath = Path.Combine(GetBaseAniDBImagesPath(), subFolder); if (!Directory.Exists(filePath)) { Directory.CreateDirectory(filePath); } return(filePath); }
public void TestGetRecursiveFilesWithSubsetSearch() { var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename); try { Assert.IsTrue(Directory.Exists(tempLongPathFilename)); var randomFileName = Util.CreateNewEmptyFile(tempLongPathFilename); var searchPattern = Path.GetFileName(randomFileName).Substring(0, 3) + "*" + Path.GetExtension(randomFileName); var files = Directory.GetFiles(uncDirectory, searchPattern, SearchOption.AllDirectories).ToArray(); Assert.AreEqual(1, files.Length); Assert.IsFalse(files.Contains(uncFilePath)); Assert.IsTrue(files.Contains(randomFileName)); } finally { const bool recursive = true; Directory.Delete(tempLongPathFilename, recursive); } }
public void TestMove() { var tempLongPathFilename1 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename1); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); var tempLongPathFilename2 = Path.Combine(uncDirectory, Path.GetRandomFileName()); Directory.CreateDirectory(tempLongPathFilename2); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); string destinationPath = Path.GetFullPath(Path.Combine(tempLongPathFilename1, Path.GetFileName(tempLongPathFilename2))); Directory.Move(tempLongPathFilename2, destinationPath); Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1))); Assert.IsFalse(Directory.Exists(Path.GetFullPath(tempLongPathFilename2))); Assert.IsTrue(Directory.Exists(destinationPath)); const bool recursive = true; Directory.Delete(tempLongPathFilename1, recursive); Directory.Delete(tempLongPathFilename2, recursive); }