import mongoose from "mongoose"; import { DBModel } from "../models/index.js"; import config from "../config.js"; import logger from "../utils/logger.js"; import ResponseUtil from "../utils/responseUtil.js"; import { isAdmin } from "../utils/permissions.js"; import * as wxpay from "../utils/wechatpay.js"; const { WechatPayError } = wxpay; const PAYABLE_ORDER_STATUS = ["pending", "confirmed"]; const ACTIVE_PAYMENT_STATUS = ["created", "closed_unconfirmed"]; const DEFAULT_REFUND_REASON = "订单取消"; // 同一订单的 createPayment 串行执行,防止并发产生多条在途流水 const payLocks = new Map(); function withPayLock(key, fn) { const previous = payLocks.get(key) || Promise.resolve(); const current = previous.then(fn, fn); const tracked = current.then( () => { if (payLocks.get(key) === tracked) payLocks.delete(key); }, () => { if (payLocks.get(key) === tracked) payLocks.delete(key); } ); payLocks.set(key, tracked); return current; } function isValidObjectId(value) { return mongoose.Types.ObjectId.isValid(value); } function nowMs() { return Date.now(); } function toDate(value) { if (!value) return null; const date = value instanceof Date ? value : new Date(value); return Number.isNaN(date.getTime()) ? null : date; } // 支付页轮询会高频触发查单:短 TTL 缓存 + 同号合并,避免把前端轮询放大成微信侧流量。 // 只用于 queryPayment,后台巡检/关单仍直接查微信,保证收敛判断拿到最新状态 const ORDER_QUERY_TTL = 3000; const ORDER_QUERY_CACHE_MAX = 1000; /** * 创建查单缓存 * * - TTL 内重复查询直接复用结果; * - 同一 outTradeNo 的并发请求共享同一次上游调用; * - 查询失败不缓存,下一轮仍会重试。 * * @param {Object} [options] * @param {number} [options.ttl] 缓存毫秒数 * @param {number} [options.maxSize] 最大缓存条数 * @param {Function} [options.query] 实际查单函数 * @param {Function} [options.now] 时钟(测试注入) * @returns {Function} (outTradeNo, { force }?) => Promise */ export function createOrderQueryCache({ ttl = ORDER_QUERY_TTL, maxSize = ORDER_QUERY_CACHE_MAX, query = (outTradeNo) => wxpay.queryOrder(outTradeNo), now = nowMs, } = {}) { const cache = new Map(); const inFlight = new Map(); const prune = () => { const time = now(); for (const [key, entry] of cache) { if (entry.expiresAt <= time) cache.delete(key); } while (cache.size > maxSize) { cache.delete(cache.keys().next().value); } }; return async function queryOrderCached(outTradeNo, { force = false } = {}) { if (!outTradeNo) return query(outTradeNo); if (!force) { const hit = cache.get(outTradeNo); if (hit && hit.expiresAt > now()) return hit.trade; } const running = inFlight.get(outTradeNo); if (running) return running; const task = Promise.resolve() .then(() => query(outTradeNo)) .then((trade) => { cache.set(outTradeNo, { trade, expiresAt: now() + ttl }); prune(); return trade; }) .finally(() => { inFlight.delete(outTradeNo); }); inFlight.set(outTradeNo, task); return task; }; } const queryOrderForPolling = createOrderQueryCache(); // 微信侧已明确终结的交易状态:可以直接把本地流水收敛为 closed const CLOSED_TRADE_STATES = ["CLOSED", "PAYERROR", "REFUND", "REVOKED"]; function replySuccess(ctx) { // 官方约定:验签通过应答 200/204,无需返回应答报文 ctx.status = 200; ctx.type = "application/json"; ctx.body = ""; } function replyFail(ctx, httpStatus, message) { ctx.status = httpStatus >= 400 && httpStatus < 600 ? httpStatus : 500; ctx.type = "application/json"; ctx.body = JSON.stringify({ code: "FAIL", message: String(message || "处理失败").slice(0, 200) }); } class HandlerPayment { /** * 支付窗口终点:订单创建时间 + payWindowHours,且不晚于服务开始当天 23:59:59(+08:00) * 窗口起点固定为下单时间,重复发起支付不延长。 * @param {Object} record escort_record 文档或 plain object * @returns {Date|null} */ static getPayWindowEnd(record) { const meta = record?.meta || {}; const created = toDate(meta.createtime || meta.updatetime); if (!created) return null; const cfg = config.wechatpay || {}; const hours = Number(cfg.payWindowHours); const windowHours = Number.isFinite(hours) && hours > 0 ? hours : 24; let end = created.getTime() + windowHours * 60 * 60 * 1000; const scheduleDate = toDate(record?.schedule?.date); if (scheduleDate) { // schedule.date 以 UTC 零点保存;服务开始当天 23:59:59.999(+08:00)= 同日 15:59:59.999 UTC const dayEnd = Date.UTC( scheduleDate.getUTCFullYear(), scheduleDate.getUTCMonth(), scheduleDate.getUTCDate(), 15, 59, 59, 999 ); if (dayEnd < end) end = dayEnd; } return new Date(end); } static isPayWindowExpired(record, now = new Date()) { const end = HandlerPayment.getPayWindowEnd(record); if (!end) return false; return now.getTime() > end.getTime(); } /** * 订单访问权:本人、管理员、该单陪诊师 */ static canAccess(user, record) { if (!record) return false; if (isAdmin(user)) return true; if (String(record.userId) === String(user?._id)) return true; return Boolean(record.attendant?.id) && String(record.attendant.id) === String(user?._id); } static mapTransaction(source = {}) { return { transactionId: source.transaction_id || "", payerTotal: Number(source.amount?.payer_total ?? source.amount?.total ?? 0), bankType: source.bank_type || "", successTime: toDate(source.success_time), }; } /** * 查单结果入账前核对:商户号 / appid / 金额必须与本地流水一致, * 验签只证明报文来自微信,不证明这笔钱属于这笔订单。 */ static verifyTrade(trade = {}, payment) { const cfg = config.wechatpay || {}; const mismatch = (code, message) => new WechatPayError({ stage: "query", code, message, requestId: trade.requestId || "", httpStatus: trade.httpStatus || 200, }); if (trade.mchid && String(trade.mchid) !== String(cfg.mchid || "")) { throw mismatch("MCHID_MISMATCH", "查单商户号与本地配置不一致"); } if (trade.appid && String(trade.appid) !== String(cfg.appid || "")) { throw mismatch("APPID_MISMATCH", "查单 appid 与本地配置不一致"); } if (String(trade.amount?.currency || "") !== "CNY" || Number(trade.amount?.total) !== Number(payment.totalFee)) { throw mismatch("AMOUNT_MISMATCH", "查单金额与本地流水不一致"); } return true; } static async markPaymentError(paymentId, err, stage) { if (!paymentId) return; const detail = { stage: err?.stage || stage || "", code: err?.code || "UNKNOWN", message: err?.message || String(err || ""), requestId: err?.requestId || "", httpStatus: err?.httpStatus || 0, at: new Date(), }; try { await DBModel.PaymentRecord.markError(paymentId, detail); } catch (updateErr) { logger.error( `[payment] 写支付错误信息失败 paymentId=${paymentId} code=${detail.code} requestId=${detail.requestId}: ${updateErr.message}` ); } } static async markRefundError(refundId, err, stage) { if (!refundId) return; const detail = { stage: err?.stage || stage || "", code: err?.code || "UNKNOWN", message: err?.message || String(err || ""), requestId: err?.requestId || "", httpStatus: err?.httpStatus || 0, at: new Date(), }; try { await DBModel.RefundRecord.markError(refundId, detail); } catch (updateErr) { logger.error( `[payment] 写退款错误信息失败 refundId=${refundId} code=${detail.code} requestId=${detail.requestId}: ${updateErr.message}` ); } } static async setPaymentStatus(paymentId, status, extra = {}) { await DBModel.PaymentRecord.updateOne( { _id: paymentId }, { $set: { ...extra, status, "meta.updatetime": nowMs() } } ); } /** * 支付成功收敛:流水 → pay_success,订单快照 → paid * 订单已取消(cancelStatus 非 none)时不刷 paid,返回 cancelled 由调用方发起退款。 * @returns {{ payment: Object, record: Object|null, cancelled: boolean }} */ static async applyPaymentSuccess(paymentRecord, transaction = {}) { const setFields = { status: "pay_success", payerTotal: Number(transaction.payerTotal) || Number(paymentRecord.totalFee) || 0, bankType: transaction.bankType || paymentRecord.bankType || "", successTime: transaction.successTime || paymentRecord.successTime || new Date(), paidAt: new Date(), "meta.updatetime": nowMs(), }; // 稀疏唯一索引:没有真实交易号时不要写入空串,否则第二条流水会撞唯一索引 const transactionId = transaction.transactionId || paymentRecord.transactionId; if (transactionId) setFields.transactionId = transactionId; // closed 也允许回写:关单与支付成功存在竞态(关单瞬间用户完成支付), // 流水可能已被置为 closed,但微信侧确实是 SUCCESS。 // 不允许恢复就会丢 transactionId,退款时找不到 pay_success 流水只能人工核对 const updated = await DBModel.PaymentRecord.findOneAndUpdate( { _id: paymentRecord._id, status: { $in: [...ACTIVE_PAYMENT_STATUS, "closed"] } }, { $set: setFields }, { new: true } ); const payment = updated || await DBModel.PaymentRecord.findById(paymentRecord._id) || paymentRecord; const record = await DBModel.EscortRecord.findById(payment.recordId); if (!record || record.deletedAt) { return { payment, record: null, cancelled: true }; } // 只有正式取消才退款(兼容旧数据 status=cancelled); // 仅「待取消」时钱已到账仍按已支付如实记账,等陪诊师/平台确认取消时再退 if ((record.cancelStatus || "none") === "cancelled" || record.status === "cancelled") { return { payment, record, cancelled: true }; } // 已进入退款阶段的流水不再回刷 paid,避免快照倒退 if (!["refunding", "refunded"].includes(payment.status)) { await DBModel.EscortRecord.updateRecord(payment.recordId, { "payment.status": "paid", "payment.method": "online_wechat", "payment.paidFee": Number(record.payment?.totalFee) || 0, "payment.paymentRecordId": payment._id, }); } return { payment, record, cancelled: false }; } /** * 关闭该单所有在途流水(切换线下 / 取消 / 删除 / 支付窗口到期的前置动作) * 关单失败必须当场查单:已支付则收敛为 pay_success,否则标记 closed_unconfirmed 放行。 * @returns {{ closed: number, paid: number, unconfirmed: number }} */ static async closeOpenPayRecords(recordId) { const result = { closed: 0, paid: 0, unconfirmed: 0 }; if (!isValidObjectId(recordId)) return result; const payments = await DBModel.PaymentRecord.find({ recordId, status: { $in: ACTIVE_PAYMENT_STATUS }, }); for (const payment of payments) { if (!wxpay.isConfigured()) { // 未配置时无法关单,按「结果不确定」留痕,避免误以为已关 await HandlerPayment.setPaymentStatus(payment._id, "closed_unconfirmed", { closeUnconfirmed: true, }); result.unconfirmed += 1; continue; } try { await wxpay.closeOrder(payment.outTradeNo); await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); result.closed += 1; continue; } catch (err) { await HandlerPayment.markPaymentError(payment._id, err, "close"); if (err instanceof WechatPayError && err.code === "ORDER_CLOSED") { await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); result.closed += 1; continue; } } // 关单失败:立即查单确认,不等巡检 try { const trade = await wxpay.queryOrder(payment.outTradeNo); if (trade.trade_state === "SUCCESS") { HandlerPayment.verifyTrade(trade, payment); const applied = await HandlerPayment.applyPaymentSuccess(payment, HandlerPayment.mapTransaction(trade)); if (applied.cancelled) { HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((refundErr) => { logger.error(`[payment] 关单时发现已支付且订单已取消,退款失败 recordId=${payment.recordId}: ${refundErr?.message || refundErr}`); }); } result.paid += 1; } else { await HandlerPayment.setPaymentStatus(payment._id, "closed_unconfirmed", { closeUnconfirmed: true, }); result.unconfirmed += 1; } } catch (queryErr) { await HandlerPayment.markPaymentError(payment._id, queryErr, "query"); await HandlerPayment.setPaymentStatus(payment._id, "closed_unconfirmed", { closeUnconfirmed: true, }); result.unconfirmed += 1; } } return result; } static async applyRefundResult(refundRecord, result = {}) { // 退款回调字段为 refund_status,退款申请/查询接口字段为 status const rawStatus = String(result.refund_status || result.status || ""); const statusMap = { SUCCESS: "success", ABNORMAL: "abnormal", CLOSED: "closed", PROCESSING: "processing", }; const status = statusMap[rawStatus] || refundRecord.status; const setFields = { status, userReceivedAccount: result.user_received_account || refundRecord.userReceivedAccount || "", successTime: toDate(result.success_time) || refundRecord.successTime || null, lastQueriedAt: new Date(), "meta.updatetime": nowMs(), }; // 同 transactionId:refundId 为稀疏唯一索引,无值时不能写空串 const refundId = result.refund_id || refundRecord.refundId; if (refundId) setFields.refundId = refundId; if (status === "success") { await DBModel.RefundRecord.updateOne( { _id: refundRecord._id }, { $set: setFields } ); const recordSet = { "payment.status": "refunded", "meta.updatetime": nowMs() }; if (refundId) { recordSet["payment.refundNo"] = refundId; recordSet["payment.refundedAt"] = setFields.successTime || new Date(); } await DBModel.PaymentRecord.updateOne( { _id: refundRecord.paymentId }, { $set: { status: "refunded", "meta.updatetime": nowMs() } } ); await DBModel.EscortRecord.updateOne( { _id: refundRecord.recordId }, { $set: recordSet } ); } else { // 创建/查询响应可能晚于成功回调返回。非成功结果只能在退款尚未成功时落库, // 否则迟到的 PROCESSING 会把 success/refunded 回退成 processing/refunding。 const updated = await DBModel.RefundRecord.updateOne( { _id: refundRecord._id, status: { $ne: "success" } }, { $set: setFields } ); const matched = updated?.matchedCount ?? updated?.n; if (matched === 0) return "success"; await DBModel.PaymentRecord.updateOne( { _id: refundRecord.paymentId, status: { $ne: "refunded" } }, { $set: { status: "refunding", "meta.updatetime": nowMs() } } ); await DBModel.EscortRecord.updateOne( { _id: refundRecord.recordId, "payment.status": { $ne: "refunded" } }, { $set: { "payment.status": "refunding", "meta.updatetime": nowMs() } } ); } return status; } /** * 取消已支付订单的自动原路退款(一单一笔全额退款,outRefundNo 固定 -R1) * 先落 refund_record(processing) 再调接口;超时/系统异常先查退款,未受理则原单号重试一次。 * retry=true 时允许对已存在的退款流水按同一 outRefundNo 再次发起(微信对该单号幂等)。 */ static async createRefundForRecord(record, { reason, retry = false } = {}) { const recordId = record?._id ? String(record._id) : ""; if (!isValidObjectId(recordId)) return { skipped: true }; const payment = await DBModel.PaymentRecord.findOne({ recordId, status: { $in: ["pay_success", "refunding"] }, }).sort({ paidAt: -1, createdAt: -1 }); if (!payment) { // 手工标记的「线上微信已收款」没有支付流水,无法原路退款;留 refunding 交人工核对 logger.error(`[payment] 退款未发起:缺少成功支付流水 recordId=${recordId},请人工核对收款方式`); return { skipped: true, reason: "no_payment_record" }; } const outRefundNo = `${recordId}-R1`; const existing = await DBModel.RefundRecord.findOne({ outRefundNo }); if (existing) { if (existing.status === "success") { await HandlerPayment.applyRefundResult(existing, { status: "SUCCESS", refund_id: existing.refundId, user_received_account: existing.userReceivedAccount, success_time: existing.successTime, }); return existing; } // 默认 processing 不重复调接口;abnormal/closed 转人工;retry=true 时按同号重试 if (!retry) return existing; } if (!wxpay.isConfigured()) { logger.warn(`[payment] 退款未执行:微信支付未配置 recordId=${recordId}`); return { skipped: true }; } const refundReason = String(reason || record?.cancelReason || existing?.reason || DEFAULT_REFUND_REASON).slice(0, 120); let refundRecord; if (existing) { await DBModel.RefundRecord.updateOne( { _id: existing._id }, { $set: { reason: refundReason, lastAttemptAt: new Date(), "meta.updatetime": nowMs() } } ); refundRecord = await DBModel.RefundRecord.findById(existing._id); } else { try { refundRecord = await DBModel.RefundRecord.create({ paymentId: payment._id, recordId: payment.recordId, outTradeNo: payment.outTradeNo, outRefundNo, refundAmount: Number(payment.totalFee) || 0, totalAmount: Number(payment.totalFee) || 0, reason: refundReason, status: "processing", createdAt: new Date(), }); } catch (err) { if (err?.code === 11000) { return await DBModel.RefundRecord.findOne({ outRefundNo }); } throw err; } } // 先落库再调外部接口,并先把订单快照置为退款中 await DBModel.EscortRecord.updateOne( { _id: payment.recordId, "payment.status": { $ne: "refunded" } }, { $set: { "payment.status": "refunding", "meta.updatetime": nowMs() } } ); const refundParams = { outTradeNo: payment.outTradeNo, outRefundNo, reason: refundReason, refundAmount: Number(payment.totalFee) || 0, totalAmount: Number(payment.totalFee) || 0, notifyUrl: wxpay.getNotifyUrls().refundUrl, }; try { const result = await wxpay.createRefund(refundParams); await HandlerPayment.applyRefundResult(refundRecord, result); return await DBModel.RefundRecord.findById(refundRecord._id); } catch (err) { await HandlerPayment.markRefundError(refundRecord._id, err, "refund"); const uncertain = err instanceof WechatPayError && (err.code === "NETWORK_ERROR" || err.httpStatus >= 500 || err.httpStatus === 0); if (!uncertain) { // 明确业务错误(余额不足等)转人工,保持 processing logger.error(`[payment] 退款业务失败 recordId=${recordId} code=${err?.code || ""} requestId=${err?.requestId || ""}`); return await DBModel.RefundRecord.findById(refundRecord._id); } // 结果不确定:先查退款确认是否已受理 try { const queried = await wxpay.queryRefundResult(outRefundNo); await HandlerPayment.applyRefundResult(refundRecord, queried); return await DBModel.RefundRecord.findById(refundRecord._id); } catch (queryErr) { await HandlerPayment.markRefundError(refundRecord._id, queryErr, "refund_query"); } // 未查到受理记录:同一 outRefundNo 原参数重试一次 try { const retried = await wxpay.createRefund(refundParams); await HandlerPayment.applyRefundResult(refundRecord, retried); } catch (retryErr) { await HandlerPayment.markRefundError(refundRecord._id, retryErr, "refund"); logger.error(`[payment] 退款重试仍失败 recordId=${recordId} code=${retryErr?.code || ""} requestId=${retryErr?.requestId || ""}`); } return await DBModel.RefundRecord.findById(refundRecord._id); } } // ==================== HTTP 入口 ==================== /** * POST /escort-record/:id/pay */ async createPayment(ctx) { const id = ctx.params.id; const user = ctx.state.user; if (!isValidObjectId(id)) return ResponseUtil.badRequest(ctx, "缺少记录ID"); return withPayLock(String(id), async () => { try { const record = await DBModel.EscortRecord.findById(id); if (!record || record.deletedAt) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); if (String(record.userId) !== String(user?._id)) { return ResponseUtil.forbidden(ctx, "只能支付自己的订单"); } const payChannel = record.payment?.payChannel || "offline"; if (payChannel !== "online_wechat") { return ResponseUtil.badRequest(ctx, "请先切换为微信支付"); } if ((record.cancelStatus || "none") !== "none" || record.status === "cancelled") { return ResponseUtil.badRequest(ctx, "订单已取消或正在取消,无法支付"); } if (!PAYABLE_ORDER_STATUS.includes(record.status)) { return ResponseUtil.badRequest(ctx, "当前订单状态不支持支付"); } if ((record.payment?.status || "unpaid") !== "unpaid") { return ResponseUtil.badRequest(ctx, "订单已支付,请勿重复支付"); } if (!wxpay.isConfigured()) { logger.warn(`[payment] 微信支付未配置,拒绝发起支付 recordId=${id}:${wxpay.getConfigDiagnostics().join(";")}`); return ResponseUtil.error(ctx, "支付功能暂未开放,请选择线下支付", null, 503); } const totalFeeFen = wxpay.yuanToFen(record.payment?.totalFee); if (!totalFeeFen || totalFeeFen <= 0) { return ResponseUtil.badRequest(ctx, "订单金额不正确,暂不能线上支付"); } const windowEnd = HandlerPayment.getPayWindowEnd(record); if (!windowEnd) return ResponseUtil.badRequest(ctx, "订单时间信息异常,暂不能支付"); const now = new Date(); if (HandlerPayment.isPayWindowExpired(record, now)) { return ResponseUtil.badRequest(ctx, "支付已超时,请选择线下支付或取消订单"); } // time_expire 必须落在 now + 1 分钟 ~ now + 15 天;超出微信上限时按上限内收 const minExpire = now.getTime() + 60 * 1000; if (windowEnd.getTime() < minExpire) { return ResponseUtil.badRequest(ctx, "支付已超时,请选择线下支付或取消订单"); } const maxExpire = now.getTime() + 15 * 24 * 60 * 60 * 1000; const timeExpireAt = windowEnd.getTime() > maxExpire ? new Date(maxExpire - 1000) : windowEnd; const openid = String(user?.app?.["wxapp-escort"]?.wxopenid || ""); if (!openid) return ResponseUtil.badRequest(ctx, "请先登录小程序"); let payment = null; const currentId = record.payment?.paymentRecordId; if (currentId) { payment = await DBModel.PaymentRecord.findOne({ _id: currentId, status: "created" }); } // 关单结果不确定的流水先查单确认,避免在可能已支付的单上继续创建新流水 if (!payment) { const unconfirmed = await DBModel.PaymentRecord.findOne({ recordId: record._id, status: "closed_unconfirmed", }).sort({ createdAt: -1 }); if (unconfirmed) { try { const trade = await wxpay.queryOrder(unconfirmed.outTradeNo); if (trade.trade_state === "SUCCESS") { HandlerPayment.verifyTrade(trade, unconfirmed); const applied = await HandlerPayment.applyPaymentSuccess( unconfirmed, HandlerPayment.mapTransaction(trade) ); if (applied.cancelled) { HandlerPayment.createRefundForRecord(applied.record || { _id: unconfirmed.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((refundErr) => { logger.error(`[payment] 发起支付时发现旧流水已支付且订单已取消,退款失败 recordId=${unconfirmed.recordId}: ${refundErr?.message || refundErr}`); }); } return ResponseUtil.badRequest(ctx, "订单已支付,请勿重复支付"); } } catch (err) { await HandlerPayment.markPaymentError(unconfirmed._id, err, "query"); } } } if (!payment) { payment = await DBModel.PaymentRecord.findOne({ recordId: record._id, status: "created", }).sort({ createdAt: -1 }); } // 已有在途流水但金额与当前订单不一致(如被绕过改价):先关单再换新号。 // 关单失败时旧 prepay 可能仍可支付,必须停止本次发起,不能同时放出两张有效订单。 if (payment && Number(payment.totalFee) !== totalFeeFen) { try { await wxpay.closeOrder(payment.outTradeNo); await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); } catch (err) { await HandlerPayment.markPaymentError(payment._id, err, "close"); return ResponseUtil.error(ctx, "原支付订单正在确认关闭结果,请稍后重试", null, 409); } payment = null; } if (!payment) { const attemptNo = (await DBModel.PaymentRecord.countDocuments({ recordId: record._id })) + 1; const outTradeNo = `${record._id}-${attemptNo}`; payment = await DBModel.PaymentRecord.create({ bizType: "escort", recordId: record._id, userId: record.userId, outTradeNo, attemptNo, totalFee: totalFeeFen, timeExpireAt, appid: config.wechatpay?.appid || "", mchid: config.wechatpay?.mchid || "", tradeType: "JSAPI", status: "created", createdAt: new Date(), }); } const prepayUsable = payment.prepayId && payment.prepayExpiresAt && new Date(payment.prepayExpiresAt).getTime() > nowMs(); if (!prepayUsable) { const result = await wxpay.createJsapiOrder({ outTradeNo: payment.outTradeNo, description: `陪诊服务-${record.escort?.serviceName || "陪诊服务"}`, totalFee: Number(payment.totalFee), openid, timeExpireAt: payment.timeExpireAt || timeExpireAt, notifyUrl: wxpay.getNotifyUrls().payUrl, }); const prepayExpiresAt = new Date(nowMs() + 2 * 60 * 60 * 1000); payment = await DBModel.PaymentRecord.findOneAndUpdate( { _id: payment._id }, { $set: { prepayId: result.prepay_id, prepayedAt: new Date(), prepayExpiresAt, lastAttemptAt: new Date(), "meta.updatetime": nowMs(), }, }, { new: true } ); } else { await DBModel.PaymentRecord.updateOne( { _id: payment._id }, { $set: { lastAttemptAt: new Date(), "meta.updatetime": nowMs() } } ); } await DBModel.EscortRecord.updateRecord(record._id, { "payment.paymentRecordId": payment._id, }); const payParams = wxpay.buildPayParams({ prepayId: payment.prepayId }); return ResponseUtil.success(ctx, { payParams, payment: { outTradeNo: payment.outTradeNo, attemptNo: payment.attemptNo, timeExpireAt: payment.timeExpireAt, }, }, "下单成功"); } catch (err) { if (err instanceof WechatPayError) { logger.error( `[payment] 发起支付失败 recordId=${id} stage=${err.stage} code=${err.code} requestId=${err.requestId} message=${err.message}` ); } else { logger.error(`[payment] 发起支付异常 recordId=${id}: ${err?.stack || err?.message || err}`); } const latest = await DBModel.PaymentRecord.findOne({ recordId: id, status: { $in: ACTIVE_PAYMENT_STATUS }, }).sort({ createdAt: -1 }).catch(() => null); if (latest) await HandlerPayment.markPaymentError(latest._id, err, "create"); return ResponseUtil.error(ctx, "支付发起失败,请稍后重试;如持续失败可改用线下支付", null, 500); } }); } /** * GET /escort-record/:id/pay/status */ async queryPayment(ctx) { try { const id = ctx.params.id; if (!isValidObjectId(id)) return ResponseUtil.badRequest(ctx, "缺少记录ID"); const record = await DBModel.EscortRecord.findById(id); if (!record || record.deletedAt) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); if (!HandlerPayment.canAccess(ctx.state.user, record)) { return ResponseUtil.forbidden(ctx, "无权访问该订单"); } let tradeState = null; let payment = null; const currentId = record.payment?.paymentRecordId; if (currentId) { payment = await DBModel.PaymentRecord.findById(currentId); } if (!payment) { payment = await DBModel.PaymentRecord.findOne({ recordId: record._id }).sort({ createdAt: -1 }); } if (payment && payment.status === "pay_success") { // 快照刷新失败时,查单/回页面入口也负责把订单补成 paid(幂等) const applied = await HandlerPayment.applyPaymentSuccess(payment, {}); if (applied.cancelled) { setImmediate(() => { HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((refundErr) => { logger.error(`[payment] 已取消订单自动退款失败 recordId=${payment.recordId}: ${refundErr?.message || refundErr}`); }); }); } payment = await DBModel.PaymentRecord.findById(payment._id) || payment; } if (payment && ACTIVE_PAYMENT_STATUS.includes(payment.status) && wxpay.isConfigured()) { try { // 轮询复用短 TTL 查单结果,避免前端每次刷新都打一次微信 const trade = await queryOrderForPolling(payment.outTradeNo); tradeState = trade.trade_state || null; if (trade.trade_state === "SUCCESS") { HandlerPayment.verifyTrade(trade, payment); const applied = await HandlerPayment.applyPaymentSuccess( payment, HandlerPayment.mapTransaction(trade) ); if (applied.cancelled) { setImmediate(() => { HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((refundErr) => { logger.error(`[payment] 已取消订单自动退款失败 recordId=${payment.recordId}: ${refundErr?.message || refundErr}`); }); }); } } else { const expireAt = toDate(payment.timeExpireAt); if (CLOSED_TRADE_STATES.includes(trade.trade_state)) { await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); } else if (payment.status === "created" && trade.trade_state === "NOTPAY" && expireAt && nowMs() > expireAt.getTime()) { await HandlerPayment.closeExpiredPayment(payment); } else if (payment.status === "closed_unconfirmed" && trade.trade_state === "NOTPAY" && expireAt && nowMs() > expireAt.getTime()) { // 关单结果不确定时不能仅凭 NOTPAY 就落 closed:微信侧旧单在过期前仍可能支付。 // 已过期则补一次关单,失败保持 closed_unconfirmed 交给巡检继续收敛 await HandlerPayment.closeExpiredPayment(payment); } } } catch (err) { await HandlerPayment.markPaymentError(payment._id, err, "query"); } payment = await DBModel.PaymentRecord.findById(payment._id) || payment; } const fresh = await DBModel.EscortRecord.findById(id) || record; const refundRecord = await DBModel.RefundRecord.findOne({ recordId: record._id }) .sort({ createdAt: -1 }); const refundNo = fresh.payment?.refundNo || refundRecord?.refundId || ""; return ResponseUtil.success(ctx, { paymentStatus: fresh.payment?.status || "unpaid", orderStatus: fresh.status, payChannel: fresh.payment?.payChannel || "offline", expired: HandlerPayment.isPayWindowExpired(fresh), tradeState, payment: payment ? { outTradeNo: payment.outTradeNo, attemptNo: payment.attemptNo, status: payment.status, prepayExpiresAt: payment.prepayExpiresAt || null, timeExpireAt: payment.timeExpireAt || null, } : null, refund: (refundRecord || refundNo) ? { outRefundNo: refundRecord?.outRefundNo || "", refundId: refundNo, status: refundRecord?.status || (fresh.payment?.status === "refunded" ? "success" : ""), refundAmount: refundRecord?.refundAmount || 0, successTime: refundRecord?.successTime || fresh.payment?.refundedAt || null, lastError: refundRecord?.lastError?.message ? { code: refundRecord.lastError.code || "", message: refundRecord.lastError.message, at: refundRecord.lastError.at || null, } : null, } : null, }, "查询成功"); } catch (err) { return ResponseUtil.internalError(ctx, err); } } static async closeExpiredPayment(payment) { try { await wxpay.closeOrder(payment.outTradeNo); await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); return; } catch (err) { await HandlerPayment.markPaymentError(payment._id, err, "close"); } try { const trade = await wxpay.queryOrder(payment.outTradeNo); if (trade.trade_state === "SUCCESS") { HandlerPayment.verifyTrade(trade, payment); const applied = await HandlerPayment.applyPaymentSuccess(payment, HandlerPayment.mapTransaction(trade)); if (applied.cancelled) { HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((refundErr) => { logger.error(`[payment] 逾期关单时发现已支付且订单已取消,退款失败 recordId=${payment.recordId}: ${refundErr?.message || refundErr}`); }); } } else { await HandlerPayment.setPaymentStatus(payment._id, "closed_unconfirmed", { closeUnconfirmed: true, }); } } catch (queryErr) { await HandlerPayment.markPaymentError(payment._id, queryErr, "query"); await HandlerPayment.setPaymentStatus(payment._id, "closed_unconfirmed", { closeUnconfirmed: true, }); } } /** * POST /pay/notify (微信服务器直调,无鉴权,靠验签) */ async paymentNotify(ctx) { const rawBody = ctx.request.rawBody || JSON.stringify(ctx.request.body || {}); let payload; try { payload = wxpay.verifyNotify({ headers: ctx.headers, rawBody }); } catch (err) { logger.warn( `[payment] 支付回调验签失败 code=${err?.code || ""} requestId=${err?.requestId || ""} message=${err?.message || ""}` ); return replyFail(ctx, err?.httpStatus || 400, err?.code || "VERIFY_FAILED"); } try { if (payload.eventType !== "TRANSACTION.SUCCESS") { return replySuccess(ctx); } const tx = payload.resource || {}; if (tx.trade_state && tx.trade_state !== "SUCCESS") { logger.error(`[payment] 支付回调交易状态异常 outTradeNo=${tx.out_trade_no || ""} state=${tx.trade_state}`); return replySuccess(ctx); } const cfg = config.wechatpay || {}; if (String(tx.mchid || "") !== String(cfg.mchid || "") || String(tx.appid || "") !== String(cfg.appid || "")) { logger.error(`[payment] 支付回调商户/应用不匹配 outTradeNo=${tx.out_trade_no || ""}`); return replyFail(ctx, 500, "FIELD_MISMATCH"); } const payment = await DBModel.PaymentRecord.findOne({ outTradeNo: tx.out_trade_no }); if (!payment) { logger.error(`[payment] 支付回调找不到流水 outTradeNo=${tx.out_trade_no || ""}`); return replySuccess(ctx); } if (String(tx.amount?.currency || "") !== "CNY" || Number(tx.amount?.total) !== Number(payment.totalFee)) { logger.error( `[payment] 支付回调金额不匹配 outTradeNo=${payment.outTradeNo} local=${payment.totalFee} remote=${tx.amount?.total} currency=${tx.amount?.currency}` ); return replyFail(ctx, 500, "AMOUNT_MISMATCH"); } if (["refunding", "refunded"].includes(payment.status)) { return replySuccess(ctx); } const applied = await HandlerPayment.applyPaymentSuccess( payment, HandlerPayment.mapTransaction(tx) ); replySuccess(ctx); if (applied.cancelled) { // 钱已到账但订单已取消:应答之后再异步原路退款,不占用 5 秒应答窗口 setImmediate(() => { HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }).catch((err) => { logger.error(`[payment] 已取消订单自动退款失败 recordId=${payment.recordId}: ${err?.message || err}`); }); }); } return undefined; } catch (err) { logger.error(`[payment] 支付回调处理异常: ${err?.stack || err?.message || err}`); return replyFail(ctx, 500, "FAIL"); } } /** * POST /pay/refund-notify */ async refundNotify(ctx) { const rawBody = ctx.request.rawBody || JSON.stringify(ctx.request.body || {}); let payload; try { payload = wxpay.verifyNotify({ headers: ctx.headers, rawBody }); } catch (err) { logger.warn( `[payment] 退款回调验签失败 code=${err?.code || ""} requestId=${err?.requestId || ""} message=${err?.message || ""}` ); return replyFail(ctx, err?.httpStatus || 400, err?.code || "VERIFY_FAILED"); } try { const resource = payload.resource || {}; const cfg = config.wechatpay || {}; if (resource.mchid && String(resource.mchid) !== String(cfg.mchid || "")) { logger.error(`[payment] 退款回调商户不匹配 outRefundNo=${resource.out_refund_no || ""}`); return replyFail(ctx, 500, "FIELD_MISMATCH"); } const refundRecord = await DBModel.RefundRecord.findOne({ outRefundNo: resource.out_refund_no }); if (!refundRecord) { logger.error(`[payment] 退款回调找不到流水 outRefundNo=${resource.out_refund_no || ""}`); return replySuccess(ctx); } // 金额必须与本地退款流水一致,避免跨单报文混入 if (Number(resource.amount?.refund) !== Number(refundRecord.refundAmount) || Number(resource.amount?.total) !== Number(refundRecord.totalAmount)) { logger.error( `[payment] 退款回调金额不匹配 outRefundNo=${refundRecord.outRefundNo} localRefund=${refundRecord.refundAmount} remoteRefund=${resource.amount?.refund}` ); return replyFail(ctx, 500, "AMOUNT_MISMATCH"); } await HandlerPayment.applyRefundResult(refundRecord, resource); return replySuccess(ctx); } catch (err) { logger.error(`[payment] 退款回调处理异常: ${err?.stack || err?.message || err}`); return replyFail(ctx, 500, "FAIL"); } } /** * POST /escort-record/:id/refund/query (管理端兜底) */ async queryRefundResult(ctx) { try { const id = ctx.params.id; if (!isValidObjectId(id)) return ResponseUtil.badRequest(ctx, "缺少记录ID"); const record = await DBModel.EscortRecord.findById(id); if (!record) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); const refundRecord = await DBModel.RefundRecord.findOne({ recordId: record._id }) .sort({ createdAt: -1 }); if (!refundRecord) return ResponseUtil.error(ctx, "无退款记录", null, 404); if (!wxpay.isConfigured()) { logger.warn(`[payment] 微信支付未配置,拒绝查询退款 recordId=${id}:${wxpay.getConfigDiagnostics().join(";")}`); return ResponseUtil.error(ctx, "支付功能暂未开放,请选择线下支付", null, 503); } const result = await wxpay.queryRefundResult(refundRecord.outRefundNo); const status = await HandlerPayment.applyRefundResult(refundRecord, result); const freshRecord = await DBModel.EscortRecord.findById(id); return ResponseUtil.success(ctx, { refund: { ...refundRecord.toObject(), status }, paymentStatus: freshRecord?.payment?.status || "unpaid", }, "查询成功"); } catch (err) { logger.error( `[payment] 查询退款结果失败 recordId=${ctx.params.id} code=${err?.code || ""} requestId=${err?.requestId || ""} message=${err?.message || ""}` ); return ResponseUtil.error(ctx, "查询退款结果失败,请稍后重试", null, 500); } } /** * POST /escort-record/:id/refund/manual (管理端) * 线下收款或缺少线上流水的订单,由平台人工退款后在此核销 */ async completeManualRefund(ctx) { try { const id = ctx.params.id; if (!isValidObjectId(id)) return ResponseUtil.badRequest(ctx, "缺少记录ID"); const record = await DBModel.EscortRecord.findById(id); if (!record || record.deletedAt) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); if ((record.payment?.status || "unpaid") !== "refunding") { return ResponseUtil.badRequest(ctx, "当前订单不在退款中"); } // 线上退款单还在处理中时不允许人工核销,必须先查询退款结果 const processingRefund = await DBModel.RefundRecord.findOne({ recordId: record._id, status: "processing", }); if (processingRefund) { return ResponseUtil.badRequest(ctx, "存在处理中的线上退款,请先查询退款结果"); } const refundNo = String(ctx.request.body?.refundNo || "").trim().slice(0, 64); const setFields = { "payment.status": "refunded", "payment.refundedAt": new Date(), }; if (refundNo) setFields["payment.refundNo"] = refundNo; const updatedRecord = await DBModel.EscortRecord.updateRecord(id, setFields); if (!updatedRecord) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); logger.info(`[payment] 人工核销退款完成 recordId=${id} method=${record.payment?.method || ""} refundNo=${refundNo}`); return ResponseUtil.success(ctx, { record: updatedRecord }, "已标记为退款完成"); } catch (err) { logger.error(`[payment] 人工核销退款失败 recordId=${ctx.params.id}: ${err?.message || err}`); return ResponseUtil.internalError(ctx, err); } } /** * POST /escort-record/:id/refund/retry (管理端) * 退款失败或结果不明时,按同一 outRefundNo 再次发起微信原路退款(微信幂等) */ async retryRefund(ctx) { try { const id = ctx.params.id; if (!isValidObjectId(id)) return ResponseUtil.badRequest(ctx, "缺少记录ID"); const record = await DBModel.EscortRecord.findById(id); if (!record || record.deletedAt) return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404); if ((record.payment?.status || "unpaid") !== "refunding") { return ResponseUtil.badRequest(ctx, "当前订单不在退款中"); } const existing = await DBModel.RefundRecord.findOne({ recordId: record._id, outRefundNo: `${record._id}-R1` }); if (existing?.status === "success") { return ResponseUtil.badRequest(ctx, "该订单退款已成功,无需再次退款"); } if (!wxpay.isConfigured()) { logger.warn(`[payment] 微信支付未配置,拒绝再次退款 recordId=${id}:${wxpay.getConfigDiagnostics().join(";")}`); return ResponseUtil.error(ctx, "支付功能暂未开放,请人工核销退款", null, 503); } const refund = await HandlerPayment.createRefundForRecord(record, { retry: true }); if (refund?.skipped) { return ResponseUtil.badRequest(ctx, "缺少成功支付流水,无法发起线上退款,请人工核销"); } const freshRecord = await DBModel.EscortRecord.findById(id); return ResponseUtil.success(ctx, { refund: refund ? refund.toObject() : null, paymentStatus: freshRecord?.payment?.status || "unpaid", }, "已重新发起退款"); } catch (err) { logger.error( `[payment] 再次退款失败 recordId=${ctx.params.id} code=${err?.code || ""} requestId=${err?.requestId || ""} message=${err?.message || ""}` ); return ResponseUtil.error(ctx, "再次退款失败,请稍后重试或人工核销", null, 500); } } } // ==================== 后台巡检查单 ==================== let patrolTimer = null; let patrolRunning = false; let patrolConfigWarned = false; async function sweepPayment(payment) { try { const trade = await wxpay.queryOrder(payment.outTradeNo); const state = trade.trade_state || ""; if (state === "SUCCESS") { HandlerPayment.verifyTrade(trade, payment); const applied = await HandlerPayment.applyPaymentSuccess( payment, HandlerPayment.mapTransaction(trade) ); if (applied.cancelled) { await HandlerPayment.createRefundForRecord(applied.record || { _id: payment.recordId }, { reason: DEFAULT_REFUND_REASON, }); } return; } // 微信侧已明确终结:无需再关单,直接收敛 if (CLOSED_TRADE_STATES.includes(state)) { await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() }); return; } // 关单结果不确定时不能仅凭 NOTPAY 就落 closed:微信侧旧单在过期前仍可能支付。 // 未过期保持 closed_unconfirmed 交给下一轮继续收敛;已过期才补一次关单 if (payment.status === "closed_unconfirmed") { if (state === "NOTPAY" && payment.timeExpireAt && nowMs() > new Date(payment.timeExpireAt).getTime()) { await HandlerPayment.closeExpiredPayment(payment); } return; } if (state === "NOTPAY" && payment.timeExpireAt && nowMs() > new Date(payment.timeExpireAt).getTime()) { await HandlerPayment.closeExpiredPayment(payment); } } catch (err) { if (err instanceof WechatPayError) { await HandlerPayment.markPaymentError(payment._id, err, "query"); } else { logger.error(`[payment] 巡检查单异常 outTradeNo=${payment.outTradeNo}: ${err?.message || err}`); } } } async function runPaymentPatrolOnce() { if (patrolRunning) return; if (!wxpay.isConfigured()) { if (!patrolConfigWarned) { logger.warn("[payment] 微信支付未配置,支付巡检暂不执行"); patrolConfigWarned = true; } return; } patrolConfigWarned = false; patrolRunning = true; try { const since = new Date(nowMs() - 7 * 24 * 60 * 60 * 1000); const payments = await DBModel.PaymentRecord.find({ status: { $in: ACTIVE_PAYMENT_STATUS }, createdAt: { $gte: since }, }).sort({ createdAt: 1 }).limit(100); for (const payment of payments) { await sweepPayment(payment); } // 退款回调丢失同样由后台收敛:主动查询处理中/异常的退款单 const refunds = await DBModel.RefundRecord.find({ status: { $in: ["processing", "abnormal"] }, createdAt: { $gte: since }, }).sort({ createdAt: 1 }).limit(50); for (const refund of refunds) { try { const result = await wxpay.queryRefundResult(refund.outRefundNo); await HandlerPayment.applyRefundResult(refund, result); } catch (err) { await HandlerPayment.markRefundError(refund._id, err, "refund_query"); } } } catch (err) { logger.error(`[payment] 支付巡检异常: ${err?.stack || err?.message || err}`); } finally { patrolRunning = false; } } /** * 服务启动时注册单一定时器;默认运行,每 10 分钟一轮 */ function startPaymentPatrol({ intervalMs = 10 * 60 * 1000 } = {}) { if (patrolTimer) return patrolTimer; patrolTimer = setInterval(() => { runPaymentPatrolOnce().catch((err) => { logger.error(`[payment] 支付巡检失败: ${err?.message || err}`); }); }, intervalMs); if (typeof patrolTimer.unref === "function") patrolTimer.unref(); return patrolTimer; } export { HandlerPayment, startPaymentPatrol, runPaymentPatrolOnce, withPayLock, payLocks };