ckaczor/WeatherService
1
0
Fork 0
mirror of https://github.com/ckaczor/WeatherService.git synced 2026-01-14 01:25:43 -05:00
Code Issues Packages Projects Releases Wiki Activity

- Stop storing history in memory

Browse Source 
- Add start/end dates to history requests
- Cleanup
This commit is contained in:
Chris Kaczor
2015-03-29 17:57:05 -04:00
parent 340a486f95
commit 297a2914ad
14 changed files with 137 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Values/HumidityReading.cs
View File

@@ -5,7 +5,7 @@ namespace WeatherService.Values
[DataContract]
public class HumidityReading : ReadingBase
{
public HumidityReading(WeatherValueType valueType) : base(valueType)
public HumidityReading() : base(WeatherValueType.Humidity)
{
}
}

2
Values/PressureReading.cs
View File

@@ -5,7 +5,7 @@ namespace WeatherService.Values
[DataContract]
public class PressureReading : ReadingBase
{
public PressureReading(WeatherValueType valueType) : base(valueType)
public PressureReading() : base(WeatherValueType.Pressure)
{
}
}

2
Values/RainReading.cs
View File

@@ -5,7 +5,7 @@ namespace WeatherService.Values
[DataContract]
public class RainReading : ReadingBase
{
public RainReading(WeatherValueType valueType) : base(valueType)
public RainReading() : base(WeatherValueType.Rain)
{
}

22
Values/ReadingBase.cs
View File

@@ -78,22 +78,32 @@ namespace WeatherService.Values
switch (valueType)
{
case WeatherValueType.Temperature:
return new TemperatureReading(valueType);
return new TemperatureReading();
case WeatherValueType.Pressure:
return new PressureReading(valueType);
return new PressureReading();
case WeatherValueType.Humidity:
return new HumidityReading(valueType);
return new HumidityReading();
case WeatherValueType.WindSpeed:
return new WindSpeedReading(valueType);
return new WindSpeedReading();
case WeatherValueType.WindDirection:
return new WindDirectionReading(valueType);
return new WindDirectionReading();
case WeatherValueType.Rain:
return new RainReading(valueType);
return new RainReading();
default:
throw new ArgumentOutOfRangeException("valueType");
}
}
public static ReadingBase CreateReading(WeatherValueType valueType, DateTime readTime, double value)
{
var reading = CreateReading(valueType);
reading.ReadTime = readTime;
reading.Value = value;
return reading;
}
#endregion
}
}

2
Values/TemperatureReading.cs
View File

