iobroker.utility-monitor 1.4.5 → 1.5.0

package/lib/utils/billingHelper.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const calculator = require('../calculator');
+
+/**
+ * Shared billing and cost calculation logic
+ */
+
+/**
+ * Calculates accumulated basic charges over a period
+ *
+ * @param {number} monthlyFee - Monthly basic charge
+ * @param {number} annualFee - Fixed annual fee
+ * @param {number} months - Number of months since contract start
+ * @returns {object} { basicCharge, annualFee, total }
+ */
+function calculateAccumulatedCharges(monthlyFee, annualFee, months) {
+    const basicCharge = (monthlyFee || 0) * months;
+    const annual = annualFee || 0;
+    return {
+        basicCharge: calculator.roundToDecimals(basicCharge, 2),
+        annualFee: calculator.roundToDecimals(annual, 2),
+        total: calculator.roundToDecimals(basicCharge + annual, 2),
+    };
+}
+
+/**
+ * Calculates total paid and balance
+ *
+ * @param {number} monthlyAbschlag - Monthly installment
+ * @param {number} months - Months since start
+ * @param {number} totalCosts - Total costs calculated
+ * @returns {object} { paid, balance }
+ */
+function calculateBalance(monthlyAbschlag, months, totalCosts) {
+    const paid = (monthlyAbschlag || 0) * months;
+    const balance = totalCosts > 0.01 || paid > 0.01 ? paid - totalCosts : 0;
+
+    return {
+        paid: calculator.roundToDecimals(paid, 2),
+        balance: calculator.roundToDecimals(balance, 2),
+    };
+}
+
+/**
+ * Calculates costs for HT/NT split
+ *
+ * @param {number} htQty - High tariff quantity
+ * @param {number} htPrice - High tariff price
+ * @param {number} ntQty - Low tariff quantity
+ * @param {number} ntPrice - Low tariff price
+ * @returns {object} { htCosts, ntCosts, total }
+ */
+function calculateHTNTCosts(htQty, htPrice, ntQty, ntPrice) {
+    const ht = (htQty || 0) * (htPrice || 0);
+    const nt = (ntQty || 0) * (ntPrice || 0);
+
+    return {
+        htCosts: calculator.roundToDecimals(ht, 2),
+        ntCosts: calculator.roundToDecimals(nt, 2),
+        total: calculator.roundToDecimals(ht + nt, 2),
+    };
+}
+
+module.exports = {
+    calculateAccumulatedCharges,
+    calculateBalance,
+    calculateHTNTCosts,
+};

package/lib/utils/consumptionHelper.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const calculator = require('../calculator');
+
+/**
+ * Shared consumption logic for different managers
+ */
+
+/**
+ * Calculates gas energy (kWh) and volume (m³)
+ *
+ * @param {number} value - Raw sensor value (m³)
+ * @param {number} brennwert - Calorific value
+ * @param {number} zZahl - Z-number
+ * @returns {object} { energy, volume }
+ */
+function calculateGas(value, brennwert, zZahl) {
+    const energy = calculator.convertGasM3ToKWh(value, brennwert, zZahl);
+    return {
+        energy: calculator.roundToDecimals(energy, 2),
+        volume: calculator.roundToDecimals(value, 2),
+    };
+}
+
+/**
+ * Returns the suffix (HT/NT) based on current time
+ *
+ * @param {object} config - Adapter config
+ * @param {string} type - Utility type (config name)
+ * @returns {string} 'HT', 'NT' or empty if disabled
+ */
+function getHTNTSuffix(config, type) {
+    if (!config || !type) {
+        return '';
+    }
+    const enabled = config[`${type}HtNtEnabled`];
+    if (!enabled) {
+        return '';
+    }
+
+    return calculator.isHTTime(config, type) ? 'HT' : 'NT';
+}
+
+module.exports = {
+    calculateGas,
+    getHTNTSuffix,
+};

package/lib/utils/helpers.js

