Files
api_health/handler/escort_record.js
T
likandtrae-solo-agent 3f3dd07a2a 统一订单预约与服务端状态契约
由服务目录派生排期和费用,补齐幂等下单、取消退款联动及分页计数,避免客户端生成错误订单数据。
Co-Authored-By: Kimi <noreply@moonshot.cn>
2026-10-24 18:00:06 +08:00

465 lines
18 KiB
JavaScript

import { DBModel } from "../models/index.js";
import services from "../resource/services.js";
import ResponseUtil from "../utils/responseUtil.js";
class HandlerEscortRecord {
constructor() {
}
// 白名单:只允许写入 schema 定义的顶层字段(兼容 'patient.name' 等点号路径)
static RECORD_FIELDS = [
"userId", "healthProfileId", "patient", "escort",
"attendant", "hospital", "schedule", "payment", "notes", "status",
"shippingAddress",
];
// 用户端可自助修改的字段:费用、状态、陪诊员分配等一律由平台控制
static OWNER_UPDATE_FIELDS = [
"patient", "healthProfileId", "hospital", "schedule", "notes",
];
// 用户端只能取消;服务完成由平台确认,避免用户端重复写入终态。
static OWNER_ALLOWED_STATUS = ["cancelled"];
static STATUS_TRANSITIONS = {
pending: ["confirmed", "cancelled"],
confirmed: ["in_progress", "cancelled"],
in_progress: ["completed"],
completed: [],
cancelled: [],
};
// 单页最大条数,避免 pageSize 传超大值一次拖库
static MAX_PAGE_SIZE = 200;
/**
* 是否为管理端账号(与 WS 管理端 agent 的校验口径一致)
* @param {Object} user token 解析出的用户
*/
static isAdmin(user) {
return !!(user && user.app && ("wxapp-escort-admin" in user.app));
}
/**
* 记录访问校验:仅记录所属用户本人或管理员可读写
* @param {Object} user 当前登录用户
* @param {Object} record 目标记录
*/
static canAccess(user, record) {
if (!record) return false;
if (HandlerEscortRecord.isAdmin(user)) return true;
return String(record.userId) === String(user?._id);
}
static pickFields(body, allowFields = HandlerEscortRecord.RECORD_FIELDS) {
const picked = {};
for (const key of Object.keys(body || {})) {
const allowed = allowFields.some(
(f) => key === f || 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);
}
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: "预约时间格式不正确" };
const session = booking.sessions.find((item) => item.flexible
? startMinutes >= HandlerEscortRecord.timeToMinutes(item.start)
&& startMinutes + booking.durationMinutes <= HandlerEscortRecord.timeToMinutes(item.end)
: item.start === startTime);
if (!session) return { error: "所选时间不在该服务的可预约时段内" };
const endTime = session.flexible
? (() => {
const endMinutes = (startMinutes + booking.durationMinutes) % 1440;
return `${String(Math.floor(endMinutes / 60)).padStart(2, "0")}:${String(endMinutes % 60).padStart(2, "0")}`;
})()
: session.end;
return {
schedule: {
date,
startTime,
endTime,
duration: Number(booking.durationMinutes) || 0,
},
};
}
static buildShippingAddress(service, source, profile) {
const address = String(source?.address || "").trim();
if (service.booking?.requiresAddress && !address) {
return { error: "请填写完整收货地址" };
}
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 } = 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(HandlerEscortRecord.STATUS_TRANSITIONS, item))) {
return ResponseUtil.badRequest(ctx, "订单状态筛选值不正确");
}
const result = await DBModel.EscortRecord.findRecordPage({
page,
pageSize,
status: statusArray,
userId: effectiveUserId,
appointmentDate,
healthProfileId,
});
return ResponseUtil.success(ctx, { ...result, page, pageSize }, "查询成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err.message);
}
}
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.message);
}
}
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 }, "查询成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err.message);
}
}
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() || !String(body.hospital?.department || "").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(service, body.shippingAddress, profile);
if (addressResult.error) return ResponseUtil.badRequest(ctx, addressResult.error);
const payload = HandlerEscortRecord.pickFields(body);
payload.userId = userId;
payload.status = "pending";
payload.patient = {
name: profile.profile?.name || "",
mobile: profile.profile?.mobile || "",
birth: profile.profile?.birth || "",
};
if (["male", "female"].includes(profile.profile?.sex)) payload.patient.sex = profile.profile.sex;
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;
payload.payment = {
totalFee: Number(service.price) || 0,
paidFee: 0,
status: "unpaid",
};
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.message);
}
}
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);
if (!isAdmin && ["completed", "cancelled"].includes(existing.status)) {
return ResponseUtil.forbidden(ctx, "已结束的订单不可修改");
}
// 非管理员只能改就诊信息类字段,费用/状态/归属/陪诊员分配不可自助修改
const allowFields = isAdmin
? HandlerEscortRecord.RECORD_FIELDS
: HandlerEscortRecord.OWNER_UPDATE_FIELDS;
const payload = HandlerEscortRecord.pickFields(update, allowFields);
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];
}
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.message);
}
}
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 isAdmin = HandlerEscortRecord.isAdmin(ctx.state.user);
if (!isAdmin && !HandlerEscortRecord.OWNER_ALLOWED_STATUS.includes(status)) {
return ResponseUtil.forbidden(ctx, "不支持的状态变更");
}
if (!HandlerEscortRecord.STATUS_TRANSITIONS[existing.status]?.includes(status)) {
return ResponseUtil.badRequest(ctx, "当前订单状态不允许此操作");
}
const update = { status };
if (status === "cancelled") {
const cancelReason = String(reason || (isAdmin ? "平台取消" : "")).trim();
if (!cancelReason) return ResponseUtil.badRequest(ctx, "请选择取消原因");
update.cancelReason = cancelReason.slice(0, 200);
update.cancelledAt = new Date();
// 客服协助支付没有线上自动退款能力:已收款订单先进入退款中,退款完成再由平台核销。
if (["partial", "paid"].includes(existing.payment?.status)) {
update["payment.status"] = "refunding";
}
}
const updatedRecord = await DBModel.EscortRecord.updateRecordStatus(id, existing.status, update);
if (!updatedRecord) {
return ResponseUtil.error(ctx, "订单状态已变化,请刷新后重试", null, 409);
}
return ResponseUtil.success(ctx, { record: updatedRecord }, "状态更新成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err.message);
}
}
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);
}
if (!HandlerEscortRecord.canAccess(ctx.state.user, existing)) {
return ResponseUtil.forbidden(ctx, "无权删除该订单");
}
// 与前端口径一致:仅「未支付且未进入服务阶段」的订单可删。
// 已支付/进行中/已完成的订单承载服务与费用记录,不能只靠前端隐藏按钮来保护
const paymentStatus = existing.payment?.status || "unpaid";
const deletable = paymentStatus === "unpaid"
&& ["pending", "confirmed", "cancelled"].includes(existing.status);
if (!HandlerEscortRecord.isAdmin(ctx.state.user) && !deletable) {
return ResponseUtil.forbidden(ctx, "该订单不可删除");
}
const deletedRecord = await DBModel.EscortRecord.deleteRecord(id);
if (!deletedRecord) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: deletedRecord }, "删除成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err.message);
}
}
}
export { HandlerEscortRecord };