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

package/dist/Connections/connectionsConfigNode.js

@@ -0,0 +1,330 @@
+"use strict";
+const baseConfigNode_1 = require("../baseConfigNode");
+const connectionsTypes_1 = require("./connectionsTypes");
+const utility_1 = require("../utility");
+module.exports = function ConnectionsConfigNode(RED) {
+    const register = function (config) {
+        RED.nodes.createNode(this, config);
+        (0, baseConfigNode_1.assignBaseConfigNode)(this);
+        const self = this;
+        self.hassAPICallbacks = {};
+        self.hassActionCallbacks = {};
+        self.hassCurrentStateCallbacks = {};
+        self.hassGetEntitiesCallbacks = {};
+        self.hassEventReadyCallbacks = {};
+        self.hassEventCallbacks = {};
+        self.hassEventCallServiceCallbacks = {};
+        self.hassEventStateChangeCallbacks = {};
+        self.sendHASSAPI = function (protocol, method, path, callback, params, data, results) {
+            const callbackId = callback ? (0, utility_1.generateRandomId)(Object.keys(self.hassAPICallbacks)) : undefined;
+            const msg = {
+                topic: connectionsTypes_1.Topics.API,
+                callbackId,
+                payload: {
+                    protocol,
+                    method,
+                    path,
+                    data,
+                    params,
+                    results
+                }
+            };
+            self.sendMsg(msg);
+            //Add our callback for when a response comes back in
+            if (callbackId && callback) {
+                self.hassAPICallbacks[callbackId] = callback;
+            }
+        };
+        self.sendHASSAction = function (action, target, data, callback) {
+            const callbackId = callback ? (0, utility_1.generateRandomId)(Object.keys(self.hassActionCallbacks)) : undefined;
+            const msg = {
+                topic: connectionsTypes_1.Topics.ACTION,
+                callbackId,
+                payload: {
+                    action,
+                    target,
+                    data
+                }
+            };
+            self.sendMsg(msg);
+            //Add our callback for when a response comes back in
+            if (callbackId && callback) {
+                self.hassActionCallbacks[callbackId] = callback;
+            }
+        };
+        self.getHASSEntityState = function (entityId, callback) {
+            const callbackId = callback ? (0, utility_1.generateRandomId)(Object.keys(self.hassCurrentStateCallbacks)) : undefined;
+            const msg = {
+                topic: connectionsTypes_1.Topics.STATE,
+                callbackId,
+                payload: {
+                    entityId
+                }
+            };
+            self.sendMsg(msg);
+            //Add our callback for when a response comes back in
+            if (callbackId && callback) {
+                self.hassCurrentStateCallbacks[callbackId] = callback;
+            }
+        };
+        self.getHASSEntities = function (rules, callback) {
+            const callbackId = callback ? (0, utility_1.generateRandomId)(Object.keys(self.hassGetEntitiesCallbacks)) : undefined;
+            const msg = {
+                topic: connectionsTypes_1.Topics.GET_ENTITIES,
+                callbackId,
+                payload: {
+                    rules
+                }
+            };
+            self.sendMsg(msg);
+            //Add our callback for when a response comes back in
+            if (callbackId && callback) {
+                self.hassGetEntitiesCallbacks[callbackId] = callback;
+            }
+        };
+        self.addHASSEntity = function (entityId, data, callback) {
+            self.sendHASSAPI("http", "post", "/api/states/" + entityId, callback, undefined, data);
+        };
+        self.addHASSInputBoolean = function (options) {
+            let currentState = options.state || "unknown";
+            const entityId = options.id ? options.id : (0, utility_1.getEntityId)("input_boolean", options.friendlyName);
+            const data = (state) => {
+                return {
+                    state: state || "unknown",
+                    attributes: {
+                        friendly_name: options.friendlyName
+                    }
+                };
+            };
+            //Add the input boolean to HASS
+            self.getHASSEntities([{ property: "entity_id", logic: "is", value: entityId }], (entities) => {
+                if (entities.length > 1) {
+                    self.error(`Found more than 1 entity for ${entityId}`);
+                    return;
+                }
+                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
+                    options.creationCallback(response.payload.state, response);
+                } : undefined);
+            });
+            //Assign the changed callback if set
+            if (options.changedCallback) {
+                self.hassEventCallServiceCallbacks[entityId] = function (domain, service, serviceData) {
+                    if (domain == "input_boolean" && (serviceData === null || serviceData === void 0 ? void 0 : serviceData.entity_id) == entityId) {
+                        let state = currentState;
+                        if (service == "turn_on") {
+                            state = "on";
+                        }
+                        else if (service == "turn_off") {
+                            state = "off";
+                        }
+                        else if (service == "toggle") {
+                            state = state === "on" ? "off" : "on";
+                        }
+                        currentState = state;
+                        //Tell HASS that the button was pressed
+                        self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(currentState));
+                        options.changedCallback(currentState, serviceData);
+                    }
+                };
+            }
+        };
+        self.addHASSButton = function (options) {
+            var _a;
+            const entityId = (_a = options.id) !== null && _a !== void 0 ? _a : (0, utility_1.getEntityId)("button", options.friendlyName);
+            const data = (state) => {
+                return {
+                    state: state || "unknown",
+                    attributes: {
+                        friendly_name: options.friendlyName
+                    }
+                };
+            };
+            //Add the button to HASS
+            self.getHASSEntities([{ property: "entity_id", logic: "is", value: entityId }], (entities) => {
+                if (entities.length > 1) {
+                    self.error(`Found more than 1 entity for ${entityId}`);
+                    return;
+                }
+                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
+                    options.creationCallback(response.payload.state, response);
+                } : undefined);
+            });
+            //Assign the pressed callback if set
+            if (options.pressedCallback) {
+                self.hassEventCallServiceCallbacks[entityId] = function (domain, service, serviceData) {
+                    if (domain == "button" && service == "press" && (serviceData === null || serviceData === void 0 ? void 0 : serviceData.entity_id) == entityId) {
+                        const state = new Date();
+                        //Tell HASS that the button was pressed
+                        self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(state));
+                        options.pressedCallback(state, serviceData);
+                    }
+                };
+            }
+        };
+        self.addHASSScene = function (options) {
+            const entityId = options.id || (0, utility_1.getEntityId)("scene", options.friendlyName);
+            const data = (state) => {
+                return {
+                    state: state || "unknown",
+                    attributes: {
+                        friendly_name: options.friendlyName
+                    }
+                };
+            };
+            //Add the scene to HASS
+            self.getHASSEntities([{ property: "entity_id", logic: "is", value: entityId }], (entities) => {
+                if (entities.length > 1) {
+                    self.error(`Found more than 1 entity for ${entityId}`);
+                    return;
+                }
+                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
+                    options.creationCallback(response.payload.state, response);
+                } : undefined);
+            });
+            //Assign the activated callback if set
+            if (options.activatedCallback) {
+                self.hassEventCallServiceCallbacks[entityId] = function (domain, service, serviceData) {
+                    if (domain == "scene" && service == "turn_on") {
+                        const entities = typeof serviceData.entity_id == "string" ? [serviceData.entity_id] : serviceData.entity_id;
+                        if (!entities.includes(entityId)) {
+                            return;
+                        }
+                        const state = new Date();
+                        //Tell HASS that the scene was activated
+                        self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(state));
+                        options.activatedCallback(state, serviceData);
+                    }
+                };
+            }
+        };
+        self.addHASSSelect = function (options) {
+            const entityId = options.id || (0, utility_1.getEntityId)("select", options.friendlyName);
+            const data = (state) => {
+                return {
+                    state: state || "unknown",
+                    attributes: {
+                        friendly_name: options.friendlyName,
+                        options: options.options
+                    }
+                };
+            };
+            //Add the select to HASS
+            self.getHASSEntities([{ property: "entity_id", logic: "is", value: entityId }], (entities) => {
+                if (entities.length > 1) {
+                    self.error(`Found more than 1 entity for ${entityId}`);
+                    return;
+                }
+                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
+                    options.creationCallback(response.payload.state, response);
+                } : undefined);
+            });
+            //Assign the activated callback if set
+            if (options.activatedCallback) {
+                self.hassEventCallServiceCallbacks[entityId] = function (domain, service, serviceData) {
+                    if (domain == "select") {
+                        const entities = typeof serviceData.entity_id == "string" ? [serviceData.entity_id] : serviceData.entity_id;
+                        if (!entities.includes(entityId)) {
+                            return;
+                        }
+                        if (service == "select_option") {
+                            self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(serviceData.option));
+                            options.activatedCallback(serviceData.option, serviceData);
+                        }
+                        else if (service == "select_first") {
+                            self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(options.options[0] || "unknown"));
+                            options.activatedCallback(options.options[0] || "unknown", serviceData);
+                        }
+                        else if (service == "select_last") {
+                            self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(options.options[options.options.length - 1] || "unknown"));
+                            options.activatedCallback(options.options[options.options.length - 1] || "unknown", serviceData);
+                        }
+                        else if (service == "select_previous" || service == "select_next") {
+                            self.getHASSEntityState(entityId, (currentState) => {
+                                let index = options.options.indexOf(currentState);
+                                if (service == "select_previous") {
+                                    index = index - 1;
+                                    if (index < 0 && serviceData.cycle) {
+                                        index = options.options.length - 1;
+                                    }
+                                    if (index < 0 && !serviceData.cycle) {
+                                        index = 0;
+                                    }
+                                }
+                                else if (service == "select_next") {
+                                    index = index + 1;
+                                    if (index >= options.options.length && serviceData.cycle) {
+                                        index = 0;
+                                    }
+                                    if (index >= options.options.length && !serviceData.cycle) {
+                                        index = options.options.length - 1;
+                                    }
+                                }
+                                self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(options.options[index] || "unknown"));
+                                options.activatedCallback(options.options[index] || "unknown", serviceData);
+                            });
+                        }
+                    }
+                };
+            }
+        };
+        self.handleCallback = function (callbacks, callbackId, ...args) {
+            var _a;
+            //This is a specific callback id
+            if (callbackId) {
+                (_a = callbacks[callbackId]) === null || _a === void 0 ? void 0 : _a.call(callbacks, ...args);
+                delete callbacks[callbackId];
+                return;
+            }
+            //Send to everyone
+            for (const id of Object.keys(callbacks)) {
+                if (callbacks[id]) {
+                    callbacks[id](...args);
+                }
+            }
+        };
+        self.msgReceived = function (msg, senderIds) {
+            const payload = msg.payload;
+            //Handle based on the topic
+            switch (msg.topic) {
+                case connectionsTypes_1.Topics.API: {
+                    self.handleCallback(self.hassAPICallbacks, msg.callbackId, msg);
+                    break;
+                }
+                case connectionsTypes_1.Topics.EVENT: {
+                    if (msg.event_type == "home_assistant_client" && msg.payload == "ready") {
+                        self.handleCallback(self.hassEventReadyCallbacks, msg.callbackId, msg);
+                    }
+                    if (payload) {
+                        switch (payload.event_type) {
+                            case "call_service":
+                                self.handleCallback(self.hassEventCallServiceCallbacks, msg.callbackId, payload.event.domain, payload.event.service, payload.event.service_data);
+                                break;
+                            case "state_changed":
+                                self.handleCallback(self.hassEventStateChangeCallbacks, msg.callbackId, payload.event.entity_id, payload.event.old_state, payload.event.new_state);
+                                break;
+                        }
+                    }
+                    self.handleCallback(self.hassEventCallbacks, msg.callbackId, msg);
+                    break;
+                }
+                case connectionsTypes_1.Topics.ACTION: {
+                    self.handleCallback(self.hassActionCallbacks, msg.callbackId, payload.action, payload.target, payload.data);
+                    break;
+                }
+                case connectionsTypes_1.Topics.STATE: {
+                    self.handleCallback(self.hassCurrentStateCallbacks, msg.callbackId, payload, msg);
+                    break;
+                }
+                case connectionsTypes_1.Topics.GET_ENTITIES: {
+                    self.handleCallback(self.hassGetEntitiesCallbacks, msg.callbackId, payload);
+                    break;
+                }
+            }
+        };
+    };
+    RED.nodes.registerType("connections-config-node", register);
+};

