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

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
}
}