@kohost/api-client 1.0.0-alpha.3 → 1.0.0-beta.0

package/commands/CheckInReservationCommand.js

@@ -0,0 +1,23 @@
+const Command = require("./Command");
+const RequestError = require("../errors/RequestError");
+
+class CheckInReservationCommand extends Command {
+  constructor({ id }) {
+    if (!id) throw new RequestError("document type is required");
+    super({ id });
+  }
+
+  get name() {
+    return "CheckInReservation";
+  }
+
+  get routingKey() {
+    return `reservation.${this.data.id}.checkin`;
+  }
+
+  get replyTo() {
+    return "system.response.reservations";
+  }
+}
+
+module.exports = CheckInReservationCommand;

package/commands/DiscoverReservationsCommand.js

@@ -0,0 +1,24 @@
+const { RequestError } = require("../errors");
+const Command = require("./Command");
+
+class DiscoverReservationsCommand extends Command {
+  constructor(options) {
+    if (!options) throw new RequestError("options are required");
+    const { id, startDate, endDate, status } = options;
+    super({ id, startDate, endDate, status });
+  }
+
+  get name() {
+    return "DiscoverReservations";
+  }
+
+  get routingKey() {
+    return "reservation.discover";
+  }
+
+  get replyTo() {
+    return "system.response.reservations";
+  }
+}
+
+module.exports = DiscoverReservationsCommand;

package/commands/DiscoverRoomsCommand.js

@@ -0,0 +1,21 @@
+const Command = require("./Command");
+
+class DiscoverRoomsCommand extends Command {
+  constructor({ id }) {
+    super({ id });
+  }
+
+  get name() {
+    return "DiscoverRooms";
+  }
+
+  get routingKey() {
+    return `rooms.${this.data.id}.get`;
+  }
+
+  get replyTo() {
+    return "system.response.users";
+  }
+}
+
+module.exports = DiscoverRoomsCommand;

package/commands/DiscoverUsersCommand.js

@@ -0,0 +1,21 @@
+const Command = require("./Command");
+
+class DiscoverUsersCommand extends Command {
+  constructor({ id }) {
+    super({ id });
+  }
+
+  get name() {
+    return "DiscoverUsers";
+  }
+
+  get routingKey() {
+    return `users.${this.data.id}.get`;
+  }
+
+  get replyTo() {
+    return "system.response.users";
+  }
+}
+
+module.exports = DiscoverUsersCommand;

package/commands/{VerifyDocumentCommand.js → OCRDocumentCommand.js}

@@ -1,7 +1,7 @@
 const Command = require("./Command");
 const RequestError = require("../errors/RequestError");
 
