private async Task <Dictionary <Tuple <ModuleId, ModuleId, Measure>, List <TimeSeries <double> > > > LoadMidresSensorValues(DateTime start, DateTime end)
{
var days = new TimeSeriesSpan(start.ToUniversalTime(), end.ToUniversalTime(), 1).IncludedDates().ToList();
var loadedValues = new Dictionary <Tuple <ModuleId, ModuleId, Measure>, List <TimeSeries <double> > >();
foreach (var module in _netatmoStructure.Modules)
{
var measureTypes = _netatmoStructure.GetModuleMeasures(module.Item2);
var measures = await _netatmoClient.GetMeasure(module.Item1, module.Item2, measureTypes, MeasureScale.ScaleMax, start, end, null, true);
var series = measureTypes.ToDictionary(m => m, m => Enumerable.Range(0, days.Count).Select(k =>
new TimeSeries <double>(new TimeSeriesSpan(days[k], days[k].AddDays(1), TimeSeriesSpan.Spacing.Spacing5Min))).ToList());
foreach (var measure in measures)
{
foreach (var originSeries in measure.Value)
{
for (int k = 0; k < series[measure.Key].Count; k++)
{
MapToEquidistantTimeSeries(series[measure.Key][k], originSeries);
}
}
}
foreach (var serie in series)
{
loadedValues.Add(new Tuple <ModuleId, ModuleId, Measure>(module.Item1, module.Item2, serie.Key), serie.Value);
}
}
return(loadedValues);
}
public void TestGenericGraphViewModel()
{
var span = new TimeSeriesSpan(new DateTime(2019, 01, 01, 12, 0, 0, DateTimeKind.Utc), TimeSeriesSpan.Spacing.Spacing1Min, 5);
var timeseries = new TimeSeries <int>(span);
timeseries[2] = 23;
timeseries[4] = 42;
var graphViewModel = new GraphViewModel <int>(timeseries, "test", "#.00 Unit");
Assert.Equal(new DateTime(2019, 01, 01, 12, 2, 0, DateTimeKind.Utc), graphViewModel.Begin);
Assert.Equal(TimeSpan.FromMinutes(1), graphViewModel.Spacing);
Assert.Equal("test", graphViewModel.Name);
Assert.Equal("#.00 Unit", graphViewModel.Format);
Assert.Equal(new dynamic?[] { 23, null, 42 }, graphViewModel.Points);
Assert.Equal(1546344120000, graphViewModel.BeginUnixTimestamp);
Assert.Equal(60000, graphViewModel.SpacingMillis);
Assert.Equal(new dynamic[] {
new dynamic?[] { 23, 1546344120000 },
new dynamic?[] { null, 1546344180000 },
new dynamic?[] { 42, 1546344240000 }
}, graphViewModel.TimestampedPoints());
}
static TimeSeries <T> ToTimeSeries <T>(TimeSeriesSpan span, List <T?> source) where T : struct
{
var series = new TimeSeries <T>(span);
for (int i = 0; i < Math.Min(span.Count, source.Count); i++)
{
series[i] = source[i];
}
return(series);
}
public async Task PollSensorValues(DateTime start, DateTime end)
{
if (string.IsNullOrEmpty(_siteId))
{
_siteId = (await _sonnenClient.GetUserSites()).DefaultSiteId;
if (string.IsNullOrEmpty(_siteId))
{
return;
}
}
var energyValues = await _sonnenClient.GetEnergyMeasurements(_siteId, start, end);
if (energyValues.Start == DateTime.MinValue || energyValues.End == DateTime.MinValue)
{
return;
}
var span = new TimeSeriesSpan(energyValues.Start.ToUniversalTime(), energyValues.End.ToUniversalTime(), energyValues.Resolution);
var productionPower = new TimeSeries <int>(span);
var consumptionPower = new TimeSeries <int>(span);
var directUsagePower = new TimeSeries <int>(span);
var batteryCharging = new TimeSeries <int>(span);
var batteryDischarging = new TimeSeries <int>(span);
var gridFeedin = new TimeSeries <int>(span);
var gridPurchase = new TimeSeries <int>(span);
var batteryUsoc = new TimeSeries <double>(span);
for (int i = 0; i < Math.Min(span.Count, energyValues.ProductionPower.Count); i++)
{
productionPower[i] = energyValues.ProductionPower[i];
consumptionPower[i] = energyValues.ConsumptionPower[i];
directUsagePower[i] = energyValues.DirectUsagePower[i];
batteryCharging[i] = energyValues.BatteryCharging[i];
batteryDischarging[i] = energyValues.BatteryDischarging[i];
gridFeedin[i] = energyValues.GridFeedin[i];
gridPurchase[i] = energyValues.GridPurchase[i];
batteryUsoc[i] = energyValues.BatteryUsoc[i];
}
foreach (var day in span.IncludedDates())
{
SaveEnergyMidResValues(day, productionPower, consumptionPower, directUsagePower,
batteryCharging, batteryDischarging, gridFeedin, gridPurchase, batteryUsoc);
SaveEnergyLowResValues(day, productionPower, consumptionPower, directUsagePower,
batteryCharging, batteryDischarging, gridFeedin, gridPurchase, batteryUsoc);
}
_dbContext.SaveChanges();
}
public void TestEmptyGenericGraphViewModel()
{
var span = new TimeSeriesSpan(new DateTime(2019, 01, 01, 12, 0, 0, DateTimeKind.Utc), TimeSeriesSpan.Spacing.Spacing1Min, 5);
var timeseries = new TimeSeries <int>(span);
var graphViewModel = new GraphViewModel <int>(timeseries, "test", "#.00 Unit");
Assert.Equal(new DateTime(1970, 1, 1, 0, 0, 0), graphViewModel.Begin);
Assert.Equal(TimeSpan.FromMinutes(1), graphViewModel.Spacing);
Assert.Equal("test", graphViewModel.Name);
Assert.Equal("#.00 Unit", graphViewModel.Format);
Assert.Equal(new dynamic[] { }, graphViewModel.Points);
Assert.Equal(new dynamic[] { }, graphViewModel.TimestampedPoints());
Assert.Equal(0, graphViewModel.BeginUnixTimestamp);
Assert.Equal(60000, graphViewModel.SpacingMillis);
}
private async Task PollEnergyValues()
{
var fetchLastValues = (int)TimeSeriesSpan.Spacing.Spacing10Min;
var days = new TimeSeriesSpan(DateTime.Now.AddSeconds(-1 * fetchLastValues), TimeSeriesSpan.Spacing.Spacing1Sec, fetchLastValues).IncludedDates();
Dictionary <DateTime, TimeSeriesStreamCollection <Dsuid, int> >?timeseriesCollections = null;
try
{
timeseriesCollections = ReadHighResEnergyValuesFromDb(days);
foreach (var dsuid in Dsuids)
{
foreach (var timestampedValue in (await _dsClient.GetEnergy(dsuid, (int)TimeSeriesSpan.Spacing.Spacing1Sec, fetchLastValues)).TimeSeries)
{
foreach (var timeseries in timeseriesCollections.Select(x => x.Value[dsuid]))
{
timeseries[timestampedValue.Key.ToUniversalTime()] = (int)timestampedValue.Value;
}
}
}
SaveHighResEnergyValuesToDb(timeseriesCollections);
_dbContext.SaveChanges();
SaveMidResEnergyValuesToDb(timeseriesCollections);
_dbContext.SaveChanges();
SaveLowResEnergyValuesToDb(timeseriesCollections);
_dbContext.SaveChanges();
}
catch { throw; }
finally
{
if (timeseriesCollections != null)
{
foreach (var collection in timeseriesCollections)
{
collection.Value.Dispose();
}
}
}
}
public static TimeSeries <T> ToTimeseries <T>(this string?base64, TimeSeriesSpan span, int decimalPlaces = defaultDecimalPlaces) where T : struct
{
var timeseries = new TimeSeries <T>(span);
if (string.IsNullOrWhiteSpace(base64))
{
return(timeseries);
}
var bytes = Convert.FromBase64String(base64);
if (typeof(T) == typeof(bool))
{
int i = 0;
var boolValues = bytes.SelectMany(d => new byte[] { (byte)((d >> 6) & 0x3),
(byte)((d >> 4) & 0x3), (byte)((d >> 2) & 0x3), (byte)(d & 0x3) })
.Select(d => d > 0x01 ? null : (bool?)(d == 0x01)).Take(span.Count).ToList();
foreach (var b in boolValues)
{
(timeseries as TimeSeries <bool>) ![i++] = b;
protected Tseries Resample <Tseries, Tval>(TimeSeriesSpan span, IEnumerable <ITimeSeries <Tval> > series, Func <ITimeSeries <Tval>, ITimeSeries <Tval> >?preprocess = null) where Tval : struct where Tseries : TimeSeriesBase <Tval>
{
var resampler = new TimeSeriesResampler <Tseries, Tval>(span, SamplingConstraint.NoOversampling);
var dataToResample = series;
if (preprocess != null)
{
dataToResample = dataToResample.Select(x => preprocess(x));
}
if (typeof(Tval) == typeof(int))
{
if (typeof(Tseries) == typeof(TimeSeries <int>))
{
Aggregate((resampler as TimeSeriesResampler <TimeSeries <int>, int>) !, dataToResample.Cast <ITimeSeries <int> >(), Aggregator.Average, x => x, x => (int)x);
}
else if (typeof(Tseries) == typeof(TimeSeriesStream <int>))
{
Aggregate((resampler as TimeSeriesResampler <TimeSeriesStream <int>, int>) !, dataToResample.Cast <ITimeSeries <int> >(), Aggregator.Average, x => x, x => (int)x);
}
}
else if (typeof(Tval) == typeof(double))
{
if (typeof(Tseries) == typeof(TimeSeries <double>))
{
Aggregate((resampler as TimeSeriesResampler <TimeSeries <double>, double>) !, dataToResample.Cast <ITimeSeries <double> >(), Aggregator.Average, x => (decimal)x, x => (double)x);
}
else if (typeof(Tseries) == typeof(TimeSeriesStream <double>))
{
Aggregate((resampler as TimeSeriesResampler <TimeSeriesStream <double>, double>) !, dataToResample.Cast <ITimeSeries <double> >(), Aggregator.Average, x => (decimal)x, x => (double)x);
}
}
else if (typeof(Tval) == typeof(bool))
{
(resampler as TimeSeriesResampler <TimeSeries <bool>, bool>)?.SampleAggregate(dataToResample.Cast <ITimeSeries <bool> >(), x => x.Any(b => b));
}
return(resampler.Resampled);
}
public GraphCollectionViewModelBase()
{
span = new TimeSeriesSpan(DateTime.MinValue, DateTime.MinValue.AddMinutes(1), 1);
}
