first commit

app/src/services/dashboard/addedProject.ts

@@ -0,0 +1 @@
+ 

app/src/services/dashboard/createProject.ts

@@ -0,0 +1,30 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+
+export const createProject = async (projectUuid: string, userId: string, thumbnail: string, organization: string) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/NewProject`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ projectUuid, userId, thumbnail, organization, }),
+    });
+    if (!response.ok) {
+      throw new Error("Failed to add project");
+    }
+
+    const result = await response.json();
+    
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/deleteProject.ts

@@ -0,0 +1,39 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deleteProject = async (
+  projectId: string,
+  userId: string,
+  organization: string
+) => {
+  try {
+    console.log("projectId", userId, organization, projectId);
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Projects/Archive/${projectId}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ userId, organization }),
+      }
+    );
+    console.log("response: ", response);
+    if (!response.ok) {
+      throw new Error("Failed to clearPanel in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to clean pannel");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/deleteTrash.ts

@@ -0,0 +1,30 @@
+const url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// const url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deleteTrash = async (organization: string, projectId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Trash/Delete?projectId=${projectId}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+    console.log("restore: ", response);
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch trash data");
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error("Failed to fetch trash data:", error);
+    throw new Error(error.message || "Unknown error");
+  }
+};

app/src/services/dashboard/duplicateProject.ts

@@ -0,0 +1,38 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const duplicateProject = async (
+  projectUuid: string,
+  thumbnail: string,
+  projectName: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/project/Duplicate`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ projectUuid, thumbnail, projectName }),
+      }
+    );
+
+    console.log("response: ", response);
+    if (!response.ok) {
+      throw new Error("Failed to add project");
+    }
+
+    const result = await response.json();
+    console.log("result: ", result);
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/getAllProjects.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+ 
+export const getAllProjects = async (userId: string, organization: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Projects`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch assets");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to get asset image");
+    throw new Error(error.message);
+  }
+};

app/src/services/dashboard/getTrash.ts

@@ -0,0 +1,30 @@
+const url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// const url_Backend_dwinzo = `http://192.168.0.102:5000`;
+ 
+export const getTrash = async (organization: string) => {
+
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/TrashItems`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch trash data");
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error: any) {
+    console.error("Failed to fetch trash data:", error);
+    throw new Error(error.message || "Unknown error");
+  }
+};

app/src/services/dashboard/projectTutorial.ts

@@ -0,0 +1,28 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const projectTutorial = async () => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/tutorials`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    // console.log("response: ", response);
+
+    if (!response.ok) {
+      throw new Error("Failed to add project");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};
+ 

app/src/services/dashboard/recentlyViewed.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const recentlyViewed = async (organization: string, userId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/RecentlyViewed`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch project");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    console.error("Failed to get project");
+    throw new Error(error.message);
+  }
+};

app/src/services/dashboard/restoreTrash.ts

@@ -0,0 +1,30 @@
+const url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// const url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const restoreTrash = async (organization: string, projectId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Trash/restore?projectId=${projectId}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch trash data");
+    }
+
+    const data = await response.json();
+    console.log("restore: ", response);
+    return data;
+  } catch (error: any) {
+    console.error("Failed to fetch trash data:", error);
+    throw new Error(error.message || "Unknown error");
+  }
+};

app/src/services/dashboard/searchProjects.ts

@@ -0,0 +1,38 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const searchProject = async (
+  organization: string,
+  userId: string,
+  searchName: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/search/searchProjects?searchName=${searchName}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    console.log("response: ", response);
+    if (!response.ok) {
+      throw new Error("Failed to Search project");
+    }
+
+    const result = await response.json();
+    console.log("searchProjects: ", result);
+
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/trashSearchProject.ts

@@ -0,0 +1,36 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const trashSearchProject = async (
+  organization: string,
+  userId: string,
+  searchName: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/search/searchTrashProjects?searchName=${searchName}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to add project");
+    }
+
+    const result = await response.json();
+    console.log("searchTrashProjects: ", result);
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/updateProject.ts

@@ -0,0 +1,48 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const updateProject = async (
+  projectId: string,
+  userId: string,
+  organization: string,
+  thumbnail?: string,
+  projectName?: string
+) => {
+  const body: any = {
+    projectId,
+    userId,
+    organization,
+  };
+
+  if (projectName) body.projectName = projectName;
+  if (thumbnail) body.thumbnail = thumbnail;
+
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Projects/${projectId}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify(body),
+      }
+    );
+ 
+    if (!response.ok) {
+      throw new Error("Failed to clearPanel in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/dashboard/viewProject.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const viewProject = async (
+  organization: string,
+  projectId: string,
+  userId: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Project/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    console.error("Failed to get asset image:", error);
+    throw new Error(error.message);
+  }
+};

app/src/services/factoryBuilder/aisle/createAisleApi.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const createAisleApi = async (
+  aisleUuid: string,
+  points: any,
+  type: Object,
+  projectId: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/UpsertAisle`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>", // Replace with actual token
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "", // Coerce null to empty string
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ aisleUuid, points, type, projectId }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to add project");
+    }
+
+    const result = await response.json();
+    // console.log("result: ", result);
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/aisle/deleteAisleApi.ts

@@ -0,0 +1,29 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteAisleApi = async (aisleUuid: string, projectId: string) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/DeleteAisle`, {
+      method: "PATCH",
+      headers: {
+        Authorization: "Bearer <access_token>", // Replace with actual token
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "", // Coerce null to empty string
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ aisleUuid, projectId }),
+    });
+    if (!response.ok) {
+      throw new Error("Failed to clearPanel in the zone");
+    }
+
+    const result = await response.json();
+    // console.log('result: ', result);
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/aisle/getAisleApi.ts

@@ -0,0 +1,28 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getAisleApi = async (projectId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Aisles/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>", // Replace with actual token
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "", // Coerce null to empty string
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    // console.log("response: ", response);
+    if (!response.ok) {
+      throw new Error("Failed to fetch");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    console.error("Failed to get asset image:", error);
+    throw new Error(error.message);
+  }
+};

app/src/services/factoryBuilder/assest/assets/getAssetImages.ts

@@ -0,0 +1,24 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+
+export const getAssetImages = async (cursor?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/v3/AssetDatas?limit=10${cursor ? `&cursor=${cursor}` : ""}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch assets");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to get asset image");
+    throw new Error(error.message);
+  }
+};

app/src/services/factoryBuilder/assest/assets/getAssetModel.ts

@@ -0,0 +1,29 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+
+export const getAssetModel = async (modelId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/v2/AssetFile/${modelId}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch model");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to get asset model");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/assets/getCategoryAsset.ts

@@ -0,0 +1,20 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const getCategoryAsset = async (categoryName: any) => {
+  try {
+    const response = await fetch(
+      `${BackEnd_url}/api/v2/getCategoryAssets/${categoryName}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    const result = await response.json();
+    return result;
+  } catch (error: any) {
+    echo.error("Failed to get category asset");
+    throw new Error(error.message);
+  }
+};

