weaver-work-cli 0.1.29 → 0.1.32

package/dist/shortcuts/meeting/operations/eb/room-recommend.js

@@ -0,0 +1,378 @@
+import { meetingSuccess, schemaOf, SCHEMA_DATETIME_MINUTE } from '../types.js';
+import { EB_BASE, ebBusinessSuccess, extractEbRows, queryBody } from './factory.js';
+import { readCache, writeCache, cacheScopeSuffix } from './cache.js';
+const ROOMS_TTL_MS = 24 * 60 * 60 * 1000;
+const FREQUENT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const FREQUENT_WINDOW_DAYS = 180;
+const PAGE_SIZE = 100;
+const MAX_PAGES = 20;
+const STATUS_TEXT = { '0': '正常', '1': '封存' };
+const ATTR_TEXT = { '0': '实体', '1': '虚拟', '2': '组合' };
+function toText(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (item && typeof item === 'object' ? String(item.name ?? item.id ?? '') : String(item ?? '')))
+            .filter((item) => item !== '')
+            .join(',');
+    }
+    if (typeof value === 'object') {
+        const item = value;
+        return String(item.name ?? item.id ?? '');
+    }
+    return String(value);
+}
+function toNumber(value) {
+    const text = toText(value).trim();
+    if (text === '')
+        return 0;
+    const parsed = Number(text);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+async function fetchRoomsPage(env, pageNo) {
+    const session = await env.host.getSession();
+    const response = await env.host.request({
+        method: 'POST',
+        path: `${EB_BASE}/getFormDataList/query_meeting_room_list`,
+        operation: 'meeting.eb.room.recommend',
+        body: queryBody(session.userId, { pageNo, pageSize: PAGE_SIZE }),
+        acceptBusiness: ebBusinessSuccess,
+    });
+    const { rows } = extractEbRows(response);
+    return { rows, requests: 1 };
+}
+function normalizeRoom(row) {
+    const main = row?.mainTable ?? row ?? {};
+    const status = toText(main.status).trim();
+    const roomAttr = toText(main.room_attr).trim();
+    return {
+        id: toText(main.id).trim(),
+        name: toText(main.room_name).trim(),
+        status,
+        statusText: STATUS_TEXT[status] ?? (status === '' ? '未设置' : status),
+        roomAttr,
+        roomAttrText: ATTR_TEXT[roomAttr] ?? roomAttr,
+        minNum: toNumber(main.allow_minnum),
+        maxNum: toNumber(main.allow_maxnum),
+        place: toText(main.place).trim(),
+        equipments: toText(main.equipments).trim(),
+        mrType: toText(main.mr_type).trim(),
+    };
+}
+/** 全量会议室：优先缓存（24h），`refresh:true` 强制重拉。 */
+export async function loadRooms(env, options = {}) {
+    const key = `rooms-${await cacheScopeSuffix(env)}`;
+    const warnings = [];
+    if (!options.refresh) {
+        const cached = await readCache(env, key, { ttlMs: ROOMS_TTL_MS });
+        if (cached?.data?.length) {
+            return {
+                rooms: cached.data,
+                fromCache: true,
+                ageSeconds: Math.floor(cached.ageMs / 1000),
+                requests: 0,
+                warnings,
+            };
+        }
+    }
+    const rooms = [];
+    let requests = 0;
+    for (let pageNo = 1; pageNo <= MAX_PAGES; pageNo += 1) {
+        const page = await fetchRoomsPage(env, pageNo);
+        requests += page.requests;
+        rooms.push(...page.rows.map(normalizeRoom).filter((room) => room.id !== ''));
+        if (page.rows.length < PAGE_SIZE)
+            break;
+    }
+    if (rooms.length === 0) {
+        warnings.push('会议室列表为空（或当前账号无会议室读取权限）——无法推荐，请改为手工指定会议室');
+    }
+    else {
+        await writeCache(env, key, rooms);
+    }
+    return { rooms, fromCache: false, ageSeconds: 0, requests, warnings };
+}
+/** 个人常用会议室：统计「我近 180 天创建过的会议」里各会议室出现次数。 */
+export async function loadFrequentRooms(env, options = {}) {
+    const session = await env.host.getSession();
+    const userId = String(session?.userId ?? '').trim();
+    const key = `frequent-rooms-${await cacheScopeSuffix(env)}-${userId}`;
+    const warnings = [];
+    if (!options.refresh) {
+        const cached = await readCache(env, key, { ttlMs: FREQUENT_TTL_MS });
+        if (cached?.data) {
+            return { order: cached.data, fromCache: true, requests: 0, warnings };
+        }
+    }
+    if (!userId) {
+        return { order: [], fromCache: false, requests: 0, warnings: ['取不到当前用户 id，跳过「常用会议室」统计'] };
+    }
+    const since = new Date(Date.now() - FREQUENT_WINDOW_DAYS * 24 * 60 * 60 * 1000);
+    const pad = (n) => String(n).padStart(2, '0');
+    const sinceText = `${since.getFullYear()}-${pad(since.getMonth() + 1)}-${pad(since.getDate())} 00:00`;
+    const counts = new Map();
+    let requests = 0;
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const listOp = getMeetingOperation('meeting.eb.meeting.list');
+        for (let pageNo = 1; pageNo <= 5; pageNo += 1) {
+            const page = await listOp.handler({ creator: userId, begindatetime: sinceText, pageNo, pageSize: PAGE_SIZE }, env);
+            requests += 1;
+            const rows = (page?.data?.rows ?? []);
+            for (const row of rows) {
+                const main = row?.mainTable ?? row ?? {};
+                const name = toText(main.address).trim();
+                if (!name)
+                    continue;
+                counts.set(name, (counts.get(name) ?? 0) + 1);
+            }
+            if (rows.length < PAGE_SIZE)
+                break;
+        }
+    }
+    catch (error) {
+        warnings.push(`常用会议室统计失败（${String(error?.message ?? error).slice(0, 80)}）：本次按全量会议室排序推荐`);
+    }
+    const order = [...counts.entries()]
+        .map(([name, count]) => ({ name, count }))
+        .sort((left, right) => right.count - left.count)
+        .slice(0, 10);
+    if (order.length > 0)
+        await writeCache(env, key, order);
+    return { order, fromCache: false, requests, warnings };
+}
+/** 目标时段内被占用的会议室 id 集合（1 个请求查全部占用）。 */
+async function fetchBusyRoomIds(env, begin, end) {
+    const session = await env.host.getSession();
+    const ids = new Set();
+    let requests = 0;
+    const usageQuery = { enddatetime: end, begindatetime: begin };
+    for (let pageNo = 1; pageNo <= MAX_PAGES; pageNo += 1) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: `${EB_BASE}/getFormDataList/query_roomusage_list`,
+            operation: 'meeting.eb.room.recommend',
+            query: usageQuery,
+            body: queryBody(session.userId, { pageNo, pageSize: PAGE_SIZE }),
+            acceptBusiness: ebBusinessSuccess,
+        });
+        requests += 1;
+        const { rows } = extractEbRows(response);
+        for (const row of rows) {
+            const main = row?.mainTable ?? row ?? {};
+            const roomId = toText(main.address ?? main.room_id).trim();
+            if (roomId)
+                ids.add(roomId);
+        }
+        if (rows.length < PAGE_SIZE)
+            break;
+    }
+    return { ids, requests };
+}
+/** 推荐会议室：返回按得分排序的候选（best 为第一个）。 */
+export async function recommendRooms(env, input) {
+    const warnings = [];
+    const topN = Math.max(1, Math.min(10, input.topN ?? 3));
+    const roomData = await loadRooms(env, { refresh: input.refreshRooms === true });
+    warnings.push(...roomData.warnings);
+    const frequent = await loadFrequentRooms(env, { refresh: input.refreshFrequent === true });
+    warnings.push(...frequent.warnings);
+    const busy = await fetchBusyRoomIds(env, input.beginDatetime, input.endDatetime);
+    const frequentRank = new Map();
+    frequent.order.forEach((item, index) => {
+        frequentRank.set(item.name, { rank: index, count: item.count });
+    });
+    const memberCount = input.memberCount && input.memberCount > 0 ? input.memberCount : null;
+    const requirement = input.requirement ?? {};
+    const usable = roomData.rooms.filter((room) => room.status === '0');
+    let busyCount = 0;
+    const candidates = [];
+    for (const room of usable) {
+        const isBusy = busy.ids.has(room.id);
+        if (isBusy) {
+            busyCount += 1;
+            if (!input.includeBusy)
+                continue;
+        }
+        if (memberCount !== null) {
+            // allow_maxnum = 0 视为「不限」，超出上限或低于下限都算不满足（下限只在配置了才判）
+            if (room.maxNum > 0 && room.maxNum < memberCount)
+                continue;
+            if (room.minNum > 0 && room.minNum > memberCount)
+                continue;
+        }
+        if (requirement.roomAttr && room.roomAttr !== requirement.roomAttr)
+            continue;
+        if (requirement.mrType && room.mrType !== requirement.mrType)
+            continue;
+        if (requirement.placeKeyword && !room.place.includes(requirement.placeKeyword))
+            continue;
+        if (requirement.nameKeyword && !room.name.includes(requirement.nameKeyword))
+            continue;
+        if (requirement.equipmentsKeyword && !room.equipments.includes(requirement.equipmentsKeyword))
+            continue;
+        const reasons = [];
+        let score = 0;
+        const freq = frequentRank.get(room.name);
+        if (freq) {
+            reasons.push(`你近 ${FREQUENT_WINDOW_DAYS} 天用过 ${freq.count} 次`);
+            score += 40 - Math.min(30, freq.rank * 5);
+        }
+        if (memberCount !== null && room.maxNum > 0) {
+            const waste = room.maxNum - memberCount;
+            reasons.push(`容量 ${room.maxNum} 人，容纳 ${memberCount} 人`);
+            score += Math.max(0, 20 - Math.min(20, waste));
+        }
+        else if (room.maxNum > 0) {
+            reasons.push(`容量 ${room.maxNum} 人`);
+            score += 5;
+        }
+        if (requirement.placeKeyword) {
+            reasons.push(`地点匹配「${requirement.placeKeyword}」`);
+            score += 10;
+        }
+        if (requirement.equipmentsKeyword) {
+            reasons.push(`设备含「${requirement.equipmentsKeyword}」`);
+            score += 10;
+        }
+        if (isBusy) {
+            reasons.push('该时段已被占用（按 includeBusy 一并返回）');
+            score -= 100;
+        }
+        else {
+            reasons.push('该时段空闲');
+        }
+        candidates.push({
+            id: room.id,
+            name: room.name,
+            capacity: { min: room.minNum, max: room.maxNum },
+            place: room.place,
+            equipments: room.equipments,
+            roomAttrText: room.roomAttrText,
+            frequentCount: freq?.count ?? 0,
+            score,
+            reasons,
+        });
+    }
+    candidates.sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        // 同分时优先容量小的（不浪费大会议室），再按名称稳定排序
+        const leftCap = left.capacity.max > 0 ? left.capacity.max : Number.MAX_SAFE_INTEGER;
+        const rightCap = right.capacity.max > 0 ? right.capacity.max : Number.MAX_SAFE_INTEGER;
+        if (leftCap !== rightCap)
+            return leftCap - rightCap;
+        return left.name.localeCompare(right.name, 'zh-Hans-CN');
+    });
+    if (candidates.length === 0) {
+        warnings.push(`没有满足条件的空闲会议室（共 ${roomData.rooms.length} 间，可用 ${usable.length} 间，`
+            + `该时段被占用 ${busyCount} 间${memberCount ? `，人数 ${memberCount}` : ''}）`
+            + '——请放宽人数/地点/设备要求，或改为线上会议。');
+    }
+    return {
+        best: candidates[0] ?? null,
+        candidates: candidates.slice(0, topN),
+        meta: {
+            roomsTotal: roomData.rooms.length,
+            roomsUsable: usable.length,
+            roomsMatched: candidates.length,
+            roomsBusy: busyCount,
+            memberCount,
+            roomsFromCache: roomData.fromCache,
+            roomsCacheAgeSeconds: roomData.ageSeconds,
+            frequentFromCache: frequent.fromCache,
+            requests: roomData.requests + frequent.requests + busy.requests,
+        },
+        warnings,
+    };
+}
+/** 只推不建：按人数/要求/个人习惯推荐空闲会议室。 */
+export const ebRoomRecommendOperation = {
+    name: 'meeting.eb.room.recommend',
+    resource: 'eb',
+    method: 'meeting.eb.room.recommend',
+    action: 'meeting.eb.room.recommend',
+    summary: '会议室推荐：按人数 + 地点/设备/类型要求 + 个人常用（近 180 天）+ 时段占用，给出排序候选；会议室与常用记录走本地缓存（分别 24h / 7d），占用实时查 1 次',
+    capability: 'eb.room',
+    risk: 'read',
+    inputSchema: schemaOf({
+        beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+        endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+        memberCount: { type: 'number', description: '参会人数（可选；用于容量过滤，0 或不传 = 不按人数过滤）' },
+        hrmMembers: {
+            type: 'string',
+            description: '参会人 id 逗号分隔（可选）：不传 memberCount 时按它的人数推算',
+        },
+        placeKeyword: { type: 'string', description: '地点/楼层关键词（模糊匹配会议室 place）' },
+        nameKeyword: { type: 'string', description: '会议室名称关键词' },
+        mrType: { type: 'string', description: '会议室类型 id（mr_type）' },
+        roomAttr: { type: 'string', enum: ['0', '1', '2'], description: '会议室属性：0 实体 / 1 虚拟 / 2 组合' },
+        equipmentsKeyword: { type: 'string', description: '设备关键词（模糊匹配 equipments，如 投影/视频）' },
+        topN: { type: 'number', description: '返回候选数量（默认 3，最多 10）' },
+        refresh: { type: 'boolean', description: 'true=刷新会议室全量与常用记录缓存' },
+        includeBusy: { type: 'boolean', description: 'true=把该时段已被占用的会议室也返回（排在最后，带说明）' },
+    }, { required: ['beginDatetime', 'endDatetime'] }),
+    handler: async (args, env) => {
+        const hrmCount = String(args.hrmMembers ?? '')
+            .split(/[,;，；\s]+/)
+            .map((item) => item.trim())
+            .filter((item) => item !== '').length;
+        const memberCount = args.memberCount !== undefined ? Number(args.memberCount) : hrmCount;
+        const result = await recommendRooms(env, {
+            beginDatetime: String(args.beginDatetime),
+            endDatetime: String(args.endDatetime),
+            ...(Number.isFinite(memberCount) && memberCount > 0 ? { memberCount } : {}),
+            requirement: {
+                ...(args.placeKeyword ? { placeKeyword: String(args.placeKeyword) } : {}),
+                ...(args.nameKeyword ? { nameKeyword: String(args.nameKeyword) } : {}),
+                ...(args.mrType ? { mrType: String(args.mrType) } : {}),
+                ...(args.roomAttr ? { roomAttr: String(args.roomAttr) } : {}),
+                ...(args.equipmentsKeyword ? { equipmentsKeyword: String(args.equipmentsKeyword) } : {}),
+            },
+            ...(args.topN !== undefined ? { topN: Number(args.topN) } : {}),
+            ...(args.refresh === true ? { refreshRooms: true, refreshFrequent: true } : {}),
+            ...(args.includeBusy === true ? { includeBusy: true } : {}),
+        });
+        return meetingSuccess('meeting.eb.room.recommend', {
+            best: result.best,
+            candidates: result.candidates,
+            meta: result.meta,
+        }, result.warnings.length > 0 ? { warnings: result.warnings } : {});
+    },
+};
+/**
+ * 建会成功后把该会议室计入「个人常用」缓存（增量更新，不重拉历史）。
+ *
+ * 为什么需要（2026-10-28 用户追问）：常用会议室缓存 TTL 7 天，若只靠定时重算，
+ * 「今天刚预订了几场会议」不会立刻反映到下一天的推荐里，用户会觉得"推荐不准"。
+ * 这里在 `create.apply` 成功后直接 +1，保证同一会话/同一天内连续预约就能看到偏好变化。
+ *
+ * 约定：只在**缓存已存在**时增量（缓存不存在说明还没建过，下次推荐会自然全量统计，不必抢跑）；
+ *       房间 id → 名称优先用会议室缓存映射，映射不到就跳过（不为了计数多发一次请求）。
+ */
+export async function rememberFrequentRoom(env, roomId) {
+    const id = String(roomId ?? '').trim();
+    if (!id)
+        return false;
+    const scope = await cacheScopeSuffix(env);
+    const roomsCached = await readCache(env, `rooms-${scope}`, { ttlMs: ROOMS_TTL_MS });
+    const name = roomsCached?.data?.find((room) => room.id === id)?.name ?? '';
+    if (!name)
+        return false;
+    const session = await env.host.getSession().catch(() => null);
+    const userId = String(session?.userId ?? '').trim();
+    if (!userId)
+        return false;
+    const key = `frequent-rooms-${scope}-${userId}`;
+    const cached = await readCache(env, key, { ttlMs: FREQUENT_TTL_MS });
+    const order = cached?.data ?? [];
+    const existing = order.find((item) => item.name === name);
+    if (existing)
+        existing.count += 1;
+    else
+        order.push({ name, count: 1 });
+    order.sort((left, right) => right.count - left.count);
+    await writeCache(env, key, order.slice(0, 10));
+    return true;
+}

