Dwinzo-Backend-V0.0/src/api-server/controller/simulation/assetsFloorservice.ts

import { Request, Response } from "express";
import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
import actionModel from "../../../shared/model/simulation/actionmodel.ts";
import triggerModel from "../../../shared/model/simulation/triggersmodel.ts";
import pointModel from "../../../shared/model/builder/assets/assetPoint-Model.ts";
import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";

export class assetsFloorservice {
  // static async setFloorassets(req: Request, res: Response): Promise<any> {
  //   try {
  //     const {
  //       modelUuid,
  //       modelName,
  //       position,
  //       modelfileID,
  //       rotation,
  //       isLocked,
  //       isVisible,
  //       organization,
  //       eventData,
  //     } = req.body;
  //     console.log("req.body: ", req.body);

  //     const findvalue = await assetModel(organization).findOne({
  //       modelUuid,
  //       // modelName,
  //       isArchive: false,
  //     });
  //     const checkpointType = await pointModel(organization).findOne({
  //       modelfileID: modelfileID,
  //       isArchive: false,
  //     });

  //     if (findvalue) {
  //       const updatevalue = await assetModel(organization).findOneAndUpdate(
  //         { modelUuid, isArchive: false },
  //         {
  //           modelName: modelName,
  //           position,
  //           rotation,
  //           isVisible,
  //           isLocked,
  //         },
  //         { new: true }
  //       );
  //       return res.status(201).json(updatevalue);
  //     } else {
  //       let assetData: any = {
  //         modelUuid,
  //         modelName,
  //         position,
  //         modelfileID,
  //         rotation,
  //         isLocked,
  //         isVisible,
  //       };

  //       console.log("eventData: ", eventData);
  //       if (eventData) {
  //         if (eventData.type === "Conveyor") {
  //           assetData.speed = eventData.speed;
  //         } else if (eventData.type === "Vehicle") {
  //           assetData.speed = eventData.points.speed;
  //           if (!eventData.points) {
  //             return res
  //               .status(400)
  //               .json({ message: "Vehicle points must be a single object" });
  //           }
  //           // if (eventData.points.rotation) {
  //           //   return res.status(400).json({
  //           //     message: "Rotation is not allowed for Vehicle points",
  //           //   });
  //           // }

  //           if (eventData.points.triggers) {
  //             return res.status(400).json({
  //               message: "triggers is not allowed for Vehicle points",
  //             });
  //           }
  //         }
  //         // else if(eventData.type === "ArmBot"){
  //         //   assetData.speed = eventData.position;
  //         // }else if(eventData.type === "StaticMachine"){
  //         //   assetData.speed = eventData.position;
  //         // }

  //         assetData.points = eventData.points;
  //         assetData.type = eventData.type;
  //       }
  //       const assetDoc = await assetModel(organization).create(assetData);
  //       await assetDoc.save();

  //       return res.status(201).json({
  //         message: "Model stored successfully",
  //         modelId: assetDoc._id,
  //       });
  //     }
  //   } catch (error) {
  //     console.error("Error creating flooritems:", error);
  //     res.status(500).json({ message: "Failed to create flooritems" });
  //   }
  // }
  // static async getFloorItems(req: Request, res: Response): Promise<any> {
  //   try {
  //     const { organization } = req.params;
  //     const findValues = await assetModel(organization)
  //       .find({ isArchive: false })
  //       .select("-_id -isArchive");

  //     if (!findValues || findValues.length === 0) {
  //       return res.status(200).json({ message: "floorItems not found" });
  //     }

  //     const response = findValues.map((item) => {
  //       // console.log("item: ", item);
  //       // console.log("item: ", item.type);
  //       // console.log('findValues: ', findValues);
  //       // console.log("item.points: ", item.points);
  //       const responseItem: any = {
  //         modelUuid: item.modelUuid,
  //         modelName: item.modelName,
  //         position: item.position,
  //         rotation: item.rotation,
  //         modelfileID: item.modelfileID,
  //         isLocked: item.isLocked,
  //         isVisible: item.isVisible,
  //       };
  //       if (item.type === "Conveyor" && item.points.length > 0) {
  //         responseItem.eventData = {
  //           speed: item.speed,
  //           points: item.points,
  //           type: item.type,
  //         };
  //       }

