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

package/events/SystemSwitchUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemSwitchUpdatedEvent extends Event {
+  constructor(_switch) {
+    super(_switch);
+  }
+
+  get name() {
+    return "SystemSwitchUpdated";
+  }
+
+  get routingKey() {
+    return `switch.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemSwitchUpdatedEvent;

package/events/SystemThermostatUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemThermostatUpdatedEvent extends Event {
+  constructor(thermostat) {
+    super(thermostat);
+  }
+
+  get name() {
+    return "SystemThermostatUpdated";
+  }
+
+  get routingKey() {
+    return `thermostat.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemThermostatUpdatedEvent;

package/events/SystemUserUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemUserUpdatedEvent extends Event {
+  constructor(thermostat) {
+    super(thermostat);
+  }
+
+  get name() {
+    return "SystemUserUpdated";
+  }
+
+  get routingKey() {
+    return `user.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemUserUpdatedEvent;

package/events/SystemWindowCoveringUpdatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SystemWindowCoveringUpdatedEvent extends Event {
+  constructor(wc) {
+    super(wc);
+  }
+
+  get name() {
+    return "SystemWindowCoveringUpdated";
+  }
+
+  get routingKey() {
+    return `windowCovering.${this.data.id}.updated`;
+  }
+}
+
+module.exports = SystemWindowCoveringUpdatedEvent;

package/events/index.js

@@ -0,0 +1,28 @@
+const SystemThermostatUpdatedEvent = require("./SystemThermostatUpdatedEvent");
+const SystemDimmerUpdatedEvent = require("./SystemDimmerUpdatedEvent");
+const SystemSwitchUpdatedEvent = require("./SystemSwitchUpdatedEvent");
+const SystemLockUpdatedEvent = require("./SystemLockUpdatedEvent");
+const SystemCameraUpdatedEvent = require("./SystemCameraUpdatedEvent");
+const SystemSceneControllerUpdatedEvent = require("./SystemSceneControllerUpdatedEvent");
+const SystemWindowCoveringUpdatedEvent = require("./SystemWindowCoveringUpdatedEvent");
+const SystemSourceUpdatedEvent = require("./SystemSourceUpdatedEvent");
+const SystemCourtesyUpdatedEvent = require("./SystemCourtesyUpdatedEvent");
+
+const SystemUserUpdatedEvent = require("./SystemUserUpdatedEvent");
+const SystemSpaceUpdatedEvent = require("./SystemSpaceUpdatedEvent");
+const SystemReservationUpdatedEvent = require("./SystemReservationUpdatedEvent");
+
+module.exports = {
+  SystemThermostatUpdatedEvent,
+  SystemDimmerUpdatedEvent,
+  SystemSwitchUpdatedEvent,
+  SystemLockUpdatedEvent,
+  SystemCameraUpdatedEvent,
+  SystemSceneControllerUpdatedEvent,
+  SystemWindowCoveringUpdatedEvent,
+  SystemSourceUpdatedEvent,
+  SystemCourtesyUpdatedEvent,
+  SystemUserUpdatedEvent,
+  SystemSpaceUpdatedEvent,
+  SystemReservationUpdatedEvent,
+};

package/http/handleResponseError.js

@@ -0,0 +1,53 @@
+const defs = require("../defs").http;
+
+module.exports = function handleResponseError(error) {
+  const { config: originalReq } = error;
+  if (!error.response) return Promise.reject(error);
+  const { status, data } = error.response;
+  const errorCode = data && data.error && data.error.code;
+  const errorMessage = data && data.error && data.error.message;
+
+  try {
+    const expectedError = status >= 400 && status < 500;
+
+    if (errorMessage && errorMessage === "Login Required") {
+      this.onLoginRequired();
+      return Promise.reject(error);
+    }
+
+    // prettier-ignore
+    const newTokensNeeded = expectedError && errorCode === 1004 && status === 401;
+
+    if (status === 401 && !newTokensNeeded) {
+      return Promise.reject(error);
+    }
+    if (status === 400 && errorCode === 1010) {
+      this.onLoginRequired();
+      return Promise.reject(error);
+    }
+
+    if (newTokensNeeded) {
+      return this.RefreshToken({
+        headers: {
+          [defs.refreshTokenHeader]: this.refreshToken,
+        },
+      }).then((response) => {
+        // update headers with the new tokens
+        if (
+          response &&
+          response.headers &&
+          response.headers[this.authTokenHeaderKey]
+        ) {
+          const newToken = response.headers[this.authTokenHeaderKey];
+          originalReq.headers[defs.authTokenHeader] = newToken;
+          this.authToken = newToken;
+          return this.http(originalReq);
+        }
+      });
+    }
+  } catch (error) {
+    console.log(error);
+  }
+
+  return Promise.reject(error);
+};

package/http/handleResponseSuccess.js

@@ -0,0 +1,15 @@
+module.exports = function handleResponseSuccess(response) {
+  if (response?.data?.data) {
+    response.query = response.data.query;
+    response.pagination = response.data.pagination;
+    response.data = response.data.data;
+  }
+  if (response.headers[this.authTokenHeaderKey]) {
+    this.authToken = response.headers[this.authTokenHeaderKey];
+  }
+
+  if (response.headers[this.refreshTokenHeaderKey]) {
+    this.refreshToken = response.headers[this.refreshTokenHeaderKey];
+  }
+  return response;
+};

package/http/index.js

@@ -0,0 +1,159 @@
+const { EventEmitter } = require("events");
+const axios = require("axios");
+const defs = require("../defs").http;
+const handleResponseError = require("./handleResponseError");
+const handleResponseSuccess = require("./handleResponseSuccess");
+
+const useCases = require("../useCases/http.json");
+
+/*
+Creates methods for each use case in the API
+
+@param {Object} Client - The client class
+@returns undefined
+*/
+
+function useCaseMethodFactory(Client) {
+  const map = new Map(useCases);
+  for (const [useCase, data] of map.entries()) {
+    if (data.http) {
+      const { method, path } = data.http;
+
+      /* 
+        Creates a method for each use case in the API
+        @param {Object} options - The options to send to the API
+        @param {Object} options.headers - The headers to send to the API
+        @param {Object} options.params - The params for the reuquest to build the URL
+        @param {Object} options.data - The body to send to the API. Valid for POST and PUT requests
+        @parms {Object} options.query - The query for the request to build the URL
+        @returns {Promise} The response from the API
+      */
+
+      //eslint-disable-next-line no-inner-declarations
+      function UseCase(options) {
+        if (!options) options = {};
+
+        // get parameters from path
+        const pathParams = path.match(/:[a-zA-Z0-9]+/g);
+
+        const { data, params, query, headers } = options;
+
+        // replace path parameters with values from params
+        let url = path;
+        if (pathParams && params) {
+          for (const param of pathParams) {
+            const paramName = param.replace(":", "");
+            url = url.replace(param, params[paramName]);
+          }
+        }
+
+        // make sure all parameters have been replaced
+        if (url.match(/:[a-zA-Z0-9]+/g)) {
+          const missingParams = url.match(/:[a-zA-Z0-9]+/g);
+          // remove the colon from the parameter name
+          const missing = missingParams.map((param) => param.replace(":", ""));
+          return Promise.reject(
+            new Error(`Missing parameters: ${missing.join(", ")}`)
+          );
+        }
+
+        const config = {
+          method: method.toLowerCase(),
+          url: url,
+        };
+
+        if (data) config.data = data;
+        if (query) config.params = query;
+        if (headers) config.headers = headers;
+
+        return this._http.request(config);
+      }
+
+      Client.prototype[useCase] = UseCase;
+    }
+  }
+}
+
+class KohostApiClient extends EventEmitter {
+  /* 
+  @param {Object} options - The options to create the client
+  @param {String} options.tenantId - The tenant ID
+  @param {String} options.url - The base URL for the API endpint
+  @param {Object} options.headers - Additional headers to send with each request
+
+  */
+  constructor(
+    options = {
+      url: "",
+      tenantId: "",
+      headers: {},
+    }
+  ) {
+    super();
+    if (!options.url) throw new Error("options.url is required");
+    if (!options.tenantId) throw new Error("options.tenant is required");
+    this.options = options;
+    // eslint-disable-next-line no-undef
+    this.isBrower = typeof window !== "undefined";
+    this._http = axios.create({
+      baseURL: options.url,
+      responseType: "json",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        [defs.tenantHeader]: options.tenantId,
+        ...options.headers,
+      },
+    });
+
+    this._http.interceptors.response.use(
+      handleResponseSuccess.bind(this),
+      handleResponseError.bind(this)
+    );
+
+    this._http.interceptors.request.use((config) => {
+      config.headers[defs.authTokenHeader] = this.authToken;
+      return config;
+    });
+  }
+
+  get authTokenHeaderKey() {
+    return defs.authTokenHeader.toLowerCase();
+  }
+
+  get refreshTokenHeaderKey() {
+    return defs.refreshTokenHeader.toLowerCase();
+  }
+
+  get lsTokenKey() {
+    return `${this.options.tenantId}_${defs.authTokenHeader}`;
+  }
+
+  get authToken() {
+    if (this.isBrower) {
+      // get token from localStorage
+      // eslint-disable-next-line no-undef
+      return window.localStorage.getItem(this.lsTokenKey);
+    } else {
+      return this._authToken;
+    }
+  }
+
+  /* 
+  @param {String} token - The token to set
+  @returns undefined
+  */
+
+  set authToken(token) {
+    if (this.isBrower) {
+      // eslint-disable-next-line no-undef
+      window.localStorage.setItem(this.lsTokenKey, token);
+    } else {
+      this._authToken = token;
+    }
+  }
+}
+
+useCaseMethodFactory(KohostApiClient);
+
+module.exports = KohostApiClient;

package/index.js

@@ -1,73 +1,23 @@
-const Ajv = require("ajv");
-const ajv = new Ajv({ allErrors: true });
-
-const deviceSchema = require("./schemas/device.json");
-const switchSchema = require("./schemas/switch.json");
-const alarmSchema = require("./schemas/alarm.json");
-const dimmerSchema = require("./schemas/dimmer.json");
-const gatewaySchema = require("./schemas/gateway.json");
-const lockSchema = require("./schemas/lock.json");
-const sceneControllerSchema = require("./schemas/sceneController.json");
-const thermostatSchema = require("./schemas/thermostat.json");
-const windowCoveringSchema = require("./schemas/windowCovering.json");
-
-ajv.addSchema(deviceSchema);
-
-// compile all schemas
-const Switch = createClass(ajv.compile(switchSchema), "Switch");
-const Alarm = createClass(ajv.compile(alarmSchema), "Alarm");
-const Dimmer = createClass(ajv.compile(dimmerSchema), "Dimmer");
-const Gateway = createClass(ajv.compile(gatewaySchema), "Gateway");
-const Lock = createClass(ajv.compile(lockSchema), "Lock");
-const SceneController = createClass(
-  ajv.compile(sceneControllerSchema),
-  "SceneController"
-);
-const Thermostat = createClass(ajv.compile(thermostatSchema), "Thermostat");
-const WindowCovering = createClass(
-  ajv.compile(windowCoveringSchema),
-  "WindowCovering"
-);
-
-function createClass(validator, name) {
-  class Generic {
-    constructor(data) {
-      // apply schema properties to the class
-      //this._validator = validator;
-      this.validate(data);
-      Object.keys(validator.schema.properties).forEach((key) => {
-        if (data[key] !== undefined) this[key] = data[key];
-      });
-    }
-
-    validate(data) {
-      const valid = this._validator(data);
-      if (!valid)
-        throw new Error(`Invalid ${name}`, { cause: this._validator.errors });
-    }
-  }
-
-  // change the name of the class
-  Object.defineProperty(Generic, "name", { value: name });
-  Generic.prototype._validator = validator;
-  return Generic;
-}
-
-// Thermostat.prototype.toCelsius = function () {
-//   if (this.temperatureScale === "farenheit")
-//     this.currentTemperature = ((this.currentTemperature - 32) * 5) / 9;
-// };
-
-// export all classes on the Models object
-module.exports = {
-  Models: {
-    Switch,
-    Alarm,
-    Dimmer,
-    Gateway,
-    Lock,
-    SceneController,
-    Thermostat,
-    WindowCovering,
+const Models = require("./models");
+const Errors = require("./errors");
+const Commands = require("./commands");
+const Events = require("./events");
+const HttpClient = require("./http");
+const defs = require("./defs");
+const getFormalDeviceType = require("./utils/getFormalDeviceType");
+const getDeviceTypes = require("./utils/getDeviceTypes");
+
+const Kohost = {
+  Models,
+  Errors,
+  Commands,
+  Events,
+  defs,
+  Client: HttpClient,
+  utils: {
+    getFormalDeviceType,
+    getDeviceTypes,
   },
 };
+
+module.exports = Kohost;

package/models/acl.js

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

package/models/admin/customer.js

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

package/models/admin/property.js

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

package/models/alarm.js

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

package/models/application.js

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

package/models/camera.js

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

package/models/courtesy.js

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

package/models/dimmer.js

@@ -0,0 +1,49 @@
+// Create the Dimmer Model
+const schemas = require("../utils/schema");
+const schema = require("../schemas/dimmer.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Dimmer extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  static getActionDelta(old, _new) {
+    const delta = {};
+    for (const action in _new) {
+      if (this.actionProperties?.includes(action)) {
+        if (action === "level") {
+          const oldLevel = old[action];
+          const newLevel = _new[action];
+          delta[action] = newLevel - oldLevel / 100;
+        } else {
+          delta[action] = 1;
+        }
+      }
+    }
+    return delta;
+  }
+}
+
+Object.defineProperty(Dimmer.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Dimmer.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Dimmer, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+Object.defineProperty(Dimmer, "actionProperties", {
+  value: ["level"],
+});
+
+module.exports = Dimmer;