iobroker.poolcontrol 0.4.0 → 0.5.0

package/README.md

@@ -121,6 +121,14 @@ Funktionen können sich ändern – bitte regelmäßig den Changelog beachten.
 ## Changelog
 ### **WORK IN PROGRESS**
 
+## v0.5.0 (2025-10-28)
+- Erweiterung der Temperaturstatistik um Wochen- und Monatsauswertung  
+  (`analytics.statistics.temperature.week` / `.month`)
+- Eigenständige, eventbasierte Helper für Woche und Monat
+- Persistente Datenpunkte mit automatischen JSON- und HTML-Zusammenfassungen
+- Vorbereitung für zukünftige Erweiterungen (Saison- und Jahresstatistik)
+
+
 ### **0.4.0 (26.10.2025)**
 
 **Neue Funktionen**

package/io-package.json

@@ -1,8 +1,20 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "news": {
+      "0.5.0": {
+        "en": "Added weekly and monthly temperature statistics under analytics.statistics.temperature.week and analytics.statistics.temperature.month with automatic summaries, independent helpers and persistent data points.",
+        "de": "Wöchentliche und monatliche Temperaturstatistiken unter analytics.statistics.temperature.week und analytics.statistics.temperature.month hinzugefügt – mit automatischen Zusammenfassungen, unabhängigen Helpern und persistenten Datenpunkten.",
+        "ru": "Добавлена еженедельная и ежемесячная статистика температуры в analytics.statistics.temperature.week и analytics.statistics.temperature.month с автоматическими сводками, независимыми помощниками и постоянными точками данных.",
+        "fr": "Ajout des statistiques de température hebdomadaires et mensuelles sous analytics.statistics.temperature.week et analytics.statistics.temperature.month avec résumés automatiques, helpers indépendants et points de données persistants.",
+        "it": "Aggiunte statistiche settimanali e mensili della temperatura in analytics.statistics.temperature.week e analytics.statistics.temperature.month con riepiloghi automatici, helper indipendenti e punti dati persistenti.",
+        "es": "Se añadieron estadísticas semanales y mensuales de temperatura en analytics.statistics.temperature.week y analytics.statistics.temperature.month con resúmenes automáticos, ayudantes independientes y puntos de datos persistentes.",
+        "nl": "Wekelijkse en maandelijkse temperatuurstatistieken toegevoegd onder analytics.statistics.temperature.week en analytics.statistics.temperature.month met automatische samenvattingen, onafhankelijke helpers en persistente gegevenspunten.",
+        "pl": "Dodano tygodniowe i miesięczne statystyki temperatury w analytics.statistics.temperature.week i analytics.statistics.temperature.month z automatycznymi podsumowaniami, niezależnymi pomocnikami i trwałymi punktami danych.",
+        "uk": "Додано щотижневу та щомісячну статистику температури в analytics.statistics.temperature.week та analytics.statistics.temperature.month з автоматичними зведеннями, незалежними помічниками та постійними точками даних.",
+        "zh-cn": "在 analytics.statistics.temperature.week 和 analytics.statistics.temperature.month 中添加了每周和每月温度统计，具有自动摘要、独立助手和持久数据点。"
+      },
       "0.4.0": {
         "en": "Added daily temperature statistics under analytics.statistics.temperature.today with automatic min/max/average tracking, JSON and HTML summaries, and midnight reset logic.",
         "de": "Tägliche Temperaturstatistik unter analytics.statistics.temperature.today hinzugefügt mit automatischer Erfassung von Min-/Max-/Durchschnittswerten, JSON- und HTML-Zusammenfassungen sowie Mitternachts-Reset.",
@@ -52,19 +64,6 @@
         "es": "Recordatorio automático de contralavado añadido con notificaciones de voz y registro.",
         "pl": "Dodano automatyczne przypomnienie o płukaniu wstecznym z powiadomieniami głosowymi i dziennikiem.",
         "zh-cn": "添加了带语音和日志通知的自动反冲洗提醒。"
-      },
-      "0.2.1": {
-       "en": "Fixed the issue with invisible states for speech control and added proper internal variable handling.",
-       "de": "Behebung des Problems mit unsichtbaren States für die Sprachsteuerung und hinzugefügte korrekte Handhabung interner Variablen.",
-       "ru": "Исправлена проблема с невидимыми состояниями для управления речью и добавлена правильная обработка внутренних переменных.",
-       "pt": "Corrigido o problema com estados invisíveis para controle de fala e adicionada a manipulação adequada de variáveis internas.",
-       "nl": "Het probleem met onzichtbare toestanden voor spraakbesturing is opgelost en de juiste verwerking van interne variabelen toegevoegd.",
-       "fr": "Correction du problème des états invisibles pour le contrôle vocal et ajout d'un traitement correct des variables internes.",
-       "it": "Risolto il problema con gli stati invisibili per il controllo vocale e aggiunto un corretto trattamento delle variabili interne.",
-       "es": "Se solucionó el problema con los estados invisibles para el control de voz y se añadió el manejo adecuado de las variables internas.",
-       "pl": "Naprawiono problem z niewidzialnymi stanami dla kontroli głosowej i dodano prawidłowe przetwarzanie zmiennych wewnętrznych.",
-       "uk": "Виправлено проблему з невидимими станами для керування голосом та додано правильну обробку внутрішніх змінних.",
-       "zh-cn": "修复了语音控制的隐形状态问题，并添加了正确的内部变量处理。"
       }
 	},
     "titleLang": {

package/lib/helpers/pumpHelper.js

@@ -118,6 +118,13 @@ const pumpHelper = {
         if (this.deviceId && id === this.deviceId) {
             const val = !!state.val;
             const current = (await this.adapter.getStateAsync('pump.pump_switch'))?.val;
+
+            // NEU: Filter gegen zyklische Fremdmeldungen ohne echten Zustandswechsel
+            if (current === val) {
+                this.adapter.log.debug('[pumpHelper] Fremd-State meldet identischen Wert – ignoriert.');
+                return;
+            }
+
             if (current !== val) {
                 await this.adapter.setStateAsync('pump.pump_switch', { val, ack: true });
                 await this._updateStatus();

package/lib/helpers/statisticsHelper.js

@@ -64,14 +64,9 @@ const statisticsHelper = {
             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,
-                });
+                // Leere JSONs vorbereiten, damit spätere Temperaturwerte sie befüllen können
+                await adapter.setStateAsync(summaryJsonPath, { val: '[]', ack: true });
+                await adapter.setStateAsync(summaryHtmlPath, { val: '', ack: true });
                 continue;
             }
 
@@ -196,6 +191,9 @@ const statisticsHelper = {
             return;
         }
 
+        // NEU: Rundung auf 1 Nachkommastelle
+        newValue = Math.round(newValue * 10) / 10;
+
         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;
@@ -218,6 +216,11 @@ const statisticsHelper = {
         const newCount = count + 1;
         newAvg = tempAvg === null ? newValue : (tempAvg * count + newValue) / newCount;
 
+        // NEU: Alle Temperaturwerte auf 1 Nachkommastelle runden
+        newMin = Math.round(newMin * 10) / 10;
+        newMax = Math.round(newMax * 10) / 10;
+        newAvg = Math.round(newAvg * 10) / 10;
+
         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 });
@@ -225,15 +228,17 @@ const statisticsHelper = {
         await adapter.setStateAsync(`${basePath}.last_update`, { val: now, ack: true });
 
         // Summary aktualisieren
+        // NEU: Zusammenfassung mit gerundeten Werten (1 Nachkommastelle)
         const summary = {
             temp_min: newMin,
             temp_max: newMax,
-            temp_avg: Math.round(newAvg * 100) / 100,
+            temp_avg: newAvg,
             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>`,
+            // NEU: HTML-Ausgabe mit gerundeten Werten
+            val: `<div><b>Min:</b> ${newMin} °C / <b>Max:</b> ${newMax} °C / <b>Ø:</b> ${newAvg} °C</div>`,
             ack: true,
         });
 
@@ -241,45 +246,96 @@ const statisticsHelper = {
     },
 
     /**
-     * Gesamt-HTML/JSON-Ausgabe aktualisieren
+     * Gesamt-HTML/JSON-Ausgabe aktualisieren (Endgültige Version)
+     * Liest die fertigen summary_json-Werte aller aktiven Sensoren aus
+     * und erstellt daraus eine zusammengefasste HTML- und JSON-Ausgabe.
      */
     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;
+        try {
+            // Alle Sensoren durchlaufen
+            for (const sensor of this.sensors) {
+                // const isActive = (await adapter.getStateAsync(`temperature.${sensor.id}.active`))?.val === true;
+                // if (!isActive) continue;
+
+                // Fertige Einzel-Summary des Sensors abrufen
+                const summaryState = await adapter.getStateAsync(
+                    `analytics.statistics.temperature.today.${sensor.id}.summary_json`,
+                );
+
+                if (!summaryState || !summaryState.val) {
+                    continue;
+                }
+
+                // JSON-Inhalt parsen
+                let parsed;
+                try {
+                    parsed = JSON.parse(summaryState.val);
+                } catch {
+                    continue;
+                }
+
+                const min = parsed.temp_min;
+                const max = parsed.temp_max;
+                const avg = parsed.temp_avg;
+
+                if (min == null && max == null && avg == null) {
+                    continue;
+                }
+
+                // Werte runden
+                const rMin = typeof min === 'number' ? Math.round(min * 10) / 10 : min;
+                const rMax = typeof max === 'number' ? Math.round(max * 10) / 10 : max;
+                const rAvg = typeof avg === 'number' ? Math.round(avg * 10) / 10 : avg;
+
+                allData.push({
+                    name: sensor.name,
+                    min: rMin,
+                    max: rMax,
+                    avg: rAvg,
+                });
             }
 
-            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;
+            // Wenn noch keine Daten vorliegen → leer lassen
+            if (allData.length === 0) {
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+                    val: '[]',
+                    ack: true,
+                });
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+                    val: '',
+                    ack: true,
+                });
+                return;
+            }
 
-            allData.push({ name: sensor.name, min, max, avg });
-        }
+            // JSON-Ausgabe erstellen
+            const jsonOutput = JSON.stringify(allData);
 
-        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
-            val: JSON.stringify(allData),
-            ack: true,
-        });
+            // HTML-Ausgabe erstellen
+            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>';
 
-        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>';
+            // States setzen (auch bei gleichen Werten → Timestamp aktualisieren)
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_json', {
+                val: jsonOutput,
+                ack: true,
+            });
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
+                val: html,
+                ack: true,
+            });
 
-        await adapter.setStateAsync('analytics.statistics.temperature.today.outputs.summary_all_html', {
-            val: html,
-            ack: true,
-        });
+            adapter.log.debug('statisticsHelper: Gesamtzusammenfassung (Summary All) erfolgreich aktualisiert.');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelper: Fehler bei Gesamtzusammenfassung: ${err.message}`);
+        }
     },
 
     /**

package/lib/helpers/statisticsHelperMonth.js

@@ -0,0 +1,417 @@
+'use strict';
+
+/**
+ * statisticsHelperMonth.js
+ * ------------------------
+ * Vollständige Steuerung der Monatsstatistik (Temperatur)
+ * im Bereich analytics.statistics.temperature.month.*
+ *
+ * - Erkennt aktive Sensoren anhand temperature.<sensor>.active
+ * - Reagiert eventbasiert auf Änderungen der Temperaturwerte
+ * - Berechnet laufend Min/Max/Durchschnitt über 30 Tage
+ * - Aktualisiert JSON- und HTML-Ausgaben (pro Sensor & gesamt)
+ * - Führt automatischen Monats-Reset (1. Tag des Monats 00:05 Uhr) durch
+ *
+ * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz
+ */
+
+const statisticsHelperMonth = {
+    adapter: null,
+    monthResetTimer: 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('statisticsHelperMonth: Initialisierung gestartet.');
+
+        try {
+            await this._createTemperatureStatistics();
+            await this._subscribeActiveSensors();
+            await this._scheduleMonthReset();
+            adapter.log.debug('statisticsHelperMonth: Initialisierung abgeschlossen (Sensorüberwachung aktiv).');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelperMonth: 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.month.${sensor.id}`;
+            await adapter.setObjectNotExistsAsync(basePath, {
+                type: 'channel',
+                common: { name: `${sensor.name} (Monatsstatistik)` },
+                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: '[]', ack: true });
+                await adapter.setStateAsync(summaryHtmlPath, { val: '', 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.month.outputs';
+        await adapter.setObjectNotExistsAsync(outputBase, {
+            type: 'channel',
+            common: { name: 'Gesamtausgaben (alle Sensoren – Monat)' },
+            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.
+     *
+     * @param {string} sensorId - ID des Sensors
+     * @param {number} newValue - Neuer Messwert in °C
+     */
+    async _processTemperatureChange(sensorId, newValue) {
+        const adapter = this.adapter;
+        const basePath = `analytics.statistics.temperature.month.${sensorId}`;
+        const now = `${new Date().toLocaleDateString('de-DE', {
+            day: '2-digit',
+            month: '2-digit',
+        })} ${new Date().toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })}`;
+
+        if (typeof newValue !== 'number') {
+            return;
+        }
+
+        newValue = Math.round(newValue * 10) / 10;
+
+        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 });
+        }
+
+        const newCount = count + 1;
+        newAvg = tempAvg === null ? newValue : (tempAvg * count + newValue) / newCount;
+
+        newMin = Math.round(newMin * 10) / 10;
+        newMax = Math.round(newMax * 10) / 10;
+        newAvg = Math.round(newAvg * 10) / 10;
+
+        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 });
+
+        const summary = {
+            temp_min: newMin,
+            temp_max: newMax,
+            temp_avg: newAvg,
+            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> ${newAvg} °C</div>`,
+            ack: true,
+        });
+
+        await this._updateOverallSummary();
+    },
+
+    /**
+     * Gesamtzusammenfassung (JSON + HTML)
+     */
+    async _updateOverallSummary() {
+        const adapter = this.adapter;
+        const allData = [];
+
+        try {
+            for (const sensor of this.sensors) {
+                const summaryState = await adapter.getStateAsync(
+                    `analytics.statistics.temperature.month.${sensor.id}.summary_json`,
+                );
+                if (!summaryState || !summaryState.val) {
+                    continue;
+                }
+
+                let parsed;
+                try {
+                    parsed = JSON.parse(summaryState.val);
+                } catch {
+                    continue;
+                }
+
+                const { temp_min: min, temp_max: max, temp_avg: avg } = parsed;
+                if (min == null && max == null && avg == null) {
+                    continue;
+                }
+
+                const rMin = typeof min === 'number' ? Math.round(min * 10) / 10 : min;
+                const rMax = typeof max === 'number' ? Math.round(max * 10) / 10 : max;
+                const rAvg = typeof avg === 'number' ? Math.round(avg * 10) / 10 : avg;
+
+                allData.push({ name: sensor.name, min: rMin, max: rMax, avg: rAvg });
+            }
+
+            if (allData.length === 0) {
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.month.outputs.summary_all_json', {
+                    val: '[]',
+                    ack: true,
+                });
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.month.outputs.summary_all_html', {
+                    val: '',
+                    ack: true,
+                });
+                return;
+            }
+
+            const jsonOutput = JSON.stringify(allData);
+            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.setStateChangedAsync('analytics.statistics.temperature.month.outputs.summary_all_json', {
+                val: jsonOutput,
+                ack: true,
+            });
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.month.outputs.summary_all_html', {
+                val: html,
+                ack: true,
+            });
+
+            adapter.log.debug('statisticsHelperMonth: Gesamtzusammenfassung erfolgreich aktualisiert.');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelperMonth: Fehler bei Gesamtzusammenfassung: ${err.message}`);
+        }
+    },
+
+    /**
+     * Monats-Reset planen (1. Tag des Monats 00:05 Uhr)
+     */
+    async _scheduleMonthReset() {
+        const adapter = this.adapter;
+        if (this.monthResetTimer) {
+            clearTimeout(this.monthResetTimer);
+        }
+
+        const now = new Date();
+        const nextReset = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 5, 0, 0);
+        const msUntilReset = nextReset.getTime() - now.getTime();
+
+        this.monthResetTimer = setTimeout(async () => {
+            await this._resetMonthlyTemperatureStats();
+            await this._scheduleMonthReset();
+        }, msUntilReset);
+
+        adapter.log.debug(
+            `statisticsHelperMonth: Monats-Reset geplant in ${Math.round(msUntilReset / 60000)} Minuten.`,
+        );
+    },
+
+    /**
+     * Monatsstatistik zurücksetzen
+     */
+    async _resetMonthlyTemperatureStats() {
+        const adapter = this.adapter;
+        adapter.log.info('statisticsHelperMonth: Monatsstatistik wird zurückgesetzt.');
+
+        const resetDate = new Date().toISOString().slice(0, 19).replace('T', ' ');
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.month.${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: 'Monatswerte zurückgesetzt' }),
+                ack: true,
+            });
+            await adapter.setStateAsync(summaryHtmlPath, {
+                val: `<div style="color:gray;">Monatswerte zurückgesetzt (${resetDate})</div>`,
+                ack: true,
+            });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.month.outputs.summary_all_json', {
+            val: '{}',
+            ack: true,
+        });
+        await adapter.setStateAsync('analytics.statistics.temperature.month.outputs.summary_all_html', {
+            val: '',
+            ack: true,
+        });
+
+        adapter.log.debug('statisticsHelperMonth: Monatsstatistik zurückgesetzt.');
+    },
+
+    cleanup() {
+        if (this.monthResetTimer) {
+            clearTimeout(this.monthResetTimer);
+        }
+    },
+};
+
+module.exports = statisticsHelperMonth;

package/lib/helpers/statisticsHelperWeek.js

@@ -0,0 +1,422 @@
+'use strict';
+
+/**
+ * statisticsHelperWeek.js
+ * -----------------------
+ * Vollständige Steuerung der Wochenstatistik (Temperatur)
+ * im Bereich analytics.statistics.temperature.week.*
+ *
+ * - Erkennt aktive Sensoren anhand temperature.<sensor>.active
+ * - Reagiert eventbasiert auf Änderungen der Temperaturwerte
+ * - Berechnet laufend Min/Max/Durchschnitt über 7 Tage
+ * - Aktualisiert JSON- und HTML-Ausgaben (pro Sensor & gesamt)
+ * - Führt automatischen Wochen-Reset (Sonntag 00:05 Uhr) durch
+ *
+ * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz
+ */
+
+const statisticsHelperWeek = {
+    adapter: null,
+    weekResetTimer: 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('statisticsHelperWeek: Initialisierung gestartet.');
+
+        try {
+            await this._createTemperatureStatistics();
+            await this._subscribeActiveSensors();
+            await this._scheduleWeekReset();
+            adapter.log.debug('statisticsHelperWeek: Initialisierung abgeschlossen (Sensorüberwachung aktiv).');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelperWeek: 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.week.${sensor.id}`;
+            await adapter.setObjectNotExistsAsync(basePath, {
+                type: 'channel',
+                common: { name: `${sensor.name} (Wochenstatistik)` },
+                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: '[]', ack: true });
+                await adapter.setStateAsync(summaryHtmlPath, { val: '', 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.week.outputs';
+        await adapter.setObjectNotExistsAsync(outputBase, {
+            type: 'channel',
+            common: { name: 'Gesamtausgaben (alle Sensoren – Woche)' },
+            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 Sensors (z. B. "outside", "flow", "collector" usw.)
+     * @param {number} newValue - Der neue gemessene Temperaturwert in °C
+     */
+    async _processTemperatureChange(sensorId, newValue) {
+        const adapter = this.adapter;
+        const basePath = `analytics.statistics.temperature.week.${sensorId}`;
+        const now = new Date().toLocaleString('de-DE', {
+            weekday: 'short',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+
+        if (typeof newValue !== 'number') {
+            return;
+        }
+
+        newValue = Math.round(newValue * 10) / 10;
+
+        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 });
+        }
+
+        const newCount = count + 1;
+        newAvg = tempAvg === null ? newValue : (tempAvg * count + newValue) / newCount;
+
+        newMin = Math.round(newMin * 10) / 10;
+        newMax = Math.round(newMax * 10) / 10;
+        newAvg = Math.round(newAvg * 10) / 10;
+
+        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 });
+
+        const summary = {
+            temp_min: newMin,
+            temp_max: newMax,
+            temp_avg: newAvg,
+            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> ${newAvg} °C</div>`,
+            ack: true,
+        });
+
+        await this._updateOverallSummary();
+    },
+
+    /**
+     * Gesamtzusammenfassung aller Sensoren aktualisieren
+     */
+    async _updateOverallSummary() {
+        const adapter = this.adapter;
+        const allData = [];
+
+        try {
+            for (const sensor of this.sensors) {
+                const summaryState = await adapter.getStateAsync(
+                    `analytics.statistics.temperature.week.${sensor.id}.summary_json`,
+                );
+                if (!summaryState || !summaryState.val) {
+                    continue;
+                }
+
+                let parsed;
+                try {
+                    parsed = JSON.parse(summaryState.val);
+                } catch {
+                    continue;
+                }
+
+                const { temp_min: min, temp_max: max, temp_avg: avg } = parsed;
+                if (min == null && max == null && avg == null) {
+                    continue;
+                }
+
+                const rMin = typeof min === 'number' ? Math.round(min * 10) / 10 : min;
+                const rMax = typeof max === 'number' ? Math.round(max * 10) / 10 : max;
+                const rAvg = typeof avg === 'number' ? Math.round(avg * 10) / 10 : avg;
+
+                allData.push({ name: sensor.name, min: rMin, max: rMax, avg: rAvg });
+            }
+
+            if (allData.length === 0) {
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.week.outputs.summary_all_json', {
+                    val: '[]',
+                    ack: true,
+                });
+                await adapter.setStateChangedAsync('analytics.statistics.temperature.week.outputs.summary_all_html', {
+                    val: '',
+                    ack: true,
+                });
+                return;
+            }
+
+            const jsonOutput = JSON.stringify(allData);
+
+            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.setStateChangedAsync('analytics.statistics.temperature.week.outputs.summary_all_json', {
+                val: jsonOutput,
+                ack: true,
+            });
+            await adapter.setStateChangedAsync('analytics.statistics.temperature.week.outputs.summary_all_html', {
+                val: html,
+                ack: true,
+            });
+
+            adapter.log.debug('statisticsHelperWeek: Gesamtzusammenfassung erfolgreich aktualisiert.');
+        } catch (err) {
+            adapter.log.warn(`statisticsHelperWeek: Fehler bei Gesamtzusammenfassung: ${err.message}`);
+        }
+    },
+
+    /**
+     * Wochen-Reset planen (Sonntag 00:05 Uhr)
+     */
+    async _scheduleWeekReset() {
+        const adapter = this.adapter;
+        if (this.weekResetTimer) {
+            clearTimeout(this.weekResetTimer);
+        }
+
+        const now = new Date();
+        const nextReset = new Date(now);
+        // Sonntag 00:05
+        const daysUntilSunday = (7 - now.getDay()) % 7;
+        nextReset.setDate(now.getDate() + daysUntilSunday);
+        nextReset.setHours(0, 5, 0, 0);
+
+        const msUntilReset = nextReset.getTime() - now.getTime();
+        this.weekResetTimer = setTimeout(async () => {
+            await this._resetWeeklyTemperatureStats();
+            await this._scheduleWeekReset();
+        }, msUntilReset);
+
+        adapter.log.debug(`statisticsHelperWeek: Wochen-Reset geplant in ${Math.round(msUntilReset / 60000)} Minuten.`);
+    },
+
+    /**
+     * Wochenstatistik zurücksetzen
+     */
+    async _resetWeeklyTemperatureStats() {
+        const adapter = this.adapter;
+        adapter.log.info('statisticsHelperWeek: Wochenstatistik wird zurückgesetzt.');
+
+        const resetDate = new Date().toISOString().slice(0, 19).replace('T', ' ');
+
+        for (const sensor of this.sensors) {
+            const basePath = `analytics.statistics.temperature.week.${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: 'Wochenwerte zurückgesetzt' }),
+                ack: true,
+            });
+            await adapter.setStateAsync(summaryHtmlPath, {
+                val: `<div style="color:gray;">Wochenwerte zurückgesetzt (${resetDate})</div>`,
+                ack: true,
+            });
+        }
+
+        await adapter.setStateAsync('analytics.statistics.temperature.week.outputs.summary_all_json', {
+            val: '{}',
+            ack: true,
+        });
+        await adapter.setStateAsync('analytics.statistics.temperature.week.outputs.summary_all_html', {
+            val: '',
+            ack: true,
+        });
+
+        adapter.log.debug('statisticsHelperWeek: Wochenstatistik zurückgesetzt.');
+    },
+
+    cleanup() {
+        if (this.weekResetTimer) {
+            clearTimeout(this.weekResetTimer);
+        }
+    },
+};
+
+module.exports = statisticsHelperWeek;

