iobroker.utility-monitor 1.4.4 → 1.4.6

package/lib/messagingHandler.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const ImportManager = require('./importManager');
-
 /**
  * MessagingHandler handles all incoming adapter messages
  * and outgoing notifications.
@@ -12,7 +10,6 @@ class MessagingHandler {
      */
     constructor(adapter) {
         this.adapter = adapter;
-        this.importManager = null; // Lazy initialization
     }
 
     /**
@@ -27,7 +24,36 @@ class MessagingHandler {
 
         this.adapter.log.debug(`[onMessage] Received command: ${obj.command} from ${obj.from}`);
 
-        if (obj.command === 'getInstances') {
+        if (obj.command === 'getMeters') {
+            try {
+                // Get the utility type from the message
+                const type = obj.message?.type;
+
+                if (!type) {
+                    this.adapter.sendTo(obj.from, obj.command, [], obj.callback);
+                    return;
+                }
+
+                // Get all meters for this type from multiMeterManager
+                const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+
+                if (meters.length === 0) {
+                    this.adapter.sendTo(obj.from, obj.command, [], obj.callback);
+                    return;
+                }
+
+                // Build options array: [{ value: "main", label: "Hauptzähler (main)" }, ...]
+                const result = meters.map(meter => ({
+                    value: meter.name,
+                    label: meter.displayName ? `${meter.displayName} (${meter.name})` : meter.name,
+                }));
+
+                this.adapter.sendTo(obj.from, obj.command, result, obj.callback);
+            } catch (error) {
+                this.adapter.log.error(`Error in getMeters callback: ${error.message}`);
+                this.adapter.sendTo(obj.from, obj.command, [], obj.callback);
+            }
+        } else if (obj.command === 'getInstances') {
             try {
                 const instances = await this.adapter.getForeignObjectsAsync('system.adapter.*', 'instance');
                 const messengerTypes = [
@@ -139,65 +165,6 @@ class MessagingHandler {
                     );
                 }
             }
-        } else if (obj.command === 'importCSV') {
-            this.adapter.log.info(`[importCSV] Received import request`);
-
-            try {
-                // Lazy initialize importManager
-                if (!this.importManager) {
-                    const calculator = this.adapter.consumptionManager.calculator;
-                    this.importManager = new ImportManager(this.adapter, calculator);
-                }
-
-                // Extract data from obj.message, obj directly, or config (fallback)
-                // jsonConfig sometimes doesn't resolve ${data.xxx} variables in sendTo buttons
-                let medium = obj.message?.medium || obj.medium || this.adapter.config.importMedium;
-                let file = obj.message?.file || obj.file || this.adapter.config.importFileContent;
-
-                // Handle unresolved placeholders
-                if (medium && medium.includes('${data.')) {
-                    medium = this.adapter.config.importMedium;
-                }
-                if (file && file.includes('${data.')) {
-                    file = this.adapter.config.importFileContent;
-                }
-
-                this.adapter.log.debug(`[importCSV] Medium: ${medium}, File length: ${file?.length || 0}`);
-
-                if (!medium || !file) {
-                    this.adapter.sendTo(
-                        obj.from,
-                        obj.command,
-                        { error: 'Bitte Medium auswählen, CSV-Inhalt einfügen und dann SPEICHERN klicken, bevor du importierst!' },
-                        obj.callback,
-                    );
-                    return;
-                }
-
-                // File comes as data URL (data:text/csv;base64,...)
-                let content;
-                if (file.includes('base64,')) {
-                    // Extract base64 content
-                    const base64Content = file.split('base64,')[1];
-                    content = Buffer.from(base64Content, 'base64').toString('utf-8');
-                } else {
-                    // Plain text
-                    content = file;
-                }
-
-                // Import the CSV
-                const result = await this.importManager.importCSV(medium, content);
-
-                this.adapter.sendTo(obj.from, obj.command, result, obj.callback);
-            } catch (error) {
-                this.adapter.log.error(`[importCSV] Error: ${error.message}`);
-                this.adapter.sendTo(
-                    obj.from,
-                    obj.command,
-                    { error: error.message },
-                    obj.callback,
-                );
-            }
         } else {
             this.adapter.log.warn(`[onMessage] Unknown command: ${obj.command}`);
             if (obj.callback) {
@@ -225,43 +192,66 @@ class MessagingHandler {
                 continue;
             }
 
-            // Get current days remaining
-            const daysRemainingState = await this.adapter.getStateAsync(`${type}.billing.daysRemaining`);
-            const daysRemaining = typeof daysRemainingState?.val === 'number' ? daysRemainingState.val : 999;
-            const periodEndState = await this.adapter.getStateAsync(`${type}.billing.periodEnd`);
-            const periodEnd = periodEndState?.val || '--.--.----';
-
-            // 1. BILLING END REMINDER (Zählerstand ablesen)
-            if (this.adapter.config.notificationBillingEnabled) {
-                const billingSent = await this.adapter.getStateAsync(`${type}.billing.notificationSent`);
-                const billingDaysThreshold = this.adapter.config.notificationBillingDays || 7;
-
-                if (billingSent?.val !== true && daysRemaining <= billingDaysThreshold) {
-                    const message =
-                        `🔔 *Nebenkosten-Monitor: Zählerstand ablesen*\n\n` +
-                        `Dein Abrechnungszeitraum für *${typesDe[type]}* endet in ${daysRemaining} Tagen!\n\n` +
-                        `📅 Datum: ${periodEnd}\n\n` +
-                        `Bitte trage den Zählerstand rechtzeitig ein:\n` +
-                        `1️⃣ Datenpunkt: ${type}.billing.endReading\n` +
-                        `2️⃣ Zeitraum abschließen: ${type}.billing.closePeriod = true`;
-
-                    await this.sendNotification(type, message, 'billing');
-                }
+            // Get all meters for this type (main + additional)
+            const allMeters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+            if (allMeters.length === 0) {
+                continue;
+            }
+
+            // Filter meters based on configuration
+            // If notificationXXXMeters is empty or undefined, notify ALL meters
+            const configKey = `notification${configType.charAt(0).toUpperCase() + configType.slice(1)}Meters`;
+            const selectedMeters = this.adapter.config[configKey];
+
+            let metersToNotify = allMeters;
+            if (selectedMeters && Array.isArray(selectedMeters) && selectedMeters.length > 0) {
+                // Filter: only notify selected meters
+                metersToNotify = allMeters.filter(meter => selectedMeters.includes(meter.name));
             }
 
-            // 2. CONTRACT CHANGE REMINDER (Tarif wechseln / Kündigungsfrist)
-            if (this.adapter.config.notificationChangeEnabled) {
-                const changeSent = await this.adapter.getStateAsync(`${type}.billing.notificationChangeSent`);
-                const changeDaysThreshold = this.adapter.config.notificationChangeDays || 60;
+            // Check notifications for each meter individually
+            for (const meter of metersToNotify) {
+                const basePath = `${type}.${meter.name}`;
+                const meterLabel = meter.displayName || meter.name;
+
+                // Get current days remaining for THIS meter
+                const daysRemainingState = await this.adapter.getStateAsync(`${basePath}.billing.daysRemaining`);
+                const daysRemaining = typeof daysRemainingState?.val === 'number' ? daysRemainingState.val : 999;
+                const periodEndState = await this.adapter.getStateAsync(`${basePath}.billing.periodEnd`);
+                const periodEnd = periodEndState?.val || '--.--.----';
+
+                // 1. BILLING END REMINDER (Zählerstand ablesen)
+                if (this.adapter.config.notificationBillingEnabled) {
+                    const billingSent = await this.adapter.getStateAsync(`${basePath}.billing.notificationSent`);
+                    const billingDaysThreshold = this.adapter.config.notificationBillingDays || 7;
+
+                    if (billingSent?.val !== true && daysRemaining <= billingDaysThreshold) {
+                        const message =
+                            `🔔 *Nebenkosten-Monitor: Zählerstand ablesen*\n\n` +
+                            `Dein Abrechnungszeitraum für *${typesDe[type]} (${meterLabel})* endet in ${daysRemaining} Tagen!\n\n` +
+                            `📅 Datum: ${periodEnd}\n\n` +
+                            `Bitte trage den Zählerstand rechtzeitig ein:\n` +
+                            `1️⃣ Datenpunkt: ${basePath}.billing.endReading\n` +
+                            `2️⃣ Zeitraum abschließen: ${basePath}.billing.closePeriod = true`;
+
+                        await this.sendNotification(basePath, message, 'billing');
+                    }
+                }
+
+                // 2. CONTRACT CHANGE REMINDER (Tarif wechseln / Kündigungsfrist)
+                if (this.adapter.config.notificationChangeEnabled) {
+                    const changeSent = await this.adapter.getStateAsync(`${basePath}.billing.notificationChangeSent`);
+                    const changeDaysThreshold = this.adapter.config.notificationChangeDays || 60;
 
-                if (changeSent?.val !== true && daysRemaining <= changeDaysThreshold) {
-                    const message =
-                        `💡 *Nebenkosten-Monitor: Tarif-Check*\n\n` +
-                        `Dein Vertrag für *${typesDe[type]}* endet am ${periodEnd}.\n\n` +
-                        `⏰ Noch ${daysRemaining} Tage bis zum Ende des Zeitraums.\n\n` +
-                        `Jetzt ist ein guter Zeitpunkt, um Preise zu vergleichen oder die Kündigungsfrist zu prüfen! 💸`;
+                    if (changeSent?.val !== true && daysRemaining <= changeDaysThreshold) {
+                        const message =
+                            `💡 *Nebenkosten-Monitor: Tarif-Check*\n\n` +
+                            `Dein Vertrag für *${typesDe[type]} (${meterLabel})* endet am ${periodEnd}.\n\n` +
+                            `⏰ Noch ${daysRemaining} Tage bis zum Ende des Zeitraums.\n\n` +
+                            `Jetzt ist ein guter Zeitpunkt, um Preise zu vergleichen oder die Kündigungsfrist zu prüfen! 💸`;
 
-                    await this.sendNotification(type, message, 'change');
+                        await this.sendNotification(basePath, message, 'change');
+                    }
                 }
             }
         }
@@ -320,16 +310,24 @@ class MessagingHandler {
                 // Multi-meter: use totals
                 yearlyState = await this.adapter.getStateAsync(`${type}.totals.consumption.yearly`);
                 totalYearlyState = await this.adapter.getStateAsync(`${type}.totals.costs.totalYearly`);
-                // Balance/paidTotal not available in totals, use main meter as representative
-                paidTotalState = await this.adapter.getStateAsync(`${type}.costs.paidTotal`);
-                balanceState = await this.adapter.getStateAsync(`${type}.costs.balance`);
+                // Balance/paidTotal not available in totals, use first meter as representative
+                const firstMeter = meters[0];
+                if (firstMeter) {
+                    paidTotalState = await this.adapter.getStateAsync(`${type}.${firstMeter.name}.costs.paidTotal`);
+                    balanceState = await this.adapter.getStateAsync(`${type}.${firstMeter.name}.costs.balance`);
+                }
                 message += `(${meters.length} Zähler gesamt)\\n`;
+            } else if (meters.length === 1) {
+                // Single meter: use first meter values (new path structure)
+                const meter = meters[0];
+                const basePath = `${type}.${meter.name}`;
+                yearlyState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+                totalYearlyState = await this.adapter.getStateAsync(`${basePath}.costs.totalYearly`);
+                paidTotalState = await this.adapter.getStateAsync(`${basePath}.costs.paidTotal`);
+                balanceState = await this.adapter.getStateAsync(`${basePath}.costs.balance`);
             } else {
-                // Single meter: use main meter values
-                yearlyState = await this.adapter.getStateAsync(`${type}.consumption.yearly`);
-                totalYearlyState = await this.adapter.getStateAsync(`${type}.costs.totalYearly`);
-                paidTotalState = await this.adapter.getStateAsync(`${type}.costs.paidTotal`);
-                balanceState = await this.adapter.getStateAsync(`${type}.costs.balance`);
+                // No meters configured - skip this type
+                continue;
             }
 
             let val = yearlyState?.val || 0;
@@ -372,14 +370,14 @@ class MessagingHandler {
     /**
      * Helper to send notification and mark as sent
      *
-     * @param {string} type - gas, water, electricity
+     * @param {string} pathOrType - Full path like "gas.main" or just "system" for reports
      * @param {string} message - Message text
      * @param {string} reminderType - billing, change, or report
      */
