zone create,update and read initialized

src/API/routes/zoneRoutes.ts

@@ -1,6 +1,8 @@
 import * as express from "express";
 import { Zoneservice } from "../service/zoneService.ts";
 const router = express.Router();
-router.post("/zonecreate", Zoneservice.addandUpdateZone); //Zone create and update for the points
-//archive all the zones based on the sceneID
+router.post("/zone/save", Zoneservice.addandUpdateZone); //Zone create and update for the points
+router.get("/zones/:sceneID", Zoneservice.allZones);
+router.patch("/zone/:zoneID", Zoneservice.deleteAZone); //delete Zone
+// router.get("/zone/:sceneID", Zoneservice.allZones);
 export default router;

src/API/service/zoneService.ts

@@ -3,25 +3,24 @@ import zoneSchema from "../../shared/model/builder/lines/zone-Model.ts";
 export class Zoneservice {
   static async addandUpdateZone(req: Request, res: Response): Promise<any> {
     const organization = req.body.organization;
-    console.log("organization: ", organization);
     const zoneDatas = req.body.zonesdata;
-    console.log("zoneDatas: ", zoneDatas);
     try {
       const existingZone = await zoneSchema(organization).findOne({
-        _id: zoneDatas.zoneID,
+        zoneUUID: zoneDatas.zoneId,
         isArchive: false,
       });
       if (!existingZone) {
         const newZone = await zoneSchema(organization).create({
           zoneName: zoneDatas.zonename,
-          //   zoneUUID: zoneDatas.uuid,
+          zoneUUID: zoneDatas.zoneId,
           zonePoints: zoneDatas.points,
-          centerPoints: zoneDatas.centerPoints,
+          centerPoints: zoneDatas.viewportPosition,
           createdBy: zoneDatas.userid,
-          sceneID: zoneDatas.sceneid,
+          layer: zoneDatas.layer,
+          sceneID: zoneDatas.sceneID || "scene123",
         });
         if (newZone)
-          return res.send({
+          return res.status(200).json({
             message: "Zone created successfully",
             zoneData: {
               zoneName: newZone.zoneName,
@@ -31,16 +30,17 @@ export class Zoneservice {
           });
       } else {
         const replaceZone = await zoneSchema(organization).findOneAndUpdate(
-          { _id: zoneDatas.zoneID, isArchive: false },
+          { zoneUUID: zoneDatas.zoneId, isArchive: false },
           {
-            zonePoints: zoneDatas.zonePoints,
-            centerPoints: zoneDatas.centerPoints,
+            zonePoints: zoneDatas.points,
+            centerPoints: zoneDatas.viewportPosition,
           },
           { new: true }
         );
-        if (!replaceZone) return res.send({ message: "Zone not updated" });
+        if (!replaceZone)
+          return res.status(404).json({ message: "Zone not updated" });
         else
-          return res.send({
+          return res.status(200).json({
             message: "updated successfully",
             zoneData: {
               zoneName: replaceZone.zoneName,
@@ -53,4 +53,108 @@ export class Zoneservice {
       return res.status(500).send(error.message);
     }
   }
+
+  static async deleteAZone(req: Request, res: Response): Promise<any> {
+    const organization = req.query.organization;
+    const zoneUUID = req.params.zoneId;
+    try {
+      const existingZone = await zoneSchema(organization).findOne({
+        zoneUUID: zoneUUID,
+        isArchive: false,
+      });
+      if (!existingZone) {
+        return res.status(404).json({ message: "Zone not found for the UUID" });
+      } else {
+        const deleteZone = await zoneSchema(organization).findOneAndUpdate(
+          { zoneUUID: zoneUUID, isArchive: false },
+          {
+            isArchive: true,
+          },
+          { new: true }
+        );
+
+        if (deleteZone) {
+          return res.status(200).json({ message: "Zone deleted successfully" });
+        }
+      }
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+
+  // static async singleZone(req: Request, res: Response): Promise<any> {
+  //   const organization = req.query.organization;
+  //   console.log("organization: ", organization);
+  //   const zoneUUID = req.params.zoneUUID;
+  //   console.log("zoneUUID: ", zoneUUID);
+  //   try {
+  //     const existingZone = await zoneSchema(organization)
+  //       .findOne({
+  //         zoneUUID: req.params.zoneUUID,
+  //       })
+  //       // .select("-_id -__v -isArchive -createdAt -updatedAt");
+  //     console.log("existingZone: ", existingZone);
+  //     if (!existingZone) {
+  //       return res.send({ message: "Zone not found for the UUID" });
+  //     } else {
+  //       const panelData = await panelSchema(organization)
+  //         .find({
+  //           zoneUUID: zoneUUID,
+  //         })
+  //         .select("panelOriginalOrder panelSide lockedPanel");
+
+  //       const zoneName = existingZone.zoneName as string;
+
+  //       const objectData = {
+  //         [zoneName]: {
+  //           activeSides: panelData.flatMap((data) => data.panelSide || []),
+  //           lockedPanels: panelData.flatMap((data) => data.lockedPanel || []),
+  //           panelOrder: panelData.flatMap(
+  //             (data) => data.panelOriginalOrder || []
+  //           ),
+  //           points: existingZone.zonePoints || [],
+  //           widgets: panelData.flatMap((data) => data.widgets || []),
+  //         },
+  //       };
+
+  //       return res.send(objectData);
+  //     }
+  //   } catch (error: any) {
+  //     return res.status(500).send(error.message);
+  //   }
+  // }
+
+  static async allZones(req: Request, res: Response): Promise<any> {
+    const organization = req.query.organization;
+    const sceneID = req.params.sceneID || "scene123";
+    try {
+      const Allzones = await zoneSchema(organization)
+        .find({ sceneID: sceneID, isArchive: false })
+        .select("zoneName sceneID zoneUUID");
+
+      if (!Allzones || Allzones.length === 0) {
+        return res.status(200).json({ message: "Zone not found for the UUID" });
+      }
+      return res.status(200).json(Allzones);
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+
+  // static async ZoneIDgenerate(req: Request, res: Response): Promise<any> {
+  //   const organization = req.query.organization;
+  //   const sceneID = req.params.sceneID;
+  //   try {
+  //     const Allzones = await zoneSchema(organization)
+  //       .find({ sceneID: sceneID, isArchive: false })
+  //       .select("zoneName sceneID zoneUUID");
+
+  //     if (!Allzones || Allzones.length === 0) {
+  //       return res.send({ message: "Zone not found for the UUID" });
+  //     }
+  //     return res.send(Allzones);
+  //   } catch (error: any) {
+  //     return res.status(500).send(error.message);
+  //   }
+  // }
 }