public async void WeatherStationController_GetLastThreeTemps_ReturnsNotFound()
{
_context.Database.EnsureCreated();
List <WeatherObservation> weatherObservations = new List <WeatherObservation>();
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 25;
weatherObservations.Add(wo1);
WeatherObservation wo2 = new WeatherObservation();
wo2.Temperature = 15;
weatherObservations.Add(wo2);
foreach (var weatherObservation in weatherObservations)
{
_context.WeatherObservations.Add(weatherObservation);
}
_context.SaveChanges();
var list = await _uut.GetLastThreeTemps();
Assert.IsType <NotFoundResult>(list.Result);
_context.Database.EnsureDeleted();
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
var obsTime = DateTime.Now;
double elapsedSinceReading = (obsTime - this.startTime).TotalSeconds;
int count = this.countSinceLastRead;
this.countSinceLastRead = 0;
this.LogMessage($"Elapsed: {elapsedSinceReading}");
this.LogMessage($"Tick Count: {count}");
double average = this.CalculateSpeed(count, elapsedSinceReading);
sensorResult.AddFinalObservation(this.maxGust, "WIND_GUST", ObservationUnits.KmPerHour);
sensorResult.AddFinalObservation(average, "WIND_AVERAGE", ObservationUnits.KmPerHour);
observation.WindAverage = average;
observation.WindGust = this.maxGust != -1 ? this.maxGust : average;
this.startTime = obsTime;
this.gustCount = 0;
this.maxGust = -1;
this.LogTakeReadingComplete();
return(sensorResult);
}
public async void WeatherStationController_GetLastThreeTemps_CorrectTemprature()
{
_context.Database.EnsureCreated();
List <WeatherObservation> weatherObservations = new List <WeatherObservation>();
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 25;
weatherObservations.Add(wo1);
WeatherObservation wo2 = new WeatherObservation();
wo2.Temperature = 15;
weatherObservations.Add(wo2);
WeatherObservation wo3 = new WeatherObservation();
wo3.Temperature = 35;
weatherObservations.Add(wo3);
foreach (var weatherObservation in weatherObservations)
{
_context.WeatherObservations.Add(weatherObservation);
}
_context.SaveChanges();
var list = await _uut.GetLastThreeTemps();
Assert.Equal(25, list.Value.ElementAt(0).Temperature);
Assert.Equal(3, list.Value.Count);
_context.Database.EnsureDeleted();
}
public async void WeatherStationController_Post()
{
_context.Database.EnsureCreated();
DateTime date1 = new DateTime(2021, 5, 15);
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 2;
wo1.Humidity = 50;
wo1.AirPressure = 30;
wo1.Date = date1;
wo1.Station = new Station();
wo1.Station.Name = "";
wo1.Station.Lat = 10;
wo1.Station.Lon = 10;
await _uut.Post(wo1);
var list = await _uut.GetTempByDate(date1);
Assert.Equal(2, list.Value.ElementAt(0).Temperature);
_context.Database.EnsureDeleted();
}
public ActionResult <List <WeatherObservation> > DateGet(string date)
{
List <WeatherObservation> newList = new List <WeatherObservation>();
foreach (var foundDate in _context.WeatherObservations)
{
if (foundDate.TimeOfDay.Date == DateTime.Parse(date))
{
var WO = new WeatherObservation()
{
Temperature = foundDate.Temperature,
AirPressure = foundDate.AirPressure,
AirHumidity = foundDate.AirHumidity,
TimeOfDay = foundDate.TimeOfDay,
WeatherObservationId = foundDate.WeatherObservationId,
LocationName = foundDate.LocationName
};
newList.Add(WO);
}
}
if (newList.Count == 0)
{
return(NotFound());
}
return(newList);
}
public async Task <ActionResult <WeatherObservation> > UploadWeatherObservation(DTOWeatherObservation DtoweatherObs)
{
var weather = new WeatherObservation()
{
TimeOfDay = DtoweatherObs.TimeOfDay,
Temperature = DtoweatherObs.Temperature,
AirPressure = DtoweatherObs.AirPressure,
AirHumidity = DtoweatherObs.AirHumidity,
LocationName = DtoweatherObs.LocationName,
LocationRefId = DtoweatherObs.LocationRefId
};
_context.WeatherObservations.Add(weather);
await _context.SaveChangesAsync();
string weatherObservationFormatted = "Weatherobservation\n" +
$"Time: {DtoweatherObs.TimeOfDay.ToLongTimeString()}\n" +
$"Location: {DtoweatherObs.LocationName}\n" +
$"Temperature: {DtoweatherObs.Temperature}\n" +
$"Humidity: {DtoweatherObs.AirHumidity}\n" +
$"Pressure: {DtoweatherObs.AirPressure}";
await _hub.Clients.All.SendAsync("NewPost", weatherObservationFormatted);
return(Created(weather.WeatherObservationId.ToString(), weather));
}
public async Task <ActionResult <WeatherObservation> > PostWeatherObservation(DtoWeatherObservation dtoWeatherObservation)
{
var place = _context.Places.FirstOrDefault(p =>
p.Latitude == dtoWeatherObservation.Latitude && p.Longitude == dtoWeatherObservation.Longitude);
if (place == null)
{
place = _context.Places.Add(new Place()
{
Name = dtoWeatherObservation.Name,
Latitude = dtoWeatherObservation.Latitude,
Longitude = dtoWeatherObservation.Longitude
}).Entity;
await _context.SaveChangesAsync();
}
var weatherObservation = new WeatherObservation()
{
Date = dtoWeatherObservation.Date,
Humidity = dtoWeatherObservation.Humidity,
Temperature = dtoWeatherObservation.Temperature,
Pressure = dtoWeatherObservation.Pressure,
PlaceId = place.Id
};
_context.Observations.Add(weatherObservation);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWeatherObservation", new { id = weatherObservation.Id }, weatherObservation));
}
public ActionResult <List <WeatherObservation> > BetweenDateGet(string date1, string date2)
{
List <WeatherObservation> newList = new List <WeatherObservation>();
foreach (var wo in _context.WeatherObservations)
{
var dateFound = wo.TimeOfDay.Date;
if ((DateTime.Compare(dateFound, DateTime.Parse(date1)) >= 0) && (DateTime.Compare(dateFound, DateTime.Parse(date2)) <= 0))
{
var WeatherObs = new WeatherObservation
{
Temperature = wo.Temperature,
AirPressure = wo.AirPressure,
AirHumidity = wo.AirHumidity,
TimeOfDay = wo.TimeOfDay,
WeatherObservationId = wo.WeatherObservationId,
LocationName = wo.LocationName
};
newList.Add(WeatherObs);
}
}
if (newList.Count == 0)
{
return(NotFound());
}
return(newList);
}
public async Task <IActionResult> PutWeatherObservation(int id, WeatherObservation weatherObservation)
{
if (id != weatherObservation.WeatherObservationId)
{
return(BadRequest());
}
_context.Entry(weatherObservation).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WeatherObservationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void setValues(WeatherResult response)
{
if (response.weatherObservation != null)
{
observation = response.weatherObservation;
}
else
{
observation = new WeatherObservation
{
stationName = "NotFound",
};
}
//if (response != null)
//{
// this.Elevation = response.weatherObservation.elevation;
// this.Humidity = response.weatherObservation.humidity;
// this.Temperature = response.weatherObservation.temperature;
// this.StationName = response.weatherObservation.stationName;
//}
//else
//{
// Elevation = default(long);
// Humidity = default(long);
// Temperature = default(long);
// StationName = default(string);
//}
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var result = new SensorSample(this.SensorName);
var lines = File.ReadAllLines(this.pathForW1);
int i = 0;
bool success = false;
while (!success && i++ < 3)
{
success = lines[0].Contains("YES");
if (success)
{
var rawTemp = lines[1].Split('=').Last();
var temp = float.Parse(rawTemp) / 1000.0f;
result.AddFinalObservation(temp, "TEMPERATURE2", ObservationUnits.DegreesCelcius);
result.AddDiagnostic(lines[0]);
result.AddDiagnostic(lines[1]);
observation.Temperature2 = temp;
}
}
this.LogTakeReadingComplete();
return(result);
}
public async Task <ActionResult <WeatherObservation> > Post(WeatherObservation temperature)
{
if (temperature == null)
{
return(BadRequest());
}
var newTemp = (new WeatherObservation()
{
Date = temperature.Date,
Station = new Station()
{
Name = temperature.Station.Name,
Lat = temperature.Station.Lat,
Lon = temperature.Station.Lon
},
Temperature = Math.Round(temperature.Temperature, 1),
Humidity = CheckHumidity(temperature.Humidity),
AirPressure = Math.Round(temperature.AirPressure, 1),
});
_context.Add(newTemp);
_context.SaveChanges();
string json = JsonSerializer.Serialize(temperature);
if (_hubContext != null)
{
await _hubContext.Clients.All.SendAsync("ReceiveMessage", json);
}
return(CreatedAtAction("GetLastThreeTemps", new { id = newTemp.WeatherObservationId }, newTemp));
}
public void TestWeatherObservation()
{
var stationId = Guid.NewGuid();
var weatherObservation = new WeatherObservation {
WeatherStationId = stationId, DegreesCelcius = 15.3, Humidity = 72.3, ObservationDateTime = DateTime.Now
};
}
public void Test_010_ParseLine()
{
var text = "2012_01_01 00:02:14 34.30 30.50 26.90 74.20 346.40 11.00 3.60";
var wo = WeatherObservation.Parse(text);
Check.That(wo.TimeStamp).IsEqualTo(new DateTime(2012, 01, 01, 00, 02, 14)); //This is a check from the NFluent library, just another unit testing library
Check.That(wo.Barometric_Pressure).IsCloseTo(30.5, 0.01);
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
var result = this.sensor.Read();
if (result.Humidity.HasValue && result.Pressure.HasValue && result.Temperature.HasValue)
{
var pressure = result.Pressure.Value;
var temperature = new Temperature(result.Temperature.Value.DegreesCelsius + this.calibrationOffset, UnitsNet.Units.TemperatureUnit.DegreeCelsius);
var rawTemperature = result.Temperature.Value;
var humidity = result.Humidity.Value;
var actualAltitude = new Length(this.altitudeInMeters, UnitsNet.Units.LengthUnit.Meter);
var calculatedAltitude = WeatherHelper.CalculateAltitude(pressure, WeatherHelper.MeanSeaLevel, rawTemperature);
double absHumidity = WeatherHelper.CalculateAbsoluteHumidity(temperature, humidity).GramsPerCubicMeter;
double dewPoint = WeatherHelper.CalculateDewPoint(temperature, humidity).DegreesCelsius;
double heatIndex = WeatherHelper.CalculateHeatIndex(temperature, humidity).DegreesCelsius;
double vapourPressure = WeatherHelper.CalculateActualVaporPressure(temperature, humidity).Hectopascals;
double barometricPressure = WeatherHelper.CalculateBarometricPressure(pressure, temperature, actualAltitude, humidity).Hectopascals;
double vapourPressureOverIce = WeatherHelper.CalculateSaturatedVaporPressureOverIce(temperature).Hectopascals;
double vapourPressureOverWater = WeatherHelper.CalculateSaturatedVaporPressureOverWater(temperature).Hectopascals;
double seaLevelPressure = WeatherHelper.CalculateSeaLevelPressure(pressure, actualAltitude, temperature).Hectopascals;
sensorResult.AddFinalObservation(temperature.DegreesCelsius, "TEMPERATURE", ObservationUnits.DegreesCelcius);
sensorResult.AddFinalObservation(pressure.Hectopascals, "PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(barometricPressure, "BAROMETRIC PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(seaLevelPressure, "SEA LEVEL PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(vapourPressureOverIce, "OVER ICE PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(vapourPressureOverWater, "OVER WATER PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(humidity.Percent, "RELATIVE HUMIDITY", ObservationUnits.Percentage);
sensorResult.AddFinalObservation(absHumidity, "ABSOLUTE HUMIDITY", ObservationUnits.GramsPerCubicMeter);
sensorResult.AddFinalObservation(vapourPressure, "VAPOUR PRESSURE", ObservationUnits.HectoPascal);
sensorResult.AddFinalObservation(calculatedAltitude.Meters, "CALCULATED ALTITUDE", ObservationUnits.Meters);
sensorResult.AddFinalObservation(actualAltitude.Meters, "ACTUAL ALTITUDE", ObservationUnits.Meters);
sensorResult.AddFinalObservation(heatIndex, "HEAT INDEX", ObservationUnits.DegreesCelcius);
sensorResult.AddFinalObservation(dewPoint, "DEW POINT", ObservationUnits.DegreesCelcius);
observation.Temperature1 = temperature.DegreesCelsius;
observation.Pressure = pressure.Hectopascals;
observation.BarometricPressure = barometricPressure;
observation.SealevelPressure = seaLevelPressure;
observation.OverIcePressure = vapourPressureOverIce;
observation.OverWaterPressure = vapourPressureOverWater;
observation.RelativeHumidity = humidity.Percent;
observation.AbsoluteHumidity = absHumidity;
observation.ActualAltitude = actualAltitude.Meters;
observation.CalculatedAltitude = calculatedAltitude.Meters;
observation.HeatIndex = heatIndex;
observation.DewPoint = dewPoint;
}
this.LogTakeReadingComplete();
return(sensorResult);
}
public void Test_020_TryParseLine()
{
var text = "2012_01_01 00:02:14 34.30 30.50 26.90 74.20 346.40 11.00 3.60";
var tryParseOutcome = WeatherObservation.TryParse(text, out WeatherObservation wo);
Check.That(tryParseOutcome).IsTrue();
Check.That(wo.TimeStamp).IsEqualTo(new DateTime(2012, 01, 01, 00, 02, 14));
Check.That(wo.Barometric_Pressure).IsCloseTo(30.5, 0.01);
}
public InitOnlyClass()
{
var now = new WeatherObservation
{
RecordedAt = DateTime.Now,
TemperatureInCelsius = 20,
PressureInMillibars = 998.0m
};
now.TemperatureInCelsius = 18;
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
int count = this.tipCount.GetAndReset();
this.LogMessage($"rain:tick: {count}");
sensorResult.AddFinalObservation(count * BUCKETSIZE, "PRECIPITATION", ObservationUnits.Millimeter);
observation.Precipitation = count * BUCKETSIZE;
this.LogTakeReadingComplete();
return(sensorResult);
}
public async Task Test()
{
if (this.NestClient != null)
{
StreamWriter file = new StreamWriter($"data.tab", true);
file.WriteLine(string.Join("\t", NestThermostatMeasurementEvent.GetHeader()));
while (true)
{
try
{
Logger.WriteLine("querying thermostat");
List <NestThermostatMeasurementEvent> events = await this.NestClient.Measure();
foreach (var e in events)
{
file.WriteLine(string.Join("\t", e.GetStringValues()));
await this.Storage.AddThermostatEvent(e);
}
file.Flush();
Logger.WriteLine(JsonConvert.SerializeObject(events, Formatting.Indented));
}
catch (Exception e)
{
Logger.WriteLine(e);
}
try
{
Logger.WriteLine("querying weather");
WeatherObservation weather = await this.WeatherGovClient.GetCurrentWeather();
await this.Storage.AddWeatherObservation(weather);
Logger.WriteLine(JsonConvert.SerializeObject(weather, Formatting.Indented));
}
catch (Exception e)
{
Logger.WriteLine(e);
}
Logger.WriteLine("sleeping");
await Task.Delay(60 * 1000);
}
}
}
public async Task <ActionResult> Post(WeatherObservationDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var weatherObservation = new WeatherObservation
{
Date = dto.Date,
TemperatureC = dto.TemperatureC,
Summary = dto.Summary
};
await _weatherRepository.Add(weatherObservation);
return(Ok());
}
public async Task PostWeatherObservationAddsToDb()
{
using (var context = new ApplicationContext(_options))
{
context.Database.EnsureCreated();
int initial = context.WeatherObservations.ToList().Count;
WeatherObservationsController uut = new WeatherObservationsController(context, _hubContext);
WeatherObservation entry = new WeatherObservation()
{
LocationName = "Poland",
Temperature = 120
};
await uut.PostWeatherObservation(entry);
Assert.Equal(initial + 1, context.WeatherObservations.ToList().Count);
}
}
public async Task <ActionResult> CreateEntity([FromBody] WeatherObservationRequest request)
{
var observation = new WeatherObservation
{
Date = request.Date,
Name = request.Name,
Latitude = request.Latitude,
Longitude = request.Longitude,
TemperatureCelsius = request.TemperatureCelsius,
Humidity_Percentage = request.Humidity_Percentage,
Pressure_Millibar = request.Pressure_Millibar
};
var createdObservation = await _repository.Create(observation);
await _liveUpdateHub.Clients.All.SendAsync("newObservation", createdObservation);
return(Created(createdObservation.Id.ToString(), createdObservation));
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
lock (this.syncroot)
{
sensorResult.AddFinalObservation(this.uvacalc, "UVA", ObservationUnits.Default);
sensorResult.AddFinalObservation(this.uvbcalc, "UVB", ObservationUnits.Default);
sensorResult.AddFinalObservation(this.uvicalc, "UVI", ObservationUnits.Default);
observation.UvA = this.uvacalc;
observation.UvB = this.uvbcalc;
observation.UvI = this.uvicalc;
}
this.LogTakeReadingComplete();
return(sensorResult);
}
public async void WeatherStationController_GetTempByStartAndEndTime_Found2Observation()
{
_context.Database.EnsureCreated();
DateTime date1 = new DateTime(2021, 5, 15);
DateTime date2 = new DateTime(2021, 5, 16);
DateTime date3 = new DateTime(2021, 5, 18);
List <WeatherObservation> weatherObservations = new List <WeatherObservation>();
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 6;
wo1.Date = date1;
weatherObservations.Add(wo1);
WeatherObservation wo2 = new WeatherObservation();
wo2.Temperature = 15;
wo2.Date = date2;
weatherObservations.Add(wo2);
WeatherObservation wo3 = new WeatherObservation();
wo3.Temperature = 35;
wo3.Date = date3;
weatherObservations.Add(wo3);
foreach (var weatherObservation in weatherObservations)
{
_context.WeatherObservations.Add(weatherObservation);
}
_context.SaveChanges();
var list = await _uut.GetTempByStartAndEndTime(date1, date2);
Assert.Equal(6, list.Value.ElementAt(0).Temperature);
Assert.Equal(15, list.Value.ElementAt(1).Temperature);
Assert.Equal(2, list.Value.Count);
_context.Database.EnsureDeleted();
}
public async void WeatherStationController_GetTempByDate_FoundObservation()
{
_context.Database.EnsureCreated();
DateTime date = new DateTime(2021, 5, 15);
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 10;
wo1.Date = date;
_context.WeatherObservations.Add(wo1);
_context.SaveChanges();
var list = await _uut.GetTempByDate(date);
Assert.Equal(10, list.Value.ElementAt(0).Temperature);
_context.Database.EnsureDeleted();
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
var data = this.ReadRawBytes(CCS811ALGRESULTDATA, 4);
sensorResult.AddDiagnostic(ByteOperations.PrintByteArray(data));
var co2 = (data[0] << 8) | data[1];
var tvoc = (data[2] << 8) | data[3];
sensorResult.AddFinalObservation(co2, "CO2", ObservationUnits.PartsPerMillion);
sensorResult.AddFinalObservation(tvoc, "TVOC", ObservationUnits.PartsPerBillion);
observation.CO2 = co2;
observation.TVOC = tvoc;
this.LogTakeReadingComplete();
return(sensorResult);
}
public async void WeatherStationController_GetTempByStartAndEndTime_StartAndEndTimeNull()
{
_context.Database.EnsureCreated();
DateTime date = new DateTime(2021, 5, 15);
WeatherObservation wo1 = new WeatherObservation();
wo1.Temperature = 10;
wo1.Date = date;
_context.WeatherObservations.Add(wo1);
_context.SaveChanges();
var list = await _uut.GetTempByStartAndEndTime(null, null);
Assert.IsType <BadRequestResult>(list.Result);
_context.Database.EnsureDeleted();
}
public async Task GetWeatherObservationByDate()
{
//Arrange
WeatherObservation weatherObservations = new WeatherObservation()
{
Date = new DateTime(2020, 6, 20),
Name = "Vejle",
Latitude = 1013031,
Longitude = 2554322,
TemperatureCelsius = 11,
Humidity_Percentage = 14,
Pressure_Millibar = 5
};
//Act
var result = (await _uut.GetOnDate(new DateTime(2020, 6, 20))) as ObjectResult;
//Assert
Assert.NotNull(result);
await _weatherObservationRepository.Received().GetOnDate(new DateTime(2020, 6, 20));
}
/// <inheritdoc/>
public override ISensorSample TakeReading(WeatherObservation observation)
{
this.LogTakeReadingStart();
var sensorResult = new SensorSample(this.SensorName);
if (this.sensor.TryReadGasData(out VolumeConcentration eCO2, out VolumeConcentration eTVOC, out ElectricCurrent curr, out int adc))
{
sensorResult.AddFinalObservation(eCO2.PartsPerMillion, "CO2", ObservationUnits.PartsPerMillion);
sensorResult.AddFinalObservation(eTVOC.PartsPerBillion, "TVOC", ObservationUnits.PartsPerBillion);
observation.CO2 = eCO2.PartsPerMillion;
observation.TVOC = eTVOC.PartsPerBillion;
}
else
{
this.LogError("Error reading from CSS811");
}
this.LogTakeReadingComplete();
return(sensorResult);
}
public async Task GetWeatherObservationsBetweenDates()
{
//Arrange
WeatherObservation weatherObservations = new WeatherObservation()
{
Date = new DateTime(2020, 6, 20),
Name = "Vordingborg",
Latitude = 10130343,
Longitude = 255522,
TemperatureCelsius = 1,
Humidity_Percentage = 4,
Pressure_Millibar = 1
};
//Act
var result = (await _uut.GetBetween(new DateTime(2020, 6, 28), new DateTime(2020, 6, 10))) as ObjectResult;
//Assert
Assert.NotNull(result);
await _weatherObservationRepository.Received().GetBetween(new DateTime(2020, 6, 28), new DateTime(2020, 6, 10));
}
