Dwinzo-Backend-V0.0/src/shared/services/builder/wallService.ts

import wallItemModel from "../../../shared/model/builder/assets/wallitems-Model.ts";
import { existingUser } from "../helpers/v1projecthelperFns.ts";
interface IWallSetupData {
  modelUuid: string;
  modelName: string;
  type: string;
  csgposition: [];
  csgscale: [];
  position: [];
  quaternion: [];
  scale: [];
  organization: string;
  projectId: string;
  userId: string;
}
interface IWallGet {
  userId: string;
  organization: string;
  projectId: string;
}
interface IWallDelete {
  userId: string;
  modelUuid: string;
  modelName: string;
  organization: string;
  projectId: string;
}
interface IWallItemResult {
  data?: Object;
  status: string;
}
export class WallItems {
  static async setWallItems(data: IWallSetupData): Promise<IWallItemResult> {
    try {
      const {
        userId,
        modelUuid,
        modelName,
        position,
        type,
        csgposition,
        csgscale,
        quaternion,
        scale,
        projectId,
        organization,
      } = data;
      const UserExists = await existingUser(userId, organization);
      if (!UserExists) return { status: "User not found" };
      const findvalue = await wallItemModel(organization).findOne({
        modelUuid: modelUuid,
        isArchive: false,
      });

      if (findvalue) {
        const updatevalue = await wallItemModel(organization).findOneAndUpdate(
          { modelUuid: modelUuid, projectId: projectId, isArchive: false },
          {
            modelName,
            position,
            type,
            csgposition,
            csgscale,
            quaternion,
            scale,
          },
          { new: true }
        );
        return {
          status: "Updated successfully",
          data: updatevalue,
        };
      } else {
        const newValue = await wallItemModel(organization).create({
          modelUuid,
          modelName,
          position,
          type,
          projectId,
          csgposition,
          csgscale,
          quaternion,
          scale,
        });
        return {
          status: "wall Item created successfully",
          data: newValue,
        };
      }
    } catch (error: unknown) {
      if (error instanceof Error) {
        return {
          status: error.message,
        };
      } else {
        return {
          status: "An unexpected error occurred",
        };
      }
    }
  }
  static async getWallItems(data: IWallGet) {
    try {
      const { organization, userId, projectId } = data;
      const UserExists = await existingUser(userId, organization);
      if (!UserExists) return { status: "User not found" };
      const findValue = await wallItemModel(organization).find({
        projectId: projectId,
        isArchive: false,
      });
      if (!findValue) {
        return {
          status: "wallitems not found",
        };
      } else {
        return {
          status: "Success",
          data: findValue,
        };
      }
    } catch (error: unknown) {
      if (error instanceof Error) {
        return {
          status: error.message,
        };
      } else {
        return {
          status: "An unexpected error occurred",
        };
      }
    }
  }
  static async deleteWallItems(data: IWallDelete): Promise<IWallItemResult> {
    try {
      const { modelUuid, modelName, organization, userId, projectId } = data;
      const UserExists = await existingUser(userId, organization);
      if (!UserExists) return { status: "User not found" };
      const findValue = await wallItemModel(organization).findOneAndDelete({
        modelUuid: modelUuid,
        modelName: modelName,
        projectId: projectId,
        isArchive: false,
      });
      if (!findValue) {
        return {
          status: "model not found",
        };
      } else {
        return {
          status: "Success",
          data: findValue,
        };
      }
    } catch (error: unknown) {
      if (error instanceof Error) {
        return {
          status: error.message,
        };
      } else {
        return {
          status: "An unexpected error occurred",
        };
      }
    }
  }
}