iobroker.utility-monitor 1.4.5 → 1.5.0

package/lib/importManager.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const calculator = require('./calculator');
+const { getConfigType } = require('./utils/typeMapper');
+const stateManager = require('./stateManager');
+
+/**
+ * ImportManager handles CSV file parsing and data importing
+ * for utility-monitor historical data.
+ */
+class ImportManager {
+    /**
+     * @param {object} adapter - ioBroker adapter instance
+     */
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+
+    /**
+     * Handles the 'importCSV' message from the Admin UI
+     *
+     * @param {Record<string, any>} obj - Message object
+     */
+    async handleImportCSV(obj) {
+        if (!obj || !obj.message) {
+            return;
+        }
+
+        const { type, meterName, content, format } = obj.message;
+
+        this.adapter.log.info(`[Import] Starting CSV import for ${type}.${meterName} (Format: ${format || 'generic'})`);
+
+        try {
+            const result = await this.processImport(type, meterName, content, format);
+
+            if (obj.callback) {
+                this.adapter.sendTo(obj.from, obj.command, result, obj.callback);
+            }
+        } catch (error) {
+            this.adapter.log.error(`[Import] Failed to process CSV: ${error.message}`);
+            if (obj.callback) {
+                this.adapter.sendTo(obj.from, obj.command, { error: error.message }, obj.callback);
+            }
+        }
+    }
+
+    /**
+     * Parses and processes the CSV content
+     *
+     * @param {string} type - gas, water, electricity
+     * @param {string} meterName - technical name of the meter
+     * @param {string} content - raw CSV content (base64 or string)
+     * @param {string} _format - format profile (e.g. 'ehb')
+     */
+    async processImport(type, meterName, content, _format) {
+        // Decode base64 if necessary
+        let csvBody = content;
+        if (content.startsWith('data:') && content.includes('base64,')) {
+            const base64Data = content.split('base64,')[1];
+            csvBody = Buffer.from(base64Data, 'base64').toString('utf-8');
+        }
+
+        const lines = csvBody.split(/\r?\n/).filter(line => line.trim() !== '');
+        if (lines.length < 2) {
+            throw new Error('Die Datei ist leer oder enthält zu wenige Daten.');
+        }
+
+        // Detect separator by looking at the first 5 lines and picking the most frequent separator
+        const possibleSeparators = [';', ',', '|', '\t'];
+        let separator = ';';
+        let maxTotalCols = 0;
+
+        for (const sep of possibleSeparators) {
+            let totalCols = 0;
+            for (let i = 0; i < Math.min(lines.length, 5); i++) {
+                totalCols += lines[i].split(sep).length;
+            }
+            if (totalCols > maxTotalCols) {
+                maxTotalCols = totalCols;
+                separator = sep;
+            }
+        }
+
+        let headers = lines[0].split(separator).map(h => h.trim().toLowerCase().replace(/^"|"$/g, ''));
+
+        // Column detection
+        let dateIdx = -1;
+        let valueIdx = -1;
+
+        const dateHeaders = ['date', 'datum', 'zeit', 'timestamp', 'zeitstempel', 'day', 'tag', 'ablesedatum'];
+        const valueHeaders = [
+            'value',
+            'wert',
+            'reading',
+            'zählerstand',
+            'stand',
+            'verbrauch',
+            'amount',
+            'kwh',
+            'm³',
+            'm3',
+            'ablesewert',
+            'wasserstand',
+            'gasstand',
+            'stromstand',
+            'kaltwasser',
+            'warmwasser',
+            'energie',
+        ];
+
+        dateIdx = headers.findIndex(h => dateHeaders.some(dh => h.includes(dh)));
+        valueIdx = headers.findIndex(h => valueHeaders.some(vh => h.includes(vh)));
+
+        // Special case: If header is just numbers or very common terms, try searching for the specific media name
+        if (valueIdx === -1) {
+            const mediaTerms = { gas: 'gas', water: 'wasser', electricity: 'strom', pv: 'pv' };
+            const term = mediaTerms[type];
+            valueIdx = headers.findIndex(h => h.includes(term));
+        }
+
+        // Fallback to defaults if not found by header
+        if (dateIdx === -1) {
+            dateIdx = 0;
+        }
+        if (valueIdx === -1) {
+            valueIdx = 1;
+        }
+
+        this.adapter.log.info(
+            `[Import] Found headers: [${headers.join(' | ')}]. Selected columns: Date="${headers[dateIdx]}" (Index ${dateIdx}), Value="${headers[valueIdx]}" (Index ${valueIdx}) (Separator: "${separator}")`,
+        );
+
+        // Check if first line is actually data (contains numbers or date-like string)
+        let startIndex = 1;
+        const firstLineCols = lines[0].split(separator).map(c => c.trim().replace(/^"|"$/g, ''));
+        const dateStrFirst = firstLineCols[dateIdx] || '';
+        const isFirstLineData = !isNaN(parseFloat(firstLineCols[valueIdx])) || dateStrFirst.includes(':');
+
+        if (isFirstLineData) {
+            const hasHeaderText = headers.some(h =>
+                [...dateHeaders, ...valueHeaders].some(term => h.includes(term) && h.length > 2),
+            );
+            if (!hasHeaderText) {
+                startIndex = 0;
+                this.adapter.log.info('[Import] First line appears to be data, including it.');
+            }
+        }
+
+        const dataPoints = [];
+        for (let i = startIndex; i < lines.length; i++) {
+            const columns = lines[i].split(separator).map(c => c.trim().replace(/^"|"$/g, ''));
+            if (columns.length <= Math.max(dateIdx, valueIdx)) {
+                continue;
+            }
+
+            const dateStr = columns[dateIdx];
+            const valueStr = columns[valueIdx];
+
+            let timestamp = null;
+            let value = calculator.ensureNumber(valueStr);
+
+            // Robust Date Parsing
+            timestamp = calculator.parseDateString(dateStr);
+
+            if (!timestamp && !isNaN(Number(dateStr)) && dateStr.length > 10) {
+                // Possibly Unix Timestamp (ms)
+                timestamp = new Date(Number(dateStr));
+            }
+
+            if (timestamp && !isNaN(timestamp.getTime()) && value > 0) {
+                dataPoints.push({ timestamp, value });
+            }
+        }
+
+        if (dataPoints.length === 0) {
+            this.adapter.log.warn(
+                `[Import] No valid data found. Headers: ${headers.join('|')}, First Data Line: ${lines[1]}`,
+            );
+            throw new Error(
+                'Keine gültigen Datenpunkte gefunden. Bitte sicherstellen, dass die Datei Spalten für Datum und Wert enthält.',
+            );
+        }
+
+        // Sort by timestamp
+        dataPoints.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+        this.adapter.log.info(
+            `[Import] Found ${dataPoints.length} valid records from ${dataPoints[0].timestamp.toLocaleDateString()} to ${dataPoints[dataPoints.length - 1].timestamp.toLocaleDateString()}`,
+        );
+
+        // Pure History Import: Aggregates only
+        const basePath = `${type}.${meterName}`;
+
+        // Ensure channel and metadata structure
+        await this.ensureMeterObjects(type, meterName);
+
+        const currentYear = new Date().getFullYear();
+        const yearStats = {};
+
+        let count = 0;
+        for (const dp of dataPoints) {
+            try {
+                const year = dp.timestamp.getFullYear();
+
+                // Group by year for history states
+                if (year < currentYear) {
+                    if (!yearStats[year]) {
+                        yearStats[year] = { consumption: 0, volume: 0, count: 0 };
+                        await stateManager.createHistoryStructure(this.adapter, type, meterName, year);
+                    }
+                    yearStats[year].consumption += dp.value;
+                    if (type === 'gas') {
+                        const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
+                        const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
+                        yearStats[year].volume += dp.value / (brennwert * zZahl);
+                    }
+                    yearStats[year].count++;
+                }
+
+                // No individual writing to meterReading state needed for pure history
+                count++;
+            } catch (e) {
+                this.adapter.log.error(`[Import] Error writing data point ${dp.timestamp.toISOString()}: ${e.message}`);
+            }
+        }
+
+        // Write aggregated history states
+        for (const year in yearStats) {
+            const hPath = `${basePath}.history.${year}`;
+            const stats = yearStats[year];
+            await this.adapter.setStateAsync(
+                `${hPath}.consumption`,
+                calculator.roundToDecimals(stats.consumption, 2),
+                true,
+            );
+            if (type === 'gas') {
+                await this.adapter.setStateAsync(`${hPath}.volume`, calculator.roundToDecimals(stats.volume, 2), true);
+            }
+            // Recalculate costs for history year roughly using current price
+            const configType = getConfigType(type);
+            const price = this.adapter.config[`${configType}Preis`] || 0;
+            await this.adapter.setStateAsync(
+                `${hPath}.costs`,
+                calculator.roundToDecimals(stats.consumption * price, 2),
+                true,
+            );
+        }
+
+        // Update metadata for pure history import
+        await this.adapter.setStateAsync(`${basePath}.lastImport`, Date.now(), true);
+
+        return {
+            success: true,
+            count: count,
+            first: dataPoints[0].timestamp.toLocaleDateString(),
+            last: dataPoints[dataPoints.length - 1].timestamp.toLocaleDateString(),
+        };
+    }
+
+    /**
+     * Ensures that the minimal object structure for a meter exists (FLAT structure for imports)
+     *
+     * @param {string} type - gas, water, electricity, pv
+     * @param {string} meterName - name of the meter
+     */
+    async ensureMeterObjects(type, meterName) {
+        const basePath = `${type}.${meterName}`;
+        const typeDe = { gas: 'Gas', water: 'Wasser', electricity: 'Strom', pv: 'PV' };
+
+        // 1. Create Channel for Type (if not exists)
+        await this.adapter.setObjectNotExistsAsync(type, {
+            type: 'channel',
+            common: { name: typeDe[type] || type },
+            native: {},
+        });
+
+        // 2. Create Channel for Meter
+        await this.adapter.setObjectNotExistsAsync(basePath, {
+            type: 'channel',
+            common: { name: `Zähler: ${meterName}` },
+            native: { meterName },
+        });
+
+        // 3. Create metadata (last import timestamp)
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.lastImport`, {
+            type: 'state',
+            common: {
+                name: 'Letzter Import',
+                type: 'number',
+                role: 'value.time',
+                read: true,
+                write: false,
+                def: 0,
+            },
+            native: {},
+        });
+    }
+}
+
+module.exports = ImportManager;

package/lib/messagingHandler.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { getConfigType } = require('./utils/typeMapper');
+
 /**
  * MessagingHandler handles all incoming adapter messages
  * and outgoing notifications.
@@ -24,7 +26,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 = [
@@ -156,50 +187,73 @@ class MessagingHandler {
         const typesDe = { gas: 'Gas', water: 'Wasser', electricity: 'Strom', pv: 'PV' };
 
         for (const type of types) {
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             const enabledKey = `notification${configType.charAt(0).toUpperCase() + configType.slice(1)}Enabled`;
 
             if (!this.adapter.config[enabledKey] || !this.adapter.config[`${configType}Aktiv`]) {
                 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');
+                    }
                 }
             }
         }
@@ -238,7 +292,7 @@ class MessagingHandler {
         let hasData = false;
 
         for (const type of types) {
-            const configType = this.adapter.consumptionManager.getConfigType(type); // strom, gas, wasser, pv
+            const configType = getConfigType(type); // strom, gas, wasser, pv
 
             if (!this.adapter.config[`${configType}Aktiv`]) {
                 continue;
@@ -258,16 +312,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;
@@ -310,14 +372,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,
@@ -326,12 +388,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/meter/MeterRegistry.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * MeterRegistry manages the mapping between sensor data points and meters.
+ * Each sensor can be associated with one or more meters of different types.
+ */
+class MeterRegistry {
+    /**
+     * Initializes the registry
+     */
+    constructor() {
+        // Maps sensorDP to array of {type, meterName}
+        this.registry = {};
+    }
+
+    /**
+     * Registers a sensor with a meter
+     *
+     * @param {string} sensorDP - Sensor data point ID
+     * @param {string} type - Utility type (gas, water, electricity, pv)
+     * @param {string} meterName - Name of the meter
+     */
+    register(sensorDP, type, meterName) {
+        if (!sensorDP) {
+            return;
+        }
+
+        if (!this.registry[sensorDP]) {
+            this.registry[sensorDP] = [];
+        }
+
+        // Check if already registered
+        const exists = this.registry[sensorDP].some(entry => entry.type === type && entry.meterName === meterName);
+
+        if (!exists) {
+            this.registry[sensorDP].push({ type, meterName });
+        }
+    }
+
+    /**
+     * Finds all meters associated with a sensor
+     *
+     * @param {string} sensorDP - Sensor data point ID
+     * @returns {Array<{type: string, meterName: string}>} Array of meter entries
+     */
+    findBySensor(sensorDP) {
+        return this.registry[sensorDP] || [];
+    }
+
+    /**
+     * Removes a meter from a sensor
+     *
+     * @param {string} sensorDP - Sensor data point ID
+     * @param {string} type - Utility type
+     * @param {string} meterName - Name of the meter
+     */
+    unregister(sensorDP, type, meterName) {
+        if (!this.registry[sensorDP]) {
+            return;
+        }
+
+        this.registry[sensorDP] = this.registry[sensorDP].filter(
+            entry => !(entry.type === type && entry.meterName === meterName),
+        );
+
+        // Clean up empty entries
+        if (this.registry[sensorDP].length === 0) {
+            delete this.registry[sensorDP];
+        }
+    }
+
+    /**
+     * Clears all registrations for a sensor
+     *
+     * @param {string} sensorDP - Sensor data point ID
+     */
+    clearSensor(sensorDP) {
+        delete this.registry[sensorDP];
+    }
+
+    /**
+     * Gets all registered sensors
+     *
+     * @returns {string[]} Array of sensor data point IDs
+     */
+    getAllSensors() {
+        return Object.keys(this.registry);
+    }
+
+    /**
+     * Gets the complete registry
+     *
+     * @returns {object} The registry object
+     */
+    getRegistry() {
+        return this.registry;
+    }
+
+    /**
+     * Checks if a sensor is registered
+     *
+     * @param {string} sensorDP - Sensor data point ID
+     * @returns {boolean} True if sensor is registered
+     */
+    hasSensor(sensorDP) {
+        return !!this.registry[sensorDP];
+    }
+}
+
+module.exports = MeterRegistry;