656 lines
15 KiB
JavaScript
656 lines
15 KiB
JavaScript
const utils = require("../utils");
|
|
const dayjs = require("dayjs");
|
|
const common = require("../../common");
|
|
const appFunction = require("../app-function");
|
|
const api = require("../../api");
|
|
|
|
let db = null;
|
|
|
|
exports.main = async (content, DB) => {
|
|
db = DB;
|
|
switch (content.type) {
|
|
case "getGroups":
|
|
return await exports.getGroups(content);
|
|
case "createGroup":
|
|
return await exports.createGroup(content);
|
|
case "updateGroup":
|
|
return await exports.updateGroup(content);
|
|
case "getGroupsByCorpGroupId":
|
|
return await exports.getGroupsByCorpGroupId(content);
|
|
case "orderTeamGroups":
|
|
return await exports.orderTeamGroups(content);
|
|
case "removeGroup":
|
|
return await exports.removeGroup(content);
|
|
case "addGroupIdForMember":
|
|
return await exports.addGroupIdForMember(content);
|
|
case "customerEnterGroup":
|
|
return await exports.customerEnterGroup(content);
|
|
case "getGroupByIds":
|
|
return await exports.getGroupByIds(content);
|
|
default:
|
|
return {
|
|
success: false,
|
|
message: "未找到对应的操作类型",
|
|
};
|
|
}
|
|
};
|
|
|
|
exports.createGroup = async (context) => {
|
|
const { corpId, params } = context;
|
|
const {
|
|
groupName,
|
|
managementPlan = {},
|
|
teamId,
|
|
groupType,
|
|
description,
|
|
creator,
|
|
relatePlan,
|
|
executorUserId,
|
|
} = params;
|
|
|
|
if (!corpId) {
|
|
return {
|
|
success: false,
|
|
message: "机构ID未输入",
|
|
};
|
|
}
|
|
if (!groupName) {
|
|
return {
|
|
success: false,
|
|
message: "分组名称未输入",
|
|
};
|
|
}
|
|
|
|
const countQuery = {
|
|
corpId,
|
|
groupName,
|
|
};
|
|
if (groupType === "corp") {
|
|
countQuery.groupType = "corp";
|
|
} else {
|
|
countQuery.teamId = teamId;
|
|
}
|
|
|
|
const count = await db.collection("group").find(countQuery).count();
|
|
if (count > 0) {
|
|
return {
|
|
success: false,
|
|
message: "分组名称重复!",
|
|
};
|
|
}
|
|
|
|
let query = {
|
|
_id: common.generateRandomString(24),
|
|
corpId,
|
|
teamId,
|
|
groupName,
|
|
managementPlan,
|
|
creator,
|
|
description,
|
|
createTime: dayjs().valueOf(),
|
|
};
|
|
|
|
if (groupType === "corp") {
|
|
query["groupType"] = "corp";
|
|
} else {
|
|
query["groupType"] = "team";
|
|
query["relatePlan"] = typeof relatePlan === "boolean" ? relatePlan : false;
|
|
query["executorUserId"] =
|
|
typeof executorUserId == "string" && executorUserId.trim()
|
|
? executorUserId.trim()
|
|
: "";
|
|
}
|
|
|
|
try {
|
|
const result = await db.collection("group").insertOne(query);
|
|
const id = result.insertedId;
|
|
if (groupType === "corp") await distributeGroupToTeam(id, query);
|
|
return {
|
|
success: true,
|
|
data: id,
|
|
message: "新增分组成功",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: "新增分组失败",
|
|
};
|
|
}
|
|
};
|
|
|
|
// 分发机构分组到团队
|
|
async function distributeGroupToTeam(parentGroupId, group) {
|
|
const { corpId, groupName, managementPlan, description } = group;
|
|
|
|
try {
|
|
const { list = [] } = await api.getCorpApi({
|
|
type: "getCorpTeams",
|
|
corpId,
|
|
pageSize: 10000,
|
|
page: 1,
|
|
fields: { teamId: 1 },
|
|
showCustomerCount: false,
|
|
});
|
|
const teams = Array.isArray(list)
|
|
? list.filter((i) => Boolean(i.teamId))
|
|
: [];
|
|
const bulkOps = teams.map((team) => {
|
|
const { teamId } = team;
|
|
const query = {
|
|
_id: common.generateRandomString(24),
|
|
parentGroupId,
|
|
corpId,
|
|
teamId,
|
|
groupName,
|
|
managementPlan,
|
|
description,
|
|
createTime: dayjs().valueOf(),
|
|
};
|
|
return {
|
|
insertOne: {
|
|
document: query,
|
|
},
|
|
};
|
|
});
|
|
|
|
if (bulkOps.length > 0) {
|
|
await db.collection("group").bulkWrite(bulkOps);
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: "分发成功",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: "分发失败",
|
|
};
|
|
}
|
|
}
|
|
|
|
exports.updateGroup = async (context) => {
|
|
const { id, params, corpId } = context;
|
|
if (!id) {
|
|
return {
|
|
success: false,
|
|
message: "分组id未传",
|
|
};
|
|
}
|
|
|
|
const { groupName, managementPlan, description, relatePlan, executorUserId } =
|
|
params;
|
|
let query = { updateTime: dayjs().valueOf() };
|
|
|
|
if (typeof groupName === "string") {
|
|
query["groupName"] = groupName.trim();
|
|
}
|
|
if (typeof description === "string") {
|
|
query["description"] = description.trim();
|
|
}
|
|
if (typeof managementPlan === "object" && managementPlan) {
|
|
query["managementPlan"] = managementPlan;
|
|
}
|
|
if (typeof relatePlan === "boolean") {
|
|
query["relatePlan"] = relatePlan;
|
|
}
|
|
if (typeof executorUserId === "string") {
|
|
query["executorUserId"] = executorUserId.trim();
|
|
}
|
|
|
|
try {
|
|
await db.collection("group").updateMany(
|
|
{
|
|
corpId,
|
|
$or: [{ _id: id }, { parentGroupId: id }],
|
|
},
|
|
{ $set: query }
|
|
);
|
|
return {
|
|
success: true,
|
|
message: "修改成功",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: error.message || "修改失败",
|
|
};
|
|
}
|
|
};
|
|
exports.removeGroup = async (context) => {
|
|
const { corpId, id, groupType, teamId } = context;
|
|
if (!corpId) {
|
|
return {
|
|
success: false,
|
|
message: "机构ID未输入",
|
|
};
|
|
}
|
|
if (!id) {
|
|
return {
|
|
success: false,
|
|
message: "机构ID未输入",
|
|
};
|
|
}
|
|
|
|
try {
|
|
let memberCount = 0;
|
|
// 判断是否存在客户
|
|
if (groupType === "corp") {
|
|
// 机构分组
|
|
const groups = await db
|
|
.collection("group")
|
|
.find({ corpId, parentGroupId: id })
|
|
.toArray();
|
|
const groupIds = groups.map((e) => e._id);
|
|
memberCount = await db
|
|
.collection("member")
|
|
.find({ corpId, groupIds: { $in: groupIds } })
|
|
.count();
|
|
} else {
|
|
memberCount = await db
|
|
.collection("member")
|
|
.find({ corpId, groupIds: id, teamId })
|
|
.count();
|
|
}
|
|
|
|
if (memberCount !== 0) {
|
|
return {
|
|
success: false,
|
|
message: "此分组下还存在客户,请将客户转组后再删除本分组!",
|
|
};
|
|
}
|
|
|
|
// 删除分组
|
|
await db.collection("group").deleteMany({
|
|
corpId,
|
|
$or: [{ _id: id }, { parentGroupId: id }],
|
|
});
|
|
return {
|
|
success: true,
|
|
message: "删除成功",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: "删除失败",
|
|
};
|
|
}
|
|
};
|
|
|
|
exports.getGroupByIds = async (context) => {
|
|
const { ids, corpId } = context;
|
|
if (!ids) {
|
|
return {
|
|
success: false,
|
|
message: "分组ID未输入",
|
|
};
|
|
}
|
|
|
|
try {
|
|
const data = await db
|
|
.collection("group")
|
|
.find({ _id: { $in: ids }, corpId })
|
|
.toArray();
|
|
return {
|
|
success: true,
|
|
data,
|
|
message: "获取成功",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
message: "获取失败",
|
|
};
|
|
}
|
|
};
|
|
|
|
exports.getGroups = async (context) => {
|
|
const { corpId, teamId, page, pageSize, groupName, groupType } = context;
|
|
if (!corpId) {
|
|
return {
|
|
success: false,
|
|
message: "机构ID未输入",
|
|
};
|
|
}
|
|
|
|
let query = { corpId };
|
|
if (groupType === "corp") {
|
|
query.groupType = "corp";
|
|
} else {
|
|
query["teamId"] = teamId;
|
|
}
|
|
if (groupName && typeof groupName === "string" && groupName.trim()) {
|
|
query.groupName = new RegExp(".*" + groupName.trim() + ".*", "i");
|
|
}
|
|
|
|
const total = await db.collection("group").find(query).count();
|
|
const pages = Math.ceil(total / pageSize);
|
|
const data = await db
|
|
.collection("group")
|
|
.find(query)
|
|
.sort({ createTime: -1 })
|
|
.skip((page - 1) * pageSize)
|
|
.limit(pageSize)
|
|
.toArray();
|
|
|
|
const handler = async (item) => {
|
|
let count = await db
|
|
.collection("member")
|
|
.find({
|
|
corpId,
|
|
groupIds: item._id,
|
|
teamId: teamId,
|
|
})
|
|
.count();
|
|
item.memberCount = count;
|
|
return item;
|
|
};
|
|
|
|
let list = await utils.processInBatches(data, handler, 10);
|
|
return {
|
|
success: true,
|
|
data: list,
|
|
message: "获取成功",
|
|
total: total,
|
|
pages: pages,
|
|
size: pageSize,
|
|
};
|
|
};
|
|
|
|
exports.addGroupIdForMember = async (context) => {
|
|
const { memberId, toGroupId, fromGroupId } = context;
|
|
if (!memberId) {
|
|
return {
|
|
success: false,
|
|
message: "客户Id未输入!",
|
|
};
|
|
}
|
|
|
|
try {
|
|
const member = await db.collection("member").findOne({ _id: memberId });
|
|
let { groupIds = [] } = member;
|
|
|
|
if (fromGroupId && Array.isArray(groupIds)) {
|
|
const index = groupIds.findIndex((e) => e == fromGroupId);
|
|
groupIds.splice(index, 1);
|
|
}
|
|
if (toGroupId && Array.isArray(groupIds)) {
|
|
const index = groupIds.findIndex((e) => e == toGroupId);
|
|
if (index < 0) groupIds.push(toGroupId);
|
|
}
|
|
|
|
await db.collection("member").updateOne(
|
|
{ _id: memberId },
|
|
{
|
|
$set: { groupIds },
|
|
}
|
|
);
|
|
return {
|
|
success: true,
|
|
groupIds,
|
|
message: "更新成功!",
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: true,
|
|
message: "更新失败!",
|
|
};
|
|
}
|
|
};
|
|
exports.orderTeamGroups = async (ctx) => {
|
|
const { teamId, corpId, order } = ctx;
|
|
if (
|
|
!corpId ||
|
|
!teamId ||
|
|
Object.prototype.toString.call(order) !== "[object Object]"
|
|
) {
|
|
return {
|
|
success: false,
|
|
message: "参数错误",
|
|
};
|
|
}
|
|
|
|
const ids = Object.keys(order);
|
|
if (ids.length === 0) {
|
|
return { success: true, message: "参数错误" };
|
|
}
|
|
|
|
try {
|
|
const list = await db
|
|
.collection("group")
|
|
.find({
|
|
corpId,
|
|
teamId,
|
|
_id: { $in: ids },
|
|
})
|
|
.toArray();
|
|
|
|
const bulkOps = list
|
|
.map((i) => ({ id: i._id, order: order[i._id] }))
|
|
.filter((i) => typeof i.order === "number" && i.order >= 0)
|
|
.map((item) => ({
|
|
updateOne: {
|
|
filter: { _id: item.id },
|
|
update: { $set: { order: item.order } },
|
|
},
|
|
}));
|
|
|
|
if (bulkOps.length > 0) {
|
|
await db.collection("group").bulkWrite(bulkOps);
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: "更新成功",
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "更新失败",
|
|
};
|
|
}
|
|
};
|
|
|
|
exports.getGroupsByCorpGroupId = async (ctx) => {
|
|
const { id, corpId } = ctx;
|
|
if (!id || !corpId) {
|
|
return { success: false, message: "参数错误" };
|
|
}
|
|
|
|
try {
|
|
const data = await db
|
|
.collection("group")
|
|
.find({ parentGroupId: id, corpId })
|
|
.toArray();
|
|
return { success: true, data, message: "获取成功" };
|
|
} catch (e) {
|
|
return {
|
|
success: false,
|
|
message: e.message || "获取失败",
|
|
};
|
|
}
|
|
};
|
|
|
|
exports.customerEnterGroup = async (context) => {
|
|
let {
|
|
corpId,
|
|
customerId,
|
|
targetGroupId,
|
|
executeTeamId,
|
|
executeTeamName,
|
|
executeUserId,
|
|
planExecutionTime,
|
|
} = context;
|
|
if (!corpId || !customerId || !targetGroupId) {
|
|
return {
|
|
success: false,
|
|
message: "必须字段为传!",
|
|
};
|
|
}
|
|
const customer = await db.collection("member").findOne({ _id: customerId });
|
|
if (!customer) {
|
|
return {
|
|
success: false,
|
|
message: "患者不存在",
|
|
};
|
|
}
|
|
const { groupIds = [] } = customer;
|
|
// //先判断目标分组是否是机构分组, 若不是机构分组, 则可以直接使用
|
|
const group = await db.collection("group").findOne({
|
|
_id: targetGroupId,
|
|
corpId,
|
|
});
|
|
if (!group) {
|
|
return {
|
|
success: false,
|
|
message: "未获取到目标分组",
|
|
};
|
|
}
|
|
// 若此分组是是机构分组, 则去除在侧团队的子分组
|
|
if (!group.parentGroupId) {
|
|
const temaGroups = await db
|
|
.collection("group")
|
|
.find({
|
|
corpId,
|
|
teamId: executeTeamId,
|
|
})
|
|
.toArray();
|
|
const teamGroup = temaGroups.find((i) => i.parentGroupId === targetGroupId);
|
|
if (!teamGroup) {
|
|
return {
|
|
success: false,
|
|
message: "未获取到目标分组",
|
|
};
|
|
}
|
|
targetGroupId = teamGroup._id;
|
|
}
|
|
|
|
// 如果是机构分组, 在拿到执行团队的所有机构分组, 找到目标分组在当前团队的子分组
|
|
console.log("groupIds", groupIds);
|
|
console.log("targetGroupId", targetGroupId);
|
|
|
|
if (Array.isArray(groupIds) && groupIds.some((i) => i === targetGroupId)) {
|
|
return {
|
|
success: false,
|
|
message: "患者已进入相同分组",
|
|
};
|
|
}
|
|
const allGroupId = [...groupIds, targetGroupId];
|
|
const groups = await db
|
|
.collection("group")
|
|
.find({
|
|
_id: { $in: allGroupId },
|
|
corpId,
|
|
})
|
|
.toArray();
|
|
if (groups.length === 0 || !Array.isArray(groups)) {
|
|
return {
|
|
success: false,
|
|
message: "未获取到分组",
|
|
};
|
|
}
|
|
const targetGroup = groups.find((i) => i._id === targetGroupId); // 获取目标分组
|
|
if (!targetGroup) {
|
|
return {
|
|
success: false,
|
|
message: "未获取到目标分组",
|
|
};
|
|
}
|
|
const { managementPlan } = targetGroup;
|
|
let customerGroupIds = [];
|
|
if (groupIds.length === 0) {
|
|
customerGroupIds = [targetGroupId];
|
|
} else {
|
|
// 获取客户分组
|
|
const customerGroups = groups.filter((i) =>
|
|
groupIds.some((j) => j === i._id)
|
|
);
|
|
let res = groupRules({ customerGroups, targetGroup });
|
|
if (!res.success) return res;
|
|
customerGroupIds = allGroupId;
|
|
}
|
|
await updateGroupIdForMember({
|
|
customerGroupIds,
|
|
customer,
|
|
managementPlan,
|
|
executeTeamId,
|
|
executeTeamName,
|
|
corpId,
|
|
executeUserId,
|
|
planExecutionTime,
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
message: "进组成功",
|
|
};
|
|
};
|
|
|
|
function groupRules({ customerGroups, targetGroup }) {
|
|
const { parentGroupId: targetParentGroupId, teamId: targetTeamId } =
|
|
targetGroup;
|
|
|
|
// 如果存在targetParentGroupId 则此分组为机构分组
|
|
if (targetParentGroupId && customerGroups.some((i) => i.parentGroupId)) {
|
|
return {
|
|
success: false,
|
|
message: "患者已进入其他机构分组",
|
|
};
|
|
} else if (customerGroups.some((i) => i.teamId === targetTeamId)) {
|
|
return {
|
|
success: false,
|
|
message: "患者已入团队下其他分组",
|
|
};
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
customerGroupIds: [],
|
|
};
|
|
}
|
|
|
|
async function updateGroupIdForMember(context) {
|
|
const {
|
|
customerGroupIds,
|
|
customer,
|
|
executeTeamId,
|
|
executeTeamName,
|
|
managementPlan = {},
|
|
executeUserId,
|
|
corpId,
|
|
} = context;
|
|
// 更新患者信息分组信息
|
|
await db.collection("member").updateOne(
|
|
{ _id: customer._id },
|
|
{
|
|
$set: { groupIds: customerGroupIds },
|
|
}
|
|
);
|
|
let { taskList, planId, planName } = managementPlan;
|
|
taskList = taskList.map((item) => {
|
|
const { timeType, taskTime } = item;
|
|
if (timeType) {
|
|
item["planExecutionTime"] = dayjs().add(taskTime, timeType).valueOf();
|
|
} else {
|
|
item["planExecutionTime"] = dayjs().add(taskTime, "day").valueOf();
|
|
}
|
|
return item;
|
|
});
|
|
if (planId) {
|
|
const params = {
|
|
corpId,
|
|
customerId: customer._id || "",
|
|
customerName: customer.name || "",
|
|
customerUserId: customer.externalUserId || "",
|
|
executeTeamId,
|
|
executeTeamName,
|
|
taskList,
|
|
planId,
|
|
planName,
|
|
userId: executeUserId,
|
|
};
|
|
const res = await appFunction.executeManagementPlanTodo(params);
|
|
console.log("res", res);
|
|
}
|
|
}
|