package/lib/helpers/timeHelper.js

@@ -68,12 +68,19 @@ const timeHelper = {
                 });
             }
 
-            // Pumpe über die echte Steckdosen-ID schalten
-            await this.adapter.setForeignStateAsync(pumpSwitchId, {
-                val: shouldRun,
-                ack: false,
-            });
-            this.adapter.log.debug(`[timeHelper] Pumpe ${shouldRun ? 'EIN' : 'AUS'} (${hhmm})`);
+            // --- NEU: nur schalten, wenn sich der Zustand wirklich ändert ---
+            const currentState = (await this.adapter.getForeignStateAsync(pumpSwitchId))?.val;
+            if (currentState !== shouldRun) {
+                await this.adapter.setForeignStateAsync(pumpSwitchId, {
+                    val: shouldRun,
+                    ack: false,
+                });
+                this.adapter.log.debug(`[timeHelper] Pumpe ${shouldRun ? 'EIN' : 'AUS'} (${hhmm})`);
+            } else {
+                this.adapter.log.debug(
+                    `[timeHelper] Keine Änderung (${hhmm}) – Zustand bleibt ${shouldRun ? 'EIN' : 'AUS'}.`,
+                );
+            }
         } catch (err) {
             this.adapter.log.warn(`[timeHelper] Fehler im Check: ${err.message}`);
         }

