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; } }