Beispiel #1
0
        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 = AzureBlobStorageApi.PathCombine(path.Directory.Parent.FullName, name);

                // Move file
                await AzureBlobStorageApi.MoveDirectoryAsync(path.Directory.FullName, newPath);

                // Add it to added entries list
                response.Added.Add(await BaseModel.CreateAsync(new AzureBlobDirectory(newPath), path.RootVolume));
            }
            else
            {
                // Get new path
                var newPath = AzureBlobStorageApi.PathCombine(path.File.DirectoryName ?? string.Empty, name);

                // Move file
                await AzureBlobStorageApi.MoveFileAsync(path.File.FullName, newPath);

                // Add it to added entries list
                response.Added.Add(await CustomBaseModel.CustomCreateAsync(new AzureBlobFile(newPath), path.RootVolume));
            }

            return(await Json(response));
        }
Beispiel #2
0
        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));
        }