  //       if (item.type === "Vehicle" && item.points) {
  //         responseItem.eventData = {
  //           type: item.type,
  //           points: item.points,
  //         };
  //       }
  //       if (item.type === "ArmBot" && item.points) {
  //         responseItem.eventData = {
  //           type: item.type,
  //           points: item.points,
  //         };
  //       }
  //       if (item.type === "StaticMachine" && item.points) {
  //         responseItem.eventData = {
  //           type: item.type,
  //           points: item.points,
  //         };
  //       }
  //       return responseItem;
  //     });

  //     return res.status(200).json(response);
  //   } catch (error) {
  //     res.status(500).json({ error: "Failed to get flooritems" });
  //   }
  // }
  // static async deleteFloorItems(req: Request, res: Response): Promise<any> {
  //   try {
  //     const { modelUuid, modelName, organization } = req.body;

  //     const findValue = await assetModel(organization).findOneAndDelete({
  //       modelUuid: modelUuid,
  //       modelName: modelName,
  //       isArchive: false,
  //     });
  //     if (!findValue) {
  //       res.status(200).json("user not found");
  //     } else {
  //       res.status(201).json(findValue);
  //     }
  //   } catch (error) {
  //     res.status(500).json({ error: "Failed to get flooritems" });
  //   }
  // }
  static async updateAssetPositionRotation(
    req: Request,
    res: Response
  ): Promise<any> {
    try {
      const {
        modelUuid,
        modelName,
        position,
        modelfileID,
        rotation,
        isLocked,
        isVisible,
        organization,
        // eventData, // Optional
      } = req.body;

      const existingAsset = await assetModel(organization).findOne({
        modelUuid: modelUuid,
        isArchive: false,
      });
      if (!existingAsset) return res.send("Asset not found");
      const updateAsset = await assetModel(organization).updateMany(
        { modelUuid: modelUuid, modelName: modelName, isArchive: false },
        {
          position: position,
          rotation: rotation,
          isVisible: isVisible,
          isLocked: isLocked,
        }
      );
      if (updateAsset)
        return res.status(200).json({ message: "Asset updated successfully" });
    } catch (error: any) {
      return res.send(error.message);
    }
  }
  static async replaceEventDatas(req: Request, res: Response): Promise<any> {
    const { organization, modelUuid, eventData } = req.body;
    try {
      const existingModel = await assetModel(organization).findOne({
        modelUuid: modelUuid,
        isArchive: false,
      });
      if (!existingModel)
        return res.json({ message: "Model not for this UUID" });
      else {
        let speed;
        if (existingModel.type === "Conveyor") {
          speed = eventData?.speed;
        }
        const updatedModel = await assetModel(organization).findOneAndUpdate(
          { modelUuid, isArchive: false },
          {
            points: eventData?.points,
            type: eventData?.type || existingModel?.type,
          },
          { new: true }
        );

        if (updatedModel)
          return res.status(200).json({ message: "Data updated successfully" });
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }
  //update setfoolrassets//getFloorItems//deleteFloorItems.........
  static async setFloorassets(req: Request, res: Response): Promise<any> {
    try {
      const {
        modelUuid,
        modelName,
        position,
        modelfileID,
        rotation,
        isLocked,
        isVisible,
        organization,
        eventData,
      } = req.body;
      console.log("req.body: ", req.body);

      const findvalue = await assetModel(organization).findOne({
        modelUuid,
        // modelName,
        isArchive: false,
      });
      const checkpointType = await pointModel(organization).findOne({
        modelfileID: modelfileID,
        isArchive: false,
      });

      if (findvalue) {
        const updatevalue = await assetModel(organization).findOneAndUpdate(
          { modelUuid, isArchive: false },
          {
            modelName: modelName,
            position,
            rotation,
            isVisible,
            isLocked,
          },
          { new: true }
        );
        return res.status(201).json(updatevalue);
      } else {
        let assetData: any = {
          modelUuid,
          modelName,
          position,
          modelfileID,
          rotation,
          isLocked,
          isVisible,
          eventData
        };

        console.log("eventData: ", eventData);
        if (eventData) {
          if (eventData.type === "Conveyor") {
            assetData.speed = eventData.speed;
          } else if (eventData.type === "Vehicle") {
            assetData.speed = eventData.points.speed;
            if (!eventData.points) {
              return res
                .status(400)
                .json({ message: "Vehicle points must be a single object" });
            }
            // if (eventData.points.rotation) {
            //   return res.status(400).json({
            //     message: "Rotation is not allowed for Vehicle points",
            //   });
            // }

            if (eventData.points.triggers) {
              return res.status(400).json({
                message: "triggers is not allowed for Vehicle points",
              });
            }
          }
          // else if(eventData.type === "ArmBot"){
          //   assetData.speed = eventData.position;
          // }else if(eventData.type === "StaticMachine"){
          //   assetData.speed = eventData.position;
          // }

          assetData.points = eventData.points;
          assetData.type = eventData.type;
        }
        const assetDoc = await assetModel(organization).create(assetData);
        await assetDoc.save();

        return res.status(201).json({
          message: "Model stored successfully",
          modelId: assetDoc._id,
        });
      }
    } catch (error) {
      console.error("Error creating flooritems:", error);
      res.status(500).json({ message: "Failed to create flooritems" });
    }
  }
  static async getFloorItems(req: Request, res: Response): Promise<any> {
    try {
      const { organization } = req.params;
      const findValues = await assetModel(organization)
        .find({ isArchive: false })
        .select("-_id -isArchive");

      if (!findValues || findValues.length === 0) {
        return res.status(200).json({ message: "floorItems not found" });
      }

      const response = findValues.map((item) => {
        // console.log("item: ", item);
        // console.log("item: ", item.type);
        // console.log('findValues: ', findValues);
        // console.log("item.points: ", item.points);
        const responseItem: any = {
          modelUuid: item.modelUuid,
          modelName: item.modelName,
          position: item.position,
          rotation: item.rotation,
          modelfileID: item.modelfileID,
          isLocked: item.isLocked,
          isVisible: item.isVisible,
          eventData: item.eventData,
        };
        // if (item.type === "Conveyor" && item.points.length > 0) {
        //   responseItem.eventData = {
        //     speed: item.speed,
        //     points: item.points,
        //     type: item.type,
        //   };
        // }

        // if (item.type === "Vehicle" && item.points) {
        //   responseItem.eventData = {
        //     type: item.type,
        //     points: item.points,
        //   };
        // }
        // if (item.type === "ArmBot" && item.points) {
        //   responseItem.eventData = {
        //     type: item.type,
        //     points: item.points,
        //   };
        // }
        // if (item.type === "StaticMachine" && item.points) {
        //   responseItem.eventData = {
        //     type: item.type,
        //     points: item.points,
        //   };
        // }
        return responseItem;
      });

      // console.log('response: ', response);
      return res.status(200).json(response);
    } catch (error) {
      res.status(500).json({ error: "Failed to get flooritems" });
    }
  }
  static async deleteFloorItems(req: Request, res: Response): Promise<any> {
    try {
      const { modelUuid, modelName, organization } = req.body;
      console.log('req.body:', req.body);
  
      const asset = await assetModel(organization).findOne({
        modelUuid,
        modelName,
        isArchive: false,
      });
  
      if (!asset) {
        return res.status(404).json({ message: "Model not found" });
      }
  
      const archivedAsset = await assetModel(organization).findOneAndUpdate(
        { modelUuid, modelName },
        { $set: { isArchive: true } },
        { new: true }
      );
  
      if (!archivedAsset) {
        return res.status(500).json({ message: "Failed to archive asset" });
      }
  
      const updatedEvents = await EventsDataModel(organization).updateMany(
        { modelUuid },
        { $set: { isArchive: true } }
      );
  
      console.log("Archived asset:", archivedAsset);
      console.log("Updated events:", updatedEvents.modifiedCount);
  
      return res.status(200).json({ message: "delete Asset successfully" });
    } catch (error) {
      console.error("Error deleting floor items:", error);
      return res.status(500).json({ error: "Failed to delete floor items" });
    }
  }
}