@etainabl/nodejs-sdk 1.1.21 → 1.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etainabl/nodejs-sdk",
-  "version": "1.1.21",
+  "version": "1.1.22",
   "main": "dist/index.js",
   "author": "Jonathan Lambert <jonathan@etainabl.com>",
   "type": "module",

package/src/consumption.ts

@@ -1,73 +1,34 @@
 import moment from 'moment';
-import { interpolate } from './lib/readingsInterpolate.js';
 
-export interface Reading {
-  submittedAt: string,
-  value: number
+interface ConsumptionData {
+  date: Date;
+  consumption: number;
 }
 
-export interface ApportionedReading {
-  date: moment.Moment,
-  reading: number,
-  consumption?: number
-}
-
-const apportionedReadings = (readings: Reading[], granularity: moment.unitOfTime.Diff = 'days', interpolationMethod: string = 'linear', startDate?: string, endDate?: string): ApportionedReading[] => {
-  // Readings sorted from newest to oldest
-  const sortedReadings = [...readings].sort((a, b) => moment(a.submittedAt).diff(b.submittedAt));
-
-  // Array of every hour/day etc between the first and last reading
-  const intervals = moment(sortedReadings[sortedReadings.length - 1].submittedAt).diff(moment(sortedReadings[0].submittedAt), granularity);
-
-  const dates = [...Array(intervals).keys()]
-    .slice(1)
-    .map((interval: number) => moment(sortedReadings[0].submittedAt).startOf(granularity).add(interval, granularity));
-
-  let interpolatedReadings = dates.map((date: moment.Moment) => {
-    const reading = interpolate(sortedReadings, date, interpolationMethod);
-
-    return {
-      date,
-      reading
-    };
-  });
+export const dayNightConsumption = (data: ConsumptionData[]) => data.reduce((acc: any, item: ConsumptionData) => {
+  const hour = moment(item.date).hour(); // End Time of HH consumption period
 
-  interpolatedReadings = interpolatedReadings.map((reading: ApportionedReading, index: number) => {
-    const prevReading = interpolatedReadings[index - 1];
-
-    if (prevReading) {
-      return {
-        ...reading,
-        consumption: reading.reading - prevReading.reading
-      };
-    }
-
-    return reading;
-
-  });
-
-  if (startDate) {
-    interpolatedReadings = interpolatedReadings.filter((reading: ApportionedReading) => moment(reading.date).isSameOrAfter(startDate, granularity));
+  if (hour >= 0 && hour < 7) {
+    acc.nightConsumption += item.consumption;
+  } else {
+    acc.dayConsumption += item.consumption;
   }
 
-  if (endDate) {
-    interpolatedReadings = interpolatedReadings.filter((reading: ApportionedReading) => moment(reading.date).isSameOrBefore(endDate, granularity));
-  }
+  acc.consumption += item.consumption;
 
-  return interpolatedReadings;
-};
+  return acc;
+}, {
+  dayConsumption: 0,
+  nightConsumption: 0,
+  consumption: 0
+});
 
-const consumptionFromReadings = (readings: Reading[], startDate: string, endDate: string, granularity: moment.unitOfTime.Diff = 'hours', interpolationMethod: string = 'linear') => {
-  // Split the readings into hourly readings and calculate the consumption for each hour
-  const apportioned = apportionedReadings(readings, granularity, interpolationMethod, startDate, endDate);
+export const calcMaxConsumptionValue = (data: ConsumptionData[]) => Math.max(...data.map((item: ConsumptionData) => item.consumption));
 
-  // Calculate the total consumption between the start and end dates
-  const totalConsumption = apportioned.reduce((acc: any, reading) => acc + reading.consumption, 0);
+export const calcMaxDemand = (data: ConsumptionData[]) => calcMaxConsumptionValue(data) * 2;
 
-  return { totalConsumption, apportioned };
-};
+export const calcPeakLoad = (consumption: number, maxDemand: number, startDate: Date, endDate: Date) => {
+  const days = Math.ceil(moment(endDate).diff(moment(startDate), 'days', true));
 
-export default {
-  apportionedReadings,
-  consumptionFromReadings
-};
+  return maxDemand === 0 ? 0 : ((consumption / (maxDemand * 24 * days)) * 100);
+};