@kohost/api-client 1.0.0-alpha.1 → 1.0.0-alpha.3

package/models/discoveredDevice.js

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

package/models/gateway.js

@@ -0,0 +1,37 @@
+// Create the Gateway Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/gateway.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+const { customAlphabet } = require("nanoid/async");
+const characters =
+  "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+class Gateway extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  static async generateAuthKey(length = 64) {
+    return await customAlphabet(characters, length)();
+  }
+}
+
+Object.defineProperty(Gateway.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Gateway.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Gateway, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Gateway;

package/models/index.js

@@ -0,0 +1,56 @@
+const IotGateway = require("./iotGateway");
+const Switch = require("./switch");
+const Alarm = require("./alarm");
+const Dimmer = require("./dimmer");
+const Lock = require("./lock");
+const SceneController = require("./sceneController");
+const Thermostat = require("./thermostat");
+const WindowCovering = require("./windowCovering");
+const User = require("./user");
+const ACL = require("./acl");
+const Courtesy = require("./courtesy");
+const Camera = require("./camera");
+const MotionSensor = require("./motionSensor");
+const MediaSource = require("./mediaSource");
+const Room = require("./room");
+const Reservation = require("./reservation");
+const Application = require("./application");
+const Space = require("./space");
+const Ticket = require("./ticket");
+const Scene = require("./scene");
+const Integration = require("./integration");
+const Gateway = require("./gateway");
+const DiscoveredDevice = require("./discoveredDevice");
+
+const AdminCustomer = require("./admin/customer");
+const AdminProperty = require("./admin/property");
+
+module.exports = {
+  Admin: {
+    Customer: AdminCustomer,
+    Property: AdminProperty,
+  },
+  Gateway,
+  IotGateway,
+  Switch,
+  Alarm,
+  Dimmer,
+  Lock,
+  Courtesy,
+  Camera,
+  SceneController,
+  MotionSensor,
+  Thermostat,
+  WindowCovering,
+  MediaSource,
+  User,
+  ACL,
+  Room,
+  Application, 
+  Space,
+  Ticket,
+  Scene,
+  Integration,
+  DiscoveredDevice,
+  Reservation,
+};

package/models/integration.js

@@ -0,0 +1,76 @@
+// Create the Driver Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/integration.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+class Integration extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+  getDriverDeviceId(kohostDeviceId, type) {
+    const found = this.deviceMap.get(kohostDeviceId);
+    if (found) {
+      if (type && found.type === type) return found.id;
+      else if (!type) return found.id;
+    }
+    return null;
+  }
+
+  getDeviceId(driverDeviceId, type) {
+    const found = this.driverDeviceMap.get(driverDeviceId);
+    if (found) {
+      if (type && found.type === type) return found.id;
+      else if (!type) return found.id;
+    }
+    return null;
+  }
+
+  getRoomId(driverDeviceId, type) {
+    const found = this.driverDeviceMap.get(driverDeviceId);
+    if (found) {
+      if (type && found.type === type) return found.roomId;
+      else if (!type) return found.roomId;
+    }
+    return null;
+  }
+
+  getDeviceData(driverDeviceId, type) {
+    const found = this.driverDeviceMap.get(driverDeviceId);
+    if (found) {
+      if (type && found.type === type)
+        return { id: found.id, roomId: found.roomId };
+      else if (!type) return { id: found.id, roomId: found.roomId };
+    }
+    return null;
+  }
+
+  get deviceMap() {
+    return new Map(Object.entries(this.data?.deviceMap || {}));
+  }
+
+  get driverDeviceMap() {
+    const map = new Map();
+    for (const [id, value] of Object.entries(this.data?.deviceMap || {})) {
+      map.set(value.id, { id, type: value.type, roomId: value.roomId });
+    }
+    return map;
+  }
+}
+
+Object.defineProperty(Integration.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Integration.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Integration, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Integration;

package/models/iotGateway.js

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

package/models/kohost.js

@@ -0,0 +1,95 @@
+const { ValidationError } = require("../errors");
+const { customAlphabet: generate } = require("nanoid");
+
+class Kohost {
+  constructor(data) {
+    if (!this.schema) {
+      throw new Error("Schema is not defined");
+    }
+
+    if (!this.validator) {
+      throw new Error("Validator is not defined");
+    }
+
+    const isNew = data?.id ? false : true;
+
+    this._setId(data);
+    this._validate(data);
+    this._setProperties(data);
+    this._setTimestamps(isNew);
+  }
+
+  static get validProperties() {
+    throw new Error("validProperties is not defined");
+  }
+
+  get schemaProperties() {
+    return Object.keys(this.validator.schema.properties);
+  }
+
+  _setId(data) {
+    if (data._id) data.id = data._id;
+    if (!data.id) {
+      data.id = this.constructor.generateId();
+    }
+    delete data._id;
+  }
+
+  _setProperties(data) {
+    this.schemaProperties.forEach((key) => {
+      if (data[key] !== undefined) this[key] = data[key];
+    });
+  }
+
+  _setTimestamps(isNew) {
+    const now = new Date();
+    if (
+      isNew &&
+      this.schemaProperties.includes("createdAt") &&
+      !this.createdAt
+    ) {
+      this.createdAt = now;
+    }
+  }
+
+  _validate(data) {
+    const valid = this.validator(data);
+    if (!valid)
+      throw new ValidationError(`Invalid ${this.constructor.name}`, {
+        cause: this.validator.errors,
+      });
+  }
+
+  static generateId() {
+    const length = 8;
+    const characters =
+      "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const id = generate(characters, length)();
+    return id;
+  }
+
+  static getActionDelta(old, _new) {
+    const delta = {};
+    for (const action in _new) {
+      if (this.actionProperties?.includes(action)) {
+        if (old[action] !== _new[action]) {
+          delta[action] = 1;
+        }
+      }
+    }
+    return delta;
+  }
+
+  toObject() {
+    const obj = { ...this };
+    // delete keys if they are not valid properties
+    Object.keys(obj).forEach((key) => {
+      if (!this.constructor.validProperties.includes(key)) {
+        delete obj[key];
+      }
+    });
+    return obj;
+  }
+}
+
+module.exports = Kohost;

package/models/lock.js

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

package/models/mediaSource.js

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

package/models/motionSensor.js

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

package/models/reservation.js

@@ -0,0 +1,36 @@
+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;
+  }
+}
+
+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/models/room.js

