weaver-work-cli 0.1.1 → 0.1.4

package/dist/shortcuts/plan/operations/read.js

@@ -0,0 +1,259 @@
+import { planValidationError } from '../errors.js';
+import { SCHEMA_ID, SCHEMA_REPORT_TYPE, planSuccess, schemaOf, } from './types.js';
+import { assertLinkSupported, assertReportType, ebMainTables, normalizeEbReport, normalizeStandardReport, resolveSerialNumber, resolveYear, toIdString, } from './shared.js';
+import { buildDetailUrl, lookupReport, resolveLink, } from './link.js';
+const COMMENT_MODULE = 'workreport';
+// ---------------------------------------------------------------------------
+// 单份报告详情（按 id 或按周期），并按规则附加评论总条数
+// ---------------------------------------------------------------------------
+async function commentTotalCount(host, reportId) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/plan/common/comment/commentPage',
+        operation: 'plan.report.get',
+        body: {
+            pageNo: 1,
+            pageSize: 1,
+            targetId: reportId,
+            module: COMMENT_MODULE,
+            foldCommentList: false,
+        },
+    });
+    const total = response?.data?.page?.totalCount;
+    const numeric = Number(total);
+    return Number.isFinite(numeric) ? numeric : null;
+}
+const planReportGet = {
+    name: 'plan.report.get',
+    resource: 'plan',
+    method: 'report.get',
+    action: 'plan.report.get',
+    summary: '按报告 id 或按周期（年份+类型+周期+创建人）查询单个报告详情，并按规则附带评论总条数',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        id: { ...SCHEMA_ID, description: '报告 id；与周期参数二选一，给 id 时忽略周期参数' },
+        year: { type: 'integer', description: '报告年份；缺省取本年' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+        creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id；缺省为当前登录人' },
+        withComments: { type: 'boolean', default: true, description: '标准版链路下是否同时查询评论总条数' },
+    }, {
+        oneOf: [{ required: ['id'] }, { required: ['type', 'serialNumber'] }],
+    }),
+    handler: async (args, { host }) => {
+        const warnings = [];
+        const query = args.id !== undefined && args.id !== ''
+            ? { id: toIdString(args.id, 'id') }
+            : {
+                year: resolveYear(args.year),
+                type: assertReportType(args.type),
+                serialNumber: resolveSerialNumber(args.serialNumber),
+                ...(args.creatorUserId !== undefined && args.creatorUserId !== ''
+                    ? { creatorUserId: toIdString(args.creatorUserId, 'creatorUserId') }
+                    : {}),
+            };
+        const linkInfo = await resolveLink(host);
+        const result = await lookupReport(host, linkInfo.link, query);
+        warnings.push(...result.warnings);
+        const data = {
+            link: result.link,
+            exists: result.exists,
+            report: result.report,
+            detailUrl: result.report?.detailUrl ?? null,
+            warnings,
+        };
+        if (result.link === 'eb') {
+            data.commentsSupported = false;
+            warnings.push('eb 链路未提供报告评论接口，评论总条数不可用');
+        }
+        else if (result.exists && result.report?.reportId && args.withComments !== false) {
+            try {
+                const total = await commentTotalCount(host, result.report.reportId);
+                if (total !== null && total > 0) {
+                    data.commentCount = total;
+                    data.commentHint = `该报告下共有${total}条评论，是否需要查看评论内容？`;
+                }
+            }
+            catch {
+                warnings.push('评论总条数查询失败，报告详情已返回');
+            }
+        }
+        return planSuccess('plan.report.get', data);
+    },
+};
+// ---------------------------------------------------------------------------
+// 分页查询报告列表
+// ---------------------------------------------------------------------------
+function pageArgs(args) {
+    const pageNo = args.pageNo === undefined || args.pageNo === '' ? 1 : Number(args.pageNo);
+    const pageSize = args.pageSize === undefined || args.pageSize === '' ? 10 : Number(args.pageSize);
+    if (!Number.isInteger(pageNo) || pageNo < 1) {
+        throw planValidationError('page_invalid', 'pageNo 必须是不小于 1 的整数');
+    }
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+        throw planValidationError('page_invalid', 'pageSize 必须是 1~100 的整数');
+    }
+    return { pageNo, pageSize };
+}
+const planReportPage = {
+    name: 'plan.report.page',
+    resource: 'plan',
+    method: 'report.page',
+    action: 'plan.report.page',
+    summary: '分页查询报告列表（共享给我的报告 / 我自己与他人共享的报告），返回可直接跳转详情的行数据',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        scope: { type: 'string', enum: ['share', 'mine'], default: 'share', description: 'share-共享给我的；mine-我自己及他人共享给我的（eb 链路按创建人筛选）' },
+        unreadOnly: { type: 'boolean', default: false, description: '仅看未读（标准版专属）' },
+        year: { type: 'integer', description: '报告年份筛选' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型筛选' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期筛选' },
+        creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id 筛选（eb 链路支持）' },
+        onlyIncludeSubs: { type: 'boolean', description: '是否只包含下属（标准版专属）' },
+        pageNo: { type: 'integer', minimum: 1, default: 1, description: '页码' },
+        pageSize: { type: 'integer', minimum: 1, maximum: 100, default: 10, description: '每页条数' },
+    }),
+    handler: async (args, { host }) => {
+        const { pageNo, pageSize } = pageArgs(args);
+        const warnings = [];
+        const linkInfo = await resolveLink(host);
+        const session = await host.getSession();
+        const rows = [];
+        if (linkInfo.link === 'standard') {
+            if (args.scope === 'mine') {
+                warnings.push('标准版分页接口只返回「共享给我的报告」，scope=mine 不能作为创建人过滤条件');
+            }
+            if (args.creatorUserId !== undefined && args.creatorUserId !== '') {
+                warnings.push('标准版分页接口不支持按创建人筛选，creatorUserId 已忽略');
+            }
+            const query = {
+                type: args.unreadOnly === true ? 'unreadPage' : 'sharePage',
+                pageNo,
+                pageSize,
+            };
+            if (args.type !== undefined)
+                query.workReportType = assertReportType(args.type);
+            if (args.onlyIncludeSubs !== undefined)
+                query.onlyIncludeSubs = args.onlyIncludeSubs === true;
+            const response = await host.request({
+                method: 'GET',
+                path: '/api/workrelate/plan/workreport/indexGet',
+                query,
+                operation: 'plan.report.page',
+            });
+            const result = response?.page?.result;
+            if (Array.isArray(result)) {
+                for (const row of result) {
+                    const reportId = row?.id === undefined || row?.id === null || row?.id === '' ? null : String(row.id);
+                    rows.push(normalizeStandardReport(row, await buildDetailUrl(host, 'standard', reportId)));
+                }
+            }
+            return planSuccess('plan.report.page', {
+                link: 'standard',
+                pageNo,
+                pageSize,
+                count: rows.length,
+                rows,
+                warnings,
+            });
+        }
+        if (args.unreadOnly === true)
+            warnings.push('eb 链路分页接口不支持「仅看未读」，unreadOnly 已忽略');
+        if (args.onlyIncludeSubs !== undefined)
+            warnings.push('eb 链路分页接口不支持 onlyIncludeSubs，已忽略');
+        const creator = args.creatorUserId !== undefined && args.creatorUserId !== ''
+            ? toIdString(args.creatorUserId, 'creatorUserId')
+            : session.userId;
+        const mainTable = { creator };
+        if (args.year !== undefined)
+            mainTable.f_year = resolveYear(args.year);
+        if (args.type !== undefined)
+            mainTable.f_type = assertReportType(args.type);
+        if (args.serialNumber !== undefined)
+            mainTable.f_serial_number = resolveSerialNumber(args.serialNumber);
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/ebuilder/form/formdata/v2/getFormDataList/plan_pageQueryPlan',
+            operation: 'plan.report.page',
+            body: {
+                datajson: {
+                    mainTable,
+                    pageInfo: { pageNo: String(pageNo), pageSize: String(pageSize) },
+                    header: { operator: session.userId },
+                },
+            },
+        });
+        for (const item of ebMainTables(response)) {
+            const reportId = item?.id === undefined || item?.id === null || item?.id === '' ? null : String(item.id);
+            rows.push(normalizeEbReport(item, await buildDetailUrl(host, 'eb', reportId)));
+        }
+        return planSuccess('plan.report.page', {
+            link: 'eb',
+            pageNo,
+            pageSize,
+            count: rows.length,
+            rows,
+            warnings,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 报告评论列表
+// ---------------------------------------------------------------------------
+const planCommentList = {
+    name: 'plan.comment.list',
+    resource: 'plan',
+    method: 'comment.list',
+    action: 'plan.comment.list',
+    summary: '分页查询某份报告的评论内容（标准版链路）；仅在用户明确要求查看评论内容时调用',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        reportId: { ...SCHEMA_ID, description: '报告 id' },
+        pageNo: { type: 'integer', minimum: 1, default: 1, description: '页码' },
+        pageSize: { type: 'integer', minimum: 1, maximum: 100, default: 10, description: '每页条数' },
+    }, { required: ['reportId'] }),
+    handler: async (args, { host }) => {
+        const { pageNo, pageSize } = pageArgs(args);
+        const reportId = toIdString(args.reportId, 'reportId');
+        const linkInfo = await resolveLink(host);
+        assertLinkSupported(linkInfo.link, 'standard', 'plan.comment.list', 'eb 链路未提供报告评论接口，无法查询评论内容；当前租户走 e10-ebuilder 链路');
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/plan/common/comment/commentPage',
+            operation: 'plan.comment.list',
+            body: {
+                pageNo,
+                pageSize,
+                targetId: reportId,
+                module: COMMENT_MODULE,
+                foldCommentList: false,
+            },
+        });
+        const page = response?.data?.page ?? {};
+        const result = Array.isArray(page.result) ? page.result : [];
+        const totalCount = Number(page.totalCount);
+        return planSuccess('plan.comment.list', {
+            link: 'standard',
+            reportId,
+            pageNo,
+            pageSize,
+            totalCount: Number.isFinite(totalCount) ? totalCount : result.length,
+            comments: result.map((item) => ({
+                commentId: item?.id ?? null,
+                commentorId: item?.commentor?.id ?? null,
+                commentorName: item?.commentor?.username ?? item?.commentor?.name ?? null,
+                content: item?.content ?? item?.originContent ?? null,
+                addTime: item?.addTime ?? null,
+                parentCommentId: item?.parent?.id ?? null,
+            })),
+        });
+    },
+};
+export const planReadOperations = [
+    planReportGet,
+    planReportPage,
+    planCommentList,
+];

