feat: P1阶段完成 - 订单模块迁移与重构

## P1.3: 订单模块(orders)

### 完整迁移
- 迁移 API: orders.ts
- 迁移 Views: 5个页面(桌面3 + 移动2)
- 迁移 Composables: useOrderSnapshot.ts
- 更新所有导入路径到 shared/

### 核心重构:拆分 useOrderDetail.ts
原始文件405行,混合了订单、支付、结算、争议等多个领域

**拆分为3个独立 composables:**

1. **usePaymentPolling.ts** - 支付轮询
   - 职责:轮询查询支付状态直到完成
   - 功能:开始/停止轮询、检查支付状态、自动重载
   - 代码:~65行

2. **useSettlement.ts** - 结算流程
   - 职责:处理订单结算完整流程
   - 功能:提交/接受/反驳/确认结算、表单管理
   - 代码:~170行

3. **useOrderDetail.ts** - 核心订单(重构后)
   - 职责:订单核心流程,组合使用上述composables
   - 功能:加载、取消、支付、交接、收货、争议
   - 代码:~215行

**重构优势:**
- 职责清晰,单一职责原则
- 可复用,支付和结算逻辑可独立使用
- 易测试,每个composable独立可测
- 易维护,从405行拆分为3个文件

### 技术改进
- 建立清晰的模块边界和导出规范
- 避免循环依赖
- 提高代码可测试性和可维护性

## 里程碑

🎉 **P1 阶段完成!**

-  P0: 基础设施(shared/)- 22个文件
-  P1.1: 钱包模块 - 5个文件
-  P1.2: 聊天模块 - 8个文件
-  P1.3: 订单模块 - 11个文件

