@swan-admin/swan-ai-measurements 1.0.11 → 1.0.13

package/auth.js

@@ -0,0 +1,62 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_AUTH_WEBSOCKET_URL, APP_BASE_URL } from "./constants.js";
+let socketRef;
+
+export const registerUser = ({ email, appVerifyUrl, gender, height, username = "", accessKey }) => {
+  let body = {
+    username,
+    email,
+    appVerifyUrl,
+  };
+  if (gender && height) {
+    body = { ...body, attributes: { gender, height } };
+  }
+  return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.REGISTER_USER}`, body);
+};
+
+export const verifyToken = (token, accessKey) =>
+  axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.VERIFY_USER}`, null, {
+    params: { token },
+  });
+
+export const addUser = ({ scanId, email, name, height, gender, accessKey, offsetMarketingConsent }) =>
+  axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.ADD_USER}`, {
+    scan_id: scanId,
+    email,
+    name,
+    offsetMarketingConsent,
+    attributes: JSON.stringify({ height, gender }),
+  });
+
+export const getUserDetail = (email, accessKey) =>
+  axios.get(`${APP_BASE_URL}${API_ENDPOINTS.GET_USER_DETAIL}/${email}`);
+
+export const handleAuthSocket = ({ email, scanId, accessKey, onError, onSuccess, onClose, onOpen }) => {
+  if (socketRef) {
+    socketRef.close();
+  }
+
+  socketRef = new WebSocket(APP_AUTH_WEBSOCKET_URL);
+  const detailObj = {
+    email,
+    scanId,
+  };
+
+  socketRef.onopen = () => {
+    onOpen();
+    socketRef.send(JSON.stringify(detailObj));
+  };
+
+  socketRef.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    onSuccess(data);
+  };
+
+  socketRef.onclose = () => {
+    onClose();
+  };
+
+  socketRef.current.onerror = (event) => {
+    onError(event);
+  };
+};

package/constants.js

@@ -1,5 +1,10 @@
 export const FILE_UPLOAD_URL = "https://9xc8mxwlkj.execute-api.us-east-1.amazonaws.com/staging";
 export const FILE_UPLOAD_KEY = "7a8ccc86249849be911b0d7dbc20290e";
+export const APP_BASE_URL = "https://fitview-server-staging.ft2a64raup4pg.us-east-1.cs.amazonlightsail.com";
+export const APP_AUTH_BASE_URL = "https://staging.api.getswan.co";
+export const APP_AUTH_WEBSOCKET_URL = "wss://develop.wsnotify.api.getswan.co/auth";
+export const APP_TRY_ON_WEBSOCKET_URL = "wss://bucbzczxjk.execute-api.ap-south-1.amazonaws.com";
+export const APP_RECOMMENDATION_WEBSOCKET_URL = "wss://9cfbimvp2e.execute-api.us-east-1.amazonaws.com/staging";
 
 export const UPPY_FILE_UPLOAD_ENDPOINT = {
   UPLOAD_START: "/upload/start",
@@ -7,3 +12,13 @@ export const UPPY_FILE_UPLOAD_ENDPOINT = {
   UPLOAD_SIGN_PART: "/upload/signpart",
   UPLOAD_ABORT: "/upload/abort",
 };
+
+export const API_ENDPOINTS = {
+  GET_USER_DETAIL: "/api/user",
+  REGISTER_USER: "/auth/register",
+  VERIFY_USER: "/auth/verify",
+  ADD_USER: "/user",
+  CUSTOM_CUSTOMER: "/customers/custom",
+  MODEL: "/model",
+  TRY_ON: "/tryon/scan",
+};

package/custom.js

@@ -0,0 +1,7 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL } from "./constants.js";
+
+export const getCustomCustomerConfig = (store_url, accessKey) =>
+  axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.CUSTOM_CUSTOMER}`, { params: { store_url } });
+
+export const getModelUrl = (id, accessKey) => axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`);

package/fileUpload.js

@@ -0,0 +1,80 @@
+import AwsS3Multipart from "@uppy/aws-s3-multipart";
+import Uppy from "@uppy/core";
+import { FILE_UPLOAD_KEY, UPPY_FILE_UPLOAD_ENDPOINT } from "./constants.js";
+
+function uploadFile({ file, objMetaData, scanId, accessKey }) {
+  return new Promise((resolve, reject) => {
+    uppyIns = new Uppy({ autoProceed: true });
+    uppyIns.use(AwsS3Multipart, {
+      limit: 10,
+      retryDelays: [0, 1000, 3000, 5000],
+      getChunkSize: () => 5 * 1024 * 1024,
+      createMultipartUpload: (file) => {
+        const objectKey = `${scanId}.${file.extension}`;
+        return fetchData({
+          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
+          apiKey: FILE_UPLOAD_KEY,
+          body: {
+            objectKey,
+            contentType: file.type,
+            objectMetadata: objMetaData,
+          },
+        });
+      },
+      completeMultipartUpload: (file, { uploadId, key, parts }) =>
+        fetchData({
+          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
+          apiKey: FILE_UPLOAD_KEY,
+          body: {
+            uploadId,
+            objectKey: key,
+            parts,
+            originalFileName: file.name,
+          },
+        }),
+
+      signPart: (file, partData) =>
+        fetchData({
+          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
+          apiKey: FILE_UPLOAD_KEY,
+          body: {
+            objectKey: partData.key,
+            uploadId: partData.uploadId,
+            partNumber: partData.partNumber,
+          },
+        }),
+
+      abortMultipartUpload: (file, { uploadId, key }) =>
+        fetchData({
+          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
+          apiKey: FILE_UPLOAD_KEY,
+          body: {
+            uploadId,
+            objectKey: key,
+            originalFileName: file.name,
+          },
+        }),
+    });
+
+    uppyIns.addFile({
+      source: "manual",
+      name: file.name,
+      type: file.type,
+      data: file,
+    });
+
+    uppyIns.on("upload-error", (file, error, response) => {
+      reject(error);
+    });
+    uppyIns.on("upload-success", () => {
+      resolve({ message: "file uploaded successfully" });
+    });
+    uppyIns.on("complete", (result) => {
+      if (uppyIns) {
+        uppyIns.close();
+      }
+    });
+  });
+}
+
+export default uploadFile;

package/index.js

@@ -1,87 +1,70 @@
-import Uppy from "@uppy/core";
-import { FILE_UPLOAD_KEY, UPPY_FILE_UPLOAD_ENDPOINT } from "./constants.js";
-import { fetchData } from "./utils.js";
-import AwsS3Multipart from "@uppy/aws-s3-multipart";
+import { addUser, getUserDetail, registerUser, verifyToken } from "./auth.js";
+import { getCustomCustomerConfig } from "./custom.js";
+import uploadFile from "./fileUpload.js";
 export default class Swan {
   constructor(key) {
-    if (key !== FILE_UPLOAD_KEY) {
+    if (key !== 9876543210) {
       throw new Error("wrong access key");
     }
     this.accessKey = key;
-    this.uppyIns = null;
   }
+
+  registerUser({ email, appVerifyUrl, gender, height, username }) {
+    return registerUser({ email, appVerifyUrl, gender, height, username, accessKey: this.accessKey });
+  }
+
+  verifyToken(token) {
+    return verifyToken(token, this.accessKey);
+  }
+
+  addUser({ scanId, email, name, height, gender, offsetMarketingConsent }) {
+    return addUser({ scanId, email, name, height, gender, offsetMarketingConsent, accessKey: this.accessKey });
+  }
+
+  getUserDetail(email) {
+    return getUserDetail(email, this.accessKey);
+  }
+
   uploadFile({ file, objMetaData, scanId }) {
-    return new Promise((resolve, reject) => {
-      this.uppyIns = new Uppy({ autoProceed: true });
-      this.uppyIns.use(AwsS3Multipart, {
-        limit: 10,
-        retryDelays: [0, 1000, 3000, 5000],
-        getChunkSize: () => 5 * 1024 * 1024,
-        createMultipartUpload: (file) => {
-          const objectKey = `${scanId}.${file.extension}`;
-          return fetchData({
-            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
-            apiKey: this.accessKey,
-            body: {
-              objectKey,
-              contentType: file.type,
-              objectMetadata: objMetaData,
-            },
-          });
-        },
-        completeMultipartUpload: (file, { uploadId, key, parts }) =>
-          fetchData({
-            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
-            apiKey: this.accessKey,
-            body: {
-              uploadId,
-              objectKey: key,
-              parts,
-              originalFileName: file.name,
-            },
-          }),
+    return uploadFile({ file, objMetaData, scanId, accessKey: this.accessKey });
+  }
 
-        signPart: (file, partData) =>
-          fetchData({
-            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
-            apiKey: this.accessKey,
-            body: {
-              objectKey: partData.key,
-              uploadId: partData.uploadId,
-              partNumber: partData.partNumber,
-            },
-          }),
+  getModelUrl(id) {
+    return getModelUrl(id, this.accessKey);
+  }
 
-        abortMultipartUpload: (file, { uploadId, key }) =>
-          fetchData({
-            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
-            apiKey: this.accessKey,
-            body: {
-              uploadId,
-              objectKey: key,
-              originalFileName: file.name,
-            },
-          }),
-      });
+  getCustomCustomerConfig(storeUrl) {
+    return getCustomCustomerConfig(storeUrl, this.accessKey);
+  }
 
-      this.uppyIns.addFile({
-        source: "manual",
-        name: file.name,
-        type: file.type,
-        data: file,
-      });
+  getMeasurementStatus(scanId) {
+    return getMeasurementStatus(scanId, this.accessKey);
+  }
+
+  getTryOnMeasurements({ scanId, shopDomain, productName }) {
+    return getTryOnMeasurements({ scanId, shopDomain, productName, accessKey: this.accessKey });
+  }
 
-      this.uppyIns.on("upload-error", (file, error, response) => {
-        reject(error);
-      });
-      this.uppyIns.on("upload-success", () => {
-        resolve({ message: "file uploaded successfully" });
-      });
-      this.uppyIns.on("complete", (result) => {
-        if (this.uppyIns) {
-          this.uppyIns.close();
-        }
-      });
+  handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen }) {
+    return handleTryOnSocket({
+      shopDomain,
+      scanId,
+      productName,
+      accessKey: this.accessKey,
+      onError,
+      onSuccess,
+      onClose,
+      onOpen,
     });
   }
+
+  handleMeasurementSocket({ scanId, onError, onSuccess, onClose, onOpen }) {
+    return handleMeasurementSocket({ scanId, accessKey: this.accessKey, onError, onSuccess, onClose, onOpen });
+  }
+
+  handleAuthSocket({ email, scanId, onError, onSuccess, onClose, onOpen }) {
+    return handleAuthSocket({ email, scanId, accessKey: this.accessKey, onError, onSuccess, onClose, onOpen });
+  }
 }
+
+const a = new Swan(9876543210);

package/measurement.js

@@ -0,0 +1,127 @@
+import axios from "axios";
+import {
+  API_ENDPOINTS,
+  APP_AUTH_BASE_URL,
+  APP_RECOMMENDATION_WEBSOCKET_URL,
+  APP_TRY_ON_WEBSOCKET_URL,
+  FILE_UPLOAD_KEY,
+  FILE_UPLOAD_URL,
+} from "./constants.js";
+
+let tryOnSocketRef;
+let measurementSocketRef;
+let timerPollingRef;
+let timerWaitingRef;
+
+export const getMeasurementStatus = (scanId, accessKey) => {
+  const url = `${FILE_UPLOAD_URL}/measurements?scanId=${scanId}`;
+  return axios.get(url, {
+    headers: { "X-Api-Key": FILE_UPLOAD_KEY },
+  });
+};
+
+export const getTryOnMeasurements = ({ scanId, shopDomain, productName, accessKey }) => {
+  const tryOnUrl = `${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON}/${scanId}/shop/${shopDomain}/product/${productName}`;
+  return axios.get(tryOnUrl);
+};
+
+export const handleTryOnSocket = ({
+  shopDomain,
+  scanId,
+  productName,
+  accessKey,
+  onError,
+  onSuccess,
+  onClose,
+  onOpen,
+}) => {
+  if (tryOnSocketRef) {
+    tryOnSocketRef.close();
+  }
+  const url = `${APP_TRY_ON_WEBSOCKET_URL}/develop?store_url=${shopDomain}&product_name=${productName}&scan_id=${scanId}`;
+  tryOnSocketRef = new WebSocket(url);
+
+  tryOnSocketRef.onopen = () => {
+    onOpen();
+  };
+
+  tryOnSocketRef.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    if (data?.tryOnProcessStatus === "available") {
+      onSuccess(data);
+    } else {
+      onError({ message: "failed to get image urls" });
+    }
+  };
+
+  tryOnSocketRef.onclose = () => {
+    onClose();
+  };
+
+  tryOnSocketRef.onerror = (event) => {
+    onError(event);
+  };
+};
+
+const getMeasurementsCheck = async (onSuccess, onError, scanId, accessKey) => {
+  try {
+    const res = await getMeasurementStatus(scanId, accessKey);
+    if (res?.data && res?.data?.[0]?.isMeasured === true) {
+      onSuccess(res?.data);
+      clearInterval(timerPollingRef);
+    }
+  } catch (e) {
+    clearInterval(timerPollingRef);
+    onError(e);
+  }
+};
+
+const handlePolling = (onSuccess, onError) => {
+  clearInterval(timerPollingRef);
+  timerPollingRef = setInterval(() => {
+    getMeasurementsCheck(onSuccess, onError);
+  }, 5000);
+};
+
+const disconnectSocket = () => {
+  if (measurementSocketRef) {
+    measurementSocketRef.close();
+    clearTimeout(timerWaitingRef);
+  }
+};
+
+const handleTimeOut = (onSuccess, onError) => {
+  timerWaitingRef = setTimeout(() => {
+    handlePolling(onSuccess, onError);
+    disconnectSocket();
+  }, 2 * 60000);
+};
+
+export const handleMeasurementSocket = ({ scanId, accessKey, onError, onSuccess, onClose, onOpen }) => {
+  disconnectSocket();
+  const url = `${APP_RECOMMENDATION_WEBSOCKET_URL}?scanId=${scanId}`;
+  measurementSocketRef = new WebSocket(url);
+
+  measurementSocketRef.onopen = () => {
+    onOpen();
+    handleTimeOut(onSuccess, onError);
+  };
+
+  measurementSocketRef.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    if (data?.code === 200 && data?.scanStatus === "success") {
+      onSuccess(data);
+    } else {
+      onError(data);
+    }
+    clearTimeout(timerWaitingRef);
+  };
+
+  measurementSocketRef.onclose = () => {
+    onClose();
+  };
+
+  measurementSocketRef.current.onerror = (event) => {
+    onError(event);
+  };
+};

package/package.json

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