public async Task <JsonResult> RenameAsync(FullPath path, string name)
{
var response = new ReplaceResponseModel();
response.Removed.Add(path.HashedTarget);
await RemoveThumbsAsync(path);
if (path.IsDirectory)
{
// Get new path
var newPath = AzureStorageAPI.PathCombine(path.Directory.Parent.FullName, name);
// Move file
await AzureStorageAPI.MoveDirectoryAsync(path.Directory.FullName, newPath);
// Add it to added entries list
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageDirectory(newPath), path.RootVolume));
}
else
{
// Get new path
var newPath = AzureStorageAPI.PathCombine(path.File.DirectoryName ?? string.Empty, name);
// Move file
await AzureStorageAPI.MoveFileAsync(path.File.FullName, newPath);
// Add it to added entries list
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(newPath), path.RootVolume));
}
return(await Json(response));
}
public async Task <ConnectorResult> MakeDirAsync(FullPath path, string name, IEnumerable <string> dirs)
{
var response = new AddResponseModel();
if (!string.IsNullOrEmpty(name))
{
var newDir = new FileSystemDirectory(Path.Combine(path.Directory.FullName, name));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
}
foreach (string dir in dirs)
{
string dirName = dir.StartsWith("/") ? dir.Substring(1) : dir;
var newDir = new FileSystemDirectory(Path.Combine(path.Directory.FullName, dirName));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
string relativePath = newDir.FullName.Substring(path.RootVolume.RootDirectory.Length);
response.Hashes.Add($"/{dirName}", path.RootVolume.VolumeId + HttpEncoder.EncodePath(relativePath));
}
return(new ConnectorResult(response));
}
public async Task <JsonResult> ParentsAsync(FullPath path)
{
var response = new TreeResponseModel();
if (path.Directory.FullName == path.RootVolume.RootDirectory)
{
response.Tree.Add(await BaseModel.CreateAsync(path.Directory, path.RootVolume));
}
else
{
var parent = path.Directory;
foreach (var item in await parent.Parent.GetDirectoriesAsync())
{
response.Tree.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
while (parent.FullName != path.RootVolume.RootDirectory)
{
parent = parent.Parent;
response.Tree.Add(await BaseModel.CreateAsync(parent, path.RootVolume));
}
}
return(await Json(response));
}
public async Task <JsonResult> PasteAsync(FullPath dest, IEnumerable <FullPath> paths, bool isCut, IEnumerable <string> renames, string suffix)
{
var response = new ReplaceResponseModel();
var pathList = paths.ToList();
foreach (var src in pathList)
{
if (src.IsDirectory)
{
var newDir = new AzureBlobDirectory(AzureBlobStorageApi.PathCombine(dest.Directory.FullName, src.Directory.Name));
// Check if it already exists
if (await newDir.ExistsAsync)
{
await newDir.DeleteAsync();
}
if (isCut)
{
await RemoveThumbsAsync(src);
await AzureBlobStorageApi.MoveDirectoryAsync(src.Directory.FullName, newDir.FullName);
response.Removed.Add(src.HashedTarget);
}
else
{
// Copy directory
await AzureBlobStorageApi.CopyDirectoryAsync(src.Directory.FullName, newDir.FullName);
}
response.Added.Add(await BaseModel.CreateAsync(newDir, dest.RootVolume));
}
else
{
var newFilePath = AzureBlobStorageApi.PathCombine(dest.Directory.FullName, src.File.Name);
await AzureBlobStorageApi.DeleteFileIfExistsAsync(newFilePath);
if (isCut)
{
await RemoveThumbsAsync(src);
// Move file
await AzureBlobStorageApi.MoveFileAsync(src.File.FullName, newFilePath);
response.Removed.Add(src.HashedTarget);
}
else
{
// Copy file
await AzureBlobStorageApi.CopyFileAsync(src.File.FullName, newFilePath);
}
response.Added.Add(await CustomBaseModel.CustomCreateAsync(new AzureBlobFile(newFilePath), dest.RootVolume));
}
}
return(await Json(response));
}
public async Task <JsonResult> MakeDirAsync(FullPath path, string name, IEnumerable <string> dirs)
{
var response = new AddResponseModel();
if (!string.IsNullOrEmpty(name))
{
// Create directory
var newDir = new AzureStorageDirectory(AzureStorageAPI.PathCombine(path.Directory.FullName, name));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
}
if (dirs.Any())
{
foreach (string dir in dirs)
{
string dirName = dir.StartsWith("/") ? dir.Substring(1) : dir;
var newDir = new AzureStorageDirectory(AzureStorageAPI.PathCombine(path.Directory.FullName, dirName));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
string relativePath = newDir.FullName.Substring(path.RootVolume.RootDirectory.Length);
response.Hashes.Add($"/{dirName}", path.RootVolume.VolumeId + HttpEncoder.EncodePath(relativePath));
}
}
return(await Json(response));
}
public async Task <ConnectorResult> SearchAsync(FullPath path, string query, IEnumerable <string> mimeTypes)
{
var response = new SearchResponseModel();
if (!query.Any(Path.GetInvalidFileNameChars().Contains))
{
foreach (var item in await path.Directory.GetFilesAsync(mimeTypes, string.Concat("*", query, "*")))
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden) && !item.Directory.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
if (!mimeTypes.Any())
{
foreach (var item in await path.Directory.GetDirectoriesAsync(string.Concat("*", query, "*")))
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
}
}
return(new ConnectorResult(response));
}
public async Task <ConnectorResult> ArchiveAsync(FullPath parentPath, IEnumerable <FullPath> paths, string filename, string mimeType)
{
var response = new AddResponseModel();
if (paths == null)
{
throw new NotSupportedException();
}
if (mimeType != "application/zip")
{
throw new NotSupportedException("Only .zip files are currently supported.");
}
// Parse target path
var directoryInfo = parentPath.Directory;
if (directoryInfo != null)
{
if (filename is null)
{
filename = "newfile";
}
if (filename.EndsWith(".zip"))
{
filename = filename.Replace(".zip", "");
}
string newPath = Path.Combine(directoryInfo.FullName, filename + ".zip");
if (File.Exists(newPath))
{
File.Delete(newPath);
}
using (var newFile = ZipFile.Open(newPath, ZipArchiveMode.Create))
{
foreach (var tg in paths)
{
if (tg.IsDirectory)
{
await AddDirectoryToArchiveAsync(newFile, tg.Directory, "");
}
else
{
newFile.CreateEntryFromFile(tg.File.FullName, tg.File.Name);
}
}
}
response.Added.Add(await BaseModel.CreateAsync(new FileSystemFile(newPath), parentPath.RootVolume));
}
return(new ConnectorResult(response));
}
public async Task <ConnectorResult> MakeFileAsync(FullPath path, string name)
{
var newFile = new FileSystemFile(Path.Combine(path.Directory.FullName, name));
await newFile.CreateAsync();
var response = new AddResponseModel();
response.Added.Add(await BaseModel.CreateAsync(newFile, path.RootVolume));
return(new ConnectorResult(response));
}
public async Task <JsonResult> MakeFileAsync(FullPath path, string name)
{
var newFile = new AzureStorageFile(AzureStorageAPI.PathCombine(path.Directory.FullName, name));
await newFile.CreateAsync();
var response = new AddResponseModel();
response.Added.Add(await BaseModel.CreateAsync(newFile, path.RootVolume));
return(await Json(response));
}
public async Task <JsonResult> PutAsync(FullPath path, byte[] content)
{
var response = new ChangedResponseModel();
// Write content
await AzureStorageAPI.PutAsync(path.File.FullName, content);
response.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(await Json(response));
}
public async Task <JsonResult> InitAsync(FullPath path, IEnumerable <string> mimeTypes)
{
if (path == null)
{
var root = Roots.FirstOrDefault(r => r.StartDirectory != null);
if (root == null)
{
root = Roots.First();
}
path = new FullPath(root, new FileSystemDirectory(root.StartDirectory ?? root.RootDirectory), null);
}
var response = new InitResponseModel(await BaseModel.CreateAsync(path.Directory, path.RootVolume), new Options(path));
foreach (var item in await path.Directory.GetFilesAsync(mimeTypes))
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
foreach (var item in await path.Directory.GetDirectoriesAsync())
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
foreach (var item in Roots)
{
response.Files.Add(await BaseModel.CreateAsync(new FileSystemDirectory(item.RootDirectory), item));
}
if (path.RootVolume.RootDirectory != path.Directory.FullName)
{
var dirInfo = new DirectoryInfo(path.RootVolume.RootDirectory);
foreach (var item in dirInfo.GetDirectories())
{
var attributes = item.Attributes;
if (!attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(new FileSystemDirectory(item), path.RootVolume));
}
}
}
if (path.RootVolume.MaxUploadSize.HasValue)
{
response.Options.UploadMaxSize = $"{path.RootVolume.MaxUploadSizeInKb.Value}K";
}
return(await Json(response));
}
public async Task <JsonResult> PutAsync(FullPath path, byte[] content)
{
var response = new ChangedResponseModel();
using (var fileStream = new FileStream(path.File.FullName, FileMode.Create))
using (var writer = new BinaryWriter(fileStream))
{
writer.Write(content);
}
response.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(await Json(response));
}
public async Task <ConnectorResult> PutAsync(FullPath path, string content)
{
var response = new ChangedResponseModel();
using (var fileStream = new FileStream(path.File.FullName, FileMode.Create))
using (var writer = new StreamWriter(fileStream))
{
writer.Write(content);
}
response.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(new ConnectorResult(response));
}
public async Task <JsonResult> PasteAsync(FullPath dest, IEnumerable <FullPath> paths, bool isCut, IEnumerable <string> renames, string suffix)
{
var response = new ReplaceResponseModel();
foreach (var src in paths)
{
if (src.IsDirectory)
{
var newDir = new FileSystemDirectory(Path.Combine(dest.Directory.FullName, src.Directory.Name));
if (await newDir.ExistsAsync)
{
Directory.Delete(newDir.FullName, true);
}
if (isCut)
{
await RemoveThumbsAsync(src);
Directory.Move(src.Directory.FullName, newDir.FullName);
response.Removed.Add(src.HashedTarget);
}
else
{
DirectoryCopy(src.Directory.FullName, newDir.FullName, true);
}
response.Added.Add(await BaseModel.CreateAsync(newDir, dest.RootVolume));
}
else
{
var newFile = new FileSystemFile(Path.Combine(dest.Directory.FullName, src.File.Name));
if (await newFile.ExistsAsync)
{
await newFile.DeleteAsync();
}
if (isCut)
{
await RemoveThumbsAsync(src);
File.Move(src.File.FullName, newFile.FullName);
response.Removed.Add(src.HashedTarget);
}
else
{
File.Copy(src.File.FullName, newFile.FullName);
}
response.Added.Add(await BaseModel.CreateAsync(newFile, dest.RootVolume));
}
}
return(await Json(response));
}
public async Task <JsonResult> OpenAsync(FullPath path, bool tree, IEnumerable <string> mimeTypes)
{
var response = new OpenResponse(await BaseModel.CreateAsync(path.Directory, path.RootVolume), path);
// Get all files and directories
var items = await AzureStorageAPI.ListFilesAndDirectoriesAsync(path.Directory.FullName);
// Add visible files
foreach (var file in items.Where(i => i is CloudFile))
{
var f = new AzureStorageFile(file as CloudFile);
if (!f.Attributes.HasFlag(FileAttributes.Hidden))
{
if (mimeTypes != null && mimeTypes.Count() > 0 && !mimeTypes.Contains(f.MimeType) && !mimeTypes.Contains(f.MimeType.Type))
{
continue;
}
response.Files.Add(await BaseModel.CreateAsync(f, path.RootVolume));
}
}
// Add visible directories
foreach (var dir in items.Where(i => i is CloudFileDirectory))
{
var d = new AzureStorageDirectory(dir as CloudFileDirectory);
if (!d.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(d, path.RootVolume));
}
}
// Add parents
if (tree)
{
var parent = path.Directory;
while (parent != null && parent.FullName != path.RootVolume.RootDirectory)
{
// Update parent
parent = parent.Parent;
// Ensure it's a child of the root
if (parent != null && path.RootVolume.RootDirectory.Contains(parent.FullName))
{
response.Files.Insert(0, await BaseModel.CreateAsync(parent, path.RootVolume));
}
}
}
return(await Json(response));
}
public async Task <JsonResult> TreeAsync(FullPath path)
{
var response = new TreeResponseModel();
foreach (var item in await path.Directory.GetDirectoriesAsync())
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Tree.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
return(await Json(response));
}
/// <summary>
/// Сохранить текстовый документ
/// </summary>
/// <param name="target">Цель в формате elFinder</param>
/// <param name="content">Текст</param>
/// <param name="conv">Кодировка</param>
async public Task <JsonResult> PutAsync(FullPath path, string content, string conv)
{
var response = new ChangedResponseModel();
using (var fileStream = new FileStream(path.File.FullName, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, GetEncoding(conv)))
{
writer.Write(content);
}
}
response.Changed.Add((FileModel)await BaseModel.CreateAsync(this, path.File, path.RootVolume));
return(Json(response));
}
public async Task <JsonResult> TreeAsync(FullPath path)
{
var response = new TreeResponseModel();
var items = await AzureStorageAPI.ListFilesAndDirectoriesAsync(path.Directory.FullName);
// Add visible directories
foreach (var dir in items.Where(i => i is CloudFileDirectory))
{
var d = new AzureStorageDirectory(dir as CloudFileDirectory);
if (!d.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Tree.Add(await BaseModel.CreateAsync(d, path.RootVolume));
}
}
return(await Json(response));
}
public async Task <JsonResult> RotateAsync(FullPath path, int degree)
{
await RemoveThumbsAsync(path);
// Crop Image
ImageWithMimeType image;
using (var stream = await path.File.OpenReadAsync())
{
image = path.RootVolume.PictureEditor.Rotate(stream, degree);
}
await AzureStorageAPI.PutAsync(path.File.FullName, image.ImageStream);
var output = new ChangedResponseModel();
output.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(await Json(output));
}
public async Task <JsonResult> ResizeAsync(FullPath path, int width, int height)
{
await RemoveThumbsAsync(path);
// Resize Image
ImageWithMimeType image;
await using (var stream = await path.File.OpenReadAsync())
{
image = path.RootVolume.PictureEditor.Resize(stream, width, height);
}
await AzureBlobStorageApi.PutAsync(path.File.FullName, image.ImageStream);
var output = new ChangedResponseModel();
output.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(await Json(output));
}
public async Task <JsonResult> OpenAsync(FullPath path, bool tree, IEnumerable <string> mimeTypes)
{
var response = new OpenResponse(await BaseModel.CreateAsync(path.Directory, path.RootVolume), path);
foreach (var item in await path.Directory.GetFilesAsync(mimeTypes))
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
foreach (var item in await path.Directory.GetDirectoriesAsync())
{
if (!item.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(item, path.RootVolume));
}
}
// Add parents
if (tree)
{
var parent = path.Directory;
var rootDirectory = new DirectoryInfo(path.RootVolume.RootDirectory);
while (parent != null && parent.Name != rootDirectory.Name)
{
// Update parent
parent = parent.Parent;
// Ensure it's a child of the root
if (parent != null && path.RootVolume.RootDirectory.Contains(parent.Name))
{
response.Files.Insert(0, await BaseModel.CreateAsync(parent, path.RootVolume));
}
}
}
return(await Json(response));
}
public async Task <ConnectorResult> RotateAsync(FullPath path, int degree)
{
await RemoveThumbsAsync(path);
// Rotate Image
ImageWithMimeType image;
using (var stream = new FileStream(path.File.FullName, FileMode.Open))
{
image = path.RootVolume.PictureEditor.Rotate(stream, degree);
}
using (var fileStream = File.Create(path.File.FullName))
{
await image.ImageStream.CopyToAsync(fileStream);
}
var output = new ChangedResponseModel();
output.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(new ConnectorResult(output));
}
public async Task <JsonResult> RenameAsync(FullPath path, string name)
{
var response = new ReplaceResponseModel();
response.Removed.Add(path.HashedTarget);
await RemoveThumbsAsync(path);
if (path.IsDirectory)
{
var newPath = new FileSystemDirectory(Path.Combine(path.Directory.Parent.FullName, name));
Directory.Move(path.Directory.FullName, newPath.FullName);
response.Added.Add(await BaseModel.CreateAsync(newPath, path.RootVolume));
}
else
{
var newPath = new FileSystemFile(Path.Combine(path.File.DirectoryName, name));
File.Move(path.File.FullName, newPath.FullName);
response.Added.Add(await BaseModel.CreateAsync(newPath, path.RootVolume));
}
return(await Json(response));
}
public async Task <JsonResult> CropAsync(FullPath path, int x, int y, int width, int height)
{
await RemoveThumbsAsync(path);
// Crop Image
ImageWithMimeType image;
using (var stream = new FileStream(path.File.FullName, FileMode.Open))
{
image = path.RootVolume.PictureEditor.Crop(stream, x, y, width, height);
}
using (var fileStream = File.Create(path.File.FullName))
{
await image.ImageStream.CopyToAsync(fileStream);
}
var output = new ChangedResponseModel();
output.Changed.Add(await BaseModel.CreateAsync(path.File, path.RootVolume));
return(await Json(output));
}
public async Task <JsonResult> MakeDirAsync(FullPath path, string name, IEnumerable <string> dirs)
{
var response = new AddResponseModel();
if (!string.IsNullOrEmpty(name))
{
// Create directory
var newDir = new AzureBlobDirectory(AzureBlobStorageApi.PathCombine(path.Directory.FullName, name));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
}
var enumerable = dirs as string[] ?? dirs.ToArray();
if (!enumerable.Any())
{
return(await Json(response));
}
foreach (var dir in enumerable)
{
var dirName = dir.StartsWith("/") ? dir.Substring(1) : dir;
var newDir = new AzureBlobDirectory(AzureBlobStorageApi.PathCombine(path.Directory.FullName, dirName));
await newDir.CreateAsync();
response.Added.Add(await BaseModel.CreateAsync(newDir, path.RootVolume));
var relativePath = newDir.FullName.Substring(path.RootVolume.RootDirectory.Length);
// response.Hashes.Add(new KeyValuePair<string, string>($"/{dirName}", path.RootVolume.VolumeId + HttpEncoder.EncodePath(relativePath)));
response.Hashes.Add($"/{dirName}", path.RootVolume.VolumeId + HttpEncoder.EncodePath(relativePath));
}
return(await Json(response));
}
public async Task <JsonResult> UploadAsync(FullPath path, IEnumerable <IFormFile> files, bool?overwrite, IEnumerable <FullPath> uploadPaths, IEnumerable <string> renames, string suffix)
{
var response = new AddResponseModel();
// Check if max upload size is set and that no files exceeds it
if (path.RootVolume.MaxUploadSize.HasValue && files.Any(x => x.Length > path.RootVolume.MaxUploadSize))
{
// Max upload size exceeded
return(Error.MaxUploadFileSize());
}
foreach (string rename in renames)
{
var fileInfo = new FileInfo(Path.Combine(path.Directory.FullName, rename));
string destination = Path.Combine(path.Directory.FullName, $"{Path.GetFileNameWithoutExtension(rename)}{suffix}{Path.GetExtension(rename)}");
fileInfo.MoveTo(destination);
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(destination), path.RootVolume));
}
foreach (var uploadPath in uploadPaths)
{
var dir = uploadPath.Directory;
while (dir.FullName != path.RootVolume.RootDirectory)
{
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageDirectory(dir.FullName), path.RootVolume));
dir = dir.Parent;
}
}
var i = 0;
foreach (var file in files)
{
string destination = uploadPaths.Count() > i?uploadPaths.ElementAt(i).Directory.FullName : path.Directory.FullName;
var azureFile = new AzureStorageFile(AzureStorageAPI.PathCombine(destination, Path.GetFileName(file.FileName)));
if (await azureFile.ExistsAsync)
{
if (overwrite ?? path.RootVolume.UploadOverwrite)
{
await azureFile.DeleteAsync();
await AzureStorageAPI.UploadAsync(file, azureFile.FullName);
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(azureFile.FullName), path.RootVolume));
}
else
{
var newName = await CreateNameForCopy(azureFile, suffix);
await AzureStorageAPI.UploadAsync(file, AzureStorageAPI.PathCombine(azureFile.DirectoryName, newName));
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(newName), path.RootVolume));
}
}
else
{
await AzureStorageAPI.UploadAsync(file, azureFile.FullName);
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(azureFile.FullName), path.RootVolume));
}
i++;
}
return(await Json(response));
}
public async Task <JsonResult> DuplicateAsync(IEnumerable <FullPath> paths)
{
var response = new AddResponseModel();
foreach (var path in paths)
{
if (path.IsDirectory)
{
var parentPath = path.Directory.Parent.FullName;
var name = path.Directory.Name;
string newName = $"{parentPath}/{name} copy";
// Check if directory already exists
if (!await AzureStorageAPI.DirectoryExistsAsync(newName))
{
// Doesn't exist
await AzureStorageAPI.CopyDirectoryAsync(path.Directory.FullName, newName);
}
else
{
// Already exists, create numbered copy
var newNameFound = false;
for (int i = 1; i < 100; i++)
{
newName = $"{parentPath}/{name} copy {i}";
// Test that it doesn't exist
if (!await AzureStorageAPI.DirectoryExistsAsync(newName))
{
await AzureStorageAPI.CopyDirectoryAsync(path.Directory.FullName, newName);
newNameFound = true;
break;
}
}
// Check if new name was found
if (!newNameFound)
{
return(Error.NewNameSelectionException($@"{parentPath}/{name} copy"));
}
}
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageDirectory(newName), path.RootVolume));
}
else // File
{
var parentPath = path.File.Directory.FullName;
var name = path.File.Name.Substring(0, path.File.Name.Length - path.File.Extension.Length);
var ext = path.File.Extension;
string newName = $"{parentPath}/{name} copy{ext}";
// Check if file already exists
if (!await AzureStorageAPI.FileExistsAsync(newName))
{
// Doesn't exist
await AzureStorageAPI.CopyFileAsync(path.File.FullName, newName);
}
else
{
// Already exists, create numbered copy
var newNameFound = false;
for (var i = 1; i < 100; i++)
{
// Compute new name
newName = $@"{parentPath}/{name} copy {i}{ext}";
// Test that it doesn't exist
if (!await AzureStorageAPI.FileExistsAsync(newName))
{
await AzureStorageAPI.CopyFileAsync(path.File.FullName, newName);
newNameFound = true;
break;
}
}
// Check if new name was found
if (!newNameFound)
{
return(Error.NewNameSelectionException($@"{parentPath}/{name} copy"));
}
}
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(newName), path.RootVolume));
}
}
return(await Json(response));
}
public async Task <JsonResult> InitAsync(FullPath path, IEnumerable <string> mimeTypes)
{
if (path == null)
{
var root = Roots.FirstOrDefault(r => r.StartDirectory != null);
if (root == null)
{
root = Roots.First();
}
path = new FullPath(root, new AzureStorageDirectory(root.StartDirectory ?? root.RootDirectory), null);
}
var response = new InitResponseModel(await BaseModel.CreateAsync(path.Directory, path.RootVolume), new Options(path));
// Get all files and directories
var items = await AzureStorageAPI.ListFilesAndDirectoriesAsync(path.Directory.FullName);
// Add visible files
foreach (var file in items.Where(i => i is CloudFile))
{
var f = new AzureStorageFile(file as CloudFile);
if (!f.Attributes.HasFlag(FileAttributes.Hidden))
{
if (mimeTypes != null && mimeTypes.Count() > 0 && !mimeTypes.Contains(f.MimeType) && !mimeTypes.Contains(f.MimeType.Type))
{
continue;
}
response.Files.Add(await BaseModel.CreateAsync(f, path.RootVolume));
}
}
// Add visible directories
foreach (var dir in items.Where(i => i is CloudFileDirectory))
{
var d = new AzureStorageDirectory(dir as CloudFileDirectory);
if (!d.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(d, path.RootVolume));
}
}
// Add roots
foreach (var root in Roots)
{
response.Files.Add(await BaseModel.CreateAsync(new AzureStorageDirectory(root.RootDirectory), root));
}
if (path.RootVolume.RootDirectory != path.Directory.FullName)
{
// Get all files and directories
var entries = await AzureStorageAPI.ListFilesAndDirectoriesAsync(path.RootVolume.RootDirectory);
// Add visible directories
foreach (var dir in entries.Where(i => i is CloudFileDirectory))
{
var d = new AzureStorageDirectory(dir as CloudFileDirectory);
if (!d.Attributes.HasFlag(FileAttributes.Hidden))
{
response.Files.Add(await BaseModel.CreateAsync(d, path.RootVolume));
}
}
}
if (path.RootVolume.MaxUploadSize.HasValue)
{
response.Options.UploadMaxSize = $"{path.RootVolume.MaxUploadSizeInKb.Value}K";
}
return(await Json(response));
}
public async Task <JsonResult> ExtractAsync(FullPath fullPath, bool newFolder)
{
var response = new AddResponseModel();
if (fullPath.IsDirectory || fullPath.File.Extension.ToLower() != ".zip")
{
throw new NotSupportedException("Only .zip files are currently supported.");
}
var rootPath = fullPath.File.Directory.FullName;
if (newFolder)
{
// Azure doesn't like directory names that look like a file name i.e. blah.png
// So iterate through the names until there's no more extension
var path = Path.GetFileNameWithoutExtension(fullPath.File.Name);
while (Path.HasExtension(path))
{
path = Path.GetFileNameWithoutExtension(path);
}
rootPath = AzureStorageAPI.PathCombine(rootPath, path);
var rootDir = new AzureStorageDirectory(rootPath);
if (!await rootDir.ExistsAsync)
{
await rootDir.CreateAsync();
}
response.Added.Add(await BaseModel.CreateAsync(rootDir, fullPath.RootVolume));
}
// Create temp file
var archivePath = Path.GetTempFileName();
File.WriteAllBytes(archivePath, await AzureStorageAPI.FileBytesAsync(fullPath.File.FullName));
using (var archive = ZipFile.OpenRead(archivePath))
{
var separator = Path.DirectorySeparatorChar.ToString();
foreach (ZipArchiveEntry entry in archive.Entries)
{
try
{
var file = AzureStorageAPI.PathCombine(rootPath, entry.FullName);
if (file.EndsWith(separator)) //directory
{
var dir = new AzureStorageDirectory(file);
if (!await dir.ExistsAsync)
{
await dir.CreateAsync();
}
if (!newFolder)
{
response.Added.Add(await BaseModel.CreateAsync(dir, fullPath.RootVolume));
}
}
else
{
var filePath = Path.GetTempFileName();
entry.ExtractToFile(filePath, true);
using (var stream = new FileStream(filePath, FileMode.Open))
{
await AzureStorageAPI.PutAsync(file, stream);
}
File.Delete(filePath);
if (!newFolder)
{
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(file), fullPath.RootVolume));
}
}
}
catch //(Exception ex)
{
//throw new Exception(entry.FullName, ex);
}
}
}
File.Delete(archivePath);
return(await Json(response));
}
public async Task <JsonResult> ArchiveAsync(FullPath parentPath, IEnumerable <FullPath> paths, string filename, string mimeType)
{
var response = new AddResponseModel();
if (paths == null)
{
throw new NotSupportedException();
}
if (mimeType != "application/zip")
{
throw new NotSupportedException("Only .zip files are currently supported.");
}
// Parse target path
var directoryInfo = parentPath.Directory;
if (directoryInfo != null)
{
filename ??= "newfile";
if (filename.EndsWith(".zip"))
{
filename = filename.Replace(".zip", "");
}
var newPath = AzureStorageAPI.PathCombine(directoryInfo.FullName, filename + ".zip");
await AzureStorageAPI.DeleteFileIfExistsAsync(newPath);
var archivePath = Path.GetTempFileName();
using (var newFile = ZipFile.Open(archivePath, ZipArchiveMode.Update))
{
foreach (var tg in paths)
{
if (tg.IsDirectory)
{
await AddDirectoryToArchiveAsync(newFile, tg.Directory, "");
}
else
{
var filePath = Path.GetTempFileName();
File.WriteAllBytes(filePath, await AzureStorageAPI.FileBytesAsync(tg.File.FullName));
newFile.CreateEntryFromFile(filePath, tg.File.Name);
}
}
}
using (var stream = new FileStream(archivePath, FileMode.Open))
{
await AzureStorageAPI.PutAsync(newPath, stream);
}
// Cleanup
File.Delete(archivePath);
response.Added.Add(await BaseModel.CreateAsync(new AzureStorageFile(newPath), parentPath.RootVolume));
}
return(await Json(response));
}