app/src/services/factoryBuilder/assest/floorAsset/deleteFloorItemApi.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteFloorItem = async (
+  organization: string,
+  modelUuid: string,
+  modelName: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/v1/deletefloorItem`,
+      {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ organization, modelUuid, modelName }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete Floor Item");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete floor item");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/floorAsset/getFloorItemsApi.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getFloorAssets = async (organization: string,projectId?:string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/floorAssets/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    // console.log('response: ', response);
+    if (!response.ok) {
+      throw new Error("Failed to get assets");
+    }
+
+    const result = await response.json();
+    // console.log('result: ', result);
+
+    return result;
+  } catch (error) {
+    echo.error("Failed to get floor asset");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/floorAsset/setFloorItemApi.ts

@@ -0,0 +1,49 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+export const setFloorItemApi = async (
+  organization: string,
+  modelUuid?: string,
+  modelName?: string,
+  modelfileID?: string,
+  position?: Object,
+  rotation?: Object,
+  isLocked?: boolean,
+  isVisible?: boolean
+) => {
+  try {
+    const body: any = {
+      organization,
+      modelUuid,
+      modelName,
+      position,
+      rotation,
+      modelfileID,
+      isLocked,
+      isVisible,
+    };
+
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/setAsset`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set or update Floor Item");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to set floor items");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/wallAsset/deleteWallItemApi.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteWallItem = async (
+  organization: string,
+  modelUuid: string,
+  modelName: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/v1/deleteWallItem`,
+      {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ organization, modelUuid, modelName }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete Wall Item");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete wall items");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/wallAsset/getWallItemsApi.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getWallItems = async (organization: string,projectId?:string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/walls/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    // console.log('response: ', response);
+    if (!response.ok) {
+      throw new Error("Failed to get Wall Items");
+    }
+
+    const result = await response.json();
+    // console.log('result: ', result);
+    return result;
+  } catch (error) {
+    echo.error("Failed to get wall items");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/assest/wallAsset/setWallItemApi.ts

@@ -0,0 +1,47 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const setWallItem = async (
+  organization: string,
+  modelUuid: string,
+  modelName: string,
+  type: string,
+  csgposition: Object,
+  csgscale: Object,
+  position: Object,
+  quaternion: Object,
+  scale: Object
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/setWallItems`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        organization,
+        modelUuid,
+        modelName,
+        position,
+        type,
+        csgposition,
+        csgscale,
+        quaternion,
+        scale,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set or update Wall Item");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to set wall items");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/camera/getCameraApi.ts