@@ -5,7 +5,7 @@ namespace WeatherService.Values
[DataContract]
public class TemperatureReading : ReadingBase
{
public TemperatureReading(WeatherValueType valueType) : base(valueType)
public TemperatureReading() : base(WeatherValueType.Temperature)
{
}

197
Values/Value.cs
View File

@@ -1,6 +1,4 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using WeatherService.Data;
using WeatherService.Devices;
@@ -35,12 +33,6 @@ namespace WeatherService.Values
[DataContract]
public class Value
{
#region Constants
private const int MaximumHours = 24;
#endregion
#region Member variables
private readonly DeviceBase _ownerDevice; // Owner device
@@ -51,161 +43,12 @@ namespace WeatherService.Values
public Value(WeatherValueType valueType, DeviceBase ownerDevice)
{
MaximumHistoryHours = MaximumHours;
// Remember information we were given
ValueType = valueType;
_ownerDevice = ownerDevice;
// Create the readings
Current = ReadingBase.CreateReading(ValueType);
Maximum = ReadingBase.CreateReading(ValueType);
Minimum = ReadingBase.CreateReading(ValueType);
Average = ReadingBase.CreateReading(ValueType);
Total = valueType == WeatherValueType.Rain ? ReadingBase.CreateReading(ValueType) : new ReadingBase(valueType);
History = new List<ReadingBase>();
// Figure out the minimum time we want to load into history
DateTime minimumTime = DateTime.Now.AddHours(-MaximumHours);
using (var weatherArchiveData = new WeatherArchiveData(minimumTime.Year))
{
var readingList =
weatherArchiveData.Readings.Where(
reading =>
reading.DeviceId == ownerDevice.Id && reading.Type == (int) valueType &&
reading.ReadTime >= minimumTime);
// Loop over all readings and reload them into the history
foreach (var readingData in readingList)
{
// Get the value from the reading
double dValue = readingData.Value;
// Get the timestamp from the reading
DateTime dtTimestamp = readingData.ReadTime.LocalDateTime;
// Set the value into the history
SetValue(dValue, dtTimestamp, false);
}
}
/*
// Build a list for this device using the right value type and limit to the maximum number of hours
var readingList = from reading in Database.ReadingTable
where reading.DeviceId == ownerDevice.Id && reading.Type == valueType && reading.ReadTime >= minimumTime
select reading;
// Loop over all readings and reload them into the history
foreach (ReadingData readingData in readingList)
{
// Get the value from the reading
double dValue = readingData.Value;
// Get the timestamp from the reading
DateTime dtTimestamp = readingData.ReadTime;
// Set the value into the history
SetValue(dValue, dtTimestamp, false);
}
*/
}
#endregion
#region Private methods
private void AddHistory(double value, DateTime timeStamp)
{
// Create the reading
ReadingBase readingBase = ReadingBase.CreateReading(ValueType);
readingBase.Value = value;
readingBase.ReadTime = timeStamp;
// Add the current value to the history
History.Add(readingBase);
// Get the current head of the history list
ReadingBase oHead = History[0];
// Get the difference in time between the now and the reading time
TimeSpan oTimeSpan = DateTime.Now - oHead.ReadTime;
// If the span is over the maximum time then remove it
if (oTimeSpan.TotalHours > MaximumHours)
{
// Remove this sample
Readings--;
// Remove this value from the total
Total.Value -= oHead.Value;
// Remove the reading
History.RemoveAt(0);
}
}
private void CheckMinimumValue(double value, DateTime timeStamp)
{
// Figure out if we want a zero value
bool bNoZero = (ValueType == WeatherValueType.WindSpeed || ValueType == WeatherValueType.Rain);
// Figure out how old the current minimum is
TimeSpan oTimeSpan = DateTime.Now - Minimum.ReadTime;
// If the minimum is too old then we need a new minimum
if (oTimeSpan.TotalHours > MaximumHours)
{
List<ReadingBase> readings = bNoZero ? History.Where(r => r.Value > 0).ToList() : History;
ReadingBase newMin = readings.Min();
// If we got a minimum value then set it
if (newMin != null)
{
// Set the data into the value
Minimum.SetValue(newMin.Value, newMin.ReadTime);
}
}
// If we have no minimum or the value is over the current minimum then reset the minimum
if ((Minimum.ReadTime == DateTime.MinValue) || (value < Minimum.Value) || (Minimum.Value.Equals(0) && bNoZero))
{
bool bSetMinimum; // Is this value the new minimum?
if (bNoZero)
bSetMinimum = (value > 0) || (Minimum.ReadTime == DateTime.MinValue);
else
bSetMinimum = true;
if (bSetMinimum)
Minimum.SetValue(value, timeStamp);
}
}
private void CheckMaximumValue(double value, DateTime timeStamp)
{
// Figure out how old the current maximum is
TimeSpan oTimeSpan = DateTime.Now - Maximum.ReadTime;
// If the maximum is too old then we need a new maximum
if (oTimeSpan.TotalHours > MaximumHours)
{
// Get the new maximum
var newMax = History.Max();
// Set the maximum
Maximum.SetValue(newMax.Value, newMax.ReadTime);
}
// If we have no maximum or the value is over the current maximum then reset the maximum
if ((Maximum.ReadTime == DateTime.MinValue) || (value >= Maximum.Value))
{
Maximum.SetValue(value, timeStamp);
}
}
#endregion
@@ -229,21 +72,12 @@ namespace WeatherService.Values
// Set the current value
Current.SetValue(value, timeStamp);
// Add another sample
Readings++;
// Add the current value to the total
Total.Value += value;
// Add the value to the history
AddHistory(value, timeStamp);
if (save)
{
// Save the reading
using (var weatherArchiveData = new WeatherArchiveData(timeStamp.Year))
{
var reading = new Data.ReadingData
var reading = new ReadingData
{
DeviceId = _ownerDevice.Id,
Type = (int) ValueType,
@@ -254,16 +88,7 @@ namespace WeatherService.Values
weatherArchiveData.Readings.Add(reading);
weatherArchiveData.SaveChanges();
}
// Update the minimum value
CheckMinimumValue(value, timeStamp);
// Update the maximum value
CheckMaximumValue(value, timeStamp);
}
// Calculate the new average value
Average.SetValue(Total.Value / Readings);
}
#endregion
@@ -273,29 +98,9 @@ namespace WeatherService.Values
[DataMember]
public ReadingBase Current { get; set; }
[DataMember]
public ReadingBase Maximum { get; set; }
[DataMember]
public ReadingBase Minimum { get; set; }
[DataMember]
public ReadingBase Average { get; set; }
[DataMember]
public ReadingBase Total { get; set; }
[DataMember]
public long Readings { get; set; }
[DataMember]
public WeatherValueType ValueType { get; set; }
[DataMember]
public int MaximumHistoryHours { get; set; }
public List<ReadingBase> History { get; set; }
#endregion
}
}

