iobroker.utility-monitor 1.4.2

package/main.js

@@ -0,0 +1,297 @@
+'use strict';
+
+/*
+ * ioBroker Nebenkosten-Monitor Adapter
+ * Monitors gas, water, and electricity consumption with cost calculation
+ */
+
+const utils = require('@iobroker/adapter-core');
+const ConsumptionManager = require('./lib/consumptionManager');
+const BillingManager = require('./lib/billingManager');
+const MessagingHandler = require('./lib/messagingHandler');
+const MultiMeterManager = require('./lib/multiMeterManager');
+
+class NebenkostenMonitor extends utils.Adapter {
+    /**
+     * @param {Partial<utils.AdapterOptions>} [options] - Adapter options
+     */
+    constructor(options) {
+        super({
+            ...options,
+            name: 'nebenkosten-monitor',
+        });
+        this.on('ready', this.onReady.bind(this));
+        this.on('stateChange', this.onStateChange.bind(this));
+        this.on('unload', this.onUnload.bind(this));
+        this.on('message', this.onMessage.bind(this));
+
+        // Initialize Managers
+        this.consumptionManager = new ConsumptionManager(this);
+        this.billingManager = new BillingManager(this);
+        this.messagingHandler = new MessagingHandler(this);
+        this.multiMeterManager = null; // Initialized in onReady after other managers
+
+        this.periodicTimers = {};
+    }
+
+    /**
+     * Is called when databases are connected and adapter received configuration.
+     */
+    async onReady() {
+        this.log.info('Nebenkosten-Monitor starting...');
+
+        // Initialize MultiMeterManager
+        this.multiMeterManager = new MultiMeterManager(this, this.consumptionManager, this.billingManager);
+
+        // Initialize each utility type based on configuration
+        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',
+            common: { name: 'General Information' },
+            native: {},
+        });
+        await this.setObjectNotExistsAsync('info.lastMonthlyReport', {
+            type: 'state',
+            common: {
+                name: 'Last Monthly Report Sent Date',
+                type: 'string', // Storing ISO date string 'YYYY-MM-DD'
+                role: 'date',
+                read: true,
+                write: true,
+                def: '',
+            },
+            native: {},
+        });
+
+        // Subscribe to billing period closure triggers
+        this.subscribeStates('*.billing.closePeriod');
+
+        // Subscribe to manual adjustment changes
+        this.subscribeStates('*.adjustment.value');
+        this.subscribeStates('*.adjustment.note');
+
+        // Set up periodic tasks
+        this.setupPeriodicTasks();
+
+        this.log.info('Nebenkosten-Monitor initialized successfully');
+    }
+
+    // --- 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);
+    }
+
+    async updateCosts(type) {
+        // For Multi-Meter setups, delegate to multiMeterManager
+        if (this.multiMeterManager) {
+            const meters = this.multiMeterManager.getMetersForType(type);
+            if (meters.length > 0) {
+                // Update costs for each meter
+                for (const meter of meters) {
+                    await this.multiMeterManager.updateCosts(type, meter.name, meter.config);
+                }
+                // Update totals if multiple meters exist
+                if (meters.length > 1) {
+                    await this.multiMeterManager.updateTotalCosts(type);
+                }
+                return;
+            }
+        }
+        // Fallback to legacy billingManager for single-meter setups (backward compatibility)
+        return this.billingManager.updateCosts(type);
+    }
+
+    async closeBillingPeriod(type) {
+        return this.billingManager.closeBillingPeriod(type);
+    }
+
+    async updateBillingCountdown(type) {
+        return this.billingManager.updateBillingCountdown(type);
+    }
+
+    async resetDailyCounters(type) {
+        return this.billingManager.resetDailyCounters(type);
+    }
+
+    async resetMonthlyCounters(type) {
+        return this.billingManager.resetMonthlyCounters(type);
+    }
+
+    async resetYearlyCounters(type) {
+        return this.billingManager.resetYearlyCounters(type);
+    }
+
+    async checkPeriodResets() {
+        return this.billingManager.checkPeriodResets();
+    }
+
+    async checkNotifications() {
+        return this.messagingHandler.checkNotifications();
+    }
+
+    /**
+     * Sets up periodic tasks (daily reset, etc.)
+     */
+    setupPeriodicTasks() {
+        // Check every minute for period changes
+        this.periodicTimers.checkPeriods = setInterval(async () => {
+            await this.checkPeriodResets();
+        }, 60000); // Every minute
+
+        // Initial check
+        this.checkPeriodResets();
+    }
+
+    /**
+     * Is called when adapter shuts down - callback has to be called under any circumstances!
+     *
+     * @param {() => void} callback - Callback function
+     */
+    onUnload(callback) {
+        try {
+            this.log.info('Nebenkosten-Monitor shutting down...');
+
+            // Clear all timers
+            Object.values(this.periodicTimers).forEach(timer => {
+                if (timer) {
+                    clearInterval(timer);
+                }
+            });
+
+            callback();
+        } catch (error) {
+            this.log.error(`Error during unloading: ${error.message}`);
+            callback();
+        }
+    }
+
+    /**
+     * Is called if a subscribed state changes
+     *
+     * @param {string} id - State ID
+     * @param {ioBroker.State | null | undefined} state - State object
+     */
+    async onStateChange(id, state) {
+        if (!state || state.val === null || state.val === undefined) {
+            return;
+        }
+
+        // Check if this is a closePeriod button press
+        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
+            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
+                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
+                const meters = this.multiMeterManager?.getMetersForType(type) || [];
+                const meter = meters.find(m => m.name === meterName);
+
+                if (meter) {
+                    await this.billingManager.closeBillingPeriodForMeter(type, meter);
+                } else {
+                    this.log.error(`Meter "${meterName}" not found for type ${type}!`);
+                    await this.setStateAsync(`${type}.${meterName}.billing.closePeriod`, false, true);
+                }
+            }
+            return;
+        }
+
+        // Check if this is an adjustment value change
+        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);
+
+            // Update costs for all meters of this type
+            await this.updateCosts(type);
+            return;
+        }
+
+        // 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);
+                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;
+            }
+        }
+    }
+
+    /**
+     * Is called when adapter receives message from config window.
+     *
+     * @param {Record<string, any>} obj - Message object from config
+     */
+    async onMessage(obj) {
+        await this.messagingHandler.handleMessage(obj);
+    }
+}
+
+if (require.main !== module) {
+    // Export the constructor in compact mode
+    /**
+     * @param {Partial<utils.AdapterOptions>} [options] - Adapter options
+     */
+    module.exports = options => new NebenkostenMonitor(options);
+} else {
+    // otherwise start the instance directly
+    new NebenkostenMonitor();
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "iobroker.utility-monitor",
+  "version": "1.4.2",
+  "description": "Monitor gas, water, and electricity consumption with cost calculation",
+  "author": {
+    "name": "fischi87",
+    "email": "axel.fischer@hotmail.com"
+  },
+  "contributors": [
+    {
+      "name": "Axel Fischer"
+    }
+  ],
+  "homepage": "https://github.com/fischi87/ioBroker.utility-monitor",
+  "license": "MIT",
+  "keywords": [
+    "ioBroker",
+    "iobroker",
+    "utility",
+    "electricity",
+    "gas",
+    "water",
+    "costs",
+    "energy",
+    "monitoring",
+    "metering",
+    "consumption",
+    "home-automation",
+    "smart-home"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fischi87/ioBroker.utility-monitor.git"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "dependencies": {
+    "@iobroker/adapter-core": "^3.3.2"
+  },
+  "devDependencies": {
+    "@alcalzone/release-script": "~5.0.0",
+    "@alcalzone/release-script-plugin-iobroker": "~4.0.0",
+    "@alcalzone/release-script-plugin-license": "~4.0.0",
+    "@alcalzone/release-script-plugin-manual-review": "~4.0.0",
+    "@iobroker/adapter-dev": "~1.5.0",
+    "@iobroker/dev-server": "~0.8.0",
+    "@iobroker/eslint-config": "~2.2.0",
+    "@iobroker/testing": "~5.2.2",
+    "@tsconfig/node20": "~20.1.8",
+    "@types/iobroker": "npm:@iobroker/types@~7.1.0",
+    "@types/node": "~20.19.27",
+    "typescript": "~5.9.3"
+  },
+  "main": "main.js",
+  "files": [
+    "admin{,/!(src)/**}/!(tsconfig|tsconfig.*|.eslintrc).{json,json5}",
+    "admin{,/!(src)/**}/*.{html,css,png,svg,jpg,js}",
+    "lib/",
+    "www/",
+    "io-package.json",
+    "LICENSE",
+    "main.js"
+  ],
+  "scripts": {
+    "test:js": "mocha --config test/mocharc.custom.json \"{!(node_modules|test)/**/*.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",
+    "check": "tsc --noEmit -p tsconfig.check.json",
+    "lint": "eslint -c eslint.config.mjs .",
+    "translate": "translate-adapter",
+    "release": "release-script",
+    "dev-server": "dev-server"
+  },
+  "bugs": {
+    "url": "https://github.com/fischi87/ioBroker.utility-monitor/issues"
+  },
+  "readmeFilename": "README.md"
+}