public async void Deposit_Valid_Amount(string accountId, double amount) { var account = new Account(); var customer = Substitute.For <Customer>(); accountReadOnlyRepository .Get(Guid.Parse(accountId)) .Returns(account); var output = Substitute.For <CustomPresenter <Application.UseCases.Deposit.DepositOutput> >(); var depositUseCase = new Application.UseCases.Deposit.DepositInteractor( accountReadOnlyRepository, bus, output, converter ); var request = new Application.UseCases.Deposit.DepositInput( Guid.Parse(accountId), amount ); await depositUseCase.Process(request); Assert.Equal(request.Amount, output.Output.Transaction.Amount); }
public async Task <CustomerOutput> Execute(Guid customerId) { Customer customer = await _customerReadOnlyRepository.Get(customerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {customerId} does not exists or is not processed yet."); } List <AccountOutput> accounts = new List <AccountOutput> (); foreach (Guid accountId in customer.Accounts.ToReadOnlyCollection()) { Account account = await _accountReadOnlyRepository.Get(accountId); if (account != null) { AccountOutput accountOutput = new AccountOutput(account); accounts.Add(accountOutput); } } CustomerOutput output = new CustomerOutput(customer, accounts); return(output); }
public async Task <CloseResult> Process(CloseCommand command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); account.Close(); await accountWriteOnlyRepository.Delete(account); CloseResult result = resultConverter.Map <CloseResult>(account); return(result); }
public async Task Process(CloseInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); account.Close(); await accountWriteOnlyRepository.Delete(account); CloseOutput output = outputConverter.Map <CloseOutput>(account); this.outputBoundary.Populate(output); }
public async void Deposit_Valid_Amount() { DepositMessage command = new DepositMessage() { AccountId = Guid.NewGuid(), Amount = 600 }; accountReadOnlyRepository .Get(command.AccountId) .Returns(new Account()); Deposit sut = new Deposit( accountReadOnlyRepository, accountWriteOnlyRepository); Credit credit = await sut.Handle(command); Assert.Equal(command.Amount, credit.Amount.Value); Assert.Equal("Credit", credit.Description); Assert.True(credit.Id != Guid.Empty); }
public async Task <AccountOutput> Execute(Guid accountId) { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists or is not processed yet."); } AccountOutput output = new AccountOutput(account); return(output); }
public async Task <Guid> Execute(CloseAccountCommand command) { Account account = await _accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exist or it is already closed"); } account.Close(); await _accountWriteOnlyRepository.Delete(account); return(account.Id); }
public async Task Process(GetAccountDetailsInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } AccountOutput output = outputConverter.Map <AccountOutput>(account); outputBoundary.Populate(output); }
public async Task <CreateFinanceStatementResult> Execute <T>(Guid accountId, Title title, Amount amount = null) where T : class, IFinanceStatement { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists!"); } T financeStatement = (T)Activator.CreateInstance(typeof(T), title, amount); FinanceStatementCollection collection = account .GetCollecion <T>(); collection.Add(financeStatement); await _accountWriteOnlyRepository.Update(account, financeStatement); decimal totalIncomes = account.Incomes.Total(); decimal totalExpenses = account.Expenses.Total(); decimal totalInvestments = account.Investments.Total(); CreateFinanceStatementResult result = new CreateFinanceStatementResult { Id = financeStatement.Id, Total = financeStatement.AmountRecords.Total(), Percentage = financeStatement.AmountRecords.Percentage(collection.Total()), AmountRecords = financeStatement.AmountRecords.GetAmountRecords().Select(x => new Results.AmountRecordResult { Id = x.Id, Amount = x.Amount, Description = x.Description }), Income = new Results.FinanceStatementResult { Total = totalIncomes }, Expense = new Results.FinanceStatementResult { Total = totalExpenses, Percentage = account.Expenses.Percentage(totalIncomes) }, Investment = new Results.FinanceStatementResult { Total = totalInvestments, Percentage = account.Investments.Percentage(totalIncomes) }, }; return(result); }
public async Task Process(GetAccountDetailsInput input) { var account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { outputBoundary.Populate(null); return; } AccountOutput output = outputConverter.Map <AccountOutput>(account); outputBoundary.Populate(output); }
public async Task <SaveAmountRecordResult> Execute <T>(Guid accountId, Guid financeStatementId, IEnumerable <AmountRecord> amountRecords) where T : class, IFinanceStatement { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists"); } T financeStatement = (T)account.Get <T>(x => x.Id == financeStatementId); financeStatement .AmountRecords .Replace(amountRecords); await _accountWriteOnlyRepository.Update(account, financeStatement); decimal incomeTotal = account.Incomes.Total(); decimal expenseTotal = account.Expenses.Total(); decimal investmentTotal = account.Investments.Total(); SaveAmountRecordResult result = new SaveAmountRecordResult { Id = financeStatement.Id, Total = financeStatement.AmountRecords.Total(), Percentage = financeStatement.AmountRecords.Percentage(account.GetCollecion <T>().Total()), AmountRecords = financeStatement.AmountRecords .GetAmountRecords() .Select(x => new Results.AmountRecordResult { Id = x.Id, Amount = x.Amount, Description = x.Description }), Income = new Results.FinanceStatementResult { Total = incomeTotal, }, Expense = new Results.FinanceStatementResult { Total = expenseTotal, Percentage = account.Expenses.Percentage(incomeTotal) }, Investment = new Results.FinanceStatementResult { Total = investmentTotal, Percentage = account.Investments.Percentage(incomeTotal) } }; return(result); }
public async Task Process(CloseInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } account.Close(); await accountWriteOnlyRepository.Delete(account); CloseOutput output = outputConverter.Map <CloseOutput>(account); this.outputBoundary.Populate(output); }
public async Task <Transaction> Handle(DepositCommand command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed."); } Transaction transaction = Credit.Create(command.CustomerId, Amount.Create(command.Amount)); account.Deposit(transaction); await accountWriteOnlyRepository.Update(account); return(transaction); }
public async Task <CloseResult> Process(CloseCommand command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed."); } account.Close(); await accountWriteOnlyRepository.Delete(account); CloseResult result = new CloseResult(account); return(result); }
public async Task <Credit> Handle(DepositMessage command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed."); } Credit credit = Credit.Create(Amount.Create(command.Amount)); account.Deposit(credit); await accountWriteOnlyRepository.Update(account); return(credit); }
public async Task Process(CloseInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } account.Close(); var domainEvents = account.GetEvents(); await bus.Publish(domainEvents); CloseOutput response = responseConverter.Map <CloseOutput>(account); this.outputBoundary.Populate(response); }
public async Task Process(DepositInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } Credit credit = new Credit(account.Id, input.Amount); account.Deposit(credit); await accountWriteOnlyRepository.Update(account, credit); TransactionOutput transactionResponse = outputConverter.Map <TransactionOutput>(credit); DepositOutput output = new DepositOutput(transactionResponse, account.GetCurrentBalance().Value); outputBoundary.Populate(output); }
public async Task <DepositOutput> Execute(Guid accountId, Amount amount) { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists or is already closed."); } account.Deposit(amount); Credit credit = (Credit)account.GetLastTransaction(); await _accountWriteOnlyRepository.Update(account, credit); DepositOutput output = new DepositOutput( credit, account.GetCurrentBalance()); return(output); }
public async Task <DepositResult> Process(DepositCommand command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed."); } Credit credit = new Credit(new Amount(command.Amount)); account.Deposit(credit); await accountWriteOnlyRepository.Update(account); TransactionResult transactionResult = resultConverter.Map <TransactionResult>(credit); DepositResult result = new DepositResult(transactionResult, account.GetCurrentBalance().Value); return(result); }
public async Task <DepositResult> Execute(DepositCommand command) { Account account = await _accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exist or it is already closed"); } account.Deposit(command.Amount); Credit credit = (Credit)account.GetLastTransaction(); await _accountWriteOnlyRepository.Update( account, credit); DepositResult result = new DepositResult( credit, account.GetCurrentBalance()); return(result); }
public async void Deposit_Valid_Amount(string accountId, double amount) { var account = new Account(Guid.NewGuid()); var customer = new Customer("08724050601", "Jorge Perales Diaz"); accountReadOnlyRepository .Get(Guid.Parse(accountId)) .Returns(account); var depositUseCase = new DepositUseCase( accountReadOnlyRepository, accountWriteOnlyRepository ); DepositResult result = await depositUseCase.Execute( Guid.Parse(accountId), amount); Assert.Equal(amount, result.Transaction.Amount); }
public async Task Process(RegisterInput message) { Customer customer = new Customer(message.PIN, message.Name); Account account = new Account(); account.Open(customer.Id, new Credit(account.Id, message.InitialAmount)); customer.Register(account.Id); var customerEvents = customer.GetEvents(); var accountEvents = account.GetEvents(); await bus.Publish(customerEvents); await bus.Publish(accountEvents); // // To ensure the Customer and Account are created in the database // we wait for the records be available in the following queries // with retry // bool consumerReady = await RetryGet(async() => await customerReadOnlyRepository.Get(customer.Id)) && await RetryGet(async() => await accountReadOnlyRepository.Get(account.Id)); if (!consumerReady) { customer = null; account = null; // // TODO: Throw exception, monitor the inconsistencies and fail fast. // } CustomerOutput customerOutput = responseConverter.Map <CustomerOutput>(customer); AccountOutput accountOutput = responseConverter.Map <AccountOutput>(account); RegisterOutput output = new RegisterOutput(customerOutput, accountOutput); outputBoundary.Populate(output); }
public async Task <RemoveFinanceStatementResult> Execute <T>(Guid accountId, Guid financeStatementId) where T : class, IFinanceStatement { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists"); } FinanceStatementCollection collection = account.GetCollecion <T>(); T financeStatement = (T)collection.Get(financeStatementId); collection.Remove(financeStatement); await _accountWriteOnlyRepository.Remove(account, financeStatement); decimal totalIncomes = account.Incomes.Total(); decimal totalExpenses = account.Expenses.Total(); decimal totalInvestments = account.Investments.Total(); RemoveFinanceStatementResult result = new RemoveFinanceStatementResult { Income = new Results.FinanceStatementResult { Total = totalIncomes }, Expense = new Results.FinanceStatementResult { Total = totalExpenses, Percentage = account.Expenses.Percentage(totalIncomes) }, Investment = new Results.FinanceStatementResult { Total = totalInvestments, Percentage = account.Investments.Percentage(totalIncomes) }, }; return(result); }
public async Task Process(WithdrawInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } Debit debit = new Debit(account.Id, input.Amount); account.Withdraw(debit); var domainEvents = account.GetEvents(); await bus.Publish(domainEvents); TransactionOutput transactionOutput = responseConverter.Map <TransactionOutput>(debit); WithdrawOutput output = new WithdrawOutput(transactionOutput, account.GetCurrentBalance().Value); outputBoundary.Populate(output); }
public async Task <WithdrawResult> Execute(Guid accountId, Amount amount) { Account account = await accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists or is already closed."); } account.Withdraw(amount); Debit debit = (Debit)account.GetLastTransaction(); await accountWriteOnlyRepository.Update(account, debit); WithdrawResult result = new WithdrawResult( debit, account.GetCurrentBalance() ); return(result); }
public async Task Process(GetCustomerDetailsInput input) { // // TODO: The following queries could be simplified // Customer customer = await customerReadOnlyRepository.Get(input.CustomerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exists or is not processed yet."); } List <AccountOutput> accounts = new List <AccountOutput>(); foreach (var accountId in customer.Accounts) { Account account = await accountReadOnlyRepository.Get(accountId); // // TODO: The "Accout closed state" is not propagating to the Customer Aggregate // if (account != null) { AccountOutput accountOutput = outputConverter.Map <AccountOutput>(account); accounts.Add(accountOutput); } } CustomerOutput output = outputConverter.Map <CustomerOutput>(customer); output = new CustomerOutput( customer.Id, customer.PIN.Text, customer.Name.Text, accounts); outputBoundary.Populate(output); }
public async Task Execute <T>(Guid accountId, Guid financeStatementId, Title title) where T : class, IFinanceStatement { Account account = await _accountReadOnlyRepository.Get(accountId); if (account == null) { throw new AccountNotFoundException($"The account {accountId} does not exists"); } FinanceStatementCollection collection = account.GetCollecion <T>(); if (collection.Any(x => x.Title == title && x.Id != financeStatementId)) { throw new FinanceStatementAlreadyExistsException($"Title {title} already exists!"); } FinanceStatement financeStatement = (FinanceStatement)collection.Get(financeStatementId); financeStatement.Update(title); await _accountWriteOnlyRepository.Update(account, financeStatement); }
public async Task Process(WithdrawInput input) { Account account = await accountReadOnlyRepository.Get(input.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {input.AccountId} does not exists or is already closed."); } Debit debit = new Debit(new Amount(input.Amount)); account.Withdraw(debit); await accountWriteOnlyRepository.Update(account); TransactionOutput transactionOutput = outputConverter.Map <TransactionOutput>(debit); WithdrawOutput output = new WithdrawOutput( transactionOutput, account.GetCurrentBalance().Value ); outputBoundary.Populate(output); }
public async Task <WithdrawResult> Process(WithdrawCommand command) { Account account = await accountReadOnlyRepository.Get(command.AccountId); if (account == null) { throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed."); } Debit debit = new Debit(account.Id, command.Amount); account.Withdraw(debit); await accountWriteOnlyRepository.Update(account, debit); TransactionResult transactionResult = resultConverter.Map <TransactionResult>(debit); WithdrawResult result = new WithdrawResult( transactionResult, account.GetCurrentBalance().Value ); return(result); }
public async void Deposit_Valid_Amount(string accountId, double amount) { var account = new Account(Guid.NewGuid()); var customer = new Customer("08724050601", "Ivan Paulovich"); accountReadOnlyRepository .Get(Guid.Parse(accountId)) .Returns(account); var depositUseCase = new DepositService( accountReadOnlyRepository, accountWriteOnlyRepository ); var request = new DepositCommand( Guid.Parse(accountId), amount ); DepositResult result = await depositUseCase.Process(request); Assert.Equal(request.Amount, result.Transaction.Amount); }