1056 lines
30 KiB
JavaScript
1056 lines
30 KiB
JavaScript
const dayjs = require("dayjs");
|
||
const common = require("../common");
|
||
const weCom = require("../weCom/index.js");
|
||
const utils = require("./utils");
|
||
const logger = require("../utils/logger");
|
||
const api = require("../api");
|
||
let db = null;
|
||
exports.main = async (event, mongodb) => {
|
||
db = mongodb;
|
||
switch (event.type) {
|
||
case "createGroupmsgTask":
|
||
return await createGroupmsgTask(event);
|
||
case "getWecomGroupmesgList":
|
||
return await getWecomGroupmesgList(event);
|
||
case "addWecomMsgTemplate":
|
||
return await addWecomMsgTemplate(event);
|
||
case "stopGroupmsgTask":
|
||
return await stopGroupmsgTask(event);
|
||
case "getGroupmesgById":
|
||
return await getGroupmesgById(event);
|
||
case "getCusomterGroupmsgSendResult":
|
||
return await getCusomterGroupmsgSendResult(event);
|
||
case "addWecomMsgTemplateForTeamOrCorp":
|
||
return await addWecomMsgTemplateForTeamOrCorp(event);
|
||
case "getTeamMemberExecuteState":
|
||
return await getTeamMemberExecuteState(event);
|
||
case "remindGroupmsgSend":
|
||
return await remindGroupmsgSend(event);
|
||
case "createCurrentGroupMsgTask":
|
||
return await createCurrentGroupMsgTask(event);
|
||
case "stopExpireGroupmsgTask":
|
||
return await stopExpireGroupmsgTask(event);
|
||
case "getGroupmsgMsgidsByTaskIds":
|
||
return await getGroupmsgMsgidsByTaskIds(event);
|
||
}
|
||
};
|
||
// 创建群发任务
|
||
async function remindGroupmsgSend(context) {
|
||
return await weCom.main(context, db);
|
||
}
|
||
async function getGroupmsgMsgidsByTaskIds(context) {
|
||
try {
|
||
const { taskIds, corpId } = context;
|
||
if (!taskIds || taskIds.length === 0) {
|
||
return {
|
||
success: false,
|
||
message: "任务ID列表为空",
|
||
};
|
||
}
|
||
const list = await db
|
||
.collection("groupmsg-task")
|
||
.find({ taskId: { $in: taskIds } })
|
||
.toArray();
|
||
if (!list || list.length === 0) {
|
||
return {
|
||
success: false,
|
||
message: "未找到相关任务",
|
||
};
|
||
}
|
||
const res = await getGroupmsgResultBymsgIds(list, corpId);
|
||
return {
|
||
success: true,
|
||
data: res,
|
||
message: "获取成功",
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
success: false,
|
||
message: "获取失败",
|
||
};
|
||
}
|
||
}
|
||
async function getGroupmsgResultBymsgIds(list, corpId) {
|
||
if (!list || list.length === 0) {
|
||
return [];
|
||
}
|
||
const groupmsgList = list.map(({ msgid, executor: userid, taskId }) => ({
|
||
msgid,
|
||
userid,
|
||
taskId,
|
||
}));
|
||
console.log("list", list);
|
||
const arr = groupmsgList
|
||
.filter((i) => i.msgid)
|
||
.map(async (item) => {
|
||
const { msgid, userid, taskId } = item;
|
||
const res = await weCom.main({
|
||
type: "getWecomGroupmsgSendResult",
|
||
corpId,
|
||
msgid,
|
||
userid,
|
||
});
|
||
const { send_list } = res;
|
||
const Obj =
|
||
Array.isArray(send_list) && send_list.length > 0 ? send_list[0] : {};
|
||
const { status, result } = Obj;
|
||
return {
|
||
sendSatus: status,
|
||
result,
|
||
taskId,
|
||
};
|
||
});
|
||
let sendResult = await Promise.all(arr);
|
||
console.log("sendResult", sendResult);
|
||
return sendResult;
|
||
}
|
||
async function createGroupmsgTask(context) {
|
||
let { params, accessToken, executedExternalUserIds = [] } = context;
|
||
// // 1. 为群发任务添加创建时间
|
||
params["createTime"] = dayjs().valueOf();
|
||
const _id = common.generateRandomString(24);
|
||
params["_id"] = _id;
|
||
// 2. 插入群发任务到 MongoDB
|
||
await db.collection("groupmsg-task").insertOne(params);
|
||
// 3. 如果发送来源是 "MINE"，则调用 WeCom 消息接口
|
||
if (params.sendSource === "MINE") {
|
||
let { success, executedExternalUserIds: ids } = await createWecomMsg({
|
||
params,
|
||
executedExternalUserIds,
|
||
templateId: _id, // 使用任务 ID 作为模板 ID
|
||
externalUserIds: params.externalUserIds,
|
||
accessToken,
|
||
});
|
||
// 如果成功且返回了有效的用户 ID 列表，更新执行的用户 ID 列表
|
||
if (success && ids && Array.isArray(ids)) {
|
||
executedExternalUserIds = ids;
|
||
}
|
||
}
|
||
// 返回成功的结果
|
||
return {
|
||
success: true,
|
||
message: "创建群发任务成功",
|
||
executedExternalUserIds,
|
||
id: _id, // 返回任务 ID
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 创建群发任务
|
||
* @param {*} params
|
||
* @param {*} executedExternalUserIds
|
||
* @param {*} templateId
|
||
* @returns
|
||
*/
|
||
async function createWecomMsg({
|
||
params,
|
||
executedExternalUserIds = [],
|
||
templateId,
|
||
accessToken,
|
||
}) {
|
||
const {
|
||
corpId,
|
||
externalUserIds = [],
|
||
attachments,
|
||
content,
|
||
executor,
|
||
} = params;
|
||
if (!externalUserIds || externalUserIds.length === 0) {
|
||
return await addWecomMsgTemplate({
|
||
corpId,
|
||
accessToken,
|
||
templateId,
|
||
executedExternalUserIds,
|
||
});
|
||
} else {
|
||
return await addWecomMsgTemplateApi({
|
||
corpId,
|
||
accessToken,
|
||
templateId,
|
||
externalUserIds,
|
||
attachments,
|
||
content,
|
||
executor,
|
||
});
|
||
}
|
||
}
|
||
async function addWecomMsgTemplateForTeamOrCorp(context) {
|
||
try {
|
||
const { params, id, accessToken } = context;
|
||
const { userIds, ...rest } = params;
|
||
const { teamIds } = rest;
|
||
let createSounrce = rest.sendSource;
|
||
let executedExternalUserIds = [];
|
||
for (const userId of userIds) {
|
||
let { customers, externalUserIds } = await getSendGroupmsgCustomers({
|
||
teamIds,
|
||
userId,
|
||
corpId: rest.corpId,
|
||
});
|
||
rest.createSounrce = createSounrce;
|
||
rest.customers = customers;
|
||
rest.executor = userId;
|
||
rest.sendSource = "MINE";
|
||
rest.parentId = id;
|
||
rest.executeStatus = "doing";
|
||
rest.startTaskDate = dayjs().startOf("day").valueOf();
|
||
rest.externalUserIds = externalUserIds;
|
||
let { executedExternalUserIds: userIds } = await createGroupmsgTask({
|
||
params: rest,
|
||
executedExternalUserIds,
|
||
accessToken,
|
||
});
|
||
executedExternalUserIds = userIds;
|
||
}
|
||
return {
|
||
success: true,
|
||
message: "创建群发任务成功",
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
success: false,
|
||
message: "error",
|
||
};
|
||
}
|
||
}
|
||
|
||
// 获取团队群发, 通过userId获取到该团队下加过好友的外部联系人
|
||
async function getSendGroupmsgCustomers({ teamIds, userId, corpId }) {
|
||
// 查询到member表中符合teamId字段在teamIds 和 externalUserId 存在且不为空的所有customers, 只获取_id 和 externalUserId, 注意分页查询, 获取到所有数据
|
||
const fetchData = async (page, pageSize, db) => {
|
||
let query = {
|
||
teamId: { $in: teamIds },
|
||
externalUserId: { $exists: true, $ne: "" },
|
||
corpId,
|
||
};
|
||
let result = await db
|
||
.collection("member")
|
||
.aggregate([
|
||
{ $match: query },
|
||
{ $skip: (page - 1) * pageSize },
|
||
{ $limit: pageSize },
|
||
{ $project: { externalUserId: 1, _id: 1 } },
|
||
])
|
||
.toArray();
|
||
return result;
|
||
};
|
||
const allCustomerData = await utils.getAllData(fetchData, db);
|
||
// 筛选出所有的外部联系人ID
|
||
const externalUserIds = allCustomerData.map((item) => item.externalUserId);
|
||
if (externalUserIds.length === 0) {
|
||
return { customers: [], externalUserIds: [] };
|
||
}
|
||
const fetchData2 = async (page, pageSize, db) => {
|
||
let res = await api.getCorpApi({
|
||
type: "getExternalUserIdByUserId",
|
||
userId,
|
||
externalUserIds,
|
||
corpId,
|
||
page,
|
||
pageSize,
|
||
});
|
||
console.log("res", res.data);
|
||
return res.data;
|
||
};
|
||
const allFriendsData = await utils.getAllData(fetchData2, db);
|
||
// 筛选出所有的外部联系人ID
|
||
const externalUserIds2 = allFriendsData.map((item) => item.external_userid);
|
||
const allCustomers = allCustomerData.filter((item) =>
|
||
externalUserIds2.includes(item.externalUserId)
|
||
);
|
||
const customers = allCustomers.map((item) => item._id);
|
||
return { customers, externalUserIds: externalUserIds2 };
|
||
}
|
||
|
||
async function getGroupmesgById(content) {
|
||
const { id } = content;
|
||
try {
|
||
const task = await db.collection("groupmsg-task").findOne({ _id: id });
|
||
return {
|
||
success: true,
|
||
data: task,
|
||
message: "获取群发任务成功",
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
success: false,
|
||
message: "获取群发任务失败",
|
||
};
|
||
}
|
||
}
|
||
async function getWecomGroupmesgList(context) {
|
||
const { corpId, accessToken, page, pageSize, params } = context;
|
||
const {
|
||
teamIds,
|
||
startCreateTime,
|
||
endCreateTime,
|
||
orderType = "desc",
|
||
...rest
|
||
} = params;
|
||
// 构建查询条件
|
||
let query = { corpId, ...rest };
|
||
// 如果 teamIds 存在且为数组，则使用 $in 操作符
|
||
if (Array.isArray(teamIds) && teamIds.length > 0) {
|
||
query["teamIds"] = { $in: teamIds };
|
||
}
|
||
// 处理时间范围条件
|
||
if (startCreateTime && dayjs(startCreateTime).isValid()) {
|
||
query["createTime"] = { $gte: dayjs(startCreateTime).valueOf() };
|
||
}
|
||
if (endCreateTime && dayjs(endCreateTime).isValid()) {
|
||
query["createTime"] = query["createTime"] || {}; // 如果 startCreateTime 存在，保持合并
|
||
query["createTime"]["$lte"] = dayjs(endCreateTime).valueOf();
|
||
}
|
||
// 获取企业访问令牌
|
||
try {
|
||
// 计算总数
|
||
const total = await db.collection("groupmsg-task").countDocuments(query); // 获取符合条件的总记录数
|
||
// 计算分页页数
|
||
const pages = Math.ceil(total / pageSize);
|
||
// 获取企业群发消息列表
|
||
const corpGroupmsgList = await db
|
||
.collection("groupmsg-task")
|
||
.find(query) // 使用 find() 替代 where()
|
||
.skip((page - 1) * pageSize) // 实现分页
|
||
.limit(pageSize) // 每页数量限制
|
||
.sort({ createTime: orderType === "desc" ? -1 : 1 }) // 按 createTime 倒序排序
|
||
.toArray(); // 返回数组
|
||
// 进一步处理群发消息任务
|
||
if (rest.sendSource === "MINE") {
|
||
const data = await getUserGroupmsgTask({
|
||
corpId,
|
||
accessToken,
|
||
corpGroupmsgList,
|
||
});
|
||
return {
|
||
success: true,
|
||
data,
|
||
total,
|
||
pages,
|
||
size: pageSize,
|
||
message: "获取群发任务成功",
|
||
};
|
||
} else {
|
||
const data = await getUserGroupmsgSendResult({
|
||
corpId,
|
||
accessToken,
|
||
corpGroupmsgList,
|
||
});
|
||
return {
|
||
success: true,
|
||
data,
|
||
total,
|
||
pages,
|
||
size: pageSize,
|
||
message: "获取群发任务成功",
|
||
};
|
||
}
|
||
} catch (error) {
|
||
logger.error("获取群发任务失败:", error);
|
||
return {
|
||
success: false,
|
||
message: error.message || "获取群发任务失败",
|
||
};
|
||
}
|
||
}
|
||
|
||
async function getUserGroupmsgSendResult(context) {
|
||
const { corpId, accessToken, corpGroupmsgList = [] } = context;
|
||
// 获取个人群发任务的 ID 列表
|
||
const createdTaskList = corpGroupmsgList.map((item) =>
|
||
getGroupmsgTaskByTeamId(item)
|
||
);
|
||
let msgIdList = [];
|
||
for (let i = 0; i < createdTaskList.length; i += 10) {
|
||
const promiseArr = createdTaskList.slice(i, i + 10);
|
||
let res = await Promise.all(promiseArr);
|
||
msgIdList.push(...res.flat());
|
||
}
|
||
// 获取每个任务的发送结果
|
||
const arr = msgIdList.map((item) => {
|
||
const { msgid, parentId } = item;
|
||
return weCom.main(
|
||
{
|
||
type: "getWecomGroupmsgtask",
|
||
corpId,
|
||
accessToken,
|
||
msgid,
|
||
parentId,
|
||
},
|
||
db
|
||
);
|
||
});
|
||
let sendResult = [];
|
||
// 批量执行发送结果请求，每次最多 10 个
|
||
for (let i = 0; i < arr.length; i += 10) {
|
||
const promiseArr = arr.slice(i, i + 10);
|
||
let res = await Promise.all(promiseArr);
|
||
sendResult.push(...res);
|
||
}
|
||
// 获取发送结果并处理任务
|
||
const taskCounts = await Promise.all(
|
||
corpGroupmsgList.map(async (item) => {
|
||
const taskCountResult = await db
|
||
.collection("groupmsg-task")
|
||
.countDocuments({ parentId: item._id });
|
||
return {
|
||
_id: item._id,
|
||
taskCount:
|
||
taskCountResult > 0
|
||
? taskCountResult
|
||
: item.userIds
|
||
? item.userIds.length
|
||
: 0,
|
||
};
|
||
})
|
||
);
|
||
const sendSuccessCounts = await Promise.all(
|
||
corpGroupmsgList.map(async (item) => {
|
||
const list = sendResult.filter((task) => task.parentId === item._id);
|
||
let task_list = [];
|
||
list.forEach((task) => {
|
||
task_list.push(...task.task_list);
|
||
});
|
||
return {
|
||
_id: item._id,
|
||
sendSuccessCount: task_list.filter((task) => task.status === 2).length,
|
||
};
|
||
})
|
||
);
|
||
corpGroupmsgList.forEach((item) => {
|
||
const taskCountObj = taskCounts.find((t) => t._id === item._id);
|
||
const sendSuccessCountObj = sendSuccessCounts.find(
|
||
(s) => s._id === item._id
|
||
);
|
||
item["taskCount"] = taskCountObj ? taskCountObj.taskCount : 0;
|
||
item["sendSuccessCount"] = sendSuccessCountObj
|
||
? sendSuccessCountObj.sendSuccessCount
|
||
: 0;
|
||
item["noSendCount"] = item["taskCount"] - item["sendSuccessCount"];
|
||
});
|
||
return corpGroupmsgList;
|
||
}
|
||
|
||
async function getGroupmsgTaskByTeamId(item) {
|
||
const fetchData = async (lastId = null, pageSize, db) => {
|
||
// 设置查询条件
|
||
let query = {
|
||
parentId: item._id,
|
||
corpId: item.corpId,
|
||
};
|
||
// 如果有 lastId，则通过 _id 分页
|
||
if (lastId) query["_id"] = { $gt: lastId }; // 只查询比 lastId 大的记录
|
||
// 使用聚合查询代替分页的 skip 和 limit
|
||
let result = await db
|
||
.collection("groupmsg-task")
|
||
.aggregate([
|
||
{ $match: query }, // 筛选符合条件的记录
|
||
{ $sort: { _id: 1 } }, // 按照 _id 排序（升序）
|
||
{ $limit: pageSize }, // 限制返回数量
|
||
])
|
||
.toArray(); // 转换为数组形式
|
||
|
||
return result;
|
||
};
|
||
|
||
// 获取所有数据，采用分页方式查询并合并数据
|
||
const allData = await utils.getAllData(fetchData, db);
|
||
return allData;
|
||
}
|
||
async function getUserGroupmsgTask({
|
||
corpId,
|
||
accessToken,
|
||
corpGroupmsgList,
|
||
customerList = "",
|
||
}) {
|
||
const arr = corpGroupmsgList
|
||
.filter((i) => i.msgid)
|
||
.map((item) => {
|
||
const { msgid, executor } = item;
|
||
return weCom.main({
|
||
type: "getWecomGroupmsgSendResult",
|
||
corpId,
|
||
accessToken,
|
||
msgid,
|
||
userid: executor,
|
||
});
|
||
});
|
||
// 使用 Promise.all 优化并行请求
|
||
let sendResult = await Promise.all(arr);
|
||
sendResult = sendResult.flat(); // 展开结果数组，避免嵌套
|
||
// 合并所有 customerList 或 corpGroupmsgList 中的 customers
|
||
const customerIds =
|
||
customerList || corpGroupmsgList.flatMap((item) => item.customers);
|
||
const fetchData = async (page, pageSize, db) => {
|
||
let query = {
|
||
_id: { $in: customerIds }, // 查询指定的 customerIds
|
||
externalUserId: {
|
||
$in: corpGroupmsgList.flatMap((item) => item.externalUserIds),
|
||
}, // 只查询符合 externalUserId 的记录
|
||
};
|
||
// 使用聚合管道来提高查询效率，避免使用 skip 和 limit
|
||
let result = await db
|
||
.collection("member")
|
||
.aggregate([
|
||
{ $match: query },
|
||
{ $sort: { _id: 1 } }, // 按照 _id 升序排序
|
||
{ $skip: (page - 1) * pageSize }, // 跳过指定数量的记录
|
||
{ $limit: pageSize }, // 限制返回的数量
|
||
])
|
||
.toArray();
|
||
return result;
|
||
};
|
||
const allCustomerData = await utils.getAllData(fetchData, db);
|
||
// 批量处理群发任务
|
||
for (const item of corpGroupmsgList) {
|
||
if (item.msgid) {
|
||
// 获取与当前消息相关的 send_list
|
||
let { send_list } = sendResult.find(
|
||
(task) => task.msgid === item.msgid
|
||
) || { send_list: [] };
|
||
|
||
// 过滤符合条件的客户数据
|
||
let customers = allCustomerData
|
||
.filter((customer) => item.customers.includes(customer._id))
|
||
.map((customer) => {
|
||
const { age, sex, name, externalUserId, _id } = customer;
|
||
let obj = send_list.find((i) => i.external_userid === externalUserId);
|
||
return {
|
||
age,
|
||
sex,
|
||
name,
|
||
externalUserId,
|
||
_id,
|
||
...obj,
|
||
};
|
||
});
|
||
// 统计各类状态的数量
|
||
item["unexecutedCount"] = customers.filter(
|
||
(customer) => customer.status === 0 || !customer.status
|
||
).length;
|
||
let sendSuccessList = customers.filter(
|
||
(customer) => customer.status === 1
|
||
);
|
||
if (sendSuccessList.length > 0) {
|
||
item["sendTime"] = sendSuccessList[0].send_time;
|
||
}
|
||
item["sendSuccessCount"] = sendSuccessList.length;
|
||
item["sendFileCount"] = customers.filter(
|
||
(customer) => customer.status === 2 || customer.status === 3
|
||
).length;
|
||
item["sendSuccessList"] = sendSuccessList;
|
||
item["sendFileList"] = customers.filter(
|
||
(customer) => customer.status === 2 || customer.status === 3
|
||
);
|
||
item["send_list"] = send_list;
|
||
item["customersCount"] = customers.length;
|
||
} else {
|
||
// 默认情况
|
||
item["customersCount"] = item.customers.length;
|
||
item["unexecutedCount"] = item.customers.length;
|
||
item["sendSuccessCount"] = 0;
|
||
item["sendFileCount"] = 0;
|
||
item["sendTime"] = "";
|
||
item["sendSuccessList"] = [];
|
||
item["sendFileList"] = [];
|
||
}
|
||
}
|
||
return corpGroupmsgList;
|
||
}
|
||
|
||
// 添加企业微信群发消息模板
|
||
async function addWecomMsgTemplate(context) {
|
||
let {
|
||
corpId,
|
||
accessToken,
|
||
templateId,
|
||
executedExternalUserIds = [],
|
||
} = context;
|
||
try {
|
||
const template = await db
|
||
.collection("groupmsg-task")
|
||
.findOne({ _id: templateId });
|
||
// 如果没有找到模板，返回错误
|
||
if (!template) {
|
||
return {
|
||
success: false,
|
||
message: "模板未找到",
|
||
executedExternalUserIds,
|
||
};
|
||
}
|
||
let { customers = [], content = "", attachments = [], executor } = template;
|
||
// 如果没有客户数据，直接返回
|
||
if (customers.length === 0) {
|
||
return {
|
||
success: false,
|
||
message: "客户列表为空",
|
||
executedExternalUserIds,
|
||
};
|
||
}
|
||
// 使用聚合查询批量获取客户数据，并分页处理
|
||
const fetchData = async (page, pageSize, db) => {
|
||
const result = await db
|
||
.collection("member")
|
||
.aggregate([
|
||
{ $match: { _id: { $in: customers } } }, // 过滤客户
|
||
{ $skip: (page - 1) * pageSize }, // 分页
|
||
{ $limit: pageSize }, // 分页
|
||
{ $project: { externalUserId: 1 } }, // 只返回 externalUserId 字段
|
||
])
|
||
.toArray();
|
||
return result;
|
||
};
|
||
// 获取所有客户数据
|
||
const list = await utils.getAllData(fetchData, db);
|
||
console.log("list", list);
|
||
// 提取外部用户ID，并去重
|
||
let externalUserIds = list
|
||
.map((item) => item.externalUserId)
|
||
.filter((item) => item);
|
||
console.log("externalUserIds", externalUserIds);
|
||
// 去重
|
||
externalUserIds = [...new Set(externalUserIds)];
|
||
|
||
// 去除已经发送过的客户
|
||
externalUserIds = externalUserIds.filter(
|
||
(item) => !executedExternalUserIds.includes(item)
|
||
);
|
||
|
||
// 更新已执行的用户ID列表
|
||
executedExternalUserIds = [...executedExternalUserIds, ...externalUserIds];
|
||
// 如果没有可发送的外部联系人，删除模板并返回
|
||
if (externalUserIds.length === 0) {
|
||
await db.collection("groupmsg-task").deleteOne({ _id: templateId });
|
||
return {
|
||
success: false,
|
||
message: "外部联系人为空",
|
||
executedExternalUserIds,
|
||
};
|
||
}
|
||
|
||
// 检查执行者是否为空
|
||
if (!executor) {
|
||
return {
|
||
success: false,
|
||
message: "发送人为空",
|
||
executedExternalUserIds,
|
||
};
|
||
}
|
||
|
||
// 处理附件，去除标题字段
|
||
attachments = attachments.map((item) => {
|
||
delete item.title;
|
||
return item;
|
||
});
|
||
// 调用发送消息模板的API
|
||
return await addWecomMsgTemplateApi({
|
||
corpId,
|
||
accessToken,
|
||
templateId,
|
||
executedExternalUserIds,
|
||
externalUserIds,
|
||
attachments,
|
||
content,
|
||
executor,
|
||
});
|
||
} catch (error) {
|
||
return {
|
||
success: false,
|
||
message: error.message || error,
|
||
};
|
||
}
|
||
}
|
||
|
||
async function addWecomMsgTemplateApi({
|
||
corpId,
|
||
accessToken,
|
||
templateId,
|
||
executedExternalUserIds = [],
|
||
externalUserIds = [],
|
||
attachments = [],
|
||
content = "",
|
||
executor = "",
|
||
}) {
|
||
let { errcode, fail_list, msgid } = await weCom.main(
|
||
{
|
||
type: "addWecomMsgTemplate",
|
||
corpid: corpId,
|
||
accessToken,
|
||
attachments,
|
||
content,
|
||
executor,
|
||
externalUserIds,
|
||
},
|
||
db
|
||
);
|
||
if (errcode === 0) {
|
||
await db.collection("groupmsg-task").updateOne(
|
||
{ _id: templateId }, // 查询条件：通过 ObjectId 查找指定的文档
|
||
{
|
||
$set: {
|
||
// 使用 $set 来设置更新的字段
|
||
msgid,
|
||
externalUserIds,
|
||
fail_list,
|
||
},
|
||
}
|
||
);
|
||
return {
|
||
success: true,
|
||
message: "创建群发任务成功",
|
||
executedExternalUserIds,
|
||
};
|
||
} else {
|
||
return {
|
||
success: false,
|
||
message: "创建群发任务失败",
|
||
executedExternalUserIds,
|
||
};
|
||
}
|
||
}
|
||
|
||
async function getTeamMemberExecuteState(context) {
|
||
const { corpId, accessToken, teamTaskId, customers } = context;
|
||
|
||
try {
|
||
// 校验必需字段
|
||
if (!teamTaskId || !corpId) {
|
||
return {
|
||
success: false,
|
||
data: [],
|
||
message: "缺少必要的参数",
|
||
};
|
||
}
|
||
// 使用 MongoDB 查询语法进行数据查询
|
||
let memberTaskList = await db
|
||
.collection("groupmsg-task")
|
||
.find({ parentId: teamTaskId })
|
||
.toArray();
|
||
// 处理每个任务并获取群发任务结果
|
||
const list = await getUserGroupmsgTask({
|
||
corpId,
|
||
accessToken,
|
||
corpGroupmsgList: memberTaskList,
|
||
customerList: customers,
|
||
});
|
||
return {
|
||
success: true,
|
||
data: list,
|
||
message: "获取成功",
|
||
};
|
||
} catch (error) {
|
||
logger.error(error); // 打印错误信息
|
||
return {
|
||
success: false,
|
||
data: [],
|
||
message: "获取失败",
|
||
};
|
||
}
|
||
}
|
||
|
||
async function getMemberCountBySendResult(context) {
|
||
const { list, customers } = context;
|
||
|
||
// 提取所有 externalUserId
|
||
let externalUserIds = list.map((item) => item.external_userid);
|
||
|
||
try {
|
||
// 使用 MongoDB 查询获取符合条件的记录数量
|
||
const count = await db.collection("member").countDocuments({
|
||
_id: { $in: customers }, // 使用 $in 操作符查找多个值
|
||
externalUserId: { $in: externalUserIds }, // 使用 $in 查找匹配的 externalUserIds
|
||
});
|
||
return count; // 返回符合条件的记录数
|
||
} catch (error) {
|
||
logger.error(error); // 输出错误信息，便于调试
|
||
return 0; // 出现错误时返回 0
|
||
}
|
||
}
|
||
async function getCusomterGroupmsgSendResult(context) {
|
||
const {
|
||
msgid,
|
||
corpId,
|
||
userid,
|
||
customers: customerIds,
|
||
accessToken,
|
||
} = context;
|
||
try {
|
||
// 获取群发消息发送结果
|
||
let { success, send_list } = await weCom.main(
|
||
{
|
||
type: "getWecomGroupmsgSendResult",
|
||
msgid,
|
||
userid,
|
||
corpId,
|
||
accessToken,
|
||
},
|
||
db
|
||
);
|
||
// 如果获取失败，直接返回失败信息
|
||
if (!success) {
|
||
return {
|
||
success: false,
|
||
message: "获取失败",
|
||
};
|
||
}
|
||
// 查询数据库获取客户信息
|
||
let res = await db
|
||
.collection("member")
|
||
.find({
|
||
_id: { $in: customerIds }, // 使用 $in 来查询多个客户
|
||
})
|
||
.toArray(); // 使用 toArray() 来获取完整的客户数据
|
||
// 处理查询结果并合并群发发送结果
|
||
let customers = res.map((item) => {
|
||
const { age, sex, name, externalUserId, _id } = item;
|
||
// 查找匹配的发送结果
|
||
let obj =
|
||
send_list && Array.isArray(send_list) && send_list.length > 0
|
||
? send_list.find((i) => i.external_userid === externalUserId)
|
||
: {};
|
||
// 返回合并后的客户信息
|
||
return {
|
||
age,
|
||
sex,
|
||
name,
|
||
externalUserId,
|
||
_id,
|
||
...obj,
|
||
};
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
message: "获取成功",
|
||
data: customers,
|
||
};
|
||
} catch (error) {
|
||
// 捕获错误并返回
|
||
logger.error("Error fetching customer group message result:", error);
|
||
return {
|
||
success: false,
|
||
message: "发生错误，无法获取数据。",
|
||
};
|
||
}
|
||
}
|
||
|
||
// 停止企业群发
|
||
async function stopWecomGroupmsgTask(content) {
|
||
let { corpId, accessToken, msgid, taskId } = content;
|
||
|
||
try {
|
||
let res = await weCom.main(
|
||
{
|
||
type: "stopWecomGroupmsgTask",
|
||
corpId,
|
||
accessToken,
|
||
msgid,
|
||
},
|
||
db
|
||
);
|
||
const { success } = res;
|
||
if (success) {
|
||
let result = await db
|
||
.collection("groupmsg-task")
|
||
.updateOne({ _id: taskId }, { $set: { executeStatus: "end" } });
|
||
if (result.modifiedCount === 1) {
|
||
return {
|
||
success: true,
|
||
message: "停止群发成功",
|
||
};
|
||
} else {
|
||
// 如果没有文档被更新，可能是任务ID错误或状态已更新
|
||
return {
|
||
success: false,
|
||
message: "任务更新失败，可能任务ID无效",
|
||
};
|
||
}
|
||
} else {
|
||
return res;
|
||
}
|
||
|
||
// 获取 access_token
|
||
} catch (error) {
|
||
// 捕获异常并返回
|
||
logger.error("Error stopping WeCom group message task:", error);
|
||
return {
|
||
success: false,
|
||
message: "请求失败，无法停止群发任务",
|
||
};
|
||
}
|
||
}
|
||
|
||
// 停止群发任务
|
||
async function stopGroupmsgTask(content) {
|
||
let { id, accessToken } = content;
|
||
try {
|
||
// 使用 MongoDB 的 updateOne 更新文档
|
||
await db.collection("groupmsg-task").updateOne(
|
||
{ _id: id }, // 查询条件
|
||
{ $set: { executeStatus: "end" } } // 更新操作
|
||
);
|
||
// 使用 MongoDB 的 find 查询子任务
|
||
let data = await db
|
||
.collection("groupmsg-task")
|
||
.find({
|
||
parentId: id,
|
||
executeStatus: { $ne: "end" }, // 查询 executeStatus 不等于 "end"
|
||
})
|
||
.toArray(); // 转换为数组
|
||
if (data.length > 0) {
|
||
for (const item of data) {
|
||
const { corpId, msgid, _id: taskId } = item;
|
||
// 停止子任务
|
||
await stopWecomGroupmsgTask({
|
||
corpId,
|
||
accessToken,
|
||
msgid,
|
||
taskId,
|
||
});
|
||
}
|
||
}
|
||
return {
|
||
success: true,
|
||
message: "停止群发任务成功",
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
success: false,
|
||
message: error.message || "发生错误",
|
||
};
|
||
}
|
||
}
|
||
|
||
async function getexternalMemberIdByUserId({
|
||
userId,
|
||
customers,
|
||
corpId,
|
||
accessToken,
|
||
}) {
|
||
// 获取外部联系人
|
||
let res = await weCom.main(
|
||
{
|
||
type: "getMyExternalcontact",
|
||
corpId,
|
||
accessToken,
|
||
userId: [userId],
|
||
},
|
||
db
|
||
);
|
||
// 获取外部联系人列表
|
||
let externalcontacts = res.data
|
||
? res.data.map((item) => item.external_userid)
|
||
: [];
|
||
// 获取所属客户
|
||
const fetchData = async (page, pageSize, db) => {
|
||
let data = await db
|
||
.collection("member")
|
||
.find({
|
||
_id: { $in: customers }, // 过滤客户ID
|
||
externalUserId: { $in: externalcontacts }, // 过滤外部联系人ID
|
||
})
|
||
.skip((page - 1) * pageSize) // 分页
|
||
.limit(pageSize) // 限制每次查询数量
|
||
.project({ _id: 1 }) // 只获取 _id 字段
|
||
.toArray(); // 转换为数组
|
||
return data;
|
||
};
|
||
const list = await utils.getAllData(fetchData, db);
|
||
// 返回所有符合条件的 _id
|
||
return list ? list.map((item) => item._id) : [];
|
||
}
|
||
|
||
async function createCurrentGroupMsgTask(event) {
|
||
const { corpId, accessToken } = event;
|
||
let page = 0;
|
||
let pageSize = 100;
|
||
let allData = [];
|
||
while (true) {
|
||
// 使用 MongoDB 查询语法
|
||
let data = await db
|
||
.collection("groupmsg-task")
|
||
.find({
|
||
executeStatus: "notStart",
|
||
startTaskDate: { $eq: dayjs(dayjs().format("YYYY-MM-DD")).valueOf() }, // 日期匹配
|
||
})
|
||
.skip((page - 1) * pageSize) // 分页
|
||
.limit(pageSize) // 限制每次获取的数量
|
||
.toArray(); // 获取数据并转换为数组
|
||
if (data.length > 0) {
|
||
allData.push(...data);
|
||
page++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
const handler = async (item) => {
|
||
// 创建群发任务
|
||
return await createGroupMsg({ ...item, corpId, accessToken });
|
||
};
|
||
|
||
// 批量处理任务
|
||
await utils.processInBatches(allData, handler, 10);
|
||
}
|
||
|
||
async function stopExpireGroupmsgTask(content) {
|
||
const { accessToken } = content;
|
||
const fetchData = async (page, pageSize, db) => {
|
||
let data = await db
|
||
.collection("groupmsg-task")
|
||
.find({
|
||
executeStatus: "doing",
|
||
endTaskDate: { $lte: dayjs(dayjs().format("YYYY-MM-DD")).valueOf() },
|
||
})
|
||
.skip((page - 1) * pageSize)
|
||
.limit(pageSize)
|
||
.toArray(); // 使用 toArray() 将查询结果转换为数组
|
||
return data;
|
||
};
|
||
|
||
// 获取所有数据
|
||
const allData = await utils.getAllData(fetchData, db);
|
||
|
||
const handler = async (item) => {
|
||
// 停止群发任务
|
||
await stopGroupmsgTask({ accessToken, ...item });
|
||
|
||
// 更新任务状态为结束
|
||
await db.collection("groupmsg-task").updateOne(
|
||
{ _id: item._id }, // 查询条件
|
||
{ $set: { executeStatus: "end" } } // 更新操作
|
||
);
|
||
return true;
|
||
};
|
||
|
||
// 批量处理数据
|
||
const res = await utils.processInBatches(allData, handler, 10);
|
||
logger.info(res);
|
||
}
|
||
|
||
async function createGroupMsg(context) {
|
||
const { _id, accessToken, ...rest } = context;
|
||
try {
|
||
// 第一步：调用 addWecomMsgTemplateForTeamOrCorp 方法处理消息模板（如果涉及外部系统交互）
|
||
await addWecomMsgTemplateForTeamOrCorp({
|
||
id: _id,
|
||
accessToken,
|
||
params: rest,
|
||
});
|
||
// 第二步：使用 MongoDB 更新操作更新任务的执行状态
|
||
const updateResult = await db.collection("groupmsg-task").updateOne(
|
||
{ _id }, // 使用 new ObjectId() 确保 _id 类型正确
|
||
{ $set: { executeStatus: "doing" } } // 使用 $set 更新 executeStatus 字段
|
||
);
|
||
// 如果没有找到对应的任务，则输出日志
|
||
if (updateResult.matchedCount === 0) {
|
||
logger.error(`未找到匹配的任务，_id: ${_id}`);
|
||
} else {
|
||
logger.info(`任务 _id: ${_id} 的状态已更新为 "doing"`);
|
||
}
|
||
} catch (error) {
|
||
// 捕获并处理可能的错误
|
||
logger.error("创建群消息过程中发生错误:", error);
|
||
}
|
||
}
|