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);
}
