@kohost/api-client 3.0.0-beta.9 → 3.0.0-beta.90

package/dist/cjs/Models/Room.js

@@ -0,0 +1,217 @@
+// 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");
+
+// 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 {
+  /**
+   * @typedef {import("../schemas/RoomSchema").Room} RoomType
+   * Create a Room instance.
+   * @constructor
+   * @param {RoomType} room - The room object of type Room.
+   */
+  constructor(room) {
+    const roomData = mapRoomData(room);
+    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 = structuredClone(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,169 @@
+const schemas = require("../utils/schema");
+const schema = require("../schemas/scene.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Scene extends Kohost {
+  /**
+   * @typedef {import("../schemas/SceneSchema").Scene} SceneType
+   * Create a Scene instance.
+   * @constructor
+   * @param {SceneType} scene - The scene object of type Scene.
+   */
+  constructor(scene) {
+    super(scene);
+  }
+
+  static getRoomSceneDeviceData(room, scene, restore) {
+    const deviceData = [];
+
+    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 deviceCmd = {
+              id: device.id,
+              systemId: device.systemId,
+              type: device.type,
+              driver: device.driver,
+              commandData: {},
+            };
+            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.max(
+                    currentSetpoint.min,
+                    currentSetpoint.value - delta
+                  );
+
+                  if (restore) {
+                    setpointValue = Math.min(
+                      currentSetpoint.max,
+                      currentSetpoint.value + delta
+                    );
+                  }
+
+                  deviceCmd.commandData.setpoints = {
+                    heat: {
+                      value: setpointValue,
+                    },
+                  };
+                }
+                if (currentMode === "cool") {
+                  let setpointValue = Math.min(
+                    currentSetpoint.max,
+                    currentSetpoint.value + delta
+                  );
+
+                  if (restore) {
+                    setpointValue = Math.max(
+                      currentSetpoint.min,
+                      currentSetpoint.value - delta
+                    );
+                  }
+                  deviceCmd.commandData.setpoints = {
+                    cool: {
+                      value: setpointValue,
+                    },
+                  };
+                }
+
+                if (currentMode === "auto") {
+                  if (!currentSetpoint && setpoints.cool && setpoints.heat) {
+                    let heatSetpoint = Math.max(
+                      setpoints.heat.min,
+                      setpoints.heat.value - delta
+                    );
+
+                    let coolSetpoint = Math.min(
+                      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.commandData.setpoints = {
+                      heat: {
+                        value: heatSetpoint,
+                      },
+                      cool: {
+                        value: coolSetpoint,
+                      },
+                    };
+                  }
+                }
+
+                if (currentMode === "off") {
+                  // move to next loop
+                  continue;
+                }
+              } else {
+                deviceCmd.commandData[prop] = deviceProps[prop];
+              }
+            }
+
+            // move to next loop if no keys in command data
+            if (Object.keys(deviceCmd.commandData).length === 0) {
+              continue;
+            }
+
+            deviceData.push(deviceCmd);
+          }
+        }
+        /**
+         * TODO: handle individual device ids
+         */
+      }
+    }
+    return deviceData;
+  }
+}
+
+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,35 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/ShortLinkSchema").ShortLink} ShortLinkType
+   * Create a ShortLink instance.
+   * @constructor
+   * @param {ShortLinkType} shortlink - The shortlink object of type ShortLink.
+   */
+  constructor(shortlink) {
+    super(shortlink);
+  }
+}
+
+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,35 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/SmsMessageSchema").SmsMessage} SmsMessageType
+   * Create a SmsMessage instance.
+   * @constructor
+   * @param {SmsMessageType} message - The message object of type SmsMessage.
+   */
+  constructor(message) {
+    super(message);
+  }
+}
+
+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} SpaceType
+   * Create a Space instance.
+   * @constructor
+   * @param {SpaceType} space - The space object of type Space.
+   */
+  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/Switch.js

@@ -0,0 +1,39 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/SwitchSchema").Switch} SwitchType
+   * Create a Switch instance.
+   * @constructor
+   * @param {SwitchType} _switch - The _switch object of type Switch.
+   */
+  constructor(_switch) {
+    super(_switch);
+  }
+}
+
+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,55 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/SystemUserSchema").SystemUser} SystemUserType
+   * Create a SystemUser instance.
+   * @constructor
+   * @param {SystemUserType} user - The user object of type SystemUser.
+   */
+
+  constructor(user) {
+    super(user);
+  }
+
+  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;