private void commandToolStripMenuItem_Click(object sender, EventArgs e) { UpdateOutput("A account is created, transaction commands are queued up then committed, the results are displayed."); BankAccount bankAccount = new BankAccount(); TransactionsQueue queue = new TransactionsQueue(); CommandAbstract command; UpdateOutput("Beginning account balance: " + bankAccount.Balance.ToString()); command = new DepositCommand(bankAccount, 50); queue.AddTransaction(command); UpdateOutput("Depositing 50"); command = new DepositCommand(bankAccount, 20); queue.AddTransaction(command); UpdateOutput("Depositing 20"); command = new WithdrawCommand(bankAccount, 10); queue.AddTransaction(command); UpdateOutput("Withdrawing 10"); UpdateOutput("Before committing account balance: " + bankAccount.Balance.ToString()); queue.CommitTransactions(); UpdateOutput("Final account balance: " + bankAccount.Balance.ToString()); }
public void DepositCommandCreateTest() { DepositCommand command = new DepositCommand(null, 0); Assert.IsInstanceOfType(command, typeof(DepositCommand)); Assert.IsInstanceOfType(command, typeof(CommandAbstract)); }
public async Task <IActionResult> Deposit( [FromBody] DepositRequest request, CancellationToken token) { var query = new DepositCommand( request.AccountNumber, request.Amount, CorrelationContext.Get()); var response = await _mediator .Send( query, token); if (!response .ValidationResult .IsValid) { var errors = string.Empty; response .ValidationResult .Errors .ToList() .ForEach(e => { errors += $"{e}//r//n"; }); return(BadRequest(errors)); } return(Ok(new DepositView( response.Balance))); }
public IActionResult Deposit(DepositViewModel model) { if (ModelState.IsValid) { var command = new DepositCommand() { AccountId = model.AccountId, Amount = model.Amount }; var query = new DepositHandler().Handler(command); if (query.IsCompletedSuccessfully) { TempData["Success"] = $"{model.Amount.ToString("C")} deposited to account"; return(View()); } else { TempData["Error"] = $"Deposit failed"; return(View()); } } else { return(NotFound()); } }
public async void Deposit_Valid_Amount(string pin, string name, string accountId, double amount) { var account = Substitute.For <Account>(); var customer = Substitute.For <Customer>(); customer.FindAccount(Arg.Any <Guid>()) .Returns(account); customerReadOnlyRepository .GetByAccount(Guid.Parse(accountId)) .Returns(customer); var depositUseCase = new DepositService( customerReadOnlyRepository, customerWriteOnlyRepository, converter ); var request = new DepositCommand( Guid.Parse(accountId), amount ); DepositResult result = await depositUseCase.Handle(request); Assert.Equal(request.Amount, result.Transaction.Amount); }
public async Task <IActionResult> Deposit( [FromBody] DepositCommand command, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); return(Ok(await _mediator.Send(command, cancellationToken))); }
static void Main(string[] args) { //Receiver receiver = new Receiver(); //Command command = new ConcreteCommand(receiver); //Invoker invoker = new Invoker(); //invoker.SetCommand(command); //invoker.ExecuteCommand(); Account account = new Account(); var commandDepoist = new DepositCommand(account, 5000); var invoker = new Bank.Invoker(); invoker.SetCommand(commandDepoist); invoker.ExecuteCommand(); Console.WriteLine("The current amount of account is:{0}", account.TotalAmount); var commandWithdrawal = new WithdrawalCommand(account, 2000); invoker.SetCommand(commandWithdrawal); invoker.ExecuteCommand(); Console.WriteLine("The current amount of account is:{0}", account.TotalAmount); Console.Read(); }
public async Task <IActionResult> Deposit([FromBody] DepositRequest message) { var request = new DepositCommand(message.AccountId, message.Amount); await depositInput.Handle(request); return(depositPresenter.ViewModel); }
public void DepositCommandExecuteTest() { BankAccount bankAccount = new BankAccount(); DepositCommand command = new DepositCommand(bankAccount, 10); command.Execute(); Assert.AreEqual(bankAccount.Balance, 10); }
//-- Calls the Invoker method Deposit() that calls the ConcreteCommand Deposit public void DoDeposit() { Console.Write("How much is being deposited?\n$"); _deposit = new DepositCommand(_account, GetValue(), _transactionCount); _invoker.DepositCommand = _deposit; _invoker.Deposit(); _transactionCount = _invoker.TransactionHistory.Count + 1; }
public async Task <IActionResult> Deposit([FromBody] DepositCommand command) { var result = await _mediator.Send(command); return(result.Success ? Ok() : BadRequest(result.Error)); }
private void Deposit(DepositCommand depositCommand) { if (!_managedAccounts.TryGetValue(depositCommand.TransactionToAccountId, out var account)) { account = Context.ActorOf(_system.DI().Props <CustomerActor>(), depositCommand.TransactionToAccountId.ToString()); } account.Tell(depositCommand); }
public async Task Should_be_possible_to_deposit_amount_on_account() { var command = new DepositCommand { AccountNo = 4, Amount = 100 }; var content = new StringContent(command.AsJson(), Encoding.UTF8, "application/json"); var response = await _httpClient.PostAsync("api/account/deposit", content); response.StatusCode.Should().Be(HttpStatusCode.OK); }
string BuildDepositCommand() { var order = new DepositCommand() { AccountId = "test1", DepositAmount = 1000 }; return(JsonConvert.SerializeObject(order)); }
public Task <Result <Account> > Handle(DepositCommand request, CancellationToken cancellationToken) { var account = this._context.Accounts.Find(request.AccountNo); if (account is Account) { var result = account.Deposit(request.Amount); return(Task.FromResult(Result.From(account, result))); } return(Task.FromResult(Result.Fail <Account>($"Conta #{request.AccountNo} não encontrada"))); }
public async Task <IActionResult> Deposit([FromBody] DepositCommand command) { await Mediator.Send(command); var query = new InquiryByAccountNumberQuery() { AccountNumber = command.AccountNumber }; return(Ok(await Mediator.Send(query))); }
public async Task <IActionResult> Deposit(Guid accountId, [FromBody] DepositModel model, CancellationToken token) { var command = new DepositCommand { AccountId = accountId, Amount = model.Amount, }; var response = await mediator.Send(command, token); return(Ok(response)); }
public async Task <IActionResult> Deposit([FromRoute] int accountNumber, [FromBody] AccountOperationRequest request) { var depositCommand = new DepositCommand { AccountNumber = accountNumber, Amount = request.OperationAmount, Tags = request.Tags }; await _mediator.Send(depositCommand).ConfigureAwait(false); return(Ok()); }
public WhenDepositingMoney() { _accountAuthorisationMock = new Mock <IAccountAuthorisation>(); var container = Bootstrapper.BootstrapContainerAndAdapters(c => { c.RegisterInstance(_accountAuthorisationMock.Object); }); _command = container.GetInstance <DepositCommand>(); _bankAccountStore = container.GetInstance <IBankAccountStore>(); }
public void Deposit_GivenUnSupportCurrency_ShouldThrowBusinessErrorException() { var command = new DepositCommand() { AccountNumber = "1", Amount = 3, Currency = "VND" }; var result = Assert.ThrowsAsync <DepositFailException>(() => handler.Handle(command, CancellationToken.None)); result.ShouldNotBeNull(); result.Message.Contains("Invalid Currency VND."); }
public void Deposit_GivenNegativeExchangedAmount_ShouldThrowBusinessErrorException() { var command = new DepositCommand() { AccountNumber = "1", Amount = -3, Currency = "EUR" }; var result = Assert.ThrowsAsync <DepositFailException>(() => handler.Handle(command, CancellationToken.None)); result.ShouldNotBeNull(); result.Message.Contains($"Invalid actual amount {command.Amount * 40}"); }
/// <summary> /// The Command Handler. /// This Allows interleaving of processing because multiple deposits can happen concurrently /// </summary> /// <param name="command"></param> /// <returns></returns> public async Task Deposit(DepositCommand command) { if (this.IsClosed()) { throw new UnableToDepositToClosedAccountException(); } await this.ConcurrentWriteAsync(new DepositedEvent(command.Amount) { RelationEvent = Guid.NewGuid().ToString("D") }, MQ.MQPublishType.Asynchronous); }
private async Task DepositAsync(DepositCommand depositCommand) { IActorRef account; if (!_cachedAccounts.ContainsKey(depositCommand.TransactionToAccountId)) { account = await Context.ActorSelection($"../*/*/{depositCommand.TransactionToAccountId}").ResolveOne(TimeSpan.FromSeconds(10)); } else { account = _cachedAccounts[depositCommand.TransactionToAccountId]; } account?.Tell(depositCommand); }
public async Task <IActionResult> Deposit([FromBody] DepositCommand command) { DepositResult depositResult = await _depositCommandHandler.Execute(command); if (depositResult == null) { return(new NoContentResult()); } Model model = new Model( depositResult.Transaction.Amount, depositResult.Transaction.Description, depositResult.Transaction.TransactionDate, depositResult.UpdatedBalance); return(new ObjectResult(model)); }
private void InitializeFields() { _transactionCount = 1; _account = new SavingsAccount { Balance = 500.00m, //InterestPercentage = 0.0215m }; //_interest = new CalculateInterest(_account, _transactionCount); _balance = new GetBalanceCommand(_account, _transactionCount); _deposit = new DepositCommand(_account, 0m, _transactionCount); _withdraw = new WithdrawCommand(_account, 0m, _transactionCount); _revert = new RevertTransaction(_account, 0m, _transactionCount, 0); _invoker = new AccountInvoker(_balance, _deposit, _withdraw, _revert); }
// TODO: In the future use correlation id public async Task Execute(TransactionCommand command) { var currentEvents = (await bankTransactionEventStore.ReadAll(command.AccountId)).ToArray(); var currentVersion = currentEvents.Length; var balance = BalanceReport.GetBalance(currentEvents); TransactionEvent evt = command switch { DepositCommand deposit => new Deposit(deposit.Amount, deposit.AccountId, DateTimeOffset.Now, deposit.CorrelationId), WithdrawalCommand withdrawal when balance >= withdrawal.Amount => new Withdrawal(withdrawal.Amount, withdrawal.AccountId, DateTimeOffset.Now, withdrawal.CorrelationId), _ => throw new ArgumentException() }; await bankTransactionEventStore.Append(currentVersion, evt); } }
public async Task Deposit_GivenCorrectRequest_WithSameCurrency_ShouldDepositSuccessfulWithCorrectAmount() { DepositCommand command = new DepositCommand() { AccountNumber = "1", Amount = 30, Currency = "THB" }; await handler.Handle(command, CancellationToken.None); var depositAccount = context.BankAccounts.First(a => a.AccountNumber == command.AccountNumber); var currentBalance = _accountRepository.GetCurrentBalanceByAccountId(depositAccount); var withdrawTransaction = context.Transactions.FirstOrDefault(a => a.AccountId == depositAccount.Id && a.TransactionDatetime == dateTime.Now && a.Action == ActionCode.Deposit); currentBalance.ShouldBe(130); withdrawTransaction.ShouldNotBeNull(); withdrawTransaction.Amount.ShouldBe(30); depositAccount.LastActivityDate.ShouldBe(dateTime.Now); }
public void Setup() { var fixture = new Fixture(); _depositCommand = fixture.Build <DepositCommand>() .FromFactory(() => new DepositCommand(1, CurrencySettings.DefaultCurrencyKey)) .Create(); _depositCommandWithZeroMoney = fixture.Build <DepositCommand>() .FromFactory(() => new DepositCommand(0, CurrencySettings.DefaultCurrencyKey)) .Create(); _currencies = fixture.Build <Currency>() //.FromFactory(() => new Currency("PHP", 1,"en-PH")) .CreateMany(5); _wallets = fixture.Build <Wallet>() .CreateMany(1); _target = new DepositCommandHandler(_walletRepositoryMock.Object, _currencyRepositoryMock.Object, _authenticationServiceMock.Object); }
private async Task Handle(DepositCommand c, IEventPublisher publisher) { await _executionInfoRepository.GetOrAddAsync( OperationName, c.OperationId, () => new OperationExecutionInfo <WithdrawalDepositData>( OperationName, c.OperationId, new WithdrawalDepositData { AccountId = c.AccountId, Amount = c.Amount, AuditLog = c.AuditLog, State = WithdrawalState.Created, Comment = c.Comment }, _systemClock.UtcNow.UtcDateTime)); _chaosKitty.Meow(c.OperationId); publisher.PublishEvent(new DepositStartedInternalEvent(c.OperationId, _systemClock.UtcNow.UtcDateTime)); }
public async Task <IActionResult> Deposit([FromBody] DepositRequest request) { var command = new DepositCommand( request.AccountId, request.Amount); DepositResult depositResult = await depositService.Process(command); if (depositResult == null) { return(new NoContentResult()); } Model model = new Model( depositResult.Transaction.Amount, depositResult.Transaction.Description, depositResult.Transaction.TransactionDate, depositResult.UpdatedBalance ); return(new ObjectResult(model)); }