node-red-contrib-power-saver 2.0.5 → 3.0.2

package/src/strategy-best-save.js

@@ -0,0 +1,95 @@
+const { countAtEnd, makeSchedule, getSavings, getStartAtIndex, getDiff } = require("./utils");
+const { handleStrategyInput } = require("./handle-input");
+const { loadDayData } = require("./utils");
+
+const mostSavedStrategy = require("./strategy-best-save-functions");
+
+module.exports = function (RED) {
+  function StrategyBestSaveNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    const originalConfig = {
+      maxHoursToSaveInSequence: config.maxHoursToSaveInSequence,
+      minHoursOnAfterMaxSequenceSaved: config.minHoursOnAfterMaxSequenceSaved,
+      minSaving: parseFloat(config.minSaving),
+      sendCurrentValueWhenRescheduling: config.sendCurrentValueWhenRescheduling,
+      outputIfNoSchedule: config.outputIfNoSchedule === "true",
+      scheduleOnlyFromCurrentTime: config.scheduleOnlyFromCurrentTime === "true",
+    };
+    node.context().set("config", originalConfig);
+
+    node.on("close", function () {
+      clearTimeout(node.schedulingTimeout);
+    });
+
+    node.on("input", function (msg) {
+      handleStrategyInput(node, msg, doPlanning);
+    });
+  }
+  RED.nodes.registerType("ps-strategy-best-save", StrategyBestSaveNode);
+};
+
+function adjustSavingsPassedHours(plan, includeFromLastPlanHours) {
+  const firstOnIndex = plan.hours.findIndex((h) => h.onOff);
+  if (firstOnIndex < 0) {
+    return;
+  }
+  const nextOnValue = plan.hours[firstOnIndex].price;
+  let adjustIndex = includeFromLastPlanHours.length - 1;
+  while (adjustIndex >= 0 && !includeFromLastPlanHours[adjustIndex].onOff) {
+    includeFromLastPlanHours[adjustIndex].saving = getDiff(includeFromLastPlanHours[adjustIndex].price, nextOnValue);
+    adjustIndex--;
+  }
+}
+
+function loadDataJustBefore(node, dateDayBefore, dateToday, startAtIndex) {
+  const dataDayBefore = loadDayData(node, dateDayBefore);
+  const dataToday = loadDayData(node, dateToday);
+  return {
+    schedule: [...dataDayBefore.schedule, ...dataToday.schedule.slice(0, startAtIndex)],
+    hours: [...dataDayBefore.hours, ...dataToday.hours.slice(0, startAtIndex)],
+  };
+}
+
+function doPlanning(node, effectiveConfig, priceData, planFromTime, dateDayBefore, dateToday) {
+  const startAtIndex = getStartAtIndex(effectiveConfig, priceData, planFromTime);
+  const dataJustBefore = loadDataJustBefore(node, dateDayBefore, dateToday, startAtIndex);
+  const values = priceData.map((d) => d.value).slice(startAtIndex);
+  const startTimes = priceData.map((d) => d.start).slice(startAtIndex);
+  const onOffBefore = dataJustBefore.hours.map((h) => h.onOff);
+  const lastPlanHours = node.context().get("lastPlan")?.hours ?? [];
+  const plan = makePlan(node, values, startTimes, onOffBefore);
+  const includeFromLastPlanHours = lastPlanHours.filter(
+    (h) => h.start < plan.hours[0].start && h.start >= priceData[0].start
+  );
+  adjustSavingsPassedHours(plan, includeFromLastPlanHours);
+  plan.hours.splice(0, 0, ...includeFromLastPlanHours);
+  return plan;
+}
+
+function makePlan(node, values, startTimes, onOffBefore, firstValueNextDay) {
+  const lastValueDayBefore = onOffBefore[onOffBefore.length - 1];
+  const lastCountDayBefore = countAtEnd(onOffBefore, lastValueDayBefore);
+  const onOff = mostSavedStrategy.calculate(
+    values,
+    node.maxHoursToSaveInSequence,
+    node.minHoursOnAfterMaxSequenceSaved,
+    node.minSaving,
+    lastValueDayBefore,
+    lastCountDayBefore
+  );
+
+  const schedule = makeSchedule(onOff, startTimes, lastValueDayBefore);
+  const savings = getSavings(values, onOff, firstValueNextDay);
+  const hours = values.map((v, i) => ({
+    price: v,
+    onOff: onOff[i],
+    start: startTimes[i],
+    saving: savings[i],
+  }));
+  return {
+    hours,
+    schedule,
+  };
+}

package/src/strategy-lowest-price-functions.js