@@ -0,0 +1,36 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getCamera = async (organization: string, userId: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/cameras/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to get Camera position and target");
+    }
+
+    const result = await response.json();
+    if (result === "user not found") {
+      return null;
+    } else {
+      return result;
+    }
+  } catch (error) {
+    echo.error("Failed to get camera");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/camera/setCameraApi.ts

@@ -0,0 +1,39 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const setCamera = async (
+  organization: string,
+  userId: string,
+  position: Object,
+  target: Object,
+  rotation: Object
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/setCamera`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        organization,
+        userId,
+        position,
+        target,
+        rotation,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set Camera Position and Target");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to set camera");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/collab/getActiveUsers.ts

@@ -0,0 +1,32 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export default async function getActiveUsersData(organization: string) {
+  const apiUrl = `${url_Backend_dwinzo}/api/v1/activeCameras/${organization}`;
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Error: ${response.status} - ${response.statusText}`);
+    }
+
+    if (!response.ok) {
+      throw new Error("Failed to get active cameras ");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to get active users");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+}

app/src/services/factoryBuilder/collab/getUsersApi.ts

@@ -0,0 +1,32 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export default async function fetchShareUsers(organization: string) {
+  const apiUrl = `${url_Backend_dwinzo}/api/v1/findshareUsers?organization=${organization}`;
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Error: ${response.status} - ${response.statusText}`);
+    }
+
+    if (!response.ok) {
+      throw new Error("Failed to get users ");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to get user API");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+}

app/src/services/factoryBuilder/collab/giveCollabAccess.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export default async function giveCollabAccess(
+  email: string,
+  isShare: boolean,
+  organization: string
+) {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/shareUser`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ email, isShare, organization }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set Camera Position and Target");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to give collab access");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+}

app/src/services/factoryBuilder/environment/findEnvironment.ts

