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

package/src/strategy-fixed-schedule.js

@@ -0,0 +1,84 @@
+const {
+  booleanConfig,
+  calcNullSavings,
+  fixOutputValues,
+  fixPeriods,
+  getSavings,
+  saveOriginalConfig,
+} = require("./utils");
+const { strategyOnInput } = require("./strategy-functions");
+const { DateTime } = require("luxon");
+const cloneDeep = require("lodash.clonedeep");
+
+module.exports = function (RED) {
+  function StrategyFixedScheduleNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.status({});
+
+    const validConfig = {
+      periods: config.periods || [],
+      validFrom: config.validFrom,
+      validTo: config.validTo,
+      days: config.days || { Mon: true, Tue: true, Wed: true, Thu: true, Fri: true, Sat: true, Sun: true },
+      contextStorage: config.contextStorage || "default",
+      outputIfNoSchedule: booleanConfig(config.outputIfNoSchedule),
+      outputValueForOn: config.outputValueForOn || true,
+      outputValueForOff: config.outputValueForOff || false,
+      outputValueForOntype: config.outputValueForOntype || "bool",
+      outputValueForOfftype: config.outputValueForOfftype || "bool",
+      override: "auto",
+      sendCurrentValueWhenRescheduling: config.sendCurrentValueWhenRescheduling,
+    };
+
+    fixOutputValues(validConfig);
+    fixPeriods(validConfig);
+    saveOriginalConfig(node, validConfig);
+
+    node.on("close", function () {
+      clearTimeout(node.schedulingTimeout);
+    });
+
+    node.on("input", function (msg) {
+      strategyOnInput(node, msg, doPlanning, calcNullSavings);
+    });
+  }
+  RED.nodes.registerType("ps-strategy-fixed-schedule", StrategyFixedScheduleNode);
+};
+
+function doPlanning(node, priceData) {
+  const startTimes = priceData.map((pd) => pd.start);
+  const onOff = startTimes.map(() => node.outputIfNoSchedule);
+  const allHours = buildAllHours(node, node.periods);
+  const validFrom = DateTime.fromISO(node.validFrom || startTimes[0].substr(0, 10));
+  const validTo = DateTime.fromISO(node.validTo || startTimes[startTimes.length - 1].substr(0, 10));
+  startTimes.forEach((st, i) => {
+    const date = DateTime.fromISO(st.substr(0, 10));
+    const hour = DateTime.fromISO(st).hour;
+    const day = DateTime.fromISO(st).weekday;
+    const dayName = Object.keys(node.days)[day - 1];
+    if (date >= validFrom && date <= validTo && node.days[dayName]) {
+      onOff[i] = allHours[hour];
+    }
+  });
+
+  return onOff;
+}
+
+function buildAllHours(node, periods) {
+  const sortedPeriods = cloneDeep(periods);
+  sortedPeriods.sort((a, b) => a.start - b.start);
+  let res = [];
+  let hour = 0;
+  let current = sortedPeriods[sortedPeriods.length - 1];
+  sortedPeriods.push({ start: 24, value: null });
+  sortedPeriods.forEach((period) => {
+    const nextHour = parseInt(period.start);
+    while (hour < nextHour) {
+      res[hour] = current.value;
+      hour++;
+    }
+    current = period;
+  });
+  return res;
+}

package/src/strategy-functions.js

@@ -0,0 +1,35 @@
+const { DateTime } = require("luxon");
+const { getEffectiveConfig, getOutputForTime } = require("./utils");
+const { handleStrategyInput } = require("./handle-input");
+const { handleOutput, shallSendOutput, strategyShallSendSchedule } = require("./handle-output");
+
+function strategyOnInput(node, msg, doPlanning, calcSavings) {
+  if (msg.payload?.name && msg.payload.name !== node.name) {
+    // If payload.name is set, and does not match this nodes name, discard message
+    return;
+  }
+  const config = getEffectiveConfig(node, msg);
+  const { plan, commands } = handleStrategyInput(node, msg, config, doPlanning, calcSavings);
+  if (plan) {
+    const planFromTime = msg.payload.time ? DateTime.fromISO(msg.payload.time) : DateTime.now();
+    const currentOutput = node.context().get("currentOutput");
+    const plannedOutputNow =
+      node.override === "auto"
+        ? getOutputForTime(plan.schedule, planFromTime, node.outputIfNoSchedule)
+        : node.override === "on";
+    const outputCommands = {
+      sendOutput: shallSendOutput(
+        msg,
+        commands,
+        currentOutput,
+        plannedOutputNow,
+        node.sendCurrentValueWhenRescheduling
+      ),
+      sendSchedule: strategyShallSendSchedule(msg, commands),
+      runSchedule: commands.replan !== false,
+    };
+    handleOutput(node, config, plan, outputCommands, planFromTime);
+  }
+}
+
+module.exports = { strategyOnInput };

package/src/strategy-lowest-price.html

@@ -61,6 +61,24 @@
         required: true,
         align: "left",
       },
+      outputValueForOn: {
+        value: true,
+        required: true,
+        validate: RED.validators.typedInput("outputValueForOntype", false),
+      },
+      outputValueForOff: {
+        value: false,
+        required: true,
+        validate: RED.validators.typedInput("outputValueForOfftype", false),
+      },
+      outputValueForOntype: {
+        value: "bool",
+        required: true,
+      },
+      outputValueForOfftype: {
+        value: "bool",
+        required: true,
+      },
       outputIfNoSchedule: { value: "true", required: true, align: "left" },
       outputOutsidePeriod: { value: "false", required: true, align: "left" },
       contextStorage: { value: "default", required: false, align: "left" },
