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

import { Request, Response } from "express";
// import assetModel from "../../../shared/model/assets/flooritems-Model.ts";
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";

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

      const findvalue = await assetModel(organization).findOne({
        modeluuid,
        modelname,
        isArchive: false,
      });

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

        if (eventData) {
          let pointRefs: any[] = [];

          if (Array.isArray(eventData.points)) {
            for (const point of eventData.points) {
              let actionRefs: any[] = [];
              let triggerRefs: any[] = [];

              if (Array.isArray(point.actions)) {
                for (const action of point.actions) {
                  const actionDoc = await actionModel(organization).create({
                    pointsUUID: point.uuid,
                    isArchive: false,
                    uuid: action.uuid,
                    name: action.name,
                    type: action.type,
                    material: action.material,
                    delay: action.delay,
                    spawn_Interval: action.spawn_Interval,
                  });
                  await actionDoc.save();
                  actionRefs.push(actionDoc._id);
                }
              }

              if (Array.isArray(point.triggers)) {
                for (const trigger of point.triggers) {
                  const triggerDoc = await triggerModel(organization).create({
                    pointsUUID: point.uuid,
                    isArchive: false,
                    uuid: trigger.uuid,
                    name: trigger.name,
                    type: trigger.type,
                    bufferTime: trigger.bufferTime,
                  });
                  await triggerDoc.save();
                  triggerRefs.push(triggerDoc._id);
                }
              }
              // point.connections{
              //   source:{

              //   }
              // }
              pointRefs.push({
                uuid: point.uuid,
                position: point.position || [],
                rotation: point.rotation || [],
                actions: actionRefs,
                triggers: triggerRefs,
                connections: point.connections,
              });
            }
          }

          assetData.speed = eventData.speed;
          assetData.type = eventData.type;
          assetData.points = pointRefs;
        }

        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")
        .populate({
          path: "points",
          select: "-_id",
        })
        .populate({
          path: "points.actions",
          model: actionModel(organization),
          select: "-__v -_id -isArchive -pointsUUID -createdAt -updatedAt",
        })
        .populate({
          path: "points.triggers",
          model: triggerModel(organization),
          select: "-__v -_id -isArchive -pointsUUID -createdAt -updatedAt",
        });
      if (!findValues) {
        res.status(200).json("floorItems not found");
      } else {
        return res.status(200).json(
          findValues.map((item) => {
            let responseItem: any = {
              modeluuid: item.modeluuid,
              modelname: item.modelname,
              position: item.position,
              modelfileID: item.modelfileID,
              rotation: item.rotation,
              isLocked: item.isLocked,
              isVisible: item.isVisible,
            };

            if (item.points.length > 1) {
              responseItem.eventData = {
                speed: item.speed,
                points: item.points,
                type: item.type,
              };
            }

            return responseItem;
          })
        );
      }
    } catch (error) {
      console.error("Error get flooritems:", 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) {
      console.error("Error get flooritems:", 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 updateActionsDatas(req: Request, res: Response) {}
}