Files
api_health/handler/escort_record.js
T
lik 623ecf2651 fix(payment): 收口取消退款规则并保护退款状态
- 未确认订单取消直接生效:未收款删除,已收款进入退款
- 待取消期间到账只记账不退款,确认取消后再退
- 退款缺少支付流水时记录错误,关单/查单兜底补触发退款
- 已收款订单禁止改支付状态与金额,管理端 Agent 取消同步关单并退款
- 新增人工退款核销接口,切换支付方式不再自动退款
2026-11-06 17:30:20 +08:00

872 lines
39 KiB
JavaScript

import { DBModel } from "../models/index.js";
import services from "../resource/services.js";
import ResponseUtil from "../utils/responseUtil.js";
import logger from "../utils/logger.js";
import { isAdmin as isAdminUser, resolveEscortAdminRole } from "../utils/permissions.js";
import {
canTransition,
canCancelTransition,
STATUS_TRANSITIONS,
CANCEL_STATUS_VALUES,
} from "../utils/record_state.js";
import { HandlerPayment } from "./payment.js";
class HandlerEscortRecord {
constructor() {
}
// 白名单:只允许写入 schema 定义的顶层字段(兼容 'patient.name' 等点号路径)
static RECORD_FIELDS = [
"userId", "healthProfileId", "patient", "escort",
"attendant", "hospital", "schedule", "payment", "notes", "inquiry", "status",
"shippingAddress",
];
// 用户自助可改字段按订单状态区分(费用、状态、陪诊员分配、档案归属一律由平台控制):
// - 待支付/已支付:可改医院与排期(改期会写审计时间)
// - 进行中:服务已开始,仅可补充病历与诉求,排期与医院不允许用户单方变更
// - 终态:全部不可改
static OWNER_NOTE_FIELDS = ["notes.patientNote", "inquiry.medicalHistory", "inquiry.demand"];
static OWNER_BOOKING_FIELDS = [
"hospital.province", "hospital.name", "hospital.address", "hospital.department",
"hospital.doctor", "hospital.medicalRecordNo", "schedule.date", "schedule.startTime",
];
static OWNER_EDITABLE_BY_STATUS = {
pending: [...HandlerEscortRecord.OWNER_NOTE_FIELDS, "payment.payChannel", ...HandlerEscortRecord.OWNER_BOOKING_FIELDS],
confirmed: [...HandlerEscortRecord.OWNER_NOTE_FIELDS, "payment.payChannel", ...HandlerEscortRecord.OWNER_BOOKING_FIELDS],
in_progress: [...HandlerEscortRecord.OWNER_NOTE_FIELDS],
};
// 用户端只能发起取消,服务完成由平台确认,避免用户端重复写入终态。
// 取消与 status 解耦:cancelStatus 为 requested 表示待确认,cancelled 表示已取消。
// 「未确认且未收款」取消即物理删除;其余先置 requested,等陪诊师/管理员确认。
// 迁移规则集中在 utils/record_state.js,与管理端 Agent 工具共用
// 支付方式为平台受控枚举(与 schema 一致),空串表示清除/未记录
static PAYMENT_METHODS = ["", "online_wechat", "offline_cash", "offline_transfer"];
// 用户下单时可选择的支付渠道:线下支付不细分现金/转账,由平台收款时补记 method
static PAY_CHANNELS = ["online_wechat", "offline"];
// 单页最大条数,避免 pageSize 传超大值一次拖库
static MAX_PAGE_SIZE = 200;
// 每个用户同时未完成的预约上限:超出后不允许再下单
static MAX_UNFINISHED_RECORDS = 3;
static UNFINISHED_STATUSES = ["pending", "confirmed", "in_progress"];
/**
* 统计用户当前未完成的预约数
* 未完成 = 服务未结束(待确认/已确认/进行中),且未取消、未软删除
* @param {ObjectId} userId 订单所属用户
* @returns {Promise<number>}
*/
static countUnfinishedRecords(userId) {
return DBModel.EscortRecord.countDocuments({
userId,
status: { $in: HandlerEscortRecord.UNFINISHED_STATUSES },
cancelStatus: { $ne: "cancelled" },
deletedAt: null,
});
}
/**
* 是否为管理端账号(与 WS 管理端 agent 的校验口径一致)
* @param {Object} user token 解析出的用户
*/
static isAdmin(user) {
return isAdminUser(user);
}
/**
* 用户端在当前状态下可自助修改的字段清单(白名单精确匹配,点号路径)
* @param {string} status 订单状态
* @returns {string[]}
*/
static ownerEditableFields(status) {
return HandlerEscortRecord.OWNER_EDITABLE_BY_STATUS[status] || [];
}
/**
* 就诊人快照:下单与更换档案共用,保证订单里的展示字段一致
* @param {Object} profile 健康档案文档
* @returns {Object}
*/
static buildPatientSnapshot(profile) {
const patient = {
name: profile.profile?.name || "",
mobile: profile.profile?.mobile || "",
birth: profile.profile?.birth || "",
};
if (["male", "female"].includes(profile.profile?.sex)) patient.sex = profile.profile.sex;
return patient;
}
/**
* 记录访问校验:仅记录所属用户本人或管理员可读写
* @param {Object} user 当前登录用户
* @param {Object} record 目标记录
*/
static canAccess(user, record) {
if (!record) return false;
if (HandlerEscortRecord.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);
}
/**
* 输出给前端的订单视图:追加支付窗口终点,供列表/详情判断「支付已超时」。
* 只派生展示字段,不写库。
* @param {Object} record mongoose 文档
* @returns {Object}
*/
static withPaymentWindow(record) {
if (!record) return record;
const plain = record.toObject ? record.toObject() : { ...record };
const end = HandlerPayment.getPayWindowEnd(plain);
plain.paymentWindowEnd = end ? end.toISOString() : null;
return plain;
}
/**
* 从入参中挑出白名单字段
* @param {Object} body 请求体
* @param {string[]} allowFields 允许的字段(支持点号路径)
* @param {boolean} exact 是否精确匹配;用户端用 true,防止 notes.patientNote.x 这类嵌套越界
*/
static pickFields(body, allowFields = HandlerEscortRecord.RECORD_FIELDS, exact = false) {
const picked = {};
for (const key of Object.keys(body || {})) {
const allowed = allowFields.some(
(f) => key === f || (!exact && key.startsWith(f + "."))
);
if (allowed) {
picked[key] = body[key];
}
}
return picked;
}
// 解析分页参数并夹紧上限,防止超大 pageSize 拖库
static parsePaging(query = {}) {
const page = Math.max(1, parseInt(query.page) || 1);
const rawSize = parseInt(query.pageSize) || 20;
const pageSize = Math.min(Math.max(1, rawSize), HandlerEscortRecord.MAX_PAGE_SIZE);
return { page, pageSize };
}
static formatDateOnly(value) {
if (!value) return "";
if (value instanceof Date) return value.toISOString().slice(0, 10);
return String(value).slice(0, 10);
}
// 预约开始时间的最晚档位:所有服务统一可约到 23:30(整点/半点)
static LATEST_START_MINUTES = 23 * 60 + 30;
static timeToMinutes(value) {
if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(value || "")) return null;
const [hour, minute] = value.split(":").map(Number);
return hour * 60 + minute;
}
// 服务目录是预约规则与订单排期的唯一事实源,客户端提交的时长和结束时间一律忽略。
static buildSchedule(service, dateValue, startTime, now = new Date()) {
const date = HandlerEscortRecord.formatDateOnly(dateValue);
const parsedDate = new Date(`${date}T00:00:00.000Z`);
if (!/^\d{4}-\d{2}-\d{2}$/.test(date)
|| Number.isNaN(parsedDate.getTime())
|| parsedDate.toISOString().slice(0, 10) !== date) {
return { error: "预约日期格式不正确" };
}
const booking = service.booking;
if (!booking || !Array.isArray(booking.sessions) || booking.sessions.length === 0) {
return { error: "该服务暂未开放预约" };
}
const earliest = new Date(now);
earliest.setHours(0, 0, 0, 0);
earliest.setDate(earliest.getDate() + Number(booking.advanceDays || 0));
const earliestDate = `${earliest.getFullYear()}-${String(earliest.getMonth() + 1).padStart(2, "0")}-${String(earliest.getDate()).padStart(2, "0")}`;
if (date < earliestDate) {
return { error: `请至少提前${booking.advanceDays}天预约` };
}
const startMinutes = HandlerEscortRecord.timeToMinutes(startTime);
if (startMinutes === null) return { error: "预约时间格式不正确" };
// 与原班次起点一致时沿用该班次;其余开始时刻从服务最早时段起、统一放宽到 23:30
const session = booking.sessions.find((item) => item.start === startTime)
|| booking.sessions.find((item) => startMinutes >= HandlerEscortRecord.timeToMinutes(item.start)
&& startMinutes <= HandlerEscortRecord.LATEST_START_MINUTES);
if (!session) return { error: "所选时间不在该服务的可预约时段内" };
// 非原班次起点:结束时刻按服务时长顺延,跨天按 24 小时取模
const endTime = session.start === startTime
? session.end
: (() => {
const endMinutes = (startMinutes + booking.durationMinutes) % 1440;
return `${String(Math.floor(endMinutes / 60)).padStart(2, "0")}:${String(endMinutes % 60).padStart(2, "0")}`;
})();
return {
schedule: {
date,
startTime,
endTime,
duration: Number(booking.durationMinutes) || 0,
},
};
}
static buildShippingAddress(source, profile) {
// 地址选填:跑腿/买药未填时由客服线下确认,仅保存快照
const address = String(source?.address || "").trim();
return {
shippingAddress: {
recipientName: profile.profile?.name || "",
mobile: profile.profile?.mobile || "",
address,
},
};
}
// 按条件查询记录(管理端,可查全部)
async getRecords(ctx) {
return this._listRecords(ctx, false);
}
// 查询"我的"记录:强制以登录用户身份查询,忽略 query 中的 userId
async getMyRecords(ctx) {
return this._listRecords(ctx, true);
}
async _listRecords(ctx, forceSelf) {
try {
const { status, userId, appointmentDate, healthProfileId, cancelStatus, includeCancelled } = ctx.request.query;
const { page, pageSize } = HandlerEscortRecord.parsePaging(ctx.request.query);
const effectiveUserId = forceSelf ? ctx.state.user?._id : userId;
// status解析成数组
let statusArray = null;
if (status && status.length > 0) {
statusArray = status.split(',')
}
if (statusArray && statusArray.some((item) => !Object.hasOwn(STATUS_TRANSITIONS, item))) {
return ResponseUtil.badRequest(ctx, "订单状态筛选值不正确");
}
// 取消状态筛选:none / requested / cancelled
let cancelStatusArray = null;
if (cancelStatus && String(cancelStatus).length > 0) {
cancelStatusArray = String(cancelStatus).split(',').filter(Boolean);
if (cancelStatusArray.some((item) => !CANCEL_STATUS_VALUES.includes(item))) {
return ResponseUtil.badRequest(ctx, "订单取消状态筛选值不正确");
}
}
const result = await DBModel.EscortRecord.findRecordPage({
page,
pageSize,
status: statusArray,
cancelStatus: cancelStatusArray,
includeCancelled: ["1", "true"].includes(String(includeCancelled)),
userId: effectiveUserId,
appointmentDate,
healthProfileId,
});
const records = result.records.map((record) => HandlerEscortRecord.withPaymentWindow(record));
return ResponseUtil.success(ctx, { ...result, records, page, pageSize }, "查询成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async getAttendantRecords(ctx) {
try {
// 只允许查询当前登录陪诊员自己的记录
const attendantId = ctx.state.user?._id;
if (!attendantId) {
return ResponseUtil.badRequest(ctx, "缺少陪诊员ID");
}
const { status } = ctx.request.query;
const { page, pageSize } = HandlerEscortRecord.parsePaging(ctx.request.query);
const records = await DBModel.EscortRecord.findRecordsByAttendant(attendantId, {
page,
pageSize,
status,
});
return ResponseUtil.success(ctx, { records }, "查询成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async getRecordById(ctx) {
try {
const { id } = ctx.params;
if (!id) {
return ResponseUtil.badRequest(ctx, "缺少记录ID");
}
const record = await DBModel.EscortRecord.findById(id);
if (!record) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
// 归属校验:非本人订单按无权限处理,避免凭 id 遍历他人订单
if (!HandlerEscortRecord.canAccess(ctx.state.user, record)) {
return ResponseUtil.forbidden(ctx, "无权访问该订单");
}
return ResponseUtil.success(ctx, { record: HandlerEscortRecord.withPaymentWindow(record) }, "查询成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async createRecord(ctx) {
try {
const body = ctx.request.body || {};
const userId = ctx.state.user?._id;
if (!userId) {
return ResponseUtil.unauthorized(ctx, "登录已失效");
}
const idempotencyKey = String(body.idempotencyKey || "").trim();
if (idempotencyKey && !/^[\w-]{8,80}$/.test(idempotencyKey)) {
return ResponseUtil.badRequest(ctx, "下单幂等标识格式不正确");
}
if (idempotencyKey) {
const existing = await DBModel.EscortRecord.findByIdempotencyKey(userId, idempotencyKey);
if (existing) return ResponseUtil.success(ctx, { record: existing }, "订单已创建");
}
// 订单必须关联就诊人:patient 是下单当刻的快照,healthProfileId 才是关联
if (!body.healthProfileId) {
return ResponseUtil.badRequest(ctx, "缺少就诊人档案ID");
}
// 就诊人档案必须属于当前登录用户,避免把订单挂到他人档案上
const profile = await DBModel.HealthProfile.findProfileById(body.healthProfileId);
if (!profile || String(profile.userId) !== String(userId)) {
return ResponseUtil.badRequest(ctx, "就诊人档案不存在");
}
// 服务项目、服务名称、区域、排期与价格均以服务端目录为准。
const service = services.find((s) => String(s.id) === String(body.escort?.serviceId));
if (!service) return ResponseUtil.badRequest(ctx, "服务项目不存在或已下架");
if (!service.areas.includes(body.hospital?.province)) {
return ResponseUtil.badRequest(ctx, "所选省份暂未开通服务");
}
// 科室为选填:用户可能尚未确定科室,可下单后在详情页补录
if (!String(body.hospital?.name || "").trim()) {
return ResponseUtil.badRequest(ctx, "请填写就诊医院");
}
const scheduleResult = HandlerEscortRecord.buildSchedule(
service,
body.schedule?.date,
body.schedule?.startTime
);
if (scheduleResult.error) return ResponseUtil.badRequest(ctx, scheduleResult.error);
const addressResult = HandlerEscortRecord.buildShippingAddress(body.shippingAddress, profile);
const payload = HandlerEscortRecord.pickFields(body);
// 陪诊员分配由平台决定:用户下单时提交的 attendant 一律丢弃,防止自选/伪造陪诊员
if (!HandlerEscortRecord.isAdmin(ctx.state.user)) delete payload.attendant;
payload.userId = userId;
// healthProfileId 以校验通过的档案为准,覆盖客户端原值
payload.healthProfileId = profile._id;
payload.status = "pending";
payload.patient = HandlerEscortRecord.buildPatientSnapshot(profile);
payload.escort = {
serviceId: service.id,
serviceName: service.title,
sexRequirement: ["none", "male", "female"].includes(body.escort?.sexRequirement)
? body.escort.sexRequirement
: "none",
};
payload.schedule = scheduleResult.schedule;
payload.shippingAddress = addressResult.shippingAddress;
if (idempotencyKey) payload.idempotencyKey = idempotencyKey;
// 支付渠道:用户端只可选微信支付 / 线下支付;管理员代下单可按 method 推导
const requestedChannel = body.payment?.payChannel;
if (requestedChannel !== undefined
&& !HandlerEscortRecord.PAY_CHANNELS.includes(requestedChannel)) {
return ResponseUtil.badRequest(ctx, "支付方式不正确");
}
let payChannel;
if (HandlerEscortRecord.isAdmin(ctx.state.user)) {
payChannel = HandlerEscortRecord.PAY_CHANNELS.includes(requestedChannel)
? requestedChannel
: (body.payment?.method === "online_wechat" ? "online_wechat" : "offline");
} else {
payChannel = requestedChannel || "online_wechat";
}
payload.payment = {
totalFee: Number(service.price) || 0,
paidFee: 0,
status: "unpaid",
payChannel,
};
// 实际收款方式由平台在收款时补记:仅管理员代客下单时可指定,用户端提交一律丢弃
if (HandlerEscortRecord.isAdmin(ctx.state.user)
&& HandlerEscortRecord.PAYMENT_METHODS.includes(body.payment?.method)) {
payload.payment.method = body.payment.method;
}
// 每个用户同时最多 3 个未完成预约,超出则不再允许新增
const unfinishedCount = await HandlerEscortRecord.countUnfinishedRecords(userId);
if (unfinishedCount >= HandlerEscortRecord.MAX_UNFINISHED_RECORDS) {
return ResponseUtil.badRequest(
ctx,
`每个用户最多同时保留${HandlerEscortRecord.MAX_UNFINISHED_RECORDS}个未完成的预约,请先完成或取消已有预约后再下单`
);
}
try {
const newRecord = await DBModel.EscortRecord.createRecord(payload);
return ResponseUtil.success(ctx, { record: newRecord }, "创建成功");
} catch (err) {
// 并发重复提交由唯一索引兜底,后到的请求返回已创建订单。
if (err?.code === 11000 && idempotencyKey) {
const existing = await DBModel.EscortRecord.findByIdempotencyKey(userId, idempotencyKey);
if (existing) return ResponseUtil.success(ctx, { record: existing }, "订单已创建");
}
throw err;
}
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async updateRecord(ctx) {
try {
const { id } = ctx.params;
const update = ctx.request.body;
if (!id) {
return ResponseUtil.badRequest(ctx, "缺少记录ID");
}
const existing = await DBModel.EscortRecord.findById(id);
if (!existing) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
if (!HandlerEscortRecord.canAccess(ctx.state.user, existing)) {
return ResponseUtil.forbidden(ctx, "无权修改该订单");
}
const isAdmin = HandlerEscortRecord.isAdmin(ctx.state.user);
// 兼容旧数据:取消曾存放在 status 中
const cancelStatus = existing.status === "cancelled"
? "cancelled"
: (existing.cancelStatus || "none");
// 非管理员的可改字段随订单状态收敛:终态无可改字段,进行中只剩就诊人备注;
// 已申请取消或已取消的订单一律冻结,等待平台处理
const allowFields = isAdmin
? HandlerEscortRecord.RECORD_FIELDS
: cancelStatus !== "none"
? []
: HandlerEscortRecord.ownerEditableFields(existing.status);
if (allowFields.length === 0) {
return ResponseUtil.forbidden(ctx, "已结束的订单不可修改");
}
// 非管理员只能改就诊信息类字段,费用/状态/归属/陪诊员分配不可自助修改
const payload = HandlerEscortRecord.pickFields(update, allowFields, !isAdmin);
if (Object.keys(payload).length === 0) {
// 例如进行中订单提交医院/排期:字段被状态规则过滤,明确告知而不是静默成功
return ResponseUtil.badRequest(ctx, "该订单当前状态不支持修改这些信息");
}
// 已收款订单一律锁定支付状态与实收金额:否则编辑退款中的订单会把它改回未支付,
// 用户可再次支付造成重复扣款;金额改动也会与 payment_record 对不上
const currentPayStatus = existing.payment?.status || "unpaid";
const settledPayStatus = ["partial", "paid", "refunding", "refunded"].includes(currentPayStatus);
const nextPayStatus = payload["payment.status"] ?? payload.payment?.status;
const nextPaidFee = payload["payment.paidFee"] ?? payload.payment?.paidFee;
if (settledPayStatus) {
if (nextPayStatus !== undefined && nextPayStatus !== currentPayStatus) {
return ResponseUtil.badRequest(ctx, "已收款订单不可修改支付状态,如需退款请走取消流程");
}
if (nextPaidFee !== undefined && Number(nextPaidFee) !== (Number(existing.payment?.paidFee) || 0)) {
return ResponseUtil.badRequest(ctx, "已收款订单不可修改实收金额");
}
const nextTotalFee = payload["payment.totalFee"] ?? payload.payment?.totalFee;
if (nextTotalFee !== undefined
&& Number(nextTotalFee) !== (Number(existing.payment?.totalFee) || 0)) {
return ResponseUtil.badRequest(ctx, "已收款订单不可修改金额,如需调整请先退款");
}
}
// 线上微信收款只能由支付回调写入:手工标记会没有支付流水,取消时无法原路退款
const nextPaymentMethod = payload["payment.method"] ?? payload.payment?.method;
if (nextPaymentMethod === "online_wechat" && nextPayStatus === "paid") {
const paidPayment = await DBModel.PaymentRecord.findOne({
recordId: id,
status: { $in: ["pay_success", "refunding", "refunded"] },
});
if (!paidPayment) {
return ResponseUtil.badRequest(ctx, "线上微信收款只能由支付回调写入,请选择线下现金或转账");
}
}
// 支付方式为受控枚举:管理端修改时校验,防止写入非法值
const paymentMethod = update["payment.method"] ?? update.payment?.method;
if (paymentMethod !== undefined && !HandlerEscortRecord.PAYMENT_METHODS.includes(paymentMethod)) {
return ResponseUtil.badRequest(ctx, "支付方式不正确");
}
// 支付渠道:用户端仅在待支付期间可切换;切到线下前必须先关单
const requestedChannel = update["payment.payChannel"] ?? update.payment?.payChannel;
if (requestedChannel !== undefined) {
if (!HandlerEscortRecord.PAY_CHANNELS.includes(requestedChannel)) {
return ResponseUtil.badRequest(ctx, "支付方式不正确");
}
if (cancelStatus !== "none") {
return ResponseUtil.badRequest(ctx, "已申请取消的订单不可修改支付方式");
}
if ((existing.payment?.status || "unpaid") !== "unpaid") {
return ResponseUtil.forbidden(ctx, "已收款订单不可修改支付方式");
}
if (!["pending", "confirmed"].includes(existing.status)) {
return ResponseUtil.badRequest(ctx, "当前订单状态不允许修改支付方式");
}
if (requestedChannel === "offline") {
const closeResult = await HandlerPayment.closeOpenPayRecords(id);
if (closeResult.paid) {
// 已支付不能改渠道:这里只提示刷新,不主动退款。
// 否则会得到一张「仍在履约、款项已退」的死单,用户既不能再付也不能切线下
return ResponseUtil.error(ctx, "订单已支付,请刷新页面查看最新状态", null, 409);
}
payload["payment.paymentRecordId"] = null;
}
// 避免管理端提交嵌套 payment 对象时整体覆盖:统一写成点路径
if (payload["payment.payChannel"] === undefined) {
payload["payment.payChannel"] = requestedChannel;
if (payload.payment) {
const nested = { ...payload.payment };
delete nested.payChannel;
if (Object.keys(nested).length === 0) delete payload.payment;
else payload.payment = nested;
}
}
}
// 存在未支付流水时禁止改价:微信侧金额与本地流水错位会对账不上
const nextTotalFee = update["payment.totalFee"] ?? update.payment?.totalFee;
const touchesTotalFee = payload["payment.totalFee"] !== undefined
|| (payload.payment && payload.payment.totalFee !== undefined);
if (nextTotalFee !== undefined && touchesTotalFee) {
const currentTotalFee = Number(existing.payment?.totalFee) || 0;
if (Number(nextTotalFee) !== currentTotalFee) {
const openPayment = await DBModel.PaymentRecord.findOne({
recordId: id,
status: "created",
});
if (openPayment) {
return ResponseUtil.badRequest(ctx, "订单存在未支付流水,请先关闭或取消后再修改金额");
}
}
}
// 档案归属校验:档案必须属于订单所属用户,避免把订单挂到他人档案上;
// 通过后同步刷新订单里的就诊人快照
if (payload.healthProfileId) {
const profile = await DBModel.HealthProfile.findProfileById(payload.healthProfileId);
if (!profile || String(profile.userId) !== String(existing.userId)) {
return ResponseUtil.badRequest(ctx, "就诊人档案不存在");
}
payload.patient = HandlerEscortRecord.buildPatientSnapshot(profile);
}
const service = services.find((item) => item.id === existing.escort?.serviceId);
if (!service) return ResponseUtil.badRequest(ctx, "订单关联的服务已下架");
const touchesSchedule = Object.keys(payload).some((key) => key === "schedule" || key.startsWith("schedule."));
if (touchesSchedule) {
const date = update["schedule.date"] || update.schedule?.date || existing.schedule?.date;
const startTime = update["schedule.startTime"] || update.schedule?.startTime || existing.schedule?.startTime;
const scheduleResult = HandlerEscortRecord.buildSchedule(service, date, startTime);
if (scheduleResult.error) return ResponseUtil.badRequest(ctx, scheduleResult.error);
for (const key of Object.keys(payload)) {
if (key.startsWith("schedule.")) delete payload[key];
}
// 已支付后的改期留审计时间,便于客服追溯谁在何时改过排期
if (existing.status !== "pending") {
scheduleResult.schedule.scheduleUpdatedAt = new Date();
}
payload.schedule = scheduleResult.schedule;
}
const touchesHospital = Object.keys(payload).some((key) => key === "hospital" || key.startsWith("hospital."));
if (touchesHospital) {
const province = update["hospital.province"] || update.hospital?.province || existing.hospital?.province;
if (!service.areas.includes(province)) return ResponseUtil.badRequest(ctx, "所选省份暂未开通服务");
}
const updatedRecord = await DBModel.EscortRecord.updateRecord(id, payload);
if (!updatedRecord) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: updatedRecord }, "更新成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async updateStatus(ctx) {
try {
const { id } = ctx.params;
const { status, reason } = ctx.request.body;
if (!id) {
return ResponseUtil.badRequest(ctx, "缺少记录ID");
}
if (!status) {
return ResponseUtil.badRequest(ctx, "缺少状态值");
}
const existing = await DBModel.EscortRecord.findById(id);
if (!existing) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
if (!HandlerEscortRecord.canAccess(ctx.state.user, existing)) {
return ResponseUtil.forbidden(ctx, "无权修改该订单");
}
const user = ctx.state.user;
// 用户端与管理端共用本接口,按调用方 app 区分取消流程:
// appId 只用于收紧权限——即使账号同时带管理员角色,从用户端小程序发起的取消
// 也必须走取消申请,否则会在 C 端绕过「已确认订单需人工确认」直接退款。
// 管理端固定带 appId=wxapp-escort-admin;未带 appId 的历史调用保持原角色判定。
const requestAppId = String(ctx.request.body?.appId || "");
const isUserApp = requestAppId === "wxapp-escort";
const role = isUserApp ? null : await resolveEscortAdminRole(user);
const isOwner = String(existing.userId) === String(user?._id);
const paymentStatus = existing.payment?.status || "unpaid";
const cancelReason = String(reason || "").trim().slice(0, 200);
let effectivePaymentStatus = paymentStatus;
let effectivePayment = existing.payment || {};
// 兼容旧数据:取消曾存放在 status 中
const cancelStatus = existing.status === "cancelled"
? "cancelled"
: (existing.cancelStatus || "none");
if (cancelStatus === "cancelled") {
return ResponseUtil.badRequest(ctx, "订单已取消,不能再次操作");
}
if (role !== "admin" && role !== "attendant") {
// 用户端只能取消:未确认订单直接取消(未收款删除、已收款退款);已确认订单提交取消申请
if (status !== "cancelled" || !isOwner) {
return ResponseUtil.forbidden(ctx, "不支持的状态变更");
}
if (cancelStatus === "requested") {
return ResponseUtil.badRequest(ctx, "取消申请已提交,请等待确认");
}
if (!["pending", "confirmed"].includes(existing.status)) {
return ResponseUtil.badRequest(ctx, "当前订单状态不允许此操作");
}
if (!cancelReason) return ResponseUtil.badRequest(ctx, "请选择取消原因");
if (existing.status === "pending") {
// 未确认订单:陪诊师尚未接单,取消直接生效,无需人工确认。
// 取消前先关单,否则旧 prepay 仍可支付一张已不存在的订单
const closeResult = await HandlerPayment.closeOpenPayRecords(id);
let payStatus = paymentStatus;
let pay = existing.payment || {};
if (closeResult.paid) {
const fresh = await DBModel.EscortRecord.findById(id);
payStatus = fresh?.payment?.status || "paid";
pay = fresh?.payment || pay;
}
if (payStatus === "unpaid") {
const deletedRecord = await DBModel.EscortRecord.deleteRecord(id);
if (!deletedRecord) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: deletedRecord, deleted: true }, "订单已取消");
}
// 已收款:直接转已取消并进入退款;线上微信自动原路退款,线下由平台人工核销
const updatedRecord = await DBModel.EscortRecord.updateRecordCancel(id, cancelStatus, {
cancelStatus: "cancelled",
cancelReason,
cancelledAt: new Date(),
...(["partial", "paid"].includes(payStatus) ? { "payment.status": "refunding" } : {}),
});
if (!updatedRecord) {
return ResponseUtil.error(ctx, "订单状态已变化,请刷新后重试", null, 409);
}
if (pay.method === "online_wechat" && ["partial", "paid"].includes(payStatus)) {
HandlerPayment.createRefundForRecord(updatedRecord, {
reason: cancelReason || "订单取消",
}).catch((err) => {
logger.error(`[escort] 未确认订单取消自动退款失败 recordId=${id}: ${err?.message || err}`);
});
}
return ResponseUtil.success(
ctx,
{ record: HandlerEscortRecord.withPaymentWindow(updatedRecord) },
"订单已取消,退款已发起"
);
}
// 申请取消前先关闭未支付的 prepay,避免等待确认期间又被支付
const closeResult = await HandlerPayment.closeOpenPayRecords(id);
if (closeResult.paid) {
const fresh = await DBModel.EscortRecord.findById(id);
effectivePaymentStatus = fresh?.payment?.status || "paid";
effectivePayment = fresh?.payment || effectivePayment;
}
if (!canCancelTransition(cancelStatus, "requested")) {
return ResponseUtil.badRequest(ctx, "当前订单不允许取消");
}
const updatedRecord = await DBModel.EscortRecord.updateRecordCancel(id, cancelStatus, {
cancelStatus: "requested",
cancelReason,
cancelRequestedAt: new Date(),
});
if (!updatedRecord) {
return ResponseUtil.error(ctx, "订单状态已变化,请刷新后重试", null, 409);
}
return ResponseUtil.success(
ctx,
{ record: HandlerEscortRecord.withPaymentWindow(updatedRecord) },
"取消申请已提交"
);
}
// 管理端/陪诊师:普通状态推进,或确认取消申请 / 直接取消
if (status !== "cancelled") {
if (cancelStatus === "requested") {
return ResponseUtil.badRequest(ctx, "用户已申请取消,请先处理取消申请");
}
if (!canTransition(existing.status, status)) {
return ResponseUtil.badRequest(ctx, "当前订单状态不允许此操作");
}
const updatedRecord = await DBModel.EscortRecord.updateRecordStatus(id, existing.status, { status });
if (!updatedRecord) {
return ResponseUtil.error(ctx, "订单状态已变化,请刷新后重试", null, 409);
}
return ResponseUtil.success(ctx, { record: updatedRecord }, "状态更新成功");
}
if (!canCancelTransition(cancelStatus, "cancelled")) {
return ResponseUtil.badRequest(ctx, "当前订单不允许取消");
}
// 已完成是终态:服务已交付,取消/退款需走线下售后,不能由接口直接改状态
if (existing.status === "completed") {
return ResponseUtil.badRequest(ctx, "已完成订单不可取消,请走线下售后处理");
}
// 取消前先关单:未支付订单可能仍有旧 prepay 在途,关单后发现已支付则按已收款走退款
const closeResult = await HandlerPayment.closeOpenPayRecords(id);
if (closeResult.paid) {
const fresh = await DBModel.EscortRecord.findById(id);
effectivePaymentStatus = fresh?.payment?.status || "paid";
effectivePayment = fresh?.payment || effectivePayment;
}
// 只有「未确认且未收款」的订单取消后直接物理删除;
// 已确认订单即使未收款也需保留记录供后续追溯
if (effectivePaymentStatus === "unpaid" && existing.status === "pending") {
const deletedRecord = await DBModel.EscortRecord.deleteRecord(id);
if (!deletedRecord) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: deletedRecord, deleted: true }, "订单已取消");
}
const update = {
cancelStatus: "cancelled",
cancelledAt: new Date(),
// 已收款订单先进入退款中;线上支付随后自动原路退款,线下由平台人工核销
...(["partial", "paid"].includes(effectivePaymentStatus) ? { "payment.status": "refunding" } : {}),
};
// 正式取消:保留申请原因;平台直接取消时补默认原因
if (cancelReason) update.cancelReason = cancelReason;
else if (role === "admin" && !existing.cancelReason) update.cancelReason = "平台取消";
const updatedRecord = await DBModel.EscortRecord.updateRecordCancel(id, cancelStatus, update);
if (!updatedRecord) {
return ResponseUtil.error(ctx, "订单状态已变化,请刷新后重试", null, 409);
}
// 已支付的线上订单:取消落库后再发起原路全额退款
if (effectivePayment?.method === "online_wechat"
&& ["partial", "paid"].includes(effectivePaymentStatus)) {
HandlerPayment.createRefundForRecord(updatedRecord, {
reason: updatedRecord.cancelReason || cancelReason || "订单取消",
}).catch((err) => {
logger.error(`[escort] 取消订单自动退款失败 recordId=${id}: ${err?.message || err}`);
});
}
return ResponseUtil.success(ctx, { record: updatedRecord }, "状态更新成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
async deleteRecord(ctx) {
try {
const { id } = ctx.params;
if (!id) {
return ResponseUtil.badRequest(ctx, "缺少记录ID");
}
const existing = await DBModel.EscortRecord.findById(id);
if (!existing) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
// 用户端不再提供删除入口:未确认且未收款的取消已在 updateStatus 中直接物理删除。
// 这里只保留管理员的数据清理能力,且一律软删除,保留费用与服务审计链。
if (!HandlerEscortRecord.isAdmin(ctx.state.user)) {
return ResponseUtil.forbidden(ctx, "无权删除该订单");
}
let paymentStatus = existing.payment?.status || "unpaid";
let paymentMethod = existing.payment?.method || "";
// 软删除前先关单:否则已软删除的订单仍可能被旧 prepay 支付
const closeResult = await HandlerPayment.closeOpenPayRecords(id);
if (closeResult.paid) {
const fresh = await DBModel.EscortRecord.findById(id);
paymentStatus = fresh?.payment?.status || "paid";
paymentMethod = fresh?.payment?.method || "online_wechat";
}
const update = { deletedAt: new Date() };
if (["partial", "paid"].includes(paymentStatus)) {
update.cancelStatus = "cancelled";
update.cancelReason = existing.cancelReason || "平台删除";
update.cancelledAt = update.deletedAt;
update["payment.status"] = "refunding";
}
const softDeleted = await DBModel.EscortRecord.updateRecord(id, update);
if (!softDeleted) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
if (update.cancelStatus === "cancelled" && paymentMethod === "online_wechat") {
HandlerPayment.createRefundForRecord(softDeleted, {
reason: softDeleted.cancelReason || "平台删除",
}).catch((err) => {
logger.error(`[escort] 删除订单自动退款失败 recordId=${id}: ${err?.message || err}`);
});
}
return ResponseUtil.success(ctx, { record: softDeleted }, "删除成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
}
export { HandlerEscortRecord };