public void GetRates_ДанныеБерутсяИзIRatesSourceProvider_ВозвращаетсяРезультат()
{
IEnumerable <RateInfo> list = new List <RateInfo>()
{
new RateInfo()
{
To = "RUB",
Rate = 10,
}
};
var result = new Task <IEnumerable <RateInfo> >(() => list);
var ratesStorageService = new Mock <IRatesStorageService>();
ratesStorageService.Setup(o => o.SaveRates(It.IsAny <string>(), It.IsAny <IEnumerable <ExpiredRateInfo> >()))
.Verifiable();
var ratesSourceProvider = new Mock <IRatesSourceProvider>();
ratesSourceProvider.Setup(o => o.GetRatesAsync(It.IsAny <string>()))
.Returns(Task.FromResult(list));
var service = new RatesService(ratesSourceProvider.Object, ratesStorageService.Object, 10);
var rates = service.GetRates("USD", "RUB").Result;
Assert.IsNotEmpty(rates);
ratesStorageService.Verify();
}
public string GetFilteredApartments()
{
var data = new List <Rate>();
var service_item = new RatesService();
rates = service_item.rates();
data = service_item.filter_list_visitor(rates, apartments_info_model);
var str = JsonConvert.SerializeObject(data);
return(str);
}
public string GetApartments()
{
var data = new List <Rate>();
try
{
var service_item = new RatesService();
var rates_list = new RatesList(service_item);
data = rates_list.rates;
rates = data;
}
catch (Exception ex)
{
}
var str = JsonConvert.SerializeObject(data);
return(str);
}
public async Task AlreadyRatedTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Ratings.Add(new Rating
{
ProductId = 1,
UserId = "Test",
});
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Rating>(dbContext);
var service = new RatesService(repository);
Assert.True(service.AlreadyRated("Test", 1));
Assert.False(service.AlreadyRated("Wrong", 1));
}
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));
}
public async Task AddRateAsyncTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Rating>(dbContext);
var service = new RatesService(repository);
var newRating = new RateViewModel
{
Description = "Test",
Grade = (int)Grade.VeryGood,
ProductId = 1,
UserId = "Test",
};
await service.AddRateAsync(newRating);
}
public void Initialize()
{
var memoryService = new PhoneMemoryService();
var iconsService = new IconsService();
var statisticsManager = new StatisticsManager();
var options = new Options(memoryService);
var dataContext = new DataContext(memoryService);
var skyDriveFileManager = new SkyDriveFileManager(memoryService);
var skyDriveService = new SkyDriveService(dataContext, skyDriveFileManager);
var csvDataExportService = new CsvDataExportService(memoryService);
var cashService = new CashService(dataContext);
var tileService = new TileService(dataContext);
var categoryUsageService = new CategoryUsageService(dataContext.Operations);
var dependenciesService = new DependenciesService(dataContext, iconsService);
var defaultCategoriesInitializer = new DefaultCategoriesInitializer(dataContext, iconsService);
var accountInitializer = new AccountsInitializer(dataContext);
var ratesHtmlParser = new RatesHtmlParser();
var ratesWebClient = new RatesWebClient();
var ratesService = new RatesService(memoryService, ratesHtmlParser, ratesWebClient);
var depositCalculator = new DepositCalculator();
var creaditCalculator = new CreditCalculator();
_container.RegisterInstance <IPhoneMemoryService>(memoryService);
_container.RegisterInstance <IIconsService>(iconsService);
_container.RegisterInstance <IStatisticsManager>(statisticsManager);
_container.RegisterInstance <Options>(options);
_container.RegisterInstance <IDataContext>(dataContext);
_container.RegisterInstance <ISkyDriveService>(skyDriveService);
_container.RegisterInstance <IDataExportService>(csvDataExportService);
_container.RegisterInstance <ICashService>(cashService);
_container.RegisterInstance <IRatesService>(ratesService);
_container.RegisterInstance <DepositCalculator>(depositCalculator);
_container.RegisterInstance <CreditCalculator>(creaditCalculator);
}
public async Task GetAsync()
{
//Arrange
IEnumerable <Rates> rates = MockRates.GetRates();
var mockRatesRepository = new Mock <IRepository <Rates> >();
mockRatesRepository.Setup(p => p.GetAsync()).Returns(Task.FromResult(rates));
RatesService ratesService = new RatesService(mockRatesRepository.Object, null);
//Act
var ratesDTOs = await ratesService.GetAsync().ConfigureAwait(false);
//Assert
Assert.Equal(expected: rates.Count(), actual: ratesDTOs.Count());
for (int i = 0; i < rates.Count(); i++)
{
Assert.Equal(expected: rates.ElementAt(i).From, actual: ratesDTOs.ElementAt(i).From);
Assert.Equal(expected: rates.ElementAt(i).To, actual: ratesDTOs.ElementAt(i).To);
Assert.Equal(expected: rates.ElementAt(i).Rate, actual: ratesDTOs.ElementAt(i).Rate);
}
}
public void GetRates_ДанныеЕстьВБД_ВозвращаетсяРезультат()
{
var list = new List <ExpiredRateInfo>()
{
new ExpiredRateInfo()
{
To = "RUB",
Rate = 10,
ExpireAt = DateTime.Today
}
};
var ratesSourceProvider = Mock.Of <IRatesSourceProvider>();
var ratesStorageService = new Mock <IRatesStorageService>();
ratesStorageService.Setup(o => o.GetRates(It.IsAny <string>(), It.IsAny <string>()))
.Returns(list);
var service = new RatesService(ratesSourceProvider, ratesStorageService.Object, 10);
var rates = service.GetRates("from", "to").Result;
CollectionAssert.AreEqual(list, rates);
}
public async Task <IActionResult> GetAsync(string currencyCode, DateTime?date = null)
{
DateTime effectiveDate = DateTime.Now.Date;
if (date.HasValue)
{
effectiveDate = date.Value.Date;
}
if (!await RatesService.IsValidCurrencyToQuoteAsync(currencyCode))
{
return(BadRequest("Currency not valid"));
}
CurrencyQuoteModel currencyQuote = await RatesService.GetRateQuoteAsync(currencyCode, effectiveDate);
if (currencyQuote == null)
{
return(NotFound($"No quote found for {currencyCode} on {effectiveDate}"));
}
return(Ok(currencyQuote));
}
protected override async Task OnParametersSetAsync()
{
switch (Page)
{
case null:
case "lights":
if (Lights is null)
{
Lights = await LightService.GetAllAsync();
}
break;
case "heats":
if (Heats is null)
{
Heats = await HeatService.GetAllAsync();
}
break;
case "courts":
if (Courts is null)
{
Courts = await CourtService.GetAllAsync();
}
break;
case "rates":
if (Rates is null)
{
Rates = await RatesService.GetAllAsync();
}
break;
default:
throw new KeyNotFoundException("Dashboard nested page not found!");
}
}
public IHttpActionResult DeleteRateController(int id)
{
RatesService.DeleteRate(id);
return(Ok());
}
public IHttpActionResult PutRatesController([FromBody] CORE.Model.Rates rate)
{
RatesService.PutRates(rate);
return(Ok());
}
public IHttpActionResult PostRatesController(CORE.Model.Rates rate)
{
RatesService.PostRates(rate);
return(Ok());
}
public object GetAllRatesController()
{
return(Ok(RatesService.GetAllRates()));
}
public RatesController(RatesService service)
{
Service = service;
}
public async Task <IActionResult> GetLatestQuotesAsync(DateTime?date = null)
{
return(Ok(await RatesService.GetLatestRatesAsync(date: date)));
}
