protected void NotificarValidacoesErro(ValidationResult validationResult)
{
foreach (var error in validationResult.Errors)
{
_notifications.AddNotification(new Notification(error.PropertyName, error.ErrorMessage));
}
}
public async Task <ApplicationResponseViewModel> InsertAsync(ApplicationRequestViewModel applicationViewModel)
{
var applicationModel = _mapper.Map <ApplicationRequestModel>(applicationViewModel);
var trackCode = Guid.NewGuid().ToString("N");
var responseSso = await _ssoService.RegisterClient(new RegisterClientRequest()
{
ClientId = $"Like{trackCode}",
GrantType = "client_credentials",
Scopes = new string[1] {
"like-api"
}
});
if (responseSso is SsoError ssoError)
{
_domainNotification.AddNotification("SsoError", ssoError.ErrorMessage);
return(null);
}
var registerClientResponse = responseSso as RegisterClientResponse;
await _applicationRepository.InsertAsync(new ApplicationInsertDapper()
{
Id = trackCode,
Secret = registerClientResponse.ClientSecret,
Domains = applicationModel.Domains
});
return(new ApplicationResponseViewModel()
{
TrackCode = trackCode
});
}
public async Task <ExchangeRateResponse> GetQuoteForeignCurrencyAsync(QuoteForeignCurrencyRequest request)
{
var foreignExchangeRate = await _foreignExchangeRatesService.GetLatestExchangeRateAsync(request.Currency);
if (foreignExchangeRate == null)
{
_domainNotification.AddNotification("QuoteForeignCurrency", "Foreign Exchange Rates API request error");
return(null);
}
var exchangeRate = new ExchangeRate(request.Amount, foreignExchangeRate.Rates.BrazilianReal);
var calculateQuoteForeignCurrency = exchangeRate.CalculateQuoteForeignCurrency();
return(new ExchangeRateResponse(calculateQuoteForeignCurrency));
}
public async Task <CourseViewModel> UpdateAsync(CourseViewModel courseViewModel)
{
var model = _mapper.Map <Course>(courseViewModel);
model.Category = null;
var validation = new UpdateCourseValidation().Validate(model);
if (!validation.IsValid)
{
_domainNotification.AddNotifications(validation);
return(courseViewModel);
}
if (await _categoryRepository.GetByIdAsync(courseViewModel.CategoryId) != null)
{
await ValidateBusinessRulesAsync(courseViewModel);
if (!_domainNotification.HasNotifications)
{
_courseRepository.Update(model);
_unitOfWork.Commit();
var viewModel = _mapper.Map <CourseViewModel>(model);
return(viewModel);
}
}
else
{
_domainNotification.AddNotification("CourseNotFound", "O Curso nao foi encontrado!");
}
return(courseViewModel);
}
public async Task DebitAccount(Transaction transaction)
{
var account = await _accountRepository.GetAccountById(transaction.AccountId);
if (account == null)
{
_notification.AddNotification("DebitAccount", "Não foi possível encontrar sua conta.");
return;
}
if (!account.HasBalance(transaction.Value))
{
_notification.AddNotification("DebitAccount", "Saldo insuficiente para saque.");
return;
}
account.Debit(transaction.Value);
_accountRepository.AddTransaction(transaction);
_accountRepository.UpdateAccount(account);
await _unitOfWork.Commit();
}
public async Task <ViaCep> GetByCEPAsync(int cep)
{
var response = await _httpClient.GetAsync($"{cep}/json");
var stringResponse = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ViaCep>(stringResponse));
}
_domainNotification.AddNotification(HttpStatusCode.BadRequest.ToString(), "Cep não encontrado!", true);
return(null);
}
public async Task <Directions> GetAsync(string origin, string destination)
{
var response = await _httpClient.GetAsync($"json?origin={origin}&destination={destination}&key={keygoogle}");
var stringResponse = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <Directions>(stringResponse));
}
else
{
_domainNotification.AddNotification(JsonConvert.DeserializeObject <ResponseService>(stringResponse));
return(null);
}
}
public async Task <TransactionViewModel> Transaction(TransactionInputViewModel transactionVM)
{
TransactionViewModel viewModel = null;
var transaction = _mapper.Map <Transaction>(transactionVM);
var validation = await new TransactionInsertValidation().ValidateAsync(transaction);
if (!validation.IsValid)
{
_notification.AddNotifications(validation);
return(viewModel);
}
switch (transaction.TransactionType)
{
case ETransactionType.Debit:
await _transactionService.DebitAccount(transaction);
break;
case ETransactionType.Deposit:
case ETransactionType.BankIncome:
{
await _transactionService.DepositAccount(transaction);
break;
}
case ETransactionType.Transfer:
await _transactionService.TransferAccount(transaction);
break;
default:
_notification.AddNotification("transaction", "Tipo de transação não disponível.");
return(null);
}
viewModel = _mapper.Map <TransactionViewModel>(transaction);
return(viewModel);
}
