V1 for the builder processing

src/api-server/Routes/zoneRoutes.ts

@@ -1,5 +1,6 @@
 import * as express from "express";
 import { ZoneService } from "../controller/lines/zoneService.ts";
+import { zone } from "../controller/lines/zone-Services.ts";
 
 const router = express.Router();
 /**
@@ -539,4 +540,6 @@ router.get("/A_zone/:zoneId/:organization", ZoneService.ZoneData);
  */
 router.patch("/zone/:zoneId", ZoneService.deleteAZone); //delete Zone
 router.patch("/zones/lockedPanels", ZoneService.lockedPanel);
+
+router.get("/findZones/:organization", zone.getZones);
 export default router;

src/api-server/V1/v1Controllers/builderController/v1wallController.ts

@@ -0,0 +1,69 @@
+import { Request, Response } from "express";
+import { WallItems } from "../../../../shared/services/builder/wallService.ts";
+import { error } from "console";
+import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
+
+export const WallSetup = async (
+  req: AuthenticatedRequest,
+  res: Response
+): Promise<void> => {
+  try {
+    const { userId, organization } = req.user || {};
+    const {
+      modelUuid,
+      modelName,
+      position,
+      type,
+      csgposition,
+      csgscale,
+      quaternion,
+      scale,
+      // versionId
+      projectId,
+    } = req.body;
+    if (
+      !modelUuid ||
+      !modelName ||
+      !position ||
+      !type ||
+      !projectId ||
+      !csgscale ||
+      !csgposition ||
+      // !versionId ||
+      !quaternion ||
+      !scale ||
+      !organization
+    ) {
+      res.status(400).json({
+        message: "All fields are required!",
+      });
+      return;
+    }
+    const result = await WallItems.setWallItems({
+      projectId,
+      modelUuid,
+      // versionId,
+      modelName,
+      position,
+      type,
+      csgposition,
+      csgscale,
+      quaternion,
+      scale,
+      organization,
+    });
+    switch (result.state) {
+      case "Updated successfully":
+        res.status(201).json(result.data);
+        break;
+      case "wall Item created successfully":
+        res.status(201).json(result.data);
+        break;
+      default:
+        res.status(500).json(error);
+        break;
+    }
+  } catch (error: unknown) {
+    res.status(500).json({ message: "Unknown error" });
+  }
+};

src/api-server/V1/v1Controllers/builderController/v1zoneController.ts

@@ -0,0 +1,115 @@
+import { Request, Response } from "express";
+
+import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
+import {
+  GetCamers,
+  SetCamera,
+} from "../../../../shared/services/builder/cameraService.ts";
+
+export const SetNewCamera = async (
+  req: AuthenticatedRequest,
+  res: Response
+): Promise<void> => {
+  try {
+    const { organization, role, userId } = req.user || {};
+    const { position, target, rotation, projectId, versionId } = req.body;
+    if (
+      !organization ||
+      !role ||
+      !userId ||
+      !position ||
+      !target ||
+      !rotation ||
+      !projectId ||
+      !versionId
+    ) {
+      res.status(400).json({
+        message: "All fields are required",
+      });
+      return;
+    }
+    const data = {
+      position,
+      target,
+      rotation,
+      projectId,
+      versionId,
+      organization,
+      role,
+      userId,
+    };
+    const result = await SetCamera(data);
+
+    switch (result.status) {
+      case "Project not found":
+        res.status(404).json({
+          message: "Project not found",
+          TrashDatas: [],
+        });
+        break;
+
+      case "Update Success":
+        res.status(200).json({
+          TrashDatas: result.data,
+        });
+        break;
+      case "Success":
+        res.status(200).json({
+          TrashDatas: result.data,
+        });
+        break;
+      default:
+        res.status(500).json({
+          message: "Internal server error",
+        });
+        break;
+    }
+  } catch (error) {
+    console.log("error: ", error);
+    res.status(500).json({
+      message: "Unknown error",
+    });
+  }
+};
+export const CameraList = async (
+  req: AuthenticatedRequest,
+  res: Response
+): Promise<void> => {
+  try {
+    const { organization, role, userId } = req.user || {};
+    if (!organization || !role || !userId) {
+      res.status(400).json({
+        message: "All fields are required",
+      });
+      return;
+    }
+    const result = await GetCamers({
+      organization,
+      role,
+      userId,
+    });
+
+    switch (result.status) {
+      case "Project not found":
+        res.status(404).json({
+          message: "Project not found",
+          TrashDatas: [],
+        });
+        break;
+      case "Success":
+        res.status(200).json({
+          TrashDatas: result.data,
+        });
+        break;
+      default:
+        res.status(500).json({
+          message: "Internal server error",
+        });
+        break;
+    }
+  } catch (error) {
+    res.status(500).json({
+      message: "Unknown error",
+    });
+  }
+};

