public async Task GetTransactionsPage_ServiceFailed_Returns500()
{
// Arrange
var mediator = new Mock <IMediator>();
var transactionPageQueryResult = new OperationDataResult <TransactionPageQueryResult>(false, new List <string> {
"Error"
});
mediator.Setup(m => m.Send(It.IsAny <TransactionPageQuery>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(transactionPageQueryResult));
var controller = new TransactionsController(mediator.Object);
// Act
var result = await controller.GetTransactionsPage(new TransactionPageQuery());
var objectResult = result as ObjectResult;
var operationDataResult = objectResult.Value as OperationDataResult <TransactionPageQueryResult>;
// Assert
Assert.AreEqual(500, objectResult.StatusCode);
Assert.AreEqual(false, operationDataResult.Succeeded);
Assert.AreNotEqual(0, operationDataResult.Messages);
}
private void GetResult()
{
OperationDataResult result = DataHandler.BinaryOperationResult();
if (result.Success)
{
InfoLabel.Text = result.Data;
}
DataHandler.ExpressionContinuation = false;
}
public void ChangeOperationUnary(Operations operation)
{
DataHandler.OperationData = operation;
OperationDataResult result = DataHandler.UnaryOperationResult();
if (result.Success)
{
InfoLabel.Text = result.Data;
}
DataHandler.ExpressionContinuation = false;
}
public async Task GenerateSingleListResults(ItemListCasesPnRequestModel requestModel)
{
OperationDataResult <FileStreamModel> result = await _listService.GenerateSingleListResults(requestModel);
const int bufferSize = 4086;
byte[] buffer = new byte[bufferSize];
Response.OnStarting(async() =>
{
try
{
if (!result.Success)
{
Response.ContentLength = result.Message.Length;
Response.ContentType = "text/plain";
Response.StatusCode = 400;
byte[] bytes = Encoding.UTF8.GetBytes(result.Message);
await Response.Body.WriteAsync(bytes, 0, result.Message.Length);
await Response.Body.FlushAsync();
}
else
{
using (FileStream excelStream = result.Model.FileStream)
{
int bytesRead;
Response.ContentLength = excelStream.Length;
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
while ((bytesRead = excelStream.Read(buffer, 0, buffer.Length)) > 0 &&
!HttpContext.RequestAborted.IsCancellationRequested)
{
await Response.Body.WriteAsync(buffer, 0, bytesRead);
await Response.Body.FlushAsync();
}
}
}
}
finally
{
if (!string.IsNullOrEmpty(result?.Model?.FilePath) &&
System.IO.File.Exists(result.Model.FilePath))
{
System.IO.File.Delete(result.Model.FilePath);
}
}
});
// return await _listService.GenerateSingleListResults(requestModel);
}
public async Task <OperationDataResult <FileStreamModel> > GenerateReportFile(GenerateReportModel model)
{
string excelFile = null;
try
{
OperationDataResult <ReportModel> reportDataResult = await GenerateReport(model);
if (!reportDataResult.Success)
{
return(new OperationDataResult <FileStreamModel>(false, reportDataResult.Message));
}
excelFile = _excelService.CopyTemplateForNewAccount("report_template");
bool writeResult = _excelService.WriteRecordsExportModelsToExcelFile(
reportDataResult.Model,
model,
excelFile);
if (!writeResult)
{
throw new Exception($"Error while writing excel file {excelFile}");
}
FileStreamModel result = new FileStreamModel()
{
FilePath = excelFile,
FileStream = new FileStream(excelFile, FileMode.Open),
};
return(new OperationDataResult <FileStreamModel>(true, result));
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(excelFile) && File.Exists(excelFile))
{
File.Delete(excelFile);
}
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <FileStreamModel>(
false,
_itemsPlanningLocalizationService.GetString("ErrorWhileGeneratingReportFile")));
}
}
public async Task <OperationDataResult <CloseRouletteResult> > CloseRouletteAsync(string rouletteCode)
{
var result = new OperationDataResult <CloseRouletteResult> {
Data = new CloseRouletteResult()
};
var rouletteStorage = _rouletteRepositories.First(x => x.StorageProvider == _rouletteSettings.StorageProvider);
var roulette = await rouletteStorage.FindByCodeAsync(rouletteCode);
if (roulette != null)
{
if (roulette.RouletteStatus != RouletteStatus.Open)
{
throw new RouletteException("La ruleta ya se encuentra cerrada");
}
roulette.RouletteStatus = RouletteStatus.Closed;
await rouletteStorage.UpdateAsync(roulette);
result.Data.NumberWinner = new Random().Next(_rouletteSettings.MinNumberBet, _rouletteSettings.MaxNumberBet);
result.Data.ColorWinner = new Random().Next(1, 3) == 1 ? Color.Black.ToString() : Color.Red.ToString();
var betStorage = _betRepositories.First(x => x.StorageProvider == _rouletteSettings.StorageProvider);
var betsNumberWinners = await betStorage.FindByStringsFiltersAsync(new Dictionary <string, string>
{
{ "RouletteCode", rouletteCode },
{ "Number", result.Data.NumberWinner.ToString() }
});
var betsColorWinners = await betStorage.FindByStringsFiltersAsync(new Dictionary <string, string>
{
{ "RouletteCode", rouletteCode },
{ "Color", result.Data.ColorWinner }
});
result.Data.Winners = GetWinnersAndgetMoney(betsNumberWinners, betsColorWinners);
}
else
{
result.Success = false;
}
return(result);
}
public static OperationDataResult UnaryOperationResult()
{
var result = new OperationDataResult
{
Success = false
};
ParseData();
if (TryExecuteUnary().Success)
{
if (float.IsInfinity(FirstData))
{
result.Data = "Ошибка";
}
else
{
result.Data = FirstData.ToString();
}
result.Success = true;
}
return(result);
}
public async Task GetTransactionsPage_ServiceSucceeded_Returns200()
{
// Arrange
var mediator = new Mock <IMediator>();
var transactionPageQueryResult = new OperationDataResult <TransactionPageQueryResult>(true, new TransactionPageQueryResult(1, new List <TransactionModel>()));
mediator.Setup(m => m.Send(It.IsAny <TransactionPageQuery>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(transactionPageQueryResult));
var controller = new TransactionsController(mediator.Object);
// Act
var result = await controller.GetTransactionsPage(new TransactionPageQuery());
var objectResult = result as ObjectResult;
var operationDataResult = objectResult.Value as OperationDataResult <TransactionPageQueryResult>;
// Assert
Assert.AreEqual(200, objectResult.StatusCode);
Assert.AreEqual(true, operationDataResult.Succeeded);
Assert.IsNotNull(operationDataResult.Model.Transactions);
Assert.AreEqual(transactionPageQueryResult.Model.TotalTransactionsCount, operationDataResult.Model.TotalTransactionsCount);
}
public async Task <OperationDataResult <FileStreamModel> > GenerateReportFile(GenerateReportModel model)
{
string excelFile = null;
try
{
OperationDataResult <ReportModel> reportDataResult = await GenerateReport(model);
if (!reportDataResult.Success)
{
return(new OperationDataResult <FileStreamModel>(false, reportDataResult.Message));
}
string outerResourceName = "";
string innerResourceName = "";
try
{
outerResourceName = _dbContext.PluginConfigurationValues.SingleOrDefault(x => x.Name == "OuterInnerResourceSettings:OuterResourceName")?.Value;
innerResourceName = _dbContext.PluginConfigurationValues.SingleOrDefault(x => x.Name == "OuterInnerResourceSettings:InnerResourceName")?.Value;
}
catch
{
}
switch (reportDataResult.Model.Relationship)
{
case ReportRelationshipType.Employee:
reportDataResult.Model.HumanReadableName =
_outerInnerResourceLocalizationService.GetString("Employee");
break;
case ReportRelationshipType.InnerResource:
reportDataResult.Model.HumanReadableName = innerResourceName;
break;
case ReportRelationshipType.OuterResource:
reportDataResult.Model.HumanReadableName = outerResourceName;
break;
case ReportRelationshipType.EmployeeInnerResource:
reportDataResult.Model.HumanReadableName =
_outerInnerResourceLocalizationService.GetString("Employee") + "-" + innerResourceName;
break;
case ReportRelationshipType.EmployeeOuterResource:
reportDataResult.Model.HumanReadableName =
_outerInnerResourceLocalizationService.GetString("Employee") + "-" + outerResourceName;
break;
case ReportRelationshipType.EmployeeTotal:
reportDataResult.Model.HumanReadableName =
_outerInnerResourceLocalizationService.GetString("Employee" + "-Total");
break;
case ReportRelationshipType.OuterInnerResource:
reportDataResult.Model.HumanReadableName =
$"{outerResourceName} {innerResourceName}";
break;
case ReportRelationshipType.InnerOuterResource:
reportDataResult.Model.HumanReadableName =
$"{innerResourceName} {outerResourceName}";
break;
}
excelFile = _excelService.CopyTemplateForNewAccount("report_template");
bool writeResult = _excelService.WriteRecordsExportModelsToExcelFile(
reportDataResult.Model,
model,
excelFile);
if (!writeResult)
{
throw new Exception($"Error while writing excel file {excelFile}");
}
FileStreamModel result = new FileStreamModel()
{
FilePath = excelFile,
FileStream = new FileStream(excelFile, FileMode.Open),
};
return(new OperationDataResult <FileStreamModel>(true, result));
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(excelFile) && File.Exists(excelFile))
{
File.Delete(excelFile);
}
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <FileStreamModel>(
false,
_outerInnerResourceLocalizationService.GetString("ErrorWhileGeneratingReportFile")));
}
}
