@swan-admin/swan-ai-measurements 1.0.30 → 1.0.32

package/constants.js

@@ -22,6 +22,10 @@ export const API_ENDPOINTS = {
   CUSTOM_CUSTOMER: "/customers/custom",
   MODEL: "/model",
   TRY_ON: "/tryon/scan",
+  TRY_ON_IMAGE_UPLOAD: "/tryon/user-image-urls/upload",
+  TRY_ON_IMAGE_DOWNLOAD: "/tryon/user-image-urls/download",
+  TRY_ON_IMAGE_URLS: "/tryon/user-image-urls",
+  TRY_ON_RESULT_IMAGE_DOWNLOAD: "/tryon/result-image-urls/download",
 };
 
 export const REQUIRED_MESSAGE = "Please verify required parameters";

package/index.js

@@ -3,6 +3,7 @@ import Custom from "./custom.js";
 import FileUpload from "./fileUpload.js";
 import Measurement from "./measurement.js";
 import PoseDetection from "./poseDetection.js";
+import TryOn from "./tryOn.js";
 export default class Swan {
   static accessKey;
   constructor(key) {
@@ -21,4 +22,7 @@ export default class Swan {
   measurement = new Measurement(Swan.accessKey);
 
   poseDetection = new PoseDetection(Swan.accessKey);
+
+  tryOn = new TryOn(Swan.accessKey);
 }
+const a = new Swan(9876543210);

package/measurement.js

@@ -11,13 +11,13 @@ import { checkParameters } from "./utils.js";
 
 export default class Measurement {
   static accessKey;
-  constructor(key) {
-    Measurement.accessKey = key;
-  }
   static tryOnSocketRef = null;
   static measurementSocketRef = null;
   static timerPollingRef = null;
   static timerWaitingRef = null;
+  constructor(key) {
+    Measurement.accessKey = key;
+  }
 
   getMeasurementStatus(scanId) {
     if (!scanId) {
@@ -70,7 +70,7 @@ export default class Measurement {
 
   static getMeasurementsCheck = async (onSuccess, onError, scanId) => {
     try {
-      const res = await getMeasurementStatus(scanId);
+      const res = await this.getMeasurementStatus(scanId);
       if (res?.data && res?.data?.[0]?.isMeasured === true) {
         onSuccess?.(res?.data);
         clearInterval(Measurement.timerPollingRef);
@@ -96,7 +96,7 @@ export default class Measurement {
   static handleTimeOut = (onSuccess, onError) => {
     Measurement.timerWaitingRef = setTimeout(() => {
       Measurement.handlePolling(onSuccess, onError);
-      disconnectSocket();
+      Measurement.disconnectSocket();
     }, 2 * 60000);
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swan-admin/swan-ai-measurements",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "provides ai measurement suggestion",
   "main": "index.js",
   "type": "module",

package/tryOn.js

@@ -0,0 +1,143 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, REQUIRED_MESSAGE } from "./constants";
+import { checkParameters } from "./utils";
+
+class TryOn {
+  static accessKey;
+  static tryOnSocketRef = null;
+  static timerWaitingRef = null;
+  constructor(accessKey) {
+    TryOn.accessKey = accessKey;
+  }
+
+  uploadFile(files, userId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const payload = {
+          userId,
+          userImages: [files?.[0]?.name],
+        };
+        if (files?.[1]) {
+          payload.userImages.push(files?.[1]?.name);
+        }
+        const signedUrlRes = await TryOn.getSignedUrl(payload);
+        for (const file of files) {
+          await TryOn.s3Upload(signedUrlRes?.data?.uploadUrls?.[file.name]?.url, file);
+        }
+        resolve("uploaded successfully!");
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  static getSignedUrl(payload) {
+    return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_IMAGE_UPLOAD}`, payload, {
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  }
+
+  static s3Upload(url, file) {
+    return axios.put(url, file, {
+      headers: {
+        "Content-Type": file.type,
+      },
+    });
+  }
+
+  getUploadedFiles(userId) {
+    return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_IMAGE_DOWNLOAD}?userId=${userId}`);
+  }
+
+  deleteImage(userId, name) {
+    return axios.delete(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_IMAGE_URLS}?userId=${userId}&file=${name}`);
+  }
+
+  static disconnectSocket = () => {
+    TryOn.tryOnSocketRef?.close();
+    clearTimeout(TryOn.timerWaitingRef);
+  };
+
+  static handleTimeOut = ({ onSuccess, onError, shopDomain, userId, productName }) => {
+    TryOn.timerWaitingRef = setTimeout(() => {
+      this.getTryOnResult({ shopDomain, userId, productName });
+      TryOn.disconnectSocket();
+    }, 78000);
+  };
+
+  handleTryOnWebSocket = ({ shopDomain, userId, productName, onError, onSuccess, onClose, onOpen }) => {
+    if (checkParameters(shopDomain, userId, productName) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    TryOn.disconnectSocket();
+    TryOn.tryOnSocketRef = new WebSocket(url);
+    TryOn.tryOnSocketRef.onopen = async () => {
+      onOpen?.();
+      TryOn.handleTimeOut({ onSuccess, onError, shopDomain, userId, productName });
+      try {
+        await this.handleForLatestImage({ shopDomain, userId, productName });
+      } catch (error) {
+        onError?.(error);
+      }
+    };
+    TryOn.tryOnSocketRef.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      if (data?.status === "success") {
+        this.getTryOnResult({ shopDomain, userId, productName });
+      } else {
+        onError?.(data);
+      }
+      clearTimeout(TryOn.tryOnSocketRef);
+    };
+    TryOn.tryOnSocketRef.onclose = () => {
+      onclose?.();
+    };
+    TryOn.tryOnSocketRef.onerror = (event) => {
+      onError?.(event);
+      clearTimeout(TryOn.tryOnSocketRef);
+    };
+  };
+
+  handleForLatestImage = async ({ userId, shopDomain, productName, onError }) => {
+    if (checkParameters(shopDomain, userId, productName) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return new Promise(async (resolve, reject) => {
+      try {
+        const url = `${APP_AUTH_BASE_URL}/tryon/?scan_id=${id}&store_url=${shopDomain}&product_name=${productName}`;
+        const res = await axios.post(url);
+        if (res?.data?.tryOnProcessStatus === "failed") {
+          TryOn.disconnectSocket();
+          reject(res?.data);
+        } else {
+          resolve(res?.data);
+        }
+      } catch (error) {
+        onError?.(error);
+        TryOn.disconnectSocket();
+        reject(error);
+      }
+    });
+  };
+
+  handleGetTryOnResult = async ({ onSuccess, onError, shopDomain, userId, productName }) => {
+    try {
+      const data = await this.getTryOnResult({ shopDomain, userId, productName });
+      onSuccess?.(data?.data);
+    } catch (error) {
+      onError?.(error);
+    }
+  };
+
+  getTryOnResult = async ({ userId, shopDomain, productName }) => {
+    if (checkParameters(shopDomain, userId, productName) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    const url = `${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_RESULT_IMAGE_DOWNLOAD}?scan_id=${userId}&store_url=${shopDomain}&product_name=${productName}`;
+    return axios.post(url);
+  };
+}
+
+export default TryOn;