public-fuse/src/store/scene.ts

import { confirm } from "@/helper/message";
import {
  PaggingReq,
  PaggingRes,
  axios,
  cancelUModel,
  checkGenMeshScene,
  copyModel,
  copyScene,
  delScene,
  deleteModel,
  downModelHash,
  downSceneHash,
  downloadSceneList,
  genMeshSceneByCloud,
  getModelRunProgress,
  getModelSceneList,
  getSceneList,
  updateModelScene,
  uploadModel,
} from "@/request";
import saveAs from "@/util/file-serve";
import { ElMessage } from "element-plus";

interface BaseScene {
  title: string;
  time: string;
  type: SceneType;
  id: string;
  uploadStatus: UploadStatus;
  fileMd5: string;
  fileType: ZipType;
}

export enum ZipType {
  f_e57 = 0,
  f_e57_s = 1,
  n_e57 = 2,
  a_az = 3,
  m_obj = 4,
  m_cot = 5,
  m_qx = 6,
}
export const ZipTypeDesc = {
  [ZipType.f_e57]: "法如e57",
  [ZipType.f_e57_s]: "法如e57加全景图",
  [ZipType.n_e57]: "标准e57",
  [ZipType.a_az]: "AZ系列数据包",
  [ZipType.m_obj]: "模型",
  [ZipType.m_cot]: "点云",
  [ZipType.m_qx]: "倾斜模型",
};

// 只有当location 为4 时，才能生成obj
export enum LocationEnum {
  Scene_Location_Slam, //slam\n" +
  Scene_Location_SFM, //sfm\n" +F
  Scene_Location_SFMAI, //SFM + AI\n" +
  Scene_Location_MutiFloor, //多楼层\n" +
  Scene_Location_PointCloud, //点云\n" +
  Scene_Location_SLAMPoint, //slam实时拍\n" +
  Scene_Location_SLAMPointAndSFMAI, //slam实时拍+站点\n" +
}

export type QuoteScene = BaseScene & {
  hasSynchronized: boolean;
  sceneNum: string;
  sceneName: string;
  createTime: string;
  vrLink: string;
  num: string;
  snCode: string;
  location: LocationEnum;
  viewCount: number;
  status: QuoteSceneStatus;
};

export enum UploadStatus {
  ING = 0,
  SUCCESS = 1,
  ERRPR = -1,
}

export const UploadStatusDesc = {
  [UploadStatus.ING]: "上传中",
  [UploadStatus.SUCCESS]: "上传成功",
  [UploadStatus.ERRPR]: "上传失败",
};

// 普通场景状态
export enum QuoteSceneStatus {
  DEL = -1,
  RUN = 0,
  ERR = 1,
  QUEUE = 5,
  SUCCESS = 2,
  ARCHIVE = 3,
  RERUN = 4,
}

export interface ModelScene extends BaseScene {
  modelTitle: string;
  renderType: string;
  modelId: number;
  createStatus: ModelSceneStatus;
  fileNewName: string;
  modelSize: string;
  modelDateType: string;
  progress?: number;

  createTime: string;
}

export type Scene = QuoteScene | ModelScene;

export enum SceneType {
  SWKK,
  SWKJ,
  SWSS,
  SWMX,
  SWSSMX,

  SWYDSS,
  SWYDMX,

  C_SWSS,
  C_SWKK,
}

// 模型场景状态
export enum ModelSceneStatus {
  ERR = -1,
  RUN = 0,
  REV = 2,
  SUCCESS = 1,
  CANCEL = -2,
}

const downHash = async (res: string, name: string) => {
  if (res.includes("code")) {
    ElMessage.error(JSON.parse(res).message);
  } else {
    await saveAs(new Blob([res], { type: "text/plain" }), name + "-hash.txt");
  }
};

export const setModelScene = (scene: ModelScene) =>
  axios.post(updateModelScene, {
    modelId: scene.modelId,
    modelTitle: scene.modelTitle,
    renderType: scene.renderType,
  });

export const cancelUploadModelScene = (scene: ModelScene) =>
  axios.get(cancelUModel, { params: { modelId: scene.modelId } });