package/dist/Connections/connectionsNode.html

@@ -0,0 +1,30 @@
+<script type="text/javascript" id="node-connections-node">
+    RED.nodes.registerType("connections-node", {
+        category: "HASS Stuff",
+        color: "#ffcc00",
+        inputs: 1,
+        outputs: 1,
+        icon: "bulb.svg",
+        defaults: {
+            name: { value: "" },
+            connectionsConfigNode: { value: '', type: "connections-config-node", required: true }
+        },
+        label: function () {
+            return this.name || "Connections"
+        }
+    });
+</script>
+
+
+<script type="text/html" data-template-name="connections-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-connectionsConfigNode">Config</label>
+        <input type="text" id="node-input-connectionsConfigNode" />
+    </div>
+</script>
+<script type="text/html" data-help-name="connections-node">
+</script>

package/dist/Connections/connectionsNode.js

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

package/dist/Connections/connectionsTypes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topics = void 0;
+var Topics;
+(function (Topics) {
+    Topics["API"] = "api";
+    Topics["EVENT"] = "event";
+    Topics["STATE"] = "state";
+    Topics["ACTION"] = "action";
+    Topics["GET_ENTITIES"] = "get_entities";
+})(Topics = exports.Topics || (exports.Topics = {}));

package/dist/LightControl/lightControlConfigNode.html