@@ -0,0 +1,34 @@
+
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const findEnvironment = async (organization: string, userId: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/Environments/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+
+    if (!response.ok) {
+      throw new Error("Failed to get wall and roof visibility");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to find env");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/environment/setEnvironment.ts

@@ -0,0 +1,54 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const setEnvironment = async (
+  organization: string,
+  userId: string,
+  wallVisibility: boolean,
+  roofVisibility: boolean,
+  shadowVisibility: boolean,
+  renderDistance: number,
+  limitDistance: boolean,
+  projectId?: string
+) => {
+
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/SetEnvironments`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({
+          organization,
+          userId,
+          wallVisibility,
+          roofVisibility,
+          shadowVisibility,
+          renderDistance,
+          limitDistance,
+          projectId
+        }),
+      }
+    );
+
+    // console.log('responseenv: ', response);
+    if (!response.ok) {
+      throw new Error("Failed to set wall and roof visibility");
+    }
+
+    const result = await response.json();
+    // console.log('resultsetenv: ', result);
+    return result;
+  } catch (error) {
+    echo.error("Failed to set env");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/deleteLayerApi.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteLayer = async (organization: string, layer: number) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/deleteLayer`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ organization, layer }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete line");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete line");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/deleteLineApi.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteLineApi = async (organization: string, line: Object) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/deleteLine`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ organization, line }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete line");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete line");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/deletePointApi.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deletePointApi = async (organization: string, uuid: string) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/deletePoint`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ organization, uuid }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete point");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete point");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/getLinesApi.ts

@@ -0,0 +1,33 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getLines = async (organization: string,projectId?:string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/lines/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to get Lines");
+    }
+
+    const result = await response.json();
+    // console.log('result: ', result);
+    return result;
+  } catch (error) {
+    echo.error("Failed to get Lines");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/setLineApi.ts

@@ -0,0 +1,32 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const setLine = async (
+  organization: string,
+  layer: number,
+  line: Object,
+  type: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/setLine`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ organization, layer, line, type }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set line");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to set line");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/lines/updatePointApi.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const updatePoint = async (
+  organization: string,
+  position: Object,
+  uuid: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/updatePoint`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ organization, position, uuid }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to update point");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to update point");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/mqtt/mqttEvents.ts

@@ -0,0 +1,45 @@
+import React, { useEffect } from "react";
+import mqtt from "mqtt";
+import { useDrieUIValue } from "../../../store/builder/store";
+
+const MqttEvents = () => {
+    const { setTouch, setTemperature, setHumidity } = useDrieUIValue();
+    useEffect(() => {
+
+        // const client = mqtt.connect(`ws://${process.env.REACT_APP_SERVER_MQTT_URL}`);
+
+        // client.subscribe("touch");
+        // client.subscribe("temperature");
+        // client.subscribe("humidity");
+
+        // const handleMessage = (topic: string, message: any) => {
+        //     const value = message.toString();
+
+        //     if (topic === "touch") {
+        //         setTouch(value);
+        //     } else if (topic === "temperature") {
+        //         setTemperature(parseFloat(value));
+        //     } else if (topic === "humidity") {
+        //         setHumidity(parseFloat(value));
+        //     }
+        // };
+
+        // client.on("message", handleMessage);
+
+        // client.on("error", (err) => {
+        //     console.error("MQTT Connection Error:", err);
+        // });
+
+        // client.on("close", () => {
+        //     console.log("MQTT Connection Closed");
+        // });
+
+        // return () => {
+        //     client.end();
+        // };
+    }, [setTouch, setTemperature, setHumidity]);
+
+    return null;
+};
+
+export default MqttEvents;

app/src/services/factoryBuilder/signInSignUp/signInApi.ts

@@ -0,0 +1,22 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const signInApi = async (Email: string, Password: Object, organization: Object, fingerprint: any) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/Auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", },
+      body: JSON.stringify({ Email, Password, organization, fingerprint }),
+    });
+
+    const result = await response.json();
+
+    return result;
+  } catch (error) {
+    echo.error("Failed to sign-in");
+    if (error instanceof Error) {
+      return { error: error.message };
+    } else {
+      return { error: "An unknown error occurred" };
+    }
+  }
+};

app/src/services/factoryBuilder/signInSignUp/signUpApi.ts

