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,
  cameraTypeAllList,
  getMix3dList,
  SYNC_INFO,
} from "@/request";
import saveAs from "@/util/file-serve";
import { ElMessage } from "element-plus";
import { user } from "@/store/user";
import { getCaseSceneList } from "@/store/case";

interface BaseScene {
  title: string;
  time: string;
  searchType: any;
  // type: SceneType;
  id: string;
}

// 只有当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;
  fusionTitle: any;
};

// 普通场景状态
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,
  SWSX1,
  SWSX,
}

// 模型场景状态
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, "searchType"> & {
    sceneName: string;
    status?: number;
    caseId?: number;
    deptId: string;
    snCode: string;
    cameraType: string;
    searchType: any;
    isObj: number;
    fusionTitle: any;
  }
>;
export const getScenePagging = async (params: ScenePaggingParams) => {
  const data = (await axios.get(getSceneList,{params})).data as PaggingRes<Scene>;

  return data;
};

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

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场景，需要较长时间，请耐心等待；");
  }
};

// 获取设备列表
export const getCameraTypeAllList = async () =>{
  let data = (await axios.get(cameraTypeAllList)).data as any;
  return data
}

// 获取多远融合列表
export const getMix3dPagging = async (params: ScenePaggingParams) => {
  const data = (await axios.post(getMix3dList, params)).data as PaggingRes<Scene>;

  return data;
};

// 获取同屏勘验信息
export const getSyncSceneInfo = async (scene: Scene, caseId: number) => {
  return (await axios.post<string>(SYNC_INFO, { caseId, num: scene.num }));
};

export const SceneTypePaths: { [key in SceneType]: string[] } = {
  [SceneType.SWKK]: [
    "/swkk/spg.html",
    "/swkk/epg.html",
    `/livestream/fd/criminal.html`,
  ],
  [SceneType.SWKJ]: ["/swkk/spg.html", "/swkk/epg.html"],
  [SceneType.DSFXJ]: ["/swkk/spg.html", "/swkk/epg.html"],
  [SceneType.SWSS]: ["/swss/index.html", "/swss/index.html"],
  [SceneType.SWMX]: import.meta.env.DEV
    ? ["/dev-code/index.html", "/dev-code/index.html"]
    : ["/code/index.html", "/code/index.html"],
  [SceneType.SWSSMX]: ["/swkk/spg.html", "/swkk/epg.html"],
  [SceneType.SWYDSS]: ["/swss/index.html", "/swss/index.html"],
  [SceneType.SWYDMX]: ["/swkk/spg.html", "/swkk/epg.html"],
};

const SceneTypeDesc: { [key in SceneType]: string } = {
  [SceneType.SWKK]: "八目",
  [SceneType.SWKJ]: "双目转台",
  [SceneType.SWSS]: "激光转台点云场景",
  [SceneType.SWMX]: "三维模型",
  [SceneType.SWSSMX]: "激光转台Mesh场景",
  [SceneType.SWYDSS]: "激光移动点云场景",
  [SceneType.SWYDMX]: "激光移动Mesh场景",
  // [SceneType.QJKK]: '全景看看',
};

export const getSWKKSyncLink = async (scene: Scene, caseId: number) => {
  console.log('scene', scene)
  const supportTypes = [SceneType.SWKJ, SceneType.SWSSMX, SceneType.SWYDMX];
  const kkScenes = supportTypes.includes(scene.sceneType)

  let msg: string | null = null;
  if (!kkScenes) {
    msg = `带看仅支持${supportTypes
      .map((type) => SceneTypeDesc[type])
      .join("、")}类型场景，请添加此类型场景。`;
  }
  if (msg) {
    ElMessage.error(msg);
    throw msg;
  }

  const url = new URL(SceneTypePaths[SceneType.SWKK][2], window.location.href.includes('localhost')?'https://test-mix3d.4dkankan.com/':window.location.href);
  const userInfo = user.value.info;
  const roomId = await getSyncSceneInfo(scene, caseId);
  const params = {
    vruserId: userInfo.userName,
    roomId: roomId.data,
    role: "leader",
    redirect: encodeURIComponent(location.href),
    name: userInfo.userName,
    m: scene.num,
  };
  for (const [name, val] of Object.entries(params)) {
    url.searchParams.append(name, val || "");
  }
  return url;
};