public async Task <ExchangeRate[]> GetRangeAsync(ExchangeRateFetchModel request)
{
var result = new List <ExchangeRate>();
var expectedResults = GetExpectedExchangeRates(request);
var toFetchRequest = request;
foreach (var step in fetchExchangeRateSteps.OrderBy(step => step.Order))
{
var fetchedRates = await step.ExecuteAsync(toFetchRequest);
if (!fetchedRates.Any())
{
continue;
}
result.AddRange(fetchedRates);
if (result.Count == expectedResults.Length)
{
return(result.ToArray());
}
var dataToFetch = expectedResults
.Where(r => !result.Any(
res => res.Date == r.Date &&
res.Source == r.Source &&
res.Target == r.Target))
.ToArray();
toFetchRequest = new ExchangeRateFetchModel(request.CurrencyCodes, dataToFetch.Min(r => r.Date), dataToFetch.Max(r => r.Date));
}
return(result.ToArray());
}
public Task <ExchangeRate[]> GetExchangeRateAsync(ExchangeRateFetchModel request) => exchangeRatesDbSet .Where(rate => rate.Date >= request.StartTime) .Where(rate => rate.Date <= request.EndTime) .Where(rate => request.SourceCurrencies.Contains(rate.Source)) .Where(rate => request.TargetCurrencies.Contains(rate.Target)) .ProjectTo <ExchangeRate>(mapper.ConfigurationProvider) .ToArrayAsync();
public async Task <ExchangeRate[]> GetExternalExchangeRates(ExchangeRateFetchModel request)
{
var requestUrls = ComposeRequestUrl(request);
var getExchangeTasks = requestUrls.Select(HttpClientUtil.GetAsync);
var fetchedResponses = await Task.WhenAll(getExchangeTasks);
return(fetchedResponses.SelectMany(Parse).OrderBy(rate => rate.Date).ToArray());
}
public async Task GetExternalExchangeRates_FetchForDateWithoutEntry_One_Target_Currency_ReturnEmptyArray()
{
var request = new ExchangeRateFetchModel(currencyCodesOneTarget, DateWithoutExchangeDateEntry, DateWithoutExchangeDateEntry);
var exchangeRateProvider = new ExchangeRateApiProvider();
var result = await exchangeRateProvider.GetExternalExchangeRates(request);
Assert.Empty(result);
}
public async Task <ExchangeRate[]> ExecuteAsync(ExchangeRateFetchModel request)
{
var daysBeforeStartTimeToFetch = 3;
var requestWithOffset = new ExchangeRateFetchModel(request.CurrencyCodes, request.StartTime.AddDays(-daysBeforeStartTimeToFetch), request.EndTime);
var results = await exchangeRateIntegrationService.GetExchangeRateAsync(requestWithOffset);
return(results.Where(r => r.Date >= request.StartTime).ToArray());
}
public async Task GetExternalExchangeRates_FetchFor08_05_2020_One_Target_Currency_ReturnCorrectResult()
{
var expectedExchangeDateValue = 1.084;
var testedDate = new DateTime(2020, 05, 08);
var request = new ExchangeRateFetchModel(currencyCodesOneTarget, testedDate, testedDate);
var exchangeRateProvider = new ExchangeRateApiProvider();
var result = await exchangeRateProvider.GetExternalExchangeRates(request);
Assert.True(result.Length == 1);
Assert.Equal(result[0].Value, expectedExchangeDateValue, 2);
Assert.Equal(result[0].Date, testedDate);
}
public async Task <ExchangeRate[]> GetExchangeRateAsync(ExchangeRateFetchModel request)
{
var parsedExchangeRates = await exchangeRateProvider.GetExternalExchangeRates(request);
if (!parsedExchangeRates.Any())
{
return(Array.Empty <ExchangeRate>());
}
var imputedExchangeRates = ImputForward(parsedExchangeRates, request.StartTime, request.EndTime);
await exchangeRateRepository.AddRangeAsync(imputedExchangeRates);
return(imputedExchangeRates);
}
private ExpectedExchangeRate[] GetExpectedExchangeRates(ExchangeRateFetchModel request)
{
var exchangeRatesToFetch = request.CurrencyCodes
.Select(currencyCode => (Source: currencyCode.Key, Target: currencyCode.Value));
return(Enumerable
.Range(0, (request.EndTime - request.StartTime).Days + 1)
.SelectMany(dayOffset => exchangeRatesToFetch,
(dayOffset, exchangeRate) =>
new ExpectedExchangeRate
{
Date = request.StartTime.AddDays(dayOffset),
Source = exchangeRate.Source,
Target = exchangeRate.Target
})
.ToArray());
}
public async Task GetExternalExchangeRates_FetchFor_0708_05_2020_One_Target_Currency_ReturnCorrectResults()
{
var startDate = new DateTime(2020, 05, 07);
var endDate = new DateTime(2020, 05, 08);
var request = new ExchangeRateFetchModel(currencyCodesOneTarget, startDate, endDate);
var exchangeRateProvider = new ExchangeRateApiProvider();
var result = await exchangeRateProvider.GetExternalExchangeRates(request);
Assert.True(result.Length == 2);
Assert.Equal(result.Min(res => res.Date), startDate);
Assert.Equal(result.Max(res => res.Date), endDate);
var expectedFirstDateExchangeValue = 1.0783;
Assert.Equal(result[0].Value, expectedFirstDateExchangeValue, 2);
Assert.Equal(result[0].Date, startDate);
var expectedSecondDateExchangeValue = 1.084;
Assert.Equal(result[1].Value, expectedSecondDateExchangeValue, 2);
Assert.Equal(result[1].Date, endDate);
}
public async Task GetExternalExchangeRates_FetchFor_0708_05_2020_Two_Target_Currency_ReturnCorrectResults()
{
var startDate = new DateTime(2020, 05, 07);
var endDate = new DateTime(2020, 05, 08);
var request = new ExchangeRateFetchModel(currencyCodesForMultipleTargets, startDate, endDate);
var exchangeRateProvider = new ExchangeRateApiProvider();
var result = await exchangeRateProvider.GetExternalExchangeRates(request);
Assert.True(result.Length == 4);
Assert.Equal(result.Min(res => res.Date), startDate);
Assert.Equal(result.Max(res => res.Date), endDate);
var expectedFirstDateEURExchangeValue = 1.0783;
var firstDayEuroExchangeRate = result.Where(rate => rate.Target == "EUR").First();
Assert.Equal(firstDayEuroExchangeRate.Value, expectedFirstDateEURExchangeValue, 2);
Assert.Equal(firstDayEuroExchangeRate.Date, startDate);
var expectedSecondDateEURExchangeValue = 1.084;
var secondDayEuroExchangeRate = result.Where(rate => rate.Target == "EUR").Skip(1).First();
Assert.Equal(secondDayEuroExchangeRate.Value, expectedSecondDateEURExchangeValue, 2);
Assert.Equal(secondDayEuroExchangeRate.Date, endDate);
var expectedFirstDatePLNExchangeValue = 0.231;
var firstDayPlnExchangeRate = result.Where(rate => rate.Target == "PLN").First();
Assert.Equal(firstDayPlnExchangeRate.Value, expectedFirstDatePLNExchangeValue, 2);
Assert.Equal(firstDayPlnExchangeRate.Date, startDate);
var expectedSecondDatePLNExchangeValue = 0.23;
var secondDayPlnExchangeRate = result.Where(rate => rate.Target == "PLN").Skip(1).First();
Assert.Equal(secondDayPlnExchangeRate.Value, expectedSecondDatePLNExchangeValue, 2);
Assert.Equal(secondDayPlnExchangeRate.Date, endDate);
}
public Task <ExchangeRate[]> ExecuteAsync(ExchangeRateFetchModel request) => exchangeRateRepository.GetExchangeRateAsync(request);
private static string GetRequestUrl(ExchangeRateFetchModel request, IEnumerable <string> sourceCurrencies, string destinationCurrency)
=> $"{baseUri}" +
$"?start_at={request.StartTime.ToString("yyyy-MM-dd")}" +
$"&end_at={request.EndTime.ToString("yyyy-MM-dd")}" +
$"&base={destinationCurrency}" +
$"&symbols={string.Join(",", sourceCurrencies.Distinct())}";
private string[] ComposeRequestUrl(ExchangeRateFetchModel request) => request.CurrencyCodes .GroupBy(currency => currency.Value) .Select(currenciesGroup => (DestCurrency: currenciesGroup.Key, SourceCurrencies: currenciesGroup.Select(currencyItem => currencyItem.Key)))
public Task <ExchangeRate[]> ExecuteAsync(ExchangeRateFetchModel request) => exchangeRateIntegrationService.GetExchangeRateAsync(request);