@@ -0,0 +1,30 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const signUpApi = async (
+  userName: string,
+  Email: string,
+  Password: Object,
+  organization: Object
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/Auth/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", },
+      body: JSON.stringify({ userName, Email, Password, organization }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to signUpApi");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to sign-up");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/webWorkers/gltfLoaderWorker.js

@@ -0,0 +1,41 @@
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
+import { retrieveGLTF, storeGLTF } from '../../../utils/indexDB/idbUtils';
+
+const loader = new GLTFLoader();
+const dracoLoader = new DRACOLoader();
+dracoLoader.setDecoderPath('https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/libs/draco/gltf/');
+loader.setDRACOLoader(dracoLoader);
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+
+onmessage = async (event) => {
+    const { floorItems } = event.data;
+
+    const uniqueItems = floorItems.filter((item, index, self) =>
+        index === self.findIndex((t) => t.modelfileID === item.modelfileID)
+    );
+
+    for (const item of uniqueItems) {
+        if(item.modelfileID === null || item.modelfileID === undefined) {
+            continue; // Skip items without a valid modelfileID
+        }
+        const modelID = item.modelfileID;
+        const indexedDBModel = await retrieveGLTF(modelID);
+
+        let modelBlob;
+        if (indexedDBModel) {
+            modelBlob = indexedDBModel;
+            const message = "gltfLoaded";
+            postMessage({ message, modelID, modelBlob });
+        } else {
+            const modelUrl = `${url_Backend_dwinzo}/api/v2/AssetFile/${modelID}`;
+            const modelBlob = await fetch(modelUrl).then((res) => res.blob());
+            await storeGLTF(modelID, modelBlob);
+            const message = "gltfLoaded";
+            postMessage({ message, modelID, modelBlob });
+        }
+    }
+
+    postMessage({ message: 'done' })
+};

app/src/services/factoryBuilder/webWorkers/shadowWorker.js

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+
+onmessage = (event) => {
+    const { controlsTarget, sunPosition, offsetDistance } = event.data;
+
+    const lightPosition = new THREE.Vector3()
+        .copy(controlsTarget)
+        .addScaledVector(new THREE.Vector3().copy(sunPosition).normalize(), offsetDistance);
+
+    postMessage({ lightPosition, controlsTarget });
+};

app/src/services/factoryBuilder/zones/deleteZoneApi.ts

@@ -0,0 +1,32 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteZonesApi = async (
+  userId: string,
+  organization: string,
+  zoneUuid: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/setLine`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ userId, organization, zoneUuid }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete zone");
+    }
+
+    const result = await response.json();
+
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete zone");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/zones/getZonesApi.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const getZonesApi = async (organization: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/zones/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+        throw new Error("Failed to get Zones");
+    }
+
+    const result = await response.json();
+    // console.log('result:zone ', result);
+    
+    return result;
+  } catch (error) {
+    echo.error("Failed to get zone data");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/factoryBuilder/zones/setZonesApi.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const setZonesApi = async (
+  userId: string,
+  organization: string,
+  zoneData: any
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/v1/setLine`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ userId, organization, zoneData }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to set zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to zone data");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/marketplace/fetchAssetDetails.ts

@@ -0,0 +1,24 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const getAssetDetails = async (filename: string) => {
+  console.log('filename: ', filename);
+  try {
+    const response = await fetch(`${BackEnd_url}/api/v1/assetDetails`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ filename }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch asset details");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error: any) {
+    echo.error("Failed to fetch assetg details");
+    // console.error("Error fetching category:", error.message);
+    throw new Error(error.message);
+  }
+};

app/src/services/marketplace/fetchAssets.ts

@@ -0,0 +1,17 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const fetchAssets = async () => {
+  try {
+    const response = await fetch(`${BackEnd_url}/api/v1/getAllAssets`);
+    if (!response.ok) {
+      throw new Error("Network response was not ok");
+    }
+    const result = await response.json();
+    // const last10Assets = result.slice(-10);
+    // console.log('last10Assets: ', last10Assets);
+    return result;
+  } catch (error) {
+    echo.error("Failed to fetch assets");
+    console.log("error: ", error);
+    // throw new Error(error.message);
+  }
+};

app/src/services/marketplace/fetchGltfUrl.ts

@@ -0,0 +1,26 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const fetchGltfUrl = async (filename: string, AssetID: string) => {
+  try {
+    const response = await fetch(
+      `${BackEnd_url}/api/v2/assetDetails/${filename}/${AssetID}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        // body: JSON.stringify(assetData),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch asset details");
+    }
+
+    const result = await response.json();
+
+    return result;
+  } catch (error: any) {
+    //
+    throw new Error(error.message);
+  }
+}

app/src/services/marketplace/getAssetDownload.ts

@@ -0,0 +1,4 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const getAssetDownload = (filename: any) => {
+  return `${BackEnd_url}/api/v1/getAssetFile/${filename}.gltf`;
+};

app/src/services/marketplace/getSortedAssets.ts

@@ -0,0 +1,26 @@
+let BackEnd_url = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+export const getSortedAssets = async (category: any, orders: any) => {
+  try {
+    const response = await fetch(
+      `${BackEnd_url}/api/v1/categoryWise/${category}?sortBy=${orders}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`Error: ${response.statusText}`);
+    }
+
+    const result = await response.json();
+
+    return result; // Return the result to be used later
+  } catch (error: any) {
+    echo.error("Failed to fetching category");
+    console.error("Error fetching category:", error.message);
+    throw new Error(error.message);
+  }
+};

