private async Task UpdateAccount(Coinbase.Models.Account coinbaseAccount, IEnumerable <AccountDto> accountsInDb)
{
var exchangeRate = await _exchangeRateService.GetExchangeRate(coinbaseAccount.Currency.Code);
if (exchangeRate == null)
{
_logger.LogWarning("Could not get exchange rate for currency {Currency}", coinbaseAccount.Currency.Name);
return;
}
var correspondingAccountInDb =
accountsInDb.FirstOrDefault(x => x.Currency.ToString() == coinbaseAccount.Currency.Code);
if (correspondingAccountInDb == null)
{
correspondingAccountInDb = new AccountDto
{
Currency = coinbaseAccount.Currency.Code,
Balance = coinbaseAccount.Balance.Amount * exchangeRate.NOKRate,
Exchange = "Coinbase"
};
_dbRepository.QueueAdd <Account, AccountDto>(correspondingAccountInDb);
}
else
{
correspondingAccountInDb.Balance = coinbaseAccount.Balance.Amount * exchangeRate.NOKRate;
_dbRepository.QueueUpdate <Account, AccountDto>(correspondingAccountInDb);
}
}
/// <summary>
/// Обменять валюту
/// </summary>
/// <param name="sourceCurrencyId">Идентификатор исходящей валюты</param>
/// <param name="destinationCurrencyId">Идентификатор входящей валюты</param>
/// <param name="sumInSourceCurrency">Сумма в исходящей валюте</param>
public void Exchange(long userId, int sourceCurrencyId, int destinationCurrencyId, decimal sumInSourceCurrency)
{
var wallet = walletRepository.GetWalletByUserId(userId);
if (wallet == null)
{
throw new ArgumentException($"В системе не заведен кошелек для пользователя с ИД = {userId}");
}
var sourceCurrency = currencyRepository.GetCurrencyById(sourceCurrencyId);
var destinationCurrency = currencyRepository.GetCurrencyById(destinationCurrencyId);
if (sourceCurrency == null)
{
throw new ArgumentException($"В БД не найдена валюта с ИД = {sourceCurrencyId}");
}
if (destinationCurrency == null)
{
throw new ArgumentException($"В БД не найдена валюта с ИД = {destinationCurrencyId}");
}
var exchangeRate = exchangeRateService.GetExchangeRate(sourceCurrency.Code, destinationCurrency.Code);
wallet.Withdraw(sourceCurrencyId, sumInSourceCurrency);
var sumInDestinationCurrency = sumInSourceCurrency * exchangeRate;
wallet.Deposit(destinationCurrencyId, sumInDestinationCurrency);
walletRepository.Update(wallet);
}
private void LoadExchangeIndexes()
{
_exchangeRateService.GetExchangeRate(RateType.USD).ContinueWith(task =>
{
if (task.Exception == null)
{
USD = task.Result;
}
});
_exchangeRateService.GetExchangeRate(RateType.EUR).ContinueWith(task =>
{
if (task.Exception == null)
{
EUR = task.Result;
}
});
}
public MessageModel <List <CurrencyInfoDTO> > GetCurrencyInfo([FromRoute, SwaggerParameter("國家 e.g. VN ", Required = true)] string country)
{
Logger.LogInformation(country);
List <CurrencyCode> currencyCodes = currencyService.GetCurrencyByCountry(country.ToUpper());
List <CurrencyInfoDTO> currencyInfoDTOs = mapper.Map <List <CurrencyInfoDTO> >(currencyCodes);
List <ExchangeRate> exchangeRates = exchangeRateService.GetExchangeRate();
foreach (CurrencyInfoDTO currency in currencyInfoDTOs)
{
currency.rate = exchangeRates.Find(rate => rate.CurrencyName.Equals(currency.currencyName)).Rate;
}
return(new MessageModel <List <CurrencyInfoDTO> >
{
Data = currencyInfoDTOs
});
}
public decimal GetExchangeRate(CurrencyPair currencyPair)
{
if (currencyPair.HaveSameCurrency())
{
return(1);
}
return(_exchangeRateProvider.GetExchangeRate(currencyPair.FromCurrency, currencyPair.ToCurrency));
}
public async Task <SignResult> Sign(Guid transferId)
{
var signResult = new SignResult();
var transfer = _transferRepository.GetById(transferId);
if (transfer == null)
{
signResult.ValidationResult.Messages.Add("The transfer that you want to sign doesn't exist");
return(signResult);
}
var account = _accountService.GetByUserId(transfer.UserId);
var transferValidation = _transferValidator.Validate(transfer);
if (transferValidation.Succeded)
{
var transaction = _mapper.Map <Transaction>(transfer);
var exchangeRate = await _exchangeRateService.GetExchangeRate(DateTime.Today, transfer.DestinationCurrencyCode, account.CurrencyCode);
if (exchangeRate == null)
{
signResult.ValidationResult.Messages.Add("There is no exchange rate available for the selected currencies.");
return(signResult);
}
transaction.UsedRate = exchangeRate.Rate;
transaction.UsedRateDate = exchangeRate.RateDate;
transaction.IsBaseCurrencySameAsTo = exchangeRate.IsBaseCurrencySameAsTo;
var transactionValidation = _transactionValidator.Validate(transaction);
if (transactionValidation.Succeded)
{
transfer.Status = Status.Signed;
transfer.UpdatedOn = DateTime.UtcNow;
if (exchangeRate.IsBaseCurrencySameAsTo)
{
account.Balance -= transaction.Amount / transaction.UsedRate;
}
else
{
account.Balance -= transaction.Amount * transaction.UsedRate;
}
signResult.TransactionId = _transferRepository.SignTransfer(transfer, transaction, account);
}
else
{
signResult.ValidationResult.Messages.AddRange(transactionValidation.Messages);
}
}
else
{
signResult.ValidationResult.Messages.AddRange(transferValidation.Messages);
}
return(signResult);
}
public async Task <ActionResult <string> > Get()
{
try
{
var rate = await _rateService.GetExchangeRate();
return(Ok(rate));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "exchangerate")] HttpRequest req,
ILogger log, IBinder binder)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var result = await _exchangeRateService.GetExchangeRate(binder);
if (result.ServiceResultCode == (int)HttpStatusCode.OK)
{
return(new OkObjectResult(result.Data.rate));
}
return(new StatusCodeResult(result.ServiceResultCode));
}
//
// GET: CreateEdit
public ActionResult CreateEdit(string xid)
{
UExchangeRate exRate = new UExchangeRate();
exRate.CurrencySelect = new SelectList(exchangeRateService.CurrencyObj.GetCurrencies(countryProg.Id), "Id", "Name");
exRate.MainCurrencyId = mbCurrency.Id.ToString();
exRate.MonthSelect = new SelectList(ExchangeRateExtension.GetMonths(), "Month", "MonthName");
exRate.Month = DateTime.Today.Month;
exRate.Year = DateTime.Today.Year;
Guid excRateId;
if (Guid.TryParse(xid, out excRateId))
{
ViewBag.Action = "Edit";
exRate._ExchangeRate = exchangeRateService.GetExchangeRate(excRateId);
}
return(View(exRate));
}
public async Task ShouldUpdateBalanceAndSetStatusSignedToTheTransfer()
{
//Arrange
var transfer = new Transfer
{
Amount = 100,
DestinationCurrencyCode = "USD",
CartId = Guid.NewGuid(),
DestinationAccountNumber = "TEST",
Status = "Pending",
UserId = Guid.NewGuid()
};
var account = new Account
{
CurrencyCode = "EUR",
Balance = 15200
};
var transaction = new Transaction
{
DestinationAccountNumber = transfer.DestinationAccountNumber,
Amount = transfer.Amount,
DestinationCurrencyCode = transfer.DestinationCurrencyCode,
UserId = transfer.UserId
};
transferRepository.GetById(Arg.Any <Guid>()).Returns(transfer);
accountService.GetByUserId(Arg.Any <Guid>()).Returns(account);
mapper.Map <Transaction>(Arg.Any <Transfer>()).Returns(transaction);
exchangeRateService.GetExchangeRate(Arg.Any <DateTime>(), "USD", "EUR").Returns(
new CachedExchangeRate
{
CurrencyCodeFrom = "EUR",
CurrencyCodeTo = "USD",
Rate = 1.18M,
RateDate = DateTime.Today,
IsBaseCurrencySameAsTo = true
});
//Act
var transferService = new TransferService(transferRepository, accountService, mapper, userRepository, exchangeRateService, new TransferValidator(), new TransactionValidator(accountService));
await transferService.Sign(transfer.Id);
//Assert
account.Balance.Should().BeApproximately(15115.25M, 2);
transfer.Status.Should().Be(Status.Signed);
}
