fuse-code/src/api/fuse-model.ts

import axios from "./instance";
import {
  FUSE_MODEL_LIST,
  FUSE_INSERT_MODEL,
  FUSE_UPDATE_MODEL,
  FUSE_DELETE_MODEL,
} from "./constant";
import { params } from "@/env";

import { Scene, SceneStatus, SceneType } from "./scene";

export interface FuseModelAttrs {
  show: boolean;
  scale: number;
  opacity: number;
  bottom: number;
  position: SceneLocalPos;
  rotation: SceneLocalPos;
}

export interface FuseModel extends FuseModelAttrs {
  id: string;
  modelId: number;
  fusionNumId: number;
  url: string[];
  title: string;
  fusionId: number;
  modelType: string;
  type: SceneType;
  size: number;
  status: SceneStatus;
  raw?: any;
  time: string;
}

interface ServiceFuseModel {
  fusionId: number;
  hide: number;
  opacity: number;
  bottom: number;
  fusionNumId: number;
  transform: {
    position: SceneLocalPos;
    rotation: SceneLocalPos;
    scale: [number, number, number];
  };
  sceneData: Scene;
}

export const getSceneUrl = (sceneData: Scene) => {
  let url: any = [""];
  console.log(sceneData, sceneData.type);
  if (
    [SceneType.SWSS, SceneType.SWYDSS].includes(sceneData.type)
  ) {
    url = [sceneData.num];
  } else {
    switch (sceneData.modelDateType) {
      case "3dgs":
        url = sceneData.model3dgsUrl;
        break;
      case "shp":
        url = sceneData.modelShpUrl;
        break;
      default:
        url = sceneData.modelGlbUrl;
    }
    try {
      url = JSON.parse(url);
    } catch (e) {
      console.error(url, e);
    }
  }
  return url
}

const serviceToLocal = (
  serviceModel: ServiceFuseModel,
  test = false
): FuseModel => {

  return {
    show: true,
    scale: serviceModel.transform.scale[0],
    opacity: serviceModel.opacity || 1,
    bottom: serviceModel.bottom || 0,
    fusionNumId: serviceModel.fusionNumId,
    modelType: serviceModel.sceneData?.modelDateType,
    position: serviceModel.transform.position,
    rotation: serviceModel.transform.rotation,
    id: serviceModel.fusionNumId.toString(),
    url: getSceneUrl(serviceModel.sceneData),
    title: serviceModel.sceneData
      ? serviceModel.sceneData?.name ||
        serviceModel.sceneData.sceneName ||
        serviceModel.sceneData.modelTitle
      : "-",
    modelId: serviceModel.sceneData?.modelId,
    fusionId: serviceModel.fusionId,
    type: serviceModel.sceneData?.type,
    size: serviceModel.sceneData?.modelSize,
    raw: serviceModel.sceneData,
    time: serviceModel.sceneData?.createTime,
    status: serviceModel.sceneData
      ? serviceModel.sceneData.status
      : SceneStatus.ERR,
  };
};

const localToService = (
  model: FuseModel
): Omit<ServiceFuseModel, "sceneData"> => ({
  fusionId: model.fusionId,
  hide: Number(!model.show),
  opacity: model.opacity,
  fusionNumId: model.fusionNumId,
  bottom: model.bottom,
  transform: {
    position: model.position,
    rotation: model.rotation,
    scale: [model.scale, model.scale, model.scale],
  },
});

export type FuseModels = FuseModel[];

export const fetchFuseModels = async () => {
  const serviceModels = await axios.get<ServiceFuseModel[]>(FUSE_MODEL_LIST, {
    params: { caseId: params.caseId },
  });
  console.error(
    serviceModels.map((item, index) => serviceToLocal(item, index == 0))
  );
  return serviceModels.map((item, index) => serviceToLocal(item, index == 0));
};

export const postAddFuseModel = async (model: FuseModel) => {
  const upload = localToService(model);
  const serviceModel = await axios<ServiceFuseModel>({
    url: FUSE_INSERT_MODEL,
    method: "POST",
    data: {
      caseId: params.caseId,
      modelId: model.modelId,
      hide: upload.hide,
      transform: upload.transform,
      opacity: upload.opacity,
      bottom: upload.bottom,
    },
  });
  return serviceToLocal(serviceModel);
};

export const postUpdateFuseModels = (model: FuseModel) => {
  const upload = localToService(model);
  return axios.post<undefined>(FUSE_UPDATE_MODEL, {
    fusionNumId: upload.fusionNumId,
    hide: upload.hide,
    transform: upload.transform,
    opacity: upload.opacity,
    bottom: upload.bottom,
  });
};

export const postDeleteFuseModel = (model: FuseModel) => {
  return axios.post<undefined>(FUSE_DELETE_MODEL, {
    fusionNumId: model.fusionNumId,
  });
};