export const delModelScene = (scene: ModelScene) =>
  axios.post(deleteModel, { modelId: scene.modelId });

export const copyModelScene = (scene: ModelScene) =>
  axios.post(copyModel, { modelId: scene.modelId });

export const downModelSceneHash = async (scene: ModelScene) => {
  const res = (await axios.get(downModelHash, {
    params: { modelId: scene.modelId, ingoreRes: true },
    responseType: "text",
  })) as string;
  await downHash(res, scene.modelTitle);
};

export const uploadModelScene = async (
  file: File,
  progressCallback: (progress: number) => void
) => {
  let done = false;
  await axios<undefined>({
    method: "POST",
    url: uploadModel,
    data: { file },
    onUploadProgress(event: any) {
      if (!done) {
        const p = Math.round((event.loaded / event.total) * 100);
        if (p === 100) {
          progressCallback(0);
        } else {
          progressCallback(p || 0);
        }
        console.log("进度：", p);
      }
    },
  });
  console.log("上传完成");
  done = true;
  progressCallback(0);
};
export const getModelSceneStatus = async (scene: ModelScene) => {
  const progress = (
    await axios.get<number>(getModelRunProgress, {
      params: { modelId: scene.modelId },
    })
  ).data;

  return {
    progress,
    status:
      progress >= 100
        ? ModelSceneStatus.SUCCESS
        : progress < 0
        ? ModelSceneStatus.ERR
        : ModelSceneStatus.RUN,
  };
};

// *-----公用

type ScenePaggingParams = PaggingReq<
  Pick<BaseScene, "type"> & {
    modelTitle: string;
    sceneName: string;
    status?: number;
    caseId?: number;
    deptId: string;
    snCode: string;
  }
>;
export const getScenePagging = async (params: ScenePaggingParams) => {
  const data = (
    await axios.get(
      params.type === SceneType.SWMX ? getModelSceneList : getSceneList,
      {
        params,
      }
    )
  ).data as PaggingRes<Scene>;

  return data;
};

export const delQuoteScene = (scene: QuoteScene) =>
  axios.get(delScene, { params: { num: scene.num, uploadId: scene.id } });

export const copyQuoteScene = (scene: QuoteScene) =>
  axios.post(copyScene, { num: scene.num });

export const downQuoteSceneHash = async (scene: QuoteScene) => {
  const res = (await axios.get(downSceneHash, {
    params: { num: scene.num, ingoreRes: true, type: scene.type },
    responseType: "text",
  })) as any;
  await downHash(res, scene.title);
};

export type QueryDownloadQuoteSceneParams = PaggingReq<{
  deptId: string;
  userName: string;
  nickName: string;
  createTime: string;
  sceneTitle: string;
  sceneNum: string;
  snCode: string;
}>;

export type DownloadQuoteSceneLog = {
  id: number;
  sceneNum: string;
  sceneTitle: string;
  userName: string;
  nickName: string;
  snCode: string;
  deptLevelStr: string;
  deptName: string;
  deptId: string;
  createTime: string;
};
export const getDownloadQuoteScene = async (
  params: Omit<QueryDownloadQuoteSceneParams, "createTime"> & {
    startCreateTime: string | null;
    endCreateTime: string | null;
  }
) =>
  (await axios.post(downloadSceneList, params))
    .data as PaggingRes<DownloadQuoteSceneLog>;

export const genMeshScene = async (scene: QuoteScene) => {
  const res = (await axios.post(checkGenMeshScene, { id: scene.id })).data;
  if (res?.buildObjStatus === 2) {
    ElMessage.error("Mesh场景正在计算中，请耐心等待。");
  } else if (
    res?.buildObjStatus !== 1 ||
    (await confirm("重新生成obj，Mesh场景将覆盖现有信息，确定要重新生成吗？"))
  ) {
    await axios.post(genMeshSceneByCloud, { id: scene.id });
    ElMessage.success("生成obj将同时生成Mesh场景，需要较长时间，请耐心等待；");
  }
};