iobroker.poolcontrol 0.4.0 → 0.5.1

package/lib/helpers/statisticsHelperWeek.js

@@ -0,0 +1,501 @@
+'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.');
+
+        // --- Überinstallationsschutz ---
+        try {
+            // Prüft, ob alle States vorhanden sind, und legt fehlende still neu an
+            await this._verifyStructure();
+        } catch {
+            // keine Log-Ausgabe – stiller Schutz
+        }
+
+        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 });
+
+        // Summary aktualisieren – erweitert um Datum, Zeitpunkte, Messanzahl, Name
+        const summary = {
+            name: 'Wochenstatistik',
+            week_range: this._getCurrentWeekRange(),
+            date: new Date().toISOString().slice(0, 10),
+            temp_min: newMin,
+            temp_min_time: (await adapter.getStateAsync(`${basePath}.temp_min_time`))?.val || '',
+            temp_max: newMax,
+            temp_max_time: (await adapter.getStateAsync(`${basePath}.temp_max_time`))?.val || '',
+            temp_avg: newAvg,
+            data_points_count: newCount,
+            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();
+    },
+
+    /**
+     * Gesamt-HTML/JSON-Ausgabe aktualisieren (erweiterte Version – Woche)
+     */
+    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 min = parsed.temp_min;
+                const max = parsed.temp_max;
+                const avg = parsed.temp_avg;
+                const date = parsed.date || '';
+                const minTime = parsed.temp_min_time || '';
+                const maxTime = parsed.temp_max_time || '';
+                const count = parsed.data_points_count || 0;
+
+                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({
+                    week_range: this._getCurrentWeekRange(),
+                    name: sensor.name,
+                    date,
+                    min: rMin,
+                    min_time: minTime,
+                    max: rMax,
+                    max_time: maxTime,
+                    avg: rAvg,
+                    data_points_count: count,
+                });
+            }
+
+            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, null, 2);
+
+            let html = '<table style="width:100%;border-collapse:collapse;">';
+            html +=
+                '<tr><th style="text-align:left;">Sensor</th><th>Datum</th><th>Min</th><th>Zeit</th><th>Max</th><th>Zeit</th><th>Ø</th><th>Anz.</th></tr>';
+            for (const entry of allData) {
+                html += `<tr>
+                    <td>${entry.name}</td>
+                    <td>${entry.date || '-'}</td>
+                    <td>${entry.min ?? '-'}</td>
+                    <td>${entry.min_time || '-'}</td>
+                    <td>${entry.max ?? '-'}</td>
+                    <td>${entry.max_time || '-'}</td>
+                    <td>${entry.avg ?? '-'}</td>
+                    <td>${entry.data_points_count ?? '-'}</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,
+            });
+        } catch {
+            // bewusst kein Log hier – stiller Schutz
+        }
+    },
+
+    /**
+     * 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.');
+    },
+
+    /**
+     * Stiller Überinstallationsschutz:
+     * Prüft und legt fehlende States erneut an, ohne bestehende Werte zu überschreiben.
+     */
+    async _verifyStructure() {
+        try {
+            await this._createTemperatureStatistics();
+        } catch {
+            // bewusst keine Logs – stiller Selbstschutz
+        }
+    },
+
+    /**
+     * Berechnet den Zeitraum (Start/Ende) der aktuellen Woche.
+     * Rückgabe: z. B. "27.10.2025 – 02.11.2025"
+     */
+    _getCurrentWeekRange() {
+        const today = new Date();
+
+        // Aktuellen Sonntag (nächster Wochenreset) finden
+        const nextSunday = new Date(today);
+        const day = today.getDay(); // Sonntag=0, Montag=1 …
+        const daysUntilSunday = (7 - day) % 7;
+        nextSunday.setDate(today.getDate() + daysUntilSunday);
+
+        // Wochenstart ist der Montag vor diesem Sonntag
+        const monday = new Date(nextSunday);
+        monday.setDate(nextSunday.getDate() - 6);
+
+        const fmt = d =>
+            d.toLocaleDateString('de-DE', {
+                day: '2-digit',
+                month: '2-digit',
+                year: 'numeric',
+            });
+
+        return `${fmt(monday)} – ${fmt(nextSunday)}`;
+    },
+
+    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);