@@ -0,0 +1,35 @@
+const cloneDeep = require("lodash.clonedeep");
+const { sortedIndex } = require("./utils");
+
+function getBestContinuous(values, count) {
+  let min = values.reduce((p, v) => p + v, 0);
+  let minIndex = 0;
+  for (let i = 0; i <= values.length - count; i++) {
+    let sum = 0;
+    for (let j = 0; j < count; j++) {
+      sum += values[i + j];
+    }
+    if (sum < min) {
+      min = sum;
+      minIndex = i;
+    }
+  }
+  const onOff = cloneDeep(values)
+    .fill(false)
+    .fill(true, minIndex, minIndex + count);
+  return onOff;
+}
+
+function getBestX(values, count) {
+  const sorted = sortedIndex(values);
+  const onOff = cloneDeep(values).fill(true);
+  for (let i = 0; i < sorted.length - count; i++) {
+    onOff[sorted[i]] = false;
+  }
+  return onOff;
+}
+
+module.exports = {
+  getBestContinuous,
+  getBestX,
+};

package/src/strategy-lowest-price.html

@@ -0,0 +1,168 @@
+<script type="text/javascript">
+  const hours = [
+    "00",
+    "01",
+    "02",
+    "03",
+    "04",
+    "05",
+    "06",
+    "07",
+    "08",
+    "09",
+    "10",
+    "11",
+    "12",
+    "13",
+    "14",
+    "15",
+    "16",
+    "17",
+    "18",
+    "19",
+    "20",
+    "21",
+    "22",
+    "23",
+  ];
+
+  RED.nodes.registerType("ps-strategy-lowest-price", {
+    category: "Power Saver",
+    color: "#a6bbcf",
+    defaults: {
+      name: { value: "Lowest Price" },
+      fromTime: {
+        value: "00",
+        required: true,
+      },
+      toTime: {
+        value: "00",
+        required: true,
+      },
+      hoursOn: {
+        value: "12",
+        required: true,
+      },
+      doNotSplit: {
+        value: "false",
+        required: true,
+        align: "left",
+      },
+      sendCurrentValueWhenRescheduling: {
+        value: "true",
+        required: true,
+        align: "left",
+      },
+      outputIfNoSchedule: { value: "true", required: true, align: "left" },
+      outputOutsidePeriod: { value: "false", required: true, align: "left" },
+    },
+    inputs: 1,
+    outputs: 3,
+    icon: "font-awesome/fa-bar-chart",
+    color: "#FFCC66",
+    label: function () {
+      return this.name || "Lowest Price";
+    },
+    outputLabels: ["on", "off", "schedule"],
+    oneditprepare: function () {
+      $("#node-input-outputIfNoSchedule").typedInput({
+        types: [
+          {
+            value: "onoff",
+            options: [
+              { value: "true", label: "On" },
+              { value: "false", label: "Off" },
+            ],
+          },
+        ],
+      });
+      $("#node-input-outputOutsidePeriod").typedInput({
+        types: [
+          {
+            value: "onoff",
+            options: [
+              { value: "true", label: "On" },
+              { value: "false", label: "Off" },
+            ],
+          },
+        ],
+      });
+      $("#node-input-fromTime").typedInput({
+        types: [
+          {
+            value: "fromtime",
+            options: hours.map((h) => ({ value: h, label: h + ":00" })),
+          },
+        ],
+      });
+      $("#node-input-toTime").typedInput({
+        types: [
+          {
+            value: "totime",
+            options: hours.map((h) => ({ value: h, label: h + ":00" })),
+          },
+        ],
+      });
+      $("#node-input-hoursOn").typedInput({
+        types: [
+          {
+            value: "hourson",
+            options: (() => {
+              const res = hours.map((h) => ({ value: h, label: h }));
+              res.push({ value: "24", label: "24" });
+              return res;
+            })(),
+          },
+        ],
+      });
+    },
+  });
+</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-arrows-h"></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-arrows-h"></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-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>
+    </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>
+</script>
+
+<script type="text/markdown" data-help-name="ps-strategy-lowest-price">
+  A node to turn on a switch the hours when the price is lowest.
+
+  Please read more in the [node documentation](https://ottopaulsen.github.io/node-red-contrib-power-saver/nodes/ps-strategy-lowest-price)
+</script>

package/src/strategy-lowest-price.js

@@ -0,0 +1,125 @@
+const { DateTime } = require("luxon");
+const { booleanConfig, makeSchedule, loadDayData } = require("./utils");
+const { handleStrategyInput } = require("./handle-input");
+const { getBestContinuous, getBestX } = require("./strategy-lowest-price-functions");
+
+module.exports = function (RED) {
+  function StrategyLowestPriceNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    const originalConfig = {
+      fromTime: config.fromTime,
+      toTime: config.toTime,
+      hoursOn: parseInt(config.hoursOn),
+      doNotSplit: booleanConfig(config.doNotSplit),
+      sendCurrentValueWhenRescheduling: booleanConfig(config.sendCurrentValueWhenRescheduling),
+      outputIfNoSchedule: booleanConfig(config.outputIfNoSchedule),
+      outputOutsidePeriod: booleanConfig(config.outputOutsidePeriod),
+    };
+    node.context().set("config", originalConfig);
+
+    node.on("close", function () {
+      clearTimeout(node.schedulingTimeout);
+    });
+
+    node.on("input", function (msg) {
+      handleStrategyInput(node, msg, doPlanning);
+    });
+  }
+
+  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)];
+
+  const from = parseInt(node.fromTime);
+  const to = parseInt(node.toTime);
+  const periodStatus = [];
+  const startIndexes = [];
+  const endIndexes = [];
+  let currentStatus = from < to ? "Outside" : "StartMissing";
+  let hour;
+  priceData.forEach((pd, i) => {
+    hour = DateTime.fromISO(pd.start).hour;
+    if (hour === to && to === from && currentStatus === "Inside") {
+      endIndexes.push(i - 1);
+    }
+    if (hour === to && to !== from) {
+      currentStatus = "Outside";
+      endIndexes.push(i - 1);
+    }
+    if (hour === from) {
+      currentStatus = "Inside";
+      startIndexes.push(i);
+    }
+    periodStatus[i] = currentStatus;
+  });
+  if (currentStatus === "Inside" && hour !== (to === 0 ? 23 : to - 1)) {
+    // Last period incomplete
+    let i = periodStatus.length - 1;
+    do {
+      periodStatus[i] = "EndMissing";
+      hour = DateTime.fromISO(priceData[i].start).hour;
+      i--;
+    } while (periodStatus[i] === "Inside" && hour !== from);
+  }
+  if (hour === (to === 0 ? 23 : to - 1)) {
+    endIndexes.push(priceData.length - 1);
+  }
+
+  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(priceData[lastStartMissing].start)) {
+      for (let i = 0; i <= lastStartMissing; i++) {
+        onOff[i] = dataDayBefore.hours.find((h) => h.start === priceData[i].start);
+        periodStatus[i] = "Backfilled";
+      }
+    }
+  }
+
+  // Set onOff for hours that will not be planned
+  periodStatus.forEach((s, i) => {
+    onOff[i] =
+      s === "Outside"
+        ? node.outputOutsidePeriod
+        : s === "StartMissing" || s === "EndMissing"
+        ? node.outputIfNoSchedule
+        : null;
+  });
+
+  startIndexes.forEach((s, i) => {
+    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,
+  };
+}
+
+function makePlan(node, values, onOff, fromIndex, toIndex) {
+  const valuesInPeriod = values.slice(fromIndex, toIndex + 1);
+  const res = node.doNotSplit
+    ? getBestContinuous(valuesInPeriod, node.hoursOn)
+    : getBestX(valuesInPeriod, node.hoursOn);
+  res.forEach((v, i) => {
+    onOff[fromIndex + i] = v;
+  });
+  return onOff;
+}