@@ -0,0 +1,109 @@
+<script type="text/javascript" id="node-light-control-config-node">
+    RED.nodes.registerType("light-control-config-node", {
+        category: "config",
+        defaults: {
+            name: { value: "" },
+            connectionsConfigNode: { value: "", type: "connections-config-node", required: true },
+            groupEntityId: { value: "", required: true, default: "light.example" },
+            nightModeEntityId: { value: "", required: false, default: "input_boolean.example" },
+            entitiesOffAtNight: { value: "", required: false, default: "light.example1,light.example2" },
+            concentrateSettings: { value: "", required: true, default: "concentrate 100" },
+            readSettings: { value: "", required: true, default: "read 100" },
+            relaxSettings: { value: "", required: true, default: "relax 100" },
+            restSettings: { value: "", required: true, default: "rest 100" },
+            nightLightSettings: { value: "", required: true, default: "nightLight 100" },
+            nightSettings: { value: "", required: true, default: "nightLight 30" },
+        },
+        label: function () {
+            return this.name || "Light Control Config"
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="light-control-config-node">
+    <div class="form-row">
+        <h2>Basic configuration</h2>
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-connectionsConfigNode">Config</label>
+        <input type="text" id="node-config-input-connectionsConfigNode" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-groupEntityId">Group Entity ID</label>
+        <p>The entity ID of the light group to control.</p>
+        <input type="text" id="node-config-input-groupEntityId" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-nightModeEntityId">Night Mode Entity ID</label>
+        <p>The entity ID of the input_boolean that controls night mode. Empty to disable</p>
+        <input type="text" id="node-config-input-nightModeEntityId" />
+    </div>  
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-entitiesOffAtNight">Entities Off At Night</label>
+        <p>Comma-separated list of entities to turn off during night mode. Empty to disable</p>
+        <input type="text" id="node-config-input-entitiesOffAtNight" />
+    </div>
+    <div class="form-row">
+        <hr>
+        <h2>Scene definitions</h2>
+        <p>
+            The following settings define what the scenes should do. They follow the syntax of [scene] [brightnessPercent] 
+            where scene is the scene name, if the same as below values will use the 
+            <a style="font-weight: bold;" href="https://github.com/basnijholt/adaptive-lighting">Adaptive Lighting HACS plugin</a>
+            otherwise will send to scene.apply. The brightnessPercent is the brightness percentage to set
+        </p>
+        <ul>
+            <li>rest</li>
+            <li>relax</li>
+            <li>concentrate</li>
+            <li>energize</li>
+            <li>coolBright</li>
+            <li>bright</li>
+            <li>dimmed</li>
+            <li>nightLight</li>
+            <li>sleepy</li>
+            <li>paintedSky</li>
+            <li>rollingHills</li>
+            <li>sailingAway</li>
+            <li>sunFlare</li>
+        </ul>
+    </div>
+
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-concentrateSettings">Concentrate Settings</label>
+        <p>The scene to use for the concentrate scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-concentrateSettings" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-readSettings">Read Settings</label>
+        <p>The scene to use for the read scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-readSettings" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-relaxSettings">Relax Settings</label>
+        <p>The scene to use for the relax scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-relaxSettings" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-restSettings">Rest Settings</label>
+        <p>The scene to use for the rest scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-restSettings" />
+    </div>
+    <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-nightLightSettings">Night Light Settings</label>
+        <p>The scene to use for the night light scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-nightLightSettings" />
+    </div>
+        <div class="form-row">
+        <label style="font-weight: bold;" for="node-config-input-nightSettings">Night Settings</label>
+        <p>The scene to use for the night light scene [scene] [brightnessPercent]</p>
+        <input type="text" id="node-config-input-nightSettings" />
+    </div>
+</script>
+
+<script type="text/html" data-help-name="light-control-config-node">
+</script>