54
Values/WindDirectionReading.cs
View File

@@ -1,5 +1,5 @@
using System.Runtime.Serialization;
using WeatherService.Common.Formatting;
using System;
using System.Runtime.Serialization;
using WeatherService.Devices;
namespace WeatherService.Values
@@ -7,21 +7,63 @@ namespace WeatherService.Values
[DataContract]
public class WindDirectionReading : ReadingBase
{
public WindDirectionReading(WeatherValueType valueType) : base(valueType)
public static string GetShortDirectionString(WindDirection actualValue)
{
switch (actualValue)
{
case WindDirection.North:
return "N";
case WindDirection.NorthNorthEast:
return "NNE";
case WindDirection.NorthEast:
return "NE";
case WindDirection.EastNorthEast:
return "ENE";
case WindDirection.East:
return "E";
case WindDirection.EastSouthEast:
return "ESE";
case WindDirection.SouthEast:
return "SE";
case WindDirection.SouthSouthEast:
return "SSE";
case WindDirection.South:
return "S";
case WindDirection.SouthSouthWest:
return "SSW";
case WindDirection.SouthWest:
return "SW";
case WindDirection.WestSouthWest:
return "WSW";
case WindDirection.West:
return "W";
case WindDirection.WestNorthWest:
return "WNW";
case WindDirection.NorthWest:
return "NW";
case WindDirection.NorthNorthWest:
return "NNW";
default:
return String.Empty;
}
}
public WindDirectionReading()
: base(WeatherValueType.WindDirection)
{
}
[DataMember]
public WindDirection WindDirectionValue
{
get { return (WindDirection) Value; }
set { Value = (double) value; }
get { return (WindDirection)Value; }
set { Value = (double)value; }
}
[DataMember]
public string WindDirectionString
{
get { return Format.GetShortDirectionString(WindDirectionValue); }
get { return GetShortDirectionString(WindDirectionValue); }
set { }
}
}

2
Values/WindSpeedReading.cs
View File

@@ -5,7 +5,7 @@ namespace WeatherService.Values
[DataContract]
public class WindSpeedReading : ReadingBase
{
public WindSpeedReading(WeatherValueType valueType) : base(valueType)
public WindSpeedReading() : base(WeatherValueType.WindSpeed)
{
}
}