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

package/dist/cjs/Models/Reservation.js

@@ -0,0 +1,98 @@
+const schemas = require("../utils/schema");
+const schema = require("../schemas/reservation.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Reservation extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  get peopleCount() {
+    return this.adultCount + this.childCount;
+  }
+
+  get hasPayment() {
+    return this.paymentId?.length > 0;
+  }
+
+  range(tz) {
+    const start = new Date(this.checkInDateTime);
+    const end = new Date(this.checkOutDateTime);
+
+    // output Dec 19 if same day in timezone
+
+    if (
+      start.getDate() === end.getDate() &&
+      start.getMonth() === end.getMonth() &&
+      start.getFullYear() === end.getFullYear()
+    ) {
+      return `${start.toLocaleString("default", {
+        month: "short",
+        timeZone: tz,
+      })} ${start.toLocaleString("default", {
+        timeZone: tz,
+        day: "numeric",
+      })}`;
+    }
+    // output Dec 19-23 if same month and year
+    if (
+      start.getMonth() === end.getMonth() &&
+      start.getFullYear() === end.getFullYear()
+    ) {
+      return `${start.toLocaleString("default", {
+        month: "short",
+        timeZone: tz,
+      })} ${start.toLocaleString("default", {
+        timeZone: tz,
+        day: "numeric",
+      })}-${end.toLocaleString("default", {
+        timeZone: tz,
+        day: "numeric",
+      })}`;
+    }
+
+    // output Dec 19 - Jan 2 if different month and year
+    return `${start.toLocaleString("default", {
+      month: "short",
+      timeZone: tz,
+    })} ${start.getDate()} - ${end.toLocaleString("default", {
+      month: "short",
+      timeZone: tz,
+    })} ${end.getDate()}`;
+  }
+
+  checkInTime(tz) {
+    return new Date(this.checkInDateTime).toLocaleString("default", {
+      hour: "numeric",
+      minute: "numeric",
+      timeZone: tz,
+    });
+  }
+
+  checkOutTime(tz) {
+    return new Date(this.checkOutDateTime).toLocaleString("default", {
+      hour: "numeric",
+      minute: "numeric",
+      timeZone: tz,
+    });
+  }
+}
+
+Object.defineProperty(Reservation.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Reservation.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Reservation, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Reservation;

package/dist/cjs/Models/Room.js

@@ -0,0 +1,212 @@
+// create the Room model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/room.json");
+const deviceSchema = require("../schemas/definitions.json");
+const Kohost = require("./Kohost");
+const cloneDeep = require("lodash.clonedeep");
+
+// device dependencies
+const Switch = require("./Switch");
+const Dimmer = require("./Dimmer");
+const Thermostat = require("./Thermostat");
+const Lock = require("./Lock");
+const WindowCovering = require("./WindowCovering");
+const Courtesy = require("./Courtesy");
+const Camera = require("./Camera");
+const Alarm = require("./Alarm");
+const MediaSource = require("./MediaSource");
+const MotionSensor = require("./MotionSensor");
+
+// other dependencies
+const Scene = require("./Scene");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Room extends Kohost {
+  constructor(data) {
+    const roomData = mapRoomData(data);
+    super(roomData);
+  }
+
+  static getDevicePath(type) {
+    const validTypes = deviceSchema.definitions.type.enum;
+    if (!validTypes.includes(type))
+      throw new Error("Invalid device type:" + type);
+    switch (type) {
+      case "tv":
+      case "dvr":
+      case "appleTv":
+      case "discPlayer":
+      case "mediaPlayer":
+      case "uncontrolledDevice":
+      case "mediaSource":
+        return "mediaSources";
+      case "courtesy":
+        return type;
+      case "switch":
+        return "switches";
+      default:
+        return `${type}s`;
+    }
+  }
+
+  static getDeviceTypeFromPath(path) {
+    const validPaths = [
+      "dimmers",
+      "switches",
+      "thermostats",
+      "locks",
+      "windowCoverings",
+      "courtesy",
+      "cameras",
+      "mediaSources",
+      "motionSensors",
+      "alarms",
+    ];
+    if (!validPaths.includes(path))
+      throw new Error("Invalid device path:" + path);
+    switch (path) {
+      case "courtesy":
+        return path;
+      case "switches":
+        return "switch";
+      default:
+        return path.slice(0, -1);
+    }
+  }
+
+  get hasDimmer() {
+    return this.dimmers?.length > 0;
+  }
+
+  get hasSwitch() {
+    return this.switches?.length > 0;
+  }
+
+  get hasWindowCovering() {
+    return this.windowCoverings?.length > 0;
+  }
+
+  get hasShade() {
+    return this.hasWindowCovering;
+  }
+
+  get hasThermostat() {
+    return this.thermostats?.length > 0;
+  }
+
+  get hasClimate() {
+    return this.hasThermostat;
+  }
+
+  get hasLock() {
+    return this.locks?.length > 0;
+  }
+
+  get hasCourtesy() {
+    return this.courtesy?.length > 0;
+  }
+
+  get hasCamera() {
+    return this.cameras?.length > 0;
+  }
+
+  get hasAlarm() {
+    return this.alarms?.length > 0;
+  }
+
+  get hasMedia() {
+    return this.mediaSources?.length > 0;
+  }
+
+  get hasLight() {
+    const hasSubTypeLight = this.switches?.some((sw) => {
+      return sw.subType === "light" || sw.subType === "fan";
+    });
+    return this.hasDimmer || hasSubTypeLight;
+  }
+
+  get occupied() {
+    const now = new Date();
+    const lastOccupied = new Date(this.occupiedAt);
+    const diff = now - lastOccupied;
+    // check if the room has been occupied in the last 60 minutes
+    return diff < 60 * 60 * 1000;
+  }
+}
+
+Object.defineProperty(Room.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Room.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Room, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+function mapRoomData(data) {
+  const roomData = cloneDeep(data);
+  roomData.dimmers?.map((dimmer) => {
+    if (dimmer instanceof Dimmer) return dimmer;
+    else return new Dimmer(dimmer);
+  });
+  roomData.switches?.map((switch_) => {
+    if (switch_ instanceof Switch) return switch_;
+    else return new Switch(switch_);
+  });
+
+  roomData.windowCoverings?.map((windowCovering) => {
+    if (windowCovering instanceof WindowCovering) return windowCovering;
+    else return new WindowCovering(windowCovering);
+  });
+
+  roomData.thermostats?.map((thermostat) => {
+    if (thermostat instanceof Thermostat) return thermostat;
+    else return new Thermostat(thermostat);
+  });
+
+  roomData.locks?.map((lock) => {
+    if (lock instanceof Lock) return lock;
+    else return new Lock(lock);
+  });
+
+  roomData.courtesy?.map((courtesy) => {
+    if (courtesy instanceof Courtesy) return courtesy;
+    else return new Courtesy(courtesy);
+  });
+
+  roomData.mediaSources?.map((source) => {
+    if (source instanceof MediaSource) return source;
+    else return new MediaSource(source);
+  });
+
+  roomData.cameras?.map((camera) => {
+    if (camera instanceof Camera) return camera;
+    else return new Camera(camera);
+  });
+
+  roomData.alarms?.map((alarm) => {
+    if (alarm instanceof Alarm) return alarm;
+    else return new Alarm(alarm);
+  });
+
+  roomData.motionSensors?.map((motionSensor) => {
+    if (motionSensor instanceof MotionSensor) return motionSensor;
+    else return new MotionSensor(motionSensor);
+  });
+
+  roomData.scenes?.map((scene) => {
+    if (scene instanceof Scene) return scene;
+    else return new Scene(scene);
+  });
+
+  return roomData;
+}
+
+module.exports = Room;

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;