gameSeriveUniapp/src/store/modules/service.ts

/**
 * 服务 Store
 */

import { defineStore } from 'pinia'
import type { Service, ServiceCategory } from '@/types'
import { mockServices, mockCategories, getServiceList, getServiceDetail } from '@/mock'

interface ServiceState {
  categories: ServiceCategory[]
  serviceList: Service[]
  hotServices: Service[]
  currentService: Service | null
  loading: boolean
}

export const useServiceStore = defineStore('service', {
  state: (): ServiceState => ({
    categories: mockCategories,
    serviceList: [],
    hotServices: [],
    currentService: null,
    loading: false
  }),

  getters: {
    // 服务列表 getter
    services: (state) => state.serviceList
  },

  actions: {
    /**
     * 获取服务分类
     */
    async fetchCategories(): Promise<ServiceCategory[]> {
      this.categories = mockCategories
      return mockCategories
    },

    /**
     * 获取服务列表
     */
    async fetchServiceList(params?: {
      categoryId?: number
      keyword?: string
    }): Promise<Service[]> {
      this.loading = true
      try {
        const list = getServiceList(params)
        this.serviceList = list
        return list
      } finally {
        this.loading = false
      }
    },

    /**
     * 获取服务详情
     */
    async fetchServiceDetail(id: number): Promise<Service | undefined> {
      const service = getServiceDetail(id)
      if (service) {
        this.currentService = service
      }
      return service
    },

    /**
     * 获取热门服务
     */
    async fetchHotServices(limit: number = 6): Promise<Service[]> {
      const list = mockServices
        .sort((a, b) => b.salesCount - a.salesCount)
        .slice(0, limit)

      this.hotServices = list
      return list
    },

    /**
     * 获取服务列表（别名）
     */
    async getServiceList(params?: {
      categoryId?: number
      keyword?: string
    }): Promise<Service[]> {
      return this.fetchServiceList(params)
    }
  }
})

/**
 * 代练 Store
 */

import type { Player } from '@/types'
import { getPlayerList, getPlayerDetail } from '@/mock'

interface PlayerState {
  playerList: Player[]
  currentPlayer: Player | null
  loading: boolean
}

export const usePlayerStore = defineStore('player', {
  state: (): PlayerState => ({
    playerList: [],
    currentPlayer: null,
    loading: false
  }),

  getters: {
    // 在线代练数
    onlineCount: (state) => state.playerList.filter(p => p.isOnline).length,

    // 获取在线代练
    onlinePlayers: (state) => state.playerList.filter(p => p.isOnline)
  },

  actions: {
    /**
     * 获取代练列表
     */
    async fetchPlayerList(params?: {
      gameId?: string
      isOnline?: boolean
      minRating?: number
    }): Promise<Player[]> {
      this.loading = true
      try {
        const list = getPlayerList(params)
        this.playerList = list
        return list
      } finally {
        this.loading = false
      }
    },

    /**
     * 获取代练详情
     */
    async fetchPlayerDetail(id: number): Promise<Player | undefined> {
      const player = getPlayerDetail(id)
      if (player) {
        this.currentPlayer = player
      }
      return player
    },

    /**
     * 获取代练列表（别名）
     */
    async getPlayerList(params?: {
      gameId?: string
      isOnline?: boolean
      minRating?: number
    }): Promise<Player[]> {
      return this.fetchPlayerList(params)
    }
  }
})