city-gather/src/store/user.ts

import { defineStore } from 'pinia'
import { dayjs } from 'wot-design-uni'
import { REDIRECT_URL, 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
  /**
   * 用户会员信息
   */
  userMemberInfo: Api.userMemberInfo
}
export const useUserStore = defineStore('user', {
  state: (): userStroe => ({
    token: '',
    redirectName: '',
    userInfo: {
      id: 0,
      channelId: 0,
      channelName: '',
    },
    addresses: [],
    selectedAddress: null,
    smqjhSelectedAddress: null,
    userMemberInfo: {
      active: false,
      isFirstLogin: false,
      expireTime: undefined,
    },
  }),
  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.getUserMemberInfo()
        await this.getuserAddresslist()
        this.getSelectedAddress()
        await useSmqjhCartStore().getCartList('XSB')
      }
    },
    /**
     * 获取用户会员信息
     */
    async getUserMemberInfo() {
      if (this.token) {
        const { data } = await Apis.sys.userVipInfo({})
        this.userMemberInfo = data
      }
    },
    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)
        })
      })
    },
    /**
     * H5支付后轮询通用订单支付状态
     * @param orderNumber 订单号
     * @param interval 轮询间隔，默认3秒
     * @param timeout 超时时间，默认90秒
     */
    async pollOrderPaySuccess(orderNumber: string, interval = 3000, timeout = 90000): Promise<boolean> {
      if (!orderNumber) {
        useGlobalToast().show({ msg: '订单号为空！请联系管理员' })
        return false
      }

      const startedAt = Date.now()
      const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))

      while (Date.now() - startedAt <= timeout) {
        try {
          const res = await Apis.xsb.orderInfo({
            data: {
              orderNo: orderNumber,
            },
          })
          const orderInfo = res.data
          if (orderInfo?.isPayed === 1 || (orderInfo?.hbOrderStatus !== undefined && orderInfo.hbOrderStatus !== OrderStatus.PaddingPay)) {
            return true
          }
        }
        catch (error) {
          console.error('轮询订单支付状态失败', error)
        }

        if (Date.now() - startedAt + interval > timeout)
          break

        await sleep(interval)
      }

      return false
    }, /**
        *
        * @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, pickupInfo?: {
      consigneeName?: string
      consigneeMobile?: string
    }, isFreeShipping?: boolean): Promise<string> {
      uni.showLoading({ mask: true })
      return new Promise((resolve, reject) => {
        if (dvyType !== 2 && !this.selectedAddress) {
          uni.hideLoading()
          reject(new Error('请选择收货地址'))
          return
        }
        const orderData: any = {
          channelId: Number(this.userInfo.channelId),
          businessType,
          addressId: Number(this.selectedAddress?.id),
          dvyType,
          freightAmount: freightFee,
          shopId,
          orderItemList,
          remarks,
          allowanceIds: allowanceId ? [allowanceId] : [],
          ...pickupInfo,
        }
        if (isFreeShipping) {
          orderData.isFreeShipping = 1
        }
        Apis.common.addOrder({
          data: orderData,
        }).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) {
          console.log(skuids, '执行中')
          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())
      })
    },
    /**
     *
     * @param _item 兑换的券 加油
     */
    async handleExchange(_item: any) {
      uni.showLoading({ mask: true })
      try {
        const res = await Apis.app.get_smqjh_system_app_api_coupon_exchangepoints({ params: { couponId: _item.id } })
        uni.hideLoading()
        // 兑换成功，跳转成功页
        router.push({
          name: 'exchangeSuccess',
          params: {
            couponId: res.data?.id || _item.id,
            batchNo: res.data?.batchId || '',
            expireDays: res.data?.expirationDate || _item.expirationDate,
            discountMoney: res.data?.discountMoney || _item.discountMoney,
            amountMoney: res.data?.amountMoney || _item.amountMoney,
          },
        })
      }
      catch (error: any) {
        console.log(error)

        uni.hideLoading()
        // 兑换失败，跳转失败页
        router.push({
          name: 'exchangeFail',
          params: {
            failReason: error?.message || '兑换失败，请稍后重试',
          },
        })
      }
    },
    /**
     * 拉起小橘支付
     * @param path
     */
    handleCommonPath(path: string) {
      uni.showLoading({ mask: true })
      const url = REDIRECT_URL
      window.location.href = `${path}&redirectUrl=${url}`
      uni.hideLoading()
    },
    async handleCommonGoXiaoJuPay(orderNumber: string) {
      try {
        const res = await Apis.general.post_smqjh_oms_api_v1_oil_order_findbypayurl({ params: { orderNumber } })
        this.handleCommonPath(res.data as string)
      }
      catch (error) {
        console.log(error)
        useGlobalToast().show('获取支付信息失败')
      }
    },
    /**
     * 加油统一取消订单
     * @param orderNumber
     * @returns
     */
    async handleCommonCancelOrderJY(orderNumber: string) {
      try {
        const res = await Apis.xsb.cancelOrder({ data: { orderNo: orderNumber } })
        return res
      }
      catch (error) {
        console.log(error)
        useGlobalToast().show('取消订单失败')
      }
    },
    /**
     * h5专属。小程序不可调用
     * h5第三方统一拉起微信支付跳转路径及参数
     * @param orderNumber
     */
    handleCommonWechatPay(orderNumber: string, model: string = 'mixture') {
      // #ifdef H5
      uni.showLoading({ mask: true })
      const query = {
        orderNumber,
        phone: String(this.userInfo.mobile),
        model,
        tenantCode: useSysStore().tenantCode,
      }
      const queryString = Object.entries(query)
        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
        .join('&')
      const path = 'subPack-common/threePay/index'
      // const env = 'develop'
      // const env = 'trial'
      const env = 'release'
      window.location.href = `weixin://dl/business/?appid=wx43b5b906cc30ed0b&path=${path}&query=${encodeURIComponent(queryString)}&env_version=${env}`
      uni.hideLoading()
      // #endif
    },
    async getPayMent(orderNumber: string): Promise<{ payType: 'point' | 'hybrid' | 'wx' }> {
      return new Promise((resolve, reject) => {
        Apis.common.hybridPaymentType({ data: { orderNumber } })
          .then((res) => {
            resolve(res.data)
          })
          .catch((err) => {
            reject(err)
          })
      })
    },
  },
})