weaver-work-cli 0.1.28 → 0.1.31

package/dist/shortcuts/contract/operations/clause-library.js

@@ -0,0 +1,522 @@
+import { ContractCliError, contractPolicyError, contractValidationError } from '../errors.js';
+import { clauseLibraryPageUrl } from './page.js';
+import { ContractReadOperation } from './read.js';
+import { bodyFrom, fingerprintFields, requireId, requireNonEmptyString } from './shared.js';
+import { ContractWriteApplyOperation, ContractWritePrepareOperation } from './write.js';
+const PERMISSION_PATH = '/api/ebd/contract/component/checkPermissionV2';
+const TREE_BASE = '/api/ebd/contract/tree';
+const INFO_BASE = '/api/ebd/contract/clauseinfo';
+const GROUP_BASE = '/api/ebd/contract/clausegroup';
+/** 条款库鉴权固定业务头，来源见 clause-library.md「权限鉴权」。 */
+const CLAUSE_HEADERS = { ebbusinessid: '10000000000000000' };
+/**
+ * 条款库 CRUD 前的强制鉴权门。
+ * 放行依据只有 data.checkPermission === true；hasLicense / privateDeploy / isRelease 不作为放行依据。
+ */
+export async function assertClausePermission(host) {
+    const value = await host.contractRequest({
+        method: 'GET',
+        path: PERMISSION_PATH,
+        query: { moduleFlag: 'termComponent' },
+        headers: CLAUSE_HEADERS,
+    });
+    const data = (value?.data ?? {});
+    const denied = value?.status === false || value?.fail === true || data.checkPermission !== true;
+    if (denied) {
+        throw contractPolicyError('clause_no_permission', '暂无权限访问条款库（checkPermissionV2 未返回 data.checkPermission=true）；已中止后续所有条款库接口，不要重试或换接口绕行', { path: PERMISSION_PATH, status: value?.status, fail: value?.fail, hasLicense: data.hasLicense });
+    }
+    return {
+        checkPermission: true,
+        hasLicense: data.hasLicense,
+        privateDeploy: data.privateDeploy,
+        dataInfo: data.dataInfo,
+    };
+}
+/** 所有条款库 operation 统一在入口处鉴权，包括查询类。 */
+class ClauseGatedOperation {
+    name;
+    inner;
+    constructor(name, inner) {
+        this.name = name;
+        this.inner = inner;
+    }
+    async execute(input, context) {
+        await assertClausePermission(context.host);
+        return this.inner.execute(input, context);
+    }
+}
+/** 从分页接口的多种返回形状里取记录数组。 */
+function recordsOf(value) {
+    const data = value?.data ?? {};
+    for (const candidate of [data.records, data.list, data.rows, data.data, data]) {
+        if (Array.isArray(candidate))
+            return candidate;
+    }
+    return [];
+}
+function flattenTree(nodes, out = []) {
+    if (!Array.isArray(nodes))
+        return out;
+    for (const node of nodes) {
+        if (!node || typeof node !== 'object')
+            continue;
+        out.push(node);
+        flattenTree(node.children, out);
+        flattenTree(node.childList, out);
+    }
+    return out;
+}
+async function listCategories(host) {
+    const value = await host.contractRequest({ method: 'GET', path: `${TREE_BASE}/queryList` });
+    return flattenTree(value?.data);
+}
+async function listClauses(host, query) {
+    const value = await host.contractRequest({
+        method: 'GET',
+        path: `${INFO_BASE}/getListPage`,
+        query: { pageNo: 1, pageSize: 50, ...query },
+    });
+    return recordsOf(value);
+}
+async function listClauseGroups(host, query) {
+    const value = await host.contractRequest({
+        method: 'GET',
+        path: `${GROUP_BASE}/getListPage`,
+        query: { pageNo: 1, pageSize: 50, ...query },
+    });
+    return recordsOf(value);
+}
+// ---------------------------------------------------------------- 查询类
+export const contractClausePermissionOperation = {
+    name: 'contract.clause.permission',
+    async execute(_input, { host }) {
+        const permission = await assertClausePermission(host);
+        const session = await host.getSession();
+        return {
+            status: 'COMPLETE',
+            data: { ...permission, url: clauseLibraryPageUrl(session.baseUrl) },
+        };
+    },
+};
+export const contractClauseTypeListOperation = new ClauseGatedOperation('contract.clause.types', new ContractReadOperation('contract.clause.types', {
+    method: 'GET',
+    path: `${TREE_BASE}/queryAllCluseType`,
+    shape: (value) => ({ code: value.code, msg: value.msg, types: value.data }),
+}));
+export const contractClauseCheckOperation = {
+    name: 'contract.clause.check',
+    async execute(input, { host }) {
+        await assertClausePermission(host);
+        // 判重只允许传 clauseName + belongId；缺 belongId 会静默返回「不存在」，必须在这里拦住。
+        const clauseName = requireNonEmptyString(input.clauseName, 'clauseName', 200).trim();
+        const belongId = requireId(input.belongId, 'belongId');
+        const value = await host.contractRequest({
+            method: 'GET',
+            path: `${INFO_BASE}/checkData`,
+            query: { clauseName, belongId },
+        });
+        const data = value?.data;
+        const exists = data !== null && data !== undefined && data !== '' && data !== false;
+        return {
+            status: 'COMPLETE',
+            data: { clauseName, belongId, exists, raw: data },
+        };
+    },
+};
+export const contractClauseBrowserOperation = {
+    name: 'contract.clause.browser',
+    async execute(input, { host }) {
+        await assertClausePermission(host);
+        const name = requireNonEmptyString(input.name, 'name', 200).trim();
+        const value = await host.contractRequest({
+            method: 'POST',
+            path: `${INFO_BASE}/common/browser/data/clauseInfoBrowser`,
+            body: { quickSearchDatas: { name } },
+        });
+        const rows = Array.isArray(value?.data) ? value.data : recordsOf(value);
+        return {
+            status: 'COMPLETE',
+            data: {
+                name,
+                clauses: rows.map((row) => ({
+                    id: row.id,
+                    name: row.name ?? row.clauseName,
+                })),
+                hint: rows.length > 1 ? '命中多条时必须让用户确认条款，禁止自动选第一条' : undefined,
+            },
+        };
+    },
+};
+export const contractClauseSubcompanyOperation = {
+    name: 'contract.clause.subcompany',
+    async execute(input, { host }) {
+        await assertClausePermission(host);
+        const name = typeof input.name === 'string' ? input.name.trim() : '';
+        try {
+            const value = await host.contractRequest({
+                method: 'POST',
+                path: '/api/hrm/common/browser/data/subcompany',
+                body: { quickSearchDatas: { name } },
+            });
+            const rows = Array.isArray(value?.data) ? value.data : recordsOf(value);
+            return {
+                status: 'COMPLETE',
+                data: { source: 'subcompany', subs: rows, hint: '未指定分部时 belongSub 传空字符串 ""' },
+            };
+        }
+        catch (error) {
+            // 源资料明确：subcompany 返回 500 时降级到机构树接口。
+            if (!(error instanceof ContractCliError) || (error.type !== 'api' && error.type !== 'network'))
+                throw error;
+            const value = await host.contractRequest({
+                method: 'GET',
+                path: '/api/hrm/common/getOrgTree',
+                query: {
+                    menuCode: 'termComponent',
+                    onlySubcompany: 'false',
+                    containDisableDept: 'false',
+                    moduleCode: 'CONTRACT',
+                    virtualId: 1,
+                    loadCount: 'false',
+                    checkAllPermission: 'true',
+                    isMobile: 'false',
+                },
+            });
+            return {
+                status: 'COMPLETE',
+                data: { source: 'getOrgTree', subs: flattenTree(value?.data), hint: '未指定分部时 belongSub 传空字符串 ""' },
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------- 写操作
+function pairContractType(input) {
+    const id = input.contractType;
+    const name = input.contractTypeName;
+    if ((id === undefined) !== (name === undefined)) {
+        throw contractValidationError('contract_type_pair_required', 'contractType 与 contractTypeName 必须成对提交：只传 id 会导致页面合同类型名缺失');
+    }
+}
+function clauseBody(input) {
+    return bodyFrom(input, [
+        'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'contractType', 'contractTypeName',
+        'clauseVersion', 'clauseGroup', 'clauseStatus', 'clauseForm', 'isSmartCombination',
+    ]);
+}
+const categoryCreateSpec = {
+    method: 'POST',
+    path: `${TREE_BASE}/save`,
+    validate(input) {
+        requireNonEmptyString(input.clauseName, 'clauseName', 200);
+        const parentId = input.parentId === undefined ? '0' : String(input.parentId);
+        if (parentId !== '0')
+            requireId(parentId, 'parentId');
+        const levelNum = input.levelNum === undefined ? (parentId === '0' ? '0' : undefined) : String(input.levelNum);
+        if (levelNum === undefined) {
+            throw contractValidationError('level_num_required', '子分类必须传 levelNum（父分类 levelNum + 1）；顶层分类可省略，固定为 0');
+        }
+        if (parentId === '0' && levelNum !== '0') {
+            throw contractValidationError('level_num_invalid', '顶层分类的 levelNum 必须是 0');
+        }
+    },
+    body: (input) => bodyFrom(input, ['clauseName', 'parentId', 'orderNum', 'clauseStatus', 'isSystem', 'levelNum'], {
+        parentId: input.parentId === undefined ? '0' : String(input.parentId),
+        orderNum: input.orderNum ?? '1',
+        clauseStatus: input.clauseStatus ?? '1',
+        isSystem: '0',
+        levelNum: input.levelNum === undefined ? '0' : String(input.levelNum),
+    }),
+    fingerprint: fingerprintFields(['clauseName', 'parentId', 'orderNum', 'clauseStatus', 'levelNum']),
+    preview: (input) => ({
+        action: '新增条款分类',
+        clauseName: input.clauseName,
+        parentId: input.parentId ?? '0',
+        levelNum: input.levelNum ?? '0',
+        warning: 'clauseType 不传（传了会 500）；删除分类会级联删除其下条款',
+    }),
+    async precheck(input, host) {
+        const value = await host.contractRequest({
+            method: 'GET',
+            path: `${TREE_BASE}/checkData`,
+            query: { clauseName: input.clauseName },
+        });
+        const existing = value?.data;
+        if (existing !== null && existing !== undefined && existing !== '' && existing !== false) {
+            throw contractPolicyError('category_already_exists', '同分类下已存在同名条款分类，禁止重复创建', { clauseName: input.clauseName });
+        }
+        return { duplicateCheck: 'passed' };
+    },
+    async readback(_result, input, host) {
+        const nodes = await listCategories(host);
+        const hit = nodes.find((node) => node.clauseName === input.clauseName || node.name === input.clauseName);
+        if (!hit)
+            throw new Error('分类树中未找到刚创建的分类');
+        return { id: hit.id, clauseName: hit.clauseName ?? hit.name };
+    },
+};
+const categoryUpdateSpec = {
+    method: 'POST',
+    path: `${TREE_BASE}/update`,
+    validate(input) {
+        requireId(input.id, '分类 id');
+        requireNonEmptyString(input.clauseName, 'clauseName', 200);
+    },
+    body: (input) => bodyFrom(input, ['id', 'clauseName', 'parentId', 'orderNum', 'clauseStatus', 'isSystem', 'levelNum']),
+    fingerprint: fingerprintFields(['id', 'clauseName', 'parentId', 'orderNum', 'clauseStatus', 'levelNum']),
+    preview: (input) => ({ action: '修改条款分类', id: input.id, clauseName: input.clauseName }),
+    async readback(_result, input, host) {
+        const nodes = await listCategories(host);
+        const hit = nodes.find((node) => String(node.id) === String(input.id));
+        if (!hit)
+            throw new Error('分类树中未找到被修改的分类');
+        return { id: hit.id, clauseName: hit.clauseName ?? hit.name };
+    },
+};
+const categoryDeleteSpec = {
+    method: 'POST',
+    path: `${TREE_BASE}/deletebyid`,
+    validate(input) {
+        requireId(input.id, '分类 id');
+    },
+    body: (input) => ({ id: String(input.id) }),
+    fingerprint: fingerprintFields(['id']),
+    preview: (input) => ({
+        action: '删除条款分类',
+        id: input.id,
+        warning: '删除会级联删除该分类下的条款；必须已获得用户明确同意',
+    }),
+    async precheck(input, host) {
+        const nodes = await listCategories(host);
+        const hit = nodes.find((node) => String(node.id) === String(input.id));
+        if (!hit)
+            throw contractPolicyError('category_not_found', '分类不存在，未发起删除', { id: input.id });
+        const clauses = await listClauses(host, { belongId: String(input.id) });
+        return {
+            clauseName: hit.clauseName ?? hit.name,
+            clauseCount: clauses.length,
+            warning: clauses.length ? `该分类下仍有 ${clauses.length} 条条款，删除将一并级联删除` : '该分类下未查到条款',
+        };
+    },
+    async readback(_result, input, host) {
+        const nodes = await listCategories(host);
+        if (nodes.some((node) => String(node.id) === String(input.id))) {
+            throw new Error('删除接口返回成功，但分类树中仍能查到该分类');
+        }
+        return { id: input.id, removed: true };
+    },
+};
+const clauseCreateSpec = {
+    method: 'POST',
+    path: `${INFO_BASE}/save`,
+    validate(input) {
+        requireNonEmptyString(input.clauseName, 'clauseName', 200);
+        // 漏传 clauseNum 时服务端不报错、静默存空编号，必须前置拦截。
+        requireNonEmptyString(input.clauseNum, 'clauseNum', 64);
+        requireNonEmptyString(input.clauseVersion, 'clauseVersion', 32);
+        requireId(input.belongId, 'belongId');
+        if (input.clauseGroup === undefined || String(input.clauseGroup) === '') {
+            throw contractValidationError('clause_group_required', 'clauseGroup 必传（无所属条款组时传 "-1"），缺失服务端 500');
+        }
+        pairContractType(input);
+    },
+    body: (input) => clauseBody(input),
+    fingerprint: fingerprintFields([
+        'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'contractType', 'contractTypeName',
+        'clauseVersion', 'clauseGroup', 'clauseStatus',
+    ]),
+    preview: (input) => ({
+        action: '新增条款',
+        clauseName: input.clauseName,
+        clauseNum: input.clauseNum,
+        belongId: input.belongId,
+        clauseVersion: input.clauseVersion,
+        clauseGroup: input.clauseGroup,
+        contractType: input.contractType,
+        contractTypeName: input.contractTypeName,
+    }),
+    async precheck(input, host) {
+        const value = await host.contractRequest({
+            method: 'GET',
+            path: `${INFO_BASE}/checkData`,
+            query: { clauseName: input.clauseName, belongId: String(input.belongId) },
+        });
+        const existing = value?.data;
+        if (existing !== null && existing !== undefined && existing !== '' && existing !== false) {
+            throw contractPolicyError('clause_already_exists', '同一分类下已存在同名条款；判重依据是名称，不是编号或内容', {
+                clauseName: input.clauseName,
+                belongId: input.belongId,
+            });
+        }
+        return { duplicateCheck: 'passed' };
+    },
+    async readback(_result, input, host) {
+        const rows = await listClauses(host, { clauseName: input.clauseName, belongId: String(input.belongId) });
+        const hit = rows.find((row) => (row.clauseName ?? row.name) === input.clauseName);
+        if (!hit)
+            throw new Error('条款列表中未找到刚创建的条款');
+        if (String(hit.clauseNum ?? '') !== String(input.clauseNum)) {
+            throw new Error(`编号未落库：期望 ${input.clauseNum}，实际 ${hit.clauseNum ?? '(空)'}`);
+        }
+        return { id: hit.id, clauseName: hit.clauseName ?? hit.name, clauseNum: hit.clauseNum };
+    },
+};
+const clauseUpdateSpec = {
+    method: 'POST',
+    path: `${INFO_BASE}/update`,
+    validate(input) {
+        requireId(input.id, '条款 id');
+        if (input.clauseNum !== undefined)
+            requireNonEmptyString(input.clauseNum, 'clauseNum', 64);
+        pairContractType(input);
+    },
+    body: (input) => bodyFrom(input, [
+        'id', 'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'contractType', 'contractTypeName',
+        'clauseVersion', 'clauseGroup', 'clauseStatus', 'clauseForm', 'isSmartCombination',
+    ]),
+    fingerprint: fingerprintFields([
+        'id', 'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'contractType', 'contractTypeName',
+        'clauseVersion', 'clauseGroup', 'clauseStatus',
+    ]),
+    preview: (input) => ({ action: '修改条款', id: input.id, clauseName: input.clauseName, clauseNum: input.clauseNum }),
+    async readback(_result, input, host) {
+        if (!input.clauseName)
+            return { skipped: '未提供 clauseName，无法按名称回读' };
+        const rows = await listClauses(host, {
+            clauseName: input.clauseName,
+            ...(input.belongId ? { belongId: String(input.belongId) } : {}),
+        });
+        const hit = rows.find((row) => String(row.id) === String(input.id));
+        if (!hit)
+            throw new Error('条款列表中未找到被修改的条款');
+        return { id: hit.id, clauseNum: hit.clauseNum, clauseStatus: hit.clauseStatus };
+    },
+};
+const clauseDeleteSpec = {
+    method: 'POST',
+    path: `${INFO_BASE}/deletebyid`,
+    validate(input) {
+        requireId(input.id, '条款 id');
+    },
+    body: (input) => ({ id: String(input.id) }),
+    fingerprint: fingerprintFields(['id']),
+    preview: (input) => ({ action: '删除条款', id: input.id, clauseName: input.clauseName }),
+    async readback(_result, input, host) {
+        if (!input.clauseName)
+            return { skipped: '未提供 clauseName，删除接口对不存在的 id 也会返回成功，建议补 clauseName 复核' };
+        const rows = await listClauses(host, {
+            clauseName: input.clauseName,
+            ...(input.belongId ? { belongId: String(input.belongId) } : {}),
+        });
+        if (rows.some((row) => String(row.id) === String(input.id))) {
+            throw new Error('删除接口返回成功，但条款列表中仍能查到该条款');
+        }
+        return { id: input.id, removed: true };
+    },
+};
+const groupCreateSpec = {
+    method: 'POST',
+    path: `${GROUP_BASE}/save`,
+    validate(input) {
+        requireNonEmptyString(input.clauseName, 'clauseName', 200);
+        requireNonEmptyString(input.clauseContent, 'clauseContent', 4000);
+        if (!/^\d+(,\d+)*$/u.test(input.clauseContent)) {
+            throw contractValidationError('clause_content_invalid', 'clauseContent 必须是逗号分隔的条款 id 字符串（先用 contract.clause.browser 取 id）');
+        }
+        if (typeof input.belongSub !== 'string') {
+            throw contractValidationError('belong_sub_required', 'belongSub 必传字符串；未指定分部时传空字符串 ""，缺失服务端 500');
+        }
+        pairContractType(input);
+    },
+    body: (input) => bodyFrom(input, [
+        'clauseName', 'clauseNum', 'belongId', 'contractType', 'contractTypeName', 'clauseStatus', 'clauseContent', 'belongSub',
+    ], { belongSub: input.belongSub }),
+    fingerprint: fingerprintFields([
+        'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'belongSub', 'contractType', 'contractTypeName', 'clauseStatus',
+    ]),
+    preview: (input) => ({
+        action: '新增条款组',
+        clauseName: input.clauseName,
+        clauseIds: input.clauseContent,
+        belongSub: input.belongSub || '(不分部)',
+    }),
+    async readback(_result, input, host) {
+        // checkData 对确实存在的组名也会返回「不存在」，只能用 list 自行比对。
+        const rows = await listClauseGroups(host, { clauseName: input.clauseName });
+        const hit = rows.find((row) => (row.clauseName ?? row.name) === input.clauseName);
+        if (!hit)
+            throw new Error('条款组列表中未找到刚创建的条款组');
+        return { id: hit.id, clauseName: hit.clauseName ?? hit.name, clauseContent: hit.clauseContent };
+    },
+};
+const groupUpdateSpec = {
+    method: 'POST',
+    path: `${GROUP_BASE}/update`,
+    validate(input) {
+        requireId(input.id, '条款组 id');
+        requireNonEmptyString(input.clauseContent, 'clauseContent', 4000);
+        if (!/^\d+(,\d+)*$/u.test(input.clauseContent)) {
+            throw contractValidationError('clause_content_invalid', 'clauseContent 必须是逗号分隔的条款 id 字符串');
+        }
+        if (input.belongSub !== undefined && typeof input.belongSub !== 'string') {
+            throw contractValidationError('belong_sub_invalid', 'belongSub 必须是字符串；未指定分部时传空字符串 ""');
+        }
+        pairContractType(input);
+    },
+    body: (input) => bodyFrom(input, [
+        'id', 'clauseName', 'clauseNum', 'belongId', 'contractType', 'contractTypeName', 'clauseStatus', 'clauseContent', 'belongSub',
+    ]),
+    fingerprint: fingerprintFields([
+        'id', 'clauseName', 'clauseNum', 'clauseContent', 'belongId', 'belongSub', 'contractType', 'contractTypeName', 'clauseStatus',
+    ]),
+    preview: (input) => ({ action: '修改条款组', id: input.id, clauseName: input.clauseName, clauseIds: input.clauseContent }),
+    async readback(_result, input, host) {
+        if (!input.clauseName)
+            return { skipped: '未提供 clauseName，无法按名称回读' };
+        const rows = await listClauseGroups(host, { clauseName: input.clauseName });
+        const hit = rows.find((row) => String(row.id) === String(input.id));
+        if (!hit)
+            throw new Error('条款组列表中未找到被修改的条款组');
+        return { id: hit.id, clauseContent: hit.clauseContent };
+    },
+};
+const groupDeleteSpec = {
+    method: 'POST',
+    path: `${GROUP_BASE}/deletebyid`,
+    validate(input) {
+        requireId(input.id, '条款组 id');
+    },
+    body: (input) => ({ id: String(input.id) }),
+    fingerprint: fingerprintFields(['id']),
+    preview: (input) => ({ action: '删除条款组', id: input.id, clauseName: input.clauseName }),
+    async readback(_result, input, host) {
+        if (!input.clauseName)
+            return { skipped: '未提供 clauseName，删除接口对不存在的 id 也会返回成功' };
+        const rows = await listClauseGroups(host, { clauseName: input.clauseName });
+        if (rows.some((row) => String(row.id) === String(input.id))) {
+            throw new Error('删除接口返回成功，但条款组列表中仍能查到该条款组');
+        }
+        return { id: input.id, removed: true };
+    },
+};
+function writePair(name, applyName, spec) {
+    return [
+        new ClauseGatedOperation(name, new ContractWritePrepareOperation(name, applyName, spec)),
+        new ClauseGatedOperation(applyName, new ContractWriteApplyOperation(applyName, spec)),
+    ];
+}
+export const contractClauseLibraryOperations = [
+    contractClausePermissionOperation,
+    contractClauseTypeListOperation,
+    contractClauseCheckOperation,
+    contractClauseBrowserOperation,
+    contractClauseSubcompanyOperation,
+    ...writePair('contract.clause.category.create.prepare', 'contract.clause.category.create.apply', categoryCreateSpec),
+    ...writePair('contract.clause.category.update.prepare', 'contract.clause.category.update.apply', categoryUpdateSpec),
+    ...writePair('contract.clause.category.delete.prepare', 'contract.clause.category.delete.apply', categoryDeleteSpec),
+    ...writePair('contract.clause.create.prepare', 'contract.clause.create.apply', clauseCreateSpec),
+    ...writePair('contract.clause.update.prepare', 'contract.clause.update.apply', clauseUpdateSpec),
+    ...writePair('contract.clause.delete.prepare', 'contract.clause.delete.apply', clauseDeleteSpec),
+    ...writePair('contract.clause.group.create.prepare', 'contract.clause.group.create.apply', groupCreateSpec),
+    ...writePair('contract.clause.group.update.prepare', 'contract.clause.group.update.apply', groupUpdateSpec),
+    ...writePair('contract.clause.group.delete.prepare', 'contract.clause.group.delete.apply', groupDeleteSpec),
+];