@@ -132,58 +150,78 @@
           },
         ],
       });
+      $("#node-input-outputValueForOn").typedInput({
+        default: "bool",
+        typeField: $("#node-input-outputValueForOntype"),
+        types: ["bool", "num", "str"],
+      });
+      $("#node-input-outputValueForOff").typedInput({
+        default: "bool",
+        typeField: $("#node-input-outputValueForOfftype"),
+        types: ["bool", "num", "str"],
+      });
     },
   });
 </script>
 
 <script type="text/html" data-template-name="ps-strategy-lowest-price">
-  <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" style="width: 240px">
-  </div>
-  <div class="form-row">
-      <label for="node-input-fromTime"><i class="fa fa-clock-o"></i> From time</label>
-      <input type="text" id="node-input-fromTime" style="width: 80px">
+    <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" style="width: 240px">
     </div>
-  <div class="form-row">
-      <label for="node-input-toTime"><i class="fa fa-clock-o"></i> To time</label>
-      <input type="text" id="node-input-toTime" style="width: 80px">
-  </div>
-  <div class="form-row">
-      <label for="node-input-hoursOn"><i class="fa fa-arrows-h"></i> Hours on</label>
-      <input type="text" id="node-input-hoursOn" style="width: 80px">
-  </div>
-  <div class="form-row">
-    <label for="node-input-maxPrice"><i class="fa fa-minus"></i> Max price</label>
-    <input type="text" id="node-input-maxPrice" placeholder="Max price" style="width: 80px">
-  </div>
-  <div class="form-row">
-      <label for="node-input-doNotSplit">Consecutive on-period</label>
-      <input type="checkbox" id="node-input-doNotSplit" style="display:inline-block; width:22px; vertical-align:top;">
-      </label>
-  </div>
     <div class="form-row">
-        <label for="node-input-sendCurrentValueWhenRescheduling" style="width:240px">
-        <input type="checkbox"
-               id="node-input-sendCurrentValueWhenRescheduling"
-               style="display:inline-block; width:22px; vertical-align:top;"
-               autocomplete="off"><span>Send when rescheduling</span>
-        </label>
+        <label for="node-input-fromTime"><i class="fa fa-clock-o"></i> From time</label>
+        <input type="text" id="node-input-fromTime" style="width: 80px">
+      </div>
+    <div class="form-row">
+        <label for="node-input-toTime"><i class="fa fa-clock-o"></i> To time</label>
+        <input type="text" id="node-input-toTime" style="width: 80px">
     </div>
     <div class="form-row">
-        <label for="node-input-outputIfNoSchedule">If no schedule, send</label>
-        <input type="text" id="node-input-outputIfNoSchedule" style="width: 80px">
-        </label>
+        <label for="node-input-hoursOn"><i class="fa fa-arrows-h"></i> Hours on</label>
+        <input type="text" id="node-input-hoursOn" style="width: 80px">
     </div>
     <div class="form-row">
-        <label for="node-input-outputIfNoSchedule">Outside period, send</label>
-        <input type="text" id="node-input-outputOutsidePeriod" style="width: 80px">
-        </label>
+      <label for="node-input-maxPrice"><i class="fa fa-minus"></i> Max price</label>
+      <input type="text" id="node-input-maxPrice" placeholder="Max price" style="width: 80px">
     </div>
     <div class="form-row">
-      <label for="node-input-contextStorage"><i class="fa fa-archive"></i> Context storage</label>
-      <input type="text" id="node-input-contextStorage" style="width: 160px">
+        <label for="node-input-doNotSplit">Consecutive on-period</label>
+        <input type="checkbox" id="node-input-doNotSplit" style="display:inline-block; width:22px; vertical-align:top;">
+        </label>
     </div>
+    <div class="form-row">
+      <label for="node-input-outputValueForOn">Output value for on</label>
+      <input type="text" id="node-input-outputValueForOn" style="text-align: left; width: 120px">
+      <input type="hidden" id="node-input-outputValueForOntype">
+  </div>
+  <div class="form-row">
+      <label for="node-input-outputValueForOff">Output value for off</label>
+      <input type="text" id="node-input-outputValueForOff" style="text-align: left; width: 120px">
+      <input type="hidden" id="node-input-outputValueForOfftype">
+  </div>
+    <div class="form-row">
+          <label for="node-input-sendCurrentValueWhenRescheduling" style="width:240px">
+          <input type="checkbox"
+                 id="node-input-sendCurrentValueWhenRescheduling"
+                 style="display:inline-block; width:22px; vertical-align:top;"
+                 autocomplete="off"><span>Send when rescheduling</span>
+          </label>
+      </div>
+      <div class="form-row">
+          <label for="node-input-outputIfNoSchedule">If no schedule, send</label>
+          <input type="text" id="node-input-outputIfNoSchedule" style="width: 80px">
+          </label>
+      </div>
+      <div class="form-row">
+          <label for="node-input-outputIfNoSchedule">Outside period, send</label>
+          <input type="text" id="node-input-outputOutsidePeriod" style="width: 80px">
+          </label>
+      </div>
+      <div class="form-row">
+        <label for="node-input-contextStorage"><i class="fa fa-archive"></i> Context storage</label>
+        <input type="text" id="node-input-contextStorage" style="width: 160px">
+      </div>
 </script>
 
 <script type="text/markdown" data-help-name="ps-strategy-lowest-price">

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 });
+    });
+  });
+});