818 lines
24 KiB
JavaScript
818 lines
24 KiB
JavaScript
const { ObjectId } = require("mongodb");
|
|
const dayjs = require("dayjs");
|
|
const peopleUtils = require("./hlw-people-utils");
|
|
const { recordDoctorRecommendation, getDoctorRecommendationCount } = require("./doctor-count-in-one-minute");
|
|
let db = "";
|
|
module.exports = async (item, mongodb) => {
|
|
db = mongodb;
|
|
switch (item.type) {
|
|
case "getHlwDoctorList":
|
|
return await getHlwDoctorList(item);
|
|
case "getHlwPersonList":
|
|
return await getHlwPersonList(item);
|
|
case "deleteHlwDoctor":
|
|
return await deleteHlwDoctor(item);
|
|
case "updateHlwDoctor":
|
|
return await updateHlwDoctor(item);
|
|
case "addHlwDoctor":
|
|
return await addHlwDoctor(item);
|
|
case "getRandomOnlineDoctor":
|
|
return await getRandomOnlineDoctor(item);
|
|
case "isDoctorOnline":
|
|
return await isDoctorOnline(item);
|
|
case "getAllDoctorNos":
|
|
return await getAllDoctorNos(item);
|
|
case "getRecommendDoctor":
|
|
return await getRecommendDoctor(item);
|
|
case "getOptimalRecommendDoctor":
|
|
return await getOptimalRecommendDoctor(item);
|
|
case "setPharmacistOnlineStatus":
|
|
return await setPharmacistOnlineStatus(item);
|
|
case "getPharmacistOnlineStatus":
|
|
return await getPharmacistOnlineStatus(item);
|
|
case "addHlwPerson":
|
|
return await addHlwPerson(item);
|
|
case "updateHlwPerson":
|
|
return await updateHlwPerson(item);
|
|
case "deleteHlwPerson":
|
|
return await deleteHlwPerson(item);
|
|
case "updateHlwPersonDeptInfo":
|
|
return await updateHlwPersonDeptInfo(item);
|
|
case "autoSetPeopleOffline":
|
|
return await autoSetPeopleOffline(item);
|
|
case "getDoctorByNo":
|
|
return await getDoctorByNo(item);
|
|
}
|
|
};
|
|
|
|
async function getPendingOrdersCount(doctorList) {
|
|
const doctorNos = doctorList.map((doctor) => doctor.doctorNo);
|
|
const before3Minutes = Date.now() - 3 * 60 * 1000;
|
|
const case1 = {
|
|
orderStatus: 'pending',
|
|
payStatus: 'pending',
|
|
createTime: { $gte: before3Minutes },
|
|
} // 3分钟内的待支付订单
|
|
const case2 = {
|
|
orderStatus: { $in: ['pending', 'processing'] },
|
|
payStatus: 'success',
|
|
createTime: { $gte: dayjs().startOf('day').valueOf() },
|
|
expireTime: { $gt: Date.now() }
|
|
} // 当天并且未过期的处理中订单
|
|
const countMap = new Map();
|
|
try {
|
|
const doctorOrderCount = await db.collection("consult-order").aggregate([
|
|
{ $match: { doctorCode: { $in: doctorNos }, $or: [case1, case2] } },
|
|
{ $group: { _id: "$doctorCode", count: { $sum: 1 } } }, // 按照医生编号分组，并计算订单数量
|
|
]).toArray()
|
|
doctorOrderCount.forEach((item) => {
|
|
countMap.set(item._id, item.count);
|
|
});
|
|
} catch (e) {
|
|
console.log("获取医生待支付订单数量失败", e);
|
|
}
|
|
|
|
return doctorList.map(i => ({
|
|
...i,
|
|
pendingOrdersCount: countMap.get(i.doctorNo) || 0
|
|
})).sort((a, b) => {
|
|
return a.pendingOrdersCount - b.pendingOrdersCount;
|
|
});
|
|
}
|
|
/**
|
|
* 获取推荐医生
|
|
* @param storeCode 店铺代码
|
|
* @param presType 处方类型 西药处方 west 中医处方 chinese
|
|
* @returns
|
|
*/
|
|
async function getRecommendDoctor({ storeCode, presType }) {
|
|
try {
|
|
// 获取所有在线且服务可用的医生
|
|
const doctorListResult = await getOptimalRecommendDoctor({ recordInOneMinute: true, doctorType: presType },);
|
|
if (!doctorListResult.success) {
|
|
return {
|
|
success: false,
|
|
message: "没有可用的在线医生",
|
|
};
|
|
}
|
|
const doctor = doctorListResult.data;
|
|
// 如果提供了店铺代码，获取收费信息
|
|
if (doctor && storeCode) {
|
|
const storeApi = require("../drug-store");
|
|
const { success, list } = await storeApi(
|
|
{ type: "getDrugStoreList", storeId: storeCode, pageSize: 1 },
|
|
db
|
|
);
|
|
const store = list && list[0] ? list[0] : null;
|
|
const chargeItem =
|
|
store && store.chargeItems ? store.chargeItems[0] : null;
|
|
if (success && chargeItem && chargeItem.code) {
|
|
doctor.feeCode = chargeItem.code;
|
|
doctor.chargeFee = chargeItem.fee;
|
|
} else {
|
|
return {
|
|
success: false,
|
|
message: `店铺（${storeCode}）信息不存在或者店铺收费编码未配置`,
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
success: true,
|
|
message: "获取推荐医生成功",
|
|
data: doctor,
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: error.message || "获取推荐医生失败",
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* @param {boolean} recordInOneMinute 是否记录一分钟内获取推荐医生的数量
|
|
* @returns
|
|
*/
|
|
async function getOptimalRecommendDoctor({ recordInOneMinute = false, doctorType }) {
|
|
try {
|
|
const type = ['west', 'chinese'].includes(doctorType) ? doctorType : 'west';
|
|
// 查询条件：在线且服务状态启用的医生
|
|
const query = {
|
|
onlineStatus: "online",
|
|
serviceStatus: "enabled",
|
|
job: "doctor",
|
|
testDoctor: { $ne: true }, // 过滤测试医生
|
|
};
|
|
if (type === 'chinese') {
|
|
query.openChinesePres = true;
|
|
} else if (type === 'west') {
|
|
query.openWestPres = true;
|
|
}
|
|
const projection = {
|
|
doctorNo: 1,
|
|
doctorName: 1,
|
|
title: 1,
|
|
deptName: 1,
|
|
serviceFee: 1,
|
|
deptCode: 1,
|
|
onlineStatus: 1,
|
|
serviceStatus: 1,
|
|
}
|
|
const doctorList = await db.collection("hlw-doctor").find(query, { projection }).toArray();
|
|
if (doctorList.length === 0) {
|
|
return {
|
|
success: false,
|
|
message: "没有在线医生可推荐",
|
|
};
|
|
}
|
|
const doctors = await getPendingOrdersCount(doctorList);
|
|
doctors.forEach((doc) => {
|
|
const count = getDoctorRecommendationCount(doc.doctorNo);// 获取一分钟内被推荐次数
|
|
doc.weight = doc.pendingOrdersCount + count; // 计算权重 权重 = 待支付订单数 + 门店端)一分钟(内被推荐次数
|
|
})
|
|
doctors.sort((a, b) => a.weight - b.weight);
|
|
// 获取最小权重
|
|
const minWight = doctors[0].weight;
|
|
// console.log(doctors.map(i => ({ doctorNo: i.doctorNo, doctorName: i.doctorName, weight: i.weight })))
|
|
|
|
// 筛选出所有具有最小权重的医生
|
|
const optimalDoctors = doctors.filter(
|
|
(doc) => doc.weight === minWight
|
|
);
|
|
|
|
if (optimalDoctors.length === 1) {
|
|
if (recordInOneMinute) {
|
|
recordDoctorRecommendation(optimalDoctors[0].doctorNo); // 记录医生被推荐
|
|
}
|
|
return {
|
|
success: true,
|
|
message: "获取最优推荐医生成功",
|
|
data: optimalDoctors[0],
|
|
};
|
|
}
|
|
const condition = {
|
|
doctorCode: { $in: optimalDoctors.map(i => i.doctorNo) },
|
|
orderStatus: { $in: ['pending', 'processing'] },
|
|
payStatus: 'success',
|
|
settlement: { $exists: true },
|
|
createTime: { $gte: dayjs().subtract(0.5, 'hour').valueOf() },
|
|
} //
|
|
const [first] = await db.collection("consult-order").aggregate([
|
|
{ $match: condition },
|
|
// 提前进行分组，减少后续处理的数据量
|
|
{
|
|
$group: {
|
|
_id: "$doctorCode",
|
|
earliestOrder: {
|
|
$min: {
|
|
createTime: "$createTime",
|
|
chargeDate: {
|
|
$dateFromString: {
|
|
dateString: "$settlement.chage_date",
|
|
format: "%Y/%m/%d %H:%M:%S"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// 按照结算时间排序
|
|
{ $sort: { "earliestOrder.chargeDate": 1 } },
|
|
// 只返回需要的字段
|
|
{
|
|
$project: {
|
|
doctorCode: "$_id",
|
|
createTime: "$earliestOrder.createTime",
|
|
_id: 0
|
|
}
|
|
},
|
|
{ $limit: 1 } // 如果只需要第一条记录，提前限制结果
|
|
]).toArray();
|
|
|
|
const randomIndex = Math.floor(Math.random() * optimalDoctors.length);
|
|
const doctor = first ? optimalDoctors.find(i => i.doctorNo === first.doctorCode) : optimalDoctors[randomIndex];
|
|
if (doctor && doctor.doctorNo && recordInOneMinute) {
|
|
recordDoctorRecommendation(doctor.doctorNo);
|
|
}
|
|
return {
|
|
success: true,
|
|
message: "获取最优推荐医生成功",
|
|
data: doctor,
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: err.message || "获取最优推荐医生失败",
|
|
};
|
|
}
|
|
}
|
|
// 获取最优推荐医生（问诊量最少）
|
|
async function getOptimalRecommendDoctor1() {
|
|
try {
|
|
// 查询条件：在线且服务状态启用的医生
|
|
const query = {
|
|
onlineStatus: "online",
|
|
serviceStatus: "enabled",
|
|
job: "doctor",
|
|
testDoctor: { $ne: true }, // 过滤测试医生
|
|
};
|
|
|
|
// 使用聚合查询获取医生并计算问诊量
|
|
const doctors = await db
|
|
.collection("hlw-doctor")
|
|
.aggregate([
|
|
{ $match: query },
|
|
{
|
|
$lookup: {
|
|
from: "consult-order",
|
|
localField: "doctorNo",
|
|
foreignField: "doctorCode",
|
|
as: "orders",
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
pendingOrdersCount: {
|
|
$size: {
|
|
$filter: {
|
|
input: "$orders",
|
|
as: "order",
|
|
cond: {
|
|
$or: [
|
|
{
|
|
$and: [
|
|
{
|
|
$in: [
|
|
"$$order.orderStatus",
|
|
["pending", "processing"],
|
|
],
|
|
},
|
|
{ $eq: ["$$order.payStatus", "success"] },
|
|
{ $gt: ["$$order.expireTime", Date.now()] },
|
|
{ $gt: ["$$order.createTime", dayjs().startOf('day').valueOf()] },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$sort: {
|
|
pendingOrdersCount: 1, // 按问诊量升序排序
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
doctorNo: 1,
|
|
doctorName: 1,
|
|
title: 1,
|
|
deptName: 1,
|
|
serviceFee: 1,
|
|
deptCode: 1,
|
|
onlineStatus: 1,
|
|
serviceStatus: 1,
|
|
pendingOrdersCount: 1,
|
|
},
|
|
},
|
|
])
|
|
.toArray();
|
|
|
|
// 如果没有找到符合条件的医生
|
|
if (!doctors || doctors.length === 0) {
|
|
return {
|
|
success: false,
|
|
message: "没有在线医生可推荐",
|
|
};
|
|
}
|
|
|
|
// 获取最少问诊量的值
|
|
const minPendingOrders = doctors[0].pendingOrdersCount;
|
|
|
|
// 筛选出所有具有最少问诊量的医生
|
|
const optimalDoctors = doctors.filter(
|
|
(doc) => doc.pendingOrdersCount === minPendingOrders
|
|
);
|
|
// 如果有多个问诊量相同的医生，随机选择一个
|
|
const randomIndex = Math.floor(Math.random() * optimalDoctors.length);
|
|
const doctor = optimalDoctors[randomIndex];
|
|
return {
|
|
success: true,
|
|
message: "获取最优推荐医生成功",
|
|
data: doctor,
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: err.message || "获取最优推荐医生失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
// 获取医生列表 hlw-doctor 分页 数据库
|
|
async function getHlwDoctorList(item) {
|
|
const {
|
|
doctorName,
|
|
page,
|
|
pageSize,
|
|
doctorCode,
|
|
onlineStatus,
|
|
serviceStatus,
|
|
corpId,
|
|
} = item;
|
|
let query = { job: 'doctor' };
|
|
if (doctorCode) query.doctorNo = doctorCode;
|
|
if (onlineStatus) query.onlineStatus = onlineStatus;
|
|
if (serviceStatus) query.serviceStatus = serviceStatus;
|
|
if (corpId) query.corpId = corpId;
|
|
if (typeof doctorName === "string") {
|
|
query.doctorName = new RegExp(doctorName.trim(), "i");
|
|
}
|
|
if (pageSize === 1) {
|
|
// 查询单个医生（默认为查询推荐医生 过滤测试医生）
|
|
query.testDoctor = { $ne: true };
|
|
}
|
|
if (item.doctorType === 'west') {
|
|
query.openWestPres = true;
|
|
} else if (item.doctorType === 'chinese') {
|
|
query.openChinesePres = true;
|
|
}
|
|
try {
|
|
const projection = {
|
|
doctorNo: 1,
|
|
doctorName: 1,
|
|
title: 1,
|
|
deptName: 1,
|
|
serviceFee: 1,
|
|
deptCode: 1,
|
|
onlineStatus: 1,
|
|
serviceStatus: 1,
|
|
enableVideoConsult: 1,
|
|
}
|
|
const pageNum = Number.isInteger(page) && page > 0 ? page : 1;
|
|
const pageSizeNum =
|
|
Number.isInteger(pageSize) && pageSize > 0 ? pageSize : 15;
|
|
const doctorList = await db.collection("hlw-doctor")
|
|
.find(query, { projection })
|
|
.skip((pageNum - 1) * pageSizeNum)
|
|
.limit(pageSizeNum)
|
|
.toArray();
|
|
console.log("doctorList", doctorList);
|
|
const res = await getPendingOrdersCount(doctorList);
|
|
const total = await db.collection("hlw-doctor").countDocuments(query);
|
|
return {
|
|
success: true,
|
|
message: "查询成功",
|
|
data: res,
|
|
total,
|
|
pages: Math.ceil(total / pageSize),
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: err.message || "查询失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
// 删除医生信息
|
|
async function deleteHlwDoctor(item) {
|
|
const { _id } = item;
|
|
try {
|
|
// 调用mongo 数据库删除
|
|
const res = await db.collection("hlw-doctor").deleteOne({
|
|
_id: new ObjectId(_id),
|
|
job: "doctor",
|
|
});
|
|
return {
|
|
success: true,
|
|
message: "删除成功",
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: "删除失败",
|
|
};
|
|
}
|
|
}
|
|
// 更新医生信息
|
|
async function updateHlwDoctor(item) {
|
|
const { _id, params, doctorNo } = item;
|
|
try {
|
|
let query = { job: { $in: ['doctor', 'TCMDoctor'] } };
|
|
if (_id) query._id = new ObjectId(_id);
|
|
if (doctorNo) query.doctorNo = doctorNo;
|
|
// 调用mongo 数据库更新
|
|
// 如果包含 onlineStatus 字段，按需维护 offlineTime 字段
|
|
const setObj = {
|
|
...params,
|
|
updateTime: Date.now(),
|
|
};
|
|
if (Object.prototype.hasOwnProperty.call(params || {}, 'onlineStatus')) {
|
|
if (params.onlineStatus === 'offline') {
|
|
// 记录下线时间
|
|
setObj.offlineTime = Date.now();
|
|
} else if (params.onlineStatus === 'online') {
|
|
// 清除 offlineTime
|
|
setObj.offlineTime = null;
|
|
}
|
|
}
|
|
|
|
const res = await db.collection("hlw-doctor").updateOne(query, {
|
|
$set: setObj,
|
|
});
|
|
return {
|
|
success: true,
|
|
message: "更新成功",
|
|
res,
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: "更新失败",
|
|
};
|
|
}
|
|
}
|
|
//新增医生信息
|
|
async function addHlwDoctor(item) {
|
|
const { doctorName, doctorTitle, doctorDepartment } = item;
|
|
try {
|
|
// 调用mongo 数据库新增
|
|
const res = await db.collection("hlw-doctor").insertOne({
|
|
doctorName,
|
|
doctorTitle,
|
|
doctorDepartment,
|
|
createTime: Date.now(),
|
|
job: "doctor",
|
|
});
|
|
return {
|
|
success: true,
|
|
message: "新增成功",
|
|
data: res,
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: "新增失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
// 正在咨询数
|
|
async function getRandomOnlineDoctor(params) {
|
|
try {
|
|
const query = {
|
|
onlineStatus: "online",
|
|
serviceStatus: "enabled",
|
|
job: "doctor",
|
|
};
|
|
if (query.doctorNo) {
|
|
query.doctorNo = query.doctorNo;
|
|
}
|
|
const res = await db
|
|
.collection("hlw-doctor")
|
|
.aggregate([
|
|
{ $match: query }, // 假设这是你的查询条件
|
|
{ $project: { idNo: 0 } },
|
|
{ $sample: { size: 1 } }, // 随机返回一个文档
|
|
])
|
|
.toArray();
|
|
return { success: true, data: res, message: "查询成功" };
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "查询失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function isDoctorOnline() {
|
|
try {
|
|
const count = await db.collection("hlw-doctor").countDocuments({
|
|
onlineStatus: "online",
|
|
serviceStatus: "enabled",
|
|
openWestPres: true,
|
|
job: "doctor",
|
|
});
|
|
return { success: true, data: count > 0, message: "查询成功" };
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "查询失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function getAllDoctorNos(ctx) {
|
|
try {
|
|
const jobs = Array.isArray(ctx.jobs) ? ctx.jobs : ['doctor'];
|
|
const query = ctx.showAll === true ? {} : { job: { $in: jobs } };
|
|
const res = await db
|
|
.collection("hlw-doctor")
|
|
.find(query, { projection: { doctorNo: 1, doctorName: 1, job: 1 } })
|
|
.toArray();
|
|
return { success: true, data: res, message: "查询成功" };
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "查询失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function getPharmacistOnlineStatus(ctx) {
|
|
if (typeof ctx.doctorNo !== 'string' || ctx.doctorNo.trim() === '') {
|
|
return { success: false, message: "药师编号不能为空" }
|
|
}
|
|
try {
|
|
const res = await db.collection("hlw-doctor").findOne(
|
|
{ doctorNo: ctx.doctorNo, job: 'pharmacist' },
|
|
{ projection: { onlineStatus: 1 } }
|
|
);
|
|
if (!res) {
|
|
return { success: false, message: "药师不存在或不是药师" }
|
|
}
|
|
return { success: true, message: "查询成功", data: res.onlineStatus }
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "查询药师在线状态失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function setPharmacistOnlineStatus(ctx) {
|
|
if (typeof ctx.doctorNo !== 'string' || ctx.doctorNo.trim() === '') {
|
|
return { success: false, message: "药师编号不能为空" }
|
|
}
|
|
if (!['online', 'offline'].includes(ctx.onlineStatus)) {
|
|
return { success: false, message: "无效的在线状态" }
|
|
}
|
|
try {
|
|
const res = await db.collection("hlw-doctor").updateOne(
|
|
{ doctorNo: ctx.doctorNo, job: 'pharmacist' },
|
|
{ $set: { onlineStatus: ctx.onlineStatus } }
|
|
);
|
|
if (res.matchedCount === 0) {
|
|
return { success: false, message: "药师不存在或不是药师" }
|
|
}
|
|
if (res.modifiedCount === 1) {
|
|
return { success: true, message: "在线状态修改成功", data: ctx.onlineStatus }
|
|
}
|
|
return { success: false, message: "在线状态修改失败" }
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "设置药师在线状态失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function getHlwPersonList(ctx) {
|
|
const corpId = typeof ctx.corpId === 'string' ? ctx.corpId.trim() : '';
|
|
if (!corpId) {
|
|
return { success: false, message: "机构ID不能为空" }
|
|
}
|
|
const page = Number.isInteger(ctx.page) && ctx.page > 0 ? ctx.page : 1;
|
|
const pageSize = Number.isInteger(ctx.pageSize) && ctx.pageSize > 0 ? ctx.pageSize : 10;
|
|
try {
|
|
const query = { corpId };
|
|
if (typeof ctx.keyword === 'string' && ctx.keyword.trim() !== '') {
|
|
query['$or'] = [
|
|
{ doctorName: new RegExp(ctx.keyword.trim(), 'i') },
|
|
{ doctorNo: new RegExp(ctx.keyword.trim(), 'i') },
|
|
]
|
|
}
|
|
if (typeof ctx.deptCode === 'string' && ctx.deptCode.trim() !== '') {
|
|
query.deptCode = ctx.deptCode.trim();
|
|
}
|
|
if (Array.isArray(ctx.deptCodes)) {
|
|
query.deptCode = { $in: ctx.deptCodes };
|
|
}
|
|
if (typeof ctx.doctorNo === 'string' && ctx.doctorNo.trim() !== '') {
|
|
query.doctorNo = ctx.doctorNo.trim();
|
|
}
|
|
const res = await db.collection("hlw-doctor").find(query, { projection: { idNo: 0 } }).sort({ createTime: -1 }).skip((page - 1) * pageSize).limit(pageSize).toArray();
|
|
const total = await db.collection("hlw-doctor").countDocuments(query);
|
|
return { success: true, message: "查询成功", data: res, total };
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "查询人员列表失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
async function addHlwPerson(ctx) {
|
|
try {
|
|
const { success, message, data } = peopleUtils.getPeopleData(ctx);
|
|
if (!success) {
|
|
return { success, message };
|
|
}
|
|
const corpId = typeof ctx.corpId === 'string' ? ctx.corpId.trim() : '';
|
|
if (!corpId) {
|
|
return { success: false, message: "机构ID不能为空" }
|
|
}
|
|
const total = await db.collection("hlw-doctor").countDocuments({ corpId, doctorNo: data.doctorNo });
|
|
if (total > 0) {
|
|
return { success: false, message: "院内工号已存在" }
|
|
}
|
|
const res = await db.collection("hlw-doctor").insertOne({
|
|
...data,
|
|
corpId,
|
|
serviceStatus: "enabled", // 默认启用
|
|
onlineStatus: "offline", // 默认离线
|
|
createTime: Date.now()
|
|
});
|
|
return {
|
|
success: true,
|
|
message: "新增人员成功",
|
|
id: res.insertedId,
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "新增人员失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function updateHlwPerson(ctx) {
|
|
const { success, data, message } = peopleUtils.getPeopleData(ctx, false);
|
|
if (!success) {
|
|
return { success, message };
|
|
}
|
|
try {
|
|
const { doctorCode, ...rest } = data; // 员工编号 不支持修改
|
|
const res = await db.collection("hlw-doctor").updateOne(
|
|
{ _id: new ObjectId(ctx._id) },
|
|
{ $set: { ...rest, updateTime: Date.now() } }
|
|
);
|
|
if (res.matchedCount === 0) {
|
|
return { success: false, message: "人员不存在" }
|
|
}
|
|
return {
|
|
success: true,
|
|
message: "更新人员成功",
|
|
data: res,
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "更新人员失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function updateHlwPersonDeptInfo(ctx) {
|
|
try {
|
|
const query = {
|
|
corpId: typeof ctx.corpId === 'string' ? ctx.corpId.trim() : '',
|
|
deptCode: Array.isArray(ctx.deptCodes) ? { $in: ctx.deptCodes } : '',
|
|
}
|
|
const data = {
|
|
deptCode: typeof ctx.newDeptCode == 'string' ? ctx.newDeptCode.trim() : '',
|
|
deptName: typeof ctx.newDeptName == 'string' ? ctx.newDeptName.trim() : '',
|
|
}
|
|
const res = await db.collection("hlw-doctor").updateMany(
|
|
query,
|
|
{ $set: { ...data, updateTime: Date.now() } }
|
|
);
|
|
return {
|
|
success: true,
|
|
message: "更新人员成功",
|
|
data: res,
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "更新人员失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function deleteHlwPerson(ctx) {
|
|
try {
|
|
const res = await db.collection("hlw-doctor").deleteOne({
|
|
_id: new ObjectId(ctx._id)
|
|
});
|
|
if (res.deletedCount === 0) {
|
|
return { success: false, message: "人员不存在" }
|
|
}
|
|
return {
|
|
success: true,
|
|
message: "删除人员成功",
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "删除人员失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
async function autoSetPeopleOffline() {
|
|
if (![22, 23, 24].includes(dayjs().hour())) {
|
|
return { success: false, message: '每天自动下线时间在22:00-24:00之间' }
|
|
}
|
|
try {
|
|
await db.collection("hlw-doctor").updateMany(
|
|
{ onlineStatus: 'online' },
|
|
{ $set: { onlineStatus: 'offline' } }
|
|
);
|
|
return { success: true, message: "设置人员离线成功" }
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "设置人员离线失败",
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* 一对一通过 doctorNo 查询人员信息
|
|
* 仅允许 job 为 doctor 或 pharmacist
|
|
*/
|
|
async function getDoctorByNo(ctx) {
|
|
const doctorNo = typeof ctx.doctorNo === 'string' ? ctx.doctorNo.trim() : '';
|
|
const corpId = typeof ctx.corpId === 'string' ? ctx.corpId.trim() : '';
|
|
|
|
if (!doctorNo) {
|
|
return { success: false, message: "doctorNo 不能为空" };
|
|
}
|
|
|
|
const query = {
|
|
doctorNo,
|
|
job: { $in: ['doctor', 'pharmacist'] },
|
|
};
|
|
if (corpId) {
|
|
query.corpId = corpId;
|
|
}
|
|
|
|
try {
|
|
const projection = {
|
|
idNo: 0, // 默认不返回证件号等敏感信息，如需可调整
|
|
};
|
|
const res = await db.collection("hlw-doctor").findOne(query, { projection });
|
|
|
|
if (!res) {
|
|
return {
|
|
success: false,
|
|
message: "人员不存在，或不是医生/药师",
|
|
};
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: "查询成功",
|
|
data: res,
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
success: false,
|
|
message: err.message || "查询失败",
|
|
};
|
|
}
|
|
} |