public async Task <CommandHandlingResult> Handle(CreateTransactionCommand command)
{
await _transactionsRepository.TryCreateAsync(command.OrderId, BitCoinCommands.SwapOffchain, "", null, "");
ChaosKitty.Meow();
return(CommandHandlingResult.Ok());
}
public async Task <IActionResult> Create([FromBody] CreateTransactionCommand command)
{
await transactionService.CreateTransactionAsync(command);
return(Created($"/api/transactions/{command.Id}", new EntityCreatedDto {
Id = command.Id
}));
}
public async Task <IActionResult> CreateTransaction([FromBody] CreateTransactionCommand createTransactionCommand)
{
var userId = User.GetUserId() ?? default;
createTransactionCommand.UserId = userId;
var response = await Mediator.Send(createTransactionCommand);
return(Created($"/v1/transactions/{response.TransactionId}", response));
}
public void UpdateCustomerEmotion(CustomerModel customer, CreateTransactionCommand command)
{
customer.LastestCustomerEmotion = command.CustomerEmotion;
customer.EmotionProbability = command.CustomerEmotionProbability;
context.Entry <CustomerModel>(customer).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
public async Task <ActionResult <string> > Create(string cardStatementId, [FromBody] CreateTransactionCommand command)
{
if (cardStatementId != command.CardStatementId)
{
return(BadRequest());
}
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> PostAsync([FromBody] TransactionCreationDto dto)
{
var query = new CreateTransactionCommand(dto);
var result = await this.mediator.RunCommandAsync <CreateTransactionCommand, Guid>(query).ConfigureAwait(false);
return(this.AcceptedAtRoute("TransactionsGetById", new RouteValueDictionary {
{ "id", result }, { "api-version", this.RouteData.Values["api-version"] }
}));
}
private void Handle(CreateTransactionCommand cmd)
{
if (!this.ConsumedCommands.TryGetValue(cmd.TransactionId, out var cmdList))
{
cmdList = new List <CreateTransactionCommand>();
this.ConsumedCommands.Add(cmd.TransactionId, cmdList);
}
cmdList.Add(cmd);
}
private void btTransferMoney_Click(object sender, EventArgs e)
{
var cmd = new CreateTransactionCommand()
{
FromAccountId = (cbFromAccountId.SelectedItem as AccountDTO).Id, ToAccountId = tbToAccount.Text, Sum = decimal.Parse(tbSumTransfer.Text)
};
Client.Execute(cmd);
MessageBox.Show("Transfer Success!");
OnDialogResult(System.Windows.Forms.DialogResult.OK);
}
private TransactionEntity ToEntity(CreateTransactionCommand createTransaction)
{
return(new TransactionEntity
{
Id = createTransaction.Id,
Amount = createTransaction.Amount,
Currency = createTransaction.Currency,
Date = createTransaction.Date,
Status = createTransaction.Status,
TransactionId = createTransaction.TransactionId
});
}
public async Task PayTransaction(PayTransaction model)
{
var command = new CreateTransactionCommand
{
TransactionType = TransactionType.FinancialReceipts,
ToUserId = model.ToUserId,
Amount = model.Amount,
FinancialProjectId = model.FinancialProjectId
};
await Mediator.Send(command);
}
public async Task Create()
{
var command = new CreateTransactionCommand();
_mockMediator.Setup(x => x.Send(command, It.IsAny <CancellationToken>()))
.ReturnsAsync(123);
var result = await _sut.Create(command);
Assert.IsAssignableFrom <OkObjectResult>(result.Result);
Assert.AreEqual(123, ((OkObjectResult)result.Result).Value);
}
public void Handle_ToUserIdIsNull_ShouldThrowValidationException()
{
var command = new CreateTransactionCommand
{
TransactionType = 0,
FinancialProjectId = "DASDASD",
ToUserId = null,
Amount = 1000
};
FluentActions.Invoking(async() => { await SendAsync(command); }).Should().Throw <ValidationException>();
}
public void Handle_AmountBelowZero_ShouldThrowValidationException()
{
var command = new CreateTransactionCommand
{
TransactionType = TransactionType.FinancialReceipts,
FinancialProjectId = "DASDASD",
ToUserId = SecondUser.Id,
Amount = -10
};
FluentActions.Invoking(async() => { await SendAsync(command); }).Should().Throw <ValidationException>();
}
public async Task Create(CreateTransactionCommand createTransaction)
{
var entity = new TransactionEntity
{
Id = createTransaction.Id,
Amount = createTransaction.Amount,
Currency = createTransaction.Currency,
Date = createTransaction.Date,
Status = createTransaction.Status,
TransactionId = createTransaction.TransactionId
};
await _context.Transactions.AddAsync(entity);
}
public async Task <IActionResult> Post([FromBody] CreateTransactionCommand command)
{
try
{
var result = await _mediator.Send(command);
return(Ok(result));
}
catch (Exception e)
{
_logger.LogError("Create Transaction failed:" + e.Message);
throw;
}
}
public async Task <ActionResult <bool> > SaveTransaction([FromBody] Transaction transaction)
{
var createTransactionCommand = new CreateTransactionCommand()
{
Transaction = transaction,
};
var result = await _mediator.Send(createTransactionCommand);
if (result.Type == CommandResultTypeEnum.InvalidInput)
{
return(new BadRequestResult());
}
return(new OkObjectResult(result.Result));
}
public async Task <IActionResult> Withdraw(CreateTransactionCommand command)
{
if (ModelState.IsValid)
{
command.Operation = "Withdrawal in Cash";
command.Type = "Debit";
var result = await _mediator.Send(command);
if (result.Success)
{
return(View("TransactionSuccess"));
}
TempData["Error"] = result.Message;
return(View(command));
}
return(View(command));
}
public async Task <ActionResult <Transaction> > Create([FromBody] CreateTransactionCommand command)
{
try
{
var authenticationUser = (AuthenticationUser)HttpContext.Items["auth"];
command.UserId = authenticationUser.UserId;
var result = await _mediator.Send(command);
_logger.LogInformation("New transaction from " + command.SenderAccountId + " to " + command.ReceiverAccountId + " in the amount of " + command.Amount + " has been created");
return(result);
}
catch (Exception e)
{
_logger.LogError("Transaction creation error");
return(NotFound());
}
}
public void InvalidAccountDepositTest()
{
var testAccount = TestData.MockAccount(_userId);
_mockAccountRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ThrowsAsync(new Exception());
_mockTransactionRepository
.Setup(x => x.Add(It.IsAny <Transaction>())).ReturnsAsync(new Guid());
var createTransactionCommand = new CreateTransactionCommand()
{
AccountId = new Guid(),
Amount = 50m,
Reference = "Test Reference",
TransactionType = TransactionType.Deposit,
CurrencyType = "GBP"
};
Assert.ThrowsAsync <Exception>(() => _createTransactionCommandHandler.Handle(createTransactionCommand, CancellationToken.None));
}
public async Task Handle_ValidId_ShouldDeleteTransaction()
{
var projectId = await CreateFinancialProject();
var transaction = new CreateTransactionCommand
{
FinancialProjectId = projectId,
Amount = 100,
ToUserId = SecondUser.Id,
TransactionType = TransactionType.FinancialReceipts
};
var transactionId = await SendAsync(transaction);
var context = CreateContext();
var oweRecord = context.OweRecords.FirstOrDefault(x => x.UserId == User.Id &&
x.OwedUserId == SecondUser.Id &&
x.FinancialProjectId == projectId);
oweRecord.Should().NotBeNull();
oweRecord !.Amount.Should().Be(transaction.Amount * -1);
var deleteTransaction = new DeleteTransactionCommand
{
Id = transactionId
};
await SendAsync(deleteTransaction);
context = CreateContext();
oweRecord = context.OweRecords.FirstOrDefault(x => x.UserId == User.Id &&
x.OwedUserId == SecondUser.Id &&
x.FinancialProjectId == projectId);
oweRecord.Should().NotBeNull();
oweRecord !.Amount.Should().Be(0);
var entity = await FindAsync <CoolWebsite.Domain.Entities.Financial.Transaction>(transactionId);
entity.Should().BeNull();
}
public async Task SalesRequest_WithoutStock_ShouldThrowException()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
var products = await TestFramework.DataFactory.AddProducts(2);
var command = new CreateTransactionCommand()
{
TransactionType = Domain.TransactionType.Sales,
PartnerId = partner.Id,
TransactionLines = products.Select(p => new CreateTransactionCommand.TransactionLine()
{
ProductId = p.Id,
ProductQuantity = 5
}).ToArray()
};
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().ThrowExactly <InputValidationException>()
.And.Errors.SelectMany(e => e.Value).Should().ContainMatch("*stock*");
}
public async Task ValidAccountTransactionsTest(int transactionType, decimal expected)
{
var testAccount = TestData.MockAccount(_userId);
_mockAccountRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(testAccount);
_mockTransactionRepository
.Setup(x => x.Add(It.IsAny <Transaction>())).ReturnsAsync(new Guid());
var createTransactionCommand = new CreateTransactionCommand()
{
AccountId = testAccount.Id,
Amount = 50m,
Reference = "Test Reference",
TransactionType = transactionType == 0 ? TransactionType.Deposit : TransactionType.Withdraw,
CurrencyType = "GBP"
};
var result = await _createTransactionCommandHandler.Handle(createTransactionCommand, CancellationToken.None);
result.Balance.ShouldBe(expected);
}
public async Task <ActionResult <TransactionModel> > PostTransaction(TransactionInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var command = new CreateTransactionCommand
{
Input = model
};
var result = await Mediator.Send(command, HttpContext.RequestAborted)
.ConfigureAwait(false);
if (result.IsFailure)
{
return(result.AsActionResult());
}
return(CreatedAtAction(nameof(GetTransaction), new { id = result.Value.Id }, result.Value));
}
public async Task SalesRequest_ShouldCreateTransaction()
{
CreateTransactionCommand.TransactionLine[] lines;
Partner partner;
{ // Create procurement transaction to prepare product stock for sales.
var t = await TestFramework.DataFactory.CreateProcurementTransaction(3);
lines = t.TransactionLines.Select(x => new CreateTransactionCommand.TransactionLine()
{
ProductId = x.Product.Id,
ProductQuantity = x.Quantity
}).ToArray();
partner = t.Partner;
}
var command = new CreateTransactionCommand()
{
TransactionType = Domain.TransactionType.Sales,
PartnerId = partner.Id,
TransactionLines = lines
};
// Act.
var result = await TestFramework.SendAsync(command);
var transaction = await TestFramework.Data.FindAsync <Transaction>(result, x => x.TransactionLines, x => x.Partner);
transaction.Should().NotBeNull();
transaction.Partner.Id.Should().Be(partner.Id);
transaction.Total.Amount.Should().Be(transaction.TransactionLines.Sum(x => x.UnitPrice.Amount * x.Quantity));
transaction.TransactionLines.Should().HaveSameCount(lines)
.And.Subject.Select(x => new { x.ProductId, ProductQuantity = x.Quantity })
.Should().BeEquivalentTo(command.TransactionLines,
o => o.ComparingByMembers <CreateTransactionCommand.TransactionLine>());
var products = await TestFramework.Data.GetAllAsync <Product>();
products.Should().Match(x => x.All(p => p.NumberInStock == 0)); // Because we sold the exact amount we procured.
}
public async Task <IActionResult> Post([FromBody] CreateTransactionRequest request)
{
var command = new CreateTransactionCommand(request.Amount, request.CurrencyCode, request.CardId, request.UniqueId, request.ChargeDate);
var result = await commandDispatcher.Dispatch(command);
if (result.Success)
{
var response = new CreateTransactionResponse()
{
Amount = result.Amount,
CardId = result.CardId,
ChargeDate = result.ChargeDate,
CurrencyCode = result.CurrencyCode,
Id = result.Id,
UniqueId = result.UniqueId
};
return(CreatedAtAction(null, response));
}
return(BadRequest(validationNotificationHandler.Notifications));
}
public async Task Handler_creates_new_transaction_with_the_correct_properties()
{
var category = Persister <Data.Entity.Category> .New().Persist();
var transaction = new Data.Entity.Transaction
{
CategoryId = category.Id,
Debit = 100,
Description = "Test transaction",
Recorded = DateTime.Now
};
var command = new CreateTransactionCommand(transaction);
var response = await mediator.ProcessCommandAsync <int>(command);
Assert.IsTrue(response.Successful, "The command response is successful");
var createdTransaction = await Context.Transactions.SingleAsync(p => p.Id == response.Result);
Assert.That.This(createdTransaction).HasSameProperties(transaction, "Id");
Assert.IsTrue(Context.Categories.Any());
}
public async Task <CommandHandlingResult> Handle(CreateTransactionCommand command)
{
var sw = new Stopwatch();
sw.Start();
try
{
await _transactionsRepository.TryCreateAsync(command.OrderId, BitCoinCommands.SwapOffchain, "", null, "");
ChaosKitty.Meow();
return(CommandHandlingResult.Ok());
}
finally
{
sw.Stop();
_log.Info("Command execution time",
context: new { TxHandler = new { Handler = nameof(TradeCommandHandler), Command = nameof(CreateTransactionCommand),
Time = sw.ElapsedMilliseconds } });
}
}
public async Task CreateTransactionAsync(CreateTransactionCommand command)
{
if (command.Id == Guid.Empty)
{
throw new AggregateValidationException("Invalid transaction id");
}
var transaction = await transactionRepository.GetAsync(command.Id);
if (transaction != null)
{
throw new AggregateIllegalLogicException("Cannot create transaciton with given id. Transaction exists.");
}
var application = new TransactionEntity(
command.Id,
command.Name,
command.Description,
command.IncomingStatusId,
command.OutgoingStatusId);
await transactionRepository.CreateAsync(application);
}
public async Task Handle_WrongUser_ShouldThrowNotFoundException()
{
var projectId = await CreateFinancialProject();
var transaction = new CreateTransactionCommand
{
FinancialProjectId = projectId,
Amount = 100,
ToUserId = SecondUser.Id,
TransactionType = TransactionType.FinancialReceipts
};
var id = await SendAsync(transaction);
var deleteTransaction = new DeleteTransactionCommand
{
Id = id
};
await RunAsUserAsync("*****@*****.**", "nah");
FluentActions.Invoking(async() => await SendAsync(deleteTransaction)).Should().Throw <NotFoundException>();
}
public async Task CreateTransaction_Tests(decimal amount, string type)
{
var command = new CreateTransactionCommand()
{
AccountId = 1, Amount = amount, Type = type
};
var options = new DbContextOptionsBuilder <BankAppDataContext>()
.UseInMemoryDatabase(databaseName: "CreateTransaction_Tests")
.Options;
using (var context = new BankAppDataContext(options))
{
context.Accounts.Add(new Account()
{
AccountId = 1, Balance = 1000
});
var handler = new CreateTransactionCommandHandler(context);
var result = await handler.Handle(command, CancellationToken.None);
Assert.False(result.Success);
}
}
