fuse-code/src/api/tagging-position.ts

import axios from './instance'
import { 
  TAGGING_POINT_LIST,
  DELETE_TAGGING_POINT,
  UPDATE_TAGGING_POINT,
  INSERT_TAGGING_POINT
} from './constant'

import type { FuseModel } from './fuse-model'
import type { Tagging } from './tagging'
import { Tagging3DProps } from '@/sdk'

interface ServicePosition {
  "tagPointId": number,
  "tagId": number,
  "fusionNumId": number
  "modelId"?: number
  "tagPoint": string,
  normal: string
  
  globalVisibility: number
  type: string,
  mat: string
  fontSize: number,
  lineHeight: number,
  visibilityRange: number
  pose?: string;
  
}

export enum TaggingPositionType {
  '2d' = '2d',
  '3d' = '3d'
}
export interface TaggingPosition {
  id: string,
  taggingId: Tagging['id']
  modelId: FuseModel['id']
  normal: SceneLocalPos,
  localPos: SceneLocalPos
  fontSize: number,
  lineHeight: number,
  globalVisibility: boolean
  visibilityRange: number

  type: TaggingPositionType
  mat: Tagging3DProps['mat']
  pose?: {
    position: SceneLocalPos;
    target: SceneLocalPos;
    panoInfo?: {
      panoId: any;
      modelId: string;
      posInModel: SceneLocalPos;
      rotInModel: SceneLocalPos;
    };
  };
}

export type TaggingPositions = TaggingPosition[]


const serviceToLocal = (position: ServicePosition, taggingId?: Tagging['id']): TaggingPosition => ({
  id: position.tagPointId.toString(),
  modelId: position.fusionNumId ? position.fusionNumId.toString() : position.modelId ? position.modelId.toString() : '123123',
  taggingId: taggingId || position.tagId.toString(),
  localPos: JSON.parse(position.tagPoint),
  type: (position.type || TaggingPositionType['2d']) as TaggingPositionType,
  globalVisibility: Boolean(position.globalVisibility),
  normal: position.normal ? JSON.parse(position.normal) : { x: 0, y: 0, z: 1 },
  mat: position.mat ? JSON.parse(position.mat) : {
    scale: 1,
    rotation: 0
  },
  visibilityRange: position.visibilityRange || 30,
  fontSize: position.fontSize || 12,
  lineHeight: position.lineHeight || 1,
  pose: position.pose && JSON.parse(position.pose)
})

const localToService = (position: TaggingPosition, update = false): PartialProps<ServicePosition, 'tagPointId'> => ({
  "tagPointId": update ? Number(position.id) : undefined,
  "tagId": Number(position.taggingId),
  "fusionNumId": Number(position.modelId),
  "tagPoint": JSON.stringify(position.localPos),
  globalVisibility: Number(position.globalVisibility),
  type: position.type,
  mat: position.mat && JSON.stringify(position.mat),
  normal: JSON.stringify(position.normal),
  fontSize: position.fontSize,
  lineHeight: position.lineHeight,
  visibilityRange: position.visibilityRange ,
  pose: position.pose && JSON.stringify(position.pose)
})


export const fetchTaggingPositions = async (taggingId: Tagging['id']) => {
  const positions = await axios.get<ServicePosition[]>(`${TAGGING_POINT_LIST}`, {params: { tagId: taggingId } })
  return positions.map(position => serviceToLocal(position, taggingId))
}

export const postAddTaggingPosition = async (position: TaggingPosition) => {
  console.log(localToService(position))
  const servicePosition = await axios.post<ServicePosition>(INSERT_TAGGING_POINT, localToService(position))
  return serviceToLocal(servicePosition)
}

export const postUpdateTaggingPosition = (position: TaggingPosition) => {
  return axios.post<undefined>(UPDATE_TAGGING_POINT, localToService(position, true))
}
  
export const postDeleteTaggingPosition = (position: TaggingPosition) => {
  return axios.post<undefined>(DELETE_TAGGING_POINT, { tagPointId: Number(position.id) })
}