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

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;

package/dist/cjs/Models/User.js

@@ -0,0 +1,73 @@
+// 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 {
+  constructor(data) {
+    if (data.photo) data.photo = new MediaFile(data.photo);
+    if (data.reservations)
+      data.reservations = data.reservations.map((res) => new Reservation(res));
+    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);
+  }
+
+  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,49 @@
+// 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 {
+  constructor(data) {
+    super(data);
+  }
+
+  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 });
+  }
+};

package/dist/cjs/defs/deviceTypes.js

@@ -0,0 +1,15 @@
+const types = [
+  "dimmer",
+  "switch",
+  "thermostat",
+  "lock",
+  "windowCovering",
+  "courtesy",
+  "alarm",
+  "camera",
+  "mediaSource",
+  "motionSensor",
+  "gateway",
+];
+
+module.exports = types;

package/dist/cjs/defs/formalDeviceTypes.js

@@ -0,0 +1,6 @@
+const deviceTypes = require("./deviceTypes");
+const formalDeviceTypes = deviceTypes.map(
+  (type) => type.charAt(0).toUpperCase() + type.slice(1)
+);
+
+module.exports = formalDeviceTypes;

package/dist/cjs/defs/index.js

@@ -0,0 +1,11 @@
+const deviceTypes = require("./deviceTypes");
+const formalDeviceTypes = require("./formalDeviceTypes");
+const { defs: httpDefs } = require("../Client");
+
+const defs = {
+  http: httpDefs,
+  deviceTypes,
+  formalDeviceTypes,
+};
+
+module.exports = defs;

package/dist/cjs/{index.cjs.js → index.js}

@@ -5,13 +5,19 @@ const Events = require("./Events");
 const defs = require("./defs");
 const utils = require("./utils");
 const Client = require("./Client");
+const SocketIoClient = require("./SocketIoClient");
+const AMQPClient = require("./AMQPClient");
+
 const Kohost = {
   Models,
   Errors,
   Commands,
   Events,
   Client,
+  SocketIoClient,
+  AMQPClient,
   defs,
-  utils
+  utils: utils,
 };
+
 module.exports = Kohost;

package/dist/cjs/schemas/alarm.json

@@ -0,0 +1,103 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "alarm.json",
+  "title": "Alarm",
+  "description": "Any smart alarm system",
+  "type": "object",
+  "properties": {
+    "id": {
+      "$ref": "definitions.json#/definitions/id"
+    },
+    "name": {
+      "type": "string"
+    },
+    "type": {
+      "$ref": "definitions.json#/definitions/type"
+    },
+    "systemData": {
+      "$ref": "definitions.json#/definitions/systemData"
+    },
+    "supportedNotifications": {
+      "$ref": "definitions.json#/definitions/supportedNotifications"
+    },
+    "notification": {
+      "$ref": "definitions.json#/definitions/notification"
+    },
+    "driver": {
+      "$ref": "definitions.json#/definitions/driver"
+    },
+    "areas": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "number": {
+            "type": "number"
+          },
+          "name": {
+            "type": "string"
+          },
+          "securityMode": {
+            "type": "string",
+            "enum": ["arming", "disarming", "armed", "disarmed", "alarm"]
+          },
+          "readyToArm": {
+            "type": "boolean"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "zones": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "number": {
+            "type": "number",
+            "minimum": 0
+          },
+          "name": {
+            "type": "string"
+          },
+          "secure": {
+            "type": "boolean"
+          },
+          "bypassed": {
+            "type": "boolean"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "supportedTroubles": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "enum": ["battery", "ac", "phone", "bell", "fire"]
+      }
+    },
+    "troubles": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/properties/supportedTroubles/items"
+      }
+    },
+    "watts": {
+      "$ref": "definitions.json#/definitions/watts"
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "id",
+    "type",
+    "systemData",
+    "areas",
+    "zones",
+    "supportedTroubles",
+    "troubles",
+    "driver"
+  ]
+}