app/src/services/simulation/products/UpsertProductOrEventApi.ts

@@ -0,0 +1,33 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const upsertProductOrEventApi = async (body: any) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/ProductUpsert`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify(body),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to add product or event");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to upsert product Or eventApi");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/products/deleteEventDataApi.ts

@@ -0,0 +1,33 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteEventDataApi = async (body: any) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/DeleteEvent`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify(body),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete event data");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete event data API");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/products/deleteProductApi.ts

@@ -0,0 +1,33 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const deleteProductApi = async (body: any) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/DeleteProduct`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify(body),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete product data");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete product API");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/products/getProductApi.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getProductApi = async (
+  productUuid: string,
+  projectId: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/EventsByProduct?productUuid=${productUuid}&projectId=${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch product data");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to get product asset");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/products/getallProductsApi.ts

@@ -0,0 +1,32 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const getAllProductsApi = async (projectId: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/ProjectProducts/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch all products data");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to get all product API");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/products/renameProductApi.ts

@@ -0,0 +1,36 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+
+export const renameProductApi = async (body: {
+  productName: string;
+  productUuid: string;
+  projectId: string;
+}) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/RenameProduct`, {
+      method: "PATCH",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to rename product");
+    }
+
+    const result = await response.json();
+    console.log('result: ', result);
+    return result;
+  } catch (error) {
+    echo.error("Failed to rename product Api");
+
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/simulation/webWorkers/collisionWorker.ts

@@ -0,0 +1,40 @@
+onmessage = function (e) {
+    const { materials, positions, sizes } = e.data;
+    const collisions = [];
+    const allPairs = [];
+
+    for (let i = 0; i < materials.length; i++) {
+        for (let j = i + 1; j < materials.length; j++) {
+            const mat1 = materials[i];
+            const mat2 = materials[j];
+            const pos1 = positions[mat1.materialId];
+            const pos2 = positions[mat2.materialId];
+
+            if (!pos1 || !pos2) continue;
+
+            const size1 = sizes[mat1.materialId] || 0.2;
+            const size2 = sizes[mat2.materialId] || 0.2;
+
+            const distance = Math.sqrt(
+                Math.pow(pos1.x - pos2.x, 2) +
+                Math.pow(pos1.y - pos2.y, 2) +
+                Math.pow(pos1.z - pos2.z, 2)
+            );
+
+            allPairs.push({
+                materialId1: mat1.materialId,
+                materialId2: mat2.materialId
+            });
+
+            if (distance < (size1 + size2)) {
+                collisions.push({
+                    materialId1: mat1.materialId,
+                    materialId2: mat2.materialId,
+                    distance: distance
+                });
+            }
+        }
+    }
+
+    postMessage({ collisions, allPairs });
+};

app/src/services/visulization/zone/add3dWidget.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const adding3dWidgets = async (
+  zoneUuid: string,
+  organization: string,
+  widget: {}
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/widget3d/save`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, widget }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to add 3dwidget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to add 3d widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/addFloatingWidgets.ts

@@ -0,0 +1,38 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const addingFloatingWidgets = async (
+  zoneUuid: string,
+  organization: string,
+  widget: {}
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/floatWidget/save`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ organization, zoneUuid, widget }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to add Floatingwidget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to add floating");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/addWidgets.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const addingWidgets = async (
+  zoneUuid: string,
+  organization: string,
+  widget: {}
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/widget/save`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, widget }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to add widget in the zone");
+    }
+
+    const result = await response.json();
+    // console.log('result: ', result);
+    return result;
+  } catch (error) {
+    echo.error("Failed to add widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/clearPanel.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const clearPanel = async (
+  zoneUuid: string,
+  organization: string,
+  panelName: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/panel/clear`, {
+      method: "PATCH",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, panelName }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to clearPanel in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to clean pannel");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/delete3dWidget.ts

@@ -0,0 +1,38 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const delete3dWidgetApi = async (
+  zoneUuid: string,
+  organization: string,
+  id: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/widget3d/delete`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ organization, zoneUuid, id }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete floating widget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete 3d widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/deleteFloatingWidget.ts

@@ -0,0 +1,37 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deleteFloatingWidgetApi = async (
+  floatWidgetID: string,
+  organization: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/floatWidget/delete`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ organization, floatWidgetID }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete floating widget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete floating widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/deletePanel.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deletePanelApi = async (
+  zoneUuid: string,
+  panelName: string,
+  organization: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/panel/delete`, {
+      method: "PATCH",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, panelName }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete widget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete pannel");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/deleteTemplate.ts

@@ -0,0 +1,36 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deleteTemplateApi = async (
+  templateID: string,
+  organization?: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/template/delete`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to delete template ");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/deleteWidgetApi.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const deleteWidgetApi = async (
+  widgetID: string,
+  organization: string,
+  zoneUuid: string
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/widget/delete`, {
+      method: "PATCH",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, widgetID, zoneUuid }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to delete widget in the zone");
+    }
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to delete widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/duplicateWidget.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const duplicateWidgetApi = async (
+  zoneUuid: string,
+  organization: string,
+  widget: {}
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/widget/save`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, widget }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to duplicate widget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to dublicate widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/get3dWidgetData.ts

@@ -0,0 +1,32 @@
+import { projectTutorial } from "../../dashboard/projectTutorial";
+
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const get3dWidgetZoneData = async (
+  zoneUuid?: string,
+  organization?: string,
+  projectId?: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/widget3d/data/${zoneUuid}/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error("Failed to fetch Zone3dWidgetData");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to fetch 3d data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/getFloatingData.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const getFloatingZoneData = async (
+  zoneUuid?: string,
+  organization?: string,
+  projectId?: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/floatWidgets/${zoneUuid}/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch ZoneFloatingData");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to fetch floating data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/getSelect2dZoneData.ts

@@ -0,0 +1,28 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const getSelect2dZoneData = async (zoneUuid?: string, organization?: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/zones/panel/${projectId}/${zoneUuid}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch zoneDatas");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to fetch 2d widget data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/getTemplate.ts

@@ -0,0 +1,27 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const getTemplateData = async (organization?: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/template/data/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch ZoneFloatingData");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to template data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/getZoneData.ts

@@ -0,0 +1,26 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const getZone2dData = async (organization?: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/zones/visualization/${projectId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error("Failed to fetch zoneDatas");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to fetch 2d zone data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/getZones.ts

@@ -0,0 +1,28 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const getZoneData = async (zoneUuid: string, organization: string, projectId?: string) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/zones/${projectId}/${zoneUuid}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch zoneData");
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    echo.error("Failed to fetch zone data");
+    throw new Error(error.message);
+  }
+};

app/src/services/visulization/zone/loadTemplate.ts

@@ -0,0 +1,37 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const loadTempleteApi = async (
+  templateID: string,
+  zoneUuid: string,
+  organization: string
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/template/toZone`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({ organization, zoneUuid, templateID }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to load Template in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to load template");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/lockPanel.ts

@@ -0,0 +1,34 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const lockPanel = async (
+  zoneUuid: string,
+  organization: string,
+  lockedPanel: any
+) => {
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/v2/zones/lockedPanels`,
+      {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ organization, zoneUuid, lockedPanel }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to Lock Panel in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to fetch locked panel data");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/panel.ts

@@ -0,0 +1,35 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+type Side = "top" | "bottom" | "left" | "right";
+
+export const panelData = async (
+  organization: string,
+  zoneUuid: string,
+  panelOrder: Side[]
+) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/panel/save`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, zoneUuid, panelOrder }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to add panelOrder for Zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to fetch panel data");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/saveTempleteApi.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const saveTemplateApi = async (organization: string, template: {}) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/template/save`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ organization, template }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to save template zone");
+    }
+
+    const result = await response.json();
+
+    return result;
+  } catch (error) {
+    echo.error("Failed to save template");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/update3dWidget.ts

@@ -0,0 +1,89 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+export const update3dWidget = async (
+  zoneUuid: string,
+  organization: string,
+  id: string,
+  position?: [number, number, number]
+) => {
+  console.log("organization: ", organization);
+  console.log("zoneUuid: ", zoneUuid);
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/widget3d/update`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({
+          organization,
+          zoneUuid,
+          id,
+          position,
+        }),
+      }
+    );
+
+    if (!response.ok) {
+      echo.error("Failed to update 3d widget");
+      throw new Error("Failed to add 3dwidget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};
+
+export const update3dWidgetRotation = async (
+  zoneUuid: string,
+  organization: string,
+  id: string,
+  rotation?: [number, number, number]
+) => {
+  console.log("organization: ", organization);
+  console.log("zoneUuid: ", zoneUuid);
+  try {
+    const response = await fetch(
+      `${url_Backend_dwinzo}/api/V1/widget3d/update`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: "Bearer <access_token>",
+          "Content-Type": "application/json",
+          token: localStorage.getItem("token") || "",
+          refresh_token: localStorage.getItem("refreshToken") || "",
+        },
+        body: JSON.stringify({
+          organization,
+          zoneUuid,
+          id,
+          rotation,
+        }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to add 3dwidget in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to rotate 3d widget");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};

app/src/services/visulization/zone/zoneCameraUpdation.ts

@@ -0,0 +1,31 @@
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_REST_API_BASE_URL}`;
+// let url_Backend_dwinzo = `http://192.168.0.102:5000`;
+
+export const zoneCameraUpdate = async (zoneData: {}, organization: string, projectId?: string) => {
+  try {
+    const response = await fetch(`${url_Backend_dwinzo}/api/V1/zones`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer <access_token>",  // Replace with actual token
+        "Content-Type": "application/json",
+        token: localStorage.getItem("token") || "",
+        refresh_token: localStorage.getItem("refreshToken") || "",
+      },
+      body: JSON.stringify({ zoneData, projectId }),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to update camera position in the zone");
+    }
+
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    echo.error("Failed to update zone camera");
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    } else {
+      throw new Error("An unknown error occurred");
+    }
+  }
+};