iobroker.poolcontrol 0.3.0 → 0.4.0

package/lib/helpers/runtimeHelper.js

@@ -21,9 +21,24 @@ const runtimeHelper = {
     resetTimer: null,
     liveTimer: null, // Timer für Live-Updates
 
-    init(adapter) {
+    /**
+     * Initialisiert den Runtime-Helper.
+     * Führt eine kurze Startverzögerung ein, um sicherzustellen,
+     * dass persistente States nach einer Überinstallation korrekt geladen werden.
+     *
+     * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz.
+     * @returns {Promise<void>}
+     */
+    async init(adapter) {
         this.adapter = adapter;
 
+        // ------------------------------------------------------
+        // NEU: Kurze Startverzögerung, damit ioBroker persistente States
+        //      vollständig aus der Datenbank laden kann (Überinstallationsschutz)
+        // ------------------------------------------------------
+        this.adapter.log.debug('[runtimeHelper] Warte 3 Sekunden, um persistente States zu laden ...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
         // Pumpenschalter überwachen
         this.adapter.subscribeStates('pump.pump_switch');
 
@@ -52,6 +67,13 @@ const runtimeHelper = {
         const seasonRaw = (await this.adapter.getStateAsync('runtime.season_total'))?.val;
         const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
+        // FIX: Falls States leer oder neu angelegt sind, Warnhinweis ausgeben und Werte nicht überschreiben
+        if (!totalRaw && !seasonRaw) {
+            this.adapter.log.info(
+                '[runtimeHelper] Keine gespeicherten Laufzeiten gefunden – möglicherweise neue oder überinstallierte Instanz. Laufzeiten starten bei 0.',
+            );
+        }
+
         // >>> NEU: Formatierten Text (z. B. "3h 12m 5s") in Sekunden umwandeln
         this.runtimeTotal = this._parseFormattedTimeToSeconds(totalRaw);
         this.runtimeToday = this._parseFormattedTimeToSeconds(todayRaw);
@@ -72,38 +94,72 @@ const runtimeHelper = {
             return;
         }
 
+        // FIX: Robuste Start-/Stop-Logik für pump.pump_switch
         if (id.endsWith('pump.pump_switch')) {
-            if (state.val && !this.isRunning) {
-                // Pumpe startet
-                this.isRunning = true;
-                this.lastOn = Date.now();
-                this.startCountToday += 1;
-
-                // Live-Timer starten (jede Minute)
-                this._startLiveTimer();
-
-                // Start sofort in State schreiben
-                await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
-            } else if (!state.val && this.isRunning) {
-                // Pumpe stoppt
-                const delta = Math.floor((Date.now() - this.lastOn) / 1000);
-                this.runtimeToday += delta;
-                this.runtimeTotal += delta;
-
-                // Saisonlaufzeit nur zählen, wenn aktiv
-                const seasonActive = !!(await this.adapter.getStateAsync('control.season.active'))?.val;
-                if (seasonActive) {
-                    this.runtimeSeason += delta;
+            if (state.val) {
+                // FIX: Immer starten, wenn Pumpe an ist (egal welcher Helper)
+                if (!this.isRunning || !this.lastOn) {
+                    this.isRunning = true;
+                    this.lastOn = Date.now();
+                    this.startCountToday += 1;
+
+                    // Live-Timer starten (jede Minute)
+                    this._startLiveTimer();
+
+                    // Start sofort in State schreiben
+                    await this.adapter.setStateAsync('runtime.start_count_today', {
+                        val: this.startCountToday,
+                        ack: true,
+                    });
+
+                    // ------------------------------------------------------
+                    // Statuswerte bei Pumpenstart setzen
+                    // ------------------------------------------------------
+                    const nowStr = new Date().toLocaleString();
+                    await this.adapter.setStateAsync('status.pump_last_start', { val: nowStr, ack: true });
+                    await this.adapter.setStateAsync('status.pump_today_count', {
+                        val: this.startCountToday,
+                        ack: true,
+                    });
+                    await this.adapter.setStateAsync('status.pump_was_on_today', { val: true, ack: true });
+                    // ------------------------------------------------------
+                    this.adapter.log.debug('[runtimeHelper] Pumpenlaufzeit gestartet.');
+                }
+            } else {
+                // FIX: Immer sauber stoppen, wenn Pumpe aus ist
+                if (this.isRunning && this.lastOn) {
+                    const delta = Math.floor((Date.now() - this.lastOn) / 1000);
+                    this.runtimeToday += delta;
+                    this.runtimeTotal += delta;
+
+                    // Saisonlaufzeit nur zählen, wenn aktiv
+                    const seasonActive = !!(await this.adapter.getStateAsync('control.season.active'))?.val;
+                    if (seasonActive) {
+                        this.runtimeSeason += delta;
+                    }
+
+                    this.isRunning = false;
+                    this.lastOn = null;
+
+                    // Live-Timer stoppen
+                    this._stopLiveTimer();
+
+                    // States final aktualisieren
+                    await this._updateStates();
+
+                    // ------------------------------------------------------
+                    // Statuswert bei Pumpenstopp setzen
+                    // ------------------------------------------------------
+                    const nowStr = new Date().toLocaleString();
+                    await this.adapter.setStateAsync('status.pump_last_stop', { val: nowStr, ack: true });
+                    // ------------------------------------------------------
+                    this.adapter.log.debug('[runtimeHelper] Pumpenlaufzeit gestoppt.');
+                } else {
+                    // FIX: Falls Pumpe aus, aber kein aktiver Lauf (z. B. Neustart) → nur Timer sicher stoppen
+                    this._stopLiveTimer();
+                    this.isRunning = false;
+                    this.lastOn = null;
                 }
-
-                this.isRunning = false;
-                this.lastOn = null;
-
-                // Live-Timer stoppen
-                this._stopLiveTimer();
-
-                // States final aktualisieren
-                await this._updateStates();
             }
         }
     },
@@ -134,6 +190,16 @@ const runtimeHelper = {
             await this.adapter.setStateAsync('runtime.season_total', { val: formattedSeason, ack: true });
             await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
 
+            // Poolparameter laden (vor Durchflussprüfung!)
+            const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
+            const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
+
+            // daily_required immer direkt setzen – auch ohne Durchfluss
+            const dailyRequired = Math.round(poolSize * minCirc);
+            if (dailyRequired > 0) {
+                await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+            }
+
             // Umwälzmenge berechnen
             // Reeller Durchflusswert aus pump.live.flow_current_lh
             const liveFlowLh = (await this.adapter.getStateAsync('pump.live.flow_current_lh'))?.val || 0;
@@ -143,19 +209,26 @@ const runtimeHelper = {
                 return;
             }
 
-            // Poolparameter laden
-            const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
-            const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
-
             // Berechnung der realen Tagesumwälzung (Liter)
             const dailyTotal = Math.round((effectiveToday / 3600) * liveFlowLh);
-            const dailyRequired = Math.round(poolSize * minCirc);
             const dailyRemaining = Math.max(dailyRequired - dailyTotal, 0);
 
-            // Werte schreiben
-            await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
-            await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
-            await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });
+            // Bestehende Werte für Total/Remaining laden
+            const oldTotal = (await this.adapter.getStateAsync('circulation.daily_total'))?.val || 0;
+            const oldRemaining = (await this.adapter.getStateAsync('circulation.daily_remaining'))?.val || 0;
+
+            // Nur schreiben, wenn tatsächlich sinnvolle Livewerte vorliegen
+            if (liveFlowLh > 0 && dailyTotal > 0) {
+                await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
+                await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });
+                this.adapter.log.debug(
+                    `[runtimeHelper] Circulation-Werte aktualisiert (Total=${dailyTotal}, Required=${dailyRequired}, Remaining=${dailyRemaining})`,
+                );
+            } else {
+                this.adapter.log.debug(
+                    `[runtimeHelper] Keine gültigen Live-Daten – bestehende Werte bleiben erhalten (Total=${oldTotal}, Required=${dailyRequired}, Remaining=${oldRemaining})`,
+                );
+            }
         } catch (err) {
             this.adapter.log.warn(`[runtimeHelper] Fehler beim Update der States: ${err.message}`);
         }
@@ -204,12 +277,37 @@ const runtimeHelper = {
         nextMidnight.setHours(24, 0, 0, 0);
         const msUntilMidnight = nextMidnight - now;
 
-        this.resetTimer = setTimeout(() => {
+        this.resetTimer = setTimeout(async () => {
             this.runtimeToday = 0;
             this.startCountToday = 0;
             this.lastOn = this.isRunning ? Date.now() : null;
+
+            // Laufzeiten zurücksetzen
             this._updateStates();
+
+            // --- NEU: Circulation-Werte um Mitternacht zurücksetzen ---
+            await this.adapter.setStateAsync('circulation.daily_total', { val: 0, ack: true });
+
+            // daily_required neu berechnen (optional, falls sich Poolgröße geändert hat)
+            const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
+            const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
+            const dailyRequired = Math.round(poolSize * minCirc);
+            await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+
+            // 👉 daily_remaining neue berechnen auf Grundlage von daily_required
+            await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRequired, ack: true });
+
+            // ------------------------------------------------------
+            // NEU: Pumpenstatuswerte um Mitternacht zurücksetzen
+            // ------------------------------------------------------
+            await this.adapter.setStateAsync('status.pump_today_count', { val: 0, ack: true });
+            await this.adapter.setStateAsync('status.pump_was_on_today', { val: false, ack: true });
+            // ------------------------------------------------------
+
+            // Nächsten Reset planen
             this._scheduleDailyReset();
+
+            this.adapter.log.debug('[runtimeHelper] Tagesreset (Runtime + Circulation) ausgeführt.');
         }, msUntilMidnight);
     },
 
@@ -217,8 +315,8 @@ const runtimeHelper = {
         if (this.liveTimer) {
             clearInterval(this.liveTimer);
         }
-        this.liveTimer = setInterval(() => this._updateStates(), 60 * 1000);
-        this.adapter.log.debug('[runtimeHelper] Live-Timer gestartet (Updates jede Minute)');
+        this.liveTimer = setInterval(() => this._updateStates(), 10 * 1000);
+        this.adapter.log.debug('[runtimeHelper] Live-Timer gestartet (Updates alle 10 Sekunden)');
     },
 
     _stopLiveTimer() {

package/lib/helpers/statisticsHelper.js

@@ -0,0 +1,392 @@
+'use strict';
+
+/**
+ * statisticsHelper.js
+ * -------------------
+ * Vollständige Steuerung der Tagesstatistik (Temperatur)
+ * im Bereich analytics.statistics.temperature.today.*
+ *
+ * - Erstellt alle States (Überinstallationsschutz + Persistenz)
+ * - Erkennt aktive Sensoren anhand temperature.<sensor>.active
+ * - Reagiert eventbasiert auf Änderungen der Temperaturwerte
+ * - Berechnet laufend Min/Max/Durchschnitt
+ * - Aktualisiert JSON- und HTML-Ausgaben (pro Sensor & gesamt)
+ * - Führt automatisch täglichen Reset um Mitternacht durch
+ *
+ * @param {ioBroker.Adapter} adapter - Die aktuelle Adapterinstanz (this),
+ * über die alle ioBroker-Funktionen wie setStateAsync, getStateAsync usw. aufgerufen werden.
+ */
+
+const statisticsHelper = {
+    adapter: null,
+    midnightTimer: null,
+    sensors: [
+        { id: 'outside', name: 'Außentemperatur' },
+        { id: 'ground', name: 'Bodentemperatur' },
+        { id: 'surface', name: 'Pooloberfläche' },
+        { id: 'flow', name: 'Vorlauf' },
+        { id: 'return', name: 'Rücklauf' },
+        { id: 'collector', name: 'Kollektor (Solar)' },
+    ],
+
+    async init(adapter) {
+        this.adapter = adapter;
+        adapter.log.debug('statisticsHelper: Initialisierung gestartet.');
+
+        try {
+            await this._createTemperatureStatistics();
+            await this._subscribeActiveSensors();
+            await this._scheduleMidnightReset();
+            adapter.log.debug('statisticsHelper: Initialisierung abgeschlossen (Sensorüberwachung aktiv).');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelper: Fehler bei Initialisierung: ${err.message}`);
+        }
+    },
+
+    /**
+     * Erstellt States, falls sie fehlen (Überinstallationsschutz)
+     */
+    async _createTemperatureStatistics() {
+        const adapter = this.adapter;
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
+            await adapter.setObjectNotExistsAsync(basePath, {
+                type: 'channel',
+                common: { name: `${sensor.name} (Tagesstatistik)` },
+                native: {},
+            });
+
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+
+            const summaryJsonPath = `${basePath}.summary_json`;
+            const summaryHtmlPath = `${basePath}.summary_html`;
+
+            if (!isActive) {
+                await adapter.setStateAsync(summaryJsonPath, {
+                    val: JSON.stringify({ status: 'kein Sensor aktiv' }),
+                    ack: true,
+                });
+                await adapter.setStateAsync(summaryHtmlPath, {
+                    val: '<div style="color:gray;">kein Sensor aktiv</div>',
+                    ack: true,
+                });
+                continue;
+            }
+
+            const stateDefs = [
+                { id: 'temp_min', def: null },
+                { id: 'temp_max', def: null },
+                { id: 'temp_min_time', def: '' },
+                { id: 'temp_max_time', def: '' },
+                { id: 'temp_avg', def: null },
+                { id: 'data_points_count', def: 0 },
+                { id: 'last_update', def: '' },
+                { id: 'summary_json', def: '' },
+                { id: 'summary_html', def: '' },
+            ];
+
+            for (const def of stateDefs) {
+                const fullPath = `${basePath}.${def.id}`;
+                const obj = await adapter.getObjectAsync(fullPath);
+                if (!obj) {
+                    await adapter.setObjectNotExistsAsync(fullPath, {
+                        type: 'state',
+                        common: {
+                            name: def.id,
+                            type: typeof def.def === 'number' ? 'number' : 'string',
+                            role: def.id.includes('time')
+                                ? 'value.time'
+                                : def.id.includes('temp')
+                                  ? 'value.temperature'
+                                  : 'value',
+                            read: true,
+                            write: false,
+                            persist: true,
+                        },
+                        native: {},
+                    });
+                }
+
+                const state = await adapter.getStateAsync(fullPath);
+                if (!state || state.val === null || state.val === undefined) {
+                    await adapter.setStateAsync(fullPath, { val: def.def, ack: true });
+                }
+            }
+        }
+
+        const outputBase = 'analytics.statistics.temperature.today.outputs';
+        await adapter.setObjectNotExistsAsync(outputBase, {
+            type: 'channel',
+            common: { name: 'Gesamtausgaben (alle Sensoren)' },
+            native: {},
+        });
+
+        const outputStates = [
+            { id: 'summary_all_json', def: '' },
+            { id: 'summary_all_html', def: '' },
+        ];
+
+        for (const out of outputStates) {
+            const fullPath = `${outputBase}.${out.id}`;
+            const obj = await adapter.getObjectAsync(fullPath);
+            if (!obj) {
+                await adapter.setObjectNotExistsAsync(fullPath, {
+                    type: 'state',
+                    common: {
+                        name: out.id,
+                        type: 'string',
+                        role: out.id.endsWith('json') ? 'json' : 'html',
+                        read: true,
+                        write: false,
+                        persist: true,
+                    },
+                    native: {},
+                });
+            }
+
+            const state = await adapter.getStateAsync(fullPath);
+            if (!state || state.val === null || state.val === undefined) {
+                await adapter.setStateAsync(fullPath, { val: out.id.endsWith('json') ? '{}' : '', ack: true });
+            }
+        }
+    },
+
+    /**
+     * Abonniert alle aktiven Temperatursensoren
+     */
+    async _subscribeActiveSensors() {
+        const adapter = this.adapter;
+        for (const sensor of this.sensors) {
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+            if (isActive) {
+                const stateId = `temperature.${sensor.id}.current`;
+                adapter.subscribeStates(stateId);
+            }
+        }
+
+        adapter.on('stateChange', async (id, state) => {
+            if (!state || state.ack === false) {
+                return;
+            }
+            for (const sensor of this.sensors) {
+                if (id.endsWith(`temperature.${sensor.id}.current`)) {
+                    await this._processTemperatureChange(sensor.id, state.val);
+                    break;
+                }
+            }
+        });
+    },
+
+    /**
+     * Verarbeitung einer Temperaturänderung für einen Sensor.
+     * Aktualisiert Min-, Max- und Durchschnittswerte sowie die Zusammenfassungen.
+     *
+     * @param {string} sensorId - Die ID des betroffenen Sensors (z. B. "outside" oder "flow").
+     * @param {number} newValue - Der neue gemessene Temperaturwert in °C.
+     */
+    async _processTemperatureChange(sensorId, newValue) {
+        const adapter = this.adapter;
+        const basePath = `analytics.statistics.temperature.today.${sensorId}`;
+        const now = new Date().toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
+
+        if (typeof newValue !== 'number') {
+            return;
+        }
+
+        const tempMin = (await adapter.getStateAsync(`${basePath}.temp_min`))?.val;
+        const tempMax = (await adapter.getStateAsync(`${basePath}.temp_max`))?.val;
+        const tempAvg = (await adapter.getStateAsync(`${basePath}.temp_avg`))?.val;
+        const count = (await adapter.getStateAsync(`${basePath}.data_points_count`))?.val || 0;
+
+        let newMin = tempMin;
+        let newMax = tempMax;
+        let newAvg = tempAvg;
+
+        if (tempMin === null || newValue < tempMin) {
+            newMin = newValue;
+            await adapter.setStateAsync(`${basePath}.temp_min_time`, { val: now, ack: true });
+        }
+        if (tempMax === null || newValue > tempMax) {
+            newMax = newValue;
+            await adapter.setStateAsync(`${basePath}.temp_max_time`, { val: now, ack: true });
+        }
+
+        // Durchschnitt (gleitend)
+        const newCount = count + 1;
+        newAvg = tempAvg === null ? newValue : (tempAvg * count + newValue) / newCount;
+
+        await adapter.setStateAsync(`${basePath}.temp_min`, { val: newMin, ack: true });
+        await adapter.setStateAsync(`${basePath}.temp_max`, { val: newMax, ack: true });
+        await adapter.setStateAsync(`${basePath}.temp_avg`, { val: Math.round(newAvg * 100) / 100, ack: true });
+        await adapter.setStateAsync(`${basePath}.data_points_count`, { val: newCount, ack: true });
+        await adapter.setStateAsync(`${basePath}.last_update`, { val: now, ack: true });
+
+        // Summary aktualisieren
+        const summary = {
+            temp_min: newMin,
+            temp_max: newMax,
+            temp_avg: Math.round(newAvg * 100) / 100,
+            updated: now,
+        };
+        await adapter.setStateAsync(`${basePath}.summary_json`, { val: JSON.stringify(summary), ack: true });
+        await adapter.setStateAsync(`${basePath}.summary_html`, {
+            val: `<div><b>Min:</b> ${newMin} °C / <b>Max:</b> ${newMax} °C / <b>Ø:</b> ${Math.round(newAvg * 100) / 100} °C</div>`,
+            ack: true,
+        });
+
+        await this._updateOverallSummary();
+    },
+
+    /**
+     * Gesamt-HTML/JSON-Ausgabe aktualisieren
+     */
+    async _updateOverallSummary() {
+        const adapter = this.adapter;
+        const allData = [];
+
+        for (const sensor of this.sensors) {
+            const active = (await adapter.getStateAsync(`temperature.${sensor.id}.active`))?.val === true;
+            if (!active) {
+                allData.push({ name: sensor.name, status: 'kein Sensor aktiv' });
+                continue;
+            }
+
+            const min = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_min`))
+                ?.val;
+            const max = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_max`))
+                ?.val;
+            const avg = (await adapter.getStateAsync(`analytics.statistics.temperature.today.${sensor.id}.temp_avg`))
+                ?.val;
+
+            allData.push({ name: sensor.name, min, max, avg });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+            val: JSON.stringify(allData),
+            ack: true,
+        });
+
+        let html = '<table style="width:100%;border-collapse:collapse;">';
+        html += '<tr><th style="text-align:left;">Sensor</th><th>Min</th><th>Max</th><th>Ø</th></tr>';
+        for (const entry of allData) {
+            html += `<tr><td>${entry.name}</td><td>${entry.min ?? '-'}</td><td>${entry.max ?? '-'}</td><td>${entry.avg ?? '-'}</td></tr>`;
+        }
+        html += '</table>';
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+            val: html,
+            ack: true,
+        });
+    },
+
+    /**
+     * Mitternacht-Reset planen
+     */
+    async _scheduleMidnightReset() {
+        const adapter = this.adapter;
+        if (this.midnightTimer) {
+            clearTimeout(this.midnightTimer);
+        }
+
+        const now = new Date();
+        const nextMidnight = new Date(now);
+        nextMidnight.setHours(24, 0, 5, 0);
+        const msUntilMidnight = nextMidnight.getTime() - now.getTime();
+
+        this.midnightTimer = setTimeout(async () => {
+            await this._resetDailyTemperatureStats();
+            await this._scheduleMidnightReset();
+        }, msUntilMidnight);
+
+        adapter.log.debug(
+            `statisticsHelper: Mitternacht-Reset geplant in ${Math.round(msUntilMidnight / 60000)} Minuten.`,
+        );
+    },
+
+    /**
+     * Tagesstatistik zurücksetzen
+     */
+    async _resetDailyTemperatureStats() {
+        const adapter = this.adapter;
+        adapter.log.info('statisticsHelper: Tagesstatistik wird zurückgesetzt.');
+
+        const resetDate = new Date().toISOString().slice(0, 19).replace('T', ' ');
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
+            const activeState = `temperature.${sensor.id}.active`;
+            const isActive = (await adapter.getStateAsync(activeState))?.val === true;
+
+            const summaryJsonPath = `${basePath}.summary_json`;
+            const summaryHtmlPath = `${basePath}.summary_html`;
+
+            if (!isActive) {
+                await adapter.setStateAsync(summaryJsonPath, {
+                    val: JSON.stringify({ status: 'kein Sensor aktiv' }),
+                    ack: true,
+                });
+                await adapter.setStateAsync(summaryHtmlPath, {
+                    val: '<div style="color:gray;">kein Sensor aktiv</div>',
+                    ack: true,
+                });
+                continue;
+            }
+
+            const stateList = [
+                'temp_min',
+                'temp_max',
+                'temp_min_time',
+                'temp_max_time',
+                'temp_avg',
+                'data_points_count',
+                'last_update',
+            ];
+
+            for (const state of stateList) {
+                const fullPath = `${basePath}.${state}`;
+                let defValue = null;
+                if (state.includes('time')) {
+                    defValue = '';
+                }
+                if (state === 'data_points_count') {
+                    defValue = 0;
+                }
+                if (state === 'last_update') {
+                    defValue = resetDate;
+                }
+                await adapter.setStateAsync(fullPath, { val: defValue, ack: true });
+            }
+
+            await adapter.setStateAsync(summaryJsonPath, {
+                val: JSON.stringify({ date_reset: resetDate, status: 'Tageswerte zurückgesetzt' }),
+                ack: true,
+            });
+            await adapter.setStateAsync(summaryHtmlPath, {
+                val: `<div style="color:gray;">Tageswerte zurückgesetzt (${resetDate})</div>`,
+                ack: true,
+            });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+            val: '{}',
+            ack: true,
+        });
+        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+            val: '',
+            ack: true,
+        });
+
+        adapter.log.debug('statisticsHelper: Tagesstatistik zurückgesetzt.');
+    },
+
+    cleanup() {
+        if (this.midnightTimer) {
+            clearTimeout(this.midnightTimer);
+        }
+    },
+};
+
+module.exports = statisticsHelper;

package/lib/stateDefinitions/controlStates.js

@@ -26,43 +26,6 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // Channel: control.season
-        await adapter.setObjectNotExistsAsync('control.season', {
-            type: 'channel',
-            common: {
-                name: 'Saisonsteuerung',
-                desc: 'Steuerung der aktiven Poolsaison und saisonabhängiger Funktionen',
-            },
-            native: {},
-        });
-
-        // State: control.season.active (mit Persist-Schutz)
-        await adapter.setObjectNotExistsAsync('control.season.active', {
-            type: 'state',
-            common: {
-                name: 'Poolsaison aktiv',
-                desc: 'Zeigt an, ob die Poolsaison aktiv ist (steuerbar über VIS oder Blockly)',
-                type: 'boolean',
-                role: 'switch',
-                read: true,
-                write: true,
-                def: false,
-                persist: true, // dauerhaft speichern
-            },
-            native: {},
-        });
-
-        const existingSeasonActive = await adapter.getStateAsync('control.season.active');
-        if (
-            existingSeasonActive === null ||
-            existingSeasonActive.val === null ||
-            existingSeasonActive.val === undefined
-        ) {
-            const cfgValue = !!adapter.config.season_active;
-            await adapter.setStateAsync('control.season.active', { val: cfgValue, ack: true });
-            adapter.log.debug(`[controlStates] State control.season.active initialisiert mit Wert: ${cfgValue}`);
-        }
-
         // ---------------------------------------------------------------------
         // Channel: control.pump
         await adapter.setObjectNotExistsAsync('control.pump', {