private T ExecuteAsync <T>(WsPath path, Func <Task <T> > asyncFunc)
{
using (ThreadKeeper exec = new ThreadKeeper())
{
try
{
return(exec.ExecAsync(async(cancellationToken) =>
{
await EnsureLogin();
return await asyncFunc();
}));
}
catch (Exception ex)
{
try
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
throw;
}
catch (FileNotFoundException)
{
ShowError($"Path {path} not found.", null, false);
return(default(T));
}
catch (DirectoryNotFoundException)
{
ShowError($"Folder {path} not found.", null, false);
return(default(T));
}
}
}
}
public override bool RemoveDir(RemotePath remoteName)
{
if (_moveInProgress)
{
return(true);
}
WsPath wsPath = remoteName;
switch (wsPath.Level)
{
case WsPathLevel.Root:
return(false);
case WsPathLevel.Account:
if (_uiProvider.ShowMessage(string.Format(Resources.TextResource.UnregisterAccount, wsPath.AccountName), true))
{
return(_accountRepository.UnRegisterAccount(_accountRepository[wsPath.AccountName]));
}
return(true);
case WsPathLevel.AccessLevel:
return(false);
default:
return(_accountRepository[wsPath.AccountName].DeleteFolder(wsPath));
}
}
public override async Task <FileSystemExitCode> GetFileAsync(RemotePath remoteName, string localName, CopyFlags copyFlags, RemoteInfo remoteInfo, Action <int> setProgress, CancellationToken cancellationToken)
{
WsPath wsPath = remoteName;
if (wsPath.Level == WsPathLevel.Account && wsPath.AccountName == ADD_NEW_ACCOUNT_TITLE)
{
return(FileSystemExitCode.NotSupported);
}
FileInfo localFileName = new FileInfo(localName);
bool overWrite = (CopyFlags.Overwrite & copyFlags) != 0;
bool performMove = (CopyFlags.Move & copyFlags) != 0;
bool resume = (CopyFlags.Resume & copyFlags) != 0;
if (resume)
{
return(FileSystemExitCode.NotSupported);
}
if (localFileName.Exists && !overWrite)
{
return(FileSystemExitCode.FileExists);
}
return(await _accountRepository[wsPath.AccountName].DownloadFile(
wsPath,
localFileName,
overWrite,
new Progress <int>(setProgress),
performMove,
cancellationToken
));
}
public async Task <FileSystemExitCode> UploadFile(FileInfo sourceFileName, WsPath targetFileName, bool overwrite, IProgress <int> progress, CancellationToken cancellationToken)
{
try
{
await EnsureLogin();
bool uploadDirect = overwrite;
WsFilePath targetFilePath = targetFileName.GetFilePath();
if (overwrite == false)
{
WsFile file = await _apiClient.FindFile(targetFilePath);
if (file != null)
{
if (overwrite == false)
{
return(FileSystemExitCode.FileExists);
}
using (FileStream sourceStream = sourceFileName.OpenRead())
{
await file.Replace(sourceStream, cancellationToken, progress);
}
}
else
{
uploadDirect = true;
}
}
if (uploadDirect)
{
using (FileStream sourceStream = sourceFileName.OpenRead())
{
await _apiClient.UploadFile(sourceStream, sourceStream.Length, targetFilePath, cancellationToken, progress);
}
}
return(FileSystemExitCode.OK);
}
catch (TaskCanceledException)
{
return(FileSystemExitCode.UserAbort);
}
catch (FileNotFoundException)
{
return(FileSystemExitCode.FileNotFound);
}
// TODO: dialog for file password, Exception throw in WsApiClient.CheckResultStatus
//catch (??)
//{
// return ??;
//}
catch (Exception ex)
{
if (ShowError("Upload file error", ex, true) == false)
{
return(FileSystemExitCode.UserAbort);
}
return(FileSystemExitCode.ReadError);
}
}
public override PreviewBitmapResult GetPreviewBitmap(RemotePath remoteName, int width, int height)
{
WsPath sourcePath = remoteName;
if (sourcePath.Level == WsPathLevel.Folder && sourcePath.Parent != "/") // Preview for root folder not supported
{
return(_accountRepository[sourcePath.AccountName].GetPreviewBitmap(sourcePath, width, height));
}
return(base.GetPreviewBitmap(remoteName, width, height));
}
public WsFolder CreateFolder(WsPath folderPath)
{
try
{
return(ExecuteAsync(folderPath, () => _apiClient.CreateFolder(folderPath, folderPath.IsPrivate)));
}
catch (Exception ex)
{
ShowError("Create folder error", ex, false);
return(null);
}
}
public IDisposableEnumerable <FindData> GetFolderAllFilesRecursive(WsPath folderPath, int depth = int.MaxValue)
{
try
{
return(ExecuteAsync(folderPath, async() => (IDisposableEnumerable <FindData>) new FolderItems(await _apiClient.GetFolderAllFilesRecursive(folderPath.GetFolderPath(), depth))));
}
catch (Exception ex)
{
ShowError("Get all files recursive error", ex, false);
return(FolderItems.Empty);
}
}
public override ExecResult ExecuteOpen(TcWindow mainWin, RemotePath remoteName)
{
WsPath wsPath = remoteName;
switch (wsPath.Level)
{
case WsPathLevel.Account when wsPath.AccountName == ADD_NEW_ACCOUNT_TITLE:
return(_accountRepository.AddNewAccount());
default:
return(ExecResult.Yourself);
}
}
public override bool DeleteFile(RemotePath remoteName)
{
WsPath wsPath = remoteName;
if (wsPath.Level <= WsPathLevel.AccessLevel)
{
return(false);
}
if (wsPath.Path.EndsWith(_virtualEmptyFile.FileName))
{
return(true);
}
return(_accountRepository[wsPath.AccountName].DeleteFile(wsPath));
}
public override ExecResult ExecuteProperties(TcWindow mainWin, RemotePath remoteName)
{
WsPath wsPath = remoteName;
switch (wsPath.Level)
{
case WsPathLevel.Account when wsPath.AccountName != ADD_NEW_ACCOUNT_TITLE:
Prompt.MsgOk("TODO:", "Show account properties");
return(ExecResult.Ok);
default:
return(ExecResult.Yourself);
}
}
public override IEnumerable <FindData> GetFiles(RemotePath path)
{
WsPath wsPath = path;
switch (wsPath.Level)
{
case WsPathLevel.Root:
return(new[] { new FindData(ADD_NEW_ACCOUNT_TITLE, FileAttributes.Normal | FileAttributes.ReadOnly) }.Concat(_accountRepository));
case WsPathLevel.Account:
return(new[]
{
new FindData(Resources.TextResource.PublicFolder, FileAttributes.Directory),
new FindData(Resources.TextResource.PrivateFolder, FileAttributes.Directory)
});
default:
// return only one virtual file for non empty indication during deletion
if (_deleteInProgress)
{
if (wsPath.Level == WsPathLevel.AccessLevel)
{
return new[] { _backFolder }
}
;
using (IDisposableEnumerable <FindData> allFiles = _accountRepository[wsPath.AccountName].GetFolderAllFilesRecursive(wsPath))
{
FindData firstItem = allFiles.FirstOrDefault();
if (firstItem == null)
{
firstItem = _backFolder;
}
else
{
firstItem = _virtualEmptyFile;
}
return(new[] { firstItem });
}
}
// return only one virtual file for move all folder on server, not file by file from client
if (_moveInProgress)
{
return new[] { _virtualEmptyFile }
}
;
// standard content
return(_accountRepository[wsPath.AccountName].GetFolderItems(wsPath)?.DefaultIfEmpty(_backFolder) ?? new FindData[0]);
}
}
public FileSystemExitCode CopyFile(WsPath sourceFilePath, WsPath targetPath, bool overwrite, IProgress <int> progress)
{
try
{
using (ThreadKeeper exec = new ThreadKeeper())
{
return(exec.ExecAsync(async(cancellationToken) =>
{
await EnsureLogin();
WsFile sourceFile = await _apiClient.FindFile(sourceFilePath.GetFilePath());
if (sourceFile != null)
{
if (overwrite == false)
{
if (await _apiClient.FindFile(targetPath.GetFilePath()) != null)
{
return FileSystemExitCode.FileExists;
}
}
}
if (sourceFile == null)
{
return FileSystemExitCode.FileNotFound;
}
WsFolder targetFolder = await _apiClient.FindFolder(targetPath.Parent.GetFolderPath());
if (targetFolder == null)
{
return FileSystemExitCode.FileNotFound;
}
await sourceFile.Copy(targetFolder, cancellationToken, new ThreadKeeperCancellableProgress(exec, progress));
return FileSystemExitCode.OK;
}));
}
}
catch (TaskCanceledException)
{
return(FileSystemExitCode.UserAbort);
}
catch (Exception ex)
{
ShowError("Copy file error", ex, false);
return(FileSystemExitCode.WriteError);
}
}
public IDisposableEnumerable <FindData> GetFolderItems(WsPath folderPath)
{
try
{
_filesPreviewCache.Clear();
return(ExecuteAsync(folderPath, async() => (IDisposableEnumerable <FindData>) new FolderItems(await _apiClient.GetFolderItems(folderPath.GetFolderPath()))));
}
catch (OperationCanceledException)
{
return(null);
}
catch (Exception ex)
{
ShowError("Get folder content error", ex, false);
return(FolderItems.Empty);
}
}
public override FileSystemExitCode RenMovFile(RemotePath oldRemoteName, RemotePath newRemoteName, bool move, bool overwrite, RemoteInfo remoteSourceInfo)
{
WsPath sourcePath = oldRemoteName;
WsPath targetPath = newRemoteName;
bool sourceIsFolder = (remoteSourceInfo.Attributes & FileAttributes.Directory) == FileAttributes.Directory;
if (sourcePath.Level <= WsPathLevel.AccessLevel)
{
return(FileSystemExitCode.NotSupported);
}
if (sourcePath.Name == _virtualEmptyFile.FileName)
{
sourcePath = sourcePath.Parent;
targetPath = targetPath.Parent;
sourceIsFolder = true;
}
if (sourcePath.AccountName != targetPath.AccountName)
{
// TODO: dodělat
// Server not support it. Use standard copy by download/upload.
return(FileSystemExitCode.NotSupported);
}
if (ProgressProc(oldRemoteName, newRemoteName, 0))
{
return(FileSystemExitCode.UserAbort);
}
try
{
if (move)
{
return(_accountRepository[sourcePath.AccountName].MoveOrRenameItem(sourcePath, targetPath, overwrite, sourceIsFolder));
}
else if (sourceIsFolder == false)
{
return(_accountRepository[sourcePath.AccountName].CopyFile(sourcePath, targetPath, overwrite, new CancellableProgress(this, oldRemoteName, newRemoteName)));
}
_uiProvider.ShowMessage(Resources.TextResource.FolderCopyInWsNotSupported, false);
return(FileSystemExitCode.NotSupported);
}
finally
{
ProgressProc(oldRemoteName, newRemoteName, 100);
}
}
public PreviewBitmapResult GetPreviewBitmap(WsPath filePath, int width, int height)
{
try
{
return(ExecuteAsync(filePath, async() =>
{
WsFile file = await _apiClient.FindFile(filePath.GetFilePath());
if (file != null)
{
WsFolder folder = await _apiClient.FindFolder(filePath.Parent.GetFolderPath());
if (folder != null)
{
WsFilePreview filePreview = await _filesPreviewCache.FindFilePreview(folder, filePath.Name);
byte[] jpgData = await filePreview.JpgData;
if (jpgData?.Length > 0)
{
using (MemoryStream jpgStream = new MemoryStream(jpgData))
{
Image jpg = Image.FromStream(jpgStream);
decimal ratio = (decimal)jpg.Width / jpg.Height;
if (ratio > 1)
{
height = (int)(height / ratio);
}
if (ratio < 1)
{
width = (int)(width / ratio);
}
Bitmap bmp = new Bitmap(jpg, width, height);
return PreviewBitmapResult.Extracted(bmp, null, false);
}
}
}
}
return PreviewBitmapResult.None;
}));
}
catch
{
return(PreviewBitmapResult.None);
}
}
public bool DeleteFolder(WsPath folderPath)
{
try
{
return(ExecuteAsync(folderPath, async() =>
{
WsFolder folder = await _apiClient.FindFolder(folderPath.GetFolderPath());
if (folder == null)
{
return false;
}
await folder.Delete();
return true;
}));
}
catch (Exception ex)
{
ShowError("Delete folder error", ex, false);
return(false);
}
}
public bool DeleteFile(WsPath filePath)
{
try
{
return(ExecuteAsync(filePath, async() =>
{
WsFile file = await _apiClient.FindFile(filePath.GetFilePath());
if (file == null)
{
return false;
}
await file.Delete();
return true;
}));
}
catch (Exception ex)
{
ShowError("Delete file error", ex, false);
return(false);
}
}
public async Task <FileSystemExitCode> DownloadFile(WsPath sourceFileName, FileInfo targetFileName, bool overwrite, IProgress <int> progress, bool deleteAfter, CancellationToken cancellationToken)
{
try
{
await EnsureLogin();
WsFile file = await _apiClient.GetFile(sourceFileName.GetFilePath());
FileMode mode = overwrite ? FileMode.Create : FileMode.CreateNew;
using (FileStream targetStream = targetFileName.Open(mode, FileAccess.Write))
{
await file.Download(targetStream, cancellationToken, progress);
}
targetFileName.CreationTime = targetFileName.LastWriteTime = file.Created;
if (deleteAfter)
{
await file.Delete();
}
return(FileSystemExitCode.OK);
}
catch (TaskCanceledException)
{
targetFileName.Delete();
return(FileSystemExitCode.UserAbort);
}
catch (FileNotFoundException)
{
return(FileSystemExitCode.FileNotFound);
}
catch (Exception ex)
{
targetFileName.Delete();
if (ShowError("Download file error", ex, true) == false)
{
return(FileSystemExitCode.UserAbort);
}
return(FileSystemExitCode.ReadError);
}
}
public override ExtractIconResult ExtractCustomIcon(RemotePath remoteName, ExtractIconFlags extractFlags)
{
WsPath wsPath = remoteName;
switch (wsPath.Level)
{
case WsPathLevel.Account when wsPath.AccountName == ADD_NEW_ACCOUNT_TITLE:
return(ExtractIconResult.Extracted(new System.Drawing.Icon(typeof(Resources.TextResource), "Add.ico")));
case WsPathLevel.Account when remoteName.Path.EndsWith(@"\..\") == false:
return(ExtractIconResult.Extracted(new System.Drawing.Icon(typeof(Resources.TextResource), "Account.ico")));
case WsPathLevel.AccessLevel when wsPath.IsPrivate == true && remoteName.Path.EndsWith(@"\..\") == false:
return(ExtractIconResult.Extracted(new System.Drawing.Icon(typeof(Resources.TextResource), "FolderPrivate.ico")));
case WsPathLevel.AccessLevel when wsPath.IsPrivate == false:
return(ExtractIconResult.Extracted(new System.Drawing.Icon(typeof(Resources.TextResource), "FolderPublic.ico")));
default:
return(ExtractIconResult.UseDefault);
}
}
public override async Task <FileSystemExitCode> PutFileAsync(string localName, RemotePath remoteName, CopyFlags copyFlags, Action <int> setProgress, CancellationToken cancellationToken)
{
WsPath wsPath = remoteName;
if (wsPath.Level <= WsPathLevel.AccessLevel)
{
return(FileSystemExitCode.NotSupported);
}
FileInfo localFileName = new FileInfo(localName);
bool overWrite = (CopyFlags.Overwrite & copyFlags) != 0;
bool performMove = (CopyFlags.Move & copyFlags) != 0;
bool resume = (CopyFlags.Resume & copyFlags) != 0;
if (resume)
{
return(FileSystemExitCode.NotSupported);
}
if (!localFileName.Exists)
{
return(FileSystemExitCode.FileNotFound);
}
FileSystemExitCode result = await _accountRepository[wsPath.AccountName].UploadFile(
localFileName,
wsPath,
overWrite,
new Progress <int>(setProgress),
cancellationToken
);
if (performMove && result == FileSystemExitCode.OK)
{
localFileName.Delete();
}
return(result);
}
public override bool MkDir(RemotePath remoteName)
{
if (_moveInProgress)
{
return(true);
}
WsPath wsPath = remoteName;
switch (wsPath.Level)
{
case WsPathLevel.Root:
return(false);
case WsPathLevel.Account:
// TODO: nefunguje return true, nedojde k refresh root složky
return(_accountRepository.AddNewAccount(wsPath.AccountName).Equals(ExecResult.Yourself) == false);
case WsPathLevel.AccessLevel:
return(false);
default:
return(_accountRepository[wsPath.AccountName].CreateFolder(wsPath) != null);
}
}
public FileSystemExitCode MoveOrRenameItem(WsPath sourcePath, WsPath targetPath, bool overwrite, bool sourceIsFolder)
{
try
{
return(ExecuteAsync(sourcePath, async() =>
{
WsItem sourceItem;
if (sourceIsFolder)
{
sourceItem = await _apiClient.FindFolder(sourcePath.GetFolderPath());
if (sourceItem != null)
{
if (overwrite == false)
{
if (await _apiClient.FindFolder(targetPath.GetFolderPath()) != null)
{
return FileSystemExitCode.FileExists; // TODO: not work for renaming to existing folder
}
}
}
}
else
{
sourceItem = await _apiClient.FindFile(sourcePath.GetFilePath());
if (sourceItem != null)
{
if (overwrite == false)
{
if (await _apiClient.FindFile(targetPath.GetFilePath()) != null)
{
return FileSystemExitCode.FileExists; // TODO: not work for renaming to existing file
}
}
}
}
if (sourceItem == null)
{
return FileSystemExitCode.FileNotFound;
}
if (sourcePath.Parent.Path == targetPath.Parent.Path)
{
await sourceItem.Rename(targetPath.Name);
}
else
{
WsFolder targetFolder = await _apiClient.FindFolder(targetPath.Parent.GetFolderPath());
if (targetFolder == null)
{
return FileSystemExitCode.FileNotFound;
}
await sourceItem.Move(targetFolder);
}
return FileSystemExitCode.OK;
}));
}
catch (Exception ex)
{
ShowError("Move/rename file/folder error", ex, false);
return(FileSystemExitCode.WriteError);
}
}