src/api-server/V1/v1Controllers/homeController/v1homeController.ts

@@ -50,21 +50,20 @@ export const recentDataController = async (
   }
 };
 export const searchProjectController = async (
-  req: Request,
+  req: AuthenticatedRequest,
   res: Response
 ): Promise<void> => {
   try {
-    const { searchName, organization, userId } = req.query as {
-      organization: string;
-      searchName: string;
-      userId: string;
-    };
-    if (!userId || !organization || !searchName) {
+    const { userId, organization, role } = req.user || {};
+    if (!userId || !organization || !role) {
       res.status(400).json({
         message: "All fields are required",
       });
       return;
     }
+    const { searchName } = req.query as {
+      searchName: string;
+    };
     const result = await searchProject({
       searchName,
       organization,
@@ -100,21 +99,21 @@ export const searchProjectController = async (
   }
 };
 export const searchTrashProjectController = async (
-  req: Request,
+  req: AuthenticatedRequest,
   res: Response
 ): Promise<void> => {
   try {
-    const { searchName, organization, userId } = req.query as {
-      organization: string;
-      searchName: string;
-      userId: string;
-    };
-    if (!userId || !organization || !searchName) {
+    const { userId, organization, role } = req.user || {};
+    if (!userId || !organization || !role) {
       res.status(400).json({
         message: "All fields are required",
       });
       return;
     }
+    const { searchName } = req.query as {
+      searchName: string;
+    };
+
     const result = await searchTrashProject({
       searchName,
       organization,

src/api-server/V1/v1Controllers/projectController/v1projectController.ts

@@ -14,7 +14,6 @@ export const createProjectController = async (
 ): Promise<void> => {
   try {
     const { userId, organization } = req.user || {};
-    console.log("req.user: ", req.user);
     const { projectUuid, thumbnail } = req.body;
     if (!req.user || !req.user.userId || !req.user.organization) {
       res.status(401).json({ message: "Unauthorized" });
@@ -82,7 +81,7 @@ export const GetProjects = async (
         break;
 
       case "Success":
-        res.status(201).json({
+        res.status(200).json({
           Projects: result?.Datas,
         });
         break;

src/api-server/V1/v1Routes/v1-homeRoutes.ts

@@ -1,7 +1,11 @@
 import express from "express";
 import { tokenValidator } from "../../../shared/utils/token.ts";
 import authorizedRoles from "../../../shared/middleware/rbacMiddleware.ts";
-import { recentDataController } from "../../V1/v1Controllers/homeController/v1homeController.ts";
+import {
+  recentDataController,
+  searchProjectController,
+  searchTrashProjectController,
+} from "../../V1/v1Controllers/homeController/v1homeController.ts";
 
 const v1homeRoutes = express.Router();
 
@@ -9,8 +13,20 @@ const v1homeRoutes = express.Router();
 v1homeRoutes.get(
   "/RecentlyViewed",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   recentDataController
 );
+v1homeRoutes.get(
+  "/searchProjects",
+  tokenValidator,
+  // authorizedRoles("Admin", "User"),
+  searchProjectController
+);
+v1homeRoutes.get(
+  "/searchTrashProjects",
+  tokenValidator,
+  // authorizedRoles("Admin", "User"),
+  searchTrashProjectController
+);
 
 export default v1homeRoutes;

src/api-server/V1/v1Routes/v1-projectRoutes.ts

@@ -16,26 +16,26 @@ v1projectRouter.post("/upsertProject", tokenValidator, createProjectController);
 v1projectRouter.get(
   "/Projects",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   GetProjects
 );
 v1projectRouter.patch(
   "/Project/archive/:projectId",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   RemoveProject
 );
 
 v1projectRouter.patch(
   "/Project/:projectId",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   updateProjectController
 );
 v1projectRouter.get(
   "/Project/:projectId",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   ViewData
 );
 

src/api-server/V1/v1Routes/v1-trashRoutes.ts

@@ -7,19 +7,18 @@ import {
 } from "../../V1/v1Controllers/trashController/v1trashController.ts";
 
 const v1TrashRoutes = express.Router();
-
 //trash
 v1TrashRoutes.get(
-  "/TrashItems ",
+  "/TrashItems",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   GetTrashList
 );
 
 v1TrashRoutes.patch(
   "/Trash/restore",
   tokenValidator,
-  authorizedRoles("Admin", "User"),
+  // authorizedRoles("Admin", "User"),
   RestoreTrash
 );
 export default v1TrashRoutes;

src/api-server/controller/environments/environments-Services.ts

@@ -11,7 +11,7 @@ export class Environment {
         shadowVisibility,
         organization,
         renderDistance,
-        limitDistance,
+        limitDistance, 
       } = req.body;
 
       const findvalue = await environmentModel(organization).findOne({

src/api-server/controller/lines/zone-Services.ts

@@ -0,0 +1,117 @@
+import { Request, Response } from "express";
+import zoneModel from "../../../shared/model/lines/zone-Model.ts";
+export class zone {
+  static async setZone(req: Request, res: Response) {
+    try {
+      const { organization, userId, zoneData } = req.body;
+      // console.log('req.body: ', req.body);
+      const zoneId = zoneData.zoneId;
+      const points = zoneData.points;
+      const zoneName = zoneData.zoneName;
+      const layer = zoneData.layer;
+      const viewPortCenter = zoneData.viewPortCenter;
+      const viewPortposition = zoneData.viewPortposition;
+      const findZoneId = await zoneModel(organization).findOne({
+        zoneId: zoneId,
+      });
+      if (findZoneId) {
+        const updateZone = await zoneModel(organization)
+          .findOneAndUpdate(
+            { zoneId: zoneId },
+            {
+              points: points,
+              viewPortposition: viewPortposition,
+              viewPortCenter: viewPortCenter,
+            },
+            { new: true }
+          )
+          .select("-_id -__v");
+        res.status(201).json({
+          message: "zone updated",
+          data: updateZone,
+          organization: organization,
+        });
+      } else {
+        const zoneCreate = await zoneModel(organization).create({
+          zoneId,
+          createBy: userId,
+          zoneName: zoneName,
+          points,
+          layer,
+          viewPortCenter,
+          viewPortposition,
+        });
+        const createdZone = await zoneModel(organization)
+          .findById(zoneCreate._id)
+          .select("-_id -__v")
+          .lean();
+        res.status(201).json({
+          message: "zone created",
+          data: createdZone,
+          organization: organization,
+        });
+      }
+    } catch (error) {
+      console.log("error: ", error);
+      res.status(500).json({ message: "Zone not found", error });
+    }
+  }
+  static async deleteZone(req: Request, res: Response) {
+    try {
+      const { organization, userId, zoneId } = req.body;
+
+      const findZoneId = await zoneModel(organization).findOne({
+        zoneId: zoneId,
+      });
+      if (findZoneId) {
+        const deleteZone = await zoneModel(organization)
+          .findOneAndDelete({ zoneId: zoneId, createBy: userId })
+          .select("-_id -__v");
+        res.status(201).json({
+          message: "zone deleted",
+          data: deleteZone,
+          organization: organization,
+        });
+      } else {
+        res.status(500).json({ message: "Invalid zone ID" });
+      }
+    } catch (error) {
+      console.log("error: ", error);
+      res.status(500).json({ message: "Zone not found", error });
+    }
+  }
+  static async getZones(req: Request, res: Response) {
+    try {
+      const { organization, userId } = req.params;
+
+      const findZoneId = await zoneModel(organization)
+        .find()
+        .select(
+          "zoneId zoneName layer points viewPortCenter viewPortposition -_id"
+        );
+
+      if (!findZoneId) {
+        res.status(500).json({ message: "Invalid zone" });
+      }
+      res.status(200).json({ data: findZoneId, organization: organization });
+    } catch (error) {
+      console.log("error: ", error);
+      res.status(500).json({ message: "Zone not found", error });
+    }
+  }
+
+  static async ZoneData(req: Request, res: Response): Promise<any> {
+    try {
+      const organization = req.params.organization;
+      const zoneId = req.params.zoneId;
+      const findZone = await zoneModel(organization).findOne({
+        zoneId: zoneId,
+      });
+      // .select("zoneName");
+      console.log("findZone: ", findZone);
+      if (findZone) return res.status(200).json(findZone);
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+}