package/lib/stateDefinitions/statisticsStates.js

@@ -3,8 +3,11 @@
 /**
  * statisticsStates.js
  * -------------------
- * Erstellt alle States für die Tagesstatistik der Temperatursensoren.
- * Struktur: analytics.statistics.temperature.today.*
+ * Erstellt alle States für die Temperaturstatistiken.
+ * Struktur:
+ *   analytics.statistics.temperature.today.*
+ *   analytics.statistics.temperature.week.*
+ *   analytics.statistics.temperature.month.*
  *
  * - Sechs Sensorbereiche (outside, ground, surface, flow, return, collector)
  * - Je Sensor: Min/Max/Avg + Zeitstempel + JSON/HTML-Ausgabe
@@ -17,7 +20,7 @@
  * @param {ioBroker.Adapter} adapter - Instanz des ioBroker-Adapters
  */
 async function createStatisticsStates(adapter) {
-    adapter.log.debug('statisticsStates: Initialisierung der Tagesstatistik (Temperatur) gestartet.');
+    adapter.log.debug('statisticsStates: Initialisierung der Temperaturstatistiken gestartet.');
 
     // Oberstruktur
     await adapter.setObjectNotExistsAsync('analytics', {
@@ -38,9 +41,36 @@ async function createStatisticsStates(adapter) {
         native: {},
     });
 
-    await adapter.setObjectNotExistsAsync('analytics.statistics.temperature.today', {
+    // -------------------------------------------------------------
+    // 🔹 TAGESSTATISTIK
+    // -------------------------------------------------------------
+    await _createTemperatureStatsGroup(adapter, 'today', 'Tagesstatistik (Temperaturen)');
+
+    // -------------------------------------------------------------
+    // 🔹 WOCHENSTATISTIK
+    // -------------------------------------------------------------
+    await _createTemperatureStatsGroup(adapter, 'week', 'Wochenstatistik (Temperaturen)');
+
+    // -------------------------------------------------------------
+    // 🔹 MONATSSTATISTIK (NEU)
+    // -------------------------------------------------------------
+    await _createTemperatureStatsGroup(adapter, 'month', 'Monatsstatistik (Temperaturen)');
+
+    adapter.log.debug('statisticsStates: Tages-, Wochen- und Monatsstatistik (Temperatur) erfolgreich angelegt.');
+}
+
+/**
+ * Erstellt eine Temperaturstatistik-Gruppe (z. B. "today", "week" oder "month").
+ *
+ * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz
+ * @param {string} periodId - z. B. "today", "week" oder "month"
+ * @param {string} displayName - Anzeigename im Objektbaum
+ */
+async function _createTemperatureStatsGroup(adapter, periodId, displayName) {
+    const basePathRoot = `analytics.statistics.temperature.${periodId}`;
+    await adapter.setObjectNotExistsAsync(basePathRoot, {
         type: 'channel',
-        common: { name: 'Tagesstatistik (Temperaturen)' },
+        common: { name: displayName },
         native: {},
     });
 
@@ -55,11 +85,10 @@ async function createStatisticsStates(adapter) {
     ];
 
     for (const sensor of sensors) {
-        const basePath = `analytics.statistics.temperature.today.${sensor.id}`;
-
+        const basePath = `${basePathRoot}.${sensor.id}`;
         await adapter.setObjectNotExistsAsync(basePath, {
             type: 'channel',
-            common: { name: `${sensor.name} (Tagesstatistik)` },
+            common: { name: `${sensor.name} (${displayName})` },
             native: {},
         });
 
@@ -71,8 +100,18 @@ async function createStatisticsStates(adapter) {
             { id: 'temp_avg', name: 'Durchschnittstemperatur', type: 'number', role: 'value.temperature', unit: '°C' },
             { id: 'data_points_count', name: 'Anzahl Messwerte', type: 'number', role: 'value' },
             { id: 'last_update', name: 'Letzte Aktualisierung', type: 'string', role: 'value.time' },
-            { id: 'summary_json', name: 'Tageszusammenfassung (JSON)', type: 'string', role: 'json' },
-            { id: 'summary_html', name: 'Tageszusammenfassung (HTML)', type: 'string', role: 'html' },
+            {
+                id: 'summary_json',
+                name: `${displayName} (JSON)`,
+                type: 'string',
+                role: 'json',
+            },
+            {
+                id: 'summary_html',
+                name: `${displayName} (HTML)`,
+                type: 'string',
+                role: 'html',
+            },
         ];
 
         for (const def of stateDefs) {
@@ -94,7 +133,7 @@ async function createStatisticsStates(adapter) {
     }
 
     // Gesamt-Ausgabe (Outputs)
-    const outputBase = 'analytics.statistics.temperature.today.outputs';
+    const outputBase = `${basePathRoot}.outputs`;
     await adapter.setObjectNotExistsAsync(outputBase, {
         type: 'channel',
         common: { name: 'Gesamtausgaben (alle Sensoren)' },
@@ -104,12 +143,12 @@ async function createStatisticsStates(adapter) {
     const outputs = [
         {
             id: 'summary_all_json',
-            name: 'Gesamtzusammenfassung aller Sensoren (JSON)',
+            name: `Gesamtzusammenfassung aller Sensoren (${displayName}, JSON)`,
             role: 'json',
         },
         {
             id: 'summary_all_html',
-            name: 'Gesamtzusammenfassung aller Sensoren (HTML)',
+            name: `Gesamtzusammenfassung aller Sensoren (${displayName}, HTML)`,
             role: 'html',
         },
     ];
@@ -129,8 +168,6 @@ async function createStatisticsStates(adapter) {
             native: {},
         });
     }
-
-    adapter.log.debug('statisticsStates: Tagesstatistik (Temperatur) erfolgreich angelegt.');
 }
 
 module.exports = {

package/main.js

@@ -9,6 +9,8 @@ const temperatureHelper = require('./lib/helpers/temperatureHelper');
 const timeHelper = require('./lib/helpers/timeHelper');
 const runtimeHelper = require('./lib/helpers/runtimeHelper');
 const statisticsHelper = require('./lib/helpers/statisticsHelper');
+const statisticsHelperWeek = require('./lib/helpers/statisticsHelperWeek');
+const statisticsHelperMonth = require('./lib/helpers/statisticsHelperMonth');
 const pumpHelper = require('./lib/helpers/pumpHelper');
 const pumpHelper2 = require('./lib/helpers/pumpHelper2');
 const pumpHelper3 = require('./lib/helpers/pumpHelper3');
@@ -103,6 +105,8 @@ class Poolcontrol extends utils.Adapter {
         timeHelper.init(this);
         runtimeHelper.init(this);
         statisticsHelper.init(this);
+        statisticsHelperWeek.init(this);
+        statisticsHelperMonth.init(this);
         pumpHelper.init(this);
         pumpHelper2.init(this);
         pumpHelper3.init(this);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.poolcontrol",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",
@@ -30,7 +30,8 @@
     "@iobroker/testing": "^5.1.1",
     "eslint": "^9.36.0",
     "prettier": "^3.6.2",
-    "proxyquire": "^2.1.3"
+    "proxyquire": "^2.1.3",
+    "release-it": "^19.0.5"
   },
   "main": "main.js",
   "files": [
@@ -48,7 +49,8 @@
     "test:integration": "mocha test/integration.cjs --exit",
     "test": "npm run test:js && npm run test:package",
     "lint": "eslint .",
-    "translate": "translate-adapter"
+    "translate": "translate-adapter",
+    "release": "release-it"
   },
   "bugs": {
     "url": "https://github.com/DasBo1975/ioBroker.poolcontrol/issues"