private async Task AddTransactionAsync(TransactionDTO transaction, BatchDTO batch)
{
var prefix = "[AddTransactionAsync]";
try
{
var category = await _categoryService.GetByNameAsync(transaction.Category.Name);
if (category == null)
{
batch.Failed += 1;
_logger.LogWarning($"{prefix} Unable to find category with name {transaction.Category.Name}");
}
else
{
transaction.BatchID = batch.ID;
transaction.Category = category;
transaction = await _transactionService.AddAsync(transaction);
_logger.LogInformation($"{prefix} Successfully added transaction with id {transaction.ID} to batch");
batch.Added += 1;
}
}
catch (Exception ex)
{
_logger.LogError($"{prefix} {ex.GetType().Name} exception while adding transaction to batch");
_logger.LogError(ex.StackTrace);
batch.Failed += 1;
}
}
public async Task <ActionResult> Post(TransactionDTO transaction)
{
TransactionModel transactionModel = _mapper.Map <TransactionModel>(transaction);
transactionModel.Status = TransactionStatus.Pending;
await _transactionService.AddAsync(transactionModel);
return(Ok());
}
public async Task <IActionResult> AddTransaction([FromBody] TransactionDTO transaction)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var info = await service.AddAsync(transaction);
return(info ? Ok() : StatusCode(400));
}
public async Task AddAsync_InvalidWalletGuid_ReturnsSuccessFalse()
{
var fakeTransaction = new WalletTransaction()
{
Guid = Guid.NewGuid(), Amount = 1, TransactionType = TransactionType.Deposit, WalletGuid = Guid.NewGuid()
};
_walletServiceMock.Setup(s => s.GetByGuidAsync(fakeTransaction.WalletGuid)).Returns(Task.FromResult <Wallet>(null));
var result = await transactionService.AddAsync(fakeTransaction);
using (new AssertionScope())
{
result.Sucess.Should().BeFalse();
result.Message.Should().Be("Transaction for invalid Wallet");
_transactionRepositoryMock.Verify(r => r.AddAsync(It.IsAny <WalletTransaction>()), Times.Never);
_walletServiceMock.Verify(s => s.UpdateAsync(It.IsAny <Wallet>()), Times.Never);
}
}
public async Task <IActionResult> Add([FromBody] AddTransactionRequest request, [FromRoute] int accountId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var response = await _transactionService.AddAsync(request, accountId);
if (!response.IsValid)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <IActionResult> PostAsync([FromBody] PostTransaction request)
{
var prefix = "[PostAsync]";
_logger.LogInformation($"{prefix} Executing action");
if (!ModelState.IsValid)
{
_logger.LogWarning($"{prefix} Invalid model");
return(BadRequest(ModelState));
}
var entity = _mapper.Map <PostTransaction, TransactionDTO>(request);
var response = await _service.AddAsync(entity);
_logger.LogInformation($"{prefix} Added transaction with id {response.ID}");
return(Created($"api/transactions/{response.ID}", response));
}
public async Task <IActionResult> PostAsync([FromBody] WalletTransaction walletTransaction)
{
try
{
var saveResponse = await _transactionService.AddAsync(walletTransaction);
if (saveResponse.Sucess)
{
return(Ok(saveResponse));
}
else
{
return(BadRequest(saveResponse));
}
}
catch (Exception)
{
return(BadRequest("Rejected"));
}
}
public async Task <IActionResult> PostTransaction([FromBody] Transaction transaction)
{
var res = await _transactionService.AddAsync(transaction);
return(Ok(res));
}
public async Task <IActionResult> UploadFileAsync([FromForm] UploadFileRequestModel model)
{
await _transactionService.AddAsync(model.File);
return(Ok());
}
