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

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/SpaceType.js

@@ -0,0 +1,36 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/SpaceTypeSchema").SpaceType} SpaceTypeType
+   * Create a SpaceType instance.
+   * @constructor
+   * @param {SpaceTypeType} spaceType - The spaceType object of type SpaceType.
+   */
+  constructor(spaceType) {
+    super(spaceType);
+  }
+}
+
+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,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;

package/dist/cjs/Models/Thermostat.js

@@ -0,0 +1,86 @@
+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 {
+  /**
+   * @typedef {import("../schemas/ThermostatSchema").Thermostat} ThermostatType
+   * Create a Thermostat instance.
+   * @constructor
+   * @param {ThermostatType} thermostat - The thermostat object of type Thermostat.
+   */
+  constructor(thermostat) {
+    super(thermostat);
+  }
+
+  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,111 @@
+// 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 {
+  /**
+   * @typedef {import("../schemas/TicketSchema").Ticket} TicketType
+   * Create a Ticket instance.
+   * @constructor
+   * @param {TicketType} ticket - The ticket object of type Ticket.
+   */
+  constructor(ticket) {
+    const ticketData = mapConversationData(ticket);
+    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;

package/dist/cjs/Models/User.js

@@ -0,0 +1,79 @@
+// Create the User Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/user.json");
+const paymentSchema = require("../schemas/payment.json");
+const Kohost = require("./Kohost");
+const MediaFile = require("./MediaFile");
+const Reservation = require("./Reservation");
+
+const { nanoid } = require("nanoid/async");
+
+schemas.add(paymentSchema);
+schemas.add(schema);
+
+const validator = schemas.compile(schema);
+
+class User extends Kohost {
+  /**
+   * @typedef {import("../schemas/UserSchema").User} UserType
+   * Create a User instance.
+   * @constructor
+   * @param {UserType} user - The user object of type User.
+   */
+  constructor(user) {
+    if (user.photo) user.photo = new MediaFile(user.photo);
+    if (user.reservations)
+      user.reservations = user.reservations.map((res) => new Reservation(res));
+    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);
+  }
+
+  static async generatePassword(len = 16) {
+    return await nanoid(len);
+  }
+}
+
+Object.defineProperty(User.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(User.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(User, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(User.prototype, "fullName", {
+  get: function () {
+    return `${this.firstName} ${this.lastName}`;
+  },
+});
+
+Object.defineProperty(User.prototype, "roles", {
+  get: function () {
+    const roles = new Set();
+    if (this.permissions) {
+      for (const permission of this.permissions) {
+        roles.add(permission.role);
+      }
+    }
+    return Array.from(roles);
+  },
+});
+
+module.exports = User;

package/dist/cjs/Models/WindowCovering.js

@@ -0,0 +1,55 @@
+// Create the WindowCovering Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/windowCovering.json");
+const Kohost = require("./Kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class WindowCovering extends Kohost {
+  /**
+   * @typedef {import("../schemas/WindowCoveringSchema").WindowCovering} WindowCoveringType
+   * Create a WindowCovering instance.
+   * @constructor
+   * @param {WindowCoveringType} windowCovering - The windowCovering object of type WindowCovering.
+   */
+  constructor(windowCovering) {
+    super(windowCovering);
+  }
+
+  static getActionDelta(old, _new) {
+    const delta = {};
+    for (const action in _new) {
+      if (this.actionProperties?.includes(action)) {
+        if (action === "position") {
+          const oldPos = old[action];
+          const newPos = _new[action];
+          delta[action] = newPos - oldPos / 100;
+        } else if (old[action] !== _new[action]) {
+          delta[action] = 1;
+        }
+      }
+    }
+    return delta;
+  }
+}
+
+Object.defineProperty(WindowCovering.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(WindowCovering.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(WindowCovering, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(WindowCovering, "actionProperties", {
+  value: ["position"],
+});
+
+module.exports = WindowCovering;

package/dist/cjs/Models/index.js

@@ -0,0 +1,68 @@
+const Reservation = require("./Reservation");
+const MediaFile = require("./MediaFile");
+const Switch = require("./Switch");
+const Alarm = require("./Alarm");
+const Dimmer = require("./Dimmer");
+const Lock = require("./Lock");
+const Thermostat = require("./Thermostat");
+const WindowCovering = require("./WindowCovering");
+const Identification = require("./Identification");
+const User = require("./User");
+const SystemUser = require("./SystemUser");
+const Courtesy = require("./Courtesy");
+const Camera = require("./Camera");
+const MotionSensor = require("./MotionSensor");
+const MediaSource = require("./MediaSource");
+const Room = require("./Room");
+
+const Space = require("./Space");
+const SpaceType = require("./SpaceType");
+
+const Ticket = require("./Ticket");
+const Scene = require("./Scene");
+const Gateway = require("./Gateway");
+const Product = require("./Product");
+const DiscoveredDevice = require("./DiscoveredDevice");
+const Credential = require("./Credential");
+const ShortLink = require("./ShortLink");
+const EnergyReportShard = require("./EnergyReportShard");
+const EnergyReport = require("./EnergyReport");
+const SMSMessage = require("./SmsMessage");
+const EmailMessage = require("./EmailMessage");
+
+const Property = require("./Property");
+const Organization = require("./Organization");
+
+module.exports = {
+  Organization,
+  Property,
+  MediaFile,
+  Gateway,
+  Switch,
+  Alarm,
+  Dimmer,
+  Lock,
+  Courtesy,
+  Camera,
+  MotionSensor,
+  Thermostat,
+  WindowCovering,
+  MediaSource,
+  Identification,
+  Product,
+  User,
+  SystemUser,
+  Room,
+  Space,
+  SpaceType,
+  Ticket,
+  Scene,
+  DiscoveredDevice,
+  Reservation,
+  Credential,
+  ShortLink,
+  EnergyReportShard,
+  EnergyReport,
+  SMSMessage,
+  EmailMessage,
+};

package/dist/cjs/SocketIoClient/index.js

@@ -0,0 +1,74 @@
+const io = require("socket.io-client");
+const { EventEmitter } = require("events");
+
+module.exports = class SocketIoClient extends EventEmitter {
+  constructor(config = { url: null, propertyId: null, options: {} }) {
+    super();
+    if (!config.url) throw new Error("Websocket URL / endpoint not provided");
+    if (!config.propertyId) throw new Error("Property ID not provided");
+    this.url = config.url;
+    this.propertyId = config.propertyId;
+    this.options = {
+      autoConnect: false,
+      forceNew: false,
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1000,
+      withCredentials: true,
+      transports: ["websocket", "polling"],
+      upgrade: true,
+      ...config.options,
+    };
+
+    this.socket = io(this.url, this.options);
+
+    this.socket.on("connect", () => {
+      this.emit("connect", this.socket);
+    });
+
+    this.socket.on("disconnect", (reason) => {
+      this.emit("disconnect", reason);
+    });
+
+    this.socket.on("reconnect_attempt", (data) => {
+      this.emit("reconnect_attempt", data);
+    });
+
+    this.socket.on("connect_error", (error) => {
+      this.emit("connect_error", error);
+    });
+  }
+
+  get connected() {
+    return this.socket?.connected || false;
+  }
+
+  get disconnected() {
+    return this.socket?.disconnected || false;
+  }
+
+  connect() {
+    this.socket.connect();
+  }
+
+  disconnect() {
+    this.socket.disconnect();
+  }
+
+  reconnect() {
+    this.disconnect();
+    this.connect();
+  }
+
+  subscribe(event, callback) {
+    this.socket.on(event, callback);
+  }
+
+  unsubscribe(event, callback) {
+    this.socket.off(event, callback);
+  }
+
+  send(event, { data = {}, query = {}, ...rest }) {
+    this.socket.emit(event, { data, query, ...rest });
+  }
+};