-    async sendNotification(type, message, reminderType) {
+    async sendNotification(pathOrType, message, reminderType) {
         try {
             const instance = this.adapter.config.notificationInstance;
-            this.adapter.log.info(`Sending ${reminderType} notification for ${type} via ${instance}`);
+            this.adapter.log.info(`Sending ${reminderType} notification for ${pathOrType} via ${instance}`);
 
             await this.adapter.sendToAsync(instance, 'send', {
                 text: message,
@@ -388,12 +386,13 @@ class MessagingHandler {
             });
 
             // Mark as sent (only for billing/change)
+            // pathOrType is now the full path like "gas.main" or "gas.werkstatt"
             if (reminderType !== 'report') {
                 const stateKey = reminderType === 'change' ? 'notificationChangeSent' : 'notificationSent';
-                await this.adapter.setStateAsync(`${type}.billing.${stateKey}`, true, true);
+                await this.adapter.setStateAsync(`${pathOrType}.billing.${stateKey}`, true, true);
             }
         } catch (error) {
-            this.adapter.log.error(`Failed to send ${reminderType} notification for ${type}: ${error.message}`);
+            this.adapter.log.error(`Failed to send ${reminderType} notification for ${pathOrType}: ${error.message}`);
         }
     }
 }

package/lib/multiMeterManager.js

@@ -70,8 +70,14 @@ class MultiMeterManager {
         // Main meter (always present if type is active)
         const mainActive = this.adapter.config[`${configType}Aktiv`];
         if (mainActive) {
+            // Get main meter name from config and normalize
+            const mainMeterName = this.adapter.config[`${configType}MainMeterName`] || 'main';
+            const normalizedName = this.normalizeMeterName(mainMeterName);
+            const displayName = mainMeterName; // Original name for display
+
             meters.push({
-                name: 'main',
+                name: normalizedName,
+                displayName: displayName,
                 config: {
                     sensorDP: this.adapter.config[`${configType}SensorDP`],
                     preis: parseConfigNumber(this.adapter.config[`${configType}Preis`], 0),
@@ -173,7 +179,7 @@ class MultiMeterManager {
      * @returns {Promise<void>}
      */
     async initializeMeter(type, meterName, config, displayName) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
         const label = displayName || meterName;
 
         this.adapter.log.info(`Initializing ${type} meter: ${label}`);
@@ -349,7 +355,7 @@ class MultiMeterManager {
             return;
         }
 
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
         this.adapter.log.debug(`Sensor update for ${basePath}: ${value}`);
 
         // Get meter config
@@ -491,14 +497,14 @@ class MultiMeterManager {
      * @param {object} config - Meter configuration
      */
     async updateCurrentPrice(type, meterName, config) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
         const configType = this.getConfigType(type);
 
         let tariffName = 'Standard';
         let activePrice = config.preis || 0;
 
-        // Only main meter supports HT/NT
-        if (meterName === 'main' && config.htNtEnabled) {
+        // Only meters with HT/NT enabled support it
+        if (config.htNtEnabled) {
             const isHT = calculator.isHTTime(this.adapter.config, configType);
             if (isHT) {
                 activePrice = this.adapter.config[`${configType}HtPrice`] || 0;
@@ -526,7 +532,7 @@ class MultiMeterManager {
      * @param {object} config - Meter configuration
      */
     async updateCosts(type, meterName, config) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
 
         // Get consumption values
         const daily = (await this.adapter.getStateAsync(`${basePath}.consumption.daily`))?.val || 0;
@@ -549,86 +555,60 @@ class MultiMeterManager {
         await this.adapter.setStateAsync(`${basePath}.costs.monthly`, calculator.roundToDecimals(monthlyCost, 2), true);
         await this.adapter.setStateAsync(`${basePath}.costs.yearly`, calculator.roundToDecimals(yearlyCost, 2), true);
 
-        await this.adapter.setStateAsync(`${basePath}.costs.basicCharge`, Number(config.grundgebuehr) || 0, true);
-
-        // Calculate annual fee (prorated)
+        // Calculate accumulated costs based on contract start
         const yearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
-        let annualFeeAccumulated = 0;
+        let monthsSinceYearStart = 1;
+        let basicChargeAccumulated = 0;
 
         if (yearStartState && yearStartState.val) {
             // yearStartState.val is a timestamp (number)
             const yearStartDate = new Date(yearStartState.val);
             if (!isNaN(yearStartDate.getTime())) {
                 const now = new Date();
-                const yearStartTime = yearStartDate.getTime();
-                const nowTime = now.getTime();
-                const daysSinceYearStart = Math.floor((nowTime - yearStartTime) / (1000 * 60 * 60 * 24));
-                const daysInYear = calculator.isLeapYear(now.getFullYear()) ? 366 : 365;
-                annualFeeAccumulated = ((config.jahresgebuehr || 0) / daysInYear) * daysSinceYearStart;
+
+                // Calculate months since contract start (started months, including current)
+                monthsSinceYearStart = calculator.getMonthsDifference(yearStartDate, now) + 1;
+
+                // Calculate accumulated basic charge (monthly fee × months)
+                basicChargeAccumulated = (config.grundgebuehr || 0) * monthsSinceYearStart;
             }
         }
 
+        // Jahresgebühr ist ein FIXER Wert pro Jahr (z.B. 60€)
+        // NICHT pro-rata nach Monaten/Tagen berechnen!
+        const annualFeeAccumulated = config.jahresgebuehr || 0;
+
+        // Update basicCharge with accumulated value (not just monthly!)
+        await this.adapter.setStateAsync(
+            `${basePath}.costs.basicCharge`,
+            calculator.roundToDecimals(basicChargeAccumulated, 2),
+            true,
+        );
+
         await this.adapter.setStateAsync(
             `${basePath}.costs.annualFee`,
             calculator.roundToDecimals(annualFeeAccumulated, 2),
             true,
         );
 
-        // Calculate balance and total yearly costs
-        if (yearStartState && yearStartState.val) {
-            // yearStartState.val is a timestamp (number)
-            const yearStartDate = new Date(yearStartState.val);
-            if (!isNaN(yearStartDate.getTime())) {
-                const now = new Date();
-                // Calculate paid total based on started months (not just completed months)
-                // If current month has started, count it as paid
-                const monthsSinceYearStart = calculator.getMonthsDifference(yearStartDate, now) + 1;
+        // Calculate total yearly costs and balance
+        const totalYearlyCost = yearlyCost + basicChargeAccumulated + annualFeeAccumulated;
 
-                // Calculate total yearly costs with correct months
-                const basicChargeAccumulated = (config.grundgebuehr || 0) * monthsSinceYearStart;
-                const totalYearlyCost = yearlyCost + basicChargeAccumulated + annualFeeAccumulated;
-
-                await this.adapter.setStateAsync(
-                    `${basePath}.costs.totalYearly`,
-                    calculator.roundToDecimals(totalYearlyCost, 2),
-                    true,
-                );
+        await this.adapter.setStateAsync(
+            `${basePath}.costs.totalYearly`,
+            calculator.roundToDecimals(totalYearlyCost, 2),
+            true,
+        );
 
-                const paidTotal = (config.abschlag || 0) * monthsSinceYearStart;
-                const balance = paidTotal - totalYearlyCost;
+        const paidTotal = (config.abschlag || 0) * monthsSinceYearStart;
+        const balance = totalYearlyCost - paidTotal;
 
-                this.adapter.log.debug(
-                    `[${basePath}] Balance calculation: abschlag=${config.abschlag}, months=${monthsSinceYearStart}, paidTotal=${paidTotal.toFixed(2)}, totalYearly=${totalYearlyCost.toFixed(2)}, balance=${balance.toFixed(2)}`,
-                );
+        this.adapter.log.debug(
+            `[${basePath}] Balance calculation: grundgebuehr=${config.grundgebuehr}, jahresgebuehr=${config.jahresgebuehr}, abschlag=${config.abschlag}, months=${monthsSinceYearStart}, basicCharge=${basicChargeAccumulated.toFixed(2)}, annualFee=${annualFeeAccumulated.toFixed(2)}, paidTotal=${paidTotal.toFixed(2)}, totalYearly=${totalYearlyCost.toFixed(2)}, balance=${balance.toFixed(2)}`,
+        );
 
-                await this.adapter.setStateAsync(
-                    `${basePath}.costs.paidTotal`,
-                    calculator.roundToDecimals(paidTotal, 2),
-                    true,
-                );
-                await this.adapter.setStateAsync(
-                    `${basePath}.costs.balance`,
-                    calculator.roundToDecimals(balance, 2),
-                    true,
-                );
-            } else {
-                // Fallback if yearStartDate parsing fails
-                const totalYearlyCost = yearlyCost + annualFeeAccumulated;
-                await this.adapter.setStateAsync(
-                    `${basePath}.costs.totalYearly`,
-                    calculator.roundToDecimals(totalYearlyCost, 2),
-                    true,
-                );
-            }
-        } else {
-            // Fallback if no yearStartState exists
-            const totalYearlyCost = yearlyCost + annualFeeAccumulated;
-            await this.adapter.setStateAsync(
-                `${basePath}.costs.totalYearly`,
-                calculator.roundToDecimals(totalYearlyCost, 2),
-                true,
-            );
-        }
+        await this.adapter.setStateAsync(`${basePath}.costs.paidTotal`, calculator.roundToDecimals(paidTotal, 2), true);
+        await this.adapter.setStateAsync(`${basePath}.costs.balance`, calculator.roundToDecimals(balance, 2), true);
     }
 
     /**
@@ -652,7 +632,7 @@ class MultiMeterManager {
         let totalCostsYearly = 0;
 
         for (const meter of meters) {
-            const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+            const basePath = `${type}.${meter.name}`;
 
             totalDaily += (await this.adapter.getStateAsync(`${basePath}.consumption.daily`))?.val || 0;
             totalMonthly += (await this.adapter.getStateAsync(`${basePath}.consumption.monthly`))?.val || 0;

package/lib/stateManager.js

@@ -817,11 +817,12 @@ async function createUtilityStateStructure(adapter, type, _config = {}) {
 async function createMeterStructure(adapter, type, meterName, _config = {}) {
     const isGas = type === 'gas';
 
+    // All meters now include the meter name in labels for consistency
     const labels = {
-        gas: { name: meterName === 'main' ? 'Gas' : `Gas (${meterName})`, unit: 'kWh', volumeUnit: 'm³' },
-        water: { name: meterName === 'main' ? 'Wasser' : `Wasser (${meterName})`, unit: 'm³', volumeUnit: 'm³' },
-        electricity: { name: meterName === 'main' ? 'Strom' : `Strom (${meterName})`, unit: 'kWh', volumeUnit: 'kWh' },
-        pv: { name: meterName === 'main' ? 'PV' : `PV (${meterName})`, unit: 'kWh', volumeUnit: 'kWh' },
+        gas: { name: `Gas (${meterName})`, unit: 'kWh', volumeUnit: 'm³' },
+        water: { name: `Wasser (${meterName})`, unit: 'm³', volumeUnit: 'm³' },
+        electricity: { name: `Strom (${meterName})`, unit: 'kWh', volumeUnit: 'kWh' },
+        pv: { name: `PV (${meterName})`, unit: 'kWh', volumeUnit: 'kWh' },
     };
 
     const label = labels[type];
@@ -832,7 +833,7 @@ async function createMeterStructure(adapter, type, meterName, _config = {}) {
         // Fallback to prevent crash
         return;
     }
-    const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+    const basePath = `${type}.${meterName}`;
 
     // Create main channel
     await adapter.setObjectNotExistsAsync(basePath, {

package/main.js

@@ -44,26 +44,12 @@ class UtilityMonitor extends utils.Adapter {
         this.multiMeterManager = new MultiMeterManager(this, this.consumptionManager, this.billingManager);
 
         // Initialize each utility type based on configuration
+        // Note: initializeUtility() internally calls multiMeterManager.initializeType()
         await this.initializeUtility('gas', this.config.gasAktiv);
         await this.initializeUtility('water', this.config.wasserAktiv);
         await this.initializeUtility('electricity', this.config.stromAktiv);
-
         await this.initializeUtility('pv', this.config.pvAktiv);
 
-        // Initialize Multi-Meter structures for each active type
-        if (this.config.gasAktiv) {
-            await this.multiMeterManager.initializeType('gas');
-        }
-        if (this.config.wasserAktiv) {
-            await this.multiMeterManager.initializeType('water');
-        }
-        if (this.config.stromAktiv) {
-            await this.multiMeterManager.initializeType('electricity');
-        }
-        if (this.config.pvAktiv) {
-            await this.multiMeterManager.initializeType('pv');
-        }
-
         // Initialize General Info States
         await this.setObjectNotExistsAsync('info', {
             type: 'channel',
@@ -209,20 +195,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
@@ -235,24 +216,42 @@ 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];
+
+                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;
+            }
         }
 
         // Determine which utility this sensor belongs to
-        // First check if it's a multi-meter sensor (additional meters)
+        // All meters (including main) are now handled by multiMeterManager
         if (this.multiMeterManager) {
             const meterInfo = this.multiMeterManager.findMeterBySensor(id);
             if (meterInfo && typeof state.val === 'number') {
@@ -260,19 +259,6 @@ class UtilityMonitor extends utils.Adapter {
                 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);
-                }
-                return;
-            }
-        }
     }
 
     /**