//public CoreConfiguration(
// ILogger<CoreConfiguration> log,
// IOptions<ActiveDirectorySettings> activeDirectory,
// IOptions<BusSettings> bus,
// IOptions<CacheSettings> cache,
// IOptions<ConnectionSettings> connection,
// IOptions<CronSettings> cron,
// IOptions<EmailSettings> email,
// IOptions<FaxSettings> fax,
// IOptions<FileSettings> files,
// IOptions<FTPSettings> ftp,
// IOptions<PrintSettings> print
// )
//{
// _coreLog = log;
// CoreId = Guid.Parse("BC0C4AF8-5EB2-4C3A-B640-5357428C0557");
// MenuCoreId = Guid.Parse("039BB7F3-AAB2-45C4-B4A4-25E20A70E0AE");
// ActiveDirectory = activeDirectory.Value;
// Bus = bus.Value;
// Cache = cache.Value;
// Connection = connection.Value;
// Cron = cron.Value;
// Email = email.Value;
// Fax = fax.Value;
// Files = files.Value;
// FTP = ftp.Value;
// Print = print.Value;
//}
public CoreConfiguration(
ILoggerFactory log,
ActiveDirectorySettings activeDirectory,
BusSettings bus,
CacheSettings cache,
ConnectionSettings connection,
CronSettings cron,
EmailSettings email,
FaxSettings fax,
FileSettings files,
FTPSettings ftp,
PrintSettings print
)
{
_coreLog = log.CreateLogger <CoreConfiguration>();
CoreId = Guid.Parse("BC0C4AF8-5EB2-4C3A-B640-5357428C0557");
MenuCoreId = Guid.Parse("039BB7F3-AAB2-45C4-B4A4-25E20A70E0AE");
ActiveDirectory = activeDirectory;
Bus = bus;
Cache = cache;
Connection = connection;
Cron = cron;
Email = email;
Fax = fax;
Files = files;
FTP = ftp;
Print = print;
}
public async Task <IEnumerable <string> > GetFileNamesAsync(FTPSettings settings, bool recursive)
{
var request = CreateRequest(settings, "", WebRequestMethods.Ftp.ListDirectoryDetails);
var response = await request.GetResponseAsync();
if (!(response is FtpWebResponse ftpWebResponse))
{
throw new NotSupportedException($"Unexpected request response. Expected: {nameof(FtpWebResponse)}, but found {response.GetType()}");
}
var responseStream = ftpWebResponse.GetResponseStream();
var reader = new StreamReader(responseStream);
var fileNames = await ProcessFileInformationResultsAsync(
reader.ReadToEnd(),
recursive, settings.ServerPath,
async newServerPath =>
{
var subFileSettigs = new FTPSettings
{
ServerUrl = settings.ServerUrl,
ServerPort = settings.ServerPort,
ServerPath = newServerPath,
Username = settings.Username,
Password = settings.Password
};
return(await GetFileNamesAsync(subFileSettigs, true));
});
return(fileNames.OrderBy(f => f).ToList());
}
/// <summary>
/// Download the specified file
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="fileName">Name of the file on ftp server</param>
/// <param name="targetPath">Path of the target directory on local file system</param>
/// <returns></returns>
public async Task <bool> DownloadAsync(FTPSettings settings, string fileName, string targetPath)
{
var directoryInfo = new DirectoryInfo(targetPath);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
var connectionInfo = CreateConnectionInfo(settings);
using (var sftp = new SftpClient(connectionInfo))
{
sftp.Connect();
ChangeServerPath(sftp, settings.ServerPath);
using (var saveFile = File.OpenWrite(Path.Combine(targetPath, fileName)))
{
await Task.Factory.FromAsync(sftp.BeginDownloadFile(fileName, saveFile), sftp.EndDownloadFile);
}
sftp.Disconnect();
}
return(true);
}
/// <summary>
/// Download the specified file
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="fileName">Name of the file on ftp server</param>
/// <param name="targetPath">Path of the target directory on local file system</param>
/// <returns></returns>
public async Task <bool> DownloadAsync(FTPSettings settings, string fileName, string targetPath)
{
var directoryInfo = new DirectoryInfo(targetPath);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
var request = CreateRequest(settings, fileName, WebRequestMethods.Ftp.DownloadFile);
var response = await request.GetResponseAsync();
if (!(response is FtpWebResponse ftpWebResponse))
{
throw new NotSupportedException($"Unexpected request response. Expected: {nameof(FtpWebResponse)}, but found {response.GetType()}");
}
var responseStream = ftpWebResponse.GetResponseStream();
using (var fsStream = File.Open(Path.Combine(targetPath, fileName), FileMode.Create, FileAccess.Write, FileShare.None))
{
await WriteAsync(responseStream, fsStream);
fsStream.Close();
}
return(ftpWebResponse.StatusCode == FtpStatusCode.ClosingData);
}
private FtpWebRequest CreateRequest(FTPSettings settings, string fileName, string method)
{
if (settings.ServerPort <= 0)
{
settings.ServerPort = 21;
}
if (!settings.ServerPath.IsNullOrEmpty() && !settings.ServerPath.EndsWith("/"))
{
settings.ServerPath += '/';
}
if (!settings.ServerUrl.ToLower().StartsWith("ftp://"))
{
settings.ServerUrl = "ftp://" + settings.ServerUrl;
}
if (settings.ServerUrl.EndsWith("/"))
{
settings.ServerUrl = settings.ServerUrl.Substring(0, settings.ServerUrl.Length - 1);
}
var request = (FtpWebRequest)WebRequest.Create(new Uri($"{settings.ServerUrl}:{settings.ServerPort}/{settings.ServerPath ?? ""}{fileName}"));
request.Method = method;
request.Credentials = new NetworkCredential(settings.Username, settings.Password);
return(request);
}
private ConnectionInfo CreateConnectionInfo(FTPSettings settings)
{
if (settings.ServerUrl.ToLower().StartsWith("sftp://"))
{
settings.ServerUrl = settings.ServerUrl.Substring(7);
}
return(new ConnectionInfo(settings.ServerUrl, settings.Username, new PasswordAuthenticationMethod(settings.Username, settings.Password)));
}
public PluginBody()
{
try
{
settings = SettingsManager.Load();
}
catch
{
settings = new FTPSettings();
}
}
/// <summary>
/// Get all file names, inclusive path, of the directory on ftp server
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="recursive">Enumerate sub directories</param>
/// <returns></returns>
public async Task <IEnumerable <string> > GetFileNamesAsync(FTPSettings settings, bool recursive)
{
var connectionInfo = CreateConnectionInfo(settings);
var fileNames = new List <string>();
var directoryNames = new List <string>();
using (var sftp = new SftpClient(connectionInfo))
{
sftp.Connect();
await Task.Factory.FromAsync(sftp.BeginListDirectory(GetServerPath(settings.ServerPath), null, null), (IAsyncResult result) =>
{
var files = sftp.EndListDirectory(result);
foreach (var file in files)
{
if (file.IsDirectory)
{
if (file.Name == "." || file.Name == ".." || !recursive)
{
continue;
}
directoryNames.Add(file.Name);
}
else
{
fileNames.Add(file.FullName);
}
}
});
sftp.Disconnect();
}
if (recursive && directoryNames.Count > 0)
{
var childSettings = new FTPSettings
{
ServerUrl = settings.ServerUrl,
ServerPort = settings.ServerPort,
Password = settings.Password,
Username = settings.Username
};
foreach (var directoryName in directoryNames)
{
childSettings.ServerPath = String.Join("/", settings.ServerPath, directoryName);
fileNames.AddRange(await GetFileNamesAsync(childSettings, true));
}
}
return(fileNames);
}
/// <summary>
/// Delete the specified directory or file from ftp server
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="directoryOrFileName">Name of the directory or file</param>
/// <returns></returns>
public async Task <bool> DeleteAsync(FTPSettings settings, string directoryOrFileName)
{
var request = CreateRequest(settings, directoryOrFileName, WebRequestMethods.Ftp.DeleteFile);
var response = await request.GetResponseAsync();
response.Close();
if (!(response is FtpWebResponse ftpWebResponse))
{
throw new NotSupportedException($"Unexpected request response. Expected: {nameof(FtpWebResponse)}, but found {response.GetType()}");
}
return(true);
}
public async Task <bool> UploadAsync(FTPSettings settings, string fileName, string fullFileName)
{
var request = CreateRequest(settings, fileName, WebRequestMethods.Ftp.UploadFile);
var ftpStream = await request.GetRequestStreamAsync();
var fsStream = File.OpenRead(fullFileName);
await WriteAsync(fsStream, ftpStream);
fsStream.Close();
var response = (FtpWebResponse)request.GetResponse();
ftpStream.Close();
return(response.StatusCode == FtpStatusCode.ClosingData);
}
public void ShowSettings()
{
using (FTPSettingsForm fs = new FTPSettingsForm(settings))
{
if (fs.ShowDialog() == DialogResult.OK)
{
settings = fs.GetSettings();
try
{
SettingsManager.Save(settings);
}
catch (Exception ex)
{
MessageBox.Show("Error while saving ftp settings!\r\n\r\n" + ex.Message, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
}
/// <summary>
/// Delete the specified directory or file from ftp server
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="directoryOrFileName">Name of the directory or file</param>
/// <returns></returns>
public Task <bool> DeleteAsync(FTPSettings settings, string directoryOrFileName)
{
var connectionInfo = CreateConnectionInfo(settings);
var directoryOrFilePath = GetServerPath(settings.ServerPath);
if (!directoryOrFilePath.EndsWith("/"))
{
directoryOrFilePath += "/";
}
directoryOrFilePath += directoryOrFileName;
using (var sftp = new SftpClient(connectionInfo))
{
sftp.Connect();
sftp.Delete(directoryOrFilePath);
sftp.Disconnect();
}
return(Task.FromResult(true));
}
/// <summary>
/// Upload the specified file
/// </summary>
/// <param name="settings">ftp server settings</param>
/// <param name="fileName">Name of the file on ftp server</param>
/// <param name="fullFileName">Name of the file, inclusive path, of the file</param>
/// <returns></returns>
public async Task <bool> UploadAsync(FTPSettings settings, string fileName, string fullFileName)
{
var connectionInfo = CreateConnectionInfo(settings);
using (var sftp = new SftpClient(connectionInfo))
{
sftp.Connect();
ChangeServerPath(sftp, settings.ServerPath);
using (var fileStream = File.OpenRead(fullFileName))
{
await Task.Factory.FromAsync(sftp.BeginUploadFile(fileStream, fileName, true, (IAsyncResult result) => { }, null), sftp.EndUploadFile);
}
sftp.Disconnect();
}
return(true);
}
public void FtpUpload(Report report, FTPSettings settings)
{
var reportName = report?.Name ?? null;
try
{
if (String.IsNullOrEmpty(reportName))
{
throw new Exception("The report has no filename.");
}
var targetPath = settings?.RemotePath?.Trim() ?? null;
if (targetPath == null)
{
var message = $"No target ftp path for report '{reportName}' found.";
logger.Error(message);
JobResult.Exception = ReportException.GetException(message);
JobResult.Status = TaskStatusInfo.ERROR;
Results.Add(new FTPResult()
{
Success = false,
ReportState = "ERROR",
TaskName = JobResult.TaskName,
Message = message,
ReportName = reportName
});
return;
}
var ftpClient = new FtpClient(settings.Host, settings.Port, settings.Username, settings.Password);
var ftpEncryptionMode = FtpEncryptionMode.None;
if (settings?.EncryptionMode != null)
{
ftpEncryptionMode = (FtpEncryptionMode)Enum.Parse(typeof(FtpEncryptionMode), settings.EncryptionMode);
}
ftpClient.EncryptionMode = ftpEncryptionMode;
ftpClient.ValidateAnyCertificate = settings.UseSsl;
ftpClient.Connect();
var fileCount = 0;
foreach (var reportPath in report.Paths)
{
if (report.Paths.Count > 1)
{
fileCount++;
}
var fileData = report.Data.FirstOrDefault(f => f.Filename == Path.GetFileName(reportPath));
var targetFtpFile = $"{targetPath}/{NormalizeReportName(reportName)}{Path.GetExtension(reportPath)}";
if (fileCount > 0)
{
targetFtpFile = $"{targetPath}/{NormalizeReportName(reportName)}_{fileCount}{Path.GetExtension(reportPath)}";
}
logger.Debug($"ftp distibute mode {settings.Mode}");
var ftpRemoteExists = FtpRemoteExists.Overwrite;
switch (settings.Mode)
{
case DistributeMode.CREATEONLY:
ftpRemoteExists = FtpRemoteExists.Skip;
break;
case DistributeMode.DELETEALLFIRST:
logger.Debug($"The FTP file '{targetFtpFile}' could not deleted.");
if (ftpClient.FileExists(targetFtpFile))
{
ftpClient.DeleteFile(targetFtpFile);
}
ftpRemoteExists = FtpRemoteExists.Skip;
break;
case DistributeMode.OVERRIDE:
ftpRemoteExists = FtpRemoteExists.Overwrite;
break;
default:
throw new Exception($"Unkown distribute mode {settings.Mode}");
}
// Create FTP Folder
var folderObject = ftpClient.GetObjectInfo(targetPath);
if (folderObject == null)
{
ftpClient.CreateDirectory(targetPath, true);
}
// Upload File
var ftpStatus = ftpClient.UploadFile(reportPath, targetFtpFile, ftpRemoteExists);
if (ftpStatus == FtpStatus.Success)
{
Results.Add(new FTPResult()
{
Success = true,
ReportState = GetFormatedState(),
ReportName = reportName,
TaskName = JobResult.TaskName,
Message = "FTP upload was executed successfully.",
FtpPath = $"ftp://{settings.Host}{targetFtpFile}"
});
}
else
{
throw new Exception($"The FTP File '{targetFtpFile}' upload failed.");
}
}
}
catch (Exception ex)
{
logger.Error(ex, "The delivery via 'ftp' failed.");
JobResult.Exception = ReportException.GetException(ex);
JobResult.Status = TaskStatusInfo.ERROR;
Results.Add(new FTPResult()
{
Success = false,
ReportState = "ERROR",
TaskName = JobResult.TaskName,
Message = ex.Message,
ReportName = reportName
});
}
}