package/dist/shortcuts/plan/operations/registry.js

@@ -0,0 +1,33 @@
+import { planValidationError } from '../errors.js';
+import { planReadOperations } from './read.js';
+import { planVersionOperations } from './version.js';
+import { planWriteOperations } from './write.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...planVersionOperations,
+        ...planReadOperations,
+        ...planWriteOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate plan operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const planOperationRegistry = buildRegistry();
+export function planOperationDefinitions() {
+    return [...planOperationRegistry.values()];
+}
+export function getPlanOperation(operation) {
+    const definition = planOperationRegistry.get(operation);
+    if (!definition) {
+        throw planValidationError('operation_unknown', `计划报告模块不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasPlanOperation(operation) {
+    return planOperationRegistry.has(operation);
+}

package/dist/shortcuts/plan/operations/shared.js

@@ -0,0 +1,246 @@
+import { createHash } from 'node:crypto';
+import { planConfirmationError, planUnsupportedError, planValidationError } from '../errors.js';
+import { POST_STATUS_LABELS, POST_TIME_STATUS_LABELS, REPORT_TYPE_LABELS, REPORT_TYPE_VALUES, } from './types.js';
+/** 原型污染防护：禁止出现在输入对象中的键。 */
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw planValidationError('input_not_object', '输入必须是 JSON 对象');
+    }
+    return value;
+}
+export function assertNoForbiddenKeys(input) {
+    for (const key of Object.keys(input)) {
+        if (FORBIDDEN_KEYS.has(key)) {
+            throw planValidationError('forbidden_key', `输入包含非法字段：${key}`);
+        }
+    }
+}
+export function toIdString(value, field) {
+    if (value === undefined || value === null || value === '') {
+        throw planValidationError('id_invalid', `${field} 必须是数字 ID（雪花 ID 请用字符串传递）`);
+    }
+    const text = String(value);
+    if (!/^\d+$/.test(text)) {
+        throw planValidationError('id_invalid', `${field} 必须是数字 ID`);
+    }
+    return text;
+}
+/**
+ * 人员 ID 列表归一化：接受 `"1001,1002"` 或 `["1001","1002"]`，输出英文逗号拼接字符串。
+ * 源资料：ids 为「英文逗号拼接」的人员 id。
+ */
+export function toIdListText(value, field) {
+    const list = [];
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (item === undefined || item === null || item === '')
+                continue;
+            list.push(String(item));
+        }
+    }
+    else if (typeof value === 'string' || typeof value === 'number') {
+        for (const part of String(value).split(',')) {
+            const trimmed = part.trim();
+            if (trimmed)
+                list.push(trimmed);
+        }
+    }
+    if (list.length === 0) {
+        throw planValidationError('ids_required', `${field} 至少需要一个人员 ID`);
+    }
+    for (const id of list) {
+        if (!/^\d+$/.test(id)) {
+            throw planValidationError('ids_invalid', `${field} 必须是人员 ID（数字字符串）`);
+        }
+    }
+    return list.join(',');
+}
+export function assertReportType(value) {
+    const text = typeof value === 'string' ? value : String(value);
+    if (!REPORT_TYPE_VALUES.includes(text)) {
+        throw planValidationError('type_invalid', `type 取值必须是 ${REPORT_TYPE_VALUES.join(' / ')} 之一`);
+    }
+    return text;
+}
+/** 报告年份：未提供时默认本年（源资料：若未提取到 year 参数，则默认取本年）。 */
+export function resolveYear(value) {
+    if (value === undefined || value === null || value === '')
+        return new Date().getFullYear();
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric < 1970 || numeric > 9999) {
+        throw planValidationError('year_invalid', 'year 必须是四位整数年份');
+    }
+    return numeric;
+}
+/** 报告周期：正整数。 */
+export function resolveSerialNumber(value) {
+    if (value === undefined || value === null || value === '') {
+        throw planValidationError('serial_number_required', 'serialNumber（报告周期）必填');
+    }
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric <= 0) {
+        throw planValidationError('serial_number_invalid', 'serialNumber（报告周期）必须是正整数');
+    }
+    return numeric;
+}
+export function requireConfirm(args, action) {
+    if (args.confirm !== true) {
+        throw planConfirmationError(action, {
+            hint: '重新调用时传入 confirm=true 与 prepare 返回的 continuation',
+        });
+    }
+}
+export function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
+}
+/** 移除值为 undefined / null / '' 的键（eb 自定义接口要求空字符串字段不传）。 */
+export function compact(mainTable) {
+    for (const key of Object.keys(mainTable)) {
+        const value = mainTable[key];
+        if (value === undefined || value === null || value === '')
+            delete mainTable[key];
+    }
+    return mainTable;
+}
+/**
+ * eb Select 字段归一化：可能是 `[{name,id}]`、`["week"]`、`"week"` 或数字。
+ * 统一返回标量字符串，便于和标准版输出对齐。
+ */
+export function optionValue(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (Array.isArray(value)) {
+        const first = value[0];
+        if (first === undefined || first === null)
+            return undefined;
+        if (typeof first === 'string' || typeof first === 'number')
+            return String(first);
+        if (typeof first === 'object') {
+            const record = first;
+            const candidate = record.id ?? record.value ?? record.name;
+            if (candidate === undefined || candidate === null || candidate === '')
+                return undefined;
+            return String(candidate);
+        }
+        return undefined;
+    }
+    if (typeof value === 'string' || typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+function asNumber(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+}
+function asText(value) {
+    if (value === undefined || value === null)
+        return null;
+    const text = String(value);
+    return text === '' ? null : text;
+}
+function typeLabelOf(type) {
+    return type ? (REPORT_TYPE_LABELS[type] ?? null) : null;
+}
+/** 标准版 workReport 结构 → 统一业务报告结构。 */
+export function normalizeStandardReport(workReport, detailUrl) {
+    const postStatus = optionValue(workReport?.postStatus) ?? null;
+    const type = optionValue(workReport?.type) ?? null;
+    const postTimeStatus = optionValue(workReport?.postTimeStatus) ?? null;
+    return {
+        reportId: asText(workReport?.id),
+        title: asText(workReport?.title),
+        content: asText(workReport?.content),
+        summary: asText(workReport?.summary),
+        plans: asText(workReport?.plans),
+        year: asNumber(workReport?.year),
+        type,
+        typeLabel: typeLabelOf(type),
+        serialNumber: asNumber(workReport?.serialNumber),
+        postStatus,
+        postStatusLabel: postStatus ? (POST_STATUS_LABELS[postStatus] ?? null) : null,
+        postTime: asNumber(workReport?.postTime),
+        postTimeStatus,
+        postTimeStatusLabel: postTimeStatus ? (POST_TIME_STATUS_LABELS[postTimeStatus] ?? null) : null,
+        creator: {
+            id: asText(workReport?.creator?.id ?? workReport?.creator?.employeeId),
+            name: asText(workReport?.creator?.name ?? workReport?.creator?.employeeId),
+        },
+        detailUrl,
+    };
+}
+/** ebuilder mainTable（f_* 字段）→ 统一业务报告结构，避免向 Agent 暴露数据库字段名。 */
+export function normalizeEbReport(mainTable, detailUrl) {
+    const postStatus = optionValue(mainTable?.f_post_status) ?? null;
+    const type = optionValue(mainTable?.f_type) ?? null;
+    const postTimeStatus = optionValue(mainTable?.f_post_time_status) ?? null;
+    return {
+        reportId: asText(mainTable?.id),
+        title: asText(mainTable?.f_title ?? mainTable?.name),
+        content: asText(mainTable?.f_content),
+        summary: asText(mainTable?.f_summary),
+        plans: asText(mainTable?.f_plans),
+        year: asNumber(mainTable?.f_year),
+        type,
+        typeLabel: typeLabelOf(type),
+        serialNumber: asNumber(mainTable?.f_serial_number),
+        postStatus,
+        postStatusLabel: postStatus ? (POST_STATUS_LABELS[postStatus] ?? null) : null,
+        postTime: asNumber(mainTable?.f_post_time),
+        postTimeStatus,
+        postTimeStatusLabel: postTimeStatus ? (POST_TIME_STATUS_LABELS[postTimeStatus] ?? null) : null,
+        creator: {
+            id: asText(mainTable?.creator),
+            name: null,
+        },
+        detailUrl,
+    };
+}
+/** 从 eb datajson 响应中取出 datas[].mainTable 列表。 */
+export function ebMainTables(value) {
+    const datas = value?.datajson?.datas;
+    if (!Array.isArray(datas))
+        return [];
+    const list = [];
+    for (const item of datas) {
+        if (item && typeof item === 'object' && item.mainTable && typeof item.mainTable === 'object') {
+            list.push(item.mainTable);
+        }
+    }
+    return list;
+}
+/** 断言当前链路支持该能力，否则抛 policy 错误（源资料未提供该链路的实现依据）。 */
+export function assertLinkSupported(link, supported, capability, message, details) {
+    if (link !== supported) {
+        throw planUnsupportedError('link_unsupported', message, { capability, link, expectedLink: supported, ...(details || {}) });
+    }
+}
+/** 校验 confirm + continuation，并确认登录上下文未变化。 */
+export async function ensureConfirmLease(args, action, env) {
+    requireConfirm(args, action);
+    const lease = await env.continuation.verify(args.continuation, action);
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw planValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    return lease;
+}
+/** 默认提醒文案（源资料：年份、周期随实际条件替换）。 */
+export function defaultRemindContent(type, year, serialNumber) {
+    switch (type) {
+        case 'week':
+            return `请提交${year}年第${serialNumber}周的报告`;
+        case 'month':
+            return `请提交${year}年${serialNumber}月的报告`;
+        case 'season':
+            return `请提交${year}年第${serialNumber}季度的报告`;
+        case 'halfYear':
+            return `请提交${year}年年中报告`;
+        case 'year':
+            return `请提交${year}年年度报告`;
+        default:
+            return `请提交${year}年的报告`;
+    }
+}

package/dist/shortcuts/plan/operations/types.js

@@ -0,0 +1,49 @@
+export function planSuccess(action, data, meta) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    return payload;
+}
+/** 构造「对象类型 + 严格禁止额外字段」的 JSON Schema。 */
+export function schemaOf(properties, options = {}) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(options.required?.length ? { required: options.required } : {}),
+        ...(options.oneOf?.length ? { oneOf: options.oneOf } : {}),
+        ...(options.anyOf?.length ? { anyOf: options.anyOf } : {}),
+        ...(options.description ? { description: options.description } : {}),
+    };
+}
+/** 报告 ID / 人员 ID：雪花 ID 语义，接受数字或数字字符串。 */
+export const SCHEMA_ID = {
+    oneOf: [{ type: 'integer' }, { type: 'string', pattern: '^\\d+$' }],
+};
+/** 需要保持字符串形态的雪花 ID（人员 ID 等）。 */
+export const SCHEMA_ID_STRING = { type: 'string', minLength: 1, pattern: '^\\d+$' };
+/** 多个人员 ID（英文字逗号拼接）。 */
+export const SCHEMA_ID_LIST_TEXT = { type: 'string', pattern: '^\\d+(,\\d+)*$' };
+export const REPORT_TYPE_VALUES = ['week', 'month', 'season', 'halfYear', 'year'];
+export const SCHEMA_REPORT_TYPE = { type: 'string', enum: [...REPORT_TYPE_VALUES] };
+export const SHARE_TYPE_VALUES = ['sharePage', 'unreadPage'];
+/** 发布状态：0-草稿 1-已发布 2-已撤回 3-审批中 4-被退回。 */
+export const POST_STATUS_LABELS = {
+    '0': '草稿',
+    '1': '已发布',
+    '2': '已撤回',
+    '3': '审批中',
+    '4': '被退回',
+};
+/** 发布时效状态：1-正常提交 2-补交。 */
+export const POST_TIME_STATUS_LABELS = {
+    '1': '正常提交',
+    '2': '补交',
+};
+export const REPORT_TYPE_LABELS = {
+    week: '周报',
+    month: '月报',
+    season: '季报',
+    halfYear: '年中报告',
+    year: '年报',
+};

package/dist/shortcuts/plan/operations/version.js

@@ -0,0 +1,49 @@
+import { planSuccess, schemaOf } from './types.js';
+import { resolveEbFormId, resolveLink, PLAN_EB_FORM_TAG } from './link.js';
+// ---------------------------------------------------------------------------
+// 版本判定与链路路由（租户级缓存 1 天）
+// ---------------------------------------------------------------------------
+const planVersionCheck = {
+    name: 'plan.version.check',
+    resource: 'plan',
+    method: 'version.check',
+    action: 'plan.version.check',
+    summary: '判定当前租户的计划报告接口链路（standard / eb），命中 1 天租户缓存时跳过接口调用',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        refresh: { type: 'boolean', default: false, description: 'true 时忽略缓存重新调用版本接口' },
+    }),
+    handler: async (args, { host }) => {
+        const info = await resolveLink(host, { refresh: args.refresh === true });
+        return planSuccess('plan.version.check', {
+            ...info,
+            versionInterface: 'plan_searchAppver',
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// ebuilder 报告详情页表单 id（idobjId）解析与长期缓存
+// ---------------------------------------------------------------------------
+const planEbFormResolve = {
+    name: 'plan.eb.form.resolve',
+    resource: 'plan',
+    method: 'eb.form.resolve',
+    action: 'plan.eb.form.resolve',
+    summary: '解析 ebuilder 报告详情表单 id（idobjId），用于生成报告详情页链接；解析结果按租户长期缓存',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({}),
+    handler: async (_args, { host }) => {
+        const info = await resolveEbFormId(host);
+        return planSuccess('plan.eb.form.resolve', {
+            ...info,
+            appTag: info.appTag,
+            formTag: PLAN_EB_FORM_TAG,
+        });
+    },
+};
+export const planVersionOperations = [
+    planVersionCheck,
+    planEbFormResolve,
+];