weaver-work-cli 0.1.29 → 0.1.31

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

@@ -0,0 +1,450 @@
+import { meetingSuccess, schemaOf, SCHEMA_DATETIME_MINUTE } from '../types.js';
+import { meetingValidationError } from '../../errors.js';
+import { readCache, writeCache } from './cache.js';
+/**
+ * 参会人「日程空闲」检测（EB 版）。
+ *
+ * 与 `meeting.eb.conflict.member` 的区别（这是两件事，别混）：
+ * - `conflict.member`：查**会议表**，判断这个人在这段时间是不是已经有**其它会议**（回执表比对）；
+ * - `schedule.free`（本文件）：查**日程应用**，判断这个人在这段时间有没有**任何日程占用**（含外出、出差、任务等）。
+ *
+ * 数据来源：ESB 动作流（用户 2026-10-28 指定，primary_key=E37BF827FF2D47F6BD1DF928ABD25F69 /
+ * esbFlowId=1328057613897310208），入参 `customParams.mainTable = {startDate, endDate, memberIds, mtId?}`。
+ * 走 ESB 而不是直连 Java 接口，是为了和其他 ESB 能力保持同一条链路（权限/日志都在 ESB 侧）。
+ *
+ * ⛔ 必须过滤「会议日程」类型：会议冲突已由 `conflict.member` 判过，日程里再由会议生成的日程
+ * 重复计入会导致「同一场会议被报两次冲突」。会议日程的类型 id **每个环境都不同**
+ * （188 环境是 1147539996611665922），所以一律**动态解析**，绝不写死：
+ *   入参 excludeTypeIds → 环境变量 WEAVER_MEETING_SCHEDULE_TYPE_IDS
+ *   → 本地缓存 → 调日程类型字典（按 type_name=会议日程 / type_code=HYRC 匹配）
+ */
+/** 日程类型字典（日程应用 queryAgendaType）。 */
+const SCHEDULE_TYPE_PATH = '/api/ebuilder/form/formdata/v2/getFormDataList/queryAgendaType';
+/** 用户指定的日程冲突动作流（可在入参里覆盖，避免换环境后失效）。 */
+const DEFAULT_SCHEDULE_FLOW_ID = '1328057613897310208';
+const DEFAULT_SCHEDULE_UNIQUE_INDENT = 'E37BF827FF2D47F6BD1DF928ABD25F69';
+/** 会议日程类型在字典里的识别依据：名称优先，名称被改过时用内置 type_code 兜底。 */
+const DEFAULT_MEETING_TYPE_NAME = '会议日程';
+const MEETING_TYPE_CODE = 'HYRC';
+const TYPE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function splitIds(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((item) => item !== '');
+    }
+    return String(value)
+        .split(/[,;，；\s]+/)
+        .map((item) => item.trim())
+        .filter((item) => item !== '');
+}
+/** 读日程类型字典（一次性全量，用于动态定位「会议日程」类型 id）。 */
+async function fetchScheduleTypeOptions(env) {
+    const session = await env.host.getSession();
+    const response = await env.host.request({
+        method: 'POST',
+        path: SCHEDULE_TYPE_PATH,
+        operation: 'meeting.eb.schedule.free',
+        body: {
+            datajson: {
+                mainTable: {},
+                pageInfo: { pageNo: '1', pageSize: '100' },
+                header: { operator: session.userId },
+            },
+        },
+        acceptBusiness: (value) => {
+            if (!value || typeof value !== 'object')
+                return false;
+            if (typeof value.status === 'boolean')
+                return value.status;
+            return Number(value.code ?? 200) === 200;
+        },
+    });
+    const value = response;
+    const dj = value?.datajson ?? value?.data ?? {};
+    const raw = dj?.datas ?? dj?.data ?? (Array.isArray(dj) ? dj : []);
+    const rows = Array.isArray(raw) ? raw : [];
+    return rows
+        .map((row) => {
+        const main = row?.mainTable ?? row ?? {};
+        return {
+            id: String(main.id ?? '').trim(),
+            name: String(main.type_name ?? main.name ?? '').trim(),
+            code: String(main.type_code ?? '').trim().toUpperCase(),
+        };
+    })
+        .filter((item) => item.id !== '');
+}
+/** 解析「会议日程」类型 id（动态，不写死）。 */
+export async function resolveMeetingScheduleTypeIds(env, options = {}) {
+    const fromArgs = splitIds(options.excludeTypeIds);
+    if (fromArgs.length > 0) {
+        return { ids: fromArgs, names: [], source: 'args', warnings: [] };
+    }
+    const fromEnv = splitIds(process.env.WEAVER_MEETING_SCHEDULE_TYPE_IDS);
+    if (fromEnv.length > 0) {
+        return { ids: fromEnv, names: [], source: 'env', warnings: [] };
+    }
+    const cacheKey = `schedule-types-${await scopeSuffix(env)}`;
+    if (!options.refresh) {
+        const cached = await readCache(env, cacheKey, { ttlMs: TYPE_CACHE_TTL_MS });
+        if (cached?.data?.meetingTypeIds?.length) {
+            return { ids: cached.data.meetingTypeIds, names: cached.data.names ?? [], source: 'cache', warnings: [] };
+        }
+    }
+    const warnings = [];
+    try {
+        const typeName = (process.env.WEAVER_MEETING_SCHEDULE_TYPE_NAME || DEFAULT_MEETING_TYPE_NAME).trim();
+        const options2 = await fetchScheduleTypeOptions(env);
+        const matched = options2.filter((item) => item.name === typeName || item.code === MEETING_TYPE_CODE);
+        if (matched.length === 0) {
+            warnings.push(`日程类型字典里没找到「${typeName}」（也没有 type_code=${MEETING_TYPE_CODE} 的项）——`
+                + '本次不做会议日程过滤，冲突里可能包含会议生成的日程（会与会议冲突重复计）。'
+                + '可用入参 excludeTypeIds 或环境变量 WEAVER_MEETING_SCHEDULE_TYPE_IDS 显式指定。');
+            return { ids: [], names: [], source: 'none', warnings };
+        }
+        const ids = matched.map((item) => item.id);
+        const names = matched.map((item) => item.name);
+        await writeCache(env, cacheKey, { meetingTypeIds: ids, names });
+        return { ids, names, source: 'remote', warnings };
+    }
+    catch (error) {
+        warnings.push(`日程类型字典读取失败（${String(error?.message ?? error).slice(0, 80)}）：`
+            + '本次不做会议日程过滤，请人工判断是否属于重复计入。');
+        return { ids: [], names: [], source: 'none', warnings };
+    }
+}
+async function scopeSuffix(env) {
+    try {
+        const session = await env.host.getSession();
+        const host = String(session?.baseUrl ?? '').replace(/^https?:\/\//, '').replace(/[^0-9a-zA-Z]+/g, '-');
+        return `${host || 'local'}-${String(session?.tenantKey ?? 'unknown')}`;
+    }
+    catch {
+        return 'local-unknown';
+    }
+}
+/** 触发 ESB 日程冲突动作流，拿到原始返回（超时/失败不重试，交给调用方判定）。 */
+export async function runScheduleConflictFlow(env, input) {
+    const session = await env.host.getSession();
+    const employeeId = String(session?.userId ?? '').trim();
+    if (!employeeId) {
+        throw meetingValidationError('schedule_employee_required', '取不到当前登录用户 id，无法触发 ESB 日程查询');
+    }
+    const { createEsbHost } = await import('../../../esb/host.js');
+    const { createEsbContinuationSigner } = await import('../../../esb/continuation.js');
+    const { getEsbOperation } = await import('../../../esb/operations/registry.js');
+    const esbEnv = {
+        ctx: env.ctx,
+        host: createEsbHost(env.ctx),
+        continuation: createEsbContinuationSigner(env.ctx),
+    };
+    const mainTable = {
+        startDate: input.startDate,
+        endDate: input.endDate,
+        memberIds: input.memberIds.join(','),
+    };
+    if (input.mtId)
+        mainTable.mtId = input.mtId;
+    // 触发方式二选一：优先用 primary_key（用户 2026-10-28 指定的唯一值触发），
+    // 也支持显式传 flowId 走普通触发（同一动作流，换环境时更省事）。
+    const explicitFlowId = String(input.flowId ?? '').trim() || process.env.WEAVER_MEETING_SCHEDULE_FLOW_ID || '';
+    const uniqueIndent = String(input.uniqueIndent ?? '').trim()
+        || process.env.WEAVER_MEETING_SCHEDULE_FLOW_KEY
+        || DEFAULT_SCHEDULE_UNIQUE_INDENT;
+    const resolvedTarget = explicitFlowId
+        ? { esbFlowId: explicitFlowId }
+        : (uniqueIndent ? { uniqueIndent } : { esbFlowId: DEFAULT_SCHEDULE_FLOW_ID });
+    const prepareOp = getEsbOperation('esb.trigger.prepare');
+    const applyOp = getEsbOperation('esb.trigger.apply');
+    const pre = await prepareOp.handler({ employeeId, ...resolvedTarget, customParams: { mainTable } }, esbEnv);
+    const applied = await applyOp.handler({ continuation: pre?.data?.continuation, confirm: true }, esbEnv);
+    const actionData = applied?.data?.actionData ?? {};
+    const main = actionData?.responseData?.customData?.mainTable ?? {};
+    const rowsFrom = (value) => {
+        if (Array.isArray(value))
+            return value;
+        return [];
+    };
+    const rows = rowsFrom(main.memberWpConflictData)
+        .concat(rowsFrom(main.wpConflictData))
+        .concat(rowsFrom(main.conflictList))
+        .concat(rowsFrom(main.scheduleConflicts));
+    const count = Number(main.memberWpConflictNum ?? main.conflictNum ?? rows.length) || 0;
+    const message = String(main.memberWpConflictMsg ?? main.conflictMsg ?? '');
+    return {
+        rows,
+        count,
+        message,
+        raw: applied?.data ?? applied,
+        target: {
+            mode: explicitFlowId ? 'esbFlowId' : 'uniqueIndent',
+            value: explicitFlowId || uniqueIndent,
+        },
+    };
+}
+function normalizeTypeId(value) {
+    if (value === undefined || value === null)
+        return { id: '', name: '' };
+    if (Array.isArray(value)) {
+        const first = value[0];
+        if (first && typeof first === 'object') {
+            return { id: String(first.id ?? '').trim(), name: String(first.name ?? '').trim() };
+        }
+        return { id: String(first ?? '').trim(), name: '' };
+    }
+    if (typeof value === 'object') {
+        const item = value;
+        return { id: String(item.id ?? '').trim(), name: String(item.name ?? '').trim() };
+    }
+    return { id: String(value).trim(), name: '' };
+}
+function normalizeMembers(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (item && typeof item === 'object' ? String(item.id ?? '') : String(item ?? '')))
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+    }
+    return splitIds(value);
+}
+function normalizeRows(rows) {
+    return rows.map((row) => {
+        const main = row?.mainTable ?? row ?? {};
+        const type = normalizeTypeId(main.agn_type);
+        return {
+            scheduleId: String(main.id ?? '').trim(),
+            title: String(main.agn_name ?? main.name ?? '').trim(),
+            startTime: String(main.start_time ?? '').trim(),
+            endTime: String(main.end_time ?? '').trim(),
+            typeId: type.id,
+            typeName: type.name,
+            members: normalizeMembers(main.participants),
+            meetingSchedule: false,
+        };
+    });
+}
+/** 把 ESB 原始返回 + 类型过滤结果整理成「哪些人空闲、哪些人忙」。 */
+export function buildScheduleFreeResult(flow, typeIds, options) {
+    const normalized = normalizeRows(flow.rows);
+    const wanted = new Set(options.memberIds);
+    const excluded = new Set(typeIds);
+    let meetingSchedule = 0;
+    const kept = [];
+    for (const item of normalized) {
+        const isMeetingType = item.typeId !== '' && excluded.has(item.typeId);
+        if (isMeetingType)
+            meetingSchedule += 1;
+        if (isMeetingType) {
+            kept.push({ ...item, meetingSchedule: true });
+            continue;
+        }
+        kept.push(item);
+    }
+    const busyMap = new Map();
+    for (const item of kept) {
+        if (item.meetingSchedule)
+            continue;
+        for (const memberId of item.members) {
+            if (wanted.size > 0 && !wanted.has(memberId))
+                continue;
+            const list = busyMap.get(memberId) ?? [];
+            list.push({
+                scheduleId: item.scheduleId,
+                title: item.title,
+                startTime: item.startTime,
+                endTime: item.endTime,
+                typeId: item.typeId,
+                typeName: item.typeName,
+            });
+            busyMap.set(memberId, list);
+        }
+    }
+    const busyMembers = [...busyMap.entries()].map(([memberId, items]) => ({ memberId, items }));
+    const busySet = new Set(busyMembers.map((item) => item.memberId));
+    const freeMembers = options.memberIds.filter((memberId) => !busySet.has(memberId));
+    const detailAvailable = normalized.length > 0 || flow.count === 0;
+    const verdict = normalized.length === 0 && flow.count === 0
+        ? 'free'
+        : busyMembers.length > 0
+            ? 'busy'
+            : 'unknown';
+    return {
+        verdict,
+        counts: {
+            requested: options.memberIds.length,
+            free: freeMembers.length,
+            busy: busyMembers.length,
+        },
+        freeMembers,
+        busyMembers,
+        filtered: { total: normalized.length, meetingSchedule },
+        meetingScheduleTypes: { ids: typeIds, names: [], source: '' },
+        message: flow.message,
+        detailAvailable,
+        target: flow.target,
+        ...(options.includeRaw ? { raw: flow.raw } : {}),
+    };
+}
+const ebScheduleFree = {
+    name: 'meeting.eb.schedule.free',
+    resource: 'eb',
+    method: 'meeting.eb.schedule.free',
+    action: 'meeting.eb.schedule.free',
+    summary: '参会人日程空闲检测（ESB 动作流查日程应用，非会议表）：判断人在目标时段有没有其它日程占用；自动过滤「会议日程」类型（类型 id 动态解析，不写死）',
+    capability: 'eb.schedule',
+    risk: 'read',
+    inputSchema: schemaOf({
+        startDate: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+        endDate: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+        memberIds: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '参会人 id 数组（必填；HRM 员工 id，与回执 member_id 同口径）',
+        },
+        mtId: { type: 'string', description: '变更会议时排除该会议自身生成的日程' },
+        excludeTypeIds: {
+            type: 'string',
+            description: '显式指定要过滤的日程类型 id（逗号分隔）。不传时按日程类型字典动态解析「会议日程」',
+        },
+        refreshTypes: { type: 'boolean', description: 'true=强制重新拉取日程类型字典（默认命中 7 天缓存）' },
+        flowId: { type: 'string', description: '覆盖 ESB 动作流 id（租户不同时用）' },
+        uniqueIndent: { type: 'string', description: '覆盖 ESB 动作流 primary_key（默认用内置值，换环境时传）' },
+        includeRaw: { type: 'boolean', description: 'true=附带 ESB 原始返回，便于排查口径问题' },
+    }, { required: ['startDate', 'endDate', 'memberIds'] }),
+    handler: async (args, env) => {
+        const startDate = String(args.startDate ?? '').trim();
+        const endDate = String(args.endDate ?? '').trim();
+        const memberIds = splitIds(args.memberIds);
+        if (memberIds.length === 0) {
+            throw meetingValidationError('schedule_member_required', 'memberIds 不能为空（参会人 id 数组）');
+        }
+        const typeResolution = await resolveMeetingScheduleTypeIds(env, {
+            excludeTypeIds: args.excludeTypeIds,
+            refresh: args.refreshTypes === true,
+        });
+        const flow = await runScheduleConflictFlow(env, {
+            startDate,
+            endDate,
+            memberIds,
+            ...(args.mtId ? { mtId: String(args.mtId) } : {}),
+            ...(args.flowId ? { flowId: String(args.flowId) } : {}),
+            ...(args.uniqueIndent ? { uniqueIndent: String(args.uniqueIndent) } : {}),
+        });
+        const result = buildScheduleFreeResult(flow, typeResolution.ids, {
+            memberIds,
+            includeRaw: args.includeRaw === true,
+        });
+        result.meetingScheduleTypes.names = typeResolution.names;
+        result.meetingScheduleTypes.source = typeResolution.source;
+        // 动作流只给「数量 + 一段提示语」时，从提示语里把「时间/日程名/涉及人」捞出来，
+        // 否则调用方只能看到 unknown（用户也看不明白到底撞了哪条日程）。
+        await applyMessageDetails(env, result, flow, memberIds);
+        const warnings = [...typeResolution.warnings];
+        if (!result.detailAvailable) {
+            warnings.push(`ESB 只返回了冲突数量（${flow.count}）与提示语「${flow.message || '空'}」，没有逐条日程明细——`
+                + '无法判断是哪几条日程占用；如需明细请让 ESB 动作流输出 scheduleConflicts 列表。');
+        }
+        return meetingSuccess('meeting.eb.schedule.free', result, warnings.length > 0 ? { warnings } : {});
+    },
+};
+export const meetingEbScheduleOperations = [ebScheduleFree];
+export function parseScheduleConflictMessage(message) {
+    const text = String(message ?? '');
+    if (!text.trim())
+        return [];
+    const pattern = /(\d{1,2}:\d{2})\s*[~～-]\s*(\d{1,2}:\d{2})[^《]*《([^》]*)》[^【]*【([^】]*)】/g;
+    const items = [];
+    for (const match of text.matchAll(pattern)) {
+        const memberNames = match[4]
+            .split(/[、,，;；\s]+/)
+            .map((name) => name.trim())
+            .filter((name) => name !== '');
+        items.push({
+            startTime: match[1],
+            endTime: match[2],
+            title: match[3].trim(),
+            memberNames,
+        });
+    }
+    return items;
+}
+/** 姓名 → 员工 id（逐个 keyword 查，人数通常在 10 以内；查不到保持原名，不猜）。 */
+export async function resolveMemberIdsByName(env, names) {
+    const map = new Map();
+    const unique = [...new Set(names)].filter((name) => name !== '');
+    if (unique.length === 0)
+        return map;
+    try {
+        const { hrmEmployeeOperations } = await import('../../../hrm/operations/employee.js');
+        const query = hrmEmployeeOperations.find((operation) => operation.name === 'hrm.employee.query');
+        if (!query)
+            return map;
+        for (const name of unique) {
+            try {
+                const result = await query.handler({ keyword: name, pageSize: 5 }, env);
+                const rows = (result?.data?.rows ?? []);
+                const hit = rows.find((row) => String(row.name ?? '').trim() === name) ?? rows[0];
+                const id = String(hit?.id ?? '').trim();
+                if (id)
+                    map.set(name, id);
+            }
+            catch {
+                // 单个查询失败不影响其它人
+            }
+        }
+    }
+    catch {
+        // hrm 模块不可用：保持原名
+    }
+    return map;
+}
+/** 把提示语解析结果并入结果集（仅在没有结构化明细时调用）。 */
+export async function applyMessageDetails(env, result, flow, requestedMemberIds) {
+    if (result.detailAvailable)
+        return false;
+    const parsed = parseScheduleConflictMessage(flow.message);
+    if (parsed.length === 0)
+        return false;
+    const idsByName = await resolveMemberIdsByName(env, parsed.flatMap((item) => item.memberNames));
+    const wanted = new Set(requestedMemberIds);
+    const busy = new Map();
+    const unresolved = [];
+    for (const item of parsed) {
+        for (const name of item.memberNames) {
+            const id = idsByName.get(name) ?? '';
+            const key = id || `name:${name}`;
+            if (id && wanted.size > 0 && !wanted.has(id))
+                continue;
+            const entry = busy.get(key) ?? { memberId: id || name, items: [] };
+            entry.items.push({
+                scheduleId: '',
+                title: item.title,
+                startTime: item.startTime,
+                endTime: item.endTime,
+                typeId: '',
+                typeName: '',
+            });
+            busy.set(key, entry);
+            if (!id)
+                unresolved.push(name);
+        }
+    }
+    if (busy.size === 0)
+        return false;
+    result.busyMembers = [...busy.values()];
+    const busyIds = new Set(result.busyMembers.map((item) => item.memberId));
+    result.freeMembers = requestedMemberIds.filter((id) => !busyIds.has(id));
+    result.counts = {
+        requested: requestedMemberIds.length,
+        free: result.freeMembers.length,
+        busy: result.busyMembers.length,
+    };
+    result.verdict = 'busy';
+    result.detailAvailable = true;
+    result.parsedFrom = 'message';
+    if (unresolved.length > 0) {
+        result.unresolvedNames = [...new Set(unresolved)];
+    }
+    return true;
+}