private static QuoteCurrency CreateQuoteCurrencyFromGetLatestCryptocurrencyQuotesResponseJsonContent(
string jsonText)
{
var jsonReader = new Utf8JsonReader(Encoding.UTF8.GetBytes(jsonText), isFinalBlock: true, state: default);
CurrencyCode currencyCode = null;
CurrencyExchangeRate crossRate = null;
var currentPropertyName = string.Empty;
while (jsonReader.Read())
{
switch (jsonReader.TokenType)
{
case JsonTokenType.PropertyName:
var previousPropertyName = currentPropertyName;
currentPropertyName = jsonReader.GetString();
TryParseQuoteCurrencyCode(previousPropertyName, currentPropertyName, ref currencyCode);
continue;
case JsonTokenType.Number:
TryParseQuoteCurrencyCrossRate(jsonReader.GetDecimal(), currentPropertyName, ref crossRate);
break;
default:
continue;
}
}
return(QuoteCurrency.Of(currencyCode, crossRate));
}
private static void TryParseQuoteCurrencyCrossRate(
decimal value, string currentPropertyName, ref CurrencyExchangeRate crossRate)
{
if (currentPropertyName == QuoteCurrencyCrossRatePropertyName)
{
crossRate = CurrencyExchangeRate.Of(value);
}
}
public async Task <CurrencyExchangeRate> Update(CurrencyExchangeRate exchangeRate)
{
ModelValidator.ValidateModelAttributes(exchangeRate);
Context.CurrencyExchangeRates.Update(exchangeRate);
await Context.SaveChangesAsync();
return(GetByKey(exchangeRate.Id));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="model"></param>
/// <returns></returns>
public static CurrencyExchangeRate Update(this CurrencyExchangeRate entity, CurrencyExchangeRateModel model)
{
if (entity == null)
{
return(null);
}
entity.Rate = model.Rate > 0 ? model.Rate : entity.Rate;
return(entity);
}
private async Task InsertDataToDb(CurrencyExchageRateApiResponse source)
{
foreach (var item in source.Rates)
{
var newData = new CurrencyExchangeRate
{
SourceCurrency = item.Key,
TargetCurrency = source.BaseCurrency,
ExchangeRate = item.Value,
Date = source.CreateTime
};
await _CurrencyExchangeRateRepository.InsertDataAsync(newData);
}
}
public Task <CurrencyExchangeRate> Update(CurrencyExchangeRate exchangeRate)
{
var exchangeRateRepository = ContextProvider.GetRepository <ICurrencyExchangeRateRepository>();
var targetExchangeRate = exchangeRateRepository.GetByKey(exchangeRate.Id);
if (targetExchangeRate == null)
{
throw new CashSchedulerException("There is no such exchange rate");
}
var currencyRepository = ContextProvider.GetRepository <ICurrencyRepository>();
if (!string.IsNullOrEmpty(exchangeRate.SourceCurrencyAbbreviation))
{
targetExchangeRate.SourceCurrency = currencyRepository.GetByKey(exchangeRate.SourceCurrencyAbbreviation);
if (targetExchangeRate.SourceCurrency == null)
{
throw new CashSchedulerException("There is no such currency", new[] { "sourceCurrencyAbbreviation" });
}
}
if (!string.IsNullOrEmpty(exchangeRate.TargetCurrencyAbbreviation))
{
targetExchangeRate.TargetCurrency = currencyRepository.GetByKey(exchangeRate.TargetCurrencyAbbreviation);
if (targetExchangeRate.TargetCurrency == null)
{
throw new CashSchedulerException("There is no such currency", new[] { "targetCurrencyAbbreviation" });
}
}
if (exchangeRate.ExchangeRate != default)
{
targetExchangeRate.ExchangeRate = exchangeRate.ExchangeRate;
}
if (exchangeRate.ValidFrom != default)
{
targetExchangeRate.ValidFrom = exchangeRate.ValidFrom;
}
if (exchangeRate.ValidTo != default)
{
targetExchangeRate.ValidTo = exchangeRate.ValidTo;
}
return(exchangeRateRepository.Update(targetExchangeRate));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static CurrencyExchangeRateModel ToModel(this CurrencyExchangeRate entity)
{
if (entity == null)
{
return(null);
}
return(new CurrencyExchangeRateModel
{
Id = entity.Id,
Rate = entity.Rate,
Day = entity.From,
});
}
public void AddCurrencyExchangeRate(string currency, double rate)
{
CurrencyExchangeRate currencyExchangeRate = new CurrencyExchangeRate {
Currency = currency, Rate = rate
};
if (MasterBank.currentBank.CurrencyExchangeList.Contains(currencyExchangeRate))
{
}
else
{
MasterBank.currentBank.CurrencyExchangeList.Add(currencyExchangeRate);
}
MasterBank.SaveCurrentState();
}
public async Task Create_ReturnsNewExchangeRate()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string currenciesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Currencies.json");
var currencies = JsonConvert.DeserializeObject <List <Currency> >(currenciesJson);
const string sourceCurrencyAbbreviation = "EUR";
const string targetCurrencyAbbreviation = "USD";
const float exchangeRate = 1.12f;
var sourceCurrency = currencies.First(c => c.Abbreviation == sourceCurrencyAbbreviation);
var targetCurrency = currencies.First(c => c.Abbreviation == targetCurrencyAbbreviation);
var newExchangeRate = new CurrencyExchangeRate
{
SourceCurrencyAbbreviation = sourceCurrencyAbbreviation,
TargetCurrencyAbbreviation = targetCurrencyAbbreviation,
ExchangeRate = exchangeRate,
IsCustom = true
};
UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user);
CurrencyRepository.Setup(c => c.GetByKey(sourceCurrencyAbbreviation)).Returns(sourceCurrency);
CurrencyRepository.Setup(c => c.GetByKey(targetCurrencyAbbreviation)).Returns(targetCurrency);
CurrencyExchangeRateRepository.Setup(c => c.Create(newExchangeRate)).ReturnsAsync(newExchangeRate);
var resultExchangeRate = await CurrencyExchangeRateService.Create(newExchangeRate);
Assert.NotNull(resultExchangeRate);
Assert.NotNull(resultExchangeRate.SourceCurrency);
Assert.NotNull(resultExchangeRate.TargetCurrency);
Assert.NotNull(resultExchangeRate.User);
Assert.Equal(TESTING_USER_ID, resultExchangeRate.User.Id);
Assert.Equal(sourceCurrencyAbbreviation, resultExchangeRate.SourceCurrency.Abbreviation);
Assert.Equal(targetCurrencyAbbreviation, resultExchangeRate.TargetCurrency.Abbreviation);
Assert.Equal(exchangeRate, resultExchangeRate.ExchangeRate);
Assert.Equal(DateTime.Today, resultExchangeRate.ValidFrom);
Assert.Equal(DateTime.Today, resultExchangeRate.ValidTo);
}
public async Task Delete_ThrowsException()
{
string currenciesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Currencies.json");
var currencies = JsonConvert.DeserializeObject <List <Currency> >(currenciesJson);
const int exchangeRateId = 1;
const string sourceCurrencyAbbreviation = "EUR";
const string targetCurrencyAbbreviation = "USD";
const float exchangeRate = 1.12f;
var sourceCurrency = currencies.First(c => c.Abbreviation == sourceCurrencyAbbreviation);
var targetCurrency = currencies.First(c => c.Abbreviation == targetCurrencyAbbreviation);
var currencyExchangeRate = new CurrencyExchangeRate
{
Id = exchangeRateId,
ExchangeRate = exchangeRate,
SourceCurrency = sourceCurrency,
TargetCurrency = targetCurrency,
IsCustom = false,
ValidFrom = DateTime.Today,
ValidTo = DateTime.Today.AddDays(1)
};
CurrencyExchangeRateRepository
.Setup(c => c.GetByKey(exchangeRateId))
.Returns(currencyExchangeRate);
CurrencyExchangeRateRepository
.Setup(c => c.Delete(exchangeRateId))
.ReturnsAsync(currencyExchangeRate);
await Assert.ThrowsAsync <CashSchedulerException>(async() =>
{
await CurrencyExchangeRateService.Delete(exchangeRateId);
});
}
public async Task <CurrencyExchangeRate> RequestExchangeRateAsync(string fromCurrency, string toCurrency)
{
var args = new List <KeyValuePair <string, string> >();
args.Add(new KeyValuePair <string, string>(FROM_CURRENCY_ARG, fromCurrency));
args.Add(new KeyValuePair <string, string>(TO_CURRENCY_ARG, toCurrency));
var url = GetUrl(CURRENCY_EXCHANGE_RATE_FUNC, args);
var json = await Request(url);
CurrencyExchangeRate rate = null;
if (json is JObject)
{
rate = CurrencyExchangeRate.FromJson((JObject)json);
}
if (rate == null)
{
log.WarnFormat("Failed to parse the result of request {0}", url);
log.WarnFormat("The JSON content is {0}", json);
}
return(rate);
}
public Task <CurrencyExchangeRate> Create(CurrencyExchangeRate exchangeRate)
{
var currencyRepository = ContextProvider.GetRepository <ICurrencyRepository>();
exchangeRate.SourceCurrency ??= currencyRepository.GetByKey(exchangeRate.SourceCurrencyAbbreviation);
exchangeRate.TargetCurrency ??= currencyRepository.GetByKey(exchangeRate.TargetCurrencyAbbreviation);
if (exchangeRate.SourceCurrency == null)
{
throw new CashSchedulerException("There is no such currency", new[] { "sourceCurrencyAbbreviation" });
}
if (exchangeRate.TargetCurrency == null)
{
throw new CashSchedulerException("There is no such currency", new[] { "targetCurrencyAbbreviation" });
}
if (exchangeRate.IsCustom && exchangeRate.User == null)
{
exchangeRate.User = ContextProvider.GetRepository <IUserRepository>().GetByKey(UserId);
}
return(ContextProvider.GetRepository <ICurrencyExchangeRateRepository>().Create(exchangeRate));
}
public async Task InsertDataAsync(CurrencyExchangeRate data)
{
await InsertAsync(data);
}
public async Task Update_ReturnsUpdatedExchangeRate()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string currenciesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Currencies.json");
var currencies = JsonConvert.DeserializeObject <List <Currency> >(currenciesJson);
const int exchangeRateId = 1;
const string sourceCurrencyAbbreviation = "EUR";
const string targetCurrencyAbbreviation = "USD";
const float exchangeRate = 1.12f;
const string newTargetCurrencyAbbreviation = "RUB";
const float newExchangeRate = 1.66f;
var sourceCurrency = currencies.First(c => c.Abbreviation == sourceCurrencyAbbreviation);
var targetCurrency = currencies.First(c => c.Abbreviation == targetCurrencyAbbreviation);
var newTargetCurrency = currencies.First(c => c.Abbreviation == newTargetCurrencyAbbreviation);
var oldCurrencyExchangeRate = new CurrencyExchangeRate
{
Id = exchangeRateId,
ExchangeRate = exchangeRate,
SourceCurrency = sourceCurrency,
TargetCurrency = targetCurrency,
ValidFrom = DateTime.Today,
ValidTo = DateTime.Today.AddDays(1)
};
var newCurrencyExchangeRate = new CurrencyExchangeRate
{
Id = exchangeRateId,
TargetCurrencyAbbreviation = newTargetCurrencyAbbreviation,
ExchangeRate = newExchangeRate,
ValidTo = DateTime.Today
};
UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user);
CurrencyRepository.Setup(c => c.GetByKey(sourceCurrencyAbbreviation)).Returns(sourceCurrency);
CurrencyRepository.Setup(c => c.GetByKey(targetCurrencyAbbreviation)).Returns(targetCurrency);
CurrencyRepository.Setup(c => c.GetByKey(newTargetCurrencyAbbreviation)).Returns(newTargetCurrency);
CurrencyExchangeRateRepository
.Setup(c => c.GetByKey(exchangeRateId))
.Returns(oldCurrencyExchangeRate);
CurrencyExchangeRateRepository
.Setup(c => c.Update(oldCurrencyExchangeRate))
.ReturnsAsync(oldCurrencyExchangeRate);
var resultExchangeRate = await CurrencyExchangeRateService.Update(newCurrencyExchangeRate);
Assert.NotNull(resultExchangeRate);
Assert.NotNull(resultExchangeRate.SourceCurrency);
Assert.NotNull(resultExchangeRate.TargetCurrency);
Assert.Equal(sourceCurrencyAbbreviation, resultExchangeRate.SourceCurrency.Abbreviation);
Assert.Equal(newTargetCurrencyAbbreviation, resultExchangeRate.TargetCurrency.Abbreviation);
Assert.Equal(newExchangeRate, resultExchangeRate.ExchangeRate);
Assert.Equal(DateTime.Today, resultExchangeRate.ValidFrom);
Assert.Equal(DateTime.Today, resultExchangeRate.ValidTo);
}
static void PrintExchangeRate(CurrencyRequestType requestType, string fromCurr, string toCurr, CurrencyExchangeRate rate)
{
if (rate == null)
{
Console.WriteLine("Failed to get rate for {0} to {1}", fromCurr, toCurr);
return;
}
Console.WriteLine(rate);
}
