612 lines
20 KiB
JavaScript
612 lines
20 KiB
JavaScript
const fs = require('fs')
|
||
const path = require('path')
|
||
const { spawnSync } = require('child_process')
|
||
|
||
const XLSX = require(path.resolve(__dirname, '../../frontend/node_modules/xlsx'))
|
||
const ExcelJS = require(path.resolve(__dirname, '../node_modules/exceljs'))
|
||
const {
|
||
mergeCandidateRowsWithSourceCodes,
|
||
normalizeLookupKey,
|
||
normalizeText,
|
||
resolveSheet2LocationMatch
|
||
} = require('./sheet2PublicSupplementUtils')
|
||
|
||
const DEFAULT_SOURCE_WORKBOOK = path.resolve(__dirname, '../../docs/总表待导入.xlsx')
|
||
const DEFAULT_SOURCE_SHEET = 'Sheet2'
|
||
const DEFAULT_CANDIDATE_WORKBOOK = path.resolve(
|
||
__dirname,
|
||
'../../docs/总表待导入-Sheet2_严格可安全补导候选-2026-03-27.xlsx'
|
||
)
|
||
const OUTPUT_ROOT = path.resolve(__dirname, '../../temp_migration_output')
|
||
const DOCS_ROOT = path.resolve(__dirname, '../../docs')
|
||
const DEFAULT_OUTPUT_WORKBOOK_BASENAME = '总表待导入-Sheet2_公共设备补导分流-2026-03-27.xlsx'
|
||
|
||
const REMOTE_NODE_COMMAND = 'cd /opt/equipment-management && docker exec -i equipment-backend node'
|
||
|
||
const DEPARTMENT_ALIASES = {
|
||
'3D视觉（广东）': '视觉中心',
|
||
'3D视觉（常州）': '视觉中心',
|
||
事业一部: '运营中心A',
|
||
事业二部: '运营中心A',
|
||
事业三部: '运营中心A',
|
||
事业四部: '运营中心A',
|
||
策划一部: '品牌策划中心',
|
||
策划二部: '品牌策划中心',
|
||
策划三部: '品牌策划中心',
|
||
策划四部: '品牌策划中心',
|
||
策划五部: '品牌策划中心',
|
||
策划六部: '品牌策划中心',
|
||
客服二部: '客服中心',
|
||
客服三部: '客服中心',
|
||
客服四部: '客服中心',
|
||
客服五部: '客服中心',
|
||
客服六部: '客服中心',
|
||
品牌营销策划中心: '品牌策划中心',
|
||
品牌创意视觉中心: '视觉中心',
|
||
品牌供应链中心: '供应链中心',
|
||
智管信息中心: '效率部（懂业务的技术部）',
|
||
总账组: '财务中心',
|
||
结算组: '财务中心',
|
||
视觉一部: '视觉中心',
|
||
视觉二部: '视觉中心',
|
||
视觉三部: '视觉中心',
|
||
视觉四部: '视觉中心',
|
||
视觉五部: '视觉中心',
|
||
视觉六部: '视觉中心',
|
||
'基本盘 采购部': '供应链中心',
|
||
'基本盘 核价组': '供应链中心',
|
||
产品视觉中心: '视觉中心',
|
||
分销外贸: '外贸部'
|
||
}
|
||
|
||
const PUBLIC_STATUS_MAP = {
|
||
在用: '可用',
|
||
闲置: '可用'
|
||
}
|
||
|
||
const buildTimestampLabel = () =>
|
||
new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19)
|
||
|
||
const requireArgValue = (args, index, argumentName) => {
|
||
const value = args[index + 1]
|
||
if (!value || String(value).startsWith('--')) {
|
||
throw new Error(`${argumentName} 缺少参数值`)
|
||
}
|
||
return value
|
||
}
|
||
|
||
const parseArgs = (args = process.argv.slice(2)) => {
|
||
const options = {
|
||
sourceWorkbook: DEFAULT_SOURCE_WORKBOOK,
|
||
sourceSheet: DEFAULT_SOURCE_SHEET,
|
||
candidateWorkbook: DEFAULT_CANDIDATE_WORKBOOK,
|
||
outputWorkbook: path.join(DOCS_ROOT, DEFAULT_OUTPUT_WORKBOOK_BASENAME),
|
||
assetCodes: [],
|
||
plinkPath: '',
|
||
sshHost: '',
|
||
sshHostkey: '',
|
||
sshPassword: ''
|
||
}
|
||
|
||
for (let index = 0; index < args.length; index += 1) {
|
||
const arg = args[index]
|
||
if (arg === '--source-workbook') {
|
||
options.sourceWorkbook = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--source-sheet') {
|
||
options.sourceSheet = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--candidate-workbook') {
|
||
options.candidateWorkbook = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--output-workbook') {
|
||
options.outputWorkbook = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--asset-codes') {
|
||
options.assetCodes = String(requireArgValue(args, index, arg))
|
||
.split(/[,\s]+/)
|
||
.map((item) => normalizeText(item).toUpperCase())
|
||
.filter(Boolean)
|
||
index += 1
|
||
} else if (arg === '--plink-path') {
|
||
options.plinkPath = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--ssh-host') {
|
||
options.sshHost = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--ssh-hostkey') {
|
||
options.sshHostkey = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else if (arg === '--ssh-password') {
|
||
options.sshPassword = requireArgValue(args, index, arg)
|
||
index += 1
|
||
} else {
|
||
throw new Error(`不支持的参数: ${arg}`)
|
||
}
|
||
}
|
||
|
||
return options
|
||
}
|
||
|
||
const resolveRemoteConnection = (options, env = process.env) => {
|
||
const connection = {
|
||
plinkPath: normalizeText(options.plinkPath || env.FIXED_ASSET_PLINK_PATH),
|
||
sshHost: normalizeText(options.sshHost || env.FIXED_ASSET_SSH_HOST),
|
||
sshHostkey: normalizeText(options.sshHostkey || env.FIXED_ASSET_SSH_HOSTKEY),
|
||
sshPassword: options.sshPassword || env.FIXED_ASSET_SSH_PASSWORD || ''
|
||
}
|
||
const missing = []
|
||
|
||
if (!connection.plinkPath) missing.push('FIXED_ASSET_PLINK_PATH / --plink-path')
|
||
if (!connection.sshHost) missing.push('FIXED_ASSET_SSH_HOST / --ssh-host')
|
||
if (!connection.sshHostkey) missing.push('FIXED_ASSET_SSH_HOSTKEY / --ssh-hostkey')
|
||
if (!connection.sshPassword) missing.push('FIXED_ASSET_SSH_PASSWORD / --ssh-password')
|
||
|
||
if (missing.length > 0) {
|
||
throw new Error(`缺少固定资产远程连接参数：${missing.join('、')}。未发起网络连接。`)
|
||
}
|
||
|
||
return connection
|
||
}
|
||
|
||
const resolvePathArg = (value) => {
|
||
const normalized = normalizeText(value)
|
||
if (!normalized) {
|
||
return ''
|
||
}
|
||
return path.isAbsolute(normalized) ? normalized : path.resolve(process.cwd(), normalized)
|
||
}
|
||
|
||
const ensureOutputDir = () => {
|
||
const timestamp = buildTimestampLabel()
|
||
const outputDir = path.join(OUTPUT_ROOT, `sheet2_public_dry_run_${timestamp}`)
|
||
fs.mkdirSync(outputDir, { recursive: true })
|
||
return outputDir
|
||
}
|
||
|
||
const writeJson = (filePath, value) => {
|
||
fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`)
|
||
}
|
||
|
||
const writeWorkbook = async (filePath, sheets) => {
|
||
const workbook = new ExcelJS.Workbook()
|
||
workbook.creator = 'Codex'
|
||
workbook.created = new Date()
|
||
|
||
for (const sheet of sheets) {
|
||
const worksheet = workbook.addWorksheet(sheet.name)
|
||
const rows = Array.isArray(sheet.rows) && sheet.rows.length ? sheet.rows : [{}]
|
||
const headers = [...new Set(rows.flatMap((row) => Object.keys(row)))]
|
||
worksheet.columns = headers.map((header) => ({
|
||
header,
|
||
key: header,
|
||
width: Math.min(Math.max(header.length + 6, 14), 40)
|
||
}))
|
||
rows.forEach((row) => worksheet.addRow(row))
|
||
worksheet.getRow(1).font = { bold: true, name: 'Arial' }
|
||
worksheet.views = [{ state: 'frozen', ySplit: 1 }]
|
||
worksheet.eachRow((row) => {
|
||
row.font = { name: 'Arial' }
|
||
row.alignment = { vertical: 'middle', wrapText: true }
|
||
})
|
||
}
|
||
|
||
await workbook.xlsx.writeFile(filePath)
|
||
}
|
||
|
||
const resolveAvailableWorkbookPath = (preferredPath) => {
|
||
const resolvedPreferredPath = resolvePathArg(preferredPath)
|
||
if (!resolvedPreferredPath) {
|
||
throw new Error('输出工作簿路径不能为空')
|
||
}
|
||
|
||
const workbookDir = path.dirname(resolvedPreferredPath)
|
||
const extension = path.extname(resolvedPreferredPath) || '.xlsx'
|
||
const baseName = path.basename(resolvedPreferredPath, extension)
|
||
const timestampedPath = path.join(workbookDir, `${baseName}-${buildTimestampLabel()}${extension}`)
|
||
|
||
try {
|
||
const fd = fs.openSync(resolvedPreferredPath, 'a')
|
||
fs.closeSync(fd)
|
||
return resolvedPreferredPath
|
||
} catch (error) {
|
||
if (error && (error.code === 'EBUSY' || error.code === 'EPERM')) {
|
||
return timestampedPath
|
||
}
|
||
throw error
|
||
}
|
||
}
|
||
|
||
const loadSourceRowMap = (sourceWorkbookPath, sourceSheetName) => {
|
||
const workbook = XLSX.readFile(sourceWorkbookPath, { raw: false })
|
||
const sheet = workbook.Sheets[sourceSheetName]
|
||
if (!sheet) {
|
||
throw new Error(`未找到源工作表: ${sourceSheetName}`)
|
||
}
|
||
|
||
const matrix = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: '' })
|
||
if (!matrix.length) {
|
||
return new Map()
|
||
}
|
||
|
||
const headerIndex = new Map()
|
||
matrix[0].forEach((header, index) => {
|
||
headerIndex.set(normalizeText(header), index)
|
||
})
|
||
|
||
const codeColumnIndex = headerIndex.get('资产编码')
|
||
if (codeColumnIndex === undefined) {
|
||
throw new Error('源工作表缺少“资产编码”列')
|
||
}
|
||
|
||
const rowMap = new Map()
|
||
for (let rowIndex = 1; rowIndex < matrix.length; rowIndex += 1) {
|
||
const row = matrix[rowIndex]
|
||
const code = normalizeText(row[codeColumnIndex]).toUpperCase()
|
||
if (code && !rowMap.has(code)) {
|
||
rowMap.set(code, rowIndex + 1)
|
||
}
|
||
}
|
||
|
||
return rowMap
|
||
}
|
||
|
||
const loadSourceRows = (sourceWorkbookPath, sourceSheetName) => {
|
||
const workbook = XLSX.readFile(sourceWorkbookPath, { raw: false })
|
||
const sheet = workbook.Sheets[sourceSheetName]
|
||
if (!sheet) {
|
||
throw new Error(`未找到源工作表: ${sourceSheetName}`)
|
||
}
|
||
|
||
return XLSX.utils.sheet_to_json(sheet, { defval: '' }).map((row) => ({
|
||
...row,
|
||
来源工作表: normalizeText(row.来源工作表) || sourceSheetName
|
||
}))
|
||
}
|
||
|
||
const loadCandidateRows = (candidateWorkbookPath) => {
|
||
const workbook = XLSX.readFile(candidateWorkbookPath, { raw: false })
|
||
const sheet = workbook.Sheets[workbook.SheetNames[0]]
|
||
return XLSX.utils.sheet_to_json(sheet, { defval: '' })
|
||
}
|
||
|
||
const fetchLiveRefs = (connection) => {
|
||
const script = `
|
||
let PrismaClient
|
||
try { ({ PrismaClient } = require('@prisma/client')) } catch { ({ PrismaClient } = require('/app/node_modules/@prisma/client')) }
|
||
const prisma = new PrismaClient()
|
||
;(async () => {
|
||
const [assetTypes, departments, locations] = await Promise.all([
|
||
prisma.assetType.findMany({
|
||
where: { status: 'active' },
|
||
select: { id: true, name: true, short_name: true },
|
||
orderBy: { name: 'asc' }
|
||
}),
|
||
prisma.department.findMany({
|
||
where: { status: 'active', source_system: 'ding_hr_business' },
|
||
select: { id: true, name: true },
|
||
orderBy: { name: 'asc' }
|
||
}),
|
||
prisma.storageLocation.findMany({
|
||
where: { status: 'active' },
|
||
select: { id: true, name: true },
|
||
orderBy: { name: 'asc' }
|
||
})
|
||
])
|
||
|
||
console.log(JSON.stringify({ assetTypes, departments, locations }))
|
||
await prisma.$disconnect()
|
||
})().catch(async (error) => {
|
||
console.error(error && error.stack ? error.stack : String(error))
|
||
try { await prisma.$disconnect() } catch {}
|
||
process.exit(1)
|
||
})
|
||
`
|
||
|
||
const result = spawnSync(
|
||
connection.plinkPath,
|
||
[
|
||
'-batch',
|
||
'-ssh',
|
||
'-hostkey',
|
||
connection.sshHostkey,
|
||
'-pw',
|
||
connection.sshPassword,
|
||
connection.sshHost,
|
||
REMOTE_NODE_COMMAND
|
||
],
|
||
{
|
||
encoding: 'utf8',
|
||
input: script,
|
||
maxBuffer: 32 * 1024 * 1024,
|
||
windowsHide: true
|
||
}
|
||
)
|
||
|
||
if (result.error) {
|
||
throw new Error('无法启动远程连接工具，请检查 FIXED_ASSET_PLINK_PATH / --plink-path。')
|
||
}
|
||
|
||
if (result.status !== 0) {
|
||
throw new Error('读取线上基础数据失败，请检查连接参数、远程服务状态和服务器日志。')
|
||
}
|
||
|
||
const stdout = normalizeText(result.stdout)
|
||
if (!stdout) {
|
||
throw new Error('线上基础数据返回为空')
|
||
}
|
||
|
||
try {
|
||
return JSON.parse(stdout)
|
||
} catch {
|
||
throw new Error('线上基础数据返回格式无效')
|
||
}
|
||
}
|
||
|
||
const buildImportDescription = (row, sourceRow) => {
|
||
const parts = [
|
||
['source_workbook', 'docs/总表待导入.xlsx'],
|
||
['source_sheet', 'Sheet2'],
|
||
['source_row', sourceRow || ''],
|
||
['source_status', normalizeText(row['当前状态'])],
|
||
['raw_department', normalizeText(row['部门'])],
|
||
['raw_location', normalizeText(row['地址'])],
|
||
['raw_asset_category', normalizeText(row['资产分类'])]
|
||
]
|
||
|
||
return parts.map(([key, value]) => `${key}=${String(value).replace(/;/g, ',')}`).join('; ')
|
||
}
|
||
|
||
const buildReadyImportPayload = (rows) =>
|
||
rows.map((row) => ({
|
||
legacyCode: row.资产编码,
|
||
equipmentName: row.资产名称,
|
||
equipmentModel: row.规格型号 || null,
|
||
equipmentType: row.资产名称,
|
||
departmentName: row.系统归并部门 || '',
|
||
storageLocationName: row.系统归并地址 || '',
|
||
systemStatus: row.系统建议状态,
|
||
purchaseDate: null,
|
||
supplier: '',
|
||
unitPrice: 0,
|
||
description: row.导入备注
|
||
}))
|
||
|
||
const createRowContext = (liveRefs) => {
|
||
const departmentByName = new Map(
|
||
liveRefs.departments.map((item) => [normalizeLookupKey(item.name), item])
|
||
)
|
||
const locationByName = new Map(
|
||
liveRefs.locations.map((item) => [normalizeLookupKey(item.name), item])
|
||
)
|
||
|
||
return { departmentByName, locationByName }
|
||
}
|
||
|
||
const classifySingleRow = (rawRow, sourceRowMap, rowContext) => {
|
||
const { departmentByName, locationByName } = rowContext
|
||
|
||
const assetCode = normalizeText(rawRow['资产编码']).toUpperCase()
|
||
const assetName = normalizeText(rawRow['资产名称'])
|
||
const rawDepartment = normalizeText(rawRow['部门'])
|
||
const resolvedDepartment = DEPARTMENT_ALIASES[rawDepartment] || rawDepartment
|
||
const departmentMatch = resolvedDepartment
|
||
? departmentByName.get(normalizeLookupKey(resolvedDepartment)) || null
|
||
: null
|
||
|
||
const rawLocation = normalizeText(rawRow['地址'])
|
||
const locationMatch = resolveSheet2LocationMatch(rawLocation, locationByName)
|
||
|
||
const rawStatus = normalizeText(rawRow['当前状态'])
|
||
const systemStatus = PUBLIC_STATUS_MAP[rawStatus] || ''
|
||
|
||
const sourceRow = sourceRowMap.get(assetCode) || ''
|
||
const baseRow = {
|
||
来源工作表: normalizeText(rawRow['来源工作表']) || 'Sheet2',
|
||
源数据行号: sourceRow,
|
||
资产编码: assetCode,
|
||
资产名称: assetName,
|
||
当前状态: rawStatus,
|
||
系统建议状态: systemStatus,
|
||
资产分类: normalizeText(rawRow['资产分类']),
|
||
部门: rawDepartment,
|
||
系统归并部门: departmentMatch?.name || resolvedDepartment,
|
||
地址: rawLocation,
|
||
系统归并地址: locationMatch.match?.name || locationMatch.normalizedValue,
|
||
地址归并规则: locationMatch.rule || '',
|
||
规格型号: normalizeText(rawRow['规格型号']),
|
||
导入备注: buildImportDescription(rawRow, sourceRow)
|
||
}
|
||
|
||
const reasons = []
|
||
if (!departmentMatch) {
|
||
reasons.push(`部门未匹配：${rawDepartment || '(空)'}`)
|
||
}
|
||
if (!locationMatch.match) {
|
||
reasons.push(`地址未匹配：${rawLocation || '(空)'}`)
|
||
}
|
||
if (!systemStatus) {
|
||
reasons.push(`状态无法自动映射：${rawStatus || '(空)'}`)
|
||
}
|
||
|
||
return { baseRow, reasons }
|
||
}
|
||
|
||
const classifyRows = (candidateRows, sourceRowMap, liveRefs) => {
|
||
const rowContext = createRowContext(liveRefs)
|
||
const readyRows = []
|
||
const pendingRows = []
|
||
|
||
for (const rawRow of candidateRows) {
|
||
const { baseRow, reasons } = classifySingleRow(rawRow, sourceRowMap, rowContext)
|
||
|
||
if (!reasons.length) {
|
||
readyRows.push(baseRow)
|
||
continue
|
||
}
|
||
|
||
pendingRows.push({
|
||
...baseRow,
|
||
待核对原因: reasons.join('；'),
|
||
建议处理: reasons.some((item) => item.startsWith('地址未匹配'))
|
||
? '先确认应归并到哪个系统地址，再导入'
|
||
: '先确认状态或部门后再导入'
|
||
})
|
||
}
|
||
|
||
return { readyRows, pendingRows }
|
||
}
|
||
|
||
const buildDuplicatePendingRows = (duplicateSourceCodes, sourceRowMap, liveRefs) => {
|
||
const rowContext = createRowContext(liveRefs)
|
||
|
||
return duplicateSourceCodes.map((item) => {
|
||
const firstRow = item.rows[0] || {}
|
||
const { baseRow } = classifySingleRow(firstRow, sourceRowMap, rowContext)
|
||
return {
|
||
...baseRow,
|
||
待核对原因: '同一资产编码在 Sheet2 内对应了不同设备信息，不能自动判断。',
|
||
建议处理: '同一编码对应了多条不同设备信息，先确认哪条才是真实记录'
|
||
}
|
||
})
|
||
}
|
||
|
||
const buildSummaryRows = ({
|
||
total,
|
||
ready,
|
||
pending,
|
||
addressPending,
|
||
otherPending,
|
||
liveRefs,
|
||
explicitCodeCount,
|
||
explicitMissingCodeCount,
|
||
duplicatePendingCount
|
||
}) => [
|
||
{ 项目: '候选总数', 说明: total },
|
||
{ 项目: '可直接补录', 说明: ready },
|
||
{ 项目: '待人工核对', 说明: pending },
|
||
{ 项目: '其中地址待核对', 说明: addressPending },
|
||
{ 项目: '其中其他待核对', 说明: otherPending },
|
||
{ 项目: '本次显式补回编码数', 说明: explicitCodeCount },
|
||
{ 项目: '显式编码仍未在源表找到', 说明: explicitMissingCodeCount },
|
||
{ 项目: '显式编码重复冲突数', 说明: duplicatePendingCount },
|
||
{ 项目: '状态映射规则', 说明: '在用/闲置 -> 系统“可用”；其余状态不自动导入' },
|
||
{ 项目: '人员处理规则', 说明: '本批当前使用员工全部为空，按公共设备处理，不自动建立借出记录' },
|
||
{ 项目: '线上部门数', 说明: liveRefs.departments.length },
|
||
{ 项目: '线上地址数', 说明: liveRefs.locations.length },
|
||
{ 项目: '线上资产类型数', 说明: liveRefs.assetTypes.length }
|
||
]
|
||
|
||
const run = async () => {
|
||
const options = parseArgs()
|
||
const connection = resolveRemoteConnection(options)
|
||
const sourceWorkbookPath = resolvePathArg(options.sourceWorkbook)
|
||
const candidateWorkbookPath = resolvePathArg(options.candidateWorkbook)
|
||
|
||
if (!fs.existsSync(sourceWorkbookPath)) {
|
||
throw new Error(`源工作簿不存在: ${sourceWorkbookPath}`)
|
||
}
|
||
|
||
if (!fs.existsSync(candidateWorkbookPath) && options.assetCodes.length === 0) {
|
||
throw new Error(`候选工作簿不存在: ${candidateWorkbookPath}`)
|
||
}
|
||
|
||
const outputDir = ensureOutputDir()
|
||
const workbookPath = resolveAvailableWorkbookPath(options.outputWorkbook)
|
||
const sourceRowMap = loadSourceRowMap(sourceWorkbookPath, options.sourceSheet)
|
||
const sourceRows = loadSourceRows(sourceWorkbookPath, options.sourceSheet)
|
||
const baseCandidateRows = fs.existsSync(candidateWorkbookPath)
|
||
? loadCandidateRows(candidateWorkbookPath)
|
||
: []
|
||
const {
|
||
rows: candidateRows,
|
||
missingCodes: missingSourceCodes,
|
||
duplicateSourceCodes
|
||
} = mergeCandidateRowsWithSourceCodes(baseCandidateRows, sourceRows, options.assetCodes)
|
||
const liveRefs = fetchLiveRefs(connection)
|
||
const { readyRows, pendingRows } = classifyRows(candidateRows, sourceRowMap, liveRefs)
|
||
const duplicatePendingRows = buildDuplicatePendingRows(duplicateSourceCodes, sourceRowMap, liveRefs)
|
||
const allPendingRows = [...pendingRows, ...duplicatePendingRows]
|
||
|
||
const addressPendingRows = allPendingRows.filter((row) => row.待核对原因.includes('地址未匹配'))
|
||
const otherPendingRows = allPendingRows.filter((row) => !row.待核对原因.includes('地址未匹配'))
|
||
const readyPayload = buildReadyImportPayload(readyRows)
|
||
|
||
const manifest = {
|
||
generatedAt: new Date().toISOString(),
|
||
sourceWorkbook: sourceWorkbookPath,
|
||
sourceSheet: options.sourceSheet,
|
||
candidateWorkbook: candidateWorkbookPath,
|
||
explicitAssetCodes: options.assetCodes,
|
||
explicitMissingCodes: missingSourceCodes,
|
||
duplicateSourceCodes: duplicateSourceCodes.map((item) => item.code),
|
||
totalCandidates: candidateRows.length + duplicatePendingRows.length,
|
||
readyCount: readyRows.length,
|
||
pendingCount: allPendingRows.length,
|
||
addressPendingCount: addressPendingRows.length,
|
||
otherPendingCount: otherPendingRows.length,
|
||
rulesVersion: 'sheet2-public-supplement-v1',
|
||
assumptions: [
|
||
'当前使用员工为空的记录按公共设备处理',
|
||
'在用/闲置统一映射为系统可用',
|
||
'地址不能 100% 确认时不自动导入'
|
||
]
|
||
}
|
||
|
||
await writeWorkbook(workbookPath, [
|
||
{
|
||
name: '汇总说明',
|
||
rows: buildSummaryRows({
|
||
total: candidateRows.length + duplicatePendingRows.length,
|
||
ready: readyRows.length,
|
||
pending: allPendingRows.length,
|
||
addressPending: addressPendingRows.length,
|
||
otherPending: otherPendingRows.length,
|
||
liveRefs,
|
||
explicitCodeCount: options.assetCodes.length,
|
||
explicitMissingCodeCount: missingSourceCodes.length,
|
||
duplicatePendingCount: duplicatePendingRows.length
|
||
})
|
||
},
|
||
{ name: '可直接补录', rows: readyRows },
|
||
{ name: '待人工核对', rows: allPendingRows },
|
||
{ name: '地址待核对', rows: addressPendingRows },
|
||
{ name: '其他待核对', rows: otherPendingRows.length ? otherPendingRows : [{ 说明: '当前无记录' }] }
|
||
])
|
||
|
||
writeJson(path.join(outputDir, 'sheet2_public_manifest.json'), manifest)
|
||
writeJson(path.join(outputDir, 'sheet2_public_ready_payload.json'), {
|
||
payloadCount: readyPayload.length,
|
||
payload: readyPayload
|
||
})
|
||
writeJson(path.join(outputDir, 'sheet2_public_pending_rows.json'), {
|
||
pendingCount: allPendingRows.length,
|
||
rows: allPendingRows
|
||
})
|
||
writeJson(path.join(outputDir, 'sheet2_live_refs.json'), liveRefs)
|
||
|
||
console.log(
|
||
JSON.stringify(
|
||
{
|
||
outputDir,
|
||
workbookPath,
|
||
manifest
|
||
},
|
||
null,
|
||
2
|
||
)
|
||
)
|
||
}
|
||
|
||
if (require.main === module) {
|
||
run().catch((error) => {
|
||
console.error(error && error.stack ? error.stack : String(error))
|
||
process.exit(1)
|
||
})
|
||
}
|
||
|
||
module.exports = {
|
||
parseArgs,
|
||
resolveRemoteConnection
|
||
}
|