public async Task <bool> RemoveAccount(AccountModelBase account)
{
var isRemoved = await RemoveAccountAsync(account);
if (isRemoved)
{
var handler = AccountRemoved;
if (handler != null)
{
handler.Invoke(account);
}
}
return(isRemoved);
}
public async Task <AccountModelBase> AddAccount(AccountModelBase account)
{
account = await AddAccountAsync(account);
if (account != null)
{
var handler = AccountAdded;
if (handler != null)
{
handler.Invoke(account);
}
}
return(account);
}
protected void AddToCache(AccountModelBase account, DirectoryModel directory)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
var hash = account.GetHashCode();
if (!string.IsNullOrEmpty(directory.Path))
{
hash += directory.Path.GetHashCode();
}
Cache.Set(hash, directory);
}
protected DirectoryModel GetFromCache(AccountModelBase account, DirectoryModel directory)
{
var hash = account.GetHashCode();
if (directory != null)
{
hash += directory.GetHashCode();
}
if (Cache.TryGetValue(hash, out DirectoryModel dir))
{
return(dir);
}
return(null);
}
protected override async Task <AccountModelBase> AddAccountAsync(AccountModelBase account = null)
{
var ftpAccount = account as AccountModel;
using (var connection = await GetConnection(ftpAccount))
{
if (!connection.IsConnected)
{
return(null);
}
await connection.DisconnectAsync();
var config = GetConfiguration <ConfigModel>();
config.Accounts.Add(ftpAccount);
SetConfiguration(config);
return(ftpAccount);
}
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = Task.FromResult(new DirectoryModel());
return(await model);
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
model.Path = "/";
}
var path = directory == null || string.IsNullOrEmpty(directory.Path) ? "/" : directory.Path;
model.Name = directory.Name;
model.Path = path;
model.Directories = new List <DirectoryModel>();
model.Files = new List <FileModel>();
using (var client = await GetConnection(account as AccountModel))
{
var entries = await client.GetListingAsync(path, FtpListOption.AllFiles);
foreach (var entry in entries)
{
switch (entry.Type)
{
case FtpFileSystemObjectType.Directory:
var dir = new DirectoryModel();
dir.Id = entry.FullName.GetHashCode().ToString();
dir.Name = entry.Name;
dir.Path = entry.FullName;
dir.Size = entry.Size;
dir.Created = entry.Created;
dir.Modified = entry.Modified;
model.Directories.Add(dir);
break;
case FtpFileSystemObjectType.File:
var file = new FileModel();
file.Id = entry.FullName.GetHashCode().ToString();
file.Name = entry.Name;
file.Path = entry.FullName;
file.Size = entry.Size;
file.Created = entry.Created;
file.Modified = entry.Modified;
model.Files.Add(file);
break;
}
}
if (client.IsConnected)
{
await client.DisconnectAsync();
}
}
AddToCache(account, model);
return(model);
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
}
model.Name = directory.Name;
model.Path = directory.Path;
model.Directories = new List <DirectoryModel>();
model.Files = new List <FileModel>();
var credentials = await GetCredential();
var parent = directory == null || directory.Id == null ? "root" : directory.Id;
var query = new StringBuilder();
if (directory.Id == null)
{
query.Append(" and 'root' in parents");
}
else
{
query.Append(" and '' in parents");
}
FileList entries;
using (var client = new DriveService(GetServiceInitializer(credentials)))
{
var request = client.Files.List();
request.Q = string.Format("trashed = false and '{0}' in parents", parent);
request.PageSize = Config.PageSize;
request.Fields = "nextPageToken, files(id, name, mimeType, parents, createdTime, modifiedTime, fileExtension, size)";
entries = await request.ExecuteAsync();
while (entries.Files != null)
{
foreach (var entry in entries.Files)
{
var parents = entry.Parents;
if (entry.MimeType.Equals(MIME_TYPE_DIRECTORY))
{
var dir = new DirectoryModel();
dir.Id = entry.Id;
dir.Name = entry.Name;
dir.Path = entry.Name;
dir.Size = entry.Size;
dir.Created = entry.CreatedTime;
dir.Modified = entry.ModifiedTime;
model.Directories.Add(dir);
}
else
{
var nameParts = SplitName(entry.Name);
var file = new FileModel();
file.Id = entry.Id;
file.Name = nameParts.Name;
file.Extension = nameParts.Extension;
file.Path = entry.Name;
file.Size = entry.Size;
file.Created = entry.CreatedTime;
file.Modified = entry.ModifiedTime;
model.Files.Add(file);
}
}
if (entries.NextPageToken == null)
{
break;
}
request.PageToken = entries.NextPageToken;
entries = await request.ExecuteAsync();
}
}
AddToCache(account, model);
return(model);
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
return(await Task.Run(() =>
{
model = new DirectoryModel();
if (string.IsNullOrEmpty(directory.Path))
{
model.Directories = new List <DirectoryModel>();
foreach (var driveInfo in DriveInfo.GetDrives())
{
if (!driveInfo.IsReady)
{
continue;
}
var drive = new DirectoryModel(true);
drive.Name = driveInfo.Name;
drive.Path = driveInfo.RootDirectory.FullName;
drive.Size = driveInfo.TotalSize;
model.Directories.Add(drive);
}
AddToCache(account, model);
return model;
}
DirectoryInfo info = new DirectoryInfo(directory.Path);
model.Name = info.Name;
model.Path = info.FullName;
model.Created = info.CreationTime;
model.Modified = info.LastWriteTime;
model.Accessed = info.LastAccessTime;
model.IsHidden = info.Attributes.HasFlag(FileAttributes.Hidden);
model.IsSystem = info.Attributes.HasFlag(FileAttributes.System);
model.Files = new List <FileModel>();
try
{
foreach (var fileInfo in info.GetFiles())
{
var file = new FileModel();
if (string.IsNullOrEmpty(fileInfo.Extension))
{
file.Name = fileInfo.Name;
}
else
{
file.Name = fileInfo.Name.Replace(fileInfo.Extension, string.Empty);
file.Extension = fileInfo.Extension.Substring(1).ToLowerInvariant();
}
file.Path = fileInfo.FullName;
file.Size = fileInfo.Length;
file.Created = fileInfo.CreationTime;
file.Modified = fileInfo.LastWriteTime;
file.Accessed = fileInfo.LastAccessTime;
file.IsHidden = fileInfo.Attributes.HasFlag(FileAttributes.Hidden);
file.IsSystem = fileInfo.Attributes.HasFlag(FileAttributes.System);
model.Files.Add(file);
}
}
catch (UnauthorizedAccessException)
{
}
model.Directories = new List <DirectoryModel>();
try
{
foreach (var directoryInfo in info.GetDirectories())
{
var dir = new DirectoryModel();
dir.Name = directoryInfo.Name;
dir.Path = directoryInfo.FullName;
dir.Created = directoryInfo.CreationTime;
dir.Modified = directoryInfo.LastWriteTime;
dir.Accessed = directoryInfo.LastAccessTime;
dir.IsHidden = directoryInfo.Attributes.HasFlag(FileAttributes.Hidden);
dir.IsSystem = directoryInfo.Attributes.HasFlag(FileAttributes.System);
model.Directories.Add(dir);
}
}
catch (UnauthorizedAccessException)
{
}
AddToCache(account, model);
return model;
}));
}
protected override Task <bool> RemoveAccountAsync(AccountModelBase account)
{
throw new NotImplementedException();
}
public abstract Task FormatAsync(AccountModelBase account, DirectoryModel directory = null);
public abstract Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null);
protected abstract Task <bool> RemoveAccountAsync(AccountModelBase account);
protected abstract Task <AccountModelBase> AddAccountAsync(AccountModelBase account = null);
protected override async Task <AccountModelBase> AddAccountAsync(AccountModelBase account = null)
{
var provider = new AccountModel("aps", "aprs");
return(await Task.FromResult(provider));
}
public override Task FormatAsync(AccountModelBase account, DirectoryModel directory = null)
{
throw new NotImplementedException();
}
protected override Task <AccountModelBase> AddAccountAsync(AccountModelBase account = null)
{
throw new NotImplementedException();
}
