/// <summary> /// Create Db context with connection string /// </summary> /// <param name="settings"></param> public DbContextFactory(IOptions <DbContextSettings> settings) { var options = new DbContextOptionsBuilder <WeatherDbContext>().UseSqlServer (settings.Value.DbConnectionString).Options; DbContext = new WeatherDbContext(options); }
public ActionResult <List <CityCode> > list() { using (WeatherDbContext context = new WeatherDbContext()) { return(context.Set <CityCode>().ToList()); } }
public ServiceUser(UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, IConfiguration config, WeatherDbContext context) { _userManager = userManager; _singInManager = signInManager; _config = config; _context = context; }
public DailyNormalService_GetDailyNormal() { WeatherDbContext context = null; // mock this value IAsyncRepository <DailyNormal> repository = new DailyNormalRepository(context); this._dailyNormalService = new DailyNormalService(repository); }
public async Task FetchAndSyncWeather_StoresNewDataInCache_WhenNoneExistsInCache() { // Expire cache data, by making it older than 4 hours var weatherDto = FakerT <WeatherDto> .Generate(); weatherDto.LocaleId = 3; var mockWeatherApi = new Mock <IWeatherApi>(); mockWeatherApi.Setup(api => api.GetWeatherForLocation(3)).Returns(Task.FromResult(TestDataGenerator.LocationWeather(3))); var option = new DbContextOptionsBuilder <WeatherDbContext>().UseInMemoryDatabase("WeatherInMemoryDatabase").Options; var dbContext = new WeatherDbContext(option); var repository = new WeatherRepository(dbContext); // Act var sut = new FetchManager.FetchManager(mockWeatherApi.Object, repository, new OpenWeatherSettings() { CacheExpiryMinutes = 180 }); var result = (await sut.FetchAndSyncWeatherForLocationAsync(3)).FirstOrDefault(); // Assert Assert.Equal(3, result.LocaleId); var insertedObject = await repository.GetWeatherById(3); Assert.Equal(3, insertedObject.Count); }
public async Task StartAsync(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { using (var scope = serviceScopeFactory.CreateScope()) { weatherContext = scope.ServiceProvider.GetService <WeatherDbContext>(); ICollection <Task <WeatherData> > cityTasks = new List <Task <WeatherData> >(); foreach (var city in cities) { cityTasks.Add(new WeatherClient().GetCity(city)); } var taskResult = await Task.WhenAll(cityTasks.AsEnumerable()); foreach (var cityWeatherData in taskResult) { weatherContext.WeatherData.Add(cityWeatherData); } await weatherContext.SaveChangesAsync(cancellationToken); _iLogger.LogInformation($"Downloaded weather data for cities ${string.Join(",", cities)} "); await Task.Delay(delayMilliseconds, cancellationToken); } } }
/// <summary> /// Get a list of all sources of data /// </summary> /// <returns>A list of tuples with id of source first, and its name second</returns> public async Task <IReadOnlyCollection <DataSource> > GetAllAsync() { using (var db = new WeatherDbContext(_dbOptions)) { return(await db.DataSources.ToListAsync()); } }
public async Task Test_GetWeatherForecastsAsync_Returns_Weather() { Db.Recreate(); var now = DateTime.UtcNow; using (WeatherDbContext ctx = Db.GetAdminContext()) { ctx.Set <WeatherForecastEntity>() .AddRange(new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now, Summary = "sum-1", TemperatureC = 1 }, new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now.AddDays(-1), Summary = "sum-2", TemperatureC = 1 }); await ctx.SaveChangesAsync(); } IWeatherForecastClient client = Integration.CreateClient(); WeatherForecastGetModel[] models = await client.GetWeatherForecasts(CancellationToken.None); Assert.AreEqual(2, models.Length); Assert.AreEqual("sum-1", models[0].Summary); Assert.AreEqual("sum-2", models[1].Summary); }
public ActionResult <CityCode> queryByAdcode(string adcode) { using (WeatherDbContext context = new WeatherDbContext()) { CityCode city = (from c in context.CityCode where c.ad_code == adcode select c).FirstOrDefault(); return(city); } }
public ActionResult <CityCode> queryByName(string cityname) { using (WeatherDbContext context = new WeatherDbContext()) { CityCode city = (from c in context.CityCode where c.city_CN == cityname select c).FirstOrDefault(); return(city); } }
public async Task <IReadOnlyCollection <AggregatedMeasurement> > GetAggregationsAsync(DateTime start, DateTime?end = null) { using (var db = new WeatherDbContext(_dbOptions)) { return(await db.AggregatedMeasurements .Where(x => x.Day.Date >= start.Date && (end != null ? x.Day.Date < end.Value.Date : true) ) .ToListAsync()); } }
private void GivenADatabase(string context) { _contextOptions = MockDatabaseHelper.CreateNewContextOptions(context); _appContext = new WeatherDbContext(_contextOptions); _settings = Substitute.For <IOptions <DbContextSettings> >(); _settings.Value.Returns(new DbContextSettings { DbConnectionString = "test" }); _dbContextFactory = Substitute.For <IDbContextFactory>(); _dbContextFactory.DbContext.Returns(_appContext); _subject = new CityRepository(_dbContextFactory, Substitute.For <ILogger>()); }
public async Task Test_GetForecastsAsync_Returns_Correct_Results() { Db.Recreate(); var now = DateTime.UtcNow; using (WeatherDbContext ctx = Db.GetAdminContext()) { ctx.Set <WeatherForecastEntity>() .AddRange(new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now, Summary = "sum-1", TemperatureC = 1 }, new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now.AddDays(-1), Summary = "sum-2", TemperatureC = 1 }, new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now.AddDays(-30), Summary = "sum-3", TemperatureC = 1 }, new WeatherForecastEntity { Id = Guid.NewGuid(), Date = now.AddDays(-31), Summary = "sum-4", TemperatureC = 1 }); await ctx.SaveChangesAsync(); } using var mock = Mock.Auto(); mock.Mock <IDateTimeService>().Setup(p => p.Now()).Returns(now); var service = mock.Create <WeatherForecastServiceImpl>(); WeatherForecastEntity[] entities = await service.GetWeatherForecastsAsync(CancellationToken.None); Assert.AreEqual(3, entities.Length); }
protected override void Seed(WeatherWidget.Models.WeatherDbContext context) { var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context)); var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context)); // Create admin role if not already in database if (!roleManager.RoleExists("Administrator")) { var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole(); role.Name = "Administrator"; roleManager.Create(role); var user = new ApplicationUser(); user.UserName = "******"; user.Email = "*****@*****.**"; string userPassword = "******"; var chkUser = UserManager.Create(user, userPassword); //Add default User to Role Admin if (chkUser.Succeeded) { var result1 = UserManager.AddToRole(user.Id, "Administrator"); } } context.SaveChanges(); // Seed database with current weather information // Get current data for each zip code from weather API and // save it to the DB List <string> zips = new List <string>() { "30909", "30907", "30809" }; WeatherDbContext db = new WeatherDbContext(); foreach (string zip in zips) { Weather weather = Weather.GetWeatherForZip(zip); db.Weather.Add(weather); db.SaveChanges(); } }
public async Task <ActionResult> Index(string zipCode) { Weather weather = null; if (ModelState.IsValid) { if (Weather.ValidateZip(zipCode)) { try { zipCode = zipCode.ToLower().Trim(); int zip; Weather.GetWeatherForZip(zipCode); // We know zip will parse because of ValidateZip() int.TryParse(zipCode, out zip); // Get weather data for the given zip code using (WeatherDbContext db = new WeatherDbContext()) { // Find weather with zip code using parameters string query = "SELECT * FROM Weathers WHERE ZipCode = @zipCode"; SqlParameter zipParameter = new SqlParameter("@zipCode", zip); weather = await db.Database.SqlQuery <Weather>(query, zipParameter).FirstOrDefaultAsync(); } if (weather == null) { ViewBag.ZipNotFound = "Sorry, we do not have weather information for that zip code."; } } catch (Exception ex) { // log exception } } else { ViewBag.ZipNotFound = "Sorry, we do not have weather information for that zip code."; } } else { ModelState.AddModelError("zipCode", "Invalid zip code."); } return(View(weather)); }
public async Task<bool> FetchTemperaturesAsync() { using (var db = new WeatherDbContext(_dbOptions)) { try { var temperatures = new List<Measurement>(); temperatures.AddRange(await FetchWeatherForecastAsync()); var hueTemps = await FetchPhilipsHueSensorsAsync(); // Only update newer readings if (hueTemps != null) { foreach(var hueTemp in hueTemps) { var lastMeasurement = db.Measurements.Where(y => hueTemp.SourceId == y.SourceId).OrderByDescending(y => y.Timestamp).Take(1).FirstOrDefault(); if(lastMeasurement == null || hueTemp.Timestamp > lastMeasurement.Timestamp) { temperatures.Add(hueTemp); } } } var piTemps = FetchRaspberryPi(); // Seems not working in Async mode if (piTemps != null) { temperatures.AddRange(piTemps); } _logger.LogInformation($"Amount of temperatures: {temperatures.Count()}"); if (temperatures.Count > 0) { db.Measurements.AddRange(temperatures); return db.SaveChanges() > 0; } } catch (Exception e) { _logger.LogError(e, $"Exception occured {e.Message}"); } return false; } }
public async Task <WeatherForecastEntity[]> GetWeatherForecastsAsync(CancellationToken ct) { _logger.LogDebug("Retrieving weather forecast items from the database"); using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }, TransactionScopeAsyncFlowOption.Enabled); using WeatherDbContext ctx = _dbContextFactory.GetWeatherDbContext(); WeatherForecastEntity[] entities = await ctx.Set <WeatherForecastEntity>() .Where(p => p.Date >= _dateTimeService.Now().AddDays(-30)) .OrderByDescending(p => p.Date) .ToArrayAsync(ct); scope.Complete(); _logger.LogDebug("Retrieved the items: {0}", entities.Length); return(entities); }
public void Test_Mapping_Functional() { Db.Recreate(); using WeatherDbContext ctx1 = Db.GetAppContext(); var entity = new WeatherForecastEntity { Id = Guid.NewGuid(), Date = DateTime.UtcNow, Summary = "some summary", TemperatureC = 10 }; ctx1.Set <WeatherForecastEntity>().Add(entity); ctx1.SaveChanges(); using WeatherDbContext ctx2 = Db.GetAppContext(); WeatherForecastEntity saved = ctx2.Set <WeatherForecastEntity>().Find(entity.Id); Assert.NotNull(saved); Assert.AreEqual(entity.Date, saved.Date); Assert.AreEqual(entity.Summary, saved.Summary); Assert.AreEqual(entity.TemperatureC, saved.TemperatureC); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, IOptionsMonitor <RabbitConfiguration> rabbitConfigurationOptions, WeatherDbContext dbContext) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } dbContext.Database.Migrate(); app.UseSwagger(); app.UseSwaggerUi3(); app.UseMvc(); }
public TemperatureController(WeatherDbContext weatherDbContext, ILogger <TemperatureController> logger, SignInManager <IdentityUser> signInManager) { _weatherDbContext = weatherDbContext; _logger = logger; }
public void Run() { using WeatherDbContext ctx = _dbContextFactory.GetWeatherDbContext(); ctx.Database.Migrate(); }
public async Task <ReadoutResponse> GetReadoutsAsync(DateTime?customSince = null) { var since = ChartConfiguration.RealTime.Labels.First().Start; if (customSince != null) { since = customSince.Value; } using (var db = new WeatherDbContext(_dbOptions)) { var sources = await db.DataSources.ToListAsync(); var measurements = await db.Measurements.Where(x => x.Timestamp > since).ToListAsync(); var readouts = new List <IReadOut>(); var labels = ChartConfiguration.RealTime.Labels.ToList(); if (customSince != null) { // we will only fetch the data for the last "frame", other data already exists in the frontend labels = labels.Where(x => customSince.Value > x.Start).TakeLast(1).ToList(); } // Have some fallback values, so we can draw continuous chart lines var lastNonNullTemperatures = new Dictionary <int, int?>(); foreach (var source in sources) { var lastMeasuredTemperature = await db.Measurements .Where(x => x.SourceId == source.Id) .OrderByDescending(x => x.Timestamp) .Take(1) .FirstOrDefaultAsync(); lastNonNullTemperatures.Add(source.Id, lastMeasuredTemperature?.Temperature); } foreach (var chartLabel in labels) { var medianTemperatures = new Dictionary <int, IEnumerable <double> >(); foreach (var source in sources) { var medianTemperature = measurements .Where(x => x.SourceId == source.Id && x.Timestamp >= chartLabel.Start && x.Timestamp < chartLabel.Start.AddMilliseconds(chartLabel.Span.TotalMilliseconds) ) .Select(x => (double)x.Temperature); medianTemperatures.Add(source.Id, medianTemperature); } if (medianTemperatures.Where(x => x.Value.Count() == 0).Count() == sources.Count()) { // If all measureents for all sensors were empty, skip this frame. continue; } foreach (var medianTemperature in medianTemperatures) { bool stale = true; if (medianTemperature.Value != null && medianTemperature.Value.Count() > 0) { lastNonNullTemperatures[medianTemperature.Key] = (int?)Math.Round(medianTemperature.Value.Median() * 100) / 100; stale = false; } readouts.Add(new ReadOut { SourceId = medianTemperature.Key, Temperature = lastNonNullTemperatures[medianTemperature.Key], Stale = stale }); } } return(new ReadoutResponse { Readouts = readouts, Timestamp = DateTime.Now }); } }
public WeatherService(WeatherDbContext weatherDb, ILogger <WeatherService> logger) { this.logger = logger; this.weatherDb = weatherDb; }
public AccountController(WeatherDbContext dbContext) { this.dbContext = dbContext; }
public LabelRepository(WeatherDbContext dbContext) { _dbContext = dbContext; }
public async Task Execute(IJobExecutionContext context) { if (Convert.ToBoolean(WebConfigurationManager.AppSettings["ESPScheduler"])) { try { using (var weatherDbcontext = new WeatherDbContext()) { Logging logging = new Logging(); logging.WriteLog(new string[] { "start insert job" }); ESPData espdata = new ESPData(); string URL = WebConfigurationManager.AppSettings["ESP8266url"]; espdata = await espdata.GetAsync(new Uri(URL)); weatherDbcontext.Weather.Add(new Weather { DATETIME = DateTime.Now, VAL1 = espdata.variables.T_OUT, VAL2 = espdata.variables.T_IN, HUMIDITY = espdata.variables.Humidity }); try { await weatherDbcontext.SaveChangesAsync(); logging.WriteLog(new string[] { "Successfull insert!", "insert at " + DateTime.Now.ToString(), "T_OUT = " + espdata.variables.T_OUT, "T_IN = " + espdata.variables.T_IN, "HUMIDITY = " + espdata.variables.Humidity }); } catch (Exception ex) { logging.WriteLog(new string[] { "error while SaveChangesAsync()", "ESPDataSender.cs " + ex.Message + " ### " + ex.InnerException }); await Execute(context); } } } catch (Exception ex) { Logging logging = new Logging(); logging.WriteLog(new string[] { "error while inserting!", "ESPDataSender.cs " + ex.Message + " ### " + ex.InnerException }); await Execute(context); } } }
public CitiesController(WeatherDbContext weatherDbContext, ILogger <CitiesController> logger) { _weatherDbContext = weatherDbContext; _logger = logger; }
public RecordRepository(WeatherDbContext context) { _context = context; }
public WeatherController(WeatherDbContext weatherDbContext) { _weatherDbContext = weatherDbContext; }
public EnviornmentsController(WeatherDbContext context) { _context = context; }