weaver-work-cli 0.1.32 → 0.1.33

package/dist/shortcuts/ehr/operations/recruit-position.js

@@ -0,0 +1,367 @@
+import { createHash } from 'node:crypto';
+import { ehrConfirmationError, ehrValidationError } from '../errors.js';
+import { WRITE, SCHEMA_ID, ehrSuccess, schemaOf, } from './types.js';
+import { buildListBody, fetchListRows, } from './recruit.js';
+import { getDsOptions, getFormDataRecord, resolvePersonId, saveFormData, toSubmitDetails, } from './recruit-write.js';
+/**
+ * 职位 JD 建职位（口述 → JD 文本 → 建到招聘职位列表）。
+ *
+ * 口径来源：ehr 技能 recruit-generate-jd.mjs（真机验证）。两步提交与页面「保存」等价：
+ *   ① saveFormData(职位管理, dataDetails)  → formDataId
+ *   ② POST /api/recruit/position/v2/addPosition?formDataId=  → positionPostId
+ *
+ * 字段 id 全部运行时从环境缓存 fields[objId] 取（dataKey → fieldId），不写死；
+ * 单行文本用 content、多行文本用 dataText、关联/枚举用 dataOptions。
+ *
+ * 默认值策略（使必填校验通过，且跨环境稳定）：
+ *   - 招聘状态 status = 「招聘中」（ds/options 按名称解析）
+ *   - 招聘人数 recruit_count=1、薪酬月份数 number_of_pay_months=12
+ *   - 薪酬类型 salary_type=月薪、招聘方式 recruit_type=社会招聘（ds/options）
+ *   - 招聘负责人 / 用人经理 = 当前登录用户
+ *   - 职位属性/序列/学历/工作年限/工作地点/薪酬上下限/招聘流程 = **取环境内已有职位记录的值**
+ *     （"默认值 = 系统现成值"，保证引用有效；取不到则跳过并在摘要中标注）
+ */
+const TEXT_KEYS = ['position_name'];
+const MTEXT_KEYS = ['position_duty', 'work_request'];
+const ASSOC_KEYS = ['demand'];
+const PERSON_DEFAULT_KEYS = ['recr_principal', 'employ_manager'];
+const REF_COPY_KEYS = [
+    'position_nature',
+    'job_category',
+    'education',
+    'work_years',
+    'work_location',
+    'salary_min',
+    'salary_max',
+    'recruit_flow',
+];
+const TEXT_DEFAULTS = { recruit_count: '1', number_of_pay_months: '12' };
+const OPTION_DEFAULTS = { salary_type: '月薪', recruit_type: '社会招聘', status: '招聘中' };
+/** 显式入参 → 职位字段 dataKey 与取值类别（逐字段声明，避免用通用 payload 包裹）。 */
+const SET_FIELDS = [
+    { arg: 'education', key: 'education', kind: 'dict', label: '学历要求（按数据字典名称）' },
+    { arg: 'workYears', key: 'work_years', kind: 'dict', label: '工作年限（按数据字典名称）' },
+    { arg: 'jobCategory', key: 'job_category', kind: 'dict', label: '职位类别（按数据字典名称）' },
+    { arg: 'positionNature', key: 'position_nature', kind: 'dict', label: '职位属性（按数据字典名称）' },
+    { arg: 'salaryType', key: 'salary_type', kind: 'option', label: '薪酬类型（月薪/年薪等）' },
+    { arg: 'recruitType', key: 'recruit_type', kind: 'option', label: '招聘方式（社会招聘/校园招聘等）' },
+    { arg: 'recruitCount', key: 'recruit_count', kind: 'number', label: '招聘人数' },
+    { arg: 'salaryMin', key: 'salary_min', kind: 'number', label: '薪酬下限' },
+    { arg: 'salaryMax', key: 'salary_max', kind: 'number', label: '薪酬上限' },
+    { arg: 'numberOfPayMonths', key: 'number_of_pay_months', kind: 'number', label: '薪酬月数' },
+    { arg: 'recruitPrincipal', key: 'recr_principal', kind: 'person', label: '招聘负责人（按姓名）' },
+    { arg: 'employManager', key: 'employ_manager', kind: 'person', label: '用人经理（按姓名）' },
+    { arg: 'interviewer', key: 'interviewer', kind: 'person', label: '面试官（按姓名）' },
+    { arg: 'recruitHelper', key: 'recr_helper', kind: 'person', label: '招聘协助人（按姓名）' },
+];
+const SET_SCHEMA = Object.fromEntries(SET_FIELDS.map((f) => [f.arg, f.kind === 'number'
+        ? { type: 'string', description: `${f.label}（数字，按字符串传）` }
+        : { type: 'string', description: f.label }]));
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
+}
+function requireConfirm(args, action) {
+    if (args.confirm !== true) {
+        throw ehrConfirmationError(action, { hint: '重新调用时传入 confirm=true 与 prepare 返回的 continuation' });
+    }
+}
+async function requireCache(env) {
+    if (!env.recruitContext)
+        throw ehrValidationError('recruit_context_unavailable', '招聘上下文加载器未初始化');
+    return env.recruitContext.load(env.host);
+}
+/** 取一条已有职位记录，作为「关联表单型字段」的默认值来源（取不到就返回空，不编造 id）。 */
+async function fetchReferenceDetails(env, cache, objId, formId) {
+    const list = cache.lists.position;
+    if (!list?.listId)
+        return [];
+    try {
+        const body = buildListBody({
+            listId: list.listId,
+            cusMenuId: list.cusMenuId,
+            menuName: list.menuName || '招聘职位',
+            title: '招聘职位',
+            pageSize: 1,
+        });
+        const page = await fetchListRows(env.host, objId, list.listId, body);
+        const row = page.rows[0];
+        const recordId = row?.form_data_id || row?.id;
+        if (!recordId)
+            return [];
+        const record = await getFormDataRecord(env.host, formId, String(recordId), objId);
+        return toSubmitDetails(record.dataDetails);
+    }
+    catch {
+        return [];
+    }
+}
+async function buildPositionPlan(env, cache, args) {
+    const form = cache.forms.position_manage;
+    const objId = form?.objId;
+    const formId = form?.formId || objId;
+    if (!objId || !formId) {
+        throw ehrValidationError('position_form_unavailable', '当前环境未启用「招聘职位」功能（未解析到 position_manage 表单），无法建职位');
+    }
+    const fields = cache.fields[objId] || {};
+    const fid = (key) => fields[key];
+    for (const key of [...TEXT_KEYS, ...MTEXT_KEYS]) {
+        if (!fid(key)) {
+            throw ehrValidationError('recruit_field_missing', `职位管理缺少字段 ${key}（ds/fields 解析不到），无法建职位`);
+        }
+    }
+    const positionName = String(args.positionName ?? '').trim();
+    if (!positionName)
+        throw ehrValidationError('position_name_required', 'positionName 必填');
+    const data = new Map();
+    const put = (entry) => {
+        if (entry && entry.formField?.id)
+            data.set(String(entry.formField.id), entry);
+    };
+    const has = (key) => {
+        const id = fid(key);
+        return !!(id && data.has(String(id)));
+    };
+    // ① 核心字段
+    put({ formField: { id: fid('position_name') }, content: positionName });
+    const duty = typeof args.duty === 'string' ? args.duty : '';
+    const requirement = typeof args.requirement === 'string' ? args.requirement : '';
+    if (duty && fid('position_duty'))
+        put({ formField: { id: fid('position_duty') }, dataText: { content: duty } });
+    if (requirement && fid('work_request'))
+        put({ formField: { id: fid('work_request') }, dataText: { content: requirement } });
+    // ② 关联招聘需求（可选）
+    const applied = [];
+    const skipped = [];
+    if (args.demandId !== undefined && args.demandId !== null && args.demandId !== '') {
+        if (!fid('demand'))
+            throw ehrValidationError('recruit_field_missing', '职位管理缺少字段 demand，无法关联招聘需求');
+        const demandId = String(args.demandId).replace(/[^\d]/g, '');
+        if (!demandId)
+            throw ehrValidationError('demand_id_invalid', 'demandId 必须是数字 ID');
+        put({
+            formField: { id: fid('demand') },
+            dataOptions: [{ optionId: demandId, content: typeof args.demandName === 'string' && args.demandName ? args.demandName : demandId }],
+        });
+        applied.push(`demand=${demandId}`);
+    }
+    // ③ 显式入参覆盖（优先于默认值）
+    for (const field of SET_FIELDS) {
+        const raw = args[field.arg];
+        if (raw === undefined || raw === null || String(raw).trim() === '')
+            continue;
+        const value = String(raw).trim();
+        const fieldId = fid(field.key);
+        if (!fieldId) {
+            skipped.push(`${field.key}（职位表单无该字段）`);
+            continue;
+        }
+        if (field.kind === 'text' || field.kind === 'number') {
+            put({ formField: { id: fieldId }, content: value });
+            applied.push(`${field.key}=${value}`);
+        }
+        else if (field.kind === 'option') {
+            const options = await getDsOptions(env.host, objId, fieldId, cache.appId);
+            const optionId = options[value];
+            if (!optionId) {
+                skipped.push(`${field.key}=${value}（选项未匹配：${Object.keys(options).slice(0, 8).join('/')}…）`);
+                continue;
+            }
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(optionId), content: value }] });
+            applied.push(`${field.key}=${value}`);
+        }
+        else if (field.kind === 'dict') {
+            const ids = cache.dict.by_name[value] || [];
+            const unique = [...new Set(ids.map(String))];
+            if (unique.length !== 1) {
+                skipped.push(`${field.key}=${value}（字典${unique.length === 0 ? '无此项' : '同名多项，歧义'}，未写入）`);
+                continue;
+            }
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: unique[0], content: value }] });
+            applied.push(`${field.key}=${value}`);
+        }
+        else {
+            const personId = await resolvePersonId(env.host, fieldId, value);
+            if (!personId) {
+                skipped.push(`${field.key}=${value}（人员未匹配）`);
+                continue;
+            }
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(personId), content: value }] });
+            applied.push(`${field.key}=${value}`);
+        }
+    }
+    // ④ 默认值：枚举 / 数值 / 当前用户
+    for (const [key, name] of Object.entries(OPTION_DEFAULTS)) {
+        const fieldId = fid(key);
+        if (!fieldId || has(key))
+            continue;
+        const options = await getDsOptions(env.host, objId, fieldId, cache.appId);
+        const optionId = options[name];
+        if (optionId)
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(optionId), content: name }] });
+    }
+    for (const [key, value] of Object.entries(TEXT_DEFAULTS)) {
+        const fieldId = fid(key);
+        if (fieldId && !has(key))
+            put({ formField: { id: fieldId }, content: value });
+    }
+    const session = await env.host.getSession();
+    for (const key of PERSON_DEFAULT_KEYS) {
+        const fieldId = fid(key);
+        if (fieldId && !has(key) && session.userId) {
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: session.userId, content: '当前用户' }] });
+        }
+    }
+    // ⑤ 关联表单型字段：沿用在册职位的现值（引用有效性由系统保证）
+    const refDetails = await fetchReferenceDetails(env, cache, objId, formId);
+    const refMap = new Map();
+    for (const detail of refDetails) {
+        const id = detail?.formField?.id;
+        if (id)
+            refMap.set(String(id), detail);
+    }
+    const inherited = [];
+    const missingRef = [];
+    for (const key of REF_COPY_KEYS) {
+        const fieldId = fid(key);
+        if (!fieldId || has(key))
+            continue;
+        const ref = refMap.get(String(fieldId));
+        if (ref) {
+            put(ref);
+            inherited.push(key);
+        }
+        else {
+            missingRef.push(key);
+        }
+    }
+    const inverse = {};
+    for (const [dataKey, fieldId] of Object.entries(fields))
+        inverse[String(fieldId)] = dataKey;
+    return {
+        objId,
+        formId,
+        dataDetails: [...data.values()],
+        summary: {
+            positionName,
+            dutyLength: duty.length,
+            requirementLength: requirement.length,
+            fieldCount: data.size,
+            filledFields: [...data.keys()].map((id) => inverse[id] || id).sort(),
+            explicitApplied: applied,
+            explicitSkipped: skipped,
+            inheritedFromExistingPosition: inherited,
+            noReferenceValue: missingRef,
+            principalDefault: session.userId ? '当前登录用户' : '未解析到当前用户',
+        },
+    };
+}
+const positionCreatePrepare = {
+    name: 'ehr.recruit.position.create.prepare',
+    resource: 'recruit',
+    method: 'position.create.prepare',
+    action: 'ehr.recruit.position.create.prepare',
+    summary: '生成职位并建到招聘职位列表前的确认摘要：解析职位表单字段、套用默认值（状态/流程/负责人/关联字段），不写入任何数据',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        positionName: { type: 'string', maxLength: 120, description: '职位名称（必填）' },
+        duty: { type: 'string', maxLength: 20000, description: '岗位职责 / JD 正文（写入职位职责多行文本）' },
+        requirement: { type: 'string', maxLength: 20000, description: '任职要求（写入工作任职要求多行文本）' },
+        demandId: { ...SCHEMA_ID, description: '关联招聘需求 id（可选）' },
+        demandName: { type: 'string', maxLength: 200, description: '关联需求名称（仅用于摘要展示）' },
+        ...SET_SCHEMA,
+    }, { required: ['positionName'] }),
+    handler: async (args, env) => {
+        const cache = await requireCache(env);
+        const plan = await buildPositionPlan(env, cache, args);
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'ehr.recruit.position.create.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: { objId: plan.objId, formId: plan.formId, positionName: String(args.positionName).trim(), dataDetails: plan.dataDetails },
+            fingerprint: fingerprint({ objId: plan.objId, dataDetails: plan.dataDetails }),
+        }, 10 * 60 * 1000);
+        return ehrSuccess('ehr.recruit.position.create.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: { action: '生成职位JD并建职位（saveFormData → addPosition）', ...plan.summary },
+            willSubmit: { objId: plan.objId, formId: plan.formId, dataDetails: plan.dataDetails },
+            continuation,
+            expiresInSeconds: 600,
+        });
+    },
+};
+const positionCreateApply = {
+    name: 'ehr.recruit.position.create.apply',
+    resource: 'recruit',
+    method: 'position.create.apply',
+    action: 'ehr.recruit.position.create.apply',
+    summary: '执行建职位（saveFormData → addPosition）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        positionName: { type: 'string', maxLength: 120 },
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['positionName', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.position.create.apply');
+        const lease = await env.continuation.verify(args.continuation, 'ehr.recruit.position.create.apply');
+        const session = await env.host.getSession();
+        if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+            throw ehrValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+        }
+        const positionName = String(args.positionName ?? '').trim();
+        const payload = lease.payload || {};
+        if (payload.positionName !== positionName) {
+            throw ehrValidationError('target_changed', '职位名称与 prepare 时不一致，请重新执行 prepare');
+        }
+        const cache = await requireCache(env);
+        // ① 保存职位表单
+        const formDataId = await saveFormData(env.host, {
+            appId: cache.appId,
+            formId: String(payload.formId),
+            objId: String(payload.objId),
+            name: `职位管理-${positionName}`,
+            dataDetails: payload.dataDetails || [],
+        });
+        if (!formDataId) {
+            throw ehrValidationError('save_failed', 'saveFormData 未返回 formDataId，职位未创建');
+        }
+        // ② 提交生成职位（与页面「保存」的第二步等价）
+        const response = (await env.host.request({
+            path: `/api/recruit/position/v2/addPosition?formDataId=${encodeURIComponent(formDataId)}`,
+            method: 'POST',
+            operation: 'ehr.recruit.position.create.apply',
+        }));
+        const data = response?.data || {};
+        const positionPostId = data.positionPostId ? String(data.positionPostId) : '';
+        const created = response?.status !== false && !!positionPostId;
+        const list = cache.lists.position;
+        const baseUrl = session.baseUrl.replace(/\/+$/, '');
+        const cardUrl = `${baseUrl}/sp/ebdfpage/card/0/${payload.objId}/${formDataId}`;
+        const listLocateUrl = list?.listId
+            ? `${baseUrl}/sp/ebdfpage/list/${list.listId}/card/0/${payload.objId}/${formDataId}/${list.listId}?id=${formDataId}&openSource=field&openSourceId=${formDataId}`
+            : null;
+        if (!created) {
+            throw ehrValidationError('position_create_failed', `职位表单已保存（formDataId=${formDataId}），但 addPosition 未返回职位 id：${response?.msg || '未知原因'}；请到职位管理核对后再决定是否重试`);
+        }
+        return ehrSuccess('ehr.recruit.position.create.apply', {
+            result: 'success',
+            formDataId,
+            positionPostId,
+            rpaChecked: data.checkRpa === undefined ? null : !!data.checkRpa,
+            rpaValidMsg: data.rpaValidMsg || null,
+            positionName,
+            cardUrl,
+            listLocateUrl,
+        });
+    },
+};
+export const recruitPositionOperations = [
+    positionCreatePrepare,
+    positionCreateApply,
+];

