iobroker.poolcontrol 1.3.33 → 1.3.34

package/lib/helpers/chemistryTdsHelper.js

@@ -2,8 +2,14 @@
 
 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;
 
 const chemistryTdsHelper = {
     adapter: null,
@@ -170,7 +176,7 @@ const chemistryTdsHelper = {
             return;
         }
 
-        await this._processValue(source, rawValue, reason, true);
+        await this._processValue(source, rawValue, reason, source === 'manual');
     },
 
     _scheduleEvaluation(reason, delayMs = 500) {
@@ -289,7 +295,7 @@ const chemistryTdsHelper = {
 
         const history = await this._updateHistory(value, now, forceSample);
         const reference = await this._updateReference(value, now);
-        const trend = await this._calculateTrend(value, now, history);
+        const trend = await this._calculateTrend(value, now, history.samples, history.dailySamples);
         const evaluation = await this._evaluateTds(value, reference, trend);
 
         await this._writeTrend(trend);
@@ -373,16 +379,17 @@ const chemistryTdsHelper = {
 
     async _updateHistory(value, now, forceSample) {
         let samples = await this._readJsonArray('chemistry.tds.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({
@@ -392,9 +399,12 @@ const chemistryTdsHelper = {
             });
         }
 
-        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.tds.history.samples_json');
+        samples = preparedHistory.samples;
 
-        await this._setString('chemistry.tds.history.samples_json', JSON.stringify(samples));
+        await this._setString('chemistry.tds.history.samples_json', preparedHistory.json);
         await this._setNumber('chemistry.tds.history.samples_count', samples.length);
 
         if (samples.length) {
@@ -410,7 +420,8 @@ const chemistryTdsHelper = {
             );
         }
 
-        return samples;
+        const dailySamples = await this._updateDailyHistory(dailySeedSamples, value, now, shouldStore);
+        return { samples, dailySamples };
     },
 
     async _updateReference(value, now) {
@@ -457,12 +468,16 @@ const chemistryTdsHelper = {
         this._scheduleEvaluation('reference_reset', 500);
     },
 
-    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;
@@ -483,7 +498,7 @@ const chemistryTdsHelper = {
         };
     },
 
-    _findReferenceSample(samples, targetTs) {
+    _findReferenceSample(samples, targetTs, toleranceMs = null) {
         if (!samples.length) {
             return null;
         }
@@ -493,7 +508,7 @@ const chemistryTdsHelper = {
 
         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;
@@ -511,7 +526,7 @@ const chemistryTdsHelper = {
             }
         }
 
-        return best;
+        return toleranceMs === null || bestDistance <= toleranceMs ? best : null;
     },
 
     _getOverallDirection(ref24h, ref7d, ref30d, delta24h, delta7d, delta30d) {
@@ -768,17 +783,264 @@ const chemistryTdsHelper = {
         return !!state?.val;
     },
 
+    async _updateDailyHistory(shortTermSamples, value, now, sampleStored) {
+        const id = 'chemistry.tds.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.tds.trend.reference_30d_value');
+            const legacyAtState = await this.adapter.getStateAsync('chemistry.tds.trend.reference_30d_at');
+            const legacyValue = Number(legacyValueState?.val);
+            const legacyTs = Number(legacyAtState?.val);
+
+            if (
+                Number.isFinite(legacyValue) &&
+                legacyValue >= 0 &&
+                legacyValue <= 10000 &&
+                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(`[chemistryTdsHelper] Ignoring non-string daily history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] 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 > 10000 ||
+                        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(`[chemistryTdsHelper] Daily history ${id} was trimmed to stay within 8 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] 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(`[chemistryTdsHelper] Ignoring non-string history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] 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 > 10000) {
+                        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(`[chemistryTdsHelper] History ${id} was trimmed to stay within 64 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] History ${id} could not be limited safely; resetting it.`);
+            return { samples: [], json: '[]' };
+        }
+
+        return { samples: limitedSamples, json };
+    },
+
     async _setString(id, value) {
         await this.adapter.setStateChangedAsync(id, { val: String(value ?? ''), ack: true });
     },

package/lib/helpers/debugLogHelper.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const MAX_DEBUG_LOG_BYTES = 64 * 1024;
+
 /**
  * debugLogHelper (SystemCheck-Version)
  * - Überwacht nur einen auswählbaren Bereich (z. B. pump.*, solar.*, runtime.*)
@@ -157,9 +159,9 @@ const debugLogHelper = {
             const current = (await this.adapter.getStateAsync('SystemCheck.debug_logs.log'))?.val || '';
             const newVal = current + this.buffer;
             await this.adapter.setStateAsync('SystemCheck.debug_logs.log', {
-                val: newVal.slice(-60000),
+                val: this._truncateUtf8(newVal, MAX_DEBUG_LOG_BYTES),
                 ack: true,
-            }); // max ~60k Zeichen
+            }); // hard limit: 64 KB UTF-8
             this.buffer = '';
             if (this.bufferTimer) {
                 this.adapter.clearTimeout(this.bufferTimer);
@@ -170,6 +172,19 @@ const debugLogHelper = {
         }
     },
 
+    _truncateUtf8(value, maxBytes) {
+        const buffer = Buffer.from(String(value ?? ''), 'utf8');
+        if (buffer.length <= maxBytes) {
+            return String(value ?? '');
+        }
+
+        let start = buffer.length - maxBytes;
+        while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) {
+            start += 1;
+        }
+        return buffer.subarray(start).toString('utf8');
+    },
+
     /**
      * Löscht das Log komplett
      */

package/lib/helpers/solarLogbookHelper.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { I18n } = require('@iobroker/adapter-core');
+const MAX_LOGBOOK_BYTES = 64 * 1024;
 
 /**
  * solarLogbookHelper
@@ -261,7 +262,10 @@ const solarLogbookHelper = {
                 trimmedLog = [...dayLog, newLogItem].slice(-100);
             }
 
-            const dayLogText = this._buildDayLogText(trimmedLog);
+            const limitedLog = this._limitDayLogByBytes(trimmedLog);
+            trimmedLog = limitedLog.entries;
+            const dayLogJson = limitedLog.json;
+            const dayLogText = limitedLog.text;
 
             await this.adapter.setStateChangedAsync('analytics.insights.solar.logbook.current_entry', {
                 val: entry.text,
@@ -274,7 +278,7 @@ const solarLogbookHelper = {
             });
 
             await this.adapter.setStateChangedAsync('analytics.insights.solar.logbook.day_log_json', {
-                val: JSON.stringify(trimmedLog),
+                val: dayLogJson,
                 ack: true,
             });
 
@@ -518,6 +522,29 @@ const solarLogbookHelper = {
         return now.getTime() - lastTimestamp >= minIntervalMs;
     },
 
+    _limitDayLogByBytes(entries) {
+        let limitedEntries = entries.slice(-100);
+        let json = JSON.stringify(limitedEntries);
+        let text = this._buildDayLogText(limitedEntries);
+        let wasTrimmed = false;
+
+        while (
+            limitedEntries.length &&
+            (Buffer.byteLength(json, 'utf8') > MAX_LOGBOOK_BYTES || Buffer.byteLength(text, 'utf8') > MAX_LOGBOOK_BYTES)
+        ) {
+            limitedEntries = limitedEntries.slice(1);
+            json = JSON.stringify(limitedEntries);
+            text = this._buildDayLogText(limitedEntries);
+            wasTrimmed = true;
+        }
+
+        if (wasTrimmed) {
+            this.adapter.log.warn('[solarLogbookHelper] Day log was trimmed to keep JSON and text within 64 KB.');
+        }
+
+        return { entries: limitedEntries, json, text };
+    },
+
     _buildDayLogText(dayLog) {
         return dayLog.map(item => `${item.time} - ${item.text}`).join('\n');
     },
@@ -589,6 +616,11 @@ const solarLogbookHelper = {
             return [];
         }
 
+        if (Buffer.byteLength(jsonText, 'utf8') > MAX_LOGBOOK_BYTES) {
+            this.adapter.log.warn('[solarLogbookHelper] Oversized day_log_json was discarded before parsing.');
+            return [];
+        }
+
         try {
             const parsed = JSON.parse(jsonText);
             return Array.isArray(parsed) ? parsed : [];

package/lib/stateDefinitions/chemistryOrpStates.js

@@ -897,8 +897,25 @@ async function createChemistryOrpStates(adapter) {
             de: 'ORP-Historienwerte',
         },
         desc: {
-            en: 'Internal list of valid ORP measurement samples for trend calculation.',
-            de: 'Interne Liste gültiger ORP-Messwerte für die Trendberechnung.',
+            en: 'Bounded short-term JSON history of valid ORP samples: up to 7 days, 672 samples, and 64 KB.',
+            de: 'Begrenzte JSON-Kurzzeithistorie gültiger ORP-Messwerte: bis zu 7 Tage, 672 Samples und 64 KB.',
+        },
+        type: 'string',
+        role: 'json',
+        read: true,
+        write: false,
+        def: '[]',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.orp.history.daily_json', {
+        name: {
+            en: 'ORP daily reference history',
+            de: 'ORP-Tagesreferenzhistorie',
+        },
+        desc: {
+            en: 'Internal bounded local-calendar-day aggregates (min/max/avg/last/count) for 30-day trend calculations; last is used as reference.',
+            de: 'Interne begrenzte Aggregate lokaler Kalendertage (min/max/avg/last/count) für 30-Tage-Trendberechnungen; last dient als Referenz.',
         },
         type: 'string',
         role: 'json',

package/lib/stateDefinitions/chemistryPhStates.js

@@ -665,8 +665,25 @@ async function createChemistryPhStates(adapter) {
             de: 'Messwerte JSON',
         },
         desc: {
-            en: 'Internal JSON list of valid pH samples for up to 30 days.',
-            de: 'Interne JSON-Liste gültiger pH-Messpunkte für bis zu 30 Tage.',
+            en: 'Bounded short-term JSON history of valid pH samples: up to 7 days, 672 samples, and 64 KB.',
+            de: 'Begrenzte JSON-Kurzzeithistorie gültiger pH-Messpunkte: bis zu 7 Tage, 672 Samples und 64 KB.',
+        },
+        type: 'string',
+        role: 'json',
+        read: true,
+        write: false,
+        def: '[]',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.ph.history.daily_json', {
+        name: {
+            en: 'pH daily reference history',
+            de: 'pH-Tagesreferenzhistorie',
+        },
+        desc: {
+            en: 'Internal bounded local-calendar-day aggregates (min/max/avg/last/count) for 30-day trend calculations; last is used as reference.',
+            de: 'Interne begrenzte Aggregate lokaler Kalendertage (min/max/avg/last/count) für 30-Tage-Trendberechnungen; last dient als Referenz.',
         },
         type: 'string',
         role: 'json',

package/lib/stateDefinitions/chemistryTdsStates.js

@@ -734,8 +734,25 @@ async function createChemistryTdsStates(adapter) {
             de: 'Messwerte JSON',
         },
         desc: {
-            en: 'Internal JSON list of valid TDS samples for up to 30 days.',
-            de: 'Interne JSON-Liste gültiger TDS-Messpunkte für bis zu 30 Tage.',
+            en: 'Bounded short-term JSON history of valid TDS samples: up to 7 days, 672 samples, and 64 KB.',
+            de: 'Begrenzte JSON-Kurzzeithistorie gültiger TDS-Messpunkte: bis zu 7 Tage, 672 Samples und 64 KB.',
+        },
+        type: 'string',
+        role: 'json',
+        read: true,
+        write: false,
+        def: '[]',
+        persist: true,
+    });
+
+    await createState(adapter, 'chemistry.tds.history.daily_json', {
+        name: {
+            en: 'TDS daily reference history',
+            de: 'TDS-Tagesreferenzhistorie',
+        },
+        desc: {
+            en: 'Internal bounded local-calendar-day aggregates (min/max/avg/last/count) for 30-day trend calculations; last is used as reference.',
+            de: 'Interne begrenzte Aggregate lokaler Kalendertage (min/max/avg/last/count) für 30-Tage-Trendberechnungen; last dient als Referenz.',
         },
         type: 'string',
         role: 'json',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.poolcontrol",
-  "version": "1.3.33",
+  "version": "1.3.34",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",
@@ -21,7 +21,7 @@
     "node": ">= 22"
   },
   "dependencies": {
-    "@iobroker/adapter-core": "^3.3.2"
+    "@iobroker/adapter-core": "^3.4.1"
   },
   "devDependencies": {
     "@alcalzone/release-script": "^5.2.1",