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

package/models/space.js

@@ -0,0 +1,99 @@
+// 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 cloneDeep = require("lodash.clonedeep"); 
+
+const Room = require("./room");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Space extends Kohost {
+  constructor(data) {
+    const spaceData = mapSpaceData(data);
+    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 hasSceneController() {
+    return this.rooms.some((room) => room.hasSceneController);
+  }
+
+  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);
+  }
+  get occupied() {
+    return this.rooms.some((room) => room.occupied);
+  }
+}
+
+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 = cloneDeep(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/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;

package/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 === "farenheit")
+      this.currentTemperature = ((this.currentTemperature - 32) * 5) / 9;
+    this.temperatureScale = "celsius";
+    return this.currentTemperature;
+  }
+
+  toFarenheit() {
+    if (this.temperatureScale === "celsius")
+      this.currentTemperature = (this.currentTemperature * 9) / 5 + 32;
+    this.temperatureScale = "farenheit";
+    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/models/ticket.js

@@ -0,0 +1,91 @@
+// Create the User Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/ticket.json");
+const Kohost = require("./kohost");
+
+const sortBy = require("lodash.sortby");
+const findLast = require("lodash.findlast");
+
+const { nanoid } = require("nanoid");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Ticket extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  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.user === requester);
+    const firstResponse = sorted.find((entry) => entry.user !== 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.user !== requester;
+    });
+
+    if (!lastFromNonRequester) return null;
+    else return lastFromNonRequester.user;
+  },
+});
+
+module.exports = Ticket;

package/models/user.js

