public RatesResponse GetShippingRates(RatesRequest request)
{
RatesResponse response = null;
//Calculate rates based on the request shippingfrom and shippingto information
//Do something here....
//Hardcoding shipping rates for this sample app
List <Shippingmethod> shippingmethods = new List <Shippingmethod>();
shippingmethods.Add(new Shippingmethod()
{
methodname = "DHL Priority", rate = 32.00
});
shippingmethods.Add(new Shippingmethod()
{
methodname = "USPS First Class", rate = 3.00
});
shippingmethods.Add(new Shippingmethod()
{
methodname = "UPS Ground", rate = 12.00
});
response = new RatesResponse()
{
shippingmethods = shippingmethods
};
return(response);
}
public async Task ExchangeCurrencyAsync_WhenGBPBaseRequestReceived_AndTargetIsEuro_ThenReturnConvertedValue()
{
// Arrange
var request = new CurrencyRequest()
{
TargetCurrency = "EUR",
SourceCurrency = "GBP",
Amount = 10,
};
var rateResponse = new RatesResponse()
{
Base = "GBP",
Date = Some <string>(),
Rates = new Dictionary <string, decimal>()
{
{ "EUR", 2 },
}
};
GetMock <IRatesService>()
.Setup(x => x.GetRatesAsync(request.SourceCurrency))
.ReturnsAsync(rateResponse);
// Act
var response = await SystemUnderTest.GetConvertedCurrencyAsync(request);
// Assert
Assert.IsType <ConvertedCurrencyResponse>(response);
Assert.Equal(20, response.ConvertedAmount);
}
public void GetRates()
{
RatesRequest ratesRequest = CreateGetRatesRequest();
VisibleRequest visibleRequest = new VisibleRequest(ratesRequest, "Rates/Retrieve");
RatesResponse ratesResponse = visibleRequest.Execute <RatesResponse>();
Assert.AreEqual(0, ratesResponse.ResultCode);
}
static async Task Main(string[] args)
{
var currency = "USD";
var exchangeRateClient = new ExchangeRateServiceClient("https://localhost:50051");
RatesResponse result = await exchangeRateClient.GetRates(currency);
Console.WriteLine(JsonSerializer.Serialize(result, new JsonSerializerOptions()
{
WriteIndented = true
}));
}
private async Task <IEnumerable <Rate> > GetMissingRates(RateFilterModel filterModel,
IEnumerable <Rate> cachingRates)
{
var response = new RatesResponse();
if (!cachingRates.Any())
{
response = await _externalRatesService.GetRatesAsync(filterModel.DateFrom,
filterModel.DateTo,
filterModel.BaseCurrency.Code,
filterModel.ResultCurrencyList.Select(x => x.Code));
}
else
{
var groupingCachingRates = cachingRates.GroupBy(x => x.ResultCurrencyId);
var fullMissingResultCurrency =
GetFullMissingResultCurrencyCodes(groupingCachingRates.Select(x => x.First().ResultCurrency.Code),
filterModel.ResultCurrencyList.Select(x => x.Code));
var partiallyMissingResultCurrency =
GetPartiallyMissingResultCurrencyCodes(groupingCachingRates, filterModel.DateFrom, filterModel.DateTo);
var minMaxUpdatingInterval = new Tuple <DateTime?, DateTime?>(null, null);
if (!partiallyMissingResultCurrency.Any() && !fullMissingResultCurrency.Any())
{
return(new List <Rate>());
}
if (fullMissingResultCurrency.Any())
{
minMaxUpdatingInterval = new Tuple <DateTime?, DateTime?>(filterModel.DateFrom, filterModel.DateTo);
}
else
{
if (partiallyMissingResultCurrency.Any())
{
minMaxUpdatingInterval = GetMinMaxMissingIntervalByCachingItems(cachingRates, filterModel.DateFrom, filterModel.DateTo);
}
}
if (!minMaxUpdatingInterval.Item1.HasValue || !minMaxUpdatingInterval.Item2.HasValue)
{
throw new ArgumentException("Nothing to search. Min/Max interval not found");
}
var missingCurrencyCodes = new List <string>(fullMissingResultCurrency);
missingCurrencyCodes.AddRange(partiallyMissingResultCurrency);
response = await _externalRatesService.GetRatesAsync(minMaxUpdatingInterval.Item1.Value, minMaxUpdatingInterval.Item2.Value,
filterModel.BaseCurrency.Code,
missingCurrencyCodes);
}
return(await ConvertResponseToList(response));
}
// GET: Rates
public ActionResult GetRates(RatesRequest jsonRatesRequest)
{
RatesResponse jsonRatesResponse = null;
bool isValid = false;
//Validate credentials
try
{
isValid = _ratesService.ValidateCredentials();
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized, ex.Message));
}
if (!isValid)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized, "Invalid Credentials"));
}
//Validate request
try
{
isValid = _ratesService.ValidateRequest(jsonRatesRequest);
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, ex.Message));
}
if (!isValid)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Bad Request"));
}
//Proceed to calculates the rates
try
{
jsonRatesResponse = _ratesService.GetShippingRates(jsonRatesRequest);
}
catch { }
if (jsonRatesResponse == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(Json(jsonRatesResponse));
}
public RatesResponse GetExchange(RatesRequest request)
{
var response = new RatesResponse();
var sourceCurrency = SupportedCurrencies.Currencies.Find(c => c.Code == request.From?.ToUpper());
var targetCurrency = SupportedCurrencies.Currencies.Find(c => c.Code == request.To?.ToUpper());
if (sourceCurrency != null && targetCurrency != null)
{
response.From = new Exchange(sourceCurrency, request.Amount);
response.To = _quotes.GetExchanges(sourceCurrency, targetCurrency, request.Amount);
return(response);
}
throw new ApplicationException(string.Format("Conversão de {0} para {1} não suportada!", request.From, request.To));
}
private async Task <IEnumerable <Rate> > ConvertResponseToList(RatesResponse response)
{
var currenciesMap = (await _ratesRepository.GetAllCurrencyAsync()).ToDictionary(key => key.Code, value => value);
var results = response.RatesDictionary.Select(x => x.Value.Select(y => new Rate
{
BaseCurrencyId = currenciesMap[response.BaseCurrencyCode].Id,
BaseCurrency = currenciesMap[response.BaseCurrencyCode],
ResultCurrencyId = currenciesMap[y.Key].Id,
ResultCurrency = currenciesMap[y.Key],
RateDate = DateTime.Parse(x.Key),
RateValue = y.Value
}));
var resultingRates = new List <Rate>();
foreach (var result in results)
{
resultingRates.AddRange(result);
}
return(resultingRates);
}
public static IExchangeRatesProvider GrpcClientMock()
{
var mockFX = new Mock <IExchangeRatesProvider>();
mockFX.Setup(instance => instance.GetRates(It.IsAny <string>())).Returns(() =>
{
var ratesResponse = new RatesResponse()
{
BaseCurrency = TestConstants.BaseCurrency,
};
var rates = new Dictionary <string, double>()
{
{ TestConstants.TargetCurrency, TestConstants.AudUsdConversionRate }
};
ratesResponse.Rates.Add(rates);
return(Task.FromResult(ratesResponse));
});
return(mockFX.Object);
}
public override async Task <RatesResponse> GetRates(RatesRequest request, ServerCallContext context)
{
var serializeOptions = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
var httpClient = _httpClientFactory.CreateClient("ExchangeRateHttpClient");
var uri = $"https://api.exchangeratesapi.io/latest?base={request.BaseCurrency}";
var apiResponse = await httpClient.GetFromJsonAsync <FxResponse>(uri, serializeOptions);
var result = new RatesResponse()
{
BaseCurrency = request.BaseCurrency, Date = apiResponse.Date
};
result.Rates.Add(apiResponse.Rates);
//TODO: cache this result.
return(result);
}
public async Task <Dictionary <Currencies, decimal> > GetLatestAsync(Currencies baseCurrency)
{
string cacheName = $"FER-RATES-{baseCurrency}";
if (_memoryCache.TryGetValue(cacheName, out Dictionary <Currencies, decimal> rates))
{
return(rates);
}
var result = await _httpClient.GetAsync($"{baseUrl}/latest?base={baseCurrency}").ConfigureAwait(false);
if (result.IsSuccessStatusCode)
{
string rawContent = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
RatesResponse ratesResponse = JsonConvert.DeserializeObject <RatesResponse>(rawContent);
if (ratesResponse != null && ratesResponse.Rates.Any())
{
return(_memoryCache.Set(cacheName, ratesResponse.Rates, GetNextRefreshDateTime(ratesResponse.Date).Subtract(DateTime.UtcNow.AddHours(1))));
}
}
return(new Dictionary <Currencies, decimal>());
}
public void Init()
{
this.apiClient = Setup.GetClient();
this.request = new RatesRequest()
{
pickupDate = new DateTime(2014, 12, 1)
, originPostalCode = "30303"
, originType = "business dock"
, destPostalCode = "60606"
, destType = "business dock"
, paymentTerms = "Outbound Prepaid"
, items = new List <QuoteItem>()
{
new QuoteItem()
{
freightClass = 50
, weight = 500
, length = 48
, width = 48
, height = 48
, hazardous = false
, pieces = 1
, package = "Pallets_other"
}
}
, charges = new List <string>()
{
"liftgate pickup"
}
};
var task = apiClient.GetRates(request);
task.Wait(30000);
this.result = task.Result;
}
