refactor: unify cancel logic with cancelOrderCore and show blocked UI

- Extract cancelOrderCore() shared by user cancel, admin cancel, and timeout expire
- Query payment platform before cancelling: if already paid, run confirmPayment
- Simplify timeout.ts to delegate to cancelOrderCore
- Cancel API returns already_paid outcome for frontend handling
- Show "订单已支付，无法取消" prompt with back button when cancel is blocked

src/lib/order/timeout.ts

@@ -1,7 +1,5 @@
 import { prisma } from '@/lib/db';
-import { initPaymentProviders, paymentRegistry } from '@/lib/payment';
-import type { PaymentType } from '@/lib/payment';
-import { confirmPayment } from './service';
+import { cancelOrderCore } from './service';
 
 const INTERVAL_MS = 30_000; // 30 seconds
 let timer: ReturnType<typeof setInterval> | null = null;
@@ -25,49 +23,16 @@ export async function expireOrders(): Promise<number> {
 
   for (const order of orders) {
     try {
-      // If order has a payment on the platform, check its actual status
-      if (order.paymentTradeNo && order.paymentType) {
-        try {
-          initPaymentProviders();
-          const provider = paymentRegistry.getProvider(order.paymentType as PaymentType);
-
-          // Query the real payment status before expiring
-          const queryResult = await provider.queryOrder(order.paymentTradeNo);
-
-          if (queryResult.status === 'paid') {
-            // User already paid — process as success instead of expiring
-            await confirmPayment({
-              orderId: order.id,
-              tradeNo: order.paymentTradeNo,
-              paidAmount: queryResult.amount,
-              providerName: provider.name,
-            });
-            console.log(`Order ${order.id} was paid during timeout, processed as success`);
-            continue;
-          }
-
-          // Not paid — cancel on the platform
-          if (provider.cancelPayment) {
-            try {
-              await provider.cancelPayment(order.paymentTradeNo);
-            } catch (cancelErr) {
-              // Cancel may fail if session already expired on platform side — that's fine
-              console.warn(`Failed to cancel payment for order ${order.id}:`, cancelErr);
-            }
-          }
-        } catch (platformErr) {
-          // Platform unreachable — still expire the order locally
-          console.warn(`Platform check failed for order ${order.id}, expiring anyway:`, platformErr);
-        }
-      }
-
-      // Mark as expired in database (WHERE status='PENDING' ensures idempotency)
-      const result = await prisma.order.updateMany({
-        where: { id: order.id, status: 'PENDING' },
-        data: { status: 'EXPIRED' },
+      const outcome = await cancelOrderCore({
+        orderId: order.id,
+        paymentTradeNo: order.paymentTradeNo,
+        paymentType: order.paymentType,
+        finalStatus: 'EXPIRED',
+        operator: 'timeout',
+        auditDetail: 'Order expired',
       });
 
-      if (result.count > 0) expiredCount++;
+      if (outcome === 'cancelled') expiredCount++;
     } catch (err) {
       console.error(`Error expiring order ${order.id}:`, err);
     }