public static Schema GetSchemaFromForm(ConfigureWriteFormData formData)
{
var tableName = new DirectoryInfo(formData.TargetFileName).Name;
var schema = new Schema
{
Id = tableName,
Name = tableName,
DataFlowDirection = Schema.Types.DataFlowDirection.Write,
Query = tableName,
PublisherMetaJson = JsonConvert.SerializeObject(formData),
};
var properties = new List <Property>();
foreach (var column in formData.Columns)
{
if (properties.Exists(p => p.Id == column.Name))
{
throw new Exception($"Duplicate column {column.Name} defined.");
}
properties.Add(new Property
{
Id = column.Name,
Name = column.Name,
Type = PropertyType.String,
PublisherMetaJson = JsonConvert.SerializeObject(column)
});
}
schema.Properties.AddRange(properties);
return(schema);
}
public static void WriteToDisk(IImportExportFile targetImportExport, ConfigureWriteFormData config, Settings settings, bool forceWrite = false)
{
// check if 5 seconds have passed since last write to disk
if (forceWrite || (DateTime.Now - LastWriteTime).TotalSeconds >= 5 && PendingWrites)
{
// write out to disk
targetImportExport.ExportTable(config.GetLocalTargetFilePath());
PendingWrites = false;
// write to Remote
if (config.FileWriteMode != Constants.FileModeLocal)
{
var localFileName = config.GetLocalTargetFilePath();
var remoteFileName = config.GetRemoteTargetFilePath();
switch (config.FileWriteMode)
{
case Constants.FileModeFtp:
using (var client = Utility.Utility.GetFtpClient())
{
try
{
var status = client.UploadFile(localFileName, remoteFileName);
if (status == FtpStatus.Failed)
{
throw new Exception($"Could not write file to remote {remoteFileName}");
}
}
finally
{
client.Disconnect();
}
}
break;
case Constants.FileModeSftp:
using (var client = Utility.Utility.GetSftpClient())
{
try
{
var fileStream = Utility.Utility.GetStream(localFileName, Constants.FileModeLocal, true);
client.UploadFile(fileStream.Stream, remoteFileName);
fileStream.Close();
}
catch
{
throw new Exception($"Could not write file to remote {remoteFileName}");
}
finally
{
client.Disconnect();
}
}
break;
}
}
}
}
public static void DeleteFileAtPath(string path, ConfigureWriteFormData config, Settings settings, bool deleteRemote)
{
DeleteFileAtPath(path, config.FileWriteMode, settings, deleteRemote);
}
public DelimitedImportExport(SqlDatabaseConnection sqlDatabaseConnection, string tableName, string schemaName, ConfigureWriteFormData writeFormData)
{
if (string.IsNullOrWhiteSpace(tableName))
{
throw new Exception("TableName parameter is required.");
}
if (string.IsNullOrWhiteSpace(schemaName))
{
throw new Exception("SchemaName parameter is required.");
}
if (sqlDatabaseConnection.State == System.Data.ConnectionState.Closed)
{
sqlDatabaseConnection.Open();
}
SQLDatabaseConnection = sqlDatabaseConnection;
TableName = tableName;
SchemaName = schemaName;
Delimiter = writeFormData.GetDelimiter();
ReplicationFormData = writeFormData.GetReplicationFormData();
}
public IImportExportFile MakeImportExportFile(SqlDatabaseConnection sqlDatabaseConnection,
ConfigureWriteFormData writeFormData, string tableName, string schemaName)
{
return(new DelimitedImportExport(sqlDatabaseConnection, tableName, schemaName, writeFormData));
}
public static List <string> ValidateWriteFormData(this ConfigureWriteFormData data,
Settings settings)
{
var errors = new List <string>();
if (string.IsNullOrWhiteSpace(data.TargetFileDirectory))
{
errors.Add("Target file directory is empty.");
}
if (string.IsNullOrWhiteSpace(data.TargetFileName))
{
errors.Add("Target file name is empty.");
}
if (string.IsNullOrWhiteSpace(data.FileWriteMode))
{
errors.Add("File Write Mode is empty.");
}
if (string.IsNullOrWhiteSpace(data.NullValue))
{
data.NullValue = "";
}
if (string.IsNullOrWhiteSpace(data.CustomHeader))
{
data.CustomHeader = "";
}
if (data.FileWriteMode != Constants.FileModeLocal)
{
var testFileName = "test.txt";
var remoteTargetDirectory = data.GetRemoteTargetDirectory();
var remoteTargetTestFileName = Path.Join(remoteTargetDirectory, testFileName);
var localTestDirectory = data.GetLocalTargetDirectory();
var localTestFileName = Path.Join(localTestDirectory, testFileName);
Directory.CreateDirectory(localTestDirectory);
var testFile = new StreamWriter(localTestFileName);
testFile.WriteLine("test");
testFile.Close();
switch (data.FileWriteMode)
{
case Constants.FileModeFtp:
using (var client = Utility.Utility.GetFtpClient())
{
try
{
if (!client.DirectoryExists(remoteTargetDirectory))
{
errors.Add($"{remoteTargetDirectory} is not a directory on remote FTP");
}
else
{
var status = client.UploadFile(localTestFileName, remoteTargetTestFileName);
if (status == FtpStatus.Failed)
{
errors.Add($"Could not write to target directory {remoteTargetDirectory}");
}
}
Utility.Utility.DeleteFileAtPath(localTestFileName, data, settings, true);
}
finally
{
client.Disconnect();
}
}
break;
case Constants.FileModeSftp:
using (var client = Utility.Utility.GetSftpClient())
{
try
{
try
{
if (!client.Exists(remoteTargetDirectory))
{
errors.Add($"{remoteTargetDirectory} is not a directory on remote FTP");
}
else
{
var fileStream = Utility.Utility.GetStream(localTestFileName, Constants.FileModeLocal, true);
client.UploadFile(fileStream.Stream, remoteTargetTestFileName);
fileStream.Close();
Utility.Utility.DeleteFileAtPath(localTestFileName, data, settings, true);
}
}
catch
{
errors.Add($"Could not write to target directory {remoteTargetDirectory}");
}
}
finally
{
client.Disconnect();
}
}
break;
}
}
return(errors);
}
public IImportExportFile MakeImportExportFile(SqlDatabaseConnection sqlDatabaseConnection,
ConfigureWriteFormData writeFormData, string tableName, string schemaName)
{
throw new System.NotImplementedException();
}
