iobroker.utility-monitor 1.4.6 → 1.5.0

package/lib/billingManager.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const calculator = require('./calculator');
+const { getConfigType } = require('./utils/typeMapper');
+const billingHelper = require('./utils/billingHelper');
 
 /**
  * BillingManager handles all cost calculations,
@@ -20,7 +22,7 @@ class BillingManager {
      * @param {string} type - Utility type
      */
     async updateCosts(type) {
-        const configType = this.adapter.consumptionManager.getConfigType(type);
+        const configType = getConfigType(type);
 
         // Get price and basic charge from config
         const priceKey = `${configType}Preis`;
@@ -56,7 +58,7 @@ class BillingManager {
                 const yearlyVolume = typeof yearlyVolumeState?.val === 'number' ? yearlyVolumeState.val : 0;
                 const totalM3 = yearlyVolume + adjustment;
                 const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                const zZahl = this.adapter.config.gasZahl || 0.95;
+                const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
                 yearly = calculator.convertGasM3ToKWh(totalM3, brennwert, zZahl);
             } else {
                 yearly += adjustment;
@@ -67,7 +69,6 @@ class BillingManager {
         let dailyConsumptionCost, monthlyConsumptionCost, yearlyConsumptionCost;
 
         if (htNtEnabled) {
-            // HT/NT Calculation
             const htPrice = this.adapter.config[`${configType}HtPrice`] || 0;
             const ntPrice = this.adapter.config[`${configType}NtPrice`] || 0;
 
@@ -82,48 +83,27 @@ class BillingManager {
             if (adjustment !== 0) {
                 if (type === 'gas') {
                     const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                    const zZahl = this.adapter.config.gasZahl || 0.95;
+                    const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
                     yearlyHT = Number(yearlyHT) + calculator.convertGasM3ToKWh(adjustment, brennwert, zZahl);
                 } else {
                     yearlyHT = Number(yearlyHT) + Number(adjustment);
                 }
             }
 
-            dailyConsumptionCost = Number(dailyHT) * parseFloat(htPrice) + Number(dailyNT) * parseFloat(ntPrice);
-            monthlyConsumptionCost = Number(monthlyHT) * parseFloat(htPrice) + Number(monthlyNT) * parseFloat(ntPrice);
-            yearlyConsumptionCost = Number(yearlyHT) * parseFloat(htPrice) + Number(yearlyNT) * parseFloat(ntPrice);
+            const dailyRes = billingHelper.calculateHTNTCosts(dailyHT, htPrice, dailyNT, ntPrice);
+            const monthlyRes = billingHelper.calculateHTNTCosts(monthlyHT, htPrice, monthlyNT, ntPrice);
+            const yearlyRes = billingHelper.calculateHTNTCosts(yearlyHT, htPrice, yearlyNT, ntPrice);
 
-            // Update HT/NT specific cost states
-            await this.adapter.setStateAsync(
-                `${type}.costs.dailyHT`,
-                calculator.roundToDecimals(Number(dailyHT) * parseFloat(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.dailyNT`,
-                calculator.roundToDecimals(Number(dailyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.monthlyHT`,
-                calculator.roundToDecimals(Number(monthlyHT) * calculator.ensureNumber(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.monthlyNT`,
-                calculator.roundToDecimals(Number(monthlyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.yearlyHT`,
-                calculator.roundToDecimals(Number(yearlyHT) * calculator.ensureNumber(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.yearlyNT`,
-                calculator.roundToDecimals(Number(yearlyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
+            dailyConsumptionCost = dailyRes.total;
+            monthlyConsumptionCost = monthlyRes.total;
+            yearlyConsumptionCost = yearlyRes.total;
+
+            await this.adapter.setStateAsync(`${type}.costs.dailyHT`, dailyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.dailyNT`, dailyRes.ntCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.monthlyHT`, monthlyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.monthlyNT`, monthlyRes.ntCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.yearlyHT`, yearlyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.yearlyNT`, yearlyRes.ntCosts, true);
         } else {
             dailyConsumptionCost = calculator.calculateCost(daily, price);
             monthlyConsumptionCost = calculator.calculateCost(monthly, price);
@@ -131,40 +111,18 @@ class BillingManager {
         }
 
         // Basic charge calculation
-        const contractStartKey = `${configType}ContractStart`;
-        const contractStartDate = this.adapter.config[contractStartKey];
-
-        let monthsSinceContract;
-        if (contractStartDate) {
-            const contractStart = calculator.parseGermanDate(contractStartDate);
-            if (contractStart && !isNaN(contractStart.getTime())) {
-                const now = new Date();
-                const yDiff = now.getFullYear() - contractStart.getFullYear();
-                const mDiff = now.getMonth() - contractStart.getMonth();
-                monthsSinceContract = Math.max(1, yDiff * 12 + mDiff + 1);
-            }
-        }
-
-        if (monthsSinceContract === undefined) {
-            const yearStartState = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
-            const yearStartTime = typeof yearStartState?.val === 'number' ? yearStartState.val : Date.now();
-            const yearStart = new Date(yearStartTime);
-            const now = new Date();
-            const yDiff = now.getFullYear() - yearStart.getFullYear();
-            const mDiff = now.getMonth() - yearStart.getMonth();
-            monthsSinceContract = Math.max(1, yDiff * 12 + mDiff + 1);
-        }
-
-        // Calculate accumulated basic charge (monthly fee × months)
-        const basicChargeAccumulated = basicChargeMonthly * monthsSinceContract;
+        const monthsSinceContract = await this._calculateMonthsSinceStart(type, configType);
 
-        // Jahresgebühr ist ein FIXER Wert pro Jahr (z.B. 60€)
-        // NICHT pro-rata nach Monaten/Tagen berechnen!
-        const annualFeeAccumulated = annualFeePerYear;
-
-        const totalYearlyCost = yearlyConsumptionCost + basicChargeAccumulated + annualFeeAccumulated;
+        const charges = billingHelper.calculateAccumulatedCharges(
+            basicChargeMonthly,
+            annualFeePerYear,
+            monthsSinceContract,
+        );
+        const basicChargeAccumulated = charges.basicCharge;
+        const annualFeeAccumulated = charges.annualFee;
+        const totalYearlyCost = yearlyConsumptionCost + charges.total;
 
-        // Update states
+        // Update basic charge states
         await this.adapter.setStateAsync(
             `${type}.costs.daily`,
             calculator.roundToDecimals(dailyConsumptionCost, 2),
@@ -185,32 +143,39 @@ class BillingManager {
             calculator.roundToDecimals(totalYearlyCost, 2),
             true,
         );
-        await this.adapter.setStateAsync(
-            `${type}.costs.annualFee`,
-            calculator.roundToDecimals(annualFeeAccumulated, 2),
-            true,
-        );
-        // basicCharge enthält NUR die monatliche Grundgebühr (akkumuliert)
-        // Jahresgebühr ist separat in annualFee
-        await this.adapter.setStateAsync(
-            `${type}.costs.basicCharge`,
-            calculator.roundToDecimals(basicChargeAccumulated, 2),
-            true,
-        );
+        await this.adapter.setStateAsync(`${type}.costs.annualFee`, annualFeeAccumulated, true);
+        await this.adapter.setStateAsync(`${type}.costs.basicCharge`, basicChargeAccumulated, true);
 
-        // Abschlag
+        // Abschlag / Installment
         const abschlagKey = `${configType}Abschlag`;
         const monthlyAbschlag = this.adapter.config[abschlagKey] || 0;
 
-        if (monthlyAbschlag > 0) {
-            const paidTotal = monthlyAbschlag * monthsSinceContract;
-            const balance = totalYearlyCost - paidTotal;
-            await this.adapter.setStateAsync(`${type}.costs.paidTotal`, calculator.roundToDecimals(paidTotal, 2), true);
-            await this.adapter.setStateAsync(`${type}.costs.balance`, calculator.roundToDecimals(balance, 2), true);
-        } else {
-            await this.adapter.setStateAsync(`${type}.costs.paidTotal`, 0, true);
-            await this.adapter.setStateAsync(`${type}.costs.balance`, 0, true);
+        const balanceRes = billingHelper.calculateBalance(monthlyAbschlag, monthsSinceContract, totalYearlyCost);
+        await this.adapter.setStateAsync(`${type}.costs.paidTotal`, balanceRes.paid, true);
+        await this.adapter.setStateAsync(`${type}.costs.balance`, balanceRes.balance, true);
+    }
+
+    /**
+     * Calculates months since contract or year start
+     *
+     * @param {string} type - Utility type
+     * @param {string} configType - Mapped config type
+     * @returns {Promise<number>} Number of months (at least 1)
+     */
+    async _calculateMonthsSinceStart(type, configType) {
+        const contractStartDate = this.adapter.config[`${configType}ContractStart`];
+        let startDate;
+
+        if (contractStartDate) {
+            startDate = calculator.parseGermanDate(contractStartDate);
         }
+
+        if (!startDate || isNaN(startDate.getTime())) {
+            const lastYearStart = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
+            startDate = new Date(lastYearStart?.val || Date.now());
+        }
+
+        return Math.max(1, calculator.getMonthsDifference(startDate, new Date()) + 1);
     }
 
     /**
@@ -232,7 +197,7 @@ class BillingManager {
             return;
         }
 
-        const configType = this.adapter.consumptionManager.getConfigType(type);
+        const configType = getConfigType(type);
         const contractStartKey = `${configType}ContractStart`;
         const contractStart = this.adapter.config[contractStartKey];
 
@@ -548,7 +513,7 @@ class BillingManager {
         const types = ['gas', 'water', 'electricity', 'pv'];
 
         for (const type of types) {
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             if (!this.adapter.config[`${configType}Aktiv`]) {
                 continue;
             }
@@ -560,34 +525,92 @@ class BillingManager {
 
             const nowDate = new Date(now);
 
-            // DAILY RESET: All meters reset together at midnight
-            const lastDayStart = await this.adapter.getStateAsync(`${type}.statistics.lastDayStart`);
+            // Get all meters for this type (needed for all reset checks)
+            const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+
+            if (meters.length === 0) {
+                continue;
+            }
+
+            const firstMeter = meters[0];
+            const basePath = `${type}.${firstMeter.name}`;
+
+            // Reset time window: 23:59 (last minute of the day)
+            // This ensures History adapter sees clean day boundaries
+            const isResetTime = nowDate.getHours() === 23 && nowDate.getMinutes() === 59;
+
+            // Helper: Check if timestamp is from today
+            const todayStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate()).getTime();
+            const isFromToday = timestamp => timestamp >= todayStart;
+
+            // DAILY RESET: Trigger at 23:59 if today's reset hasn't happened yet
+            const lastDayStart = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayStart`);
             if (lastDayStart?.val) {
-                const lastDay = new Date(lastDayStart.val);
-                if (nowDate.getDate() !== lastDay.getDate()) {
+                const lastResetTime = lastDayStart.val;
+                const alreadyResetToday = isFromToday(lastResetTime);
+
+                // Reset at 23:59 if not yet reset today, OR catch up if we missed it (e.g. adapter was offline)
+                if (isResetTime && !alreadyResetToday) {
+                    this.adapter.log.info(`Täglicher Reset für ${type} um 23:59`);
+                    await this.resetDailyCounters(type);
+                } else if (!alreadyResetToday && nowDate.getTime() > lastResetTime + 24 * 60 * 60 * 1000) {
+                    // Catch-up: More than 24h since last reset (adapter was offline)
+                    this.adapter.log.info(`Täglicher Reset für ${type} (Nachholung - Adapter war offline)`);
                     await this.resetDailyCounters(type);
                 }
             }
 
-            // MONTHLY RESET: All meters reset together on 1st of month
-            const lastMonthStart = await this.adapter.getStateAsync(`${type}.statistics.lastMonthStart`);
-            if (lastMonthStart?.val) {
-                const lastMonth = new Date(lastMonthStart.val);
-                if (nowDate.getMonth() !== lastMonth.getMonth()) {
-                    await this.resetMonthlyCounters(type);
+            // WEEKLY RESET: Trigger at 23:59 on Sunday if this week's reset hasn't happened yet
+            const lastWeekStart = await this.adapter.getStateAsync(`${basePath}.statistics.lastWeekStart`);
+            if (lastWeekStart?.val) {
+                const lastWeekTime = lastWeekStart.val;
+                const isSunday = nowDate.getDay() === 0; // 0 = Sunday
+
+                // Check if we're in a new week (more than 6 days since last reset)
+                const daysSinceLastReset = (nowDate.getTime() - lastWeekTime) / (24 * 60 * 60 * 1000);
+                const needsWeeklyReset = daysSinceLastReset >= 6;
+
+                if (isSunday && isResetTime && needsWeeklyReset) {
+                    this.adapter.log.info(`Wöchentlicher Reset für ${type} um 23:59`);
+                    await this.resetWeeklyCounters(type);
+                } else if (needsWeeklyReset && daysSinceLastReset > 7) {
+                    // Catch-up: More than 7 days since last reset
+                    this.adapter.log.info(`Wöchentlicher Reset für ${type} (Nachholung)`);
+                    await this.resetWeeklyCounters(type);
+                }
+            }
+
+            // MONTHLY RESET: Trigger at 23:59 on last day of month
+            if (meters.length > 0) {
+                const lastMonthStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastMonthStart`);
+                if (lastMonthStartState?.val) {
+                    const lastMonthTime = lastMonthStartState.val;
+                    const lastMonthDate = new Date(lastMonthTime);
+                    const isLastDayOfMonth =
+                        new Date(nowDate.getFullYear(), nowDate.getMonth() + 1, 0).getDate() === nowDate.getDate();
+                    const monthChanged = nowDate.getMonth() !== lastMonthDate.getMonth();
+
+                    if (isLastDayOfMonth && isResetTime && monthChanged) {
+                        this.adapter.log.info(`Monatlicher Reset für ${type} um 23:59`);
+                        await this.resetMonthlyCounters(type);
+                    } else if (monthChanged && nowDate.getDate() > 1) {
+                        // Catch-up: We're past the 1st of a new month and haven't reset yet
+                        this.adapter.log.info(`Monatlicher Reset für ${type} (Nachholung)`);
+                        await this.resetMonthlyCounters(type);
+                    }
                 }
             }
 
             // YEARLY RESET: Each meter resets individually based on ITS contract date
-            const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+            // Trigger at 23:59 on the day BEFORE the anniversary (so the new year starts fresh)
             for (const meter of meters) {
-                const basePath = `${type}.${meter.name}`;
-                const lastYearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
+                const meterBasePath = `${type}.${meter.name}`;
+                const lastYearStartState = await this.adapter.getStateAsync(
+                    `${meterBasePath}.statistics.lastYearStart`,
+                );
 
                 if (lastYearStartState?.val) {
                     const lastYearStartDate = new Date(lastYearStartState.val);
-
-                    // Get contract date for THIS specific meter (all meters have config.contractStart)
                     const contractStartDate = meter.config?.contractStart;
 
                     if (contractStartDate) {
@@ -595,30 +618,64 @@ class BillingManager {
                         if (contractStart) {
                             const annMonth = contractStart.getMonth();
                             const annDay = contractStart.getDate();
-                            const isPast =
+
+                            // Check if today is the day BEFORE the anniversary (for 23:59 reset)
+                            // or if we're past it and haven't reset yet (catch-up)
+                            const anniversaryThisYear = new Date(nowDate.getFullYear(), annMonth, annDay);
+                            const dayBeforeAnniversary = new Date(anniversaryThisYear.getTime() - 24 * 60 * 60 * 1000);
+
+                            const isTodayDayBefore =
+                                nowDate.getMonth() === dayBeforeAnniversary.getMonth() &&
+                                nowDate.getDate() === dayBeforeAnniversary.getDate();
+
+                            const isPastAnniversary =
                                 nowDate.getMonth() > annMonth ||
                                 (nowDate.getMonth() === annMonth && nowDate.getDate() >= annDay);
 
-                            if (isPast && lastYearStartDate.getFullYear() !== nowDate.getFullYear()) {
+                            const needsReset = lastYearStartDate.getFullYear() < nowDate.getFullYear();
+
+                            if (isTodayDayBefore && isResetTime && needsReset) {
                                 this.adapter.log.info(
-                                    `Yearly reset for ${basePath} (contract anniversary: ${contractStartDate})`,
+                                    `Yearly reset for ${meterBasePath} um 23:59 (Vertragsjubiläum morgen: ${contractStartDate})`,
+                                );
+                                await this.resetYearlyCountersForMeter(type, meter);
+
+                                if (meters.length > 1) {
+                                    await this.adapter.multiMeterManager.updateTotalCosts(type);
+                                }
+                            } else if (isPastAnniversary && needsReset) {
+                                // Catch-up: Anniversary has passed but we haven't reset yet
+                                this.adapter.log.info(
+                                    `Yearly reset for ${meterBasePath} (Nachholung - Jubiläum: ${contractStartDate})`,
                                 );
                                 await this.resetYearlyCountersForMeter(type, meter);
 
-                                // Update totals if multiple meters exist
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
                                 }
                             }
                         }
-                    } else if (nowDate.getFullYear() !== lastYearStartDate.getFullYear()) {
-                        // No contract date: reset on January 1st
-                        this.adapter.log.info(`Yearly reset for ${basePath} (calendar year)`);
-                        await this.resetYearlyCountersForMeter(type, meter);
-
-                        // Update totals if multiple meters exist
-                        if (meters.length > 1) {
-                            await this.adapter.multiMeterManager.updateTotalCosts(type);
+                    } else {
+                        // No contract date: reset at 23:59 on December 31st (or catch up in January)
+                        const isDecember31 = nowDate.getMonth() === 11 && nowDate.getDate() === 31;
+                        const needsReset = nowDate.getFullYear() > lastYearStartDate.getFullYear();
+
+                        if (isDecember31 && isResetTime && !needsReset) {
+                            // Reset at 23:59 on Dec 31 for the upcoming year
+                            this.adapter.log.info(`Yearly reset for ${meterBasePath} um 23:59 (Kalenderjahr)`);
+                            await this.resetYearlyCountersForMeter(type, meter);
+
+                            if (meters.length > 1) {
+                                await this.adapter.multiMeterManager.updateTotalCosts(type);
+                            }
+                        } else if (needsReset) {
+                            // Catch-up: We're in a new year but haven't reset yet
+                            this.adapter.log.info(`Yearly reset for ${meterBasePath} (Nachholung - Kalenderjahr)`);
+                            await this.resetYearlyCountersForMeter(type, meter);
+
+                            if (meters.length > 1) {
+                                await this.adapter.multiMeterManager.updateTotalCosts(type);
+                            }
                         }
                     }
                 }
@@ -666,7 +723,7 @@ class BillingManager {
             }
 
             // Reset HT/NT daily counters if enabled
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
                 const dailyHT = await this.adapter.getStateAsync(`${basePath}.consumption.dailyHT`);
@@ -718,17 +775,26 @@ class BillingManager {
 
             this.adapter.log.debug(`Resetting monthly counter for ${basePath} (${label})`);
 
+            // Get current values before reset
             const monthlyState = await this.adapter.getStateAsync(`${basePath}.consumption.monthly`);
             const monthlyValue = monthlyState?.val || 0;
 
-            await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, 0, true);
+            // Save last month consumption
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonth`, monthlyValue, true);
 
+            // For gas: also save volume
             if (type === 'gas') {
+                const monthlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.monthlyVolume`);
+                const monthlyVolumeValue = monthlyVolume?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.lastMonthVolume`, monthlyVolumeValue, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyVolume`, 0, true);
             }
 
+            // Reset monthly counters
+            await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, 0, true);
+
             // Reset HT/NT monthly counters if enabled
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyHT`, 0, true);
@@ -821,6 +887,52 @@ class BillingManager {
         // Update lastYearStart timestamp
         await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, Date.now(), true);
     }
+
+    /**
+     * Resets weekly counters
+     *
+     * @param {string} type - Utility type
+     */
+    async resetWeeklyCounters(type) {
+        this.adapter.log.info(`Resetting weekly counters for ${type}`);
+
+        const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+        for (const meter of meters) {
+            const basePath = `${type}.${meter.name}`;
+
+            // Save last week consumption before reset
+            const weeklyState = await this.adapter.getStateAsync(`${basePath}.consumption.weekly`);
+            const weeklyValue = weeklyState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeek`, weeklyValue, true);
+
+            // For gas: also save volume
+            if (type === 'gas') {
+                const weeklyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.weeklyVolume`);
+                const weeklyVolumeValue = weeklyVolume?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekVolume`, weeklyVolumeValue, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.weeklyVolume`, 0, true);
+            }
+
+            // Reset weekly counters
+            await this.adapter.setStateAsync(`${basePath}.consumption.weekly`, 0, true);
+            await this.adapter.setStateAsync(`${basePath}.costs.weekly`, 0, true);
+
+            const configType = getConfigType(type);
+            const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
+            if (htNtEnabled) {
+                await this.adapter.setStateAsync(`${basePath}.consumption.weeklyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.weeklyNT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.weeklyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.weeklyNT`, 0, true);
+            }
+
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekStart`, Date.now(), true);
+        }
+
+        if (meters.length > 1) {
+            await this.adapter.multiMeterManager.updateTotalCosts(type);
+        }
+    }
 }
 
 module.exports = BillingManager;