protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
PropertyDescriptor ftpSessionProperty = context.DataContext.GetProperties()[WithFtpSession.FtpSessionPropertyName];
IFtpSession ftpSession = ftpSessionProperty?.GetValue(context.DataContext) as IFtpSession;
if (ftpSession == null)
{
throw new InvalidOperationException("FTPSessionNotFoundException");
}
string localPath = LocalPath.Get(context);
string remotePath = RemotePath.Get(context);
if (Directory.Exists(localPath))
{
if (string.IsNullOrWhiteSpace(Path.GetExtension(remotePath)))
{
if (!(await ftpSession.DirectoryExistsAsync(remotePath, cancellationToken)))
{
if (Create)
{
await ftpSession.CreateDirectoryAsync(remotePath, cancellationToken);
}
else
{
throw new ArgumentException("PathNotFoundException", remotePath);
}
}
}
else
{
throw new InvalidOperationException("IncompatiblePathsException");
}
}
else
{
if (File.Exists(localPath))
{
if (string.IsNullOrWhiteSpace(Path.GetExtension(remotePath)))
{
remotePath = FtpConfiguration.CombinePaths(remotePath, Path.GetFileName(localPath));
}
string directoryPath = FtpConfiguration.GetDirectoryPath(remotePath);
if (!(await ftpSession.DirectoryExistsAsync(directoryPath, cancellationToken)))
{
if (Create)
{
await ftpSession.CreateDirectoryAsync(directoryPath, cancellationToken);
}
else
{
throw new InvalidOperationException(directoryPath);
}
}
}
else
{
throw new ArgumentException("PathNotFoundException", localPath);
}
}
await ftpSession.UploadAsync(localPath, remotePath, Overwrite, Recursive, cancellationToken);
return((asyncCodeActivityContext) =>
{
});
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
PropertyDescriptor ftpSessionProperty = context.DataContext.GetProperties()[WithFtpSession.FtpSessionPropertyName];
IFtpSession ftpSession = ftpSessionProperty?.GetValue(context.DataContext) as IFtpSession;
if (ftpSession == null)
{
throw new InvalidOperationException("FTPSessionNotFoundException");
}
string remotePath = RemotePath.Get(context);
string localPath = LocalPath.Get(context);
FtpObjectType objectType = await ftpSession.GetObjectTypeAsync(remotePath, cancellationToken);
if (objectType == FtpObjectType.Directory)
{
if (string.IsNullOrWhiteSpace(Path.GetExtension(localPath)))
{
if (!Directory.Exists(localPath))
{
if (Create)
{
Directory.CreateDirectory(localPath);
}
else
{
throw new ArgumentException("PathNotFoundException", localPath);
}
}
}
else
{
throw new InvalidOperationException("IncompatiblePathsException");
}
}
else
{
if (objectType == FtpObjectType.File)
{
if (string.IsNullOrWhiteSpace(Path.GetExtension(localPath)))
{
localPath = Path.Combine(localPath, Path.GetFileName(remotePath));
}
string directoryPath = Path.GetDirectoryName(localPath);
if (!Directory.Exists(directoryPath))
{
if (Create)
{
Directory.CreateDirectory(directoryPath);
}
else
{
throw new InvalidOperationException("PathNotFoundException");
}
}
}
else
{
throw new NotImplementedException("UnsupportedObjectTypeException");
}
}
if (Overwrite)
{
await ftpSession.DownloadAsync(remotePath, localPath, FtpLocalExists.Overwrite, Recursive, cancellationToken);
}
else
{
await ftpSession.DownloadAsync(remotePath, localPath, FtpLocalExists.Append, Recursive, cancellationToken);
}
return((asyncCodeActivityContext) =>
{
});
}