@@ -0,0 +1,185 @@
+// create the Room model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/room.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 SceneController = require("./sceneController");
+const Camera = require("./camera");
+const Alarm = require("./alarm");
+const Source = 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 = [
+      "dimmer",
+      "switch",
+      "thermostat",
+      "lock",
+      "windowCovering",
+      "courtesy",
+      "sceneController",
+      "camera",
+      "source",
+      "motionSensor",
+      "alarm",
+    ];
+    if (!validTypes.includes(type))
+      throw new Error("Invalid device type:" + type);
+    switch (type) {
+      case "courtesy":
+        return type;
+      case "switch":
+        return "switches";
+      default:
+        return `${type}s`;
+    }
+  }
+
+  get hasDimmer() {
+    return this.dimmers?.length > 0;
+  }
+
+  get hasSwitch() {
+    return this.switches?.length > 0;
+  }
+
+  get hasWindowCovering() {
+    return this.windowCoverings?.length > 0;
+  }
+
+  get hasThermostat() {
+    return this.thermostats?.length > 0;
+  }
+
+  get hasLock() {
+    return this.locks?.length > 0;
+  }
+
+  get hasCourtesy() {
+    return this.courtesy?.length > 0;
+  }
+
+  get hasSceneController() {
+    return this.sceneControllers?.length > 0;
+  }
+
+  get hasCamera() {
+    return this.cameras?.length > 0;
+  }
+
+  get hasAlarm() {
+    return this.alarms?.length > 0;
+  }
+
+  get hasMedia() {
+    return this.sources?.length > 0;
+  }
+
+  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.sources?.map((source) => {
+    if (source instanceof Source) return source;
+    else return new Source(source);
+  });
+
+  roomData.sceneControllers?.map((sceneController) => {
+    if (sceneController instanceof SceneController) return sceneController;
+    else return new SceneController(sceneController);
+  });
+
+  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/models/scene.js

@@ -0,0 +1,28 @@
+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 {
+  constructor(data) {
+    super(data);
+  }
+}
+
+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/models/sceneController.js

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