855 lines
27 KiB
JavaScript
855 lines
27 KiB
JavaScript
const fs = require('fs')
|
|
const path = require('path')
|
|
|
|
const ExcelJS = require(path.resolve(__dirname, '../node_modules/exceljs'))
|
|
const { resolveStorageLocationMatch } = require('./locationNormalization')
|
|
|
|
const OUTPUT_ROOT = path.resolve(__dirname, '../../temp_migration_output')
|
|
const DEFAULT_API_BASE = 'https://www.jsgdzc.cn/api'
|
|
const MIGRATION_MARKER = 'parent_child_excel_20260323'
|
|
const PARENT_BUILDABLE_STATUSES = new Set(['可用', '已借出', '维护中'])
|
|
|
|
const parseArgs = () => {
|
|
const args = process.argv.slice(2)
|
|
const options = {
|
|
mode: 'preflight',
|
|
planDir: '',
|
|
apiBase: DEFAULT_API_BASE,
|
|
username: '',
|
|
password: '',
|
|
limit: 0,
|
|
parentCode: '',
|
|
sourceRow: 0
|
|
}
|
|
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index]
|
|
if (arg === '--mode') {
|
|
options.mode = args[index + 1] || options.mode
|
|
index += 1
|
|
} else if (arg === '--plan-dir') {
|
|
options.planDir = args[index + 1] || ''
|
|
index += 1
|
|
} else if (arg === '--api-base') {
|
|
options.apiBase = args[index + 1] || DEFAULT_API_BASE
|
|
index += 1
|
|
} else if (arg === '--username') {
|
|
options.username = args[index + 1] || ''
|
|
index += 1
|
|
} else if (arg === '--password') {
|
|
options.password = args[index + 1] || ''
|
|
index += 1
|
|
} else if (arg === '--limit') {
|
|
options.limit = Number(args[index + 1] || 0) || 0
|
|
index += 1
|
|
} else if (arg === '--parent-code') {
|
|
options.parentCode = args[index + 1] || ''
|
|
index += 1
|
|
} else if (arg === '--source-row') {
|
|
options.sourceRow = Number(args[index + 1] || 0) || 0
|
|
index += 1
|
|
}
|
|
}
|
|
|
|
return options
|
|
}
|
|
|
|
const normalizeText = (value) =>
|
|
String(value == null ? '' : value)
|
|
.replace(/\r/g, ' ')
|
|
.replace(/\n/g, ' ')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
|
|
const normalizeLookupKey = (value) => normalizeText(value).toUpperCase()
|
|
|
|
const normalizeMode = (value) => {
|
|
const mode = normalizeText(value).toLowerCase()
|
|
if (mode === 'apply') {
|
|
return 'apply'
|
|
}
|
|
return 'preflight'
|
|
}
|
|
|
|
const resolvePlanDir = (value) => {
|
|
if (normalizeText(value)) {
|
|
const resolved = path.isAbsolute(value) ? value : path.resolve(process.cwd(), value)
|
|
if (!fs.existsSync(resolved)) {
|
|
throw new Error(`计划目录不存在: ${resolved}`)
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
const candidates = fs
|
|
.readdirSync(OUTPUT_ROOT, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.startsWith('parent_child_dry_run_'))
|
|
.map((entry) => entry.name)
|
|
.sort()
|
|
|
|
if (!candidates.length) {
|
|
throw new Error(`未找到 parent_child_dry_run 输出目录: ${OUTPUT_ROOT}`)
|
|
}
|
|
|
|
return path.join(OUTPUT_ROOT, candidates[candidates.length - 1])
|
|
}
|
|
|
|
const ensureOutputDir = (prefix) => {
|
|
const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19)
|
|
const outputDir = path.join(OUTPUT_ROOT, `${prefix}_${timestamp}`)
|
|
fs.mkdirSync(outputDir, { recursive: true })
|
|
return outputDir
|
|
}
|
|
|
|
const readJsonFile = (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf8'))
|
|
|
|
const writeJson = (filePath, value) => {
|
|
fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`)
|
|
}
|
|
|
|
const escapeCsv = (value) => {
|
|
const stringValue = String(value == null ? '' : value)
|
|
if (/[,"\n]/.test(stringValue)) {
|
|
return `"${stringValue.replace(/"/g, '""')}"`
|
|
}
|
|
return stringValue
|
|
}
|
|
|
|
const writeCsv = (filePath, headers, rows) => {
|
|
const lines = [headers.map(escapeCsv).join(',')]
|
|
for (const row of rows) {
|
|
lines.push(headers.map((header) => escapeCsv(row[header] ?? '')).join(','))
|
|
}
|
|
fs.writeFileSync(filePath, `\uFEFF${lines.join('\n')}`)
|
|
}
|
|
|
|
const buildSummaryRows = (summary) =>
|
|
Object.entries(summary).map(([key, value]) => ({
|
|
key,
|
|
value: Array.isArray(value) || (value && typeof value === 'object') ? JSON.stringify(value) : value
|
|
}))
|
|
|
|
const writeWorkbook = async (filePath, sheets) => {
|
|
const workbook = new ExcelJS.Workbook()
|
|
workbook.creator = 'Codex'
|
|
workbook.created = new Date()
|
|
|
|
for (const sheet of sheets) {
|
|
const rows = Array.isArray(sheet.rows) && sheet.rows.length ? sheet.rows : [{}]
|
|
const headers = [...new Set(rows.flatMap((row) => Object.keys(row)))]
|
|
const worksheet = workbook.addWorksheet(sheet.name)
|
|
worksheet.columns = headers.map((header) => ({
|
|
header,
|
|
key: header,
|
|
width: Math.min(Math.max(header.length + 4, 16), 48)
|
|
}))
|
|
rows.forEach((row) => worksheet.addRow(row))
|
|
worksheet.getRow(1).font = { bold: true }
|
|
worksheet.views = [{ state: 'frozen', ySplit: 1 }]
|
|
}
|
|
|
|
await workbook.xlsx.writeFile(filePath)
|
|
}
|
|
|
|
const loadPlan = (planDir, options) => {
|
|
const reportPath = path.join(planDir, 'report.json')
|
|
const summaryPath = path.join(planDir, 'summary.json')
|
|
|
|
if (!fs.existsSync(reportPath)) {
|
|
throw new Error(`未找到 report.json: ${reportPath}`)
|
|
}
|
|
|
|
const report = readJsonFile(reportPath)
|
|
const summary = fs.existsSync(summaryPath) ? readJsonFile(summaryPath) : report.summary || {}
|
|
let plannedChildren = Array.isArray(report.plannedChildren) ? report.plannedChildren : []
|
|
|
|
if (normalizeText(options.parentCode)) {
|
|
const parentCodeKey = normalizeLookupKey(options.parentCode)
|
|
plannedChildren = plannedChildren.filter((item) => normalizeLookupKey(item.parent_code) === parentCodeKey)
|
|
}
|
|
|
|
if (options.sourceRow > 0) {
|
|
plannedChildren = plannedChildren.filter((item) => Number(item.source_row) === Number(options.sourceRow))
|
|
}
|
|
|
|
if (options.limit > 0) {
|
|
plannedChildren = plannedChildren.slice(0, options.limit)
|
|
}
|
|
|
|
return {
|
|
planDir,
|
|
report,
|
|
summary,
|
|
plannedChildren
|
|
}
|
|
}
|
|
|
|
const sanitizeTokenValue = (value) => normalizeText(value).replace(/;/g, ',')
|
|
|
|
const buildActionKey = (item) =>
|
|
[
|
|
normalizeLookupKey(item.parent_code),
|
|
normalizeLookupKey(item.field_key),
|
|
Number(item.source_row) || 0,
|
|
Number(item.split_index) || 1
|
|
].join('||')
|
|
|
|
const buildChildTypeModelKey = (type, model) =>
|
|
`${normalizeLookupKey(type)}||${normalizeLookupKey(model)}`
|
|
|
|
const buildMigrationTokens = (item) => ({
|
|
migration_marker: MIGRATION_MARKER,
|
|
source_row: String(Number(item.source_row) || 0),
|
|
parent_code: sanitizeTokenValue(item.parent_code),
|
|
field_key: sanitizeTokenValue(item.field_key),
|
|
split_index: String(Number(item.split_index) || 1)
|
|
})
|
|
|
|
const buildChildDescription = (item) => {
|
|
const tokens = [
|
|
['migration_marker', MIGRATION_MARKER],
|
|
['source_row', Number(item.source_row) || 0],
|
|
['parent_code', item.parent_code],
|
|
['field_key', item.field_key],
|
|
['child_type', item.child_type],
|
|
['child_model', item.child_model],
|
|
['source_child_model', item.source_child_model || item.child_model],
|
|
['split_index', Number(item.split_index) || 1],
|
|
['split_quantity', Number(item.split_quantity) || 1],
|
|
['split_pattern', item.split_pattern || 'single_unit'],
|
|
['parent_name', item.parent_name],
|
|
['parent_type', item.parent_type],
|
|
['workbook_department', item.workbook_department],
|
|
['workbook_owner', item.workbook_owner],
|
|
['workbook_location', item.workbook_location]
|
|
]
|
|
|
|
return tokens.map(([key, value]) => `${key}=${sanitizeTokenValue(value)}`).join('; ')
|
|
}
|
|
|
|
const buildMountNote = (item) =>
|
|
Number(item.split_quantity) > 1
|
|
? `根据8.xlsx第${item.source_row}行补建${item.child_name || item.child_type}第${item.split_index}/${item.split_quantity}件，字段=${item.field_key}，原始型号=${sanitizeTokenValue(item.source_child_model || item.child_model)}，拆分后型号=${sanitizeTokenValue(item.child_model)}`
|
|
: `根据8.xlsx第${item.source_row}行补建${item.child_name || item.child_type}，字段=${item.field_key}，型号=${sanitizeTokenValue(item.child_model)}`
|
|
|
|
const descriptionMatchesPlan = (description, item) => {
|
|
const normalizedDescription = normalizeText(description)
|
|
if (!normalizedDescription) {
|
|
return false
|
|
}
|
|
|
|
const tokens = buildMigrationTokens(item)
|
|
return Object.entries(tokens).every(([key, value]) =>
|
|
normalizedDescription.includes(`${key}=${sanitizeTokenValue(value)}`)
|
|
)
|
|
}
|
|
|
|
const buildCookieHeader = (response) => {
|
|
if (typeof response.headers.getSetCookie === 'function') {
|
|
return response.headers.getSetCookie().map((item) => item.split(';')[0]).join('; ')
|
|
}
|
|
|
|
const setCookie = response.headers.get('set-cookie')
|
|
return setCookie ? setCookie.split(';')[0] : ''
|
|
}
|
|
|
|
class ApiSession {
|
|
constructor({ apiBase, username, password }) {
|
|
this.apiBase = normalizeText(apiBase).replace(/\/$/, '')
|
|
this.username = normalizeText(username)
|
|
this.password = String(password == null ? '' : password)
|
|
this.cookieHeader = ''
|
|
}
|
|
|
|
async login() {
|
|
if (!this.apiBase || !this.username || !this.password) {
|
|
throw new Error('缺少 API 登录参数')
|
|
}
|
|
|
|
const response = await fetch(`${this.apiBase}/auth/local/login`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
username: this.username,
|
|
password: this.password
|
|
})
|
|
})
|
|
|
|
const text = await response.text()
|
|
if (!response.ok) {
|
|
throw new Error(`登录失败: status=${response.status} body=${text}`)
|
|
}
|
|
|
|
this.cookieHeader = buildCookieHeader(response)
|
|
if (!this.cookieHeader) {
|
|
throw new Error('登录成功但未拿到 session cookie')
|
|
}
|
|
|
|
return JSON.parse(text)
|
|
}
|
|
|
|
async requestJson(endpoint, options = {}, retry = true) {
|
|
if (!this.cookieHeader) {
|
|
await this.login()
|
|
}
|
|
|
|
const headers = {
|
|
...(options.headers || {}),
|
|
Cookie: this.cookieHeader
|
|
}
|
|
|
|
const response = await fetch(`${this.apiBase}${endpoint}`, {
|
|
...options,
|
|
headers
|
|
})
|
|
const text = await response.text()
|
|
|
|
if (response.status === 401 && retry) {
|
|
await this.login()
|
|
return this.requestJson(endpoint, options, false)
|
|
}
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`请求失败: ${endpoint} status=${response.status} body=${text}`)
|
|
}
|
|
|
|
return JSON.parse(text)
|
|
}
|
|
}
|
|
|
|
const unwrapListPayload = (payload) => {
|
|
if (Array.isArray(payload)) {
|
|
return payload
|
|
}
|
|
|
|
if (payload && Array.isArray(payload.list)) {
|
|
return payload.list
|
|
}
|
|
|
|
if (payload?.data && Array.isArray(payload.data.list)) {
|
|
return payload.data.list
|
|
}
|
|
|
|
throw new Error('接口返回结构不符合预期，未找到 list')
|
|
}
|
|
|
|
const fetchLiveData = async (session, outputDir, tag) => {
|
|
const [equipmentPayload, assetTypePayload, storageLocationPayload] = await Promise.all([
|
|
session.requestJson('/equipment/list?page=1&pageSize=5000'),
|
|
session.requestJson('/asset-types/list?page=1&pageSize=200'),
|
|
session.requestJson('/storage-locations/list?page=1&pageSize=200')
|
|
])
|
|
|
|
const equipmentSourcePath = path.join(outputDir, `live_equipment_${tag}.json`)
|
|
const assetTypeSourcePath = path.join(outputDir, `live_asset_types_${tag}.json`)
|
|
const storageLocationSourcePath = path.join(outputDir, `live_storage_locations_${tag}.json`)
|
|
writeJson(equipmentSourcePath, equipmentPayload)
|
|
writeJson(assetTypeSourcePath, assetTypePayload)
|
|
writeJson(storageLocationSourcePath, storageLocationPayload)
|
|
|
|
return {
|
|
equipmentList: unwrapListPayload(equipmentPayload),
|
|
assetTypes: unwrapListPayload(assetTypePayload),
|
|
storageLocations: unwrapListPayload(storageLocationPayload),
|
|
equipmentSourcePath,
|
|
assetTypeSourcePath,
|
|
storageLocationSourcePath
|
|
}
|
|
}
|
|
|
|
const buildLiveRefs = (liveData) => {
|
|
const topLevelByCode = new Map()
|
|
const topLevelItems = Array.isArray(liveData.equipmentList) ? liveData.equipmentList : []
|
|
|
|
for (const item of topLevelItems) {
|
|
const code = normalizeLookupKey(item.equipment_code)
|
|
if (code) {
|
|
topLevelByCode.set(code, item)
|
|
}
|
|
}
|
|
|
|
const assetTypeByName = new Map()
|
|
for (const item of liveData.assetTypes || []) {
|
|
assetTypeByName.set(normalizeLookupKey(item.name), item)
|
|
}
|
|
|
|
const locationByName = new Map()
|
|
for (const item of liveData.storageLocations || []) {
|
|
locationByName.set(normalizeLookupKey(item.name), item)
|
|
}
|
|
|
|
return {
|
|
topLevelItems,
|
|
topLevelByCode,
|
|
assetTypeByName,
|
|
locationByName
|
|
}
|
|
}
|
|
|
|
const summarizeByReason = (rows, reasonKey = 'reason') => {
|
|
const counts = {}
|
|
for (const row of rows) {
|
|
const reason = normalizeText(row[reasonKey]) || 'unknown'
|
|
counts[reason] = (counts[reason] || 0) + 1
|
|
}
|
|
return counts
|
|
}
|
|
|
|
const analyzePlan = (plan, liveData) => {
|
|
const refs = buildLiveRefs(liveData)
|
|
const actions = []
|
|
const blocked = []
|
|
const satisfied = []
|
|
const mountedChildQueueCache = new Map()
|
|
|
|
const getMountedChildQueue = (parent, key) => {
|
|
const cacheKey = `${parent.id}||${key}`
|
|
if (mountedChildQueueCache.has(cacheKey)) {
|
|
return mountedChildQueueCache.get(cacheKey)
|
|
}
|
|
|
|
const queue = (Array.isArray(parent.children) ? parent.children : []).filter(
|
|
(child) => buildChildTypeModelKey(child.equipment_type, child.equipment_model) === key
|
|
)
|
|
mountedChildQueueCache.set(cacheKey, queue)
|
|
return queue
|
|
}
|
|
|
|
for (const item of plan.plannedChildren) {
|
|
const parentCodeKey = normalizeLookupKey(item.parent_code)
|
|
const parent = refs.topLevelByCode.get(parentCodeKey)
|
|
const actionBase = {
|
|
action_key: buildActionKey(item),
|
|
source_row: item.source_row,
|
|
parent_code: item.parent_code,
|
|
parent_name: item.parent_name,
|
|
parent_type: item.parent_type,
|
|
parent_status: item.parent_status,
|
|
child_type: item.child_type,
|
|
child_name: item.child_name,
|
|
child_model: item.child_model,
|
|
source_child_model: item.source_child_model || item.child_model,
|
|
field_key: item.field_key,
|
|
split_index: Number(item.split_index) || 1,
|
|
split_quantity: Number(item.split_quantity) || 1,
|
|
split_pattern: item.split_pattern || 'single_unit',
|
|
notes: item.notes,
|
|
workbook_department: item.workbook_department,
|
|
workbook_owner: item.workbook_owner,
|
|
workbook_location: item.workbook_location,
|
|
planned_description: buildChildDescription(item),
|
|
planned_mount_note: buildMountNote(item)
|
|
}
|
|
|
|
const block = (reason, extra = {}) => {
|
|
blocked.push({
|
|
...actionBase,
|
|
reason,
|
|
...extra
|
|
})
|
|
}
|
|
|
|
if (!parent) {
|
|
block('live_parent_not_found')
|
|
continue
|
|
}
|
|
|
|
const liveParentType = refs.assetTypeByName.get(normalizeLookupKey(parent.equipment_type))
|
|
if (!liveParentType?.can_be_parent) {
|
|
block('live_parent_type_not_parent_capable', { live_parent_type: parent.equipment_type })
|
|
continue
|
|
}
|
|
|
|
if (parent.parent_id != null) {
|
|
block('live_parent_is_child', { live_parent_id: parent.parent_id })
|
|
continue
|
|
}
|
|
|
|
if (!PARENT_BUILDABLE_STATUSES.has(normalizeText(parent.status))) {
|
|
block('live_parent_status_not_buildable', { live_parent_status: parent.status })
|
|
continue
|
|
}
|
|
|
|
const childTypeConfig = refs.assetTypeByName.get(normalizeLookupKey(item.child_type))
|
|
if (!childTypeConfig?.can_be_child) {
|
|
block('child_asset_type_not_child_capable')
|
|
continue
|
|
}
|
|
|
|
const expectedChildKey = buildChildTypeModelKey(item.child_type, item.child_model)
|
|
const matchingMountedChildQueue = getMountedChildQueue(parent, expectedChildKey)
|
|
const matchingMountedChild = matchingMountedChildQueue.shift()
|
|
|
|
if (matchingMountedChild) {
|
|
satisfied.push({
|
|
...actionBase,
|
|
reason: 'already_mounted_matching_type_model',
|
|
live_parent_id: parent.id,
|
|
live_child_id: matchingMountedChild.id,
|
|
live_child_code: matchingMountedChild.equipment_code,
|
|
live_child_status: matchingMountedChild.status
|
|
})
|
|
continue
|
|
}
|
|
|
|
const orphanMatches = refs.topLevelItems.filter((equipment) => descriptionMatchesPlan(equipment.description, item))
|
|
|
|
if (orphanMatches.length > 1) {
|
|
block('duplicate_script_created_orphans', {
|
|
matched_orphan_codes: orphanMatches.map((equipment) => equipment.equipment_code).join(' | ')
|
|
})
|
|
continue
|
|
}
|
|
|
|
if (orphanMatches.length === 1) {
|
|
const orphan = orphanMatches[0]
|
|
|
|
if (buildChildTypeModelKey(orphan.equipment_type, orphan.equipment_model) !== expectedChildKey) {
|
|
block('script_created_orphan_model_mismatch', {
|
|
matched_orphan_code: orphan.equipment_code,
|
|
matched_orphan_type: orphan.equipment_type,
|
|
matched_orphan_model: orphan.equipment_model
|
|
})
|
|
continue
|
|
}
|
|
|
|
if (orphan.parent_id != null) {
|
|
block('script_created_orphan_already_mounted_elsewhere', {
|
|
matched_orphan_code: orphan.equipment_code,
|
|
matched_orphan_parent_id: orphan.parent_id
|
|
})
|
|
continue
|
|
}
|
|
|
|
if (normalizeText(orphan.status) !== '可用' || Number(orphan.remaining_quantity) <= 0) {
|
|
block('script_created_orphan_not_mountable', {
|
|
matched_orphan_code: orphan.equipment_code,
|
|
matched_orphan_status: orphan.status,
|
|
matched_orphan_remaining_quantity: orphan.remaining_quantity
|
|
})
|
|
continue
|
|
}
|
|
|
|
if (orphan.current_borrow) {
|
|
block('script_created_orphan_has_active_borrow', {
|
|
matched_orphan_code: orphan.equipment_code
|
|
})
|
|
continue
|
|
}
|
|
|
|
actions.push({
|
|
...actionBase,
|
|
action_type: 'mount_existing',
|
|
live_parent_id: parent.id,
|
|
existing_child_id: orphan.id,
|
|
existing_child_code: orphan.equipment_code,
|
|
parent_storage_location_id: parent.storage_location_id,
|
|
parent_department_id: parent.department_id
|
|
})
|
|
continue
|
|
}
|
|
|
|
const fallbackLocationResolution = !parent.storage_location_id
|
|
? resolveStorageLocationMatch(item.workbook_location, refs.locationByName)
|
|
: { match: null, normalizedValue: '', rule: '' }
|
|
const resolvedStorageLocationId = parent.storage_location_id || fallbackLocationResolution.match?.id || null
|
|
const resolvedStorageLocationName =
|
|
parent.storageLocation?.name ||
|
|
fallbackLocationResolution.match?.name ||
|
|
''
|
|
|
|
if (!resolvedStorageLocationId) {
|
|
block('live_parent_missing_storage_location', {
|
|
live_parent_id: parent.id,
|
|
workbook_location_resolution: fallbackLocationResolution.normalizedValue || '',
|
|
workbook_location_rule: fallbackLocationResolution.rule || ''
|
|
})
|
|
continue
|
|
}
|
|
|
|
actions.push({
|
|
...actionBase,
|
|
action_type: 'create_and_mount',
|
|
live_parent_id: parent.id,
|
|
parent_storage_location_id: resolvedStorageLocationId,
|
|
parent_storage_location_name: resolvedStorageLocationName,
|
|
parent_storage_location_source: parent.storage_location_id ? 'live_parent' : 'workbook_fallback',
|
|
parent_department_id: parent.department_id
|
|
})
|
|
}
|
|
|
|
const summary = {
|
|
planned_child_count: plan.plannedChildren.length,
|
|
actionable_count: actions.length,
|
|
actionable_create_and_mount_count: actions.filter((item) => item.action_type === 'create_and_mount').length,
|
|
actionable_mount_existing_count: actions.filter((item) => item.action_type === 'mount_existing').length,
|
|
satisfied_count: satisfied.length,
|
|
blocked_count: blocked.length,
|
|
blocked_reason_counts: summarizeByReason(blocked),
|
|
satisfied_reason_counts: summarizeByReason(satisfied)
|
|
}
|
|
|
|
return {
|
|
summary,
|
|
actions,
|
|
blocked,
|
|
satisfied
|
|
}
|
|
}
|
|
|
|
const buildCreateChildPayload = (action) => ({
|
|
entry_mode: 'child',
|
|
equipment_name: action.child_name,
|
|
equipment_model: action.child_model,
|
|
equipment_type: action.child_type,
|
|
code_generation_mode: 'auto',
|
|
unit_price: 0,
|
|
total_quantity: 1,
|
|
remaining_quantity: 1,
|
|
status: '可用',
|
|
storage_location_id: action.parent_storage_location_id,
|
|
department_id: action.parent_department_id || null,
|
|
description: action.planned_description
|
|
})
|
|
|
|
const applyActions = async (session, analysis) => {
|
|
const results = []
|
|
const errors = []
|
|
|
|
for (let index = 0; index < analysis.actions.length; index += 1) {
|
|
const action = analysis.actions[index]
|
|
const progress = `${index + 1}/${analysis.actions.length}`
|
|
console.log(`[${progress}] ${action.action_type} ${action.parent_code} ${action.child_type} ${action.child_model}`)
|
|
|
|
let createdChild = null
|
|
let stage = 'mount'
|
|
|
|
try {
|
|
let childId = action.existing_child_id || null
|
|
let childCode = action.existing_child_code || ''
|
|
|
|
if (action.action_type === 'create_and_mount') {
|
|
stage = 'create'
|
|
const createResult = await session.requestJson('/equipment', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(buildCreateChildPayload(action))
|
|
})
|
|
|
|
createdChild = createResult?.data || null
|
|
childId = createdChild?.id || null
|
|
childCode = normalizeText(createdChild?.equipment_code)
|
|
|
|
if (!childId || !childCode) {
|
|
throw new Error('创建子资产返回的数据不完整')
|
|
}
|
|
}
|
|
|
|
stage = 'mount'
|
|
await session.requestJson(`/mount/${action.live_parent_id}/mount`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
child_id: childId,
|
|
notes: action.planned_mount_note
|
|
})
|
|
})
|
|
|
|
results.push({
|
|
...action,
|
|
apply_status: 'success',
|
|
child_id: childId,
|
|
child_code: childCode,
|
|
created_new_child: action.action_type === 'create_and_mount' ? 'yes' : 'no'
|
|
})
|
|
} catch (error) {
|
|
let cleanupStatus = 'not_needed'
|
|
let cleanupMessage = ''
|
|
|
|
if (action.action_type === 'create_and_mount' && createdChild?.id) {
|
|
cleanupStatus = 'pending'
|
|
try {
|
|
await session.requestJson(`/equipment/${createdChild.id}`, {
|
|
method: 'DELETE'
|
|
})
|
|
cleanupStatus = 'deleted'
|
|
} catch (cleanupError) {
|
|
cleanupStatus = 'delete_failed'
|
|
cleanupMessage = cleanupError?.message || String(cleanupError)
|
|
}
|
|
}
|
|
|
|
errors.push({
|
|
...action,
|
|
apply_status: 'failed',
|
|
failed_stage: stage,
|
|
error_message: error?.message || String(error),
|
|
created_child_id: createdChild?.id || '',
|
|
created_child_code: createdChild?.equipment_code || '',
|
|
cleanup_status: cleanupStatus,
|
|
cleanup_message: cleanupMessage
|
|
})
|
|
break
|
|
}
|
|
}
|
|
|
|
return {
|
|
results,
|
|
errors,
|
|
stopped_early: errors.length > 0
|
|
}
|
|
}
|
|
|
|
const writeAnalysisOutputs = async ({
|
|
outputDir,
|
|
plan,
|
|
liveData,
|
|
analysis,
|
|
execution = null,
|
|
postVerify = null,
|
|
mode
|
|
}) => {
|
|
const manifest = {
|
|
generated_at: new Date().toISOString(),
|
|
mode,
|
|
plan_dir: plan.planDir,
|
|
source_plan_summary: plan.summary,
|
|
selected_planned_child_count: plan.plannedChildren.length,
|
|
live_total_equipment: liveData.equipmentList.length,
|
|
live_total_asset_types: liveData.assetTypes.length,
|
|
live_total_storage_locations: (liveData.storageLocations || []).length,
|
|
analysis_summary: analysis.summary,
|
|
execution_summary: execution
|
|
? {
|
|
success_count: execution.results.length,
|
|
error_count: execution.errors.length,
|
|
stopped_early: execution.stopped_early
|
|
}
|
|
: null,
|
|
post_verify_summary: postVerify?.summary || null
|
|
}
|
|
|
|
writeJson(path.join(outputDir, 'manifest.json'), manifest)
|
|
writeJson(path.join(outputDir, 'analysis_summary.json'), analysis.summary)
|
|
writeJson(path.join(outputDir, 'blocked.json'), analysis.blocked)
|
|
writeJson(path.join(outputDir, 'satisfied.json'), analysis.satisfied)
|
|
writeJson(path.join(outputDir, 'actions.json'), analysis.actions)
|
|
|
|
writeCsv(
|
|
path.join(outputDir, 'actions.csv'),
|
|
Object.keys(analysis.actions[0] || { action_key: '', action_type: '', parent_code: '', child_type: '', child_model: '' }),
|
|
analysis.actions
|
|
)
|
|
writeCsv(
|
|
path.join(outputDir, 'blocked.csv'),
|
|
Object.keys(analysis.blocked[0] || { action_key: '', reason: '', parent_code: '', child_type: '', child_model: '' }),
|
|
analysis.blocked
|
|
)
|
|
writeCsv(
|
|
path.join(outputDir, 'satisfied.csv'),
|
|
Object.keys(analysis.satisfied[0] || { action_key: '', reason: '', parent_code: '', child_type: '', child_model: '' }),
|
|
analysis.satisfied
|
|
)
|
|
|
|
const workbookSheets = [
|
|
{ name: 'Summary', rows: buildSummaryRows(manifest) },
|
|
{ name: 'Actions', rows: analysis.actions },
|
|
{ name: 'Blocked', rows: analysis.blocked },
|
|
{ name: 'Satisfied', rows: analysis.satisfied },
|
|
{ name: 'OriginalSkippedRows', rows: plan.report.skippedRows || [] }
|
|
]
|
|
|
|
if (execution) {
|
|
writeJson(path.join(outputDir, 'apply_results.json'), execution.results)
|
|
writeJson(path.join(outputDir, 'apply_errors.json'), execution.errors)
|
|
writeCsv(
|
|
path.join(outputDir, 'apply_results.csv'),
|
|
Object.keys(execution.results[0] || { action_key: '', apply_status: '', child_code: '' }),
|
|
execution.results
|
|
)
|
|
writeCsv(
|
|
path.join(outputDir, 'apply_errors.csv'),
|
|
Object.keys(execution.errors[0] || { action_key: '', apply_status: '', error_message: '' }),
|
|
execution.errors
|
|
)
|
|
workbookSheets.push({ name: 'ApplyResults', rows: execution.results })
|
|
workbookSheets.push({ name: 'ApplyErrors', rows: execution.errors })
|
|
}
|
|
|
|
if (postVerify) {
|
|
writeJson(path.join(outputDir, 'post_verify.json'), postVerify)
|
|
workbookSheets.push({ name: 'PostVerifySummary', rows: buildSummaryRows(postVerify.summary || {}) })
|
|
workbookSheets.push({ name: 'PostVerifyBlocked', rows: postVerify.blocked || [] })
|
|
workbookSheets.push({ name: 'PostVerifyActions', rows: postVerify.actions || [] })
|
|
workbookSheets.push({ name: 'PostVerifySatisfied', rows: postVerify.satisfied || [] })
|
|
}
|
|
|
|
await writeWorkbook(path.join(outputDir, 'parent_child_live_migration.xlsx'), workbookSheets)
|
|
}
|
|
|
|
const run = async () => {
|
|
const options = parseArgs()
|
|
const mode = normalizeMode(options.mode)
|
|
const plan = loadPlan(resolvePlanDir(options.planDir), options)
|
|
const outputDir = ensureOutputDir(
|
|
mode === 'apply' ? 'parent_child_live_apply' : 'parent_child_live_preflight'
|
|
)
|
|
|
|
if (!plan.plannedChildren.length) {
|
|
throw new Error('筛选后没有可处理的 plannedChildren')
|
|
}
|
|
|
|
const session = new ApiSession({
|
|
apiBase: options.apiBase,
|
|
username: options.username,
|
|
password: options.password
|
|
})
|
|
|
|
const liveBefore = await fetchLiveData(session, outputDir, 'before')
|
|
const analysis = analyzePlan(plan, liveBefore)
|
|
|
|
let execution = null
|
|
let postVerify = null
|
|
|
|
if (mode === 'apply' && analysis.actions.length > 0) {
|
|
execution = await applyActions(session, analysis)
|
|
const liveAfter = await fetchLiveData(session, outputDir, 'after')
|
|
postVerify = analyzePlan(plan, liveAfter)
|
|
}
|
|
|
|
await writeAnalysisOutputs({
|
|
outputDir,
|
|
plan,
|
|
liveData: liveBefore,
|
|
analysis,
|
|
execution,
|
|
postVerify,
|
|
mode
|
|
})
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
outputDir,
|
|
mode,
|
|
selectedPlannedChildCount: plan.plannedChildren.length,
|
|
analysisSummary: analysis.summary,
|
|
executionSummary: execution
|
|
? {
|
|
successCount: execution.results.length,
|
|
errorCount: execution.errors.length,
|
|
stoppedEarly: execution.stopped_early
|
|
}
|
|
: null,
|
|
postVerifySummary: postVerify ? postVerify.summary : null
|
|
},
|
|
null,
|
|
2
|
|
)
|
|
)
|
|
}
|
|
|
|
run().catch((error) => {
|
|
console.error(error?.stack ? error.stack : String(error))
|
|
process.exit(1)
|
|
})
|