node-red-contrib-power-saver 3.6.1 → 4.0.0

package/src/strategy-lowest-price.js

@@ -1,7 +1,7 @@
 const { DateTime } = require("luxon");
-const { booleanConfig, makeSchedule, loadDayData } = require("./utils");
-const { handleStrategyInput } = require("./handle-input");
+const { booleanConfig, calcNullSavings, fixOutputValues, saveOriginalConfig } = require("./utils");
 const { getBestContinuous, getBestX } = require("./strategy-lowest-price-functions");
+const { strategyOnInput } = require("./strategy-functions");
 
 module.exports = function (RED) {
   function StrategyLowestPriceNode(config) {
@@ -9,7 +9,7 @@ module.exports = function (RED) {
     const node = this;
     node.status({});
 
-    const originalConfig = {
+    const validConfig = {
       fromTime: config.fromTime,
       toTime: config.toTime,
       hoursOn: parseInt(config.hoursOn),
@@ -18,27 +18,31 @@ module.exports = function (RED) {
       sendCurrentValueWhenRescheduling: booleanConfig(config.sendCurrentValueWhenRescheduling),
       outputIfNoSchedule: booleanConfig(config.outputIfNoSchedule),
       outputOutsidePeriod: booleanConfig(config.outputOutsidePeriod),
+      outputValueForOn: config.outputValueForOn || true,
+      outputValueForOff: config.outputValueForOff || false,
+      outputValueForOntype: config.outputValueForOntype || "bool",
+      outputValueForOfftype: config.outputValueForOfftype || "bool",
+      override: "auto",
       contextStorage: config.contextStorage || "default",
     };
-    node.context().set("config", originalConfig);
-    node.contextStorage = originalConfig.contextStorage;
+
+    fixOutputValues(validConfig);
+    saveOriginalConfig(node, validConfig);
 
     node.on("close", function () {
       clearTimeout(node.schedulingTimeout);
     });
 
     node.on("input", function (msg) {
-      handleStrategyInput(node, msg, doPlanning);
+      strategyOnInput(node, msg, doPlanning, calcNullSavings);
     });
   }
-
   RED.nodes.registerType("ps-strategy-lowest-price", StrategyLowestPriceNode);
 };
 
-function doPlanning(node, _, priceData, _, dateDayBefore, _) {
-  const dataDayBefore = loadDayData(node, dateDayBefore);
-  const values = [...dataDayBefore.hours.map((h) => h.price), ...priceData.map((pd) => pd.value)];
-  const startTimes = [...dataDayBefore.hours.map((h) => h.start), ...priceData.map((pd) => pd.start)];
+function doPlanning(node, priceData) {
+  const values = priceData.map((pd) => pd.value);
+  const startTimes = priceData.map((pd) => pd.start);
 
   const from = parseInt(node.fromTime);
   const to = parseInt(node.toTime);
@@ -78,18 +82,6 @@ function doPlanning(node, _, priceData, _, dateDayBefore, _) {
 
   const onOff = [];
 
-  // Fill in data from previous plan for StartMissing
-  const lastStartMissing = periodStatus.lastIndexOf((s) => s === "StartMissing");
-  if (lastStartMissing >= 0 && dataDayBefore?.hours?.length > 0) {
-    const lastBefore = DateTime.fromISO(dataDayBefore.hours[dataDayBefore.hours.length - 1].start);
-    if (lastBefore >= DateTime.fromISO(startTimes[lastStartMissing])) {
-      for (let i = 0; i <= lastStartMissing; i++) {
-        onOff[i] = dataDayBefore.hours.find((h) => h.start === startTimes[i]);
-        periodStatus[i] = "Backfilled";
-      }
-    }
-  }
-
   // Set onOff for hours that will not be planned
   periodStatus.forEach((s, i) => {
     onOff[i] =
@@ -104,18 +96,7 @@ function doPlanning(node, _, priceData, _, dateDayBefore, _) {
     makePlan(node, values, onOff, s, endIndexes[i]);
   });
 
-  const schedule = makeSchedule(onOff, startTimes, !onOff[0]);
-
-  const hours = values.map((v, i) => ({
-    price: v,
-    onOff: onOff[i],
-    start: startTimes[i],
-    saving: null,
-  }));
-  return {
-    hours,
-    schedule,
-  };
+  return onOff;
 }
 
 function makePlan(node, values, onOff, fromIndex, toIndex) {

package/src/utils.js

@@ -4,6 +4,21 @@ function booleanConfig(value) {
   return value === "true" || value === true;
 }
 
+function calcNullSavings(values, _) {
+  return values.map(() => null);
+}
+
+/**
+ * Save the config object in the context, and set
+ * all values directly on the node.
+ *
+ * @param {*} node
+ * @param {*} originalConfig Object with config values
+ */
+function saveOriginalConfig(node, originalConfig) {
+  node.context().set("config", originalConfig);
+}
+
 /**
  * Sort values in array and return array with index of original array
  * in sorted order. Highest value first.
@@ -62,14 +77,22 @@ function getEffectiveConfig(node, msg) {
     node.error("Node has no config");
     return {};
   }
+  res.hasChanged = false;
   const isConfigMsg = !!msg?.payload?.config;
   if (isConfigMsg) {
     const inputConfig = msg.payload.config;
     Object.keys(inputConfig).forEach((key) => {
-      res[key] = inputConfig[key];
+      if (res[key] !== inputConfig[key]) {
+        res[key] = inputConfig[key];
+        res.hasChanged = true;
+      }
     });
     node.context().set("config", res);
   }
+
+  // Store config variables in node
+  Object.keys(res).forEach((key) => (node[key] = res[key]));
+
   return res;
 }
 
@@ -77,7 +100,7 @@ function loadDayData(node, date) {
   // Load saved schedule for the date (YYYY-MM-DD)
   // Return null if not found
   const key = date.toISODate();
-  const saved = node.context().get(key, node.contextStorage);
+  const saved = node.context().get(key);
   const res = saved ?? {
     schedule: [],
     hours: [],
@@ -152,6 +175,14 @@ function makeSchedule(onOff, startTimes, initial = null) {
   return res;
 }
 
+function makeScheduleFromHours(hours, initial = null) {
+  return makeSchedule(
+    hours.map((h) => h.onOff),
+    hours.map((h) => h.start),
+    initial
+  );
+}
+
 function fillArray(value, count) {
   if (value === undefined || count <= 0) {
     return [];
@@ -187,21 +218,63 @@ function validationFailure(node, message, status = null) {
   node.warn(message);
 }
 
+function msgHasPriceData(msg) {
+  return !!msg?.payload?.priceData;
+}
+
+function msgHasConfig(msg) {
+  return !!msg?.payload?.config;
+}
+
+function fixOutputValues(config) {
+  if (config.outputValueForOntype === "bool") {
+    config.outputValueForOn = booleanConfig(config.outputValueForOn);
+  }
+  if (config.outputValueForOntype === "num") {
+    config.outputValueForOn = Number(config.outputValueForOn);
+  }
+  if (config.outputValueForOfftype === "bool") {
+    config.outputValueForOff = booleanConfig(config.outputValueForOff);
+  }
+  if (config.outputValueForOfftype === "num") {
+    config.outputValueForOff = Number(config.outputValueForOff);
+  }
+}
+
+function fixPeriods(config) {
+  config.periods.forEach((p) => {
+    p.value = p.value === "true" || p.value === true;
+  });
+}
+
+function getOutputForTime(schedule, time, defaultValue) {
+  const pastSchedule = schedule.filter((entry) => DateTime.fromISO(entry.time) <= time);
+  return pastSchedule.length ? pastSchedule[pastSchedule.length - 1].value : defaultValue;
+}
+
 module.exports = {
   booleanConfig,
+  calcNullSavings,
   countAtEnd,
   extractPlanForDate,
   fillArray,
   firstOn,
+  fixOutputValues,
+  fixPeriods,
   getDiff,
   getDiffToNextOn,
   getEffectiveConfig,
+  getOutputForTime,
   getSavings,
   getStartAtIndex,
   isSameDate,
   loadDayData,
   makeSchedule,
+  makeScheduleFromHours,
+  msgHasConfig,
+  msgHasPriceData,
   roundPrice,
+  saveOriginalConfig,
   sortedIndex,
   validationFailure,
 };

package/test/commands-input-best-save.test.js

@@ -0,0 +1,142 @@
+const expect = require("expect");
+const cloneDeep = require("lodash.clonedeep");
+const helper = require("node-red-node-test-helper");
+const bestSave = require("../src/strategy-best-save.js");
+const prices = require("./data/converted-prices.json");
+const result = require("./data/commands-result-best-save.json");
+const { equalPlan } = require("./test-utils");
+const { makeFlow } = require("./strategy-best-save-test-utils");
+
+helper.init(require.resolve("node-red"));
+
+describe("send command as input to best save", () => {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should send schedule on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    let pass = 1;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n1.sendCurrentValueWhenRescheduling = true;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({ payload: { commands: { sendSchedule: true } } });
+            break;
+          case 2:
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            done();
+            break;
+        }
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+
+  it("should send output on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      n1.sendCurrentValueWhenRescheduling = true;
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        expect(equalPlan(result, msg.payload)).toBeTruthy();
+        n1.receive({ payload: { commands: { sendOutput: true }, time: "2021-10-11T11:00:05.000+02:00" } });
+        setTimeout(() => {
+          console.log("countOn = " + countOn + ", countOff = " + countOff);
+          expect(countOn).toEqual(1);
+          expect(countOff).toEqual(1);
+          done();
+        }, 50);
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+
+      n1.receive({ payload });
+    });
+  });
+  it("should reset on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalPlan(result, msg.payload)).toBeTruthy();
+        n1.receive({ payload: { commands: { reset: true } } });
+        n1.warn.should.be.calledWithExactly("No price data");
+        done();
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+
+  it("should replan on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    let pass = 1;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({ payload: { commands: { replan: true }, time: "2021-10-11T00:00:05.000+02:00" } });
+            break;
+          case 2:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            setTimeout(() => {
+              console.log("countOn = " + countOn + ", countOff = " + countOff);
+              expect(countOn).toEqual(0);
+              expect(countOff).toEqual(2);
+              done();
+            }, 50);
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+});

package/test/commands-input-lowest-price.test.js

@@ -0,0 +1,149 @@
+const expect = require("expect");
+const cloneDeep = require("lodash.clonedeep");
+const helper = require("node-red-node-test-helper");
+const lowestPrice = require("../src/strategy-lowest-price.js");
+const prices = require("./data/converted-prices.json");
+const result = require("./data/commands-result-lowest-price.json");
+const { equalPlan, equalSchedule } = require("./test-utils");
+const { makeFlow } = require("./strategy-lowest-price-test-utils");
+
+helper.init(require.resolve("node-red"));
+
+describe("send command as input to lowest price", () => {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should send schedule on command", function (done) {
+    const flow = makeFlow(3, 2);
+    let pass = 1;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n1.sendCurrentValueWhenRescheduling = true;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalSchedule(result.schedule, msg.payload.schedule)).toBeTruthy();
+            n1.receive({ payload: { commands: { sendSchedule: true } } });
+            break;
+          case 2:
+            expect(equalSchedule(result.schedule, msg.payload.schedule)).toBeTruthy();
+            done();
+            break;
+        }
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-10T00:00:00.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+
+  it("should send output on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    let pass = 1;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      n1.sendCurrentValueWhenRescheduling = true;
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({ payload: { commands: { sendOutput: true }, time: "2021-10-11T11:00:05.000+02:00" } });
+            setTimeout(() => {
+              console.log("countOn = " + countOn + ", countOff = " + countOff);
+              expect(countOn).toEqual(1);
+              expect(countOff).toEqual(1);
+              done();
+            }, 50);
+            break;
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-10T00:00:05.000+02:00";
+      payload.commands = { runSchedule: false };
+
+      n1.receive({ payload });
+    });
+  });
+  it("should reset on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalPlan(result, msg.payload)).toBeTruthy();
+        n1.receive({ payload: { commands: { reset: true } } });
+        n1.warn.should.be.calledWithExactly("No price data");
+        done();
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+
+  it("should replan on command", function (done) {
+    const flow = makeFlow(3, 2, true);
+    let pass = 1;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({ payload: { commands: { replan: true }, time: "2021-10-11T00:00:05.000+02:00" } });
+            break;
+          case 2:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            setTimeout(() => {
+              console.log("countOn = " + countOn + ", countOff = " + countOff);
+              expect(countOn).toEqual(0);
+              expect(countOff).toEqual(2);
+              done();
+            }, 50);
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+      const payload = cloneDeep(prices);
+      payload.time = "2021-10-11T00:00:05.000+02:00";
+      n1.receive({ payload });
+    });
+  });
+});

package/test/commands-input-schedule-merger.test.js

@@ -0,0 +1,128 @@
+const expect = require("expect");
+const cloneDeep = require("lodash.clonedeep");
+const helper = require("node-red-node-test-helper");
+const prices = require("./data/converted-prices.json");
+const { testPlan, equalHours } = require("./test-utils");
+const { makeFlow, makePayload } = require("./schedule-merger-test-utils");
+const scheduleMerger = require("../src/schedule-merger.js");
+const { allOff, someOn } = require("./data/merge-schedule-data.js");
+
+helper.init(require.resolve("node-red"));
+
+describe("send command as input to schedule merger", () => {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should send schedule on command", function (done) {
+    const flow = makeFlow("OR");
+    let pass = 1;
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+            n1.warn.should.not.be.called;
+            n1.receive({ payload: { commands: { sendSchedule: true } } });
+            break;
+          case 2:
+            expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+            done();
+            break;
+        }
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+
+  it("should send output on command", function (done) {
+    const flow = makeFlow("OR");
+    let pass = 1;
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+            n1.warn.should.not.be.called;
+            n1.receive({ payload: { commands: { sendOutput: true }, time: "2021-06-20T01:05:00.000+02:00" } });
+            setTimeout(() => {
+              console.log("countOn = " + countOn + ", countOff = " + countOff);
+              expect(countOn).toEqual(1);
+              expect(countOff).toEqual(1);
+              done();
+            }, 50);
+            break;
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+  it("should reset on command", function (done) {
+    const flow = makeFlow("OR");
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        n1.warn.should.not.be.called;
+        n1.receive({ payload: { commands: { reset: true } } });
+        n1.warn.should.be.calledWithExactly("No schedule");
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+
+  it("should replan on command", function (done) {
+    const flow = makeFlow("OR");
+    let pass = 1;
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+            n1.warn.should.not.be.called;
+            n1.receive({ payload: { commands: { replan: true }, time: "2021-06-19T00:00:00.000+02:00" } });
+            break;
+          case 2:
+            expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+            done();
+            break;
+        }
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+});

package/test/data/best-save-overlap-result.json

@@ -49,6 +49,11 @@
       "time": "2022-08-17T23:00:00.000+02:00",
       "value": true,
       "countHours": 1
+    },
+    {
+      "time": "2022-08-18T00:00:00.000+02:00",
+      "value": false,
+      "countHours": null
     }
   ],
   "hours": [
@@ -350,7 +355,6 @@
     "outputIfNoSchedule": false,
     "contextStorage": "default"
   },
-  "sentOnCommand": false,
   "time": "2022-08-16T17:14:35.673+02:00",
   "version": "3.6.0",
   "current": false

package/test/data/best-save-result.json

@@ -55,6 +55,10 @@
     {
       "time": "2021-06-20T01:50:00.470+02:00",
       "value": true
+    },
+    {
+      "time": "2021-06-20T02:50:00.470+02:00",
+      "value": false
     }
   ],
   "hours": [