vizualization updates

src/api-server/controller/lines/zoneService.ts

@@ -0,0 +1,197 @@
+import { Request, Response } from "express";
+import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
+import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
+import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
+export class Zoneservice {
+  static async addandUpdateZone(req: Request, res: Response): Promise<any> {
+    const organization = req.body.organization;
+    const zoneDatas = req.body.zonesdata;
+    
+    console.log('organization: ', organization);
+    try {
+      const existingZone = await zoneSchema(organization).findOne({
+        zoneId: zoneDatas.zoneId,
+        isArchive: false,
+      });
+      if (!existingZone) {
+        const newZone = await zoneSchema(organization).create({
+          zoneName: zoneDatas.zonename,
+          zoneId: zoneDatas.zoneId,
+          zonePoints: zoneDatas.points,
+          viewPortposition: zoneDatas.viewportPosition,
+          viewPortCenter: zoneDatas.viewPortCenter,
+          createdBy: zoneDatas.userid,
+          layer: zoneDatas.layer,
+          sceneID: zoneDatas.sceneID,
+        });
+        if (newZone)
+          return res.status(200).json({
+            message: "Zone created successfully",
+            zoneData: {
+              zoneName: newZone.zoneName,
+              points: newZone.zonePoints,
+              viewPortposition: zoneDatas.viewPortposition,
+              viewPortCenter: zoneDatas.viewPortCenter,
+            },
+          });
+      } else {
+        const replaceZone = await zoneSchema(organization).findOneAndUpdate(
+          { zoneId: zoneDatas.zoneId, isArchive: false },
+          {
+            zonePoints: zoneDatas.points,
+            viewPortposition: zoneDatas.viewPortposition,
+            viewPortCenter: zoneDatas.viewPortCenter,
+          },
+          { new: true }
+        );
+        if (!replaceZone)
+          return res.status(404).json({ message: "Zone not updated" });
+        else
+          return res.status(200).json({
+            message: "updated successfully",
+            zoneData: {
+              zoneName: replaceZone.zoneName,
+              points: replaceZone.zonePoints,
+              viewPortposition: replaceZone.viewPortposition,
+              viewPortCenter: replaceZone.viewPortCenter,
+            },
+          });
+      }
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+
+  static async deleteAZone(req: Request, res: Response): Promise<any> {
+    const organization = req.query.organization;
+    const zoneId = req.params.zoneId;
+    try {
+      const existingZone = await zoneSchema(organization).findOne({
+        zoneId: zoneId,
+        isArchive: false,
+      });
+      if (!existingZone) {
+        return res.status(404).json({ message: "Zone not found for the UUID" });
+      } else {
+        const deleteZone = await zoneSchema(organization).findOneAndUpdate(
+          { zoneId: zoneId, 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 singleZonePanelDatas(req: Request, res: Response): Promise<any> {
+    const organization = req.query.organization;
+    const zoneId = req.params.zoneId;
+
+    try {
+      const existingZone = await zoneSchema(organization)
+        .findOne({
+          zoneId: req.params.zoneId,
+          isArchive: false,
+        })
+        .select("panelOrder zoneName zonePoints lockedPanel");
+      if (!existingZone) {
+        return res.send({ message: "Zone not found for the UUID" });
+      } else {
+        const panelData = await panelSchema(organization).find({
+          zoneId: zoneId,
+          isArchive: false,
+        });
+        const zoneName = existingZone.zoneName as string;
+
+        const widgets = await Promise.all(
+          panelData.map(async (data) => {
+            const widgetDataArray = await widgetSchema(organization).find({
+              panelID: data._id,
+              isArchive: false,
+            });
+
+            return widgetDataArray.map((widgetData) => ({
+              id: widgetData.widgetID,
+              type: widgetData.elementType,
+              title: widgetData.widgetName,
+              panel: widgetData.widgetside,
+              data: widgetData.Data || [],
+            }));
+          })
+        );
+
+        const flattenedWidgets = widgets.flat();
+
+        const objectData = {
+          zoneName,
+          activeSides: existingZone.panelOrder || [],
+          panelOrder: existingZone.panelOrder || [],
+          lockedPanels: existingZone.lockedPanel || [],
+          points: existingZone.zonePoints || [],
+          widgets: flattenedWidgets,
+        };
+
+        return res.status(200).json(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 zoneId");
+
+      if (!Allzones || Allzones.length === 0) {
+        return res.status(404).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 ZoneData(req: Request, res: Response): Promise<any> {
+    try {
+      const organization = req.query.organization;
+      console.log("organization: ", organization);
+      const zoneId = req.params.zoneId;
+      console.log("zoneId: ", zoneId);
+      const findZone = await zoneSchema(organization).findOne({
+        zoneId: zoneId,
+      });
+      // .select("zoneName");
+      if (findZone) return res.status(200).json(findZone);
+    } 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 zoneId");
+
+  //     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);
+  //   }
+  // }
+}