public static void ValidateInputRate(this ExchangeRateInput rateInput)
{
// TODO - Probably the best way is to load all currencies on Startup.cs
var currencies = new string[] { "CAD", "HKD", "USD", "PHP", "DKK", "HUF", "CZK", "GBP", "RON",
"SEK", "IDR", "INR", "BRL", "RUB", "HRK", "JPY", "THB", "CHF", "EUR", "MYR", "BGN", "TRY",
"CNY", "NOK", "NZD", "ZAR", "MXN", "SGD", "AUD", "ILS", "KRW", "PLN" };
if (string.IsNullOrWhiteSpace(rateInput.Dates))
{
throw new ApiException(HttpStatusCode.BadRequest, "Parameter 'dates' must not be empty");
}
if (!Regex.IsMatch(rateInput.BaseCurr, @"[A-Z]{3}$") || !currencies.Contains(rateInput.BaseCurr))
{
throw new ApiException(HttpStatusCode.BadRequest, $"Base currency {rateInput.BaseCurr} is not supported");
}
if (!Regex.IsMatch(rateInput.TargetCurr, @"[A-Z]{3}$") || !currencies.Contains(rateInput.TargetCurr))
{
throw new ApiException(HttpStatusCode.BadRequest, $"Target currency {rateInput.TargetCurr} is not supported");
}
rateInput.DatesArray = rateInput.Dates.Trim().Split(',');
if (!rateInput.DatesArray.IsDatesMatch())
{
throw new ApiException(HttpStatusCode.BadRequest, "Parameter 'dates' needs to be in 'yyyy-MM-dd' format, ',' separated");
}
}
/// <summary>
/// Reads response and prepare a list of exchange rate
/// </summary>
/// <param name="exchangeRateInput">Exchange rate input object</param>
/// <param name="dates">set of input dates in required format</param>
/// <param name="dataString">Reponse of the service call</param>
/// <returns>List of date along with exchange rate</returns>
private List <Tuple <double, DateTime> > ProcessResponse(ExchangeRateInput exchangeRateInput, List <DateTime> dates, Task <string> dataString)
{
try
{
var result = (JObject)JsonConvert.DeserializeObject(dataString?.Result.ToString());
var rateList = result.SelectToken(ExchangeRateConstant.Rate).ToList();
List <Tuple <double, DateTime> > outputList = new List <Tuple <double, DateTime> >();
if (rateList.Count > 1)
{
foreach (var item in rateList)
{
outputList.Add(new Tuple <double, DateTime>(Convert.ToDouble(item.ToString().Split(' ')[4].TrimEnd(ExchangeRateConstant.charToRemove).Trim()), (DateTime.Parse(item.ToString().Substring(1, 10).Trim(), CultureInfo.InvariantCulture)).Date));
}
}
else
{
outputList.Add(new Tuple <double, DateTime>(Convert.ToDouble(rateList[0].ToString().Split()[1].Trim()), (DateTime.Parse(exchangeRateInput.Dates[0].Trim(), CultureInfo.InvariantCulture)).Date));
}
outputList = outputList.Where(x => dates.Any(z => x.Item2 == z)).ToList();
return(outputList);
}
catch (Exception)
{
throw;
}
}
public void GetExchangeRateHistory_BadResultWithEmptyEndDate()
{
ExchangeRateInput exchangeRateInput = GetExchangeRateHistoryInputModel();
exchangeRateInput.EndDate = string.Empty;
var exchangeRateController = new ExchangeRateController();
var result = exchangeRateController.GetExchangeRateHistory(exchangeRateInput);
var contentResult = result as BadRequestResult;
Assert.IsNotNull(result);
}
public void GetExchangeRateHistory_ValidResult()
{
ExchangeRateInput exchangeRateInput = GetExchangeRateHistoryInputModel();
var exchangeRateController = new ExchangeRateController();
var result = exchangeRateController.GetExchangeRateHistory(exchangeRateInput);
var contentResult = ((OkNegotiatedContentResult <ExchangeRateOutputModel>)(result));
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
}
private ExchangeRateInput GetExchangeRateHistoryInputModel()
{
ExchangeRateInput exchangeRateInput = new ExchangeRateInput
{
BaseCurrency = "SEK",
TargetCurrency = "NOK",
StartDate = "2018-07-01",
EndDate = "2018-09-01"
};
return(exchangeRateInput);
}
public async Task <HttpResponseMessage> ExchangeRateResponse(ExchangeRateInput rateInput)
{
using (var client = new HttpClient())
{
var baseUri = _configuration.GetSection("BaseUri").Get <string>();
client.BaseAddress = new Uri(baseUri);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
return(await client
.GetAsync(@$ "history?start_at={rateInput.MinDate}&end_at={rateInput.MaxDate}&base={rateInput.BaseCurr}&symbols={rateInput.TargetCurr}"));
}
}
/// <summary>
/// Prepare request url as per input
/// </summary>
/// <param name="exchangeRateInput">Exchange rate input object</param>
/// <param name="dates">Set of input date</param>
/// <returns>Request Url</returns>
private string PrepareRequestUrl(ExchangeRateInput exchangeRateInput, List <DateTime> dates)
{
try
{
var minDate = dates.Min().ToString(ExchangeRateConstant.DateFormat, CultureInfo.InvariantCulture);
var maxDate = dates.Count > 1 ? dates.Max().ToString(ExchangeRateConstant.DateFormat, CultureInfo.InvariantCulture) : string.Empty;
var requestURL = string.IsNullOrEmpty(maxDate)
? minDate + ExchangeRateConstant.BaseCurrency + exchangeRateInput.BaseCurrency + ExchangeRateConstant.TargetCurrency + exchangeRateInput.TargetCurrency
: ExchangeRateConstant.StartAt + minDate + ExchangeRateConstant.EndAt + maxDate + ExchangeRateConstant.BaseCurrencyForPeriod + exchangeRateInput.BaseCurrency + ExchangeRateConstant.TargetCurrency + exchangeRateInput.TargetCurrency;
return(requestURL);
}
catch (Exception)
{
throw;
}
}
public IHttpActionResult GetExchangeRateHistory([FromUri] ExchangeRateInput exchangeRateInput)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
ExchangeRateOutputModel exchangeRateStatisticsForDateRange = ExchangeRateBusiness.GetExchangeRateStatistics(exchangeRateInput.StartDate, exchangeRateInput.EndDate,
exchangeRateInput.BaseCurrency, exchangeRateInput.TargetCurrency);
return(Ok(exchangeRateStatisticsForDateRange));
}
catch (Exception ex)
{
log.Error("GetExchangeRateHistory failed to serve the results", ex);
return(BadRequest());
}
}
public static void SetMinMaxDate(this ExchangeRateInput rateInput)
{
if (rateInput.DatesArray != null)
{
var datesList = new List <DateTime>();
foreach (var date in rateInput.DatesArray)
{
datesList.Add(DateTime.Parse(date));
}
if (datesList != null)
{
rateInput.MinDate = datesList.Min().ToString("yyyy-MM-dd");
rateInput.MaxDate = datesList.Max().ToString("yyyy-MM-dd");
}
}
}
public async Task <IActionResult> GetExchangeRateResult([FromQuery] ExchangeRateInput rateInput)
{
rateInput.ValidateInputRate();
rateInput.SetMinMaxDate();
var response = await _exchangeRateService.ExchangeRateResponse(rateInput);
if (response.IsSuccessStatusCode)
{
var objectResult = response.Content.ReadAsStringAsync().Result;
var rateOutput = JsonConvert.DeserializeObject <ExchangeRateOutput>(objectResult);
rateOutput.FilterRateOutput(rateInput.DatesArray);
return(Ok(new { rateOutput.MinRate, rateOutput.MaxRate, rateOutput.AvgRate }));
}
throw new Exception("Internal Service Error");
}
public ExchangeRateResponse GetExchangeRateInformation(ExchangeRateRequest exchangeRateRequest)
{
var exchangeRateResponse = new ExchangeRateResponse();
try
{
exchangeRateResponse = ValidateInput(exchangeRateRequest, exchangeRateResponse);
if (exchangeRateResponse.Error == null)
{
var exchangerateinput = new ExchangeRateInput
{
BaseCurrency = exchangeRateRequest.BaseCurrency,
TargetCurrency = exchangeRateRequest.TargetCurrency,
Dates = exchangeRateRequest.Dates
};
var result = _exchangeRateManager.GetExchangeRateInformation(exchangerateinput);
if (result.Error == null)
{
exchangeRateResponse.MinRate = result.MinRate;
exchangeRateResponse.MaxRate = result.MaxRate;
exchangeRateResponse.AverageRate = result.AverageRate;
}
else
{
exchangeRateResponse.Error = new ErrorResponse
{
ErrorCode = result.Error.ErrorCode,
ErrorMessage = result.Error.ErrorMessage
};
}
}
}
catch (Exception ex)
{
exchangeRateResponse.Error = new ErrorResponse
{
ErrorCode = HttpStatusCode.InternalServerError,
ErrorMessage = ex.Message
};
}
return(exchangeRateResponse);
}
/// <summary>
/// Method to fetch required exchange rate information based on input data
/// </summary>
/// <param name="exchangeRateInput">Exchange rate input model</param>
/// <returns>Exchange rate information based on input data</returns>
public ExchangeRateOutput GetExchangeRateInformation(ExchangeRateInput exchangeRateInput)
{
ExchangeRateOutput exchangeRateOutput = new ExchangeRateOutput();
try
{
if (_httpClient.BaseAddress == null)
{
ClientInitialSetup();
}
List <DateTime> dates = ProcessDate(exchangeRateInput.Dates);
string requestURL = PrepareRequestUrl(exchangeRateInput, dates);
var response = _httpClient.GetAsync(requestURL);
var dataString = response.Result.Content.ReadAsStringAsync();
response.Wait();
if (response.IsCompleted && response.Result.IsSuccessStatusCode)
{
List <Tuple <double, DateTime> > outputList = ProcessResponse(exchangeRateInput, dates, dataString);
exchangeRateOutput = PrepareOutput(outputList);
}
else
{
exchangeRateOutput.Error = new ErrorModel
{
ErrorCode = response.Result.StatusCode,
ErrorMessage = dataString.Result.Substring(10).TrimEnd(ExchangeRateConstant.charToRemove)
};
}
}
catch (Exception)
{
throw;
}
return(exchangeRateOutput);
}
public async Task <IHttpActionResult> GetExchangeRateHistoryAsync([FromUri] ExchangeRateInput exchangeRateInput)
{
return(await Task.FromResult(GetExchangeRateHistory(exchangeRateInput)));
}
