@kohost/api-client 1.0.0-alpha.4 → 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

@@ -1,6 +1,6 @@
 const Command = require("./Command");
 
-class SetAlarmCommand extends Command {
+class DiscoverUsersCommand extends Command {
   constructor({ id }) {
     super({ id });
   }
@@ -18,4 +18,4 @@ class SetAlarmCommand extends Command {
   }
 }
 
-module.exports = SetAlarmCommand;
+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,10 +6,12 @@ const SetLockCommand = require("./SetLockCommand");
 const SetSceneControllerCommand = require("./SetSceneControllerCommand");
 const SetWindowCoveringCommand = require("./SetWindowCoveringCommand");
 const SetCourtesyCommand = require("./SetCourtesyCommand");
-
 const DiscoverUsersCommand = require("./DiscoverUsersCommand");
-
-const VerifyDocumentCommand = require("./VerifyDocumentCommand");
+const OCRDocumentCommand = require("./OCRDocumentCommand");
+const CheckInReservationCommand = require("./CheckInReservationCommand");
+const SendSMSCommand = require("./SendSMSCommand");
+const DiscoverReservationsCommand = require("./DiscoverReservationsCommand");
+const DiscoverRoomsCommand = require("./DiscoverRoomsCommand");
 
 module.exports = {
   SetAlarmCommand,
@@ -20,6 +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/index.js

@@ -43,14 +43,14 @@ function useCaseMethodFactory(Client) {
         // get parameters from path
         const pathParams = path.match(/:[a-zA-Z0-9]+/g);
 
-        const { data, params, query, headers } = requestData;
+        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]);
           }
         }
 
@@ -85,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
 
@@ -93,13 +93,13 @@ 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.isBrowser = typeof window !== "undefined";
@@ -114,7 +114,7 @@ class KohostApiClient extends EventEmitter {
         headers: {
           "Content-Type": "application/json",
           Accept: "application/json",
-          [defs.tenantHeader]: options.tenantId,
+          [defs.propertyHeader]: options.propertyId,
           ...options.headers,
         },
       });
@@ -143,7 +143,7 @@ class KohostApiClient extends EventEmitter {
   }
 
   get lsTokenKey() {
-    return `${this.options.tenantId}_${defs.authTokenHeader}`;
+    return `${this.options.propertyId}_${defs.authTokenHeader}`;
   }
 
   get authToken() {
@@ -158,6 +158,10 @@ class KohostApiClient extends EventEmitter {
   set authToken(token) {
     this._authToken = token;
   }
+
+  onLoginRequired() {
+    this.emit("LoginRequired");
+  }
 }
 
 useCaseMethodFactory(KohostApiClient);

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;

package/models/index.js

@@ -1,13 +1,11 @@
-const IotGateway = require("./iotGateway");
 const Switch = require("./switch");
 const Alarm = require("./alarm");
 const Dimmer = require("./dimmer");
 const Lock = require("./lock");
-const SceneController = require("./sceneController");
 const Thermostat = require("./thermostat");
 const WindowCovering = require("./windowCovering");
+const Identification = require("./identification");
 const User = require("./user");
-const ACL = require("./acl");
 const Courtesy = require("./courtesy");
 const Camera = require("./camera");
 const MotionSensor = require("./motionSensor");
@@ -18,9 +16,11 @@ const Application = require("./application");
 const Space = require("./space");
 const Ticket = require("./ticket");
 const Scene = require("./scene");
-const Integration = require("./integration");
 const Gateway = require("./gateway");
+const Product = require("./product");
 const DiscoveredDevice = require("./discoveredDevice");
+const Credential = require("./credential");
+const ShortLink = require("./shortLink");
 
 const AdminCustomer = require("./admin/customer");
 const AdminProperty = require("./admin/property");
@@ -31,26 +31,26 @@ module.exports = {
     Property: AdminProperty,
   },
   Gateway,
-  IotGateway,
   Switch,
   Alarm,
   Dimmer,
   Lock,
   Courtesy,
   Camera,
-  SceneController,
   MotionSensor,
   Thermostat,
   WindowCovering,
   MediaSource,
+  Identification,
+  Product,
   User,
-  ACL,
   Room,
-  Application, 
+  Application,
   Space,
   Ticket,
   Scene,
-  Integration,
   DiscoveredDevice,
   Reservation,
+  Credential,
+  ShortLink,
 };

package/models/kohost.js

@@ -54,10 +54,11 @@ class Kohost {
 
   _validate(data) {
     const valid = this.validator(data);
-    if (!valid)
+    if (!valid) {
       throw new ValidationError(`Invalid ${this.constructor.name}`, {
-        cause: this.validator.errors,
-      });
+        cause: this.validator.errors,   
+    });    }
+   
   }
 
   static generateId() {

package/models/product.js

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

package/models/reservation.js

@@ -17,6 +17,53 @@ class Reservation extends Kohost {
   get hasPayment() {
     return this.paymentId?.length > 0;
   }
+
+  range(tz) {
+    const start = new Date(this.checkInDateTime);
+    const end = new Date(this.checkOutDateTime);
+
+    // output Dec 19-23 if same month and year
+    if (
+      start.getMonth() === end.getMonth() &&
+      start.getFullYear() === end.getFullYear()
+    ) {
+      return `${start.toLocaleString("default", {
+        month: "short",
+        timeZone: tz,
+      })} ${start.toLocaleString("default", {
+        timeZone: tz,
+        day: "numeric",
+      })}-${end.toLocaleString("default", {
+        timeZone: tz,
+        day: "numeric",
+      })}`;
+    }
+
+    // output Dec 19 - Jan 2 if different month and year
+    return `${start.toLocaleString("default", {
+      month: "short",
+      timeZone: tz,
+    })} ${start.getDate()} - ${end.toLocaleString("default", {
+      month: "short",
+      timeZone: tz,
+    })} ${end.getDate()}`;
+  }
+
+  checkInTime(tz) {
+    return new Date(this.checkInDateTime).toLocaleString("default", {
+      hour: "numeric",
+      minute: "numeric",
+      timeZone: tz,
+    });
+  }
+
+  checkOutTime(tz) {
+    return new Date(this.checkOutDateTime).toLocaleString("default", {
+      hour: "numeric",
+      minute: "numeric",
+      timeZone: tz,
+    });
+  }
 }
 
 Object.defineProperty(Reservation.prototype, "schema", {