Files
api_health/handler/payment.js
T
lik d21f5da682 feat: 记录并展示订单退款流水号与失败原因
- 订单 payment 新增 refundNo/refundedAt,线上退款成功回填微信退款单号
- 人工核销退款支持录入退款流水号
- pay/status 返回退款概要(单号、流水号、状态、金额、最近失败原因)
- retryRefund 补充微信支付未配置检查
2026-11-06 22:46:15 +08:00

1150 lines
46 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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);
payLocks.set(key, current.finally(() => {
if (payLocks.get(key) === current) payLocks.delete(key);
}));
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;
}
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;
const updated = await DBModel.PaymentRecord.findOneAndUpdate(
{ _id: paymentRecord._id, status: { $in: ACTIVE_PAYMENT_STATUS } },
{ $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;
await DBModel.RefundRecord.updateOne(
{ _id: refundRecord._id },
{ $set: setFields }
);
if (status === "success") {
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 {
await DBModel.PaymentRecord.updateOne(
{ _id: refundRecord.paymentId },
{ $set: { status: "refunding", "meta.updatetime": nowMs() } }
);
await DBModel.EscortRecord.updateOne(
{ _id: refundRecord.recordId },
{ $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 });
}
// 已有在途流水但金额与当前订单不一致(如被绕过改价):先关单再换新号
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");
}
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 {
const trade = await wxpay.queryOrder(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 (payment.status === "created" && trade.trade_state === "NOTPAY"
&& expireAt && nowMs() > expireAt.getTime()) {
await HandlerPayment.closeExpiredPayment(payment);
} else if (payment.status === "closed_unconfirmed") {
await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() });
}
}
} 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 (payment.status === "closed_unconfirmed") {
await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() });
return;
}
if (["CLOSED", "PAYERROR", "REFUND", "REVOKED"].includes(state)) {
await HandlerPayment.setPaymentStatus(payment._id, "closed", { closedAt: new Date() });
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 };