@kohost/api-client 3.0.0-beta.47 → 3.0.0-beta.50

package/dist/cjs/Models/Scene.js

@@ -0,0 +1,183 @@
+const schemas = require("../utils/schema");
+const schema = require("../schemas/scene.json");
+const Kohost = require("./Kohost");
+const SetSceneCommand = require("../Commands/SetSceneCommand");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Scene extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  static createSceneCommandPayload(room, scene, restore) {
+    const commandsByDriver = [];
+
+    const sceneDevices = scene?.devices || {};
+    const sceneId = scene.id;
+
+    for (const deviceType in sceneDevices) {
+      const sceneData = sceneDevices[deviceType];
+
+      const roomDevices = room[deviceType];
+
+      if (sceneId === "1" && restore && deviceType !== "thermostats") continue;
+
+      for (const data of sceneData) {
+        const { id, ...deviceProps } = data;
+        if (id === "*") {
+          for (const device of roomDevices) {
+            const driver = device.driver;
+            const deviceCmd = {
+              id: device.systemData?.id,
+            };
+            for (const prop in deviceProps) {
+              if (prop === "setpointDelta") {
+                const delta = deviceProps[prop];
+                const currentMode = device.hvacMode;
+                const setpoints = device.setpoints;
+                const minAutoDelta = device.minAutoDelta;
+                const currentSetpoint = setpoints[currentMode];
+
+                if (currentMode === "heat") {
+                  let setpointValue = Math.min(
+                    currentSetpoint.min,
+                    currentSetpoint.value - delta
+                  );
+
+                  if (restore) {
+                    setpointValue = Math.min(
+                      currentSetpoint.max,
+                      currentSetpoint.value + delta
+                    );
+                  }
+
+                  deviceCmd.setpoints = {
+                    heat: {
+                      value: setpointValue,
+                    },
+                  };
+                }
+                if (currentMode === "cool") {
+                  let setpointValue = Math.max(
+                    currentSetpoint.max,
+                    currentSetpoint.value + delta
+                  );
+
+                  if (restore) {
+                    setpointValue = Math.max(
+                      currentSetpoint.min,
+                      currentSetpoint.value - delta
+                    );
+                  }
+                  deviceCmd.setpoints = {
+                    cool: {
+                      value: setpointValue,
+                    },
+                  };
+                }
+
+                if (currentMode === "auto") {
+                  if (!currentSetpoint && setpoints.cool && setpoints.heat) {
+                    let heatSetpoint = Math.min(
+                      setpoints.heat.min,
+                      setpoints.heat.value - delta
+                    );
+
+                    let coolSetpoint = Math.max(
+                      setpoints.cool.max,
+                      setpoints.cool.value + delta
+                    );
+
+                    if (restore) {
+                      heatSetpoint = Math.min(
+                        setpoints.heat.max,
+                        setpoints.heat.value + delta
+                      );
+
+                      coolSetpoint = Math.max(
+                        setpoints.cool.min,
+                        setpoints.cool.value - delta
+                      );
+                    }
+
+                    // make sure the delta is not less than the minAutoDelta
+                    if (Math.abs(heatSetpoint - coolSetpoint) < minAutoDelta) {
+                      continue;
+                    }
+
+                    deviceCmd.setpoints = {
+                      heat: {
+                        value: heatSetpoint,
+                      },
+                      cool: {
+                        value: coolSetpoint,
+                      },
+                    };
+                  }
+                }
+
+                if (currentMode === "off") {
+                  // move to next loop
+                  continue;
+                }
+              } else {
+                deviceCmd[prop] = deviceProps[prop];
+              }
+            }
+
+            // move to next loop if the only key in deviceCmd is id
+            if (Object.keys(deviceCmd).length === 1) {
+              continue;
+            }
+
+            const driverIndex = commandsByDriver.findIndex(
+              (c) => c.driver === driver
+            );
+            if (driverIndex >= 0) {
+              commandsByDriver[driverIndex].command.devices.push(deviceCmd);
+            } else {
+              commandsByDriver.push({
+                driver,
+                command: {
+                  id: sceneId,
+                  devices: [deviceCmd],
+                },
+              });
+            }
+          }
+        }
+        /**
+         * TODO: handle individual device ids
+         */
+      }
+    }
+
+    const commands = commandsByDriver.map((c) => {
+      const command = new SetSceneCommand(c.command);
+      return {
+        driver: c.driver,
+        command,
+      };
+    });
+
+    return commands;
+  }
+}
+
+Object.defineProperty(Scene.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Scene.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Scene, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Scene;

package/dist/cjs/Models/ShortLink.js

@@ -0,0 +1,29 @@
+// Create the Lock Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/shortLink.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class ShortLink extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(ShortLink.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(ShortLink.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(ShortLink, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = ShortLink;

package/dist/cjs/Models/SmsMessage.js

@@ -0,0 +1,29 @@
+// Create the SMS Message Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/smsMessage.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class SMSMessage extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(SMSMessage.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(SMSMessage.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(SMSMessage, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = SMSMessage;

package/dist/cjs/Models/Space.js

@@ -0,0 +1,97 @@
+// Create the Space Model
+// A group of rooms -> rooms could become a space later...
+const schemas = require("../utils/schema");
+const schema = require("../schemas/space.json");
+const Kohost = require("./Kohost");
+
+const Room = require("./Room");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Space extends Kohost {
+  /**
+   * @typedef {import("../schemas/SpaceSchema").Space} SpaceSchema
+   * Create a Dimmer instance.
+   * @constructor
+   * @param {SpaceSchema} space - The dimmer object of type Dimmer.
+   */
+  constructor(space) {
+    const spaceData = mapSpaceData(space);
+    super(spaceData);
+  }
+
+  get floor() {
+    const floors = new Set();
+
+    this.room.forEach((room) => {
+      if (room.floor) floors.add(room.floor);
+    });
+
+    return floors.size == 1 ? [...floors][0] : undefined;
+  }
+
+  get hasDimmer() {
+    return this.rooms.some((room) => room.hasDimmer);
+  }
+
+  get hasSwitch() {
+    return this.rooms.some((room) => room.hasSwitch);
+  }
+
+  get hasWindowCovering() {
+    return this.rooms.some((room) => room.hasWindowCovering);
+  }
+
+  get hasThermostat() {
+    return this.rooms.some((room) => room.hasThermostat);
+  }
+
+  get hasLock() {
+    return this.rooms.some((room) => room.hasLock);
+  }
+
+  get hasCourtesy() {
+    return this.rooms.some((room) => room.hasCourtesy);
+  }
+
+  get hasCamera() {
+    return this.rooms.some((room) => room.hasCamera);
+  }
+
+  get hasAlarm() {
+    return this.rooms.some((room) => room.hasAlarm);
+  }
+
+  get hasMedia() {
+    return this.rooms.some((room) => room.hasMedia);
+  }
+}
+
+Object.defineProperty(Space.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Space.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Space, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+function mapSpaceData(data) {
+  const spaceData = structuredClone(data);
+  if (spaceData.rooms?.length) {
+    spaceData.rooms.map((room) => {
+      if (typeof room === "string") return room;
+      if (room instanceof Room) return room;
+      return new Room(room);
+    });
+  }
+  return spaceData;
+}
+
+module.exports = Space;

package/dist/cjs/Models/SpaceType.js

@@ -0,0 +1,30 @@
+// Create the Space Type Model
+// Originally used for hotel room type e.g. Double Queen
+const schemas = require("../utils/schema");
+const schema = require("../schemas/spaceType.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class SpaceType extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(SpaceType.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(SpaceType.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(SpaceType, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = SpaceType;

package/dist/cjs/Models/Switch.js

@@ -0,0 +1,33 @@
+// create the Switch model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/switch.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Switch extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+}
+
+Object.defineProperty(Switch.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Switch.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Switch, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Switch, "actionProperties", {
+  value: ["state"],
+});
+
+module.exports = Switch;

package/dist/cjs/Models/SystemUser.js

@@ -0,0 +1,48 @@
+// Create the User Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/systemUser.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+
+const validator = schemas.compile(schema);
+
+class SystemUser extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  static validatePhone(phoneNumber) {
+    const regex = /^\+?[1-9]\d{1,14}$/;
+    return regex.test(phoneNumber);
+  }
+
+  static validateEmail(email) {
+    //eslint-disable-next-line no-useless-escape
+    const regex =
+      /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+    return regex.test(email);
+  }
+}
+
+Object.defineProperty(SystemUser.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(SystemUser.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(SystemUser, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(SystemUser.prototype, "fullName", {
+  get: function () {
+    return `${this.firstName} ${this.lastName}`;
+  },
+});
+
+module.exports = SystemUser;

package/dist/cjs/Models/Thermostat.js

@@ -0,0 +1,80 @@
+const schemas = require("../utils/schema");
+const schema = require("../schemas/thermostat.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Thermostat extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  toCelsius() {
+    if (this.temperatureScale === "fahrenheit")
+      this.currentTemperature = ((this.currentTemperature - 32) * 5) / 9;
+    this.temperatureScale = "celsius";
+    return this.currentTemperature;
+  }
+
+  toFahrenheit() {
+    if (this.temperatureScale === "celsius")
+      this.currentTemperature = (this.currentTemperature * 9) / 5 + 32;
+    this.temperatureScale = "fahrenheit";
+    return this.currentTemperature;
+  }
+
+  static getActionDelta(old, _new) {
+    const delta = {};
+    for (const action in _new) {
+      if (this.actionProperties.includes(action)) {
+        switch (action) {
+          case "hvacMode":
+          case "fanMode": {
+            if (old[action] !== _new[action]) delta[action] = 1;
+            break;
+          }
+          case "setpoints": {
+            const setpoints = _new[action];
+            for (const setpoint in setpoints) {
+              if (old[action][setpoint].value !== setpoints[setpoint].value) {
+                const min =
+                  setpoints[setpoint].min || old[action][setpoint].min;
+                const max =
+                  setpoints[setpoint].max || old[action][setpoint].max;
+                const oldValue = old[action][setpoint].value;
+                const value = setpoints[setpoint].value;
+                // get percentage change relative to min and max
+                const percentChange = (value - oldValue) / (max - min);
+                // get the delta
+                delta[`setpoints.${setpoint}`] = percentChange;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return delta;
+  }
+}
+
+Object.defineProperty(Thermostat.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Thermostat.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Thermostat, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Thermostat, "actionProperties", {
+  value: ["hvacMode", "fanMode", "setpoints"],
+});
+
+module.exports = Thermostat;

package/dist/cjs/Models/Ticket.js

@@ -0,0 +1,105 @@
+// Create the User Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/ticket.json");
+const Kohost = require("./Kohost");
+const MediaFile = require("./MediaFile");
+
+const sortBy = require("lodash.sortby");
+const findLast = require("lodash.findlast");
+
+const { nanoid } = require("nanoid");
+const cloneDeep = require("lodash.clonedeep");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Ticket extends Kohost {
+  constructor(data) {
+    const ticketData = mapConversationData(data);
+    super(ticketData);
+  }
+
+  static generateMessageId(len = 16) {
+    return nanoid(len);
+  }
+}
+
+Object.defineProperty(Ticket.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Ticket.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Ticket, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Ticket.prototype, "responseTime", {
+  get: function () {
+    const conversation = this.conversation;
+    const requester = this.requester;
+
+    if (conversation.length === 0) return 0;
+    const mapped = conversation.map((msg) => {
+      if (typeof msg.timestamp === "string")
+        msg.timestamp = new Date(msg.timestamp);
+      return msg;
+    });
+    const sorted = sortBy(mapped, ["timestamp"]);
+    const firstMsg = sorted.find((entry) => entry.userId === requester);
+    const firstResponse = sorted.find((entry) => entry.userId !== requester);
+
+    if (firstMsg && firstResponse) {
+      const firstMsgTime = firstMsg.timestamp.getTime() / 1000;
+      const firstResponseTime = firstResponse.timestamp.getTime() / 1000;
+      return firstResponseTime - firstMsgTime;
+    }
+
+    return 0;
+  },
+});
+
+Object.defineProperty(Ticket.prototype, "resolutionTime", {
+  get: function () {
+    if (this.status !== "closed") return 0;
+    const createdAt = this.createdAt.getTime() / 1000;
+    const solvedAt = this.solvedAt
+      ? this.solvedAt.getTime() / 1000
+      : this.updatedAt.getTime() / 1000;
+
+    return Math.abs(solvedAt - createdAt);
+  },
+});
+
+Object.defineProperty(Ticket.prototype, "lastResponder", {
+  get: function () {
+    const conversation = this.conversation;
+    const requester = this.requester;
+
+    const sorted = sortBy(conversation, ["timestamp"]);
+
+    const lastFromNonRequester = findLast(sorted, function (c) {
+      return c.userId !== requester;
+    });
+
+    if (!lastFromNonRequester) return null;
+    else return lastFromNonRequester.userId;
+  },
+});
+
+function mapConversationData(data) {
+  const ticketData = cloneDeep(data);
+  ticketData.conversation = ticketData.conversation.map((msg) => {
+    if (msg.media) {
+      msg.media = new MediaFile(msg.media);
+    }
+    return msg;
+  });
+  return ticketData;
+}
+
+module.exports = Ticket;