public async Task <CurrencyExchangeTransactionModel> SubmitTransactionAsync(CurrencyExchangeModel currencyExchangeModel,
double foreignCurrencyAmount,
DateTime transactionDate,
int rateId)
{
Rate rate = await RatesRepository.GetRateByIdAsync(rateId);
CurrencyExchangeTransaction transaction = new CurrencyExchangeTransaction()
{
LocalCurrencyAmount = currencyExchangeModel.LocalCurrencyAmount,
ForeignCurrencyAmount = foreignCurrencyAmount,
ForeignCurrencyCode = currencyExchangeModel.ForeignCurrencyCode,
Rate = rate,
TransactionDate = transactionDate,
UserId = currencyExchangeModel.UserId
};
TransactionsRepository.AddTransaction(transaction);
await TransactionsRepository.SaveChangesAsync();
return(new CurrencyExchangeTransactionModel()
{
Id = transaction.Id,
UserId = transaction.UserId,
LocalCurrencyAmount = transaction.LocalCurrencyAmount,
ForeignCurrencyAmount = transaction.ForeignCurrencyAmount,
ForeignCurrencyCode = transaction.ForeignCurrencyCode,
TransactionDate = transaction.TransactionDate,
});
}
public async Task ExchangeRate(IDialogContext context, LuisResult result)
{
string currency = result.Entities.First().Entity.ToUpper();
string url = "https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency=NZD&to_currency=" + currency + "&apikey=HZLXQ37YR6PGEMW7";
var client = new HttpClient();
HttpResponseMessage response;
response = await client.GetAsync(url);
try
{
var responseString = await response.Content.ReadAsStringAsync();
CurrencyExchangeModel responseModel = JsonConvert.DeserializeObject <CurrencyExchangeModel>(responseString);
double exchangerate = responseModel.RealtimeCurrencyExchangeRate.ExchangeRate;
string from_currency = responseModel.RealtimeCurrencyExchangeRate.From_CurrencyName;
string to_currency = responseModel.RealtimeCurrencyExchangeRate.To_CurrencyName;
string message = "1 " + from_currency + " equals " + exchangerate + " " + to_currency + "\n\n(data provided by www.alphavantage.co)";
await context.PostAsync(message);
context.Wait(MessageReceived);
}
catch
{
var message = "Unable to fetch exchange rate data.\n\nPlease try again.";
await context.PostAsync(message);
context.Wait(MessageReceived);
}
}
public async void ConvertUSDToGBP_RetrunsExpectedResult()
{
//Assign
var logger = new NullLogger <CurrencyExchangeHandler>();
var mockLogFormatter = new Mock <ILogFormatter>();
var mockExchangeRateService = new Mock <IExchangeRateService>();
mockExchangeRateService
.Setup(ex => ex.GetRate(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(1.2M));
var handler = new CurrencyExchangeHandler(logger, mockLogFormatter.Object, mockExchangeRateService.Object);
var currencyExchangeRequest = new CurrencyExchangeModel()
{
Amount = 9,
TargetCurrency = "GBP",
SourceCurrency = "USD"
};
var request = new CurrencyExchangeRequest(currencyExchangeRequest);
//Act
var actualResponse = await handler.Handle(request, new CancellationToken());
var convertedAmount = actualResponse.ConvertedAmount;
//Assert
convertedAmount.Should().Be(10.8M);
}
private async Task <CurrencyExchangeModel> GetExchangeModel()
{
var response = await _settings.Dolar.GetJsonAsync <IList <string> >();
var result = new CurrencyExchangeModel
{
Currency = REAL_CURRENCY_CODE,
Exchange = Convert.ToDecimal(response[0]) / 4,
Date = response[2]
};
return(result);
}
public async Task <IActionResult> ExecuteCurrencyExchangeAsync(CurrencyExchangeModel currencyExchangeModel)
{
if (!await RatesService.IsValidCurrencyToQuoteAsync(currencyExchangeModel.ForeignCurrencyCode))
{
return(BadRequest("Foreign currency not valid"));
}
if (currencyExchangeModel.Direction == CurrencyExchangeDirection.SellForeign)
{
return(BadRequest("Selling foreign currency not fully implemented yet (missing limit business logic)."));
}
DateTime transactionDate = DateTime.Now;
CurrencyQuoteModel foreignCurrencyRate = await RatesService.GetRateQuoteAsync(currencyExchangeModel.ForeignCurrencyCode,
transactionDate);
if (foreignCurrencyRate == null)
{
return(BadRequest($"No rate found for {currencyExchangeModel.ForeignCurrencyCode} on {transactionDate}"));
}
double foreignCurrencyAmount = CurrencyExchangeService.CalculateForeignCurrencyAmount(currencyExchangeModel.Direction,
currencyExchangeModel.LocalCurrencyAmount,
foreignCurrencyRate.SellValue,
foreignCurrencyRate.BuyValue);
double userRemainingLimit = await CurrencyExchangeService.GetUserRemainingLimitAsync(currencyExchangeModel.UserId,
currencyExchangeModel.ForeignCurrencyCode,
transactionDate);
//TODO: This validation works corretly when buying foreign, but needs refactor for selling
if (userRemainingLimit < foreignCurrencyAmount)
{
return(BadRequest("Operation would exceed monthly limits. Operation cancelled."));
}
CurrencyExchangeTransactionModel newTransaction = await CurrencyExchangeService.SubmitTransactionAsync(currencyExchangeModel,
foreignCurrencyAmount,
transactionDate,
foreignCurrencyRate.RateId);
return(Ok(newTransaction));
}
private void InitializeObjects()
{
apiCaller = new CallingApi(Const.API_KEY);
PhysicalCurrencies = CodesHelper.ReadCurrencies(Const.PATH_TO_PHYSICAL, CurrencyType.Physical).ToList();
DigitalCurrencies = CodesHelper.ReadCurrencies(Const.PATH_TO_DIGITAL, CurrencyType.Digital).ToList();
Currencies = PhysicalCurrencies.Concat(DigitalCurrencies).ToList();
DataContext = this;
ExchangeModel = new CurrencyExchangeModel();
ExchangeModel.PropertyChanged += ExchangeModel_PropertyChanged;
DailyModel = new CurrencyDailyModel();
DailyModel.PropertyChanged += DailyModel_PropertyChanged;
parser = new JsonParser();
CryptoDailyDisplays = new ObservableCollection <CryptoCurrencyDaily>();
}
public async void RequestWithInvalidTargetCurrency_ReturnsInternalServerError()
{
//Assign
var requestBody = new CurrencyExchangeModel()
{
Amount = 10,
SourceCurrency = "GBP",
TargetCurrency = ""
};
var request = new HttpRequestMessage(HttpMethod.Get, _uriPath)
{
Content = new StringContent(JsonSerializer.Serialize(requestBody),
Encoding.UTF8, "application/json")
};
//Act
var response = await _httpClient.SendAsync(request);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
}
public CurrencyExchangeModel GetCurrencyExchange(string baseCurrency, string currency)
{
if (baseCurrency == "RON")
{
var xe = new CurrencyExchangeModel
{
Currency = currency,
BaseCurrency = baseCurrency,
Value = currency switch
{
"RON" => 1,
"AUD" => GetExchangeRest(currency),
"EUR" => GetExchangeRest(currency),
"USD" => GetExchangeRest(currency),
"JPY" => GetExchangeRest(currency),
"GBP" => GetExchangeRest(currency),
"CDN" => GetExchangeRest(currency),
"CAD" => GetExchangeRest(currency),
_ => - 1
}
};
return(xe);
//retD.Add(xe.Currency, xe.ExchangeRate);
}
else
{
// get all from BCE except RON currency
var xe = new CurrencyExchangeModel {
Currency = currency, BaseCurrency = baseCurrency
};
var currencyValue = GetExchangeRest(baseCurrency);
var acc2 = GetExchangeRest(currency);
xe.Value = acc2 / currencyValue;
return(xe);
}
}
public async Task <string> GetCurrencyExchange(CurrencyExchangeModel model)
{
var formedUrl = string.Format(this.EXCHANGE_URL, model.From.Code, model.To.Code, this.apiKey);
return(await this.GetCurrency(formedUrl));
}
public async Task CurrencyCalculation(IDialogContext context, LuisResult result)
{
String currency_to = "";
String currency_from = "";
double amount = 0.0;
foreach (var ent in result.Entities)
{
if (ent.Type == "currency_to")
{
currency_to = ent.Entity.ToUpper();
}
else if (ent.Type == "currency_from")
{
currency_from = ent.Entity.ToUpper();
}
else if (ent.Type == "amount")
{
amount = Convert.ToDouble(ent.Entity);
}
}
if ((currency_from == "") || (currency_to == "") || (amount == 0.0))
{
var message = "Could not process currency conversion.\n\nPlease try rephrasing that.";
await context.PostAsync(message);
context.Wait(MessageReceived);
}
string url = "https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency=" + currency_from + "&to_currency=" + currency_to + "&apikey=HZLXQ37YR6PGEMW7";
var client = new HttpClient();
HttpResponseMessage response;
response = await client.GetAsync(url);
try
{
var responseString = await response.Content.ReadAsStringAsync();
CurrencyExchangeModel responseModel = JsonConvert.DeserializeObject <CurrencyExchangeModel>(responseString);
double exchangerate = responseModel.RealtimeCurrencyExchangeRate.ExchangeRate;
string from_currency = responseModel.RealtimeCurrencyExchangeRate.From_CurrencyName;
string to_currency = responseModel.RealtimeCurrencyExchangeRate.To_CurrencyName;
double currency_calc = exchangerate * amount;
string message = amount + " " + from_currency + "(s) equal " + currency_calc + " " + to_currency + "(s)\n\n(data provided by www.alphavantage.co)";
await context.PostAsync(message);
context.Wait(MessageReceived);
}
catch
{
var message = "Unable to fetch exchange rate data.\n\nPlease try again.";
await context.PostAsync(message);
context.Wait(MessageReceived);
}
}
