iobroker.utility-monitor 1.4.4 → 1.4.6

package/lib/billingManager.js

@@ -155,10 +155,14 @@ class BillingManager {
             monthsSinceContract = Math.max(1, yDiff * 12 + mDiff + 1);
         }
 
+        // Calculate accumulated basic charge (monthly fee × months)
         const basicChargeAccumulated = basicChargeMonthly * monthsSinceContract;
-        const annualFeeAccumulated = (annualFeePerYear / 12) * monthsSinceContract;
-        const totalFixCostsAccumulated = basicChargeAccumulated + annualFeeAccumulated;
-        const totalYearlyCost = yearlyConsumptionCost + totalFixCostsAccumulated;
+
+        // 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;
 
         // Update states
         await this.adapter.setStateAsync(
@@ -186,9 +190,11 @@ class BillingManager {
             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(totalFixCostsAccumulated, 2),
+            calculator.roundToDecimals(basicChargeAccumulated, 2),
             true,
         );
 
@@ -416,7 +422,7 @@ class BillingManager {
      * @param {object} meter - Meter object from multiMeterManager
      */
     async closeBillingPeriodForMeter(type, meter) {
-        const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+        const basePath = `${type}.${meter.name}`;
         const label = meter.displayName || meter.name;
 
         this.adapter.log.info(`🔔 Schließe Abrechnungszeitraum für ${basePath} (${label})...`);
@@ -432,14 +438,8 @@ class BillingManager {
             return;
         }
 
-        // Get contract date for THIS meter
-        let contractStartDate;
-        if (meter.name === 'main') {
-            const configType = this.adapter.consumptionManager.getConfigType(type);
-            contractStartDate = this.adapter.config[`${configType}ContractStart`];
-        } else {
-            contractStartDate = meter.config?.contractStart;
-        }
+        // Get contract date for THIS meter (all meters have config.contractStart)
+        const contractStartDate = meter.config?.contractStart;
 
         if (!contractStartDate) {
             this.adapter.log.error(`❌ Kein Vertragsbeginn für ${basePath} konfiguriert.`);
@@ -491,42 +491,49 @@ class BillingManager {
     }
 
     /**
-     * Updates billing countdown
+     * Updates billing countdown for all meters of a type
+     * NOTE: Since v1.4.6, this updates ALL meters (main + additional)
      *
      * @param {string} type - Utility type
      */
     async updateBillingCountdown(type) {
-        const configType = this.adapter.consumptionManager.getConfigType(type);
-        const contractStart = this.adapter.config[`${configType}ContractStart`];
+        // Get all meters for this type
+        const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
 
-        if (!contractStart) {
-            return;
-        }
+        // Update countdown for each meter based on its contract date
+        for (const meter of meters) {
+            const contractStart = meter.config?.contractStart;
 
-        const startDate = calculator.parseGermanDate(contractStart);
-        if (!startDate) {
-            return;
-        }
+            if (!contractStart) {
+                continue;
+            }
 
-        const today = new Date();
-        const nextAnniversary = new Date(startDate);
-        nextAnniversary.setFullYear(today.getFullYear());
+            const startDate = calculator.parseGermanDate(contractStart);
+            if (!startDate) {
+                continue;
+            }
 
-        if (nextAnniversary < today) {
-            nextAnniversary.setFullYear(today.getFullYear() + 1);
-        }
+            const today = new Date();
+            const nextAnniversary = new Date(startDate);
+            nextAnniversary.setFullYear(today.getFullYear());
 
-        const msPerDay = 1000 * 60 * 60 * 24;
-        const daysRemaining = Math.ceil((nextAnniversary.getTime() - today.getTime()) / msPerDay);
-        const displayPeriodEnd = new Date(nextAnniversary);
-        displayPeriodEnd.setDate(displayPeriodEnd.getDate() - 1);
+            if (nextAnniversary < today) {
+                nextAnniversary.setFullYear(today.getFullYear() + 1);
+            }
 
-        await this.adapter.setStateAsync(`${type}.billing.daysRemaining`, daysRemaining, true);
-        await this.adapter.setStateAsync(
-            `${type}.billing.periodEnd`,
-            displayPeriodEnd.toLocaleDateString('de-DE'),
-            true,
-        );
+            const msPerDay = 1000 * 60 * 60 * 24;
+            const daysRemaining = Math.ceil((nextAnniversary.getTime() - today.getTime()) / msPerDay);
+            const displayPeriodEnd = new Date(nextAnniversary);
+            displayPeriodEnd.setDate(displayPeriodEnd.getDate() - 1);
+
+            const basePath = `${type}.${meter.name}`;
+            await this.adapter.setStateAsync(`${basePath}.billing.daysRemaining`, daysRemaining, true);
+            await this.adapter.setStateAsync(
+                `${basePath}.billing.periodEnd`,
+                displayPeriodEnd.toLocaleDateString('de-DE'),
+                true,
+            );
+        }
     }
 
     /**
@@ -574,21 +581,14 @@ class BillingManager {
             // YEARLY RESET: Each meter resets individually based on ITS contract date
             const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
             for (const meter of meters) {
-                const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+                const basePath = `${type}.${meter.name}`;
                 const lastYearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
 
                 if (lastYearStartState?.val) {
                     const lastYearStartDate = new Date(lastYearStartState.val);
 
-                    // Get contract date for THIS specific meter
-                    let contractStartDate;
-                    if (meter.name === 'main') {
-                        // Main meter: use adapter config
-                        contractStartDate = this.adapter.config[`${configType}ContractStart`];
-                    } else {
-                        // Additional meter: use meter's individual config
-                        contractStartDate = meter.config?.contractStart;
-                    }
+                    // Get contract date for THIS specific meter (all meters have config.contractStart)
+                    const contractStartDate = meter.config?.contractStart;
 
                     if (contractStartDate) {
                         const contractStart = calculator.parseGermanDate(contractStartDate);
@@ -644,7 +644,7 @@ class BillingManager {
 
         // Reset each meter
         for (const meter of meters) {
-            const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+            const basePath = `${type}.${meter.name}`;
             const label = meter.displayName || meter.name;
 
             this.adapter.log.debug(`Resetting daily counter for ${basePath} (${label})`);
@@ -713,7 +713,7 @@ class BillingManager {
 
         // Reset each meter
         for (const meter of meters) {
-            const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+            const basePath = `${type}.${meter.name}`;
             const label = meter.displayName || meter.name;
 
             this.adapter.log.debug(`Resetting monthly counter for ${basePath} (${label})`);
@@ -771,7 +771,7 @@ class BillingManager {
 
         // Reset each meter
         for (const meter of meters) {
-            const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+            const basePath = `${type}.${meter.name}`;
             const label = meter.displayName || meter.name;
 
             this.adapter.log.debug(`Resetting yearly counter for ${basePath} (${label})`);
@@ -803,7 +803,7 @@ class BillingManager {
      * @param {object} meter - Meter object from multiMeterManager
      */
     async resetYearlyCountersForMeter(type, meter) {
-        const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+        const basePath = `${type}.${meter.name}`;
         const label = meter.displayName || meter.name;
 
         this.adapter.log.debug(`Resetting yearly counter for ${basePath} (${label})`);

package/lib/consumptionManager.js

@@ -47,8 +47,8 @@ class ConsumptionManager {
 
         this.adapter.log.info(`Initializing ${type} monitoring...`);
 
-        // Create state structure
-        await stateManager.createUtilityStateStructure(this.adapter, type, this.adapter.config);
+        // State structure is now created by MultiMeterManager per meter (v1.4.6)
+        // Old createUtilityStateStructure removed - states are created under type.meterName.*
 
         const configType = this.getConfigType(type);
         const sensorDPKey = `${configType}SensorDP`;
@@ -56,7 +56,7 @@ class ConsumptionManager {
 
         if (!sensorDP) {
             this.adapter.log.warn(`${type} is active but no sensor datapoint configured!`);
-            await this.adapter.setStateAsync(`${type}.info.sensorActive`, false, true);
+            // Note: sensorActive state is now created per meter by MultiMeterManager
             return;
         }
 
@@ -69,91 +69,34 @@ class ConsumptionManager {
             this.adapter.log.info(`${type}: Managed with contract start: ${contractStartDateStr}`);
         }
 
-        // Subscribe to sensor datapoint
-        this.adapter.subscribeForeignStates(sensorDP);
-        await this.adapter.setStateAsync(`${type}.info.sensorActive`, true, true);
-        this.adapter.log.debug(`Subscribed to ${type} sensor: ${sensorDP}`);
+        // Sensor subscription is now handled by MultiMeterManager per meter
+        this.adapter.log.debug(`${type} sensor will be subscribed by MultiMeterManager: ${sensorDP}`);
 
         // Initialize all meters (main + additional) via MultiMeterManager
+        // This handles everything now: state creation, sensor subscription, costs calculation
         if (this.adapter.multiMeterManager) {
             await this.adapter.multiMeterManager.initializeType(type);
         }
 
-        // Restore last sensor value from persistent state to prevent delta loss
-        const lastReading = await this.adapter.getStateAsync(`${type}.info.meterReading`);
-        if (lastReading && typeof lastReading.val === 'number') {
-            this.lastSensorValues[sensorDP] = lastReading.val;
-            this.adapter.log.debug(`${type}: Restored last sensor value: ${lastReading.val}`);
-        }
-
-        // Initialize with current sensor value
-        try {
-            const sensorState = await this.adapter.getForeignStateAsync(sensorDP);
-            if (sensorState && sensorState.val !== null && typeof sensorState.val === 'number') {
-                await this.handleSensorUpdate(type, sensorDP, sensorState.val);
-            }
-        } catch (error) {
-            this.adapter.log.warn(`Could not read initial value from ${sensorDP}: ${error.message}`);
-        }
-
-        // Initialize period start timestamps if not set
-        const now = Date.now();
-        const dayStart = await this.adapter.getStateAsync(`${type}.statistics.lastDayStart`);
-        if (!dayStart || !dayStart.val) {
-            await this.adapter.setStateAsync(`${type}.statistics.lastDayStart`, now, true);
-        }
-
-        const monthStart = await this.adapter.getStateAsync(`${type}.statistics.lastMonthStart`);
-        if (!monthStart || !monthStart.val) {
-            await this.adapter.setStateAsync(`${type}.statistics.lastMonthStart`, now, true);
-        }
-
-        const yearStart = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
-        if (!yearStart || !yearStart.val) {
-            // Determine year start based on contract date or January 1st
-            const contractStartKey = `${configType}ContractStart`;
-            const contractStartDateStr = this.adapter.config[contractStartKey];
-
-            let yearStartDate;
-            if (contractStartDateStr) {
-                const contractStart = calculator.parseGermanDate(contractStartDateStr);
-                if (contractStart && !isNaN(contractStart.getTime())) {
-                    // Calculate last anniversary
-                    const nowDate = new Date(now);
-                    const currentYear = nowDate.getFullYear();
-                    yearStartDate = new Date(currentYear, contractStart.getMonth(), contractStart.getDate(), 12, 0, 0);
-
-                    // If anniversary is in the future this year, take last year
-                    if (yearStartDate > nowDate) {
-                        yearStartDate.setFullYear(currentYear - 1);
-                    }
-                }
-            }
-
-            if (!yearStartDate) {
-                // Fallback: January 1st of current year
-                const nowDate = new Date(now);
-                yearStartDate = new Date(nowDate.getFullYear(), 0, 1, 12, 0, 0);
-                this.adapter.log.info(
-                    `${type}: No contract start found. Setting initial year start to January 1st: ${yearStartDate.toLocaleDateString('de-DE')}`,
-                );
-            }
-
-            await this.adapter.setStateAsync(`${type}.statistics.lastYearStart`, yearStartDate.getTime(), true);
-        }
-        // Update current price
-        await this.updateCurrentPrice(type);
-
-        // Initial cost calculation (wichtig! Sonst bleiben Kosten bei 0)
-        if (typeof this.adapter.updateCosts === 'function') {
-            await this.adapter.updateCosts(type);
-        }
+        // Note: All initialization moved to MultiMeterManager in v1.4.6:
+        // - Sensor value restoration (per meter)
+        // - Period start timestamps (per meter)
+        // - Current price updates (per meter)
+        // - Cost calculations (per meter)
+        // Old type-level states (gas.info.*, gas.statistics.*) are no longer used
 
         // Initialize yearly consumption from initial reading if set
+        // NOTE: This is now handled per meter by MultiMeterManager in v1.4.6
+        // This legacy code path should not execute for new setups, but is kept for safety
         const initialReadingKey = `${configType}InitialReading`;
         const initialReading = this.adapter.config[initialReadingKey] || 0;
 
-        if (initialReading > 0) {
+        if (initialReading > 0 && sensorDP) {
+            // Get the main meter name to use the correct path
+            const mainMeterNameKey = `${configType}MainMeterName`;
+            const mainMeterName = this.adapter.config[mainMeterNameKey] || 'main';
+            const basePath = `${type}.${mainMeterName}`;
+
             const sensorState = await this.adapter.getForeignStateAsync(sensorDP);
             if (sensorState && typeof sensorState.val === 'number') {
                 let currentRaw = sensorState.val;
@@ -173,7 +116,7 @@ class ConsumptionManager {
                     const zZahl = this.adapter.config.gasZahl || 0.95;
                     const yearlyVolume = yearlyConsumption;
                     yearlyConsumption = calculator.convertGasM3ToKWh(yearlyConsumption, brennwert, zZahl);
-                    await this.adapter.setStateAsync(`${type}.consumption.yearlyVolume`, yearlyVolume, true);
+                    await this.adapter.setStateAsync(`${basePath}.consumption.yearlyVolume`, yearlyVolume, true);
                     this.adapter.log.info(
                         `Init yearly ${type}: ${yearlyConsumption.toFixed(2)} kWh = ${(currentRaw - initialReading).toFixed(2)} m³ (current: ${currentRaw.toFixed(2)} m³, initial: ${initialReading} m³)`,
                     );
@@ -183,17 +126,15 @@ class ConsumptionManager {
                     );
                 }
 
-                await this.adapter.setStateAsync(`${type}.consumption.yearly`, yearlyConsumption, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, yearlyConsumption, true);
                 if (typeof this.adapter.updateCosts === 'function') {
                     await this.adapter.updateCosts(type);
                 }
             }
         }
 
-        // Update billing countdown
-        if (typeof this.adapter.updateBillingCountdown === 'function') {
-            await this.adapter.updateBillingCountdown(type);
-        }
+        // Note: Billing countdown is now handled per meter by billingManager.updateBillingCountdown()
+        // which is called during checkPeriodResets()
 
         this.adapter.log.debug(`Initial cost calculation completed for ${type}`);
     }
@@ -201,17 +142,25 @@ class ConsumptionManager {
     /**
      * Handles sensor value updates
      *
+     * NOTE: This method is DEPRECATED since v1.4.6!
+     * All sensor updates are now handled by MultiMeterManager.handleSensorUpdate()
+     * This method remains only as fallback but should NEVER be called in normal operation.
+     *
      * @param {string} type - Utility type
      * @param {string} sensorDP - Sensor datapoint ID
      * @param {number} value - New sensor value
      */
     async handleSensorUpdate(type, sensorDP, value) {
+        this.adapter.log.warn(
+            `consumptionManager.handleSensorUpdate() called - this is deprecated! All sensors should be handled by MultiMeterManager.`,
+        );
+
         if (typeof value !== 'number' || value < 0) {
             this.adapter.log.warn(`Invalid sensor value for ${type}: ${value}`);
             return;
         }
 
-        this.adapter.log.debug(`Sensor update for ${type}: ${value}`);
+        this.adapter.log.debug(`[DEPRECATED] Sensor update for ${type}: ${value}`);
 
         const now = Date.now();
         let consumption = value;
@@ -371,36 +320,47 @@ class ConsumptionManager {
     }
 
     /**
-     * Updates the current price display
+     * Updates the current price display for all meters of a type
+     * NOTE: Since v1.4.6, this updates ALL meters (main + additional)
+     * Only main meters support HT/NT, additional meters have fixed price
      *
      * @param {string} type - Utility type
      */
     async updateCurrentPrice(type) {
         const configType = this.getConfigType(type);
 
-        // Check for HT/NT
-        const htNtEnabledKey = `${configType}HtNtEnabled`;
-        const htNtEnabled = this.adapter.config[htNtEnabledKey] || false;
+        // Get all meters for this type
+        const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
 
-        let tariffName = 'Standard';
-        let activePrice = 0;
+        for (const meter of meters) {
+            let tariffName = 'Standard';
+            let activePrice = 0;
 
-        if (htNtEnabled) {
-            const isHT = calculator.isHTTime(this.adapter.config, configType);
-            if (isHT) {
-                activePrice = this.adapter.config[`${configType}HtPrice`] || 0;
-                tariffName = 'Haupttarif (HT)';
+            // Check if this meter has HT/NT enabled
+            const htNtEnabled = meter.config?.htNtEnabled || false;
+
+            if (htNtEnabled) {
+                const isHT = calculator.isHTTime(this.adapter.config, configType);
+                if (isHT) {
+                    activePrice = this.adapter.config[`${configType}HtPrice`] || 0;
+                    tariffName = 'Haupttarif (HT)';
+                } else {
+                    activePrice = this.adapter.config[`${configType}NtPrice`] || 0;
+                    tariffName = 'Nebentarif (NT)';
+                }
             } else {
-                activePrice = this.adapter.config[`${configType}NtPrice`] || 0;
-                tariffName = 'Nebentarif (NT)';
+                // Use meter's configured price
+                activePrice = meter.config?.preis || 0;
             }
-        } else {
-            const priceKey = `${configType}Preis`;
-            activePrice = this.adapter.config[priceKey] || 0;
-        }
 
-        await this.adapter.setStateAsync(`${type}.info.currentPrice`, calculator.roundToDecimals(activePrice, 4), true);
-        await this.adapter.setStateAsync(`${type}.info.currentTariff`, tariffName, true);
+            const basePath = `${type}.${meter.name}`;
+            await this.adapter.setStateAsync(
+                `${basePath}.info.currentPrice`,
+                calculator.roundToDecimals(activePrice, 4),
+                true,
+            );
+            await this.adapter.setStateAsync(`${basePath}.info.currentTariff`, tariffName, true);
+        }
     }
 }