package/dist/shortcuts/meeting/operations/eb/room-summary.js

@@ -0,0 +1,84 @@
+/**
+ * 会议室列表（`meeting.eb.room.list`）的结果后处理。
+ *
+ * 为什么需要（2026-10-27 用户明确纠正）：
+ * 会议室 `status` 是 **Select，`0` = 正常、`1` = 封存**。但它的字面极性反直觉 ——
+ * 很容易把 `0` 读成"关闭/停用"，于是把一个全部正常的租户报成"6 间会议室都停用"。
+ * 直接把语义固化进返回值（`statusText` + `summary.byStatus` + `legend`），
+ * 调用方不需要再背字典，也不可能读反。
+ */
+const ROOM_STATUS = {
+    '0': '正常',
+    '1': '封存',
+};
+const ROOM_ATTR = {
+    '0': '实体',
+    '1': '虚拟',
+    '2': '组合',
+};
+function toText(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'object') {
+        const obj = value;
+        if (typeof obj.name === 'string')
+            return obj.name;
+        if (typeof obj.value === 'string')
+            return obj.value;
+        if (typeof obj.id === 'string')
+            return obj.id;
+        return '';
+    }
+    return String(value).trim();
+}
+/** 状态归一化：兼容编码（`0`/`1`）与中文渲染文本（`正常`/`封存`）。 */
+function normalizeRoomStatus(raw) {
+    const text = toText(raw);
+    if (text === '' || text === '0' || text === '正常') {
+        return { code: text === '' ? '' : '0', text: text === '' ? '未设置' : '正常' };
+    }
+    if (text === '1' || text === '封存')
+        return { code: '1', text: '封存' };
+    return { code: text, text };
+}
+function normalizeRoomAttr(raw) {
+    const text = toText(raw);
+    if (text === '')
+        return '未设置';
+    return ROOM_ATTR[text] ?? text;
+}
+export function summarizeRoomRows(rows) {
+    const byStatus = { 正常: 0, 封存: 0, 未设置: 0 };
+    const items = rows.map((row) => {
+        const main = (row?.mainTable ?? row ?? {});
+        const status = normalizeRoomStatus(main.status);
+        byStatus[status.text] = (byStatus[status.text] ?? 0) + 1;
+        return {
+            id: toText(main.id),
+            roomName: toText(main.room_name),
+            status: status.code,
+            statusText: status.text,
+            roomAttr: toText(main.room_attr),
+            roomAttrText: normalizeRoomAttr(main.room_attr),
+            allowMinNum: toText(main.allow_minnum),
+            allowMaxNum: toText(main.allow_maxnum),
+            place: toText(main.place),
+            equipments: toText(main.equipments),
+        };
+    });
+    return {
+        /** 语义字典：`0`=正常（可用）、`1`=封存（不可用）。写进返回体，避免被读反。 */
+        legend: {
+            status: ROOM_STATUS,
+            roomAttr: ROOM_ATTR,
+            note: 'status：0 = 正常（可用），1 = 封存（不可用）；不要读成"启用/停用"',
+        },
+        summary: {
+            total: items.length,
+            byStatus,
+            /** 当前页里"封存/未设置"的房间名，便于直接提示用户哪些不可用。 */
+            unusable: items.filter((item) => item.statusText !== '正常').map((item) => item.roomName),
+        },
+        items,
+    };
+}