@@ -265,28 +246,41 @@
\ No newline at end of file
+ const settingsLoad = appStore.fetchPublicSettings()
+ .then((settings) => {
+ if (!settings) {
+ return
+ }
+ contactInfo.value = settings.contact_info || ''
+ balanceLowNotifyEnabled.value = settings.balance_low_notify_enabled ?? false
+ systemDefaultThreshold.value = settings.balance_low_notify_threshold ?? 0
+ linuxdoOAuthEnabled.value = settings.linuxdo_oauth_enabled ?? false
+ wechatOAuthEnabled.value = isWeChatWebOAuthEnabled(settings)
+ wechatOAuthOpenEnabled.value = typeof settings.wechat_oauth_open_enabled === 'boolean'
+ ? settings.wechat_oauth_open_enabled
+ : undefined
+ wechatOAuthMPEnabled.value = typeof settings.wechat_oauth_mp_enabled === 'boolean'
+ ? settings.wechat_oauth_mp_enabled
+ : undefined
+ oidcOAuthEnabled.value = settings.oidc_oauth_enabled ?? false
+ oidcOAuthProviderName.value = settings.oidc_oauth_provider_name || 'OIDC'
+ })
+ .catch((error) => {
+ console.error('Failed to load settings:', error)
+ })
+
+ await Promise.all([profileRefresh, settingsLoad])
+})
+
diff --git a/frontend/src/views/user/StripePaymentView.vue b/frontend/src/views/user/StripePaymentView.vue
index 20a4a408..3f73d4d5 100644
--- a/frontend/src/views/user/StripePaymentView.vue
+++ b/frontend/src/views/user/StripePaymentView.vue
@@ -99,7 +99,7 @@ import { useI18n } from 'vue-i18n'
import { useRoute, useRouter } from 'vue-router'
import { usePaymentStore } from '@/stores/payment'
import { paymentAPI } from '@/api/payment'
-import { extractApiErrorMessage } from '@/utils/apiError'
+import { extractI18nErrorMessage } from '@/utils/apiError'
import { isMobileDevice } from '@/utils/device'
import type { PaymentOrder } from '@/types/payment'
import type { Stripe, StripeElements } from '@stripe/stripe-js'
@@ -167,7 +167,7 @@ onMounted(async () => {
mountPaymentElement(stripe, clientSecret)
}
} catch (err: unknown) {
- initError.value = extractApiErrorMessage(err, t('payment.stripeLoadFailed'))
+ initError.value = extractI18nErrorMessage(err, t, 'payment.errors', t('payment.stripeLoadFailed'))
} finally {
loading.value = false
}
@@ -248,7 +248,7 @@ async function handleGenericPay() {
scheduleClose()
}
} catch (err: unknown) {
- stripeError.value = extractApiErrorMessage(err, t('payment.result.failed'))
+ stripeError.value = extractI18nErrorMessage(err, t, 'payment.errors', t('payment.result.failed'))
} finally {
stripeSubmitting.value = false
}
diff --git a/frontend/src/views/user/StripePopupView.vue b/frontend/src/views/user/StripePopupView.vue
index 2704c62d..688ad644 100644
--- a/frontend/src/views/user/StripePopupView.vue
+++ b/frontend/src/views/user/StripePopupView.vue
@@ -56,7 +56,7 @@
import { computed, ref, onMounted, onUnmounted } from 'vue'
import { useI18n } from 'vue-i18n'
import { useRoute } from 'vue-router'
-import { extractApiErrorMessage } from '@/utils/apiError'
+import { extractI18nErrorMessage } from '@/utils/apiError'
import { isMobileDevice } from '@/utils/device'
interface StripeWithWechatPay {
@@ -143,7 +143,7 @@ async function initStripe(clientSecret: string, publishableKey: string) {
}
}
} catch (err: unknown) {
- error.value = extractApiErrorMessage(err, t('payment.stripeLoadFailed'))
+ error.value = extractI18nErrorMessage(err, t, 'payment.errors', t('payment.stripeLoadFailed'))
}
}
diff --git a/frontend/src/views/user/UserOrdersView.vue b/frontend/src/views/user/UserOrdersView.vue
index ea888eb7..c3ed80eb 100644
--- a/frontend/src/views/user/UserOrdersView.vue
+++ b/frontend/src/views/user/UserOrdersView.vue
@@ -86,7 +86,7 @@ import { useI18n } from 'vue-i18n'
import { useRouter } from 'vue-router'
import { useAppStore } from '@/stores'
import { paymentAPI } from '@/api/payment'
-import { extractApiErrorMessage } from '@/utils/apiError'
+import { extractI18nErrorMessage } from '@/utils/apiError'
import type { PaymentOrder } from '@/types/payment'
import AppLayout from '@/components/layout/AppLayout.vue'
import Pagination from '@/components/common/Pagination.vue'
@@ -128,7 +128,7 @@ async function fetchOrders() {
orders.value = res.data.items || []
pagination.total = res.data.total || 0
} catch (err: unknown) {
- appStore.showError(extractApiErrorMessage(err, t('common.error')))
+ appStore.showError(extractI18nErrorMessage(err, t, 'payment.errors', t('common.error')))
} finally {
loading.value = false
}
@@ -148,7 +148,7 @@ async function confirmCancel() {
cancelTargetId.value = null
await fetchOrders()
} catch (err: unknown) {
- appStore.showError(extractApiErrorMessage(err, t('common.error')))
+ appStore.showError(extractI18nErrorMessage(err, t, 'payment.errors', t('common.error')))
} finally {
actionLoading.value = false
}
@@ -166,7 +166,7 @@ async function confirmRefund() {
refundReason.value = ''
await fetchOrders()
} catch (err: unknown) {
- appStore.showError(extractApiErrorMessage(err, t('common.error')))
+ appStore.showError(extractI18nErrorMessage(err, t, 'payment.errors', t('common.error')))
} finally {
actionLoading.value = false
}
diff --git a/frontend/src/views/user/__tests__/PaymentResultView.spec.ts b/frontend/src/views/user/__tests__/PaymentResultView.spec.ts
new file mode 100644
index 00000000..556cf390
--- /dev/null
+++ b/frontend/src/views/user/__tests__/PaymentResultView.spec.ts
@@ -0,0 +1,402 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { flushPromises, mount } from '@vue/test-utils'
+
+const routeState = vi.hoisted(() => ({
+ query: {} as Record
,
+}))
+
+const routerPush = vi.hoisted(() => vi.fn())
+const pollOrderStatus = vi.hoisted(() => vi.fn())
+const verifyOrderPublic = vi.hoisted(() => vi.fn())
+const resolveOrderPublicByResumeToken = vi.hoisted(() => vi.fn())
+
+vi.mock('vue-router', async () => {
+ const actual = await vi.importActual('vue-router')
+ return {
+ ...actual,
+ useRoute: () => routeState,
+ useRouter: () => ({ push: routerPush }),
+ }
+})
+
+vi.mock('vue-i18n', async () => {
+ const actual = await vi.importActual('vue-i18n')
+ return {
+ ...actual,
+ useI18n: () => ({
+ t: (key: string) => key,
+ }),
+ }
+})
+
+vi.mock('@/stores/payment', () => ({
+ usePaymentStore: () => ({
+ pollOrderStatus,
+ }),
+}))
+
+vi.mock('@/api/payment', () => ({
+ paymentAPI: {
+ verifyOrderPublic,
+ resolveOrderPublicByResumeToken,
+ },
+}))
+
+import PaymentResultView from '../PaymentResultView.vue'
+import { PAYMENT_RECOVERY_STORAGE_KEY } from '@/components/payment/paymentFlow'
+
+const orderFactory = (status: string) => ({
+ id: 42,
+ user_id: 9,
+ amount: 88,
+ pay_amount: 88,
+ fee_rate: 0,
+ payment_type: 'alipay',
+ out_trade_no: 'sub2_20260420abcd1234',
+ status,
+ order_type: 'balance',
+ created_at: '2026-04-20T12:00:00Z',
+ expires_at: '2026-04-20T12:30:00Z',
+ refund_amount: 0,
+})
+
+const recoverySnapshotFactory = (resumeToken: string) => ({
+ orderId: 42,
+ amount: 88,
+ qrCode: '',
+ expiresAt: '2099-01-01T00:10:00.000Z',
+ paymentType: 'alipay',
+ payUrl: 'https://pay.example.com/session/42',
+ outTradeNo: 'sub2_20260420abcd1234',
+ clientSecret: '',
+ payAmount: 88,
+ orderType: 'balance',
+ paymentMode: 'popup',
+ resumeToken,
+ createdAt: Date.UTC(2099, 0, 1, 0, 0, 0),
+})
+
+describe('PaymentResultView', () => {
+ beforeEach(() => {
+ routeState.query = {}
+ routerPush.mockReset()
+ pollOrderStatus.mockReset()
+ verifyOrderPublic.mockReset()
+ resolveOrderPublicByResumeToken.mockReset()
+ window.localStorage.clear()
+ })
+
+ afterEach(() => {
+ vi.useRealTimers()
+ })
+
+ it('renders a pending state instead of a failure state when the restored order is still pending', async () => {
+ routeState.query = {
+ resume_token: 'resume-42',
+ order_id: '999',
+ status: 'success',
+ }
+ window.localStorage.setItem(PAYMENT_RECOVERY_STORAGE_KEY, JSON.stringify({
+ orderId: 42,
+ amount: 88,
+ qrCode: '',
+ expiresAt: '2099-01-01T00:10:00.000Z',
+ paymentType: 'alipay',
+ payUrl: 'https://pay.example.com/session/42',
+ outTradeNo: 'sub2_20260420abcd1234',
+ clientSecret: '',
+ payAmount: 88,
+ orderType: 'balance',
+ paymentMode: 'redirect',
+ resumeToken: 'resume-42',
+ createdAt: Date.UTC(2099, 0, 1, 0, 0, 0),
+ }))
+ resolveOrderPublicByResumeToken.mockResolvedValue({
+ data: orderFactory('PENDING'),
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledWith('resume-42')
+ expect(pollOrderStatus).not.toHaveBeenCalled()
+ expect(wrapper.text()).toContain('payment.result.processing')
+ expect(wrapper.text()).not.toContain('payment.result.success')
+ expect(wrapper.text()).not.toContain('payment.result.failed')
+ })
+
+ it('prefers the public resume-token result over a stale restored DB snapshot', async () => {
+ routeState.query = {
+ resume_token: 'resume-authoritative',
+ order_id: '42',
+ status: 'success',
+ }
+ window.localStorage.setItem(PAYMENT_RECOVERY_STORAGE_KEY, JSON.stringify({
+ orderId: 42,
+ amount: 88,
+ qrCode: '',
+ expiresAt: '2099-01-01T00:10:00.000Z',
+ paymentType: 'alipay',
+ payUrl: 'https://pay.example.com/session/42',
+ outTradeNo: 'sub2_20260420abcd1234',
+ clientSecret: '',
+ payAmount: 88,
+ orderType: 'balance',
+ paymentMode: 'popup',
+ resumeToken: 'resume-authoritative',
+ createdAt: Date.UTC(2099, 0, 1, 0, 0, 0),
+ }))
+ resolveOrderPublicByResumeToken.mockResolvedValue({
+ data: {
+ ...orderFactory('PAID'),
+ amount: 100,
+ pay_amount: 103,
+ fee_rate: 3,
+ },
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(pollOrderStatus).not.toHaveBeenCalled()
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledWith('resume-authoritative')
+ expect(wrapper.text()).toContain('payment.result.success')
+ expect(wrapper.text()).toContain('103.00')
+ expect(wrapper.text()).toContain('100.00')
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('refreshes a pending resume-token result until the order becomes paid', async () => {
+ vi.useFakeTimers()
+ routeState.query = {
+ resume_token: 'resume-77',
+ }
+ window.localStorage.setItem(
+ PAYMENT_RECOVERY_STORAGE_KEY,
+ JSON.stringify(recoverySnapshotFactory('resume-77')),
+ )
+ resolveOrderPublicByResumeToken
+ .mockResolvedValueOnce({
+ data: orderFactory('PENDING'),
+ })
+ .mockResolvedValueOnce({
+ data: orderFactory('PAID'),
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledTimes(1)
+ expect(wrapper.text()).toContain('payment.result.processing')
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).not.toBeNull()
+
+ await vi.advanceTimersByTimeAsync(2000)
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledTimes(2)
+ expect(wrapper.text()).toContain('payment.result.success')
+ expect(wrapper.text()).not.toContain('payment.result.failed')
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('falls back to order_id polling when resume-token recovery fails', async () => {
+ routeState.query = {
+ resume_token: 'resume-fail',
+ order_id: '77',
+ }
+ window.localStorage.setItem(
+ PAYMENT_RECOVERY_STORAGE_KEY,
+ JSON.stringify({
+ ...recoverySnapshotFactory('resume-fail'),
+ orderId: 42,
+ }),
+ )
+ resolveOrderPublicByResumeToken.mockRejectedValueOnce(new Error('resume failed'))
+ pollOrderStatus.mockResolvedValueOnce({
+ ...orderFactory('PAID'),
+ id: 77,
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledWith('resume-fail')
+ expect(pollOrderStatus).toHaveBeenCalledWith(77)
+ expect(verifyOrderPublic).not.toHaveBeenCalled()
+ expect(wrapper.text()).toContain('payment.result.success')
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('falls back to public out_trade_no verification when resume_token recovery fails in legacy return flows', async () => {
+ routeState.query = {
+ resume_token: 'resume-fail',
+ out_trade_no: 'legacy-should-not-run',
+ trade_status: 'TRADE_SUCCESS',
+ }
+ resolveOrderPublicByResumeToken.mockRejectedValueOnce(new Error('resume failed'))
+ verifyOrderPublic.mockResolvedValueOnce({
+ data: {
+ ...orderFactory('PAID'),
+ out_trade_no: 'legacy-should-not-run',
+ },
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledWith('resume-fail')
+ expect(verifyOrderPublic).toHaveBeenCalledWith('legacy-should-not-run')
+ expect(pollOrderStatus).not.toHaveBeenCalled()
+ expect(wrapper.text()).toContain('payment.result.success')
+ })
+
+ it('ignores a stale global recovery snapshot when legacy return markers do not identify the order', async () => {
+ routeState.query = {
+ trade_status: 'TRADE_SUCCESS',
+ }
+ window.localStorage.setItem(
+ PAYMENT_RECOVERY_STORAGE_KEY,
+ JSON.stringify(recoverySnapshotFactory('resume-stale')),
+ )
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).not.toHaveBeenCalled()
+ expect(verifyOrderPublic).not.toHaveBeenCalled()
+ expect(pollOrderStatus).not.toHaveBeenCalled()
+ expect(wrapper.text()).toContain('payment.result.failed')
+ expect(wrapper.text()).not.toContain('sub2_20260420abcd1234')
+ })
+
+ it('uses public out_trade_no verification when no signed resume context is available', async () => {
+ routeState.query = {
+ out_trade_no: 'legacy-123',
+ trade_status: 'TRADE_SUCCESS',
+ }
+ verifyOrderPublic.mockResolvedValue({
+ data: orderFactory('PAID'),
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(verifyOrderPublic).toHaveBeenCalledWith('legacy-123')
+ expect(pollOrderStatus).not.toHaveBeenCalled()
+ expect(wrapper.text()).toContain('payment.result.success')
+ })
+
+ it('does not use public out_trade_no verification for bare order numbers without legacy return markers', async () => {
+ routeState.query = {
+ out_trade_no: 'legacy-bare',
+ }
+
+ mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(verifyOrderPublic).not.toHaveBeenCalled()
+ })
+
+ it('resolves order by resume token when local recovery snapshot is missing', async () => {
+ routeState.query = {
+ resume_token: 'resume-77',
+ }
+ resolveOrderPublicByResumeToken.mockResolvedValue({
+ data: orderFactory('PAID'),
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(resolveOrderPublicByResumeToken).toHaveBeenCalledWith('resume-77')
+ expect(wrapper.text()).toContain('payment.result.success')
+ })
+
+ it('normalizes aliased payment methods before rendering the label', async () => {
+ routeState.query = {
+ resume_token: 'resume-88',
+ }
+ resolveOrderPublicByResumeToken.mockResolvedValueOnce({
+ data: {
+ ...orderFactory('PAID'),
+ payment_type: 'alipay_direct',
+ },
+ })
+
+ const wrapper = mount(PaymentResultView, {
+ global: {
+ stubs: {
+ OrderStatusBadge: true,
+ },
+ },
+ })
+
+ await flushPromises()
+
+ expect(wrapper.text()).toContain('payment.methods.alipay')
+ expect(wrapper.text()).not.toContain('payment.methods.alipay_direct')
+ })
+})
diff --git a/frontend/src/views/user/__tests__/PaymentView.spec.ts b/frontend/src/views/user/__tests__/PaymentView.spec.ts
new file mode 100644
index 00000000..d2683161
--- /dev/null
+++ b/frontend/src/views/user/__tests__/PaymentView.spec.ts
@@ -0,0 +1,390 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { flushPromises, shallowMount } from '@vue/test-utils'
+import PaymentView from '../PaymentView.vue'
+import { PAYMENT_RECOVERY_STORAGE_KEY } from '@/components/payment/paymentFlow'
+
+const routeState = vi.hoisted(() => ({
+ path: '/purchase',
+ query: {} as Record,
+}))
+
+const routerReplace = vi.hoisted(() => vi.fn())
+const routerPush = vi.hoisted(() => vi.fn())
+const routerResolve = vi.hoisted(() => vi.fn(() => ({ href: '/payment/stripe?mock=1' })))
+const createOrder = vi.hoisted(() => vi.fn())
+const refreshUser = vi.hoisted(() => vi.fn())
+const fetchActiveSubscriptions = vi.hoisted(() => vi.fn().mockResolvedValue(undefined))
+const showError = vi.hoisted(() => vi.fn())
+const showInfo = vi.hoisted(() => vi.fn())
+const getCheckoutInfo = vi.hoisted(() => vi.fn())
+const bridgeInvoke = vi.hoisted(() => vi.fn())
+
+vi.mock('vue-router', async () => {
+ const actual = await vi.importActual('vue-router')
+ return {
+ ...actual,
+ useRoute: () => routeState,
+ useRouter: () => ({
+ replace: routerReplace,
+ push: routerPush,
+ resolve: routerResolve,
+ }),
+ }
+})
+
+vi.mock('vue-i18n', async () => {
+ const actual = await vi.importActual('vue-i18n')
+ return {
+ ...actual,
+ useI18n: () => ({
+ t: (key: string) => key,
+ }),
+ }
+})
+
+vi.mock('@/stores/auth', () => ({
+ useAuthStore: () => ({
+ user: {
+ username: 'demo-user',
+ balance: 0,
+ },
+ refreshUser,
+ }),
+}))
+
+vi.mock('@/stores/payment', () => ({
+ usePaymentStore: () => ({
+ createOrder,
+ }),
+}))
+
+vi.mock('@/stores/subscriptions', () => ({
+ useSubscriptionStore: () => ({
+ activeSubscriptions: [],
+ fetchActiveSubscriptions,
+ }),
+}))
+
+vi.mock('@/stores', () => ({
+ useAppStore: () => ({
+ showError,
+ showInfo,
+ }),
+}))
+
+vi.mock('@/api/payment', () => ({
+ paymentAPI: {
+ getCheckoutInfo,
+ },
+}))
+
+vi.mock('@/utils/device', () => ({
+ isMobileDevice: () => true,
+}))
+
+function checkoutInfoFixture() {
+ return {
+ data: {
+ methods: {
+ wxpay: {
+ daily_limit: 0,
+ daily_used: 0,
+ daily_remaining: 0,
+ single_min: 0,
+ single_max: 0,
+ fee_rate: 0,
+ available: true,
+ },
+ },
+ global_min: 0,
+ global_max: 0,
+ plans: [],
+ balance_disabled: false,
+ balance_recharge_multiplier: 1,
+ recharge_fee_rate: 0,
+ help_text: '',
+ help_image_url: '',
+ stripe_publishable_key: '',
+ },
+ }
+}
+
+function checkoutInfoWithPlansFixture() {
+ return {
+ data: {
+ ...checkoutInfoFixture().data,
+ plans: [
+ {
+ id: 7,
+ group_id: 3,
+ name: 'Starter',
+ description: '',
+ price: 128,
+ original_price: 0,
+ validity_days: 30,
+ validity_unit: 'day',
+ rate_multiplier: 1,
+ daily_limit_usd: null,
+ weekly_limit_usd: null,
+ monthly_limit_usd: null,
+ features: [],
+ group_platform: 'openai',
+ sort_order: 1,
+ for_sale: true,
+ group_name: 'OpenAI',
+ },
+ ],
+ },
+ }
+}
+
+function jsapiOrderFixture(resumeToken: string) {
+ return {
+ order_id: 123,
+ amount: 88,
+ pay_amount: 88,
+ fee_rate: 0,
+ expires_at: '2099-01-01T00:10:00.000Z',
+ payment_type: 'wxpay',
+ out_trade_no: 'sub2_jsapi_123',
+ result_type: 'jsapi_ready' as const,
+ resume_token: resumeToken,
+ jsapi: {
+ appId: 'wx123',
+ timeStamp: '1712345678',
+ nonceStr: 'nonce',
+ package: 'prepay_id=wx123',
+ signType: 'RSA',
+ paySign: 'signed',
+ },
+ }
+}
+
+function oauthOrderFixture() {
+ return {
+ order_id: 456,
+ amount: 128,
+ pay_amount: 128,
+ fee_rate: 0,
+ expires_at: '2099-01-01T00:10:00.000Z',
+ payment_type: 'wxpay',
+ result_type: 'oauth_required' as const,
+ oauth: {
+ authorize_url: '/api/v1/auth/oauth/wechat/payment/start?payment_type=wxpay&redirect=%2Fpurchase%3Ffrom%3Dwechat',
+ appid: 'wx123',
+ scope: 'snsapi_base',
+ redirect_url: '/auth/wechat/payment/callback',
+ },
+ }
+}
+
+describe('PaymentView WeChat JSAPI flow', () => {
+ beforeEach(() => {
+ routeState.path = '/purchase'
+ routeState.query = {
+ wechat_resume: '1',
+ wechat_resume_token: 'resume-token-123',
+ }
+ routerReplace.mockReset().mockResolvedValue(undefined)
+ routerPush.mockReset().mockResolvedValue(undefined)
+ routerResolve.mockClear()
+ createOrder.mockReset()
+ refreshUser.mockReset()
+ fetchActiveSubscriptions.mockReset().mockResolvedValue(undefined)
+ showError.mockReset()
+ showInfo.mockReset()
+ getCheckoutInfo.mockReset().mockResolvedValue(checkoutInfoFixture())
+ bridgeInvoke.mockReset()
+ window.localStorage.clear()
+ ;(window as Window & { WeixinJSBridge?: { invoke: typeof bridgeInvoke } }).WeixinJSBridge = {
+ invoke: bridgeInvoke,
+ }
+ })
+
+ it('resets payment state and redirects to /payment/result after JSAPI reports success', async () => {
+ createOrder.mockResolvedValue(jsapiOrderFixture('resume-token-123'))
+ bridgeInvoke.mockImplementation((_action, _payload, callback) => {
+ callback({ err_msg: 'get_brand_wcpay_request:ok' })
+ })
+
+ shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+ await flushPromises()
+ await flushPromises()
+
+ expect(routerReplace).toHaveBeenCalledWith({ path: '/purchase', query: {} })
+ expect(routerPush).toHaveBeenCalledWith({
+ path: '/payment/result',
+ query: {
+ order_id: '123',
+ out_trade_no: 'sub2_jsapi_123',
+ resume_token: 'resume-token-123',
+ },
+ })
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('resets payment state when JSAPI reports cancellation', async () => {
+ createOrder.mockResolvedValue(jsapiOrderFixture('resume-token-cancel'))
+ bridgeInvoke.mockImplementation((_action, _payload, callback) => {
+ callback({ err_msg: 'get_brand_wcpay_request:cancel' })
+ })
+
+ shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+ await flushPromises()
+ await flushPromises()
+
+ expect(showInfo).toHaveBeenCalledWith('payment.qr.cancelled')
+ expect(routerPush).not.toHaveBeenCalled()
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('clears stale recovery state when JSAPI never becomes available', async () => {
+ vi.useFakeTimers()
+ createOrder.mockResolvedValue(jsapiOrderFixture('resume-token-missing-bridge'))
+ ;(window as Window & { WeixinJSBridge?: { invoke: typeof bridgeInvoke } }).WeixinJSBridge = undefined
+
+ const wrapper = shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+
+ await flushPromises()
+ await vi.advanceTimersByTimeAsync(4000)
+ await flushPromises()
+ await flushPromises()
+
+ expect(showError).toHaveBeenCalledWith(
+ 'payment.errors.wechatJsapiUnavailable payment.errors.wechatOpenInWeChatHint',
+ )
+ expect(routerPush).not.toHaveBeenCalled()
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ expect(wrapper.html()).not.toContain('payment-status-panel-stub')
+ })
+
+ it('clears a stale recovery snapshot before handling wechat resume callback params', async () => {
+ createOrder.mockRejectedValueOnce(new Error('resume failed'))
+ window.localStorage.setItem(PAYMENT_RECOVERY_STORAGE_KEY, JSON.stringify({
+ orderId: 999,
+ amount: 66,
+ qrCode: 'stale-qr',
+ expiresAt: '2099-01-01T00:10:00.000Z',
+ paymentType: 'alipay',
+ payUrl: 'https://pay.example.com/stale',
+ outTradeNo: 'stale-out-trade-no',
+ clientSecret: '',
+ payAmount: 66,
+ orderType: 'balance',
+ paymentMode: 'popup',
+ resumeToken: '',
+ createdAt: Date.UTC(2099, 0, 1, 0, 0, 0),
+ }))
+
+ shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+ await flushPromises()
+ await flushPromises()
+
+ expect(createOrder).toHaveBeenCalledWith(expect.objectContaining({
+ wechat_resume_token: 'resume-token-123',
+ }))
+ expect(window.localStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY)).toBeNull()
+ })
+
+ it('keeps subscription resume context for token-only WeChat callbacks', async () => {
+ routeState.query = {
+ wechat_resume: '1',
+ wechat_resume_token: 'resume-subscription-7',
+ payment_type: 'wxpay_direct',
+ order_type: 'subscription',
+ plan_id: '7',
+ }
+ getCheckoutInfo.mockResolvedValue(checkoutInfoWithPlansFixture())
+ createOrder.mockResolvedValue(oauthOrderFixture())
+
+ const originalLocation = window.location
+ const locationState = {
+ href: 'http://localhost/purchase',
+ origin: 'http://localhost',
+ }
+ Object.defineProperty(window, 'location', {
+ configurable: true,
+ value: locationState,
+ })
+
+ shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+ await flushPromises()
+ await flushPromises()
+
+ expect(routerReplace).toHaveBeenCalledWith({ path: '/purchase', query: {} })
+ expect(createOrder).toHaveBeenCalledWith(expect.objectContaining({
+ payment_type: 'wxpay',
+ order_type: 'subscription',
+ plan_id: 7,
+ wechat_resume_token: 'resume-subscription-7',
+ }))
+ expect(locationState.href).toContain('/api/v1/auth/oauth/wechat/payment/start?')
+ expect(new URL(locationState.href, 'http://localhost').searchParams.get('redirect')).toBe(
+ '/purchase?from=wechat&payment_type=wxpay&order_type=subscription&plan_id=7',
+ )
+
+ Object.defineProperty(window, 'location', {
+ configurable: true,
+ value: originalLocation,
+ })
+ })
+
+ it('shows explicit H5 authorization guidance instead of failing silently', async () => {
+ routeState.query = {
+ wechat_resume: '1',
+ wechat_resume_token: 'resume-token-h5',
+ payment_type: 'wxpay_direct',
+ }
+ createOrder.mockRejectedValueOnce({ reason: 'WECHAT_H5_NOT_AUTHORIZED' })
+
+ shallowMount(PaymentView, {
+ global: {
+ stubs: {
+ Teleport: true,
+ Transition: false,
+ },
+ },
+ })
+ await flushPromises()
+ await flushPromises()
+
+ expect(showError).toHaveBeenCalledWith(
+ 'payment.errors.wechatH5NotAuthorized payment.errors.wechatOpenInWeChatHint',
+ )
+ })
+})
diff --git a/frontend/src/views/user/__tests__/ProfileView.spec.ts b/frontend/src/views/user/__tests__/ProfileView.spec.ts
new file mode 100644
index 00000000..3b187396
--- /dev/null
+++ b/frontend/src/views/user/__tests__/ProfileView.spec.ts
@@ -0,0 +1,99 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import ProfileView from '@/views/user/ProfileView.vue'
+
+const {
+ fetchPublicSettingsMock,
+ refreshUserMock,
+ authState
+} = vi.hoisted(() => ({
+ fetchPublicSettingsMock: vi.fn(),
+ refreshUserMock: vi.fn(),
+ authState: {
+ user: null as Record | null,
+ refreshUser: vi.fn()
+ }
+}))
+
+vi.mock('@/stores/auth', () => ({
+ useAuthStore: () => authState
+}))
+
+vi.mock('@/stores/app', () => ({
+ useAppStore: () => ({
+ fetchPublicSettings: fetchPublicSettingsMock
+ })
+}))
+
+vi.mock('@/utils/format', () => ({
+ formatDate: () => 'April 2026'
+}))
+
+vi.mock('vue-i18n', async (importOriginal) => {
+ const actual = await importOriginal()
+ return {
+ ...actual,
+ useI18n: () => ({
+ t: (key: string) => key
+ })
+ }
+})
+
+describe('ProfileView', () => {
+ beforeEach(() => {
+ refreshUserMock.mockReset()
+ fetchPublicSettingsMock.mockReset()
+ refreshUserMock.mockResolvedValue(undefined)
+ authState.refreshUser = refreshUserMock
+ authState.user = {
+ id: 1,
+ username: 'alice',
+ email: 'alice@example.com',
+ role: 'user',
+ balance: 10,
+ concurrency: 2,
+ status: 'active',
+ allowed_groups: null,
+ balance_notify_enabled: true,
+ balance_notify_threshold: null,
+ balance_notify_extra_emails: [],
+ created_at: '2026-04-20T00:00:00Z',
+ updated_at: '2026-04-20T00:00:00Z'
+ }
+ fetchPublicSettingsMock.mockResolvedValue({
+ contact_info: '',
+ balance_low_notify_enabled: false,
+ balance_low_notify_threshold: 0,
+ linuxdo_oauth_enabled: true,
+ wechat_oauth_enabled: true,
+ wechat_oauth_open_enabled: true,
+ wechat_oauth_mp_enabled: false,
+ oidc_oauth_enabled: true,
+ oidc_oauth_provider_name: 'OIDC'
+ })
+ })
+
+ it('renders the simplified single-column profile shell without separate stat cards', async () => {
+ const wrapper = mount(ProfileView, {
+ global: {
+ stubs: {
+ AppLayout: { template: '
' },
+ StatCard: { template: '' },
+ ProfileInfoCard: { template: '' },
+ ProfileBalanceNotifyCard: { template: '' },
+ ProfilePasswordForm: { template: '' },
+ ProfileTotpCard: { template: '' },
+ Icon: true
+ }
+ }
+ })
+
+ await flushPromises()
+
+ expect(wrapper.findAll('.stat-card')).toHaveLength(0)
+ expect(wrapper.get('[data-testid="profile-shell"]').exists()).toBe(true)
+ expect(wrapper.get('[data-testid="profile-shell"]').html()).toContain('profile-info-card')
+ expect(wrapper.get('[data-testid="profile-shell"]').html()).toContain('profile-password-form')
+ expect(wrapper.get('[data-testid="profile-shell"]').html()).toContain('profile-totp-card')
+ })
+})
diff --git a/frontend/src/views/user/__tests__/paymentUx.spec.ts b/frontend/src/views/user/__tests__/paymentUx.spec.ts
new file mode 100644
index 00000000..8d73d1fa
--- /dev/null
+++ b/frontend/src/views/user/__tests__/paymentUx.spec.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest'
+import {
+ buildPaymentErrorToastMessage,
+ describePaymentScenarioError,
+ normalizePaymentMethodForDisplay,
+} from '../paymentUx'
+
+describe('normalizePaymentMethodForDisplay', () => {
+ it('collapses visible payment aliases to canonical method ids', () => {
+ expect(normalizePaymentMethodForDisplay(' alipay_direct ')).toBe('alipay')
+ expect(normalizePaymentMethodForDisplay('wxpay_direct')).toBe('wxpay')
+ expect(normalizePaymentMethodForDisplay('wechat_pay')).toBe('wxpay')
+ })
+
+ it('leaves non-aliased methods untouched', () => {
+ expect(normalizePaymentMethodForDisplay('stripe')).toBe('stripe')
+ })
+})
+
+describe('describePaymentScenarioError', () => {
+ it('maps WeChat H5 authorization errors to explicit in-app guidance', () => {
+ expect(describePaymentScenarioError(
+ { reason: 'WECHAT_H5_NOT_AUTHORIZED' },
+ { paymentMethod: 'wxpay', isMobile: true, isWechatBrowser: false },
+ )).toEqual({
+ messageKey: 'payment.errors.wechatH5NotAuthorized',
+ hintKey: 'payment.errors.wechatOpenInWeChatHint',
+ })
+ })
+
+ it('maps WeChat H5 authorization errors when provider aliases use wxpay_direct', () => {
+ expect(describePaymentScenarioError(
+ { reason: 'WECHAT_H5_NOT_AUTHORIZED' },
+ { paymentMethod: 'wxpay_direct', isMobile: true, isWechatBrowser: false },
+ )).toEqual({
+ messageKey: 'payment.errors.wechatH5NotAuthorized',
+ hintKey: 'payment.errors.wechatOpenInWeChatHint',
+ })
+ })
+
+ it('maps missing WeixinJSBridge to a JSAPI-specific prompt', () => {
+ expect(describePaymentScenarioError(
+ new Error('WeixinJSBridge is unavailable'),
+ { paymentMethod: 'wxpay', isMobile: true, isWechatBrowser: true },
+ )).toEqual({
+ messageKey: 'payment.errors.wechatJsapiUnavailable',
+ hintKey: 'payment.errors.wechatOpenInWeChatHint',
+ })
+ })
+
+ it('maps the internal JSAPI unavailable marker to the same prompt', () => {
+ expect(describePaymentScenarioError(
+ new Error('WECHAT_JSAPI_UNAVAILABLE'),
+ { paymentMethod: 'wxpay', isMobile: true, isWechatBrowser: true },
+ )).toEqual({
+ messageKey: 'payment.errors.wechatJsapiUnavailable',
+ hintKey: 'payment.errors.wechatOpenInWeChatHint',
+ })
+ })
+
+ it('maps generic desktop Alipay failures to QR guidance', () => {
+ expect(describePaymentScenarioError(
+ { reason: 'PAYMENT_GATEWAY_ERROR' },
+ { paymentMethod: 'alipay', isMobile: false, isWechatBrowser: false },
+ )).toEqual({
+ messageKey: 'payment.errors.alipayDesktopUnavailable',
+ hintKey: 'payment.errors.alipayDesktopQrHint',
+ })
+ })
+})
+
+describe('buildPaymentErrorToastMessage', () => {
+ it('returns the main message when no hint is present', () => {
+ expect(buildPaymentErrorToastMessage('Payment failed')).toBe('Payment failed')
+ })
+
+ it('appends the hint to the toast body when present', () => {
+ expect(buildPaymentErrorToastMessage('Payment failed', 'Open WeChat to continue.')).toBe(
+ 'Payment failed Open WeChat to continue.'
+ )
+ })
+})
diff --git a/frontend/src/views/user/__tests__/paymentWechatResume.spec.ts b/frontend/src/views/user/__tests__/paymentWechatResume.spec.ts
new file mode 100644
index 00000000..85b2b0fd
--- /dev/null
+++ b/frontend/src/views/user/__tests__/paymentWechatResume.spec.ts
@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest'
+import { parseWechatResumeRoute, stripWechatResumeQuery } from '../paymentWechatResume'
+
+describe('parseWechatResumeRoute', () => {
+ it('prefers the opaque resume token over legacy openid query params', () => {
+ expect(parseWechatResumeRoute({
+ wechat_resume: '1',
+ wechat_resume_token: 'resume-token-123',
+ openid: 'openid-123',
+ payment_type: 'wxpay',
+ amount: '12.5',
+ order_type: 'subscription',
+ plan_id: '7',
+ }, [], 88)).toEqual({
+ wechatResumeToken: 'resume-token-123',
+ paymentType: 'wxpay',
+ orderType: 'subscription',
+ orderAmount: 0,
+ planId: 7,
+ })
+ })
+
+ it('falls back to legacy openid-based resume when opaque token is absent', () => {
+ expect(parseWechatResumeRoute({
+ wechat_resume: '1',
+ openid: 'openid-123',
+ payment_type: 'wxpay',
+ amount: '12.5',
+ order_type: 'balance',
+ }, [], 88)).toEqual({
+ openid: 'openid-123',
+ paymentType: 'wxpay',
+ orderType: 'balance',
+ orderAmount: 12.5,
+ planId: undefined,
+ })
+ })
+})
+
+describe('stripWechatResumeQuery', () => {
+ it('removes both opaque-token and legacy resume params from the route query', () => {
+ expect(stripWechatResumeQuery({
+ foo: 'bar',
+ wechat_resume: '1',
+ wechat_resume_token: 'resume-token-123',
+ openid: 'openid-123',
+ payment_type: 'wxpay',
+ amount: '12.5',
+ order_type: 'subscription',
+ plan_id: '7',
+ state: 'state-123',
+ scope: 'snsapi_base',
+ })).toEqual({
+ foo: 'bar',
+ })
+ })
+})
diff --git a/frontend/src/views/user/paymentUx.ts b/frontend/src/views/user/paymentUx.ts
new file mode 100644
index 00000000..04fc7978
--- /dev/null
+++ b/frontend/src/views/user/paymentUx.ts
@@ -0,0 +1,113 @@
+import { normalizeVisibleMethod } from '@/components/payment/paymentFlow'
+import { extractApiErrorCode } from '@/utils/apiError'
+
+const DISPLAY_METHOD_ALIASES: Record = {
+ wechat: 'wxpay',
+ wechat_pay: 'wxpay',
+}
+
+export interface PaymentScenarioContext {
+ paymentMethod: string
+ isMobile: boolean
+ isWechatBrowser: boolean
+}
+
+export interface PaymentScenarioErrorDescriptor {
+ messageKey: string
+ hintKey?: string
+}
+
+export function normalizePaymentMethodForDisplay(paymentType: string): string {
+ const trimmed = paymentType.trim().toLowerCase()
+ const visibleMethod = normalizeVisibleMethod(trimmed)
+ if (visibleMethod) return visibleMethod
+ return DISPLAY_METHOD_ALIASES[trimmed] ?? trimmed
+}
+
+export function paymentMethodI18nKey(paymentType: string): string {
+ return `payment.methods.${normalizePaymentMethodForDisplay(paymentType)}`
+}
+
+export function buildPaymentErrorToastMessage(message: string, hint?: string): string {
+ if (!hint) return message
+ return `${message} ${hint}`.trim()
+}
+
+function defaultWechatHint(context: PaymentScenarioContext): string {
+ if (!context.isMobile) return 'payment.errors.wechatScanOnDesktopHint'
+ return 'payment.errors.wechatOpenInWeChatHint'
+}
+
+function defaultAlipayHint(context: PaymentScenarioContext): string {
+ if (context.isMobile) return 'payment.errors.alipayMobileOpenHint'
+ return 'payment.errors.alipayDesktopQrHint'
+}
+
+export function describePaymentScenarioError(
+ error: unknown,
+ context: PaymentScenarioContext,
+): PaymentScenarioErrorDescriptor | null {
+ const method = normalizePaymentMethodForDisplay(context.paymentMethod)
+ const code = extractApiErrorCode(error)
+ const message = error instanceof Error
+ ? error.message
+ : (typeof error === 'object' && error && 'message' in error && typeof error.message === 'string'
+ ? error.message
+ : String(error || ''))
+ const normalizedMessage = message.toLowerCase()
+
+ if (method === 'wxpay') {
+ if (code === 'WECHAT_H5_NOT_AUTHORIZED') {
+ return {
+ messageKey: 'payment.errors.wechatH5NotAuthorized',
+ hintKey: defaultWechatHint(context),
+ }
+ }
+ if (code === 'WECHAT_PAYMENT_MP_NOT_CONFIGURED') {
+ return {
+ messageKey: 'payment.errors.wechatPaymentMpNotConfigured',
+ hintKey: context.isWechatBrowser
+ ? 'payment.errors.wechatSwitchBrowserHint'
+ : defaultWechatHint(context),
+ }
+ }
+ if (code === 'NO_AVAILABLE_INSTANCE') {
+ return {
+ messageKey: 'payment.errors.wechatUnavailable',
+ hintKey: defaultWechatHint(context),
+ }
+ }
+ if (code === 'WECHAT_JSAPI_FAILED' || normalizedMessage.includes('get_brand_wcpay_request:fail')) {
+ return {
+ messageKey: 'payment.errors.wechatJsapiFailed',
+ hintKey: defaultWechatHint(context),
+ }
+ }
+ if (
+ normalizedMessage.includes('weixinjsbridge is unavailable') ||
+ normalizedMessage.includes('wechat_jsapi_unavailable')
+ ) {
+ return {
+ messageKey: 'payment.errors.wechatJsapiUnavailable',
+ hintKey: 'payment.errors.wechatOpenInWeChatHint',
+ }
+ }
+ if (code === 'PAYMENT_GATEWAY_ERROR' || code === 'UNHANDLED_PAYMENT_SCENARIO') {
+ return {
+ messageKey: 'payment.errors.wechatUnavailable',
+ hintKey: defaultWechatHint(context),
+ }
+ }
+ }
+
+ if (method === 'alipay' && (code === 'PAYMENT_GATEWAY_ERROR' || code === 'UNHANDLED_PAYMENT_SCENARIO')) {
+ return {
+ messageKey: context.isMobile
+ ? 'payment.errors.alipayMobileUnavailable'
+ : 'payment.errors.alipayDesktopUnavailable',
+ hintKey: defaultAlipayHint(context),
+ }
+ }
+
+ return null
+}
diff --git a/frontend/src/views/user/paymentWechatResume.ts b/frontend/src/views/user/paymentWechatResume.ts
new file mode 100644
index 00000000..8121bc56
--- /dev/null
+++ b/frontend/src/views/user/paymentWechatResume.ts
@@ -0,0 +1,90 @@
+import type { LocationQuery, LocationQueryRaw } from 'vue-router'
+import type { SubscriptionPlan } from '@/types/payment'
+import { normalizeVisibleMethod } from '@/components/payment/paymentFlow'
+
+export interface ParsedWechatResumeRoute {
+ orderAmount: number
+ orderType: 'balance' | 'subscription'
+ paymentType: string
+ planId?: number
+ openid?: string
+ wechatResumeToken?: string
+}
+
+function readQueryString(query: LocationQuery, key: string): string {
+ const value = query[key]
+ if (Array.isArray(value)) {
+ return typeof value[0] === 'string' ? value[0] : ''
+ }
+ return typeof value === 'string' ? value : ''
+}
+
+export function hasWechatResumeQuery(query: LocationQuery): boolean {
+ if (readQueryString(query, 'wechat_resume') === '1') {
+ return true
+ }
+ return readQueryString(query, 'wechat_resume_token') !== ''
+ || readQueryString(query, 'openid') !== ''
+}
+
+export function parseWechatResumeRoute(
+ query: LocationQuery,
+ plans: SubscriptionPlan[],
+ fallbackBalanceAmount: number,
+): ParsedWechatResumeRoute | null {
+ if (!hasWechatResumeQuery(query)) {
+ return null
+ }
+
+ const wechatResumeToken = readQueryString(query, 'wechat_resume_token')
+ const paymentType = normalizeVisibleMethod(readQueryString(query, 'payment_type')) || 'wxpay'
+ const planId = Number.parseInt(readQueryString(query, 'plan_id'), 10)
+ const hasPlanId = Number.isFinite(planId) && planId > 0
+ const orderType = readQueryString(query, 'order_type') === 'subscription' || hasPlanId
+ ? 'subscription'
+ : 'balance'
+
+ if (wechatResumeToken) {
+ return {
+ wechatResumeToken,
+ paymentType,
+ orderType,
+ orderAmount: 0,
+ planId: hasPlanId ? planId : undefined,
+ }
+ }
+
+ const openid = readQueryString(query, 'openid')
+ if (!openid) {
+ return null
+ }
+
+ const rawAmount = Number.parseFloat(readQueryString(query, 'amount'))
+ const orderAmount = Number.isFinite(rawAmount) && rawAmount > 0
+ ? rawAmount
+ : (orderType === 'subscription'
+ ? (plans.find(plan => plan.id === planId)?.price ?? 0)
+ : fallbackBalanceAmount)
+
+ return {
+ openid,
+ paymentType,
+ orderType,
+ orderAmount,
+ planId: hasPlanId ? planId : undefined,
+ }
+}
+
+export function stripWechatResumeQuery(query: LocationQuery): LocationQueryRaw {
+ const nextQuery: LocationQueryRaw = { ...query }
+ delete nextQuery.wechat_resume
+ delete nextQuery.wechat_resume_token
+ delete nextQuery.openid
+ delete nextQuery.state
+ delete nextQuery.scope
+ delete nextQuery.payment_type
+ delete nextQuery.amount
+ delete nextQuery.order_type
+ delete nextQuery.plan_id
+ return nextQuery
+}
