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} */ 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 };