city-gather/src/store/user.ts

import { defineStore } from 'pinia'
import { dayjs } from 'wot-design-uni'
import { StaticUrl } from '@/config'
import router from '@/router'
import type { wxpay } from '@/api/globals'

interface userStroe {
  token: string
  /**
   * 重定向路由名称
   */
  redirectName: string
  /**
   * 用户登录信息
   */
  userInfo: Api.userInfo
  /**
   * 用户收货地址
   */
  addresses: Api.addressList[]
  /**
   * 星闪爆用户选择的收货地址
   *
   */
  selectedAddress: Api.addressList | null
  /**
   * 市民请集合购物车用户选中的收货地址
   */
  smqjhSelectedAddress: Api.addressList | null
}
export const useUserStore = defineStore('user', {
  state: (): userStroe => ({
    token: '',
    redirectName: '',
    userInfo: {
      id: 0,
      channelId: 0,
      channelName: '',
    },
    addresses: [],
    selectedAddress: null,
    smqjhSelectedAddress: null,
  }),
  getters: {
    getUserAvatar(): string {
      if (this.userInfo.avatarUrl) {
        return this.userInfo.avatarUrl
      }
      return `${StaticUrl}/avator.png`
    },
  },
  actions: {
    async getUserInfo() {
      if (this.token) {
        const { data } = await api.sys.userInfo({})
        this.userInfo = data
        await this.getuserAddresslist()
        this.getSelectedAddress()
        await useSmqjhCartStore().getCartList('XSB')
      }
    },
    async updataUserInfo(data: Api.userInfo) {
      uni.showLoading({ mask: true })
      await Apis.sys.updateUserInfo({ pathParams: { memberId: data.id }, data })
      uni.hideLoading()
      useGlobalToast().show({ msg: '修改成功' })
      this.getUserInfo()
    },
    /**
     * 获取用户收货地址列表
     */
    async getuserAddresslist() {
      return new Promise((resolve, reject) => {
        uni.showLoading({ mask: true })
        Apis.sys.addresses({}).then((res) => {
          this.addresses = res.data || []
          resolve(res)
        }).catch(err => reject(err)).finally(() => uni.hideLoading())
      })
    },
    /**
     *
     * 更新用户选择的收货地址
     */
    updateSelectedAddress(address: Api.addressList) {
      this.selectedAddress = address
    },
    /**
     * 获取用户收货地址
     * @description 默认选择默认地址，如无默认地址则不选择
     */
    getSelectedAddress() {
      this.selectedAddress = this.addresses.find(it => it.defaulted === 1) ?? null
    },
    /**
     * 获取市民请集合购物车用户选择的收货地址
     * @description 默认选择默认地址，如无默认地址则不选择
     */
    getSmqjhSelectedAddress() {
      this.smqjhSelectedAddress = this.addresses.find(it => it.defaulted === 1) ?? null
    },
    /**
     * 更新市民请集合购物车用户选择的收货地址
     */
    updateSmqjhSelectedAddress(address: Api.addressList) {
      this.smqjhSelectedAddress = address
    },
    /**
     * 检测当前用户是否登录，如果没有登录弹窗提示未登录
     */
    checkLogin() {
      return new Promise((resolve, reject) => {
        if (!this.token) {
          useGlobalMessage().confirm({
            title: '提示',
            msg: '检测到当前状态未登录，是否登录',
            confirmButtonText: '登录',
            cancelButtonText: '取消',
            zIndex: 99999999999,
            success() {
              router.replace({ name: 'smqjh-login' })
              setTimeout(() => { // 延迟1秒后抛错，防止立马抛错之后用户立即点击按钮会重复跳转登录页面
                reject(new Error('未登录'))
              }, 1000)
            },
            fail() {
              reject(new Error('未登录'))
            },
          })
        }
        else {
          resolve(1)
        }
      })
    },
    /**
     * 通用支付逻辑
     * @param orderNumber
     * @returns
     */
    handleCommonPayMent(orderNumber: string): Promise<wxpay> {
      return new Promise((resolve, reject) => {
        if (!orderNumber) {
          useGlobalToast().show({ msg: '订单号为空！请联系管理员' })
          reject(new Error('订单号为空！请联系管理员'))
          return
        }
        uni.showLoading({ mask: true })
        Apis.common.hybridPayment({ data: { orderNumber } }).then((res) => {
          resolve(res.data)
          uni.hideLoading()
        }).catch((err) => {
          uni.hideLoading()
          reject(err)
        })
      })
    }, /**
        *
        * @param freightFee
        * @param businessType
        * @param dvyType  配送类型 1:快递 2:自提 3：及时配送
        * @param shopId
        * @param orderItemList
        * @param remarks
        * @param allowanceId
        * @returns 下单获取待支付订单号
        */
    getOrderPayMent(freightFee: number, businessType: string, dvyType: number, shopId: number, orderItemList: {
      prodCount?: number
      skuId?: number
    }[], remarks?: string, allowanceId?: string): Promise<string> {
      uni.showLoading({ mask: true })
      return new Promise((resolve, reject) => {
        if (!this.selectedAddress) {
          reject(new Error('请选择收货地址'))
          return
        }
        Apis.common.addOrder({
          data: {
            channelId: Number(this.userInfo.channelId),
            businessType,
            addressId: this.selectedAddress.id,
            dvyType,
            freightAmount: freightFee,
            shopId,
            orderItemList,
            remarks,
            allowanceIds: allowanceId ? [allowanceId] : [],
          },
        }).then((res) => {
          resolve(res.data)
          uni.hideLoading()
        }).catch((err) => {
          uni.hideLoading()
          reject(err)
        })
      })
    },
    /**
     *
     * @param orderInfo
     * @returns 统一拉起微信支付
     * @param type 0是下单，1是列表下单
     */

    getWxCommonPayment(orderPay: wxpay) {
      uni.showLoading({ mask: true })
      return new Promise((resolve, reject) => {
        const orderInfo = {
          appid: orderPay.appId,
          timeStamp: orderPay.timeStamp,
          nonceStr: orderPay.nonceStr,
          package: orderPay.package,
          signType: orderPay.signType,
          paySign: orderPay.paySign,
        }
        uni.requestPayment({
          provider: 'wxpay',
          orderInfo,
          ...orderInfo,
          success: (res) => {
            resolve(res)
          },
          fail: (e) => {
            reject(e)
          },
          complete() {
            uni.hideLoading()
          },
        })
      })
    },
    /**
     *
     * 支付成功统一跳转
     *  @param name 订单列表
     * @param idxPath 首页路径
     *
     */
    paySuccess(name: string, idxPath: string) {
      return new Promise((resolve) => {
        useSysStore().setPaySuccessPath(name, idxPath)
        router.replace({ name: 'common-paySuccess' })
        setTimeout(() => {
          resolve(1)
        }, 2000)
      })
    },
    /**
     *
     * 支付失败统一跳转
     * @param name 订单列表
     * @param idxPath 首页路径
     */
    payError(name: string, idxPath: string) {
      return new Promise((resolve) => {
        useSysStore().setPaySuccessPath(name, idxPath)
        router.replace({ name: 'common-payError' })
        setTimeout(() => {
          resolve(1)
        }, 2000)
      })
    }, /**
        * 支付成功清空购买的商品的购物车
        */

    clearCart(skuList: Api.CartSkuVo[]) {
      uni.showLoading({ mask: true })
      return new Promise((resolve) => {
        const skuids = skuList.map(item => item.id).join(',')
        if (skuids.length) {
          Apis.common.deleteShoppingCart({
            pathParams: {
              ids: skuids,
            },
          }).then(async (res) => {
            resolve(res)
            await useSmqjhCartStore().getCartList('XSB')
            uni.hideLoading()
          }).finally(() => resolve(1))
        }
        else {
          resolve(1)
          uni.hideLoading()
        }
      })
    },
    /**
     * 统一确认收货
     * @param order
     * @returns
     */
    handleCommonOrderReceive(order: Api.xsbOrderList) {
      return new Promise((resolve, reject) => {
        useGlobalMessage().confirm({
          title: '确认收货',
          msg: '确定要确认收货吗？',
          zIndex: 99999999999999,
          success: async () => {
            uni.showLoading({ mask: true })
            await Apis.xsb.confirmReceipt({
              data: {
                orderNumber: String(order.orderNumber),
              },
            })
            resolve(1)
          },
          fail: err => reject(err),
        })
      })
    },
    /**
     * 统一删除订单
     * @param order
     * @returns
     */
    handleCommonDeleteOrder(order: Api.xsbOrderList) {
      return new Promise((resolve, reject) => {
        useGlobalMessage().confirm({
          title: '删除订单',
          msg: '确定要删除该订单吗？',
          zIndex: 99999999999999,
          success: async () => {
            uni.showLoading({ mask: true })
            Apis.xsb.deleteOrder({
              pathParams: {
                ids: String(order.orderId),
              },
            }).then(res => resolve(res)).catch(err => reject(err)).finally(() => uni.hideLoading())
          },
          fail: async (err) => {
            reject(err)
          },
        })
      })
    },
    /**
     * 统一取消订单
     * @param order
     * @returns
     */
    handleCommonCancelOrder(order: Api.xsbOrderList) {
      return new Promise((resolve, reject) => {
        useGlobalMessage().confirm({
          title: '取消订单',
          msg: '确定要取消订单吗？',
          zIndex: 99999999999999,
          success: async () => {
            uni.showLoading({ mask: true })
            Apis.xsb.cancelOrder({
              data: {
                orderNo: String(order.orderNumber),
              },
            }).then(res => resolve(res)).catch(err => reject(err)).finally(() => uni.hideLoading())
          },
          fail: async (err) => {
            reject(err)
          },
        })
      })
    },
    handleXSBCommonOrderStatusText(order: Api.xsbOrderList): any {
      if (order.hbOrderStatus === OrderStatus.PaddingPay) {
        const endTime = dayjs(order.createTime).add(16, 'minutes')
        const remaining = dayjs(endTime).valueOf() - dayjs().valueOf()
        return Math.max(0, remaining) // 确保不会返回负数
      }

      if (order.hbOrderStatus === OrderStatus.OrderAccepted) {
        return '订单已接单'
      }
      if (order.hbOrderStatus === OrderStatus.OrderWaitDelivery) {
        return '订单待配送'
      }
      if (order.hbOrderStatus === OrderStatus.OrderDelivering) {
        return '订单配送中'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCancelAudit) {
        return '订单取消审核'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCancel) {
        return '订单取消'
      }
      if (order.hbOrderStatus === OrderStatus.OrderArrived) {
        return '订单已送达'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCompleted) {
        return '订单完成'
      }
      return '未知订单状态'
    },
    handleFilmCommonOrderStatusText(order: Api.xsbOrderList): any {
      if (order.hbOrderStatus === OrderStatus.PaddingPay) {
        const endTime = dayjs(order.createTime).add(16, 'minutes')
        const remaining = dayjs(endTime).valueOf() - dayjs().valueOf()
        return Math.max(0, remaining) // 确保不会返回负数
      }

      if (order.hbOrderStatus === OrderStatus.OrderAccepted) {
        return '待出票'
      }
      if (order.hbOrderStatus === OrderStatus.OrderWaitDelivery) {
        return '订单待配送'
      }
      if (order.hbOrderStatus === OrderStatus.OrderDelivering) {
        return '出票中'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCancelAudit) {
        return '订单取消审核'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCancel) {
        return '订单取消'
      }
      if (order.hbOrderStatus === OrderStatus.OrderArrived) {
        return '订单完成'
      }
      if (order.hbOrderStatus === OrderStatus.OrderCompleted) {
        return '订单完成'
      }
      return '未知订单状态'
    },
    handleDjkCommonOrderStatusText(order: Api.xsbOrderList) {
      const textMap = {
        [OrderStatus.OrderAccepted]: '待使用',
        [OrderStatus.OrderCompleted]: '已完成',
        [OrderStatus.OrderCancel]: '已取消',
        [OrderStatus.OrderRefund]: '已退款',
        [OrderStatus.OrderExpired]: '已过期',
      }
      return textMap[order.hbOrderStatus as keyof typeof textMap] || '未知订单状态'
    },
    async  getOrderNode(orderNumber: string) {
      uni.showLoading({
        mask: true,
      })
      return new Promise((resolve, reject) => {
        Apis.xsb.deliveryNode({
          data: {
            orderNumber,
          },
        }).then((res) => {
          // NodeList.value = res.data
          resolve(res.data)
        }).catch((err) => {
          reject(err)
        }).finally(() => uni.hideLoading())
      })
    },
  },
})