public async Task Execute(GetCustomerDetailsInput input)
{
ICustomer customer = await _customerRepository.Get(input.CustomerId);
if (customer == null)
{
_outputHandler.NotFound($"The customer {input.CustomerId} does not exist or is not processed yet.");
return;
}
List <Boundaries.GetCustomerDetails.Account> accounts = new List <Boundaries.GetCustomerDetails.Account>();
foreach (Guid accountId in customer.Accounts.GetAccountIds())
{
IAccount account = await _accountRepository.Get(accountId);
if (account != null)
{
Boundaries.GetCustomerDetails.Account accountOutput = new Boundaries.GetCustomerDetails.Account(account);
accounts.Add(accountOutput);
}
}
GetCustomerDetailsOutput output = new GetCustomerDetailsOutput(customer, accounts);
_outputHandler.Default(output);
}
public async Task Execute(TransferInput input)
{
IAccount originAccount;
IAccount destinationAccount;
try
{
originAccount = await _accountRepository.Get(input.OriginAccountId);
destinationAccount = await _accountRepository.Get(
input.DestinationAccountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var debit = originAccount.Withdraw(_entityFactory, input.Amount);
var credit = destinationAccount.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(originAccount, debit);
await _accountRepository.Update(destinationAccount, credit);
await _unitOfWork.Save();
BuildOutput(debit, originAccount, destinationAccount);
}
public async Task Execute(WithdrawInput input)
{
IAccount account;
IDebit debit;
try
{
account = await _accountRepository.Get(input.AccountId);
debit = account.Withdraw(_entityFactory, input.Amount);
}
catch (AccountNotFoundException notFoundEx)
{
_outputPort.NotFound(notFoundEx.Message);
return;
}
catch (MoneyShouldBePositiveException outOfBalanceEx)
{
_outputPort.OutOfBalance(outOfBalanceEx.Message);
return;
}
await _accountRepository.Update(account, debit);
await _unitOfWork.Save();
BuildOutput(debit, account);
}
public async Task Execute(InputData inputData)
{
try
{
var country = await _countriesService.FindByName(inputData.Name);
if (country is null)
{
throw new ArgumentOutOfRangeException("Name", inputData.Name, Resources.CountryNameNotFound);
}
var outputData = new OutputData(
country.Name,
country.Abbreviation,
country.Flag,
country.Population,
country.Capital,
country.Region,
country.Currencies.Select(currency => new OutputDataCurrency(currency.Name)).ToArray(),
country.EconomicGroups.Select(economicBloc => new OutputDataEconomicBloc(economicBloc.Acronym, economicBloc.Name)).ToArray(),
country.Languages,
country.Timezones,
country.Borders);
_outputPort.Success(outputData);
}
catch (ArgumentOutOfRangeException outOfRangeEx)
{
_outputPort.NotFound(outOfRangeEx.ActualValue);
}
}
public async Task ExecuteAsync(string userId, int postId)
{
var post = await _postRepository.GetAsync(postId);
if (post is null || post.UserId != userId)
{
_outputPort.NotFound();
return;
}
var result = await _imageService.RemoveAsync(post.Image);
if (result.IsT1)
{
_notification.Add("Detail", result.AsT1.Value);
_outputPort.Error();
return;
}
await _postRepository.RemoveAsync(postId);
_outputPort.Ok();
}
private async Task Withdraw(AccountId accountId, Money withdrawAmount)
{
var customerId = _customerService.GetCurrentCustomerId();
IAccount account = await _accountRepository.Find(accountId, customerId);
if (account is Account withdrawAccount)
{
Money localCurrencyAmount = await _currencyExchanger.Convert(withdrawAmount, withdrawAccount.Currency);
Debit debit = _accountFactory.NewDebit(withdrawAccount, localCurrencyAmount, DateTime.UtcNow);
var currentBalance = withdrawAccount.GetCurrentBalance();
if (currentBalance.Subtract(debit.Amount).Amount < 0)
{
_logger.LogWarning($"{nameof(Withdraw)} Account {accountId} balance insufficient");
_outputPort?.OutOfFunds();
return;
}
await Withdraw(withdrawAccount, debit);
_outputPort?.Ok(debit, withdrawAccount);
return;
}
_logger.LogWarning($"{nameof(Withdraw)} Account {accountId} not found for customer {customerId}");
_outputPort?.NotFound();
}
/// <summary>
/// Executes Get User Detail Use Case
/// </summary>
/// <param name="input">The input<see cref="RegisterUserInput"/></param>
/// <returns>The <see cref="Task"/></returns>
public async Task Execute(UserDetailsInput input)
{
if (input is null)
{
_outputPort.WriteError(Messages.InputIsNull);
_logger.LogInformation(Messages.InputIsNull);
return;
}
else if (input.Id <= 0)
{
var message = string.Format(Messages.InvalidInputFor, Messages.UserId);
_outputPort.WriteError(message);
_logger.LogInformation(message);
return;
}
_logger.LogInformation("Validation ok, retrieving user detail..");
var result = await _userRepository.GetById(input.Id);
if (result == null)
{
_logger.LogInformation(Messages.CouldNotFindResult);
_outputPort.NotFound(Messages.CouldNotFindResult);
return;
}
var output = new UserDetailsOutput
{
User = (User)result
};
this._outputPort.Standard(output);
}
public async Task Execute(GetCustomerDetailsInput input)
{
ICustomer customer;
if (_userService.GetCustomerId() is CustomerId customerId)
{
try
{
customer = await _customerRepository.GetBy(customerId);
}
catch (CustomerNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
}
else
{
_outputPort.NotFound("Customer does not exist.");
return;
}
var accounts = new List <Boundaries.GetCustomerDetails.Account>();
foreach (AccountId accountId in customer.Accounts.GetAccountIds())
{
IAccount account;
try
{
account = await _accountRepository.Get(accountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var outputAccount = new Boundaries.GetCustomerDetails.Account(account);
accounts.Add(outputAccount);
}
BuildOutput(
_userService.GetExternalUserId(),
customer,
accounts);
}
public async Task Execute(UpdateUserInput input)
{
try
{
await _userRepository.Update(input.User);
BuildOutput(input.User);
}
catch (UserNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
}
}
public async Task Execute(GetAccountDetailsInput input)
{
IAccount account = await _accountRepository.Get(input.AccountId);
if (account == null)
{
_outputHandler.NotFound($"The account {input.AccountId} does not exist or is not processed yet.");
return;
}
GetAccountDetailsOutput output = new GetAccountDetailsOutput(account);
_outputHandler.Default(output);
}
public async Task Execute(GetCustomerDetailsInput input)
{
ICustomer customer;
try
{
customer = await _customerRepository.Get(input.CustomerId);
}
catch (CustomerNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var accounts = new List <Boundaries.GetCustomerDetails.Account>();
foreach (Guid accountId in customer.Accounts.GetAccountIds())
{
IAccount account;
try
{
account = await _accountRepository.Get(accountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var outputAccount = new Boundaries.GetCustomerDetails.Account(account);
accounts.Add(outputAccount);
}
BuildOutput(customer, accounts);
}
public async Task Execute(GetUserDetailsInput input)
{
IUser user;
try
{
user = await _userRepository.Get(input.UserId);
BuildOutput(user);
}
catch (UserNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
}
}
public async Task Execute(GetAccountDetailsInput input)
{
IAccount account;
try
{
account = await _accountRepository.Get(input.AccountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
BuildOutput(account);
}
public void Execute(CustomerGetRequest request)
{
try
{
var customer = customerReadOnlyRepository.GetById(request.CustomerId);
if (customer == null)
{
output.NotFound($"Not found customer with id: {request.CustomerId}");
return;
}
output.Standard(customer);
}
catch (Exception ex)
{
output.Error($"Error on process: {ex.Message}");
}
}
public async Task Execute(DepositInput input)
{
try
{
var account = await _accountRepository.Get(input.AccountId);
var credit = await _accountService.Deposit(account, input.Amount);
await _unitOfWork.Save();
BuildOutput(credit, account);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
}
public async Task Execute(CloseAccountInput input)
{
IAccount account;
try
{
account = await _accountRepository.Get(input.AccountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
if (account.IsClosingAllowed())
{
await _accountRepository.Delete(account);
}
BuildOutput(account);
}
public async Task Execute(DepositInput input)
{
IAccount account;
try
{
account = await _accountRepository.Get(input.AccountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var credit = account.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(account, credit);
await _unitOfWork.Save();
BuildOutput(credit, account);
}
public async Task Execute(TransferInput input)
{
try
{
var originAccount = await _accountRepository.Get(input.OriginAccountId);
var destinationAccount = await _accountRepository.Get(input.DestinationAccountId);
var debit = await _accountService.Withdraw(originAccount, input.Amount);
var credit = await _accountService.Deposit(destinationAccount, input.Amount);
await _unitOfWork.Save();
BuildOutput(debit, originAccount, destinationAccount);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
}
public async Task Execute(WithdrawInput input)
{
try
{
var account = await _accountRepository.Get(input.AccountId);
var debit = await _accountService.Withdraw(account, input.Amount);
await _unitOfWork.Save();
BuildOutput(debit, account);
}
catch (AccountNotFoundException notFoundEx)
{
_outputPort.NotFound(notFoundEx.Message);
return;
}
catch (MoneyShouldBePositiveException outOfBalanceEx)
{
_outputPort.OutOfBalance(outOfBalanceEx.Message);
return;
}
}
