iobroker.utility-monitor 1.4.5 → 1.5.0

package/lib/calculator.js

@@ -1,7 +1,4 @@
-/**
- * Calculator module for nebenkosten-monitor
- * Provides utility functions for gas conversion, cost calculation, and consumption aggregation
- */
+const helpers = require('./utils/helpers');
 
 /**
  * Converts gas volume from m³ to kWh
@@ -13,13 +10,17 @@
  * @returns {number} Energy in kWh
  */
 function convertGasM3ToKWh(m3, brennwert = 11.5, zZahl = 0.95) {
-    if (typeof m3 !== 'number' || typeof brennwert !== 'number' || typeof zZahl !== 'number') {
-        throw new TypeError('All parameters must be numbers');
-    }
-    if (m3 < 0 || brennwert <= 0 || zZahl <= 0 || zZahl > 1) {
-        throw new RangeError('Invalid parameter values');
+    // Hier number zu string
+    const cleanM3 = helpers.ensureNumber(m3);
+    const cleanBrennwert = helpers.ensureNumber(brennwert);
+    const cleanZZahl = helpers.ensureNumber(zZahl);
+
+    // Validierung der Logik (jetzt mit den konvertierten Zahlen)
+    if (cleanM3 < 0 || cleanBrennwert <= 0 || cleanZZahl <= 0 || cleanZZahl > 1) {
+        throw new RangeError('Ungültige Parameterwerte für die Gas-Umrechnung');
     }
-    return m3 * brennwert * zZahl;
+
+    return cleanM3 * cleanBrennwert * cleanZZahl;
 }
 
 /**
@@ -51,69 +52,6 @@ function calculateCost(consumption, price) {
     return consumption * (price || 0);
 }
 
-/**
- * Ensures a value is a number, handling German decimal commas if provided as string.
- *
- * @param {any} value - Value to convert
- * @returns {number}
- */
-function ensureNumber(value) {
-    if (value === undefined || value === null || value === '') {
-        return 0;
-    }
-    if (typeof value === 'string') {
-        const normalized = value.replace(',', '.');
-        const parsed = parseFloat(normalized);
-        return isNaN(parsed) ? 0 : parsed;
-    }
-    const num = Number(value);
-    return isNaN(num) ? 0 : num;
-}
-
-/**
- * Rounds a number to specified decimal places
- *
- * @param {number|string} value - Value to round
- * @param {number} decimals - Number of decimal places (default: 2)
- * @returns {number} Rounded value
- */
-function roundToDecimals(value, decimals = 2) {
-    const numValue = ensureNumber(value);
-    const factor = Math.pow(10, decimals);
-    return Math.round(numValue * factor) / factor;
-}
-
-/**
- * Parses a German date string (DD.MM.YYYY) into a Date object
- *
- * @param {string} dateStr - Date string in format DD.MM.YYYY
- * @returns {Date|null} Date object or null if invalid
- */
-function parseGermanDate(dateStr) {
-    if (!dateStr || typeof dateStr !== 'string') {
-        return null;
-    }
-    const parts = dateStr.trim().split('.');
-    if (parts.length !== 3) {
-        return null;
-    }
-    let day = parseInt(parts[0], 10);
-    let month = parseInt(parts[1], 10) - 1; // Month is 0-indexed
-    let year = parseInt(parts[2], 10);
-
-    // Handle 2-digit years (e.g. 25 -> 2025)
-    if (year < 100) {
-        year += 2000;
-    }
-
-    if (isNaN(day) || isNaN(month) || isNaN(year)) {
-        return null;
-    }
-
-    // Create date at noon to avoid timezone shift issues (especially with ISO export)
-    return new Date(year, month, day, 12, 0, 0);
-}
-
 /**
  * Checks if the current time is within the High Tariff (HT) period
  *
@@ -180,75 +118,18 @@ const DEFAULTS = {
     MIN_CONSUMPTION: 0,
 };
 
-/**
- * Formats a Date object to YYYY-MM-DD HH:mm:ss string
- *
- * @param {Date} date - Date object
- * @returns {string|null} Formatted date string or null
- */
-function formatDateString(date) {
-    if (!date) {
-        return null;
-    }
-    if (!(date instanceof Date)) {
-        // If it's already a string, try to parse and re-format, or just return if it handles
-        // But the error said "calculator.formatDateString is not a function", so we need it here.
-        return null;
-    }
-
-    const pad = num => num.toString().padStart(2, '0');
-    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-}
-
-/**
- * Parses a date string (ISO or standard format)
- *
- * @param {string} dateStr - Date string
- * @returns {Date|null} Date object or null
- */
-function parseDateString(dateStr) {
-    if (!dateStr) {
-        return null;
-    }
-    const date = new Date(dateStr);
-    if (isNaN(date.getTime())) {
-        return null;
-    }
-    return date;
-}
-
-/**
- * Checks if a year is a leap year
- *
- * @param {number} year - Year to check
- * @returns {boolean} True if leap year
- */
-function isLeapYear(year) {
-    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
-}
-
-/**
- * Calculates the difference in months between two dates
- *
- * @param {Date} startDate - Start date
- * @param {Date} endDate - End date
- * @returns {number} Difference in months
- */
-function getMonthsDifference(startDate, endDate) {
-    return (endDate.getFullYear() - startDate.getFullYear()) * 12 + (endDate.getMonth() - startDate.getMonth());
-}
-
 module.exports = {
     convertGasM3ToKWh,
     getCurrentPrice,
     calculateCost,
-    ensureNumber,
-    roundToDecimals,
-    parseGermanDate,
     isHTTime,
-    formatDateString,
-    parseDateString,
-    isLeapYear,
-    getMonthsDifference,
     DEFAULTS,
+    // Re-export helpers for backward compatibility
+    ensureNumber: helpers.ensureNumber,
+    roundToDecimals: helpers.roundToDecimals,
+    parseGermanDate: helpers.parseGermanDate,
+    formatDateString: helpers.formatDateString,
+    parseDateString: s => helpers.parseGermanDate(s),
+    isLeapYear: helpers.isLeapYear,
+    getMonthsDifference: helpers.getMonthsDifference,
 };

package/lib/consumptionManager.js

@@ -1,11 +1,12 @@
 'use strict';
 
 const calculator = require('./calculator');
+const { getConfigType } = require('./utils/typeMapper');
 const stateManager = require('./stateManager');
 
 /**
- * ConsumptionManager handles all sensor-related logic,
- * including initialization, unit conversion, and sensor updates.
+ * ConsumptionManager handles utility initialization and price updates.
+ * NOTE: Sensor handling has been moved to MultiMeterManager since v1.4.6.
  */
 class ConsumptionManager {
     /**
@@ -13,22 +14,6 @@ class ConsumptionManager {
      */
     constructor(adapter) {
         this.adapter = adapter;
-        this.lastSensorValues = {};
-    }
-
-    /**
-     * Maps internal utility type to config/state name
-     *
-     * @param {string} type - gas, water, or electricity
-     * @returns {string} - gas, wasser, or strom
-     */
-    getConfigType(type) {
-        const mapping = {
-            electricity: 'strom',
-            water: 'wasser',
-            gas: 'gas',
-        };
-        return mapping[type] || type;
     }
 
     /**
@@ -47,16 +32,16 @@ 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 configType = getConfigType(type);
         const sensorDPKey = `${configType}SensorDP`;
         const sensorDP = this.adapter.config[sensorDPKey];
 
         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,338 +54,70 @@ 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];
+        // Note: All initialization moved to MultiMeterManager in v1.4.6:
+        // - State creation (per meter)
+        // - Sensor value restoration (per meter)
+        // - Period start timestamps (per meter)
+        // - Initial yearly consumption calculation (per meter)
+        // - Current price updates (per meter)
+        // - Cost calculations (per meter)
+        // - Billing countdown (per meter)
+        // Old type-level states (gas.info.*, gas.statistics.*) are no longer used
 
-            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);
-        }
-
-        // Initialize yearly consumption from initial reading if set
-        const initialReadingKey = `${configType}InitialReading`;
-        const initialReading = this.adapter.config[initialReadingKey] || 0;
-
-        if (initialReading > 0) {
-            const sensorState = await this.adapter.getForeignStateAsync(sensorDP);
-            if (sensorState && typeof sensorState.val === 'number') {
-                let currentRaw = sensorState.val;
-
-                // Apply offset if configured (in original unit)
-                const offsetKey = `${configType}Offset`;
-                const offset = this.adapter.config[offsetKey] || 0;
-                if (offset !== 0) {
-                    currentRaw = currentRaw - offset;
-                    this.adapter.log.debug(`Applied offset for ${type}: -${offset}, new value: ${currentRaw}`);
-                }
-                let yearlyConsumption = Math.max(0, currentRaw - initialReading);
-
-                // For gas: convert m³ to kWh AFTER calculating the difference
-                if (type === 'gas') {
-                    const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                    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);
-                    this.adapter.log.info(
-                        `Init yearly ${type}: ${yearlyConsumption.toFixed(2)} kWh = ${(currentRaw - initialReading).toFixed(2)} m³ (current: ${currentRaw.toFixed(2)} m³, initial: ${initialReading} m³)`,
-                    );
-                } else {
-                    this.adapter.log.info(
-                        `Init yearly ${type}: ${yearlyConsumption.toFixed(2)} (current: ${currentRaw.toFixed(2)}, initial: ${initialReading})`,
-                    );
-                }
-
-                await this.adapter.setStateAsync(`${type}.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);
-        }
-
-        this.adapter.log.debug(`Initial cost calculation completed for ${type}`);
+        this.adapter.log.debug(`${type} initialization delegated to MultiMeterManager`);
     }
 
     /**
-     * Handles sensor value updates
+     * 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
-     * @param {string} sensorDP - Sensor datapoint ID
-     * @param {number} value - New sensor value
      */
-    async handleSensorUpdate(type, sensorDP, value) {
-        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}`);
-
-        const now = Date.now();
-        let consumption = value;
-        let consumptionM3 = null;
-
-        const configType = this.getConfigType(type);
-
-        // Apply offset FIRST
-        const offsetKey = `${configType}Offset`;
-        const offset = this.adapter.config[offsetKey] || 0;
-        if (offset !== 0) {
-            consumption = consumption - offset;
-            this.adapter.log.debug(`Applied offset for ${type}: -${offset}, new value: ${consumption}`);
-        }
-
-        // For gas, convert m³ to kWh
-        if (type === 'gas') {
-            const brennwert = this.adapter.config.gasBrennwert || 11.5;
-            const zZahl = this.adapter.config.gasZahl || 0.95;
-            consumptionM3 = consumption;
-            await this.adapter.setStateAsync(`${type}.info.meterReadingVolume`, consumption, true);
-            consumption = calculator.convertGasM3ToKWh(consumption, brennwert, zZahl);
-            consumption = calculator.roundToDecimals(consumption, 2);
-        }
-
-        // Update meter reading
-        await this.adapter.setStateAsync(`${type}.info.meterReading`, consumption, true);
-
-        // Calculate deltas
-        const lastValue = this.lastSensorValues[sensorDP];
-        this.lastSensorValues[sensorDP] = consumption;
-
-        if (lastValue === undefined || consumption < lastValue) {
-            if (lastValue !== undefined && consumption < lastValue) {
-                this.adapter.log.warn(
-                    `${type}: Sensor value decreased (${lastValue} -> ${consumption}). Assuming meter reset or replacement.`,
-                );
-            }
-            if (typeof this.adapter.updateCosts === 'function') {
-                await this.adapter.updateCosts(type);
-            }
-            return;
-        }
-
-        const delta = consumption - lastValue;
-        this.adapter.log.debug(`${type} delta: ${delta}`);
-
-        // Track volume for gas
-        if (type === 'gas') {
-            const brennwert = this.adapter.config.gasBrennwert || 11.5;
-            const zZahl = this.adapter.config.gasZahl || 0.95;
-            const deltaVolume = delta / (brennwert * zZahl);
-
-            const dailyVolume = await this.adapter.getStateAsync(`${type}.consumption.dailyVolume`);
-            const monthlyVolume = await this.adapter.getStateAsync(`${type}.consumption.monthlyVolume`);
-            const yearlyVolume = await this.adapter.getStateAsync(`${type}.consumption.yearlyVolume`);
-
-            await this.adapter.setStateAsync(
-                `${type}.consumption.dailyVolume`,
-                calculator.roundToDecimals((dailyVolume?.val || 0) + deltaVolume, 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.consumption.monthlyVolume`,
-                calculator.roundToDecimals((monthlyVolume?.val || 0) + deltaVolume, 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.consumption.yearlyVolume`,
-                calculator.roundToDecimals((yearlyVolume?.val || 0) + deltaVolume, 3),
-                true,
-            );
-        }
-
-        // Update consumption values
-        const dailyState = await this.adapter.getStateAsync(`${type}.consumption.daily`);
-        await this.adapter.setStateAsync(
-            `${type}.consumption.daily`,
-            calculator.roundToDecimals((dailyState?.val || 0) + delta, 2),
-            true,
-        );
-
-        const monthlyState = await this.adapter.getStateAsync(`${type}.consumption.monthly`);
-        await this.adapter.setStateAsync(
-            `${type}.consumption.monthly`,
-            calculator.roundToDecimals((monthlyState?.val || 0) + delta, 2),
-            true,
-        );
-
-        // HT/NT tracking
-        const htNtEnabledKey = `${configType}HtNtEnabled`;
-        if (this.adapter.config[htNtEnabledKey]) {
-            const isHT = calculator.isHTTime(this.adapter.config, configType);
-            const suffix = isHT ? 'HT' : 'NT';
-
-            const dHTNT = await this.adapter.getStateAsync(`${type}.consumption.daily${suffix}`);
-            await this.adapter.setStateAsync(
-                `${type}.consumption.daily${suffix}`,
-                calculator.roundToDecimals((dHTNT?.val || 0) + delta, 2),
-                true,
-            );
+    async updateCurrentPrice(type) {
+        const configType = getConfigType(type);
 
-            const mHTNT = await this.adapter.getStateAsync(`${type}.consumption.monthly${suffix}`);
-            await this.adapter.setStateAsync(
-                `${type}.consumption.monthly${suffix}`,
-                calculator.roundToDecimals((mHTNT?.val || 0) + delta, 2),
-                true,
-            );
+        // Get all meters for this type
+        const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
 
-            const yHTNT = await this.adapter.getStateAsync(`${type}.consumption.yearly${suffix}`);
-            await this.adapter.setStateAsync(
-                `${type}.consumption.yearly${suffix}`,
-                calculator.roundToDecimals((yHTNT?.val || 0) + delta, 2),
-                true,
-            );
-        }
+        for (const meter of meters) {
+            let tariffName = 'Standard';
+            let activePrice = 0;
 
-        // Yearly consumption
-        const initialReadingKey = `${configType}InitialReading`;
-        const initialReading = this.adapter.config[initialReadingKey] || 0;
+            // Check if this meter has HT/NT enabled
+            const htNtEnabled = meter.config?.htNtEnabled || false;
 
-        if (initialReading > 0) {
-            let yearlyAmount;
-            if (type === 'gas') {
-                const yearlyM3 = Math.max(0, (consumptionM3 || 0) - initialReading);
-                await this.adapter.setStateAsync(
-                    `${type}.consumption.yearlyVolume`,
-                    calculator.roundToDecimals(yearlyM3, 2),
-                    true,
-                );
-                const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                const zZahl = this.adapter.config.gasZahl || 0.95;
-                yearlyAmount = calculator.convertGasM3ToKWh(yearlyM3, brennwert, zZahl);
+            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 {
-                yearlyAmount = Math.max(0, consumption - initialReading);
+                // Use meter's configured price
+                activePrice = meter.config?.preis || 0;
             }
+
+            const basePath = `${type}.${meter.name}`;
             await this.adapter.setStateAsync(
-                `${type}.consumption.yearly`,
-                calculator.roundToDecimals(yearlyAmount, 2),
-                true,
-            );
-        } else {
-            const yState = await this.adapter.getStateAsync(`${type}.consumption.yearly`);
-            await this.adapter.setStateAsync(
-                `${type}.consumption.yearly`,
-                calculator.roundToDecimals((yState?.val || 0) + delta, 2),
+                `${basePath}.info.currentPrice`,
+                calculator.roundToDecimals(activePrice, 4),
                 true,
             );
+            await this.adapter.setStateAsync(`${basePath}.info.currentTariff`, tariffName, true);
         }
-
-        if (typeof this.adapter.updateCosts === 'function') {
-            await this.adapter.updateCosts(type);
-        }
-
-        await this.adapter.setStateAsync(`${type}.consumption.lastUpdate`, now, true);
-        await this.adapter.setStateAsync(`${type}.info.lastSync`, now, true);
-    }
-
-    /**
-     * Updates the current price display
-     *
-     * @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;
-
-        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)';
-            } else {
-                activePrice = this.adapter.config[`${configType}NtPrice`] || 0;
-                tariffName = 'Nebentarif (NT)';
-            }
-        } 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);
     }
 }