-class VerifyDocumentCommand extends Command {
+class OCRDocumentCommand extends Command {
   constructor({ type, image }) {
     if (!type) throw new RequestError("document type is required");
     if (!image) throw new RequestError("document image is required");
@@ -9,16 +9,12 @@ class VerifyDocumentCommand extends Command {
   }
 
   get name() {
-    return "VerifyDocument";
+    return "OCRDocument";
   }
 
   get routingKey() {
-    return `document.${this.data.type}.verify`;
-  }
-
-  get replyTo() {
-    return "system.response.documents";
+    return `document.${this.data.type}.ocr`;
   }
 }
 
-module.exports = VerifyDocumentCommand;
+module.exports = OCRDocumentCommand;

package/commands/SendEmailCommand.js

@@ -0,0 +1,24 @@
+const Command = require("./Command");
+const RequestError = require("../errors/RequestError");
+
+class SendEmailCommand extends Command {
+  constructor({ text, html, to, from, subject, eventData }) {
+    if (!to) throw new RequestError("email to is required");
+    if (!from) throw new RequestError("email from is required");
+    if (!subject) throw new RequestError("email subject is required");
+    if (!text && !html)
+      throw new RequestError("email text or html is required");
+
+    super({ text, html, to, from, subject, eventData });
+  }
+
+  get name() {
+    return "SendEmail";
+  }
+
+  get routingKey() {
+    return "comm.email.send";
+  }
+}
+
+module.exports = SendEmailCommand;

package/commands/SendSMSCommand.js

@@ -0,0 +1,21 @@
+const Command = require("./Command");
+const RequestError = require("../errors/RequestError");
+
+class SendSMSCommand extends Command {
+  constructor({ body, to, from, metaData }) {
+    if (!body) throw new RequestError("sms body is required");
+    if (!to) throw new RequestError("sms to is required");
+    if (!from) throw new RequestError("sms from is required");
+    super({ body, to, from, metaData });
+  }
+
+  get name() {
+    return "SendSMS";
+  }
+
+  get routingKey() {
+    return "comm.sms.send";
+  }
+}
+
+module.exports = SendSMSCommand;

package/commands/index.js

@@ -6,7 +6,12 @@ const SetLockCommand = require("./SetLockCommand");
 const SetSceneControllerCommand = require("./SetSceneControllerCommand");
 const SetWindowCoveringCommand = require("./SetWindowCoveringCommand");
 const SetCourtesyCommand = require("./SetCourtesyCommand");
-const VerifyDocumentCommand = require("./VerifyDocumentCommand");
+const DiscoverUsersCommand = require("./DiscoverUsersCommand");
+const OCRDocumentCommand = require("./OCRDocumentCommand");
+const CheckInReservationCommand = require("./CheckInReservationCommand");
+const SendSMSCommand = require("./SendSMSCommand");
+const DiscoverReservationsCommand = require("./DiscoverReservationsCommand");
+const DiscoverRoomsCommand = require("./DiscoverRoomsCommand");
 
 module.exports = {
   SetAlarmCommand,
@@ -17,5 +22,10 @@ module.exports = {
   SetSceneControllerCommand,
   SetWindowCoveringCommand,
   SetCourtesyCommand,
-  VerifyDocumentCommand,
+  OCRDocumentCommand,
+  DiscoverUsersCommand,
+  CheckInReservationCommand,
+  SendSMSCommand,
+  DiscoverReservationsCommand,
+  DiscoverRoomsCommand,
 };

package/defs/http.js

@@ -1,7 +1,7 @@
 const http = {
   authTokenHeader: "X-Auth-Token",
   refreshTokenHeader: "X-Refresh-Token",
-  tenantHeader: "X-Tenant-Id",
+  propertyHeader: "X-Property-Id",
 };
 
 module.exports = http;

package/events/EmailSentEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class EmailSentEvent extends Event {
+  constructor(email, context) {
+    super(email, context);
+  }
+
+  get name() {
+    return "EmailSent";
+  }
+
+  get routingKey() {
+    return "comm.email.sent";
+  }
+}
+
+module.exports = EmailSentEvent;

package/events/Event.js

@@ -1,13 +1,32 @@
 class Event {
-  constructor(data) {
+  constructor(data, context) {
     this.data = {};
+    this.context = {};
     if (!data) throw new Error("Event data is required");
     if (typeof data !== "object")
       throw new Error("Event data must be an object");
 
+    if (!data.name) this.data.name = this.name;
+    if (!data.type) this.data.type = this.type;
+
     for (const key in data) {
       this.data[key] = data[key];
     }
+
+    if (data.eventData) {
+      for (const key in data.eventData) {
+        this.data[key] = data.eventData[key];
+      }
+      delete this.data.eventData;
+    }
+
+    if (context) {
+      for (const key in context) {
+        this.context[key] = context[key];
+      }
+    }
+
+    if (!this.data.timestamp) this.data.timestamp = new Date();
   }
   get name() {
     throw new Error("Event name is required");

package/events/SMSSentEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class SMSSentEvent extends Event {
+  constructor(email, context) {
+    super(email, context);
+  }
+
+  get name() {
+    return "SMSSent";
+  }
+
+  get routingKey() {
+    return "comm.sms.sent";
+  }
+}
+
+module.exports = SMSSentEvent;

package/events/ShortLinkCreatedEvent.js

@@ -0,0 +1,17 @@
+const Event = require("./Event");
+
+class ShortLinkCreatedEvent extends Event {
+  constructor(shortLink, context) {
+    super(shortLink, context);
+  }
+
+  get name() {
+    return "ShortLinkCreated";
+  }
+
+  get routingKey() {
+    return `shortlink.${this.data.id}.created`;
+  }
+}
+
+module.exports = ShortLinkCreatedEvent;

package/events/index.js

@@ -12,6 +12,10 @@ const SystemUserUpdatedEvent = require("./SystemUserUpdatedEvent");
 const SystemSpaceUpdatedEvent = require("./SystemSpaceUpdatedEvent");
 const SystemReservationUpdatedEvent = require("./SystemReservationUpdatedEvent");
 
+const SMSSentEvent = require("./SMSSentEvent");
+const EmailSentEvent = require("./EmailSentEvent");
+const ShortLinkCreatedEvent = require("./ShortLinkCreatedEvent");
+
 module.exports = {
   SystemThermostatUpdatedEvent,
   SystemDimmerUpdatedEvent,
@@ -25,4 +29,7 @@ module.exports = {
   SystemUserUpdatedEvent,
   SystemSpaceUpdatedEvent,
   SystemReservationUpdatedEvent,
+  SMSSentEvent,
+  EmailSentEvent,
+  ShortLinkCreatedEvent,
 };

package/http/handleResponseError.js

@@ -1,48 +1,28 @@
-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;
+  const errorType = data?.error?.type;
+  const errorMessage = data?.error?.message;
 
   try {
     const expectedError = status >= 400 && status < 500;
+    const newTokensNeeded = expectedError && errorType === "TokenExpiredError";
 
-    if (errorMessage && errorMessage === "Login Required") {
+    if (expectedError && 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) {
+    if (expectedError && errorMessage === "No token provided") {
       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);
-        }
+    if (expectedError && newTokensNeeded) {
+      return this.RefreshToken().then(() => {
+        // retry the original request with the new token
+        return this.http(originalReq);
       });
     }
   } catch (error) {

package/http/handleResponseSuccess.js

@@ -4,11 +4,11 @@ module.exports = function handleResponseSuccess(response) {
     response.pagination = response.data.pagination;
     response.data = response.data.data;
   }
-  if (response.headers[this.authTokenHeaderKey]) {
+  if (!this.isBrowser && response.headers[this.authTokenHeaderKey]) {
     this.authToken = response.headers[this.authTokenHeaderKey];
   }
 
-  if (response.headers[this.refreshTokenHeaderKey]) {
+  if (!this.isBrowser && response.headers[this.refreshTokenHeaderKey]) {
     this.refreshToken = response.headers[this.refreshTokenHeaderKey];
   }
   return response;

package/http/index.js

@@ -1,5 +1,4 @@
 const { EventEmitter } = require("events");
-const axios = require("axios");
 const defs = require("../defs").http;
 const handleResponseError = require("./handleResponseError");
 const handleResponseSuccess = require("./handleResponseSuccess");
@@ -30,20 +29,28 @@ function useCaseMethodFactory(Client) {
       */
 
       //eslint-disable-next-line no-inner-declarations
-      function UseCase(options) {
-        if (!options) options = {};
+      function UseCase(requestData, options = {}) {
+        if (!this._init) {
+          // wait a second for the client to initialize
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              resolve(UseCase.call(this, requestData));
+            }, 500);
+          });
+        }
+        if (!requestData) requestData = {};
 
         // get parameters from path
         const pathParams = path.match(/:[a-zA-Z0-9]+/g);
 
-        const { data, params, query, headers } = options;
+        const { data, query, headers } = requestData;
 
         // replace path parameters with values from params
         let url = path;
-        if (pathParams && params) {
+        if (pathParams && data) {
           for (const param of pathParams) {
             const paramName = param.replace(":", "");
-            url = url.replace(param, params[paramName]);
+            url = url.replace(param, data[paramName]);
           }
         }
 
@@ -60,6 +67,7 @@ function useCaseMethodFactory(Client) {
         const config = {
           method: method.toLowerCase(),
           url: url,
+          ...options,
         };
 
         if (data) config.data = data;
@@ -77,7 +85,7 @@ function useCaseMethodFactory(Client) {
 class KohostApiClient extends EventEmitter {
   /* 
   @param {Object} options - The options to create the client
-  @param {String} options.tenantId - The tenant ID
+  @param {String} options.propertyId - The property ID
   @param {String} options.url - The base URL for the API endpint
   @param {Object} options.headers - Additional headers to send with each request
 
@@ -85,35 +93,44 @@ class KohostApiClient extends EventEmitter {
   constructor(
     options = {
       url: "",
-      tenantId: "",
+      propertyId: "",
       headers: {},
     }
   ) {
     super();
     if (!options.url) throw new Error("options.url is required");
-    if (!options.tenantId) throw new Error("options.tenant is required");
+    if (!options.propertyId) throw new Error("options.property 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;
+    this.isBrowser = typeof window !== "undefined";
+    this._init = false;
+
+    import("axios").then((axiosModule) => {
+      const axios = axiosModule.default;
+      this._http = axios.create({
+        baseURL: options.url,
+        responseType: "json",
+        withCredentials: true,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          [defs.propertyHeader]: options.propertyId,
+          ...options.headers,
+        },
+      });
+
+      this._http.interceptors.response.use(
+        handleResponseSuccess.bind(this),
+        handleResponseError.bind(this)
+      );
+
+      this._http.interceptors.request.use((config) => {
+        if (!this.isBrowser) {
+          config.headers[defs.authTokenHeader] = this.authToken;
+        }
+        return config;
+      });
+      this._init = true;
     });
   }
 
@@ -126,17 +143,11 @@ class KohostApiClient extends EventEmitter {
   }
 
   get lsTokenKey() {
-    return `${this.options.tenantId}_${defs.authTokenHeader}`;
+    return `${this.options.propertyId}_${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;
-    }
+    return this._authToken;
   }
 
   /* 
@@ -145,12 +156,11 @@ class KohostApiClient extends EventEmitter {
   */
 
   set authToken(token) {
-    if (this.isBrower) {
-      // eslint-disable-next-line no-undef
-      window.localStorage.setItem(this.lsTokenKey, token);
-    } else {
-      this._authToken = token;
-    }
+    this._authToken = token;
+  }
+
+  onLoginRequired() {
+    this.emit("LoginRequired");
   }
 }
 

package/index.js

@@ -15,8 +15,8 @@ const Kohost = {
   defs,
   Client: HttpClient,
   utils: {
-    getFormalDeviceType,
-    getDeviceTypes,
+    getFormalDeviceType: getFormalDeviceType,
+    getDeviceTypes: getDeviceTypes,
   },
 };
 

package/models/credential.js

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

package/models/gateway.js

@@ -6,18 +6,10 @@ 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", {

package/models/identification.js

@@ -0,0 +1,32 @@
+const schemas = require("../utils/schema");
+const schema = require("../schemas/identification.json");
+const Kohost = require("./kohost");
+
+schemas.add(schema);
+const validator = schemas.compile(schema);
+
+class Identification extends Kohost {
+  constructor(data) {
+    super(data);
+  }
+
+  get isExpired() {
+    return new Date(this.expirationDate) < new Date();
+  }
+}
+
+Object.defineProperty(Identification.prototype, "schema", {
+  value: schema,
+});
+
+Object.defineProperty(Identification.prototype, "validator", {
+  get: function () {
+    return validator;
+  },
+});
+
+Object.defineProperty(Identification, "validProperties", {
+  value: Object.keys(schema.properties),
+});
+
+module.exports = Identification;