package/dist/shortcuts/ehr/operations/recruit-stats.js

@@ -0,0 +1,133 @@
+import { ehrValidationError } from '../errors.js';
+import { READ, ehrSuccess, schemaOf, } from './types.js';
+import { buildListBody, fetchListRows, } from './recruit.js';
+/**
+ * 招聘工作统计：各业务模块记录数（基于稳定列表接口聚合）。
+ *
+ * 口径来源：ehr 技能 recruit-stats.mjs（真机验证）。
+ * 计数降级三态（绝不输出假值）：
+ *   ① 计数接口 getListDataCount 可用 → total 精确；
+ *   ② 计数不可用、但分页翻到末页（页内行数 < pageSize）→ total = 累计行数（精确）；
+ *   ③ 计数不可用、且达扫描上限仍满页 → total = null（总数不可知），附 note。
+ * 明确不做：nchart 漏斗看板与 EDC 报表（需页面 compId/sheetId 配置，跨环境不稳定）。
+ */
+const STATS_MODULES = {
+    talent: { listKey: 'talent', formType: 'talent_pool', title: '人才库' },
+    demand: { listKey: 'demand', formType: 'demand_manage', title: '招聘需求' },
+    position: { listKey: 'position', formType: 'position_manage', title: '招聘职位' },
+    entry: { listKey: 'entry', formType: 'entry_manage', title: '入职管理' },
+    offer: { listKey: 'offer', formType: 'offer', title: '录用管理' },
+    interview: {
+        listKey: 'interview',
+        formType: 'interview_plan',
+        title: '面试安排',
+        note: '面试管理列表可能按页面配置只显示近期记录，计数仅供量级参考',
+    },
+};
+const DEFAULT_MODULES = ['talent', 'demand', 'position', 'entry', 'offer'];
+async function countModule(env, cache, key, pageSize, maxPages) {
+    const cfg = STATS_MODULES[key];
+    const list = cache.lists[cfg.listKey];
+    const objId = cache.forms[cfg.formType]?.objId;
+    if (!list?.listId || !objId) {
+        return {
+            key,
+            module: cfg.title,
+            available: false,
+            total: null,
+            totalExact: false,
+            scannedRows: 0,
+            note: '当前环境未启用该功能菜单（未找到列表或表单），已跳过',
+        };
+    }
+    const baseBody = buildListBody({
+        listId: list.listId,
+        cusMenuId: list.cusMenuId,
+        menuName: list.menuName || cfg.title,
+        title: cfg.title,
+        pageSize,
+    });
+    let scanned = 0;
+    let total = null;
+    let totalExact = false;
+    let note = cfg.note;
+    for (let current = 1; current <= maxPages; current++) {
+        const page = await fetchListRows(env.host, objId, list.listId, { ...baseBody, current, pageSize });
+        // ① 计数接口可用（total 为数字且精确）→ 直接用，不必翻页
+        if (current === 1 && page.total !== null && page.totalExact) {
+            total = page.total;
+            totalExact = true;
+            break;
+        }
+        scanned += page.rows.length;
+        // ② 页内行数 < pageSize 即已到末页 → 累计行数就是总数
+        if (page.rows.length < pageSize) {
+            total = scanned;
+            totalExact = true;
+            break;
+        }
+    }
+    // ③ 达上限仍未取完 → 总数不可知（不编造 0 或估计值）
+    if (total === null) {
+        totalExact = false;
+        note = `计数接口不可用且达扫描上限（${maxPages} 页 × ${pageSize} 行）仍未取完，总数不可知；可调大 pageSize/maxPages 重试`;
+    }
+    return { key, module: cfg.title, available: true, total, totalExact, scannedRows: scanned, ...(note ? { note } : {}) };
+}
+const recruitStats = {
+    name: 'ehr.recruit.stats',
+    resource: 'recruit',
+    method: 'stats',
+    action: 'ehr.recruit.stats',
+    summary: '招聘工作统计：按模块统计记录数（人才库/招聘需求/招聘职位/入职管理/录用管理/面试安排），计数不可用时如实标"总数不可知"',
+    capability: 'recruit',
+    risk: READ,
+    inputSchema: schemaOf({
+        modules: {
+            type: 'array',
+            items: { type: 'string', enum: Object.keys(STATS_MODULES) },
+            uniqueItems: true,
+            description: `要统计的模块，默认 ${DEFAULT_MODULES.join(',')}`,
+        },
+        pageSize: { type: 'integer', minimum: 1, maximum: 200, description: '单页行数，默认 100（计数接口不可用时用于分页实探）' },
+        maxPages: { type: 'integer', minimum: 1, maximum: 20, description: '最多翻页数，默认 5' },
+    }),
+    handler: async (args, env) => {
+        if (!env.recruitContext) {
+            throw ehrValidationError('recruit_context_unavailable', '招聘上下文加载器未初始化');
+        }
+        const requested = args.modules === undefined
+            ? DEFAULT_MODULES
+            : (Array.isArray(args.modules) ? args.modules.map(String) : []);
+        if (!requested.length) {
+            throw ehrValidationError('modules_required', `modules 必须是非空数组，可选值：${Object.keys(STATS_MODULES).join(' / ')}`);
+        }
+        for (const key of requested) {
+            if (!STATS_MODULES[key]) {
+                throw ehrValidationError('enum_invalid', `modules 含不支持的值：${key}（可选 ${Object.keys(STATS_MODULES).join(' / ')}）`);
+            }
+        }
+        const pageSize = Number.isInteger(args.pageSize) ? Number(args.pageSize) : 100;
+        const maxPages = Number.isInteger(args.maxPages) ? Number(args.maxPages) : 5;
+        const cache = await env.recruitContext.load(env.host);
+        // 模块间并发；每个模块内部翻页串行（服务端计数不可信，只能靠分页递进）
+        const modules = await Promise.all(requested.map((key) => countModule(env, cache, key, pageSize, maxPages)));
+        const known = modules.filter((m) => m.available && m.total !== null);
+        const unknown = modules.filter((m) => m.available && m.total === null);
+        const unavailable = modules.filter((m) => !m.available);
+        return ehrSuccess('ehr.recruit.stats', {
+            modules,
+            summary: {
+                knownTotal: known.reduce((sum, m) => sum + m.total, 0),
+                knownModules: known.map((m) => m.key),
+                unknownModules: unknown.map((m) => m.key),
+                unavailableModules: unavailable.map((m) => m.key),
+                note: unknown.length
+                    ? '存在总数不可知的模块（见对应 note），未计入 knownTotal'
+                    : undefined,
+            },
+        }, { pageSize, maxPages });
+    },
+};
+export const recruitStatsOperations = [recruitStats];
+export { STATS_MODULES as RECRUIT_STATS_MODULES };

