shop-back/src/api/room.ts

import {
  GET_ROOM_LIST,
  GET_ROOM_MINI_CODE,
  DEL_ROOM,
  SET_ROOM,
  GET_ROOM,
  GET_ROOM_LEADER_MINI_CODE
} from './constant'
import axios from './instance'
import type { PageResult, Scene } from './'
import type { SScene } from './scene'

type SRoom = {
  roomId: number
  roomTitle: string
  roomInfo: string
  roomHostName: string
  roomStatus: number
  roomCoverUrl: string
  roomViewCount: number
  createTime: string
}

export interface RoomScene {
  num: string
  title: string
  cover: string
}

export interface Room {
  id: number
  title: string
  desc: string
  time: string
  viewCount: number
  cover: string
  leaderName: string
  roomStatus?: number
}

export type Rooms = Room[]

const serverToLocal = (sroom: SRoom): Room => ({
  id: sroom.roomId,
  title: sroom.roomTitle,
  desc: sroom.roomInfo,
  time: sroom.createTime,
  viewCount: sroom.roomViewCount,
  cover: sroom.roomCoverUrl,
  leaderName: sroom.roomHostName,
  roomStatus: sroom.roomStatus
})
const localToServer = (room: Room): SRoom => ({
  roomId: room.id,
  roomTitle: room.title,
  roomInfo: room.desc,
  roomHostName: room.leaderName,
  roomCoverUrl: room.cover,
  roomViewCount: room.viewCount,
  createTime: room.time,
  roomStatus: room.roomStatus || 0
})

export const fetchRomms = async (): Promise<Rooms> => {
  const res = await axios.post<PageResult<SRoom>>(GET_ROOM_LIST, {
    pageNum: 1,
    pageSize: 1000
  })
  const rooms = res.list.map(serverToLocal)
  return rooms
}

export const deleteRoom = async (room: Room) => {
  await axios.post(DEL_ROOM, { roomId: room.id })
}

export const insertRoom = async (
  room: Omit<Room, 'id'>,
  numList: Scene['num'][]
) => {
  const sroom = await axios.post<SRoom>(SET_ROOM, {
    ...localToServer({ ...room, id: -1 }),
    roomId: null,
    createTime: null,
    numList
  })
  return serverToLocal(sroom)
}

export const updateRoom = async (room: Room, numList: Scene['num'][]) => {
  await axios.post(SET_ROOM, {
    ...localToServer(room),
    numList
  })
}

export const fetchRoomMiniCode = async (room: Room) => {
  return axios.get<string>(GET_ROOM_MINI_CODE, { params: { roomId: room.id } })
}

export const fetchLeaderRoomMiniCode = async (room: Room) => {
  return axios.get<string>(GET_ROOM_LEADER_MINI_CODE, {
    params: { roomId: room.id }
  })
}
interface RoomDetailType extends SRoom {
  sceneData: SScene[],
}
export const fetchRoomDetail = async (roomId: Room['id']) => {
  const res = await axios.get<RoomDetailType>(GET_ROOM, {
    params: { roomId }
  })
  return res
}