Dwinzo-Backend-V0.0/src/api-server/V1/v1Controllers/builderController/v1assetController.ts

import { Response } from "express";

import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
  deleteAssetModel,
  getFloorItems,
  replaceEventDatas,
  setAssetModel,
  updateAssetPositionRotation,
} from "../../../../shared/services/builder/assetService.ts";

export const CreateAssetController = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { organization, userId } = req.user || {};
    const {
      modelUuid,
      modelName,
      position,
      rotation,
      eventData,
      assetId,
      isLocked,
      isVisible,
      projectId,
      versionId,
    } = req.body;
    if (!organization || !userId || !projectId || !modelUuid || !versionId) {
      res.status(400).json({
        message: "All fields are required",
      });
      return;
    }
    const data = {
      organization,
      userId,
      modelUuid,
      modelName,
      position,
      rotation,
      eventData,
      assetId,
      isLocked,
      isVisible,
      projectId,
      versionId,
    };
    const result = await setAssetModel(data);

    switch (result.status) {
      case "User not found":
        res.status(404).json({
          message: "User not found",
        });
        break;
      case "Project not found":
        res.status(404).json({
          message: "Project not found",
        });
        break;
      case "Version Data not found":
        res.status(404).json({
          message: "Version Data not found",
        });
        break;
      case "Updated successfully":
        res.status(200).json(result.data);
        break;
      case "Success":
        res.status(200).json({
          message: "Model stored successfully",
        });
        break;
      default:
        res.status(500).json({
          message: "Internal server error",
        });
        break;
    }
  } catch (error) {
    res.status(500).json({
      message: "Unknown error",
    });
  }
};
export const DeleteAssetController = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { organization, userId } = req.user || {};
    const { modelUuid, modelName, projectId, versionId } = req.body;
    if (
      !organization ||
      !userId ||
      !modelUuid ||
      !projectId ||
      !modelName ||
      !versionId
    ) {
      res.status(400).json({
        message: "All fields are required",
      });
      return;
    }
    const result = await deleteAssetModel({
      organization,
      modelName,
      modelUuid,
      projectId,
      versionId,
      userId,
    });

    switch (result.status) {
      case "User not found":
        res.status(404).json({
          message: "User not found",
        });
        break;
      case "Project not found":
        res.status(404).json({
          message: "Project not found",
        });
        break;
      case "Version Data not found":
        res.status(404).json({
          message: "Version Data not found",
        });
        break;
      case "model not found":
        res.status(404).json({
          message: "Model not found",
        });
        break;
      case "Failed to archive asset":
        res.status(200).json({
          message: "Failed to archive asset",
        });
        break;
      case "Success":
        res.status(200).json({
          message: "Asset Deleted successfully",
        });
        break;
      default:
        res.status(500).json({
          message: "Internal server error",
        });
        break;
    }
  } catch (error) {
    res.status(500).json({
      message: "Unknown error",
    });
  }
};
export const GetAssetController = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { organization, userId } = req.user || {};
    const { projectId,versionId } = req.params;
    if (!organization || !userId || !projectId) {
      res.status(400).json({
        message: "All fields are required",
      });
      return;
    }
    const result = await getFloorItems({
      organization,
      projectId,
      userId,versionId,
    });

    switch (result.status) {
      case "User not found":
        res.status(404).json({
          message: "User not found",
        });
        break;
      case "Project not found":
        res.status(404).json({
          message: "Project not found",
        });
        break;
      case "Version Data not found":
        res.status(404).json({
          message: "Version Data not found",
        });
        break;
      case "floorItems not found":
        res.status(200).json([]);
        break;
      case "Success":
        res.status(200).json(result.data);
        break;
      default:
        res.status(500).json({
          message: "Internal server error",
        });
        break;
    }
  } catch (error) {
    res.status(500).json({
      message: "Unknown error",
    });
  }
};
export const ReplaceEventDataController = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { organization, userId } = req.user || {};
    const { modelUuid, eventData, projectId, versionId } = req.body;
    if (
      !organization ||
      !userId ||
      !projectId ||
      !modelUuid ||
      !versionId ||
      !eventData
    ) {
      res.status(400).json({
        message: "All fields are required",
      });
      return;
    }
    const result = await replaceEventDatas({
      modelUuid,
      organization,
      eventData,
      versionId,
      projectId,
      userId,
    });

    switch (result.status) {
      case "User not found":
        res.status(404).json({
          message: "User not found",
        });
        break;
      case "Project not found":
        res.status(404).json({
          message: "Project not found",
        });
        break;
      case "Version Data not found":
        res.status(404).json({
          message: "Version Data not found",
        });
        break;
      case "Model not for this UUID":
        res.status(404).json({
          message: "Model not for this UUID",
        });
        break;
      case "Success":
        res.status(200).json({ message: "Data updated successfully" });
        break;
      default:
        res.status(500).json({
          message: "Internal server error",
        });
        break;
    }
  } catch (error) {
    res.status(500).json({
      message: "Unknown error",
    });
  }
};
export const AssetUpdatePosRotController = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { organization, userId } = req.user || {};
    const {
      modelUuid,
      modelName,
      position,
      rotation,
      isLocked,
      isVisible,
      projectId,
      versionId,
    } = req.body;
    if (
      !organization ||
      !userId ||
      !isLocked ||
      !isVisible ||
      !position ||
      !rotation ||
      !modelName ||
      !projectId ||
      !versionId ||
      !modelUuid
    ) {
      res.status(400).json({
        message: "All fields are required",
      });
      return;
    }
    const result = await updateAssetPositionRotation({
      organization,
      userId,
      modelUuid,
      modelName,
      position,
      rotation,
      isLocked,
      isVisible,
      projectId,
      versionId,
    });

    switch (result.status) {
      case "User not found":
        res.status(404).json({
          message: "User not found",
        });
        break;
      case "Project not found":
        res.status(404).json({
          message: "Project not found",
        });
        break;
      case "Version Data not found":
        res.status(404).json({
          message: "Version Data not found",
        });
        break;
      case "Asset not found":
        res.status(404).json({
          message: "Asset not found",
        });
        break;
      case "Success":
        res.status(200).json({ message: "Asset updated successfully" });
        break;
      default:
        res.status(500).json({
          message: "Internal server error",
        });
        break;
    }
  } catch (error) {
    res.status(500).json({
      message: "Unknown error",
    });
  }
};