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 Process(GetBasketDetailsInput input)
{
var basket = await basketReadOnlyRepository.Get(input.BasketId);
if (basket == null)
{
outputBoundary.Populate(null);
return;
}
BasketOutput output = outputConverter.Map <BasketOutput>(basket);
outputBoundary.Populate(output);
}
public async Task Handle(GetAccountDetailsCommand message)
{
var customer = await customerReadOnlyRepository.GetByAccount(message.AccountId);
if (customer == null)
{
outputBoundary.Populate(null);
return;
}
var account = customer.FindAccount(message.AccountId);
AccountResponse response = responseConverter.Map <AccountResponse>(account);
outputBoundary.Populate(response);
}
public async Task Process(GetCustomerDetailsInput input)
{
Customer customer = await customerReadOnlyRepository.Get(input.CustomerId);
if (customer == null)
{
throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet.");
}
List <Order> orders = await orderReadOnlyRepository.GetByCustomer(input.CustomerId);
List <OrderOutput> orderOutputs = new List <OrderOutput>();
if (orders.Count == 0)
{
throw new CustomerNotFoundException($"No order found for customer {input.CustomerId}.");
}
else
{
foreach (var item in orders)
{
OrderOutput orderOutput = outputConverter.Map <OrderOutput>(item);
orderOutputs.Add(orderOutput);
}
}
CustomerOutput output = outputConverter.Map <CustomerOutput>(customer);
output = new CustomerOutput(customer.Id, customer.PIN.Text, customer.Name.Text, orderOutputs);
outputBoundary.Populate(output);
}
public async Task Process(Input input)
{
Order order = await orderReadOnlyRepository.Get(input.OrderId);
TrackingOutput output = outputConverter.Map <TrackingOutput>(order);
outputBoundary.Populate(output);
}
public async Task Handle(GetCustomerDetaisCommand message)
{
Domain.Customers.Customer customer = await this.customerReadOnlyRepository.Get(message.CustomerId);
CustomerResponse response = responseConverter.Map <CustomerResponse>(customer);
outputBoundary.Populate(response);
}
public async System.Threading.Tasks.Task Execute()
{
var allTasks = await _taskRepository.GetAll();
var tasksDto = _outputConverter.Map <List <TaskDto> >(allTasks);
_outputBoundary.Populate(tasksDto);
}
public void Process(Input input)
{
cajuService.Run(input);
RunOutput output = outputConverter.Map <RunOutput>(input);
outputBoundary.Populate(output);
}
public async Task Process(ListBooksInput input)
{
var books = bookReadOnlyRepository.Select();
var booksOutput = books.Select(book => outputConverter.Map <BookOutput>(book));
ListBooksOutput output = new ListBooksOutput(booksOutput);
outputBoundary.Populate(output);
}
public async Task Process(RegisterInput input)
{
Customer customer = new Customer(input.PIN, input.Name);
await customerWriteOnlyRepository.Add(customer);
CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer);
RegisterOutput output = new RegisterOutput(customerOutput);
outputBoundary.Populate(output);
}
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 Handle(RegisterCommand message)
{
Customer customer = new Customer(new PIN(message.PIN), new Name(message.Name));
Account account = new Account();
Credit credit = new Credit(new Amount(message.InitialAmount));
account.Deposit(credit);
customer.Register(account);
await customerWriteOnlyRepository.Add(customer);
CustomerResponse customerResponse = responseConverter.Map <CustomerResponse>(customer);
AccountResponse accountResponse = responseConverter.Map <AccountResponse>(account);
RegisterResponse response = new RegisterResponse(customerResponse, accountResponse);
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 Process(AddBasketInput input)
{
Customer customer = await customerReadOnlyRepository.Get(input.CustomerId);
if (customer == null)
{
throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet.");
}
Basket basket = new Basket(customer.Id);
await basketWriteOnlyRepository.Add(basket);
CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer);
BasketOutput basketOutput = outputConverter.Map <BasketOutput>(basket);
AddBasketOutput output = new AddBasketOutput(customerOutput, basketOutput);
outputBoundary.Populate(output);
}
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 Process(RegisterInput input)
{
Customer customer = new Customer(input.PIN, input.Name);
Account account = new Account(customer.Id);
Credit credit = new Credit(account.Id, input.InitialAmount);
account.Deposit(credit);
customer.Register(account.Id);
await customerWriteOnlyRepository.Add(customer);
await accountWriteOnlyRepository.Add(account, credit);
CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer);
AccountOutput accountOutput = outputConverter.Map <AccountOutput>(account);
RegisterOutput output = new RegisterOutput(customerOutput, accountOutput);
outputBoundary.Populate(output);
}
public async Task Process(CreateBookInput input)
{
Book book = bookReadOnlyRepository.Select(input.Isbn);
if (book != null)
{
throw new BookAlreadyExistsException($"The book {input.Isbn} already exists.");
}
Book newNook = new Book(
input.BookName,
input.Isbn,
input.Author,
input.Price);
bookWriteOnlyRepository.Insert(newNook);
var output = outputConverter.Map <BookOutput>(newNook);
outputBoundary.Populate(output);
}
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 Handle(DepositCommand command)
{
Customer customer = await customerReadOnlyRepository.GetByAccount(command.AccountId);
if (customer == null)
{
throw new AccountNotFoundException($"The account {command.AccountId} does not exists or is already closed.");
}
Credit credit = new Credit(new Amount(command.Amount));
Account account = customer.FindAccount(command.AccountId);
account.Deposit(credit);
await customerWriteOnlyRepository.Update(customer);
TransactionResponse transactionResponse = responseConverter.Map <TransactionResponse>(credit);
DepositResponse response = new DepositResponse(transactionResponse, account.CurrentBalance.Value);
outputBoundary.Populate(response);
}
public void Process(Input input)
{
HexagonalTemplate order = new HexagonalTemplate(
input.Name,
input.UseCases,
input.UserInterface,
input.DataAccess,
input.Tips,
input.SkipRestore);
bus.Publish(order);
trackingService.OrderReceived(
order.Id,
order.Name.Text,
order.CommandLines);
OrderOutput generateOutput = outputConverter.Map <OrderOutput>(order);
outputBoundary.Populate(generateOutput);
}
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 Process(RemoveBookInput input)
{
Book book = await bookReadOnlyRepository.Get(input.BookId);
if (book == null)
{
throw new BookNotFoundException($"The book {input.BookId} does not exist.");
}
Basket basket = (input.BasketId != null)? await basketReadOnlyRepository.Get(input.BasketId):new Basket();
Removal removal = new Removal(book.Id);
basket.RemoveBook(removal);
await basketWriteOnlyRepository.Update(basket);
OrderOutput orderResponse = outputConverter.Map <OrderOutput>(removal);
RemoveBookOutput output = new RemoveBookOutput(orderResponse, basket.GetTotalPrice().Value);
outputBoundary.Populate(output);
}
public async Task Process(CheckoutInput input)
{
Customer customer = await customerReadOnlyRepository.Get(input.CustomerId);
if (customer == null)
{
throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet.");
}
Basket basket = await basketReadOnlyRepository.Get(input.BasketId);
if (basket == null)
{
throw new BasketNotFoundException($"The basket {input.BasketId} does not exist or it was already deleted.");
}
CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer);
BasketOutput basketOutput = outputConverter.Map <BasketOutput>(basket);
CheckoutOutput output = new CheckoutOutput(customerOutput, basketOutput, input.OrderDate, basket.GetTotalPrice().Value);
outputBoundary.Populate(output);
}
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 Handle(WithdrawCommand request)
{
Customer customer = await customerReadOnlyRepository.GetByAccount(request.AccountId);
if (customer == null)
{
throw new AccountNotFoundException($"The account {request.AccountId} does not exists or is already closed.");
}
Debit debit = new Debit(new Amount(request.Amount));
Account account = customer.FindAccount(request.AccountId);
account.Withdraw(debit);
await customerWriteOnlyRepository.Update(customer);
TransactionResponse transactionResponse = responseConverter.Map <TransactionResponse>(debit);
WithdrawResponse response = new WithdrawResponse(
transactionResponse,
account.CurrentBalance.Value
);
outputBoundary.Populate(response);
}