@haydendonald/node-red-contrib-hass-stuff 0.0.1

package/dist/LightControl/lightControlConfigNode.js

@@ -0,0 +1,311 @@
+"use strict";
+const lightControlTypes_1 = require("./lightControlTypes");
+const baseConfigNode_1 = require("../baseConfigNode");
+const utility_1 = require("../utility");
+module.exports = function LightControlConfigNode(RED) {
+    const register = function (config) {
+        const self = this;
+        let groupEntities = [];
+        let currentState;
+        let nightModeState;
+        let currentSceneState;
+        let sunState;
+        let entitiesOnDuringNight = [];
+        let entitiesOffDuringNight = [];
+        let adaptiveInterval;
+        let errored = false;
+        if (!config.groupEntityId) {
+            this.error("Group Entity ID is required");
+            errored = true;
+        }
+        if (!config.concentrateSettings) {
+            this.error("Concentrate Settings is required");
+            errored = true;
+        }
+        if (!config.readSettings) {
+            this.error("Read Settings is required");
+            errored = true;
+        }
+        if (!config.relaxSettings) {
+            this.error("Relax Settings is required");
+            errored = true;
+        }
+        if (!config.restSettings) {
+            this.error("Rest Settings is required");
+            errored = true;
+        }
+        if (!config.nightLightSettings) {
+            this.error("Night Light Settings is required");
+            errored = true;
+        }
+        if (!config.nightSettings) {
+            this.error("Night Settings is required");
+            errored = true;
+        }
+        //Check that all the scenes are following [scene] [brightnessPercent]
+        const sceneRegex = /^[^\s]+ \d+$/;
+        if (!sceneRegex.test(config.concentrateSettings)) {
+            this.error("Concentrate Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (!sceneRegex.test(config.readSettings)) {
+            this.error("Read Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (!sceneRegex.test(config.relaxSettings)) {
+            this.error("Relax Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (!sceneRegex.test(config.restSettings)) {
+            this.error("Rest Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (!sceneRegex.test(config.nightLightSettings)) {
+            this.error("Night Light Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (!sceneRegex.test(config.nightSettings)) {
+            this.error("Night Settings must be in the format [scene] [brightnessPercent]");
+            errored = true;
+        }
+        if (errored) {
+            return;
+        }
+        const scenes = {
+            concentrate: {
+                friendlyName: "Concentrate",
+                sceneName: config.concentrateSettings.split(" ")[0],
+                brightnessPct: parseInt(config.concentrateSettings.split(" ")[1])
+            },
+            read: {
+                friendlyName: "Read",
+                sceneName: config.readSettings.split(" ")[0],
+                brightnessPct: parseInt(config.readSettings.split(" ")[1])
+            },
+            relax: {
+                friendlyName: "Relax",
+                sceneName: config.relaxSettings.split(" ")[0],
+                brightnessPct: parseInt(config.relaxSettings.split(" ")[1])
+            },
+            nightLight: {
+                friendlyName: "Night Light",
+                sceneName: config.nightLightSettings.split(" ")[0],
+                brightnessPct: parseInt(config.nightLightSettings.split(" ")[1])
+            },
+            night: {
+                friendlyName: "Night",
+                sceneName: config.nightSettings.split(" ")[0],
+                brightnessPct: parseInt(config.nightSettings.split(" ")[1])
+            }
+        };
+        const getSceneFromFriendlyName = (friendlyName) => {
+            return Object.values(scenes).find(scene => scene.friendlyName === friendlyName);
+        };
+        RED.nodes.createNode(this, config);
+        (0, baseConfigNode_1.assignBaseConfigNode)(this);
+        const connectionsConfigNode = RED.nodes.getNode(config.connectionsConfigNode);
+        //When HASS is ready
+        connectionsConfigNode.hassEventReadyCallbacks[this.id] = function (msg) {
+            //Get what entities exist in the group and set our internal state
+            connectionsConfigNode.getHASSEntityState(config.groupEntityId, (payload, data) => {
+                groupEntities = data.data.attributes.entity_id;
+                currentState = data.data.state;
+                entitiesOffDuringNight = config.entitiesOffAtNight.split(",");
+                entitiesOnDuringNight = groupEntities.filter((entity) => !entitiesOffDuringNight.includes(entity));
+            });
+            //Get the state of the night mode switch and store it
+            if (config.nightModeEntityId && config.nightModeEntityId != "") {
+                connectionsConfigNode.getHASSEntityState(config.nightModeEntityId, (payload, data) => {
+                    nightModeState = data.data.state;
+                });
+            }
+            //Get the state of the sun
+            connectionsConfigNode.getHASSEntityState("sun.sun", (payload, data) => {
+                sunState = data.data.state;
+            });
+            //Add our scenes to home assistant
+            for (const [sceneKey, sceneValue] of Object.entries(scenes)) {
+                connectionsConfigNode.addHASSScene({
+                    friendlyName: `${self.name} - ${sceneValue.friendlyName}`,
+                    id: (0, utility_1.getEntityId)("scene", `${self.name}_${sceneKey}`),
+                    creationCallback: (response) => { },
+                    activatedCallback: (serviceData) => {
+                        //Set our scene
+                        connectionsConfigNode.sendHASSAction("select.select_option", { entity_id: [(0, utility_1.getEntityId)("select", `${self.name}_current_scene`)] }, {
+                            option: sceneValue.friendlyName
+                        });
+                        activateScene(sceneValue, serviceData.transition || 1, true);
+                    }
+                });
+            }
+            //Add our adaptive scene
+            connectionsConfigNode.addHASSScene({
+                friendlyName: `${self.name} - Adaptive`,
+                id: (0, utility_1.getEntityId)("scene", `${self.name}_adaptive`),
+                creationCallback: (response) => { },
+                activatedCallback: (serviceData) => {
+                    //Set our scene to adaptive
+                    connectionsConfigNode.sendHASSAction("select.select_option", { entity_id: [(0, utility_1.getEntityId)("select", `${self.name}_current_scene`)] }, {
+                        option: "Adaptive"
+                    });
+                    runAdaptive(serviceData.transition || 1, true);
+                }
+            });
+            //Add our turn on scene
+            connectionsConfigNode.addHASSScene({
+                friendlyName: `${self.name} - Turn On`,
+                id: (0, utility_1.getEntityId)("scene", `${self.name}_turn_on`),
+                creationCallback: (response) => { },
+                activatedCallback: (serviceData) => {
+                    runLights(serviceData.transition || 1, true);
+                }
+            });
+            //Add our turn off scene
+            connectionsConfigNode.addHASSScene({
+                friendlyName: `${self.name} - Turn Off`,
+                id: (0, utility_1.getEntityId)("scene", `${self.name}_turn_off`),
+                creationCallback: (response) => { },
+                activatedCallback: (serviceData) => {
+                    connectionsConfigNode.sendHASSAction("light.turn_off", { entity_id: [config.groupEntityId] }, {
+                        transition: serviceData.transition || 1
+                    });
+                }
+            });
+            //Add our select to keep track of what scene we are running
+            connectionsConfigNode.addHASSSelect({
+                friendlyName: `${self.name} - Current Scene`,
+                id: (0, utility_1.getEntityId)("select", `${self.name}_current_scene`),
+                options: [
+                    ...Object.values(scenes).map(scene => scene.friendlyName),
+                    "Adaptive"
+                ],
+                creationCallback: (state) => {
+                    currentSceneState = state;
+                    runLights(300, false);
+                },
+                activatedCallback: (state, serviceData) => {
+                    currentSceneState = state;
+                }
+            });
+        };
+        //When a state change happens in home assistant
+        connectionsConfigNode.hassEventStateChangeCallbacks[this.id] = function (entityId, oldState, newState) {
+            switch (entityId) {
+                case config.groupEntityId: {
+                    currentState = newState;
+                    break;
+                }
+                case config.nightModeEntityId: {
+                    nightModeState = newState.state;
+                    break;
+                }
+                case "sun.sun": {
+                    sunState = newState.state;
+                    break;
+                }
+            }
+        };
+        //When we get a message from a node on the NodeRED flows
+        this.msgReceived = function (msg, senderIds) { };
+        const activateScene = (scene, transitionSec, turnLightsOn, entitiesOn, entitiesOff) => {
+            //If the lights are off and we are not to turn the lights on don't do anything
+            if (turnLightsOn == false && currentState == "off") {
+                return;
+            }
+            //Is not a scene preset scene if we have a entity id
+            if (scene.sceneName.includes(".")) {
+                //Run via hass scene.turn_on
+                connectionsConfigNode.sendHASSAction("scene.turn_on", {
+                    entity_id: [scene.sceneName]
+                }, {
+                    transition: transitionSec
+                });
+            }
+            //Is a scene preset
+            else {
+                const sceneId = lightControlTypes_1.ScenePresets[scene.sceneName];
+                if (!sceneId) {
+                    self.error(`Scene preset not found for ${scene.sceneName}. Please use scene.<presetname> if this is not a scene i know about`);
+                    return;
+                }
+                //Run via adaptive lights
+                connectionsConfigNode.sendHASSAction("scene_presets.apply_preset", undefined, {
+                    brightness: (scene.brightnessPct / 100.0) * 255,
+                    transition: transitionSec,
+                    preset_id: sceneId,
+                    shuffle: true,
+                    smart_shuffle: true,
+                    targets: {
+                        entity_id: entitiesOn ? entitiesOn : [config.groupEntityId]
+                    }
+                }, undefined);
+                //Run any lights off that need to be off
+                if (entitiesOff && entitiesOff.length > 0) {
+                    connectionsConfigNode.sendHASSAction("light.turn_off", {
+                        entity_id: entitiesOff
+                    }, {
+                        transition: transitionSec
+                    });
+                }
+            }
+        };
+        const runLights = (transitionSec, turnLightsOn) => {
+            if (currentSceneState == "Adaptive") {
+                runAdaptive(transitionSec, turnLightsOn);
+            }
+            else {
+                const scene = getSceneFromFriendlyName(currentSceneState);
+                if (!scene) {
+                    self.error(`Scene not found: ${currentSceneState}`);
+                    return;
+                }
+                activateScene(scene, transitionSec, turnLightsOn);
+            }
+        };
+        const runAdaptive = (transitionSec, turnLightsOn) => {
+            let entitiesOn;
+            let entitiesOff;
+            //Decide what scene to send
+            let scene = scenes["concentrate"];
+            if (nightModeState === "on") {
+                scene = scenes["night"];
+                entitiesOn = entitiesOnDuringNight;
+                entitiesOff = entitiesOffDuringNight;
+            }
+            else {
+                if (sunState == "above_horizon") {
+                    scene = scenes["concentrate"];
+                }
+                else {
+                    const currentHour = new Date().getHours();
+                    if (currentHour >= 23 || currentHour < 6) {
+                        scene = scenes["nightLight"];
+                    }
+                    else if (currentHour >= 6 && currentHour < 8) {
+                        scene = scenes["relax"];
+                    }
+                    else if (currentHour >= 8 && currentHour < 10) {
+                        scene = scenes["read"];
+                    }
+                    else if (currentHour >= 10 && currentHour < 15) {
+                        scene = scenes["concentrate"];
+                    }
+                    else if (currentHour >= 15 && currentHour < 20) {
+                        scene = scenes["relax"];
+                    }
+                    else if (currentHour >= 20 && currentHour < 23) {
+                        scene = scenes["read"];
+                    }
+                }
+            }
+            //Send it
+            activateScene(scene, transitionSec, turnLightsOn, entitiesOn, entitiesOff);
+            //Start our interval to update the adaptive scene every minute
+            clearTimeout(adaptiveInterval);
+            adaptiveInterval = setTimeout(() => {
+                runAdaptive(300, false);
+            }, 60000);
+        };
+    };
+    RED.nodes.registerType("light-control-config-node", register);
+};

package/dist/LightControl/lightControlNode.html

@@ -0,0 +1,30 @@
+<script type="text/javascript" id="node-light-control-node">
+    RED.nodes.registerType("light-control-node", {
+        category: "HASS Stuff",
+        color: "#ffcc00",
+        inputs: 1,
+        outputs: 1,
+        icon: "bulb.svg",
+        defaults: {
+            name: { value: "" },
+            lightControlConfigNode: { value: '', type: "light-control-config-node", required: true }
+        },
+        label: function () {
+            return this.name || "Light Control"
+        }
+    });
+</script>
+
+
+<script type="text/html" data-template-name="light-control-node">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-lightControlConfigNode">Config</label>
+        <input type="text" id="node-input-lightControlConfigNode" />
+    </div>
+</script>
+<script type="text/html" data-help-name="light-control-node">
+</script>

package/dist/LightControl/lightControlNode.js

@@ -0,0 +1,18 @@
+"use strict";
+const baseNode_1 = require("../baseNode");
+module.exports = function LightControlNode(RED) {
+    function register(config) {
+        RED.nodes.createNode(this, config);
+        (0, baseNode_1.assignBaseNode)(this);
+        const lightControlConfigNode = RED.nodes.getNode(config.lightControlConfigNode);
+        //When a config node wants to send a message to the output
+        lightControlConfigNode.addMsgCallback(this.id, (msg) => {
+            this.send(msg);
+        });
+        //When an input message is received
+        this.on("input", (msg, send, done) => {
+            lightControlConfigNode.msgReceived(msg, [this.id]);
+        });
+    }
+    RED.nodes.registerType("light-control-node", register);
+};

package/dist/LightControl/lightControlTypes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenePresets = void 0;
+var ScenePresets;
+(function (ScenePresets) {
+    ScenePresets["rest"] = "e03267e7-9914-4f47-97fe-63c0bd317fe7";
+    ScenePresets["relax"] = "e71b2ef3-1b15-4c4b-b036-4b3d6efe58f8";
+    ScenePresets["read"] = "035b6ecf-414e-4781-abc7-3911556097cb";
+    ScenePresets["concentrate"] = "0cbec4e8-d064-4457-986a-fe6078a63f39";
+    ScenePresets["energize"] = "0eeacfc5-2d81-4035-a23d-4a9bc02af965";
+    ScenePresets["coolBright"] = "6d10a807-7330-46d1-b093-c15520ba72c0";
+    ScenePresets["bright"] = "84ebc26c-9d61-4d25-830c-41ea66f1c325";
+    ScenePresets["dimmed"] = "8f55e62a-e5f8-456a-9e8b-61f314bd4e99";
+    ScenePresets["nightLight"] = "b6f58e22-677f-4670-8677-3dea4ac60383";
+    ScenePresets["sleepy"] = "6170702c-f2fc-46fc-99ef-ac98b6c1293e";
+    ScenePresets["paintedSky"] = "467e2d6e-50e1-47eb-ac0f-ffd45d383a06";
+    ScenePresets["rollingHills"] = "49c61bae-d3ec-4df2-89a4-65235705f3a1";
+    ScenePresets["sailingAway"] = "f2ac2635-8b9e-4d5f-a307-63bd55e60475";
+    ScenePresets["sunFlare"] = "2f9ca2fb-dabb-4780-93cc-f9b169d94963";
+})(ScenePresets = exports.ScenePresets || (exports.ScenePresets = {}));

package/dist/baseConfigNode.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignBaseConfigNode = void 0;
+function assignBaseConfigNode(node) {
+    node.msgCallbacks = {};
+    node.addMsgCallback = function (id, callback) {
+        node.msgCallbacks[id] = callback;
+    };
+    node.removeMsgCallback = function (id) {
+        delete node.msgCallbacks[id];
+    };
+    node.sendMsg = function (msg, toIds) {
+        if (toIds) {
+            toIds.forEach(id => {
+                var _a, _b;
+                (_b = (_a = node.msgCallbacks)[id]) === null || _b === void 0 ? void 0 : _b.call(_a, msg);
+            });
+            return;
+        }
+        Object.values(node.msgCallbacks).forEach(callback => callback(msg));
+    };
+    node.msgReceived = function (msg, senderIds) { };
+}
+exports.assignBaseConfigNode = assignBaseConfigNode;

package/dist/baseNode.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignBaseNode = void 0;
+function assignBaseNode(node) { }
+exports.assignBaseNode = assignBaseNode;

package/dist/utility.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityId = exports.cleanEntityId = exports.generateRandomId = void 0;
+function generateRandomId(checks) {
+    let id;
+    while (id === undefined || (checks && checks.includes(id))) {
+        id = Math.random().toString(36).substring(2, 15);
+    }
+    return id;
+}
+exports.generateRandomId = generateRandomId;
+function cleanEntityId(entityId) {
+    return entityId.toLowerCase().replace(" - ", "_").replace(/\s/g, "_").replace(/[\W]+/g, "");
+}
+exports.cleanEntityId = cleanEntityId;
+function getEntityId(scope, friendlyName) {
+    return `${scope}.${cleanEntityId(friendlyName)}`;
+}
+exports.getEntityId = getEntityId;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@haydendonald/node-red-contrib-hass-stuff",
+  "version": "0.0.1",
+  "description": "A collection of stuff I use on my Node Red + Home Assistant server. This could be of use for others, i don't know..",
+  "devDependencies": {
+    "@types/node": "^18.14.0",
+    "@types/node-red": "^1.2.1",
+    "typescript": "^4.9.5"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "package-lock.json",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && cp -r nodes dist && find dist -name '*.ts' -delete && tsc"
+  },
+  "keywords": [
+    "node-red"
+  ],
+  "author": "Hayden Donald",
+  "license": "ISC",
+  "node-red": {
+    "nodes": {
+      "ConnectionsConfigNode": "dist/Connections/connectionsConfigNode.js",
+      "ConnectionsNode": "dist/Connections/connectionsNode.js",
+      "LightControlConfigNode": "dist/LightControl/lightControlConfigNode.js",
+      "LightControlNode": "dist/LightControl/lightControlNode.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}