weaver-work-cli 0.1.8 → 0.1.21

package/dist/shortcuts/meeting/operations/eb/conflict.js

@@ -0,0 +1,389 @@
+import { meetingConflictError } from '../../errors.js';
+import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from '../types.js';
+import { assertDateTimeMinute, toIdCsv } from '../shared.js';
+import { EB_BASE, ebBusinessSuccess, extractEbRows, queryBody } from './factory.js';
+/**
+ * 会议 EB 版冲突检测（eBuilder formdata）。
+ *
+ * 为什么存在（2026-09-20）：EB 版建会此前**没有任何冲突检测** —— factory 的 prepare 只做字段
+ * 白名单 + 必填校验，于是重复占用同一间会议室、参会人在同一时段撞会都不会被拦住。
+ * 本文件补齐该项能力，并直接采用参考资料定型后的「2 次请求」方案（**无 N+1**）：
+ *
+ *   会议室：query_meeting_baseset（策略）→ query_roomusage_list（该会议室时段内占用，1 次）
+ *   参会人：query_meeting_baseset（策略）→ query_mtDetail_list（候选会议，1 次）
+ *           → query_meeting_receipt_list?mt_id=<多值批量>（1~k 次：分批 + 分页）→ 本地比对（0 请求）
+ *
+ * 口径与参考资料一致，不可随意改：
+ * - 参会人以**回执表 member_id** 为准（会议表 hrm_members 是渲染文本，不可靠）；
+ * - 只统计 `member_type=1`（参会人员）；参会客户(2)/其他人员(3) 不算冲突；
+ * - 候选会议只取 `mt_status ∈ {1审批中,2未开始,8已结束,9进行中}`；
+ *   占用视图与回执只对有效状态生成，故无需再额外过滤；
+ * - 命中后**严格按应用设置**处理，CLI 不额外加码：
+ *   - `1` = **禁止提交** → 抛 `conflict_rejected`，怎么都不允许提交（不询问、不新建）；
+ *   - `0` = **仅提醒** → 只写入 warnings（如实告知冲突、建议换时间/换地点），
+ *     **不阻止提交**：用户了解冲突后仍要求新建时，可继续 prepare → apply 完成建会。
+ *
+ * 失败语义与标准版（create.ts 的 runMandatoryConflictChecks）对齐：
+ * - 应用设置读取失败：非致命，按「开启检测 + 仅提醒」继续，并在 warnings 中如实说明；
+ * - 检测请求本身失败：视为冲突 → 拒绝建会（`conflict_check_failed`），宁可拦住不可漏检。
+ */
+/** 候选会议的有效状态：1审批中 / 2未开始 / 8已结束 / 9进行中。 */
+const ACTIVE_MT_STATUS = '1,2,8,9';
+/** 列表单页条数（EB 侧 pageSize 上限 200，尽量少翻页）。 */
+const PAGE_SIZE = 200;
+/** 回执批量查询每批携带的会议 id 数（避免 URL 过长）。 */
+const MT_ID_BATCH = 50;
+/** 防御性上限：单个列表最多翻页数（200 × 50 = 1 万条）。 */
+const MAX_PAGES = 50;
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** 单页 EB 列表查询（list，不计数；筛选走 URL query，body 带 datajson）。 */
+async function requestEbList(env, interfacePk, query, operation) {
+    const session = await env.host.getSession();
+    const response = await env.host.request({
+        method: 'POST',
+        path: `${EB_BASE}/getFormDataList/${interfacePk}`,
+        operation,
+        query,
+        body: queryBody(session.userId),
+        acceptBusiness: ebBusinessSuccess,
+    });
+    // 行数据可能是 { mainTable: {...} } 包裹，统一摊平（与 member-conflict.mjs 同口径）。
+    return extractEbRows(response).rows.map((row) => (row?.mainTable ? row.mainTable : row));
+}
+/** 分页拉全一个 EB 列表（返回累计请求数，便于在结果里如实报告开销）。 */
+async function listAllEbRows(env, interfacePk, baseQuery, operation) {
+    const rows = [];
+    let requests = 0;
+    for (let pageNo = 1; pageNo <= MAX_PAGES; pageNo += 1) {
+        const page = await requestEbList(env, interfacePk, { ...baseQuery, pageNo, pageSize: PAGE_SIZE }, operation);
+        requests += 1;
+        rows.push(...page);
+        if (page.length < PAGE_SIZE)
+            break; // 末页
+    }
+    return { rows, requests };
+}
+/** 读取应用设置（query_meeting_baseset，返回 1 条，多条取第一条）中的冲突策略。 */
+export async function fetchEbConflictPolicy(env, operation) {
+    try {
+        const rows = await requestEbList(env, 'query_meeting_baseset', { pageNo: 1, pageSize: 5 }, operation);
+        const base = rows[0] ?? {};
+        return {
+            roomChk: String(base.room_conflict_chk ?? ''),
+            roomAction: String(base.room_conflict ?? ''),
+            memberChk: String(base.member_conflict_chk ?? ''),
+            memberAction: String(base.member_conflict ?? ''),
+        };
+    }
+    catch (error) {
+        return {
+            roomChk: '',
+            roomAction: '',
+            memberChk: '',
+            memberAction: '',
+            error: errorText(error),
+        };
+    }
+}
+/** 会议室冲突：查占用视图（query_roomusage_list），时间重叠即冲突。 */
+async function checkRoomConflict(roomId, begin, end, excludeMtId, env, operation) {
+    const { rows, requests } = await listAllEbRows(env, 'query_roomusage_list', 
+    // 重叠判定：占用开始 < 我的结束（enddatetime 算子 lt）且 占用结束 > 我的开始（begindatetime 算子 gt）
+    { address: roomId, enddatetime: end, begindatetime: begin }, operation);
+    const conflicts = rows
+        .map((row) => ({
+        mtId: String(row.mt_id ?? ''),
+        begin: String(row.startdate ?? ''),
+        end: String(row.enddate ?? ''),
+    }))
+        .filter((item) => item.mtId && item.mtId !== excludeMtId);
+    return { conflicts, requests };
+}
+/**
+ * 参会人冲突：候选会议（时间范围 + 有效状态）→ 回执按 mt_id **多值批量**拉取 → 本地求交集。
+ * 共 2~k 次请求（候选 1 次 + 回执 1~k 次），**不逐场会议查回执**（旧做法＝N+1）。
+ */
+async function collectMemberConflicts(members, begin, end, excludeMtId, env, operation) {
+    const wanted = new Set(members);
+    // 占位符语义（见 catalog 的 queryParams 注释）：
+    //   `enddatetime` ↔ 会议「开始时间」，算子 lt → 传「我的结束时间」
+    //   `begindatetime` ↔ 会议「结束时间」，算子 gt → 传「我的开始时间」
+    // 两者传反会变成「整段包含」关系（会议完全包住我的时段），造成大量漏检。
+    const candidate = await listAllEbRows(env, 'query_mtDetail_list', { begindatetime: begin, enddatetime: end, mt_status: ACTIVE_MT_STATUS }, operation);
+    const candidates = candidate.rows
+        .map((row) => ({
+        id: String(row.id ?? ''),
+        name: String(row.mt_name ?? row.name ?? ''),
+        begin: String(row.begin_datetime ?? ''),
+        end: String(row.end_datetime ?? ''),
+    }))
+        .filter((item) => item.id && item.id !== excludeMtId);
+    const byId = new Map(candidates.map((item) => [item.id, item]));
+    const byMeeting = new Map();
+    let receiptCalls = 0;
+    let receipts = 0;
+    for (let index = 0; index < candidates.length; index += MT_ID_BATCH) {
+        const csv = candidates.slice(index, index + MT_ID_BATCH).map((item) => item.id).join(',');
+        const page = await listAllEbRows(env, 'query_meeting_receipt_list', { mt_id: csv }, operation);
+        receiptCalls += page.requests;
+        receipts += page.rows.length;
+        for (const row of page.rows) {
+            const meetingId = String(row.mt_id ?? '');
+            const memberId = String(row.member_id ?? '');
+            const memberType = String(row.member_type ?? '');
+            if (!meetingId || !memberId)
+                continue;
+            if (memberType && memberType !== '1')
+                continue; // 仅“参会人员”
+            if (!wanted.has(memberId))
+                continue; // 只关心本次参会人
+            if (!byMeeting.has(meetingId))
+                byMeeting.set(meetingId, new Set());
+            byMeeting.get(meetingId).add(memberId);
+        }
+    }
+    const conflicts = [...byMeeting.entries()].map(([meetingId, ids]) => {
+        const meeting = byId.get(meetingId);
+        return {
+            meetingId,
+            name: meeting?.name ?? '',
+            begin: meeting?.begin ?? '',
+            end: meeting?.end ?? '',
+            conflictedMembers: [...ids],
+        };
+    });
+    conflicts.sort((left, right) => left.begin.localeCompare(right.begin));
+    return {
+        conflicts,
+        listCalls: candidate.requests,
+        receiptCalls,
+        candidates: candidates.length,
+        receipts,
+    };
+}
+/**
+ * EB 版冲突检测主流程（建会/变更 prepare 阶段调用）。
+ *
+ * 命中「禁止提交」直接抛 `conflict_rejected`；命中「仅提醒」写入 warnings；
+ * 检测请求失败抛 `conflict_check_failed`（与标准版一致：宁可拦住不可漏检）。
+ * `throwOnReject=false` 时改为把禁止项写入 warnings（供只查不建的 operation 使用）。
+ */
+export async function runEbConflictCheck(input, env, operation, options = {}) {
+    const throwOnReject = options.throwOnReject !== false;
+    const begin = assertDateTimeMinute(input.beginDatetime, 'begin_datetime');
+    const end = assertDateTimeMinute(input.endDatetime, 'end_datetime');
+    const warnings = [];
+    const policy = await fetchEbConflictPolicy(env, operation);
+    const outcome = { warnings, policy };
+    if (policy.error) {
+        warnings.push(`应用设置（query_meeting_baseset）读取失败，冲突策略按「开启检测 + 仅提醒」处理：${policy.error}`);
+    }
+    /**
+     * 命中冲突的处置（**fail-fast**）：
+     * - 禁止提交 → **立即抛错并结束**，**不再继续后续检测** —— 结论已定局为拒绝，
+     *   继续检测只会多花请求，也不会改变结果；
+     * - 仅提醒 → 记入 warnings，**不阻止提交**（用户了解冲突后坚持新建即可继续）。
+     * `throwOnReject=false`（只查不建的 operation）时，禁止项改为写入 warnings 而不抛错。
+     */
+    const handleHit = (action, message, details) => {
+        if (action === '1') {
+            const text = `${message}；应用设置禁止提交（action=1），已拒绝，请更换时间或地点后重试`;
+            if (throwOnReject)
+                throw meetingConflictError('conflict_rejected', text, details);
+            warnings.push(text);
+            return;
+        }
+        warnings.push(`${message}；应用设置仅提醒（action=0）：请先把冲突如实告知用户，并建议更换时间或地点；`
+            + '若用户了解冲突后仍要求新建，可以继续提交完成建会（仅提醒不阻止提交）');
+    };
+    // ---- 1) 会议室冲突 ----
+    if (input.address) {
+        if (policy.roomChk === '0') {
+            outcome.room = { skipped: true, hasConflict: false, conflicts: [], requests: 0 };
+            warnings.push('应用设置 room_conflict_chk=0（关闭），已跳过会议室冲突检测');
+        }
+        else {
+            let result;
+            try {
+                result = await checkRoomConflict(input.address, begin, end, input.excludeMtId, env, operation);
+            }
+            catch (error) {
+                throw meetingConflictError('conflict_check_failed', `会议室冲突检测失败（视为冲突，拒绝建会）：${errorText(error)}`);
+            }
+            const hasConflict = result.conflicts.length > 0;
+            outcome.room = { skipped: false, hasConflict, conflicts: result.conflicts, requests: result.requests };
+            if (hasConflict) {
+                const detail = result.conflicts
+                    .map((item) => `${item.mtId}${item.begin ? `(${item.begin}~${item.end})` : ''}`)
+                    .join('、');
+                handleHit(policy.roomAction, `会议室冲突：会议室 ${input.address} 在 ${begin} ~ ${end} 已被占用（占用会议 ${detail}）`, { address: input.address, conflicts: result.conflicts, policy: policy.roomAction });
+            }
+        }
+    }
+    // ---- 2) 参会人员冲突 ----
+    const members = toIdCsv(input.hrmMembers, 'hrm_members');
+    if (policy.memberChk === '0') {
+        outcome.member = {
+            skipped: true, hasConflict: false, conflicts: [], listCalls: 0, receiptCalls: 0, candidates: 0, receipts: 0,
+        };
+        warnings.push('应用设置 member_conflict_chk=0（关闭），已跳过参会人员冲突检测');
+    }
+    else if (members) {
+        let result;
+        try {
+            result = await collectMemberConflicts(members.split(','), begin, end, input.excludeMtId, env, operation);
+        }
+        catch (error) {
+            throw meetingConflictError('conflict_check_failed', `参会人员冲突检测失败（视为冲突，拒绝建会）：${errorText(error)}`);
+        }
+        const hasConflict = result.conflicts.length > 0;
+        outcome.member = {
+            skipped: false,
+            hasConflict,
+            conflicts: result.conflicts,
+            listCalls: result.listCalls,
+            receiptCalls: result.receiptCalls,
+            candidates: result.candidates,
+            receipts: result.receipts,
+        };
+        if (hasConflict) {
+            const detail = result.conflicts
+                .map((item) => `${item.name || item.meetingId}(${item.begin}~${item.end}) 冲突人 ${item.conflictedMembers.join(',')}`)
+                .join('；');
+            handleHit(policy.memberAction, `参会人员冲突：${result.conflicts.length} 场会议与本次参会人时间重叠 —— ${detail}`, { conflicts: result.conflicts, policy: policy.memberAction });
+        }
+        if (input.orgMembers) {
+            warnings.push('org_members（参会部门）未展开为员工名单，本次人员冲突检测仅覆盖 hrm_members 显式指定的人员');
+        }
+    }
+    else if (input.orgMembers) {
+        warnings.push('仅提供 org_members（参会部门）而未提供 hrm_members：CLI 不展开部门成员，已跳过参会人员冲突检测');
+    }
+    return outcome;
+}
+/**
+ * 建会/变更 prepare 的前置钩子：EB 版补上强制冲突检测。
+ * 仅在拿到起止时间、且传了 address / hrm_members 时才发请求（无目标即无冲突可言）。
+ */
+export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env }) => {
+    if (endpoint.interfacePk !== 'create_meeting' && endpoint.interfacePk !== 'change_meeting')
+        return [];
+    const begin = payload.begin_datetime;
+    const end = payload.end_datetime;
+    if (typeof begin !== 'string' || typeof end !== 'string' || !begin || !end)
+        return [];
+    const address = typeof payload.address === 'string' && payload.address ? payload.address : undefined;
+    const hrmMembers = typeof payload.hrm_members === 'string' && payload.hrm_members ? payload.hrm_members : undefined;
+    if (!address && !hrmMembers)
+        return [];
+    const outcome = await runEbConflictCheck({
+        beginDatetime: begin,
+        endDatetime: end,
+        ...(address ? { address } : {}),
+        ...(hrmMembers ? { hrmMembers } : {}),
+        ...(typeof payload.org_members === 'string' && payload.org_members ? { orgMembers: payload.org_members } : {}),
+        ...(typeof args.id === 'string' || typeof args.id === 'number' ? { excludeMtId: String(args.id) } : {}),
+    }, env, endpoint.operation === 'meeting.eb.meeting.change' ? 'meeting.eb.meeting.change.prepare' : 'meeting.eb.meeting.create.prepare');
+    return outcome.warnings;
+};
+/** 只查不建：会议室冲突检测 operation。 */
+const ebConflictRoom = {
+    name: 'meeting.eb.conflict.room',
+    resource: 'eb',
+    method: 'meeting.eb.conflict.room',
+    action: 'meeting.eb.conflict.room',
+    summary: 'EB 版会议室冲突检测（query_roomusage_list 查该会议室时段内占用）：按应用设置 room_conflict_chk/room_conflict 给出 verdict',
+    capability: 'eb.conflict',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+            endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+            address: { ...SCHEMA_ID, description: '会议室 id（必填）' },
+            mtId: { ...SCHEMA_ID, description: '变更会议时排除自身' },
+        },
+        required: ['beginDatetime', 'endDatetime', 'address'],
+    },
+    handler: async (args, env) => {
+        const outcome = await runEbConflictCheck({
+            beginDatetime: args.beginDatetime,
+            endDatetime: args.endDatetime,
+            address: String(args.address),
+            ...(args.mtId !== undefined ? { excludeMtId: String(args.mtId) } : {}),
+        }, env, 'meeting.eb.conflict.room', { throwOnReject: false });
+        const room = outcome.room ?? { skipped: true, hasConflict: false, conflicts: [], requests: 0 };
+        const verdict = room.skipped
+            ? 'skipped'
+            : !room.hasConflict
+                ? 'ok'
+                : outcome.policy.roomAction === '1'
+                    ? 'rejected'
+                    : 'warn';
+        return meetingSuccess('meeting.eb.conflict.room', {
+            verdict,
+            hasConflict: room.hasConflict,
+            skipped: room.skipped,
+            conflicts: room.conflicts,
+            policy: { chk: outcome.policy.roomChk, action: outcome.policy.roomAction },
+            requests: 1 + room.requests,
+        }, outcome.warnings.length > 0 ? { warnings: outcome.warnings } : {});
+    },
+};
+/** 只查不建：参会人员冲突检测 operation（2 次请求方案，无 N+1）。 */
+const ebConflictMember = {
+    name: 'meeting.eb.conflict.member',
+    resource: 'eb',
+    method: 'meeting.eb.conflict.member',
+    action: 'meeting.eb.conflict.member',
+    summary: 'EB 版参会人员冲突检测（query_mtDetail_list 候选 → query_meeting_receipt_list?mt_id=多值批量 → 本地比对；2 次请求，无 N+1）：按 member_conflict_chk/member_conflict 给出 verdict',
+    capability: 'eb.conflict',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+            endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+            hrmMembers: { type: 'string', description: '参会人员 id，逗号分隔字符串（必填）' },
+            mtId: { ...SCHEMA_ID, description: '变更会议时排除自身' },
+        },
+        required: ['beginDatetime', 'endDatetime', 'hrmMembers'],
+    },
+    handler: async (args, env) => {
+        const outcome = await runEbConflictCheck({
+            beginDatetime: args.beginDatetime,
+            endDatetime: args.endDatetime,
+            hrmMembers: String(args.hrmMembers),
+            ...(args.mtId !== undefined ? { excludeMtId: String(args.mtId) } : {}),
+        }, env, 'meeting.eb.conflict.member', { throwOnReject: false });
+        const member = outcome.member ?? {
+            skipped: true, hasConflict: false, conflicts: [], listCalls: 0, receiptCalls: 0, candidates: 0, receipts: 0,
+        };
+        const verdict = member.skipped
+            ? 'skipped'
+            : !member.hasConflict
+                ? 'ok'
+                : outcome.policy.memberAction === '1'
+                    ? 'rejected'
+                    : 'warn';
+        return meetingSuccess('meeting.eb.conflict.member', {
+            verdict,
+            hasConflict: member.hasConflict,
+            skipped: member.skipped,
+            conflicts: member.conflicts,
+            policy: { chk: outcome.policy.memberChk, action: outcome.policy.memberAction },
+            cost: {
+                baseSetCalls: 1,
+                listCalls: member.listCalls,
+                receiptCalls: member.receiptCalls,
+                candidates: member.candidates,
+                receipts: member.receipts,
+            },
+        }, outcome.warnings.length > 0 ? { warnings: outcome.warnings } : {});
+    },
+};
+export const meetingEbConflictOperations = [ebConflictRoom, ebConflictMember];