iobroker.poolcontrol 1.3.32 → 1.3.34

package/lib/helpers/chemistryPhHelper.js

@@ -1,8 +1,14 @@
 'use strict';
 
 const { I18n } = require('@iobroker/adapter-core');
-const MAX_HISTORY_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_HISTORY_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_HISTORY_SAMPLES = 672;
+const MAX_HISTORY_BYTES = 64 * 1024;
 const MIN_SAMPLE_INTERVAL_MS = 15 * 60 * 1000;
+const MAX_DAILY_HISTORY_AGE_MS = 32 * 24 * 60 * 60 * 1000;
+const MAX_DAILY_HISTORY_SAMPLES = 32;
+const MAX_DAILY_HISTORY_BYTES = 8 * 1024;
+const DAILY_REFERENCE_TOLERANCE_MS = 4 * 24 * 60 * 60 * 1000;
 
 /**
  * chemistryPhHelper
@@ -383,8 +389,8 @@ const chemistryPhHelper = {
 
         await this._updateLastValues(value, now);
 
-        const history = await this._updateHistory(value, now, reason === 'external_state' || reason === 'manual_value');
-        const trend = await this._calculateTrend(value, now, history);
+        const history = await this._updateHistory(value, now, reason === 'manual_value');
+        const trend = await this._calculateTrend(value, now, history.samples, history.dailySamples);
         const evaluation = await this._evaluateValue(value);
 
         await this._writeTrend(trend);
@@ -464,16 +470,17 @@ const chemistryPhHelper = {
 
     async _updateHistory(value, now, forceSample) {
         let samples = await this._readJsonArray('chemistry.ph.history.samples_json');
+        const dailySeedSamples = samples;
         const nowTs = now.getTime();
         const minTs = nowTs - MAX_HISTORY_AGE_MS;
 
-        samples = samples.filter(
-            sample => sample && Number(sample.ts) >= minTs && Number.isFinite(Number(sample.value)),
-        );
+        samples = samples.filter(sample => sample.ts >= minTs && sample.ts <= nowTs);
 
         const newest = samples.length ? samples[samples.length - 1] : null;
         const newestTs = newest ? Number(newest.ts) : 0;
-        const shouldStore = forceSample || !newest || nowTs - newestTs >= MIN_SAMPLE_INTERVAL_MS;
+        const withinSampleInterval = newest && nowTs - newestTs < MIN_SAMPLE_INTERVAL_MS;
+        const sameValue = newest && Number(newest.value) === value;
+        const shouldStore = !newest || !withinSampleInterval || (forceSample && !sameValue);
 
         if (shouldStore) {
             samples.push({
@@ -483,9 +490,12 @@ const chemistryPhHelper = {
             });
         }
 
-        samples = samples.filter(sample => sample && Number(sample.ts) >= minTs);
+        samples = samples.filter(sample => sample.ts >= minTs && sample.ts <= nowTs).slice(-MAX_HISTORY_SAMPLES);
+
+        const preparedHistory = this._prepareHistoryForWrite(samples, 'chemistry.ph.history.samples_json');
+        samples = preparedHistory.samples;
 
-        await this._setString('chemistry.ph.history.samples_json', JSON.stringify(samples));
+        await this._setString('chemistry.ph.history.samples_json', preparedHistory.json);
         await this._setNumber('chemistry.ph.history.samples_count', samples.length);
 
         if (samples.length) {
@@ -501,15 +511,20 @@ const chemistryPhHelper = {
             );
         }
 
-        return samples;
+        const dailySamples = await this._updateDailyHistory(dailySeedSamples, value, now, shouldStore);
+        return { samples, dailySamples };
     },
 
-    async _calculateTrend(currentValue, now, samples) {
+    async _calculateTrend(currentValue, now, samples, dailySamples) {
         const nowTs = now.getTime();
 
         const ref24h = this._findReferenceSample(samples, nowTs - 24 * 60 * 60 * 1000);
         const ref7d = this._findReferenceSample(samples, nowTs - 7 * 24 * 60 * 60 * 1000);
-        const ref30d = this._findReferenceSample(samples, nowTs - 30 * 24 * 60 * 60 * 1000);
+        const ref30d = this._findReferenceSample(
+            dailySamples,
+            nowTs - 30 * 24 * 60 * 60 * 1000,
+            DAILY_REFERENCE_TOLERANCE_MS,
+        );
 
         const delta24h = ref24h ? currentValue - ref24h.value : 0;
         const delta7d = ref7d ? currentValue - ref7d.value : 0;
@@ -530,7 +545,7 @@ const chemistryPhHelper = {
         };
     },
 
-    _findReferenceSample(samples, targetTs) {
+    _findReferenceSample(samples, targetTs, toleranceMs = null) {
         if (!samples.length) {
             return null;
         }
@@ -540,7 +555,7 @@ const chemistryPhHelper = {
 
         for (const sample of samples) {
             const ts = Number(sample.ts);
-            const value = Number(sample.value);
+            const value = Number(sample.value ?? sample.last);
 
             if (!Number.isFinite(ts) || !Number.isFinite(value)) {
                 continue;
@@ -558,7 +573,7 @@ const chemistryPhHelper = {
             }
         }
 
-        return best;
+        return toleranceMs === null || bestDistance <= toleranceMs ? best : null;
     },
 
     _getOverallDirection(ref24h, ref7d, ref30d, delta24h, delta7d, delta30d) {
@@ -886,17 +901,264 @@ const chemistryPhHelper = {
         return legacyDate ? legacyDate.getTime() : null;
     },
 
+    async _updateDailyHistory(shortTermSamples, value, now, sampleStored) {
+        const id = 'chemistry.ph.history.daily_json';
+        let dailySamples = await this._readDailyJson(id);
+        const nowTs = now.getTime();
+        const minTs = nowTs - MAX_DAILY_HISTORY_AGE_MS;
+        const initializeFromSeeds = dailySamples.length === 0;
+
+        if (initializeFromSeeds) {
+            const legacyValueState = await this.adapter.getStateAsync('chemistry.ph.trend.reference_30d_value');
+            const legacyAtState = await this.adapter.getStateAsync('chemistry.ph.trend.reference_30d_at');
+            const legacyValue = Number(legacyValueState?.val);
+            const legacyTs = Number(legacyAtState?.val);
+
+            if (
+                Number.isFinite(legacyValue) &&
+                legacyValue >= 0 &&
+                legacyValue <= 14 &&
+                Number.isFinite(legacyTs) &&
+                legacyTs >= minTs &&
+                legacyTs <= nowTs &&
+                !shortTermSamples.some(sample => this._dayKey(sample.ts) === this._dayKey(legacyTs))
+            ) {
+                this._addDailySample(dailySamples, legacyTs, legacyValue);
+            }
+
+            for (const sample of shortTermSamples) {
+                if (sample.ts >= minTs && sample.ts <= nowTs) {
+                    this._addDailySample(dailySamples, sample.ts, sample.value);
+                }
+            }
+            if (sampleStored) {
+                this._addDailySample(dailySamples, nowTs, value);
+            }
+        } else if (sampleStored) {
+            this._addDailySample(dailySamples, nowTs, value);
+        }
+
+        dailySamples = dailySamples
+            .filter(sample => sample.ts >= minTs && sample.ts <= nowTs)
+            .sort((a, b) => a.ts - b.ts)
+            .slice(-MAX_DAILY_HISTORY_SAMPLES);
+
+        const preparedHistory = this._prepareDailyHistoryForWrite(dailySamples, id);
+        await this._setString(id, preparedHistory.json);
+        return preparedHistory.samples;
+    },
+
+    _addDailySample(dailySamples, sampleTs, value) {
+        const day = this._dayKey(sampleTs);
+        const existing = dailySamples.find(sample => sample.day === day);
+
+        if (!existing) {
+            dailySamples.push({
+                day,
+                ts: this._dayStartTs(sampleTs),
+                min: value,
+                max: value,
+                avg: value,
+                last: value,
+                count: 1,
+            });
+            return;
+        }
+
+        existing.min = Math.min(existing.min, value);
+        existing.max = Math.max(existing.max, value);
+        existing.avg = (existing.avg * existing.count + value) / (existing.count + 1);
+        existing.last = value;
+        existing.count += 1;
+    },
+
+    async _readDailyJson(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const rawValue = state?.val;
+
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            return [];
+        }
+
+        if (typeof rawValue !== 'string') {
+            this.adapter.log.warn(`[chemistryPhHelper] Ignoring non-string daily history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryPhHelper] Ignoring oversized daily history state ${id} (> 8 KB).`);
+            return [];
+        }
+
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+
+            const nowTs = Date.now();
+            const normalized = parsed
+                .map(sample => {
+                    const sourceTs = Number(sample?.ts);
+                    const legacyValue = Number(sample?.value);
+                    const min = Number(sample?.min ?? legacyValue);
+                    const max = Number(sample?.max ?? legacyValue);
+                    const avg = Number(sample?.avg ?? legacyValue);
+                    const last = Number(sample?.last ?? legacyValue);
+                    const count = sample?.count === undefined ? 1 : Number(sample.count);
+
+                    if (!Number.isFinite(sourceTs) || sourceTs <= 0 || sourceTs > nowTs) {
+                        return null;
+                    }
+                    if (
+                        !Number.isFinite(min) ||
+                        !Number.isFinite(max) ||
+                        !Number.isFinite(avg) ||
+                        !Number.isFinite(last) ||
+                        min < 0 ||
+                        max > 14 ||
+                        min > max ||
+                        avg < min ||
+                        avg > max ||
+                        last < min ||
+                        last > max
+                    ) {
+                        return null;
+                    }
+                    if (!Number.isInteger(count) || count < 1 || count > 1000000) {
+                        return null;
+                    }
+
+                    return {
+                        day: this._dayKey(sourceTs),
+                        ts: this._dayStartTs(sourceTs),
+                        min,
+                        max,
+                        avg,
+                        last,
+                        count,
+                    };
+                })
+                .filter(Boolean)
+                .sort((a, b) => a.ts - b.ts);
+
+            const byDay = new Map();
+            for (const sample of normalized) {
+                if (!byDay.has(sample.day)) {
+                    byDay.set(sample.day, sample);
+                }
+            }
+            return [...byDay.values()].slice(-MAX_DAILY_HISTORY_SAMPLES);
+        } catch {
+            return [];
+        }
+    },
+
+    _prepareDailyHistoryForWrite(samples, id) {
+        let limitedSamples = samples.slice(-MAX_DAILY_HISTORY_SAMPLES);
+        let json = JSON.stringify(limitedSamples);
+        let trimmedForSize = false;
+
+        while (limitedSamples.length && Buffer.byteLength(json, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            limitedSamples = limitedSamples.slice(1);
+            json = JSON.stringify(limitedSamples);
+            trimmedForSize = true;
+        }
+
+        if (trimmedForSize) {
+            this.adapter.log.warn(`[chemistryPhHelper] Daily history ${id} was trimmed to stay within 8 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryPhHelper] Daily history ${id} could not be limited; resetting it.`);
+            return { samples: [], json: '[]' };
+        }
+
+        return { samples: limitedSamples, json };
+    },
+
+    _dayKey(ts) {
+        const date = new Date(ts);
+        const year = String(date.getFullYear());
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return [year, month, day].join('-');
+    },
+
+    _dayStartTs(ts) {
+        const date = new Date(ts);
+        date.setHours(0, 0, 0, 0);
+        return date.getTime();
+    },
+
     async _readJsonArray(id) {
         const state = await this.adapter.getStateAsync(id);
+        const rawValue = state?.val;
+
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            return [];
+        }
+
+        if (typeof rawValue !== 'string') {
+            this.adapter.log.warn(`[chemistryPhHelper] Ignoring non-string history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryPhHelper] Ignoring oversized history state ${id} (> 64 KB).`);
+            return [];
+        }
 
         try {
-            const parsed = JSON.parse(String(state?.val || '[]'));
-            return Array.isArray(parsed) ? parsed : [];
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+
+            const nowTs = Date.now();
+            return parsed
+                .map(sample => {
+                    const ts = Number(sample?.ts);
+                    const value = Number(sample?.value);
+                    if (!Number.isFinite(ts) || ts <= 0 || ts > nowTs) {
+                        return null;
+                    }
+                    if (!Number.isFinite(value) || value < 0 || value > 14) {
+                        return null;
+                    }
+                    return { ts, time: this._formatDateTime(new Date(ts)), value };
+                })
+                .filter(Boolean)
+                .sort((a, b) => a.ts - b.ts)
+                .slice(-MAX_HISTORY_SAMPLES);
         } catch {
             return [];
         }
     },
 
+    _prepareHistoryForWrite(samples, id) {
+        let limitedSamples = samples.slice(-MAX_HISTORY_SAMPLES);
+        let json = JSON.stringify(limitedSamples);
+        let trimmedForSize = false;
+
+        while (limitedSamples.length && Buffer.byteLength(json, 'utf8') > MAX_HISTORY_BYTES) {
+            limitedSamples = limitedSamples.slice(1);
+            json = JSON.stringify(limitedSamples);
+            trimmedForSize = true;
+        }
+
+        if (trimmedForSize) {
+            this.adapter.log.warn(`[chemistryPhHelper] History ${id} was trimmed to stay within 64 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryPhHelper] History ${id} could not be limited safely; resetting it.`);
+            return { samples: [], json: '[]' };
+        }
+
+        return { samples: limitedSamples, json };
+    },
+
     async _readBoolean(id) {
         const state = await this.adapter.getStateAsync(id);
         return !!state?.val;