@@ -0,0 +1,178 @@
+'use strict';
+
+/**
+ * Helper utilities for iobroker.utility-monitor
+ */
+
+/**
+ * Ensures a value is a number, handling German decimal commas if provided as string.
+ *
+ * @param {any} value - Value to convert
+ * @returns {number} The numeric value
+ */
+function ensureNumber(value) {
+    if (value === undefined || value === null || value === '') {
+        return 0;
+    }
+    if (typeof value === 'number') {
+        return isNaN(value) ? 0 : value;
+    }
+    if (typeof value === 'string') {
+        let normalized = value.trim();
+        // Handle common European formats: 1.234,56 -> 1234.56 or 1234,56 -> 1234.56
+        if (normalized.includes(',') && normalized.includes('.')) {
+            // Assume . is thousands and , is decimal
+            normalized = normalized.replace(/\./g, '').replace(',', '.');
+        } else if (normalized.includes(',')) {
+            // Assume , is decimal
+            normalized = normalized.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 trimmed = dateStr.trim();
+
+    // 1. Try German format (DD.MM.YYYY)
+    if (trimmed.includes('.') && !trimmed.includes('-')) {
+        const parts = trimmed.split('.');
+        if (parts.length === 3) {
+            const day = parseInt(parts[0], 10);
+            const month = parseInt(parts[1], 10) - 1;
+            let year = parseInt(parts[2], 10);
+
+            if (year < 70) {
+                year += 2000;
+            } else if (year < 100) {
+                year += 1900;
+            }
+
+            if (!isNaN(day) && !isNaN(month) && !isNaN(year)) {
+                return new Date(year, month, day, 12, 0, 0);
+            }
+        }
+    }
+
+    // 2. Try ISO or other standard formats
+    const fallback = new Date(trimmed);
+    if (!isNaN(fallback.getTime())) {
+        return fallback;
+    }
+
+    return null;
+}
+
+/**
+ * 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 || !(date instanceof Date)) {
+        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())}`;
+}
+
+/**
+ * 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) {
+    if (!startDate || !endDate) {
+        return 0;
+    }
+    return (endDate.getFullYear() - startDate.getFullYear()) * 12 + (endDate.getMonth() - startDate.getMonth());
+}
+
+/**
+ * Normalizes a meter name to a valid ioBroker ID part
+ *
+ * @param {string} name - The name to normalize
+ * @returns {string} The normalized name
+ */
+function normalizeMeterName(name) {
+    if (!name) {
+        return 'unknown';
+    }
+
+    return name
+        .toLowerCase()
+        .replace(/ä/g, 'ae')
+        .replace(/ö/g, 'oe')
+        .replace(/ü/g, 'ue')
+        .replace(/ß/g, 'ss')
+        .replace(/[^a-z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .substring(0, 32);
+}
+
+/**
+ * Safe wrapper for setObjectNotExistsAsync with error handling
+ *
+ * @param {object} adapter - Adapter instance
+ * @param {string} id - State ID
+ * @param {object} obj - Object definition
+ */
+async function safeSetObjectNotExists(adapter, id, obj) {
+    try {
+        await adapter.setObjectNotExistsAsync(id, obj);
+    } catch (e) {
+        adapter.log.error(`Error creating object ${id}: ${e.message}`);
+    }
+}
+
+module.exports = {
+    ensureNumber,
+    roundToDecimals,
+    parseGermanDate,
+    formatDateString,
+    isLeapYear,
+    getMonthsDifference,
+    normalizeMeterName,
+    safeSetObjectNotExists,
+};

package/lib/utils/typeMapper.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * Maps internal utility type to config/state name
+ *
+ * @param {string} type - gas, water, electricity, pv
+ * @returns {string} - gas, wasser, strom, pv
+ */
+function getConfigType(type) {
+    const mapping = {
+        electricity: 'strom',
+        water: 'wasser',
+        gas: 'gas',
+        pv: 'pv',
+    };
+    return mapping[type] || type;
+}
+
+module.exports = { getConfigType };

package/main.js

@@ -10,6 +10,8 @@ const ConsumptionManager = require('./lib/consumptionManager');
 const BillingManager = require('./lib/billingManager');
 const MessagingHandler = require('./lib/messagingHandler');
 const MultiMeterManager = require('./lib/multiMeterManager');
+const ImportManager = require('./lib/importManager');
+const calculator = require('./lib/calculator');
 
 class UtilityMonitor extends utils.Adapter {
     /**
@@ -29,6 +31,7 @@ class UtilityMonitor extends utils.Adapter {
         this.consumptionManager = new ConsumptionManager(this);
         this.billingManager = new BillingManager(this);
         this.messagingHandler = new MessagingHandler(this);
+        this.importManager = new ImportManager(this);
         this.multiMeterManager = null; // Initialized in onReady after other managers
 
         this.periodicTimers = {};
@@ -43,6 +46,9 @@ class UtilityMonitor extends utils.Adapter {
         // Initialize MultiMeterManager
         this.multiMeterManager = new MultiMeterManager(this, this.consumptionManager, this.billingManager);
 
+        // Validate configuration before starting
+        this.validateConfiguration();
+
         // Initialize each utility type based on configuration
         // Note: initializeUtility() internally calls multiMeterManager.initializeType()
         await this.initializeUtility('gas', this.config.gasAktiv);
@@ -82,16 +88,64 @@ class UtilityMonitor extends utils.Adapter {
         this.log.info('Nebenkosten-Monitor initialized successfully');
     }
 
+    /**
+     * Validates the adapter configuration and logs warnings for missing settings
+     */
+    validateConfiguration() {
+        const types = [
+            { key: 'gas', configKey: 'gas', label: 'Gas' },
+            { key: 'water', configKey: 'wasser', label: 'Wasser' },
+            { key: 'electricity', configKey: 'strom', label: 'Strom' },
+            { key: 'pv', configKey: 'pv', label: 'PV' },
+        ];
+
+        for (const type of types) {
+            const isActive = this.config[`${type.configKey}Aktiv`];
+            if (!isActive) {
+                continue;
+            }
+
+            // Check main meter contract start
+            const contractStart = this.config[`${type.configKey}ContractStart`];
+            if (!contractStart) {
+                this.log.warn(
+                    `${type.label}: Kein Vertragsbeginn konfiguriert! Für korrekte Jahresberechnungen und Abrechnungsperioden sollte ein Vertragsbeginn gesetzt werden.`,
+                );
+            }
+
+            // Check main meter sensor
+            const sensorDP = this.config[`${type.configKey}SensorDP`];
+            if (!sensorDP) {
+                this.log.warn(`${type.label}: Kein Sensor-Datenpunkt konfiguriert!`);
+            }
+
+            // Check additional meters
+            const additionalMeters = this.config[`${type.configKey}AdditionalMeters`];
+            if (Array.isArray(additionalMeters)) {
+                for (const meter of additionalMeters) {
+                    if (meter && meter.name) {
+                        if (!meter.contractStart) {
+                            this.log.warn(
+                                `${type.label} Zähler "${meter.name}": Kein Vertragsbeginn konfiguriert!`,
+                            );
+                        }
+                        if (!meter.sensorDP) {
+                            this.log.warn(
+                                `${type.label} Zähler "${meter.name}": Kein Sensor-Datenpunkt konfiguriert!`,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     // --- Delegation Methods (backward compatibility for internal calls) ---
 
     async initializeUtility(type, isActive) {
         return this.consumptionManager.initializeUtility(type, isActive);
     }
 
-    async handleSensorUpdate(type, sensorDP, value) {
-        return this.consumptionManager.handleSensorUpdate(type, sensorDP, value);
-    }
-
     async updateCurrentPrice(type) {
         return this.consumptionManager.updateCurrentPrice(type);
     }
@@ -195,20 +249,15 @@ class UtilityMonitor extends utils.Adapter {
         if (id.includes('.billing.closePeriod') && state.val === true && !state.ack) {
             const parts = id.split('.');
 
-            // Parse state ID: nebenkosten-monitor.0.gas.erdgeschoss.billing.closePeriod
-            // Remove adapter prefix: gas.erdgeschoss.billing.closePeriod
+            // Parse state ID: nebenkosten-monitor.0.gas.meterName.billing.closePeriod
+            // Remove adapter prefix: gas.meterName.billing.closePeriod
             const statePathParts = parts.slice(2); // Remove "nebenkosten-monitor" and "0"
 
-            // Determine if this is main meter or additional meter
-            if (statePathParts.length === 3) {
-                // Main meter: gas.billing.closePeriod
-                const type = statePathParts[0];
-                this.log.info(`User triggered billing period closure for ${type} (main meter)`);
-                await this.closeBillingPeriod(type);
-            } else if (statePathParts.length === 4) {
-                // Additional meter: gas.erdgeschoss.billing.closePeriod
+            // All meters now use: gas.meterName.billing.closePeriod (length === 4)
+            if (statePathParts.length === 4) {
                 const type = statePathParts[0];
                 const meterName = statePathParts[1];
+
                 this.log.info(`User triggered billing period closure for ${type}.${meterName}`);
 
                 // Find the meter object from multiMeterManager
@@ -221,40 +270,50 @@ class UtilityMonitor extends utils.Adapter {
                     this.log.error(`Meter "${meterName}" not found for type ${type}!`);
                     await this.setStateAsync(`${type}.${meterName}.billing.closePeriod`, false, true);
                 }
+            } else {
+                // Invalid path format
+                this.log.warn(`Invalid billing period closure trigger: ${id}`);
             }
             return;
         }
 
         // Check if this is an adjustment value change
+        // New structure: gas.meterName.adjustment.value (4 parts after namespace)
         if (id.includes('.adjustment.value') && !state.ack) {
             const parts = id.split('.');
-            const type = parts[parts.length - 3];
-            this.log.info(`Adjustment value changed for ${type}: ${state.val}`);
-            await this.setStateAsync(`${type}.adjustment.applied`, Date.now(), true);
+            // Parse: nebenkosten-monitor.0.gas.meterName.adjustment.value
+            const statePathParts = parts.slice(2); // Remove "nebenkosten-monitor" and "0"
 
-            // Update costs for all meters of this type
-            await this.updateCosts(type);
-            return;
-        }
+            if (statePathParts.length === 3) {
+                // New structure: gas.meterName.adjustment.value
+                const type = statePathParts[0];
+                const meterName = statePathParts[1];
 
-        // Determine which utility this sensor belongs to
-        // First check if it's a multi-meter sensor (additional meters)
-        if (this.multiMeterManager) {
-            const meterInfo = this.multiMeterManager.findMeterBySensor(id);
-            if (meterInfo && typeof state.val === 'number') {
-                await this.multiMeterManager.handleSensorUpdate(meterInfo.type, meterInfo.meterName, id, state.val);
+                this.log.info(`Adjustment value changed for ${type}.${meterName}: ${state.val}`);
+                await this.setStateAsync(`${type}.${meterName}.adjustment.applied`, Date.now(), true);
+
+                // Update costs for THIS specific meter
+                if (this.multiMeterManager) {
+                    const meters = this.multiMeterManager.getMetersForType(type);
+                    const meter = meters.find(m => m.name === meterName);
+                    if (meter) {
+                        await this.multiMeterManager.updateCosts(type, meterName, meter.config);
+                    }
+                }
                 return;
             }
         }
 
-        // Check main meter sensors
-        const types = ['gas', 'water', 'electricity', 'pv'];
-        for (const type of types) {
-            const configType = this.consumptionManager.getConfigType(type);
-
-            if (this.config[`${configType}Aktiv`] && this.config[`${configType}SensorDP`] === id) {
-                if (typeof state.val === 'number') {
-                    await this.handleSensorUpdate(type, id, state.val);
+        // Determine which utility this sensor belongs to
+        // All meters (including main) are now handled by multiMeterManager
+        if (this.multiMeterManager) {
+            const meters = this.multiMeterManager.findMeterBySensor(id);
+            if (meters.length > 0 && state.val != null) {
+                // Convert sensor value to number (handles strings, German commas, etc.)
+                const numValue = calculator.ensureNumber(state.val);
+                // Call handleSensorUpdate for each meter using this sensor
+                for (const meterInfo of meters) {
+                    await this.multiMeterManager.handleSensorUpdate(meterInfo.type, meterInfo.meterName, id, numValue);
                 }
                 return;
             }
@@ -267,7 +326,11 @@ class UtilityMonitor extends utils.Adapter {
      * @param {Record<string, any>} obj - Message object from config
      */
     async onMessage(obj) {
-        await this.messagingHandler.handleMessage(obj);
+        if (obj.command === 'importCSV') {
+            await this.importManager.handleImportCSV(obj);
+        } else {
+            await this.messagingHandler.handleMessage(obj);
+        }
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.utility-monitor",
-  "version": "1.4.5",
+  "version": "1.5.0",
   "description": "Monitor gas, water, and electricity consumption with cost calculation",
   "author": {
     "name": "fischi87",
@@ -54,8 +54,14 @@
   },
   "main": "main.js",
   "files": [
-    "admin{,/!(src)/**}/!(tsconfig|tsconfig.*|.eslintrc).{json,json5}",
-    "admin{,/!(src)/**}/*.{html,css,png,svg,jpg,js}",
+    "admin/*.json",
+    "admin/*.json5",
+    "admin/*.png",
+    "admin/*.svg",
+    "admin/*.html",
+    "admin/*.js",
+    "admin/i18n/*.json",
+    "admin/custom/**",
     "lib/",
     "www/",
     "io-package.json",
@@ -63,7 +69,7 @@
     "main.js"
   ],
   "scripts": {
-    "test:js": "mocha --config test/mocharc.custom.json \"{!(node_modules|test)/**/*.test.js,*.test.js,test/**/*.test.js}\"",
+    "test:js": "mocha --config test/mocharc.custom.json \"{!(node_modules|test|admin)/**/*.test.js,*.test.js,test/**/*.test.js}\"",
     "test:package": "mocha test/package --exit",
     "test:integration": "mocha test/integration --exit",
     "test": "npm run test:js && npm run test:package",