package/dist/shortcuts/ehr/operations/recruit-write.js

@@ -29,7 +29,7 @@ async function requireRecruitCache(env) {
     return env.recruitContext.load(env.host);
 }
 /** 建前查重：按手机号搜人才库（total 恒 0 平台缺陷，以 data.data[] 非空为准）。 */
-async function checkDuplicateByMobile(env, cache, mobile) {
+export async function checkDuplicateByMobile(env, cache, mobile) {
     const talent = cache.lists.talent;
     const objId = cache.forms.talent_pool?.objId;
     if (!talent?.listId || !objId) {
@@ -158,7 +158,7 @@ async function runEsb(host, objId, dataIds, esbActionIds) {
     return response?.data || {};
 }
 /** ds/options 运行时解析枚举（面试方式/轮次/结果等）：name → optionId */
-async function getDsOptions(host, objId, fieldId, groupId) {
+export async function getDsOptions(host, objId, fieldId, groupId) {
     const response = (await host.request({
         path: '/api/ebuilder/common/ds/options',
         query: { fieldName: fieldId, objId, sourceType: 'FORM', groupId },
@@ -171,7 +171,7 @@ async function getDsOptions(host, objId, fieldId, groupId) {
     return map;
 }
 /** 人员名称 → userId（门户字段 browser/complete/resource） */
-async function resolvePersonId(host, fieldId, keyword) {
+export async function resolvePersonId(host, fieldId, keyword) {
     const response = (await host.request({
         path: '/api/ebuilder/form/common/browser/complete/resource',
         body: { formParam: { fieldId, searchValue: keyword }, 'formParam.fieldId': fieldId, 'formParam.searchValue': keyword },
@@ -180,15 +180,8 @@ async function resolvePersonId(host, fieldId, keyword) {
     const first = list[0];
     return first ? String(first.id || first.value || '') || null : null;
 }
-/** 安排面试专用：面试计划门户字段 id 映射（talent/candidate_manage/interviewer/position...） */
-async function getInterviewPortalFieldIds(host) {
-    const response = (await host.request({
-        path: '/api/recruit/candidate/getFieldIdsForInterview',
-    }));
-    return response?.data || {};
-}
 /** saveFormData：新建（rightType 0）或更新（rightType 2，带 formDataId/updateTimeStamp/layoutId） */
-async function saveFormData(host, params) {
+export async function saveFormData(host, params) {
     const layoutId = params.layoutId || params.formId; // getFormLayout GET 405 不可靠，新建回退 formId（与 mjs 一致）
     const customParam = {
         objId: params.objId,
@@ -222,7 +215,7 @@ async function saveFormData(host, params) {
     return String(response?.data?.id || '');
 }
 /** 取记录当前数据（updateTimeStamp 乐观锁 + dataDetails 全字段 + 编辑布局 id） */
-async function getFormDataRecord(host, formId, dataId, objId) {
+export async function getFormDataRecord(host, formId, dataId, objId) {
     const response = (await host.request({
         path: `/api/ebuilder/form/form/core/getFormDataAndLayout?formId=${formId}&dataId=${dataId}`,
         method: 'POST',
@@ -242,7 +235,7 @@ async function getFormDataRecord(host, formId, dataId, objId) {
     };
 }
 /** getFormDataAndLayout 返回的 dataDetails → saveFormData 可提交结构 */
-function toSubmitDetails(details) {
+export function toSubmitDetails(details) {
     const out = [];
     for (const item of details || []) {
         const fieldId = item?.fieldId || item?.formField?.id;
@@ -546,11 +539,10 @@ async function buildInterviewPlan(env, cache, args) {
     const objId = cacheObjId(cache, 'interview_plan', '面试计划表单');
     const formId = cacheFormId(cache, 'interview_plan');
     const fields = cache.fields[objId] || {};
-    const portalFields = await getInterviewPortalFieldIds(host);
-    const fieldIdOf = (key) => fields[key] || portalFields[key] || '';
+    const fieldIdOf = (key) => fields[key] || '';
     for (const key of INTERVIEW_DATAKEYS) {
         if (!fieldIdOf(key)) {
-            throw ehrValidationError('recruit_field_missing', `面试计划表单缺少字段 ${key}（ds/fields 与门户字段均解析不到）`);
+            throw ehrValidationError('recruit_field_missing', `面试计划表单缺少字段 ${key}（环境缓存 ds/fields 未解析到，请重建环境缓存后重试）`);
         }
     }
     const typeMap = await getDsOptions(host, objId, fieldIdOf('interview_type'), cache.appId);