node-red-contrib-power-saver 2.1.0 → 3.0.0

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: 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,58 +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;
 }
 
 /**
@@ -104,7 +53,36 @@ function getDiffToNextOn(values, onOff, nextOn = null) {
 }
 
 function getDiff(large, small) {
-  return Math.round((large - small) * 10000) / 10000;
+  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;
 }
 
 /**
@@ -129,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
@@ -234,17 +176,19 @@ function getStartAtIndex(effectiveConfig, priceData, time) {
 }
 
 module.exports = {
-  sortedIndex,
-  getDiffToNextOn,
-  firstOn,
-  isOnOffSequencesOk,
-  getSavings,
+  booleanConfig,
   countAtEnd,
-  makeSchedule,
-  fillArray,
-  convertMsg,
   extractPlanForDate,
-  isSameDate,
-  getStartAtIndex,
+  fillArray,
+  firstOn,
   getDiff,
+  getDiffToNextOn,
+  getEffectiveConfig,
+  getSavings,
+  getStartAtIndex,
+  isSameDate,
+  loadDayData,
+  makeSchedule,
+  roundPrice,
+  sortedIndex,
 };

package/test/data/adjustedResult.js

@@ -1,153 +1,301 @@
 module.exports = {
-  schedule: [
-    {
-      time: "2021-06-20T01:50:00.080+02:00",
-      value: true,
-    },
-    {
-      time: "2021-06-20T01:50:00.100+02:00",
-      value: false,
-    },
-    {
-      time: "2021-06-20T01:50:00.120+02:00",
-      value: true,
-    },
-    {
-      time: "2021-06-20T01:50:00.130+02:00",
-      value: false,
-    },
-    {
-      time: "2021-06-20T01:50:00.180+02:00",
-      value: true,
-    },
-  ],
+  schedule: [],
   hours: [
     {
-      price: 0.3,
-      onOff: true,
+      price: 0.2494,
+      onOff: false,
       start: "2021-06-20T01:50:00.000+02:00",
-      saving: null,
+      saving: 0.0395,
     },
     {
-      price: 0.4,
-      onOff: true,
+      price: 0.2209,
+      onOff: false,
       start: "2021-06-20T01:50:00.010+02:00",
-      saving: null,
+      saving: 0.011,
     },
     {
-      price: 0.8,
+      price: 0.2099,
       onOff: true,
       start: "2021-06-20T01:50:00.020+02:00",
       saving: null,
     },
     {
-      price: 0.9,
-      onOff: false,
+      price: 0.219,
+      onOff: true,
       start: "2021-06-20T01:50:00.030+02:00",
-      saving: 0.7,
+      saving: null,
     },
     {
-      price: 0.7,
-      onOff: false,
+      price: 0.2614,
+      onOff: true,
       start: "2021-06-20T01:50:00.040+02:00",
-      saving: 0.5,
+      saving: null,
     },
     {
-      price: 0.6,
-      onOff: false,
+      price: 0.4426,
+      onOff: true,
       start: "2021-06-20T01:50:00.050+02:00",
-      saving: 0.4,
+      saving: null,
     },
     {
-      price: 0.5,
-      onOff: false,
+      price: 0.5433,
+      onOff: true,
       start: "2021-06-20T01:50:00.060+02:00",
-      saving: 0.3,
+      saving: null,
     },
     {
-      price: 0.75,
-      onOff: false,
+      price: 0.5667,
+      onOff: true,
       start: "2021-06-20T01:50:00.070+02:00",
-      saving: 0.55,
+      saving: null,
     },
     {
-      price: 0.2,
+      price: 0.5847,
       onOff: true,
       start: "2021-06-20T01:50:00.080+02:00",
       saving: null,
     },
     {
-      price: 0.85,
+      price: 0.5762,
       onOff: true,
       start: "2021-06-20T01:50:00.090+02:00",
       saving: null,
     },
     {
-      price: 1.5,
-      onOff: false,
+      price: 0.5391,
+      onOff: true,
       start: "2021-06-20T01:50:00.100+02:00",
-      saving: 0.7,
+      saving: null,
     },
     {
-      price: 1.4,
-      onOff: false,
+      price: 0.5124,
+      onOff: true,
       start: "2021-06-20T01:50:00.110+02:00",
-      saving: 0.6,
+      saving: null,
     },
     {
-      price: 0.8,
+      price: 0.504,
       onOff: true,
       start: "2021-06-20T01:50:00.120+02:00",
       saving: null,
     },
     {
-      price: 0.9,
-      onOff: false,
+      price: 0.5057,
+      onOff: true,
       start: "2021-06-20T01:50:00.130+02:00",
-      saving: 0.7,
+      saving: null,
     },
     {
-      price: 0.7,
-      onOff: false,
+      price: 0.5066,
+      onOff: true,
       start: "2021-06-20T01:50:00.140+02:00",
-      saving: 0.5,
+      saving: null,
     },
     {
-      price: 0.6,
-      onOff: false,
+      price: 0.5136,
+      onOff: true,
       start: "2021-06-20T01:50:00.150+02:00",
-      saving: 0.4,
+      saving: null,
     },
     {
-      price: 0.5,
-      onOff: false,
+      price: 0.5143,
+      onOff: true,
       start: "2021-06-20T01:50:00.160+02:00",
-      saving: 0.3,
+      saving: null,
     },
     {
-      price: 0.75,
-      onOff: false,
+      price: 0.5306,
+      onOff: true,
       start: "2021-06-20T01:50:00.170+02:00",
-      saving: 0.55,
+      saving: null,
     },
     {
-      price: 0.2,
+      price: 0.5534,
       onOff: true,
       start: "2021-06-20T01:50:00.180+02:00",
       saving: null,
     },
     {
-      price: 0.85,
+      price: 0.5511,
       onOff: true,
       start: "2021-06-20T01:50:00.190+02:00",
       saving: null,
     },
+    {
+      price: 0.5491,
+      onOff: true,
+      start: "2021-06-20T01:50:00.200+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5485,
+      onOff: true,
+      start: "2021-06-20T01:50:00.210+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5481,
+      onOff: true,
+      start: "2021-06-20T01:50:00.220+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5218,
+      onOff: true,
+      start: "2021-06-20T01:50:00.230+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4533,
+      onOff: true,
+      start: "2021-06-20T01:50:00.240+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4196,
+      onOff: true,
+      start: "2021-06-20T01:50:00.250+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4037,
+      onOff: true,
+      start: "2021-06-20T01:50:00.260+02:00",
+      saving: null,
+    },
+    {
+      price: 0.3829,
+      onOff: true,
+      start: "2021-06-20T01:50:00.270+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4555,
+      onOff: true,
+      start: "2021-06-20T01:50:00.280+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4721,
+      onOff: true,
+      start: "2021-06-20T01:50:00.290+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4903,
+      onOff: true,
+      start: "2021-06-20T01:50:00.300+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5028,
+      onOff: true,
+      start: "2021-06-20T01:50:00.310+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5163,
+      onOff: true,
+      start: "2021-06-20T01:50:00.320+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5264,
+      onOff: true,
+      start: "2021-06-20T01:50:00.330+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5346,
+      onOff: true,
+      start: "2021-06-20T01:50:00.340+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5224,
+      onOff: true,
+      start: "2021-06-20T01:50:00.350+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5071,
+      onOff: true,
+      start: "2021-06-20T01:50:00.360+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5045,
+      onOff: true,
+      start: "2021-06-20T01:50:00.370+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5024,
+      onOff: true,
+      start: "2021-06-20T01:50:00.380+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5038,
+      onOff: true,
+      start: "2021-06-20T01:50:00.390+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5118,
+      onOff: true,
+      start: "2021-06-20T01:50:00.400+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5111,
+      onOff: true,
+      start: "2021-06-20T01:50:00.410+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5108,
+      onOff: true,
+      start: "2021-06-20T01:50:00.420+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5055,
+      onOff: true,
+      start: "2021-06-20T01:50:00.430+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5042,
+      onOff: true,
+      start: "2021-06-20T01:50:00.440+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5259,
+      onOff: true,
+      start: "2021-06-20T01:50:00.450+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5282,
+      onOff: true,
+      start: "2021-06-20T01:50:00.460+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5252,
+      onOff: true,
+      start: "2021-06-20T01:50:00.470+02:00",
+      saving: null,
+    },
   ],
-  source: "Other",
+  source: undefined,
   config: {
     maxHoursToSaveInSequence: 5,
     minHoursOnAfterMaxSequenceSaved: 2,
     minSaving: 0.25,
+    sendCurrentValueWhenRescheduling: undefined,
     outputIfNoSchedule: false,
     scheduleOnlyFromCurrentTime: true,
   },