**总计:** 3个核心业务模块,46个文件完成迁移

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
yml2213
2026-06-04 08:45:31 +08:00
co-authored by Claude Opus 4.7
parent b5903a169f
commit 125d83f2f2
13 changed files with 5075 additions and 146 deletions
@@ -0,0 +1,228 @@
import { computed, ref, onMounted } from 'vue'
import { useRoute } from 'vue-router'
import type { Order, HandoffRecord } from '../api/orders'
import {
fetchOrder,
fetchHandoffRecords,
cancelOrder,
startOrderPayment,
submitHandoff,
confirmReceive,
} from '../api/orders'
import { createDispute } from '@/api/disputes'
import { uploadFile } from '@/api/files'
import { fetchOrderChat } from '@/api/chats'
import { useSessionStore } from '@/stores/session'
import { usePaymentPolling } from './usePaymentPolling'
import { useSettlement } from './useSettlement'
/**
* 订单详情 Composable
* 负责订单的核心流程:加载、取消、支付、交接、收货
* 结算和支付轮询逻辑已拆分到独立 composables
*/
export function useOrderDetail() {
const route = useRoute()
const session = useSessionStore()
// Loading states
const loading = ref(false)
const cancelling = ref(false)
const startingPayment = ref(false)
const handoffing = ref(false)
const confirming = ref(false)
const disputing = ref(false)
const uploadingEvidence = ref(false)
const openingChat = ref(false)
// Data
const order = ref<Order | null>(null)
const handoffRecords = ref<HandoffRecord[]>([])
const handoffContent = ref('')
// Dispute form
const disputeType = ref('cannot_login')
const disputeDescription = ref('')
const disputeEvidenceText = ref('')
// 使用拆分的 composables
const paymentPolling = usePaymentPolling()
const settlement = useSettlement(order)
// Computed
const isOwner = computed(() => order.value?.owner_id === session.userId)
const isRenter = computed(() => order.value?.renter_id === session.userId)
const orderAmountLabel = computed(() => (isOwner.value ? '我的租金' : '订单金额'))
const canOpenDispute = computed(() => {
if (!order.value || (!isOwner.value && !isRenter.value)) return false
return !['completed', 'cancelled', 'closed', 'disputing', 'checkout_disputing', 'abnormal'].includes(
order.value.status
)
})
const isCheckoutDisputeStage = computed(() => {
return !!order.value && ['pending_checkout_confirm', 'pending_checkout_accept'].includes(order.value.status)
})
// Methods
async function loadOrder() {
loading.value = true
try {
order.value = await fetchOrder(String(route.params.id))
handoffRecords.value = await fetchHandoffRecords(String(route.params.id))
return order.value
} finally {
loading.value = false
}
}
async function handleCancel() {
if (!order.value) return false
cancelling.value = true
try {
await cancelOrder(order.value.id)
await loadOrder()
return true
} finally {
cancelling.value = false
}
}
async function handlePay() {
if (!order.value) return null
startingPayment.value = true
try {
const payment = await startOrderPayment(order.value.id)
// 开始支付轮询,成功后重新加载订单
paymentPolling.startPaymentPolling(payment, loadOrder)
return payment
} finally {
startingPayment.value = false
}
}
async function handleSubmitHandoff() {
if (!order.value || !handoffContent.value.trim()) return false
handoffing.value = true
try {
await submitHandoff(order.value.id, handoffContent.value.trim())
handoffContent.value = ''
await loadOrder()
return true
} finally {
handoffing.value = false
}
}
async function handleConfirmReceive() {
if (!order.value) return false
confirming.value = true
try {
await confirmReceive(order.value.id)
await loadOrder()
return true
} finally {
confirming.value = false
}
}
async function handleCreateDispute() {
if (!order.value) return false
disputing.value = true
try {
await createDispute({
order_id: order.value.id,
type: disputeType.value,
description: disputeDescription.value.trim(),
evidence: disputeEvidenceText.value.trim(),
})
await loadOrder()
return true
} finally {
disputing.value = false
}
}
async function handleUploadEvidence(file: File) {
uploadingEvidence.value = true
try {
const result = await uploadFile(file)
return result.url
} finally {
uploadingEvidence.value = false
}
}
async function handleOpenChat() {
if (!order.value) return null
openingChat.value = true
try {
const chat = await fetchOrderChat(order.value.id)
return chat
} finally {
openingChat.value = false
}
}
function getOrderStep(status: string) {
const stepMap: Record<string, number> = {
pending_payment: 0,
pending_handoff: 1,
renting: 2,
overdue: 2,
pending_checkout_confirm: 3,
pending_checkout_accept: 3,
completed: 4,
cancelled: 0,
closed: 4,
}
return stepMap[status] ?? 0
}
onMounted(loadOrder)
return {
// States
loading,
cancelling,
startingPayment,
handoffing,
confirming,
disputing,
uploadingEvidence,
openingChat,
// Data
order,
handoffRecords,
handoffContent,
// Dispute form
disputeType,
disputeDescription,
disputeEvidenceText,
// Computed
isOwner,
isRenter,
orderAmountLabel,
canOpenDispute,
isCheckoutDisputeStage,
// Methods
loadOrder,
handleCancel,
handlePay,
handleSubmitHandoff,
handleConfirmReceive,
handleCreateDispute,
handleUploadEvidence,
handleOpenChat,
getOrderStep,
// 从拆分的 composables 导出
...paymentPolling,
...settlement,
}
}
@@ -0,0 +1,147 @@
import type { Order } from '../api/orders'
export interface SnapshotResource {
key: string
label: string
quantity: number
unitPrice: number
chargeMode: '赠送' | '收费'
}
export function readSnapshot(order: Order | null) {
if (!order?.listing_snapshot) return null
try {
return JSON.parse(order.listing_snapshot) as Record<string, any>
} catch {
return null
}
}
export function readNumber(value: unknown): number {
const parsed = Number(value)
return Number.isFinite(parsed) ? parsed : 0
}
export function roundQuantity(value: number): number {
return Math.round(value * 10) / 10
}
export function roundMoney(value: number): number {
return Math.round(value * 100) / 100
}
export function readSnapshotResources(order: Order | null): SnapshotResource[] {
const snapshot = readSnapshot(order)
if (!snapshot?.quantities) return []
const quantities = snapshot.quantities as Record<string, any>[]
return quantities
.map((item) => ({
key: String(item.key || ''),
label: String(item.label || ''),
quantity: readNumber(item.quantity),
unitPrice: readNumber(item.price),
chargeMode: item.charge_mode === '收费' ? '收费' : '赠送',
}))
.filter((item) => item.key && item.label)
}
export function isChargedResource(resource: SnapshotResource): boolean {
return resource.chargeMode === '收费'
}
export function getSnapshotHafCoinM(order: Order | null): number {
const snapshot = readSnapshot(order)
return roundQuantity(readNumber(snapshot?.haf_coin_amount) / 1000000)
}
export function calculateResourceChargeAmount(
resources: SnapshotResource[],
resourceUsage: Record<string, number>
): number {
return roundMoney(
resources.reduce((sum, item) => {
if (!isChargedResource(item)) return sum
const used = resourceUsage[item.key] || 0
return sum + used * item.unitPrice
}, 0)
)
}
export function calculateCheckoutTotal(
resourceCharge: number,
consumableAmount: number,
coinConsumed: number,
otherAmount: number
): number {
return roundMoney(resourceCharge + consumableAmount + coinConsumed + otherAmount)
}
export function calculateCounterTotal(counterForm: {
consumable_amount: number
coin_consumed_m: number
other_amount: number
deposit_deduct_amount: number
}): number {
return roundMoney(
counterForm.consumable_amount +
counterForm.coin_consumed_m +
counterForm.other_amount +
counterForm.deposit_deduct_amount
)
}
export function hydrateResourceUsageFromOrder(
order: Order | null,
resources: SnapshotResource[]
): Record<string, number> {
const usage: Record<string, number> = {}
if (!order?.checkout_info) {
return usage
}
try {
const info = JSON.parse(order.checkout_info) as Record<string, any>
const consumedResources = info.consumed_resources as Record<string, number> | undefined
if (consumedResources) {
resources.forEach((res) => {
if (res.key in consumedResources) {
usage[res.key] = consumedResources[res.key]
}
})
}
} catch {
// ignore
}
return usage
}
export function hydrateCounterFormFromOrder(order: Order | null) {
if (!order?.counter_info) {
return null
}
try {
const info = JSON.parse(order.counter_info) as Record<string, any>
return {
consumable_amount: readNumber(info.consumable_amount),
coin_consumed_m: readNumber(info.coin_consumed_m),
other_amount: readNumber(info.other_amount),
deposit_deduct_amount: readNumber(info.deposit_deduct_amount),
reason: String(info.reason || ''),
evidenceText: String(info.evidence || ''),
}
} catch {
return null
}
}
export function readError(error: unknown, fallback: string): string {
if (error && typeof error === 'object' && 'message' in error) {
return String(error.message)
}
return fallback
}
@@ -0,0 +1,65 @@
import { ref, onBeforeUnmount } from 'vue'
import { queryOrderPayment, type PaymentOrder } from '../api/orders'
/**
* 支付轮询 Composable
* 负责轮询查询支付状态,直到支付完成
*/
export function usePaymentPolling() {
const activePayment = ref<PaymentOrder | null>(null)
const checkingPayment = ref(false)
let paymentPollingTimer: number | undefined
/**
* 开始轮询支付状态
*/
function startPaymentPolling(payment: PaymentOrder, onSuccess?: () => void) {
activePayment.value = payment
stopPaymentPolling()
paymentPollingTimer = window.setInterval(() => checkPaymentStatus(onSuccess), 2000)
}
/**
* 停止轮询
*/
function stopPaymentPolling() {
if (paymentPollingTimer !== undefined) {
clearInterval(paymentPollingTimer)
paymentPollingTimer = undefined
}
activePayment.value = null
}
/**
* 检查支付状态
*/
async function checkPaymentStatus(onSuccess?: () => void) {
if (!activePayment.value || checkingPayment.value) return false
checkingPayment.value = true
try {
const updated = await queryOrderPayment(activePayment.value.id)
if (updated.paid) {
stopPaymentPolling()
onSuccess?.()
return true
}
} catch {
// 忽略轮询错误,继续下次轮询
} finally {
checkingPayment.value = false
}
return false
}
// 组件卸载时停止轮询
onBeforeUnmount(stopPaymentPolling)
return {
activePayment,
checkingPayment,
startPaymentPolling,
stopPaymentPolling,
checkPaymentStatus,
}
}
@@ -0,0 +1,167 @@
import { ref, computed } from 'vue'
import { submitCheckout, acceptCheckout, counterCheckout, confirmCheckout } from '../api/orders'
import type { Order } from '../api/orders'
export interface CheckoutForm {
content: string
consumable_amount: number
coin_consumed_m: number
other_amount: number
evidenceText: string
}
export interface CounterForm {
consumable_amount: number
coin_consumed_m: number
other_amount: number
deposit_deduct_amount: number
reason: string
evidenceText: string
}
/**
* 订单结算 Composable
* 负责处理订单结算流程:提交结算、接受结算、反驳结算、确认结算
*/
export function useSettlement(order: globalThis.Ref<Order | null>) {
const returning = ref(false)
const acceptingCheckout = ref(false)
const countering = ref(false)
const rejectingCheckout = ref(false)
const completing = ref(false)
const checkoutForm = ref<CheckoutForm>({
content: '',
consumable_amount: 0,
coin_consumed_m: 0,
other_amount: 0,
evidenceText: '',
})
const counterForm = ref<CounterForm>({
consumable_amount: 0,
coin_consumed_m: 0,
other_amount: 0,
deposit_deduct_amount: 0,
reason: '',
evidenceText: '',
})
const resourceUsage = ref<Record<string, number>>({})
/**
* 提交结算单
*/
async function handleSubmitCheckout(onSuccess?: () => void) {
if (!order.value) return false
returning.value = true
try {
await submitCheckout(order.value.id, {
content: checkoutForm.value.content.trim(),
consumable_amount: checkoutForm.value.consumable_amount,
coin_consumed_m: checkoutForm.value.coin_consumed_m,
other_amount: checkoutForm.value.other_amount,
evidence: checkoutForm.value.evidenceText.trim(),
})
onSuccess?.()
return true
} finally {
returning.value = false
}
}
/**
* 接受对方的结算
*/
async function handleAcceptCheckout(onSuccess?: () => void) {
if (!order.value) return false
acceptingCheckout.value = true
try {
await acceptCheckout(order.value.id)
onSuccess?.()
return true
} finally {
acceptingCheckout.value = false
}
}
/**
* 反驳对方的结算
*/
async function handleCounterCheckout(onSuccess?: () => void) {
if (!order.value) return false
countering.value = true
try {
await counterCheckout(order.value.id, {
consumable_amount: counterForm.value.consumable_amount,
coin_consumed_m: counterForm.value.coin_consumed_m,
other_amount: counterForm.value.other_amount,
deposit_deduct_amount: counterForm.value.deposit_deduct_amount,
reason: counterForm.value.reason.trim(),
evidence: counterForm.value.evidenceText.trim(),
})
onSuccess?.()
return true
} finally {
countering.value = false
}
}
/**
* 拒绝对方的结算(简化版反驳)
*/
async function handleRejectCheckout(reason: string, onSuccess?: () => void) {
if (!order.value) return false
rejectingCheckout.value = true
try {
await counterCheckout(order.value.id, {
consumable_amount: 0,
coin_consumed_m: 0,
other_amount: 0,
deposit_deduct_amount: 0,
reason: reason.trim(),
evidence: '',
})
onSuccess?.()
return true
} finally {
rejectingCheckout.value = false
}
}
/**
* 确认最终结算
*/
async function handleConfirmCheckout(onSuccess?: () => void) {
if (!order.value) return false
completing.value = true
try {
await confirmCheckout(order.value.id)
onSuccess?.()
return true
} finally {
completing.value = false
}
}
return {
// Loading states
returning,
acceptingCheckout,
countering,
rejectingCheckout,
completing,
// Forms
checkoutForm,
counterForm,
resourceUsage,
// Methods
handleSubmitCheckout,
handleAcceptCheckout,
handleCounterCheckout,
handleRejectCheckout,
handleConfirmCheckout,
}
}