Files
api_health/handler/escort_record.js
T
likandtrae-solo-agent b8f53d3660 chore: 错误日志记录完整堆栈
internalError 统一传入 err 对象,便于定位线上问题;对外文案仍为通用提示。
2026-10-24 22:26:13 +08:00

533 lines
21 KiB
JavaScript

import { DBModel } from "../models/index.js";
import services from "../resource/services.js";
import ResponseUtil from "../utils/responseUtil.js";
import { isAdmin as isAdminUser } from "../utils/permissions.js";
import { canTransition, STATUS_TRANSITIONS } from "../utils/record_state.js";
class HandlerEscortRecord {
constructor() {
}
// 白名单:只允许写入 schema 定义的顶层字段(兼容 'patient.name' 等点号路径)
static RECORD_FIELDS = [
"userId", "healthProfileId", "patient", "escort",
"attendant", "hospital", "schedule", "payment", "notes", "status",
"shippingAddress",
];
// 用户自助可改字段按订单状态区分(费用、状态、陪诊员分配、档案归属一律由平台控制):
// - 待支付/已支付:可改医院与排期(改期会写审计时间)
// - 进行中:服务已开始,仅可补充就诊人备注,排期与医院不允许用户单方变更
// - 终态:全部不可改
static OWNER_NOTE_FIELDS = ["notes.patientNote"];
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: ["notes.patientNote", ...HandlerEscortRecord.OWNER_BOOKING_FIELDS],
confirmed: ["notes.patientNote", ...HandlerEscortRecord.OWNER_BOOKING_FIELDS],
in_progress: ["notes.patientNote"],
};
// 用户端只能取消;服务完成由平台确认,避免用户端重复写入终态。
// 迁移规则集中在 utils/record_state.js,与管理端 Agent 工具共用
static OWNER_ALLOWED_STATUS = ["cancelled"];
// 单页最大条数,避免 pageSize 传超大值一次拖库
static MAX_PAGE_SIZE = 200;
/**
* 是否为管理端账号(与 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;
return String(record.userId) === String(user?._id);
}
/**
* 从入参中挑出白名单字段
* @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);
}
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(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);
}
}
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 }, "查询成功");
} 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() || !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);
// 陪诊员分配由平台决定:用户下单时提交的 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;
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);
}
}
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);
// 非管理员的可改字段随订单状态收敛:终态无可改字段,进行中只剩就诊人备注
const allowFields = isAdmin
? HandlerEscortRecord.RECORD_FIELDS
: 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, "该订单当前状态不支持修改这些信息");
}
// 档案归属校验:档案必须属于订单所属用户,避免把订单挂到他人档案上;
// 通过后同步刷新订单里的就诊人快照
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 isAdmin = HandlerEscortRecord.isAdmin(ctx.state.user);
if (!isAdmin && !HandlerEscortRecord.OWNER_ALLOWED_STATUS.includes(status)) {
return ResponseUtil.forbidden(ctx, "不支持的状态变更");
}
if (!canTransition(existing.status, 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);
}
}
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, "无权删除该订单");
}
// 删除口径(与产品确认一致):
// - 未支付且未进入服务阶段:物理删除,允许用户/管理员清理误建订单;
// - 其他(已支付/进行中/已完成):仅管理员可「软删除」,
// 状态置为已取消并打 deletedAt 标记,保留费用与服务审计链,列表默认不再展示
const paymentStatus = existing.payment?.status || "unpaid";
const hardDeletable = paymentStatus === "unpaid"
&& ["pending", "confirmed", "cancelled"].includes(existing.status);
if (hardDeletable) {
const deletedRecord = await DBModel.EscortRecord.deleteRecord(id);
if (!deletedRecord) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: deletedRecord }, "删除成功");
}
if (!HandlerEscortRecord.isAdmin(ctx.state.user)) {
return ResponseUtil.forbidden(ctx, "该订单不可删除");
}
const softDeleted = await DBModel.EscortRecord.updateRecord(id, {
status: "cancelled",
cancelReason: "平台删除",
cancelledAt: new Date(),
deletedAt: new Date(),
});
if (!softDeleted) {
return ResponseUtil.error(ctx, "陪诊记录不存在", null, 404);
}
return ResponseUtil.success(ctx, { record: softDeleted }, "删除成功");
} catch (err) {
return ResponseUtil.internalError(ctx, err);
}
}
}
export { HandlerEscortRecord };