package/{utils.js → src/utils.js}

@@ -1,57 +1,7 @@
 const { DateTime } = require("luxon");
 
-/**
- * Get today and tomorrow data out of the input message.
- * Can accept 3 types of messages: Tibber, Nordpool or plain payload with data already converted.
- * @param {*} msg
- */
-function convertMsg(msg) {
-  let today = [];
-  let tomorrow = [];
-  let source = "Unknown";
-
-  if (msg.payload?.viewer?.homes[0]?.currentSubscription?.priceInfo?.today) {
-    source = "Tibber";
-    today = msg.payload.viewer.homes[0].currentSubscription.priceInfo.today.map(
-      (v) => ({ value: v.total, start: v.startsAt })
-    );
-  } else if (msg.data?.new_state?.attributes?.raw_today) {
-    source = "Nordpool";
-    today = msg.data.new_state.attributes.raw_today.map((v) => ({
-      value: v.value,
-      start: v.start,
-    }));
-  } else if (msg.data?.attributes?.raw_today) {
-    source = "Nordpool";
-    today = msg.data.attributes.raw_today.map((v) => ({
-      value: v.value,
-      start: v.start,
-    }));
-  } else {
-    source = "Other";
-    today = msg.payload?.today || [];
-  }
-
-  if (msg.payload?.viewer?.homes[0]?.currentSubscription?.priceInfo?.tomorrow) {
-    tomorrow =
-      msg.payload.viewer.homes[0].currentSubscription.priceInfo.tomorrow.map(
-        (v) => ({ value: v.total, start: v.startsAt })
-      );
-  } else if (msg.data?.new_state?.attributes?.raw_tomorrow) {
-    tomorrow = msg.data.new_state.attributes.raw_tomorrow.map((v) => ({
-      value: v.value,
-      start: v.start,
-    }));
-  } else if (msg.data?.attributes?.raw_tomorrow) {
-    tomorrow = msg.data.attributes.raw_tomorrow.map((v) => ({
-      value: v.value,
-      start: v.start,
-    }));
-  } else {
-    tomorrow = msg.payload?.tomorrow || [];
-  }
-
-  return { today, tomorrow, source };
+function booleanConfig(value) {
+  return value === "true" || value === true;
 }
 
 /**
@@ -94,14 +44,47 @@ function getDiffToNextOn(values, onOff, nextOn = null) {
   const res = values.map((p, i, a) => {
     for (let n = i + 1; n < a.length; n++) {
       if (onOff[n]) {
-        return Math.round((values[i] - values[n]) * 10000) / 10000;
+        return getDiff(values[i], values[n]);
       }
     }
-    return Math.round((p - nextOnValue) * 10000) / 10000;
+    return getDiff(p, nextOnValue);
   });
   return res;
 }
 
+function getDiff(large, small) {
+  return roundPrice(large - small);
+}
+
+function getEffectiveConfig(node, msg) {
+  const res = node.context().get("config");
+  const isConfigMsg = !!msg?.payload?.config;
+  if (isConfigMsg) {
+    const inputConfig = msg.payload.config;
+    Object.keys(inputConfig).forEach((key) => {
+      res[key] = inputConfig[key];
+    });
+    node.context().set("config", res);
+  }
+  return res;
+}
+
+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);
+  const res = saved ?? {
+    schedule: [],
+    hours: [],
+  };
+  return res;
+}
+
+function roundPrice(value) {
+  return Math.round(value * 10000) / 10000;
+}
+
 /**
  *
  * @param {*} values Array of prices
@@ -111,9 +94,7 @@ function getDiffToNextOn(values, onOff, nextOn = null) {
  * @returns Array with how much you save on the off-hours, null on the others.
  */
 function getSavings(values, onOff, nextOn = null) {
-  return getDiffToNextOn(values, onOff, nextOn).map((v, i) =>
-    onOff[i] ? null : v
-  );
+  return getDiffToNextOn(values, onOff, nextOn).map((v, i) => (onOff[i] ? null : v));
 }
 
 /**
@@ -126,42 +107,6 @@ function firstOn(values, onOff, defaultValue = 0) {
   return [...values, defaultValue][[...onOff, true].findIndex((e) => e)];
 }
 
-/**
- * Takes an array of true/false values where true means on and false means off.
- * Evaluates of the on/off sequences are valid according to other arguments.
- *
- * @param {*} onOff Array of on/off values
- * @param {*} maxOff Max number of values that can be off in a sequence
- * @param {*} minOnAfterOff Min number of values that must be on after maxOff is reached
- * @returns
- */
-function isOnOffSequencesOk(onOff, maxOff, minOnAfterOff) {
-  let offCount = 0;
-  let onCount = 0;
-  let reachedMaxOff = false;
-  for (let i = 0; i < onOff.length; i++) {
-    if (!onOff[i]) {
-      if (maxOff === 0 || reachedMaxOff) {
-        return false;
-      }
-      offCount++;
-      onCount = 0;
-      if (offCount >= maxOff) {
-        reachedMaxOff = true;
-      }
-    } else {
-      if (reachedMaxOff) {
-        onCount++;
-        if (onCount >= minOnAfterOff) {
-          reachedMaxOff = false;
-        }
-      }
-      offCount = 0;
-    }
-  }
-  return true;
-}
-
 /**
  * Count number of the given value at the end of the given array
  * @param {*} arr
@@ -219,21 +164,31 @@ function extractPlanForDate(plan, day) {
 }
 
 function isSameDate(date1, date2) {
-  return (
-    DateTime.fromISO(date1).toISODate() === DateTime.fromISO(date2).toISODate()
-  );
+  return DateTime.fromISO(date1).toISODate() === DateTime.fromISO(date2).toISODate();
+}
+
+function getStartAtIndex(effectiveConfig, priceData, time) {
+  if (effectiveConfig.scheduleOnlyFromCurrentTime) {
+    return priceData.map((p) => DateTime.fromISO(p.start)).filter((t) => t < time).length;
+  } else {
+    return 0;
+  }
 }
 
 module.exports = {
-  sortedIndex,
-  getDiffToNextOn,
-  firstOn,
-  isOnOffSequencesOk,
-  getSavings,
+  booleanConfig,
   countAtEnd,
-  makeSchedule,
-  fillArray,
-  convertMsg,
   extractPlanForDate,
+  fillArray,
+  firstOn,
+  getDiff,
+  getDiffToNextOn,
+  getEffectiveConfig,
+  getSavings,
+  getStartAtIndex,
   isSameDate,
+  loadDayData,
+  makeSchedule,
+  roundPrice,
+  sortedIndex,
 };