/// <summary>
/// Set error in result
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
UploadIntegrationImportCommandResult commandResult;
try
{
commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
commandResult = new UploadIntegrationImportCommandResult
{
Success = false,
Message = "Error executing integration import",
Exception = ex,
};
}
return(commandResult);
}
private async Task <UploadIntegrationImportCommandResult> HandleWithErrorLogging(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
try
{
var commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
return(commandResult);
}
catch (Exception ex)
{
const string commandName = nameof(UploadIntegrationImportCommand);
_logger.ErrorFormat(
ex,
"Error executing command {0} :\r\n{1}",
commandName,
_logger.Serialize(command));
throw;
}
}
/// <summary>
/// Validate upload integration import command
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
Argument.NotNull(command, nameof(command));
_validator.ValidateObject(command);
return(_handler.Handle(command, cancellationToken));
}
/// <summary>
/// Handle the command
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The result</returns>
public Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
if (_logger.IsErrorEnabled)
{
return(HandleWithErrorLogging(command, cancellationToken));
}
else
{
return(_handler.Handle(command, cancellationToken));
}
}
/// <summary>
/// Handles uploading the integration import
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
Argument.NotNull(command, nameof(command));
var commandResult = new UploadIntegrationImportCommandResult();
var integrationImport = command.Item;
Require.NotNull(integrationImport, nameof(integrationImport));
var query = new CreateStreamFromPathQuery
{
Path = integrationImport.File
};
using (var queryResult = await _queryHandler
.Handle(query, cancellationToken)
.ConfigureAwait(Await.Default))
{
var uploadRequest = new UploadIntegrationImportV1Request
{
IntegrationImportId = command.IntegrationImportId,
File = queryResult.File,
FileName = integrationImport.FileName,
Size = queryResult.Size,
};
var response = await _client
.Execute(uploadRequest, cancellationToken)
.ConfigureAwait(Await.Default);
if (response.IsSuccessful)
{
commandResult.Success = true;
commandResult.Message = "";
uploadRequest.Dispose();
}
else
{
commandResult.Success = false;
commandResult.Message = "Error uploading integration import";
uploadRequest.Dispose();
}
}
return(commandResult);
}
/// <summary>
/// Start an integration import upload
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
Argument.NotNull(command, nameof(command));
UploadIntegrationImportCommandResult commandResult;
var integrationImport = command.Item;
Require.NotNull(integrationImport, nameof(integrationImport));
var fileInfo = _fileInfoFactory.FromFileName(integrationImport.File);
var remoteImportId = integrationImport.FileVersionId;
var request = new StartIntegrationImportV1Request
{
IntegrationId = integrationImport.IntegrationId,
FileName = fileInfo.Name,
FileDate = integrationImport.FileDate,
FileSize = fileInfo.Length,
FileVersionId = remoteImportId
};
var response = await _client
.Execute(request, cancellationToken)
.ConfigureAwait(Await.Default);
if (response.IsSuccessful)
{
command.IntegrationImportId = response.Model.IntegrationImportId;
commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
}
else
{
commandResult = new UploadIntegrationImportCommandResult
{
Success = false,
Message = "Error starting integration import",
};
}
return(commandResult);
}
/// <summary>
/// Report status back to api
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
Argument.NotNull(command, nameof(command));
var stopwatch = Stopwatch.StartNew();
var commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
stopwatch.Stop();
int duration = Convert(stopwatch.ElapsedMilliseconds);
string exception = null;
if (commandResult.Exception != null)
{
exception = commandResult.Exception.ToString();
if (exception.Length > ExceptionLength)
{
exception = exception.Substring(0, ExceptionLength);
}
}
var request = new ReportIntegrationImportV1Request
{
IntegrationImportId = command.IntegrationImportId,
Result =
commandResult.Success == true ?
UploadIntegrationImportV1Result.Success :
UploadIntegrationImportV1Result.Failed,
Duration = duration,
Message = commandResult.Message,
Exception = exception,
};
_ = await _client
.Execute(request, cancellationToken)
.ConfigureAwait(Await.Default);
return(commandResult);
}
/// <summary>
/// Execute upload and move file after
/// </summary>
/// <param name="command">The command</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <UploadIntegrationImportCommandResult> Handle(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
Argument.NotNull(command, nameof(command));
var commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
if (commandResult.Success == true)
{
var configuration = _configuration.Value;
string doneFolder = configuration.DoneFolder;
string sourceFile = command.Item.File;
var sourceFileInfo = _factory.FromFileName(sourceFile);
string fileName = sourceFileInfo.Name;
string targetFile = _path.Combine(doneFolder, fileName);
var targetFileInfo = _factory.FromFileName(targetFile);
if (targetFileInfo.Exists)
{
targetFileInfo.Delete();
}
if (targetFileInfo.Directory.Exists == false)
{
targetFileInfo.Directory.Create();
}
sourceFileInfo.MoveTo(targetFile);
}
return(commandResult);
}
private async Task <UploadIntegrationImportCommandResult> HandleWithDebug(
UploadIntegrationImportCommand command,
CancellationToken cancellationToken)
{
const string commandName = nameof(UploadIntegrationImportCommand);
_logger.DebugFormat(
"Executing command {0} :\r\n{1}",
commandName,
_logger.Serialize(command));
var commandResult = await _handler
.Handle(command, cancellationToken)
.ConfigureAwait(Await.Default);
_logger.DebugFormat(
"Executed command {0} :\r\n{1}",
commandName,
_logger.Serialize(commandResult));
return(commandResult);
}