@@ -0,0 +1,58 @@
+// Create the User Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/user.json");
+const idSchema = require("../schemas/identification.json");
+const paymentSchema = require("../schemas/payment.json");
+const Kohost = require("./kohost");
+
+const { nanoid } = require("nanoid/async");
+
+schemas.add(idSchema);
+schemas.add(paymentSchema);
+schemas.add(schema);
+
+const validator = schemas.compile(schema);
+
+class User 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);
+  }
+
+  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}`;
+  },
+});
+
+module.exports = User;

package/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/package.json

@@ -1,15 +1,37 @@
 {
   "dependencies": {
-    "ajv": "^8.11.0"
+    "ajv": "^8.11.0",
+    "ajv-formats": "^2.1.1",
+    "axios": "^1.0.0",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.findlast": "^4.6.0",
+    "lodash.sortby": "^4.7.0",
+    "nanoid": "^3.3.4"
   },
   "name": "@kohost/api-client",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "API client for Kohost utils",
   "main": "index.js",
-  "devDependencies": {},
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "test:watch": "jest --watchAll",
+    "lint": "eslint ./",
+    "lint:fix": "eslint --fix ./",
+    "prepare": "node prepare.js"
   },
   "author": "Ian Rogers",
-  "license": "ISC"
+  "license": "ISC",
+  "devDependencies": {
+    "@kohost/eslint-config": "^1.0.0",
+    "eslint": "^8.6.0",
+    "eslint-plugin-jest": "^27.1.3",
+    "husky": "^8.0.1",
+    "jest": "^29.2.2",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.5.1"
+  },
+  "lint-staged": {
+    "*.js": "eslint --cache --fix",
+    "*.{js,css,md,json}": "prettier --write"
+  }
 }

package/prepare.js

@@ -0,0 +1,4 @@
+const isCi = process.env.CI !== undefined;
+if (!isCi) {
+  require("husky").install();
+}

package/schemas/acl.json

@@ -0,0 +1,111 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://api.kohost.app/schemas/v3/acl.json",
+  "title": "Access Control List Schema",
+  "type": "object",
+  "required": ["id", "name", "resource", "resourceFilter", "permissions"],
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "name": {
+      "type": "string"
+    },
+    "resourceType": {
+      "type": "string",
+      "enum": [
+        "*",
+        "Guest",
+        "Reservation",
+        "User",
+        "Manager",
+        "Admin",
+        "SuperAdmin",
+        "Ticket",
+        "Group",
+        "HotelRoom",
+        "Room",
+        "Notification",
+        "Image",
+        "EnergyReport",
+        "RoomType",
+        "SceneTemplate",
+        "Setting",
+        "Subscription",
+        "Integration",
+        "PMS",
+        "Source",
+        "ACL"
+      ]
+    },
+    "resource": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "resourceFilter": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "resourceType": {
+            "type": "string",
+            "enum": ["SubSystem"]
+          },
+          "resource": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "permissions": {
+            "type": "array",
+            "uniqueItems": true,
+            "items": {
+              "type": "string",
+              "enum": [
+                "*",
+                "read",
+                "write",
+                "delete",
+                "create",
+                "update",
+                "list",
+                "execute"
+              ]
+            }
+          }
+        }
+      }
+    },
+    "permissions": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "enum": [
+          "*",
+          "read",
+          "write",
+          "delete",
+          "create",
+          "update",
+          "list",
+          "execute"
+        ]
+      }
+    },
+    "begins": {
+      "type": ["object", "null"]
+    },
+    "expires": {
+      "type": ["object", "null"]
+    },
+    "global": {
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "definitions": {}
+}

package/schemas/admin/customer.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://api.kohost.app/schemas/v3/admin/customer.json",
+  "title": "Customer",
+  "type": "object",
+  "description": "A Kohost customer",
+  "required": ["accountNumber", "name"],
+  "properties": {
+    "id": {
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/id"
+    },
+    "accountNumber": {
+      "type": "number",
+      "minimum": 10000
+    },
+    "name": {
+      "type": "string"
+    },
+    "properties": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "createdAt": {
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/createdAt"
+    },
+    "updatedAt": {
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/updatedAt"
+    }
+  }
+}

package/schemas/admin/property.json

@@ -0,0 +1,54 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://api.kohost.app/schemas/v3/admin/property.json",
+  "title": "Property",
+  "type": "object",
+  "description": "A property is a physical asset or building",
+  "required": ["id", "name", "type"],
+  "properties": {
+    "id": {
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/id"
+    },
+    "name": {
+      "type": "string"
+    },
+    "type": {
+      "type": "string",
+      "enum": ["hospitality", "education", "commercial"]
+    },
+    "timezone": {
+      "type": "string"
+    },
+    "address": {
+      "type": "object",
+      "properties": {
+        "street": {
+          "type": "string"
+        },
+        "city": {
+          "type": "string"
+        },
+        "state": {
+          "type": "string"
+        },
+        "zip": {
+          "type": "string"
+        },
+        "country": {
+          "type": "string"
+        }
+      }
+    },
+    "latitude": {
+      "type": "number"
+    },
+    "longitude": {
+      "type": "number"
+    },
+    "credentials": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "additionalProperties": false
+  }
+}

package/schemas/alarm.json

@@ -6,19 +6,19 @@
   "type": "object",
   "properties": {
     "id": {
-      "$ref": "https://api.kohost.app/schemas/v3/device.json#/definitions/id"
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/device.json#/definitions/id"
     },
     "type": {
-      "$ref": "https://api.kohost.app/schemas/v3/device.json#/definitions/type"
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/device.json#/definitions/type"
     },
     "systemData": {
-      "$ref": "https://api.kohost.app/schemas/v3/device.json#/definitions/systemData"
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/device.json#/definitions/systemData"
     },
     "supportedNotifications": {
-      "$ref": "https://api.kohost.app/schemas/v3/device.json#/definitions/supportedNotifications"
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/device.json#/definitions/supportedNotifications"
     },
     "notification": {
-      "$ref": "https://api.kohost.app/schemas/v3/device.json#/definitions/notification"
+      "$ref": "https://api.kohost.app/schemas/v3/definitions/device.json#/definitions/notification"
     },
     "areas": {
       "type": "array",