import type { Request, Response } from 'express' import { Prisma } from '@prisma/client' import prisma from '../utils/prisma' import { successResponse, errorResponse } from '../utils/response' import { logOperation } from './operationLogController' import { calculateEquipmentValues } from '../utils/assetValue' import { loadAndLockAssetTree, lockEquipmentRows } from '../services/assetMovementService' import { completeLockedBorrowReturn } from '../services/borrowReturnService' import { assertDisposalItemsConfirmed, DisposalConflictError, disposalTreeSelect, getDisposalAutoReturn, getDisposalBlockedReason, getDisposalOccupancy, isDisposalAutoReturnRoot, loadDisposalAutoReturnBorrows, loadDisposalTrees, MAX_DISPOSAL_BATCH_ROOTS, type DisposalTreeItem } from '../utils/disposalSubmission' import { compactNotificationText, createBusinessNotification, escapeNotificationMarkdownInline, findActiveDingTalkUsersByIds, findActiveDingTalkUsersByRoles, findActiveStationUsersByIds, findActiveStationUsersByRoles, formatBeijingDateTime, getCurrentDingTalkRecipientRollout, mergeRecipients } from '../services/businessNotificationService' const disposalInclude = { equipment: true, applier: { select: { id: true, name: true, username: true } }, approver: { select: { id: true, name: true, username: true } }, completer: { select: { id: true, name: true, username: true } }, items: { orderBy: { id: 'asc' as const }, include: { equipment: { select: { id: true, equipment_code: true, equipment_name: true, equipment_model: true, equipment_type: true, status: true, parent_id: true, total_quantity: true, remaining_quantity: true, storage_location_id: true, department_id: true } } } }, actions: { orderBy: [{ created_at: 'asc' as const }, { id: 'asc' as const }], include: { operator: { select: { id: true, name: true, username: true } } } } } const updateEquipmentLifecycle = async ( tx: Prisma.TransactionClient, equipment: { id: number unit_price: Prisma.Decimal total_quantity: number remaining_quantity: number status: string parent_id: number | null department_id: number | null mount_status: string updated_at: Date }, targetStatus: string, expectedStatus: string, expectedParentId: number | null = equipment.parent_id ) => { const remainingQuantity = targetStatus === '已借出' ? 0 : equipment.remaining_quantity const values = calculateEquipmentValues({ unitPrice: Number(equipment.unit_price), totalQuantity: equipment.total_quantity, remainingQuantity, status: targetStatus }) const updated = await tx.equipment.updateMany({ where: { id: equipment.id, status: expectedStatus, parent_id: expectedParentId, department_id: equipment.department_id, mount_status: equipment.mount_status, remaining_quantity: equipment.remaining_quantity, updated_at: equipment.updated_at }, data: { status: targetStatus, total_value: values.total_value, borrowed_value: values.borrowed_value, available_value: values.available_value } }) if (updated.count !== 1) { throw new DisposalConflictError('资产状态或挂载关系已变化,请刷新后重试') } } const excludeApplicant = (recipients: T[], applicantId: number) => recipients.filter((recipient) => recipient.id !== applicantId) const getSubmissionRecipients = async (tx: Prisma.TransactionClient, applicantId: number) => { const rollout = getCurrentDingTalkRecipientRollout() const [stationAdministrative, dingTalkAdministrative] = await Promise.all([ findActiveStationUsersByRoles(tx, ['administrative']), findActiveDingTalkUsersByRoles(tx, ['administrative'], rollout) ]) const eligibleStationAdministrative = excludeApplicant(stationAdministrative, applicantId) const eligibleDingTalkAdministrative = excludeApplicant(dingTalkAdministrative, applicantId) const stationRecipients = eligibleStationAdministrative.length > 0 ? eligibleStationAdministrative : await findActiveStationUsersByRoles(tx, ['admin']) const dingTalkRecipients = eligibleDingTalkAdministrative.length > 0 ? eligibleDingTalkAdministrative : await findActiveDingTalkUsersByRoles(tx, ['admin'], rollout) return { stationRecipients, dingTalkRecipients } } const getResultRecipients = async (tx: Prisma.TransactionClient, applierId: number) => { const rollout = getCurrentDingTalkRecipientRollout() const [stationApplier, stationAdministrative, dingTalkApplier, dingTalkAdministrative] = await Promise.all([ findActiveStationUsersByIds(tx, [applierId]), findActiveStationUsersByRoles(tx, ['administrative']), findActiveDingTalkUsersByIds(tx, [applierId], rollout), findActiveDingTalkUsersByRoles(tx, ['administrative'], rollout) ]) let stationRecipients = mergeRecipients(stationApplier, stationAdministrative) if (stationApplier.length === 0 || stationAdministrative.length === 0) { stationRecipients = mergeRecipients( stationRecipients, await findActiveStationUsersByRoles(tx, ['admin']) ) } let dingTalkRecipients = mergeRecipients(dingTalkApplier, dingTalkAdministrative) if (dingTalkApplier.length === 0 || dingTalkAdministrative.length === 0) { dingTalkRecipients = mergeRecipients( dingTalkRecipients, await findActiveDingTalkUsersByRoles(tx, ['admin'], rollout) ) } return { stationRecipients, dingTalkRecipients } } const assetNotificationName = (name: unknown, code: unknown) => `${escapeNotificationMarkdownInline(name, '资产')}(${escapeNotificationMarkdownInline(code, '无编码')})` export const buildDisposalAppliedDingTalkContent = (input: { appliedAt: Date equipmentName: unknown equipmentCode: unknown applicantName: unknown reason: unknown }) => [ `**申请时间:** ${formatBeijingDateTime(input.appliedAt)}`, `**资产:** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`, `**申请人:** ${escapeNotificationMarkdownInline(input.applicantName)}`, `**报废原因:** ${escapeNotificationMarkdownInline(input.reason)}`, '> 请核对资产及配件明细后处理。' ].join('\n\n') // The notification center reserves up to 120 characters for the visible title. const BATCH_DISPOSAL_DINGTALK_BODY_LIMIT = 4800 - 120 - '### \n\n'.length // Approximate the proportional card font in twentieths of an em. const DISPOSAL_NOTICE_COLUMN_WIDTHS = [124, 110, 100, 80] const noticeCharacterWidth = (character: string) => { if (/\p{Mark}/u.test(character)) return 0 if (/[\p{Script=Han}\p{Script=Hangul}\p{Script=Hiragana}\p{Script=Katakana}\p{Extended_Pictographic}\u3000-\u303f\uff01-\uff60\uffe0-\uffe6]/u.test(character)) return 20 if (/[0-9]/.test(character)) return 11 if (/[A-Z]/.test(character)) return 13 if (character === '-') return 7 if (character === '+') return 12 if (/[ .,:;!'|]/.test(character)) return 5 return 10 } const noticeTextWidth = (text: string) => Array.from(text).reduce((width, character) => width + noticeCharacterWidth(character), 0) const wrapNoticeColumn = (text: string, limit: number) => { const lines: string[] = [] let line = '' let width = 0 for (const character of text) { const characterWidth = noticeCharacterWidth(character) if (width + characterWidth > limit) { lines.push(line.trim()) line = '' width = 0 } line += character width += characterWidth } lines.push(line.trim()) return lines } const noticeColumnPadding = (width: number) => { const whole = '\u3000'.repeat(Math.floor(width / 20)) const half = '\u2002'.repeat(Math.floor(width % 20 / 10)) const thin = '\u2009'.repeat(Math.floor(width % 10 / 4)) const hair = '\u200a'.repeat(Math.floor(width % 10 % 4 / 2)) return whole + half + thin + hair } const renderNoticeColumns = (columns: string[], heading = false) => columns.map((column, index) => { const escaped = column ? escapeNotificationMarkdownInline(column) : '' const text = heading ? `**${escaped}**` : escaped if (index === columns.length - 1) return text return text + noticeColumnPadding(DISPOSAL_NOTICE_COLUMN_WIDTHS[index] - noticeTextWidth(column)) }).join('\u2009').trimEnd() export const buildBatchDisposalAppliedDingTalkContents = (input: { appliedAt: Date applicantName: unknown reason: string assets: { code: string name: string department?: string holder?: string accessoryCount: number }[] }) => { const header = [ `**申请时间:** ${formatBeijingDateTime(input.appliedAt)}`, `**申请人:** ${escapeNotificationMarkdownInline(input.applicantName)}`, `**报废原因:** ${escapeNotificationMarkdownInline(input.reason, '未填写', 300)}` ] const rows = input.assets.map(asset => { const code = compactNotificationText(asset.code) const longCode = noticeTextWidth(code) > DISPOSAL_NOTICE_COLUMN_WIDTHS[0] const accessories = asset.accessoryCount ? `+${asset.accessoryCount}配件` : '' const columns = [ [longCode ? '' : code], wrapNoticeColumn(compactNotificationText(asset.name) + accessories, DISPOSAL_NOTICE_COLUMN_WIDTHS[1]), wrapNoticeColumn(compactNotificationText(asset.department, '未归属部门'), DISPOSAL_NOTICE_COLUMN_WIDTHS[2]), wrapNoticeColumn(compactNotificationText(asset.holder, '未领用'), DISPOSAL_NOTICE_COLUMN_WIDTHS[3]) ] const lines = longCode ? [escapeNotificationMarkdownInline(code)] : [] const height = Math.max(...columns.map(column => column.length)) for (let index = 0; index < height; index++) { lines.push(renderNoticeColumns(columns.map(column => column[index] || ''))) } return lines.join('\n\n') }) const total = `**待审批:** ${rows.length} 笔` const columnHeading = renderNoticeColumns(['编码', '资产', '部门', '领用人'], true) const render = (items: string[], part?: string) => [...header, ...(part ? [part] : []), total, columnHeading, ...items].join('\n\n') const singleCard = render(rows) if (singleCard.length <= BATCH_DISPOSAL_DINGTALK_BODY_LIMIT) return [singleCard] const rowBudget = BATCH_DISPOSAL_DINGTALK_BODY_LIMIT - render([], `第 ${rows.length}/${rows.length} 部分`).length const parts: string[][] = [[]] let current = parts[0] let used = 0 for (const row of rows) { if (current.length && used + 2 + row.length > rowBudget) { current = [] parts.push(current) used = 0 } used += row.length + 2 current.push(row) } return parts.map((part, index) => render(part, `第 ${index + 1}/${parts.length} 部分`)) } export const buildDisposalApprovedDingTalkContent = (input: { approvedAt: Date equipmentName: unknown equipmentCode: unknown approverName: unknown }) => [ `**审批时间:** ${formatBeijingDateTime(input.approvedAt)}`, `**资产:** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`, `**审批人:** ${escapeNotificationMarkdownInline(input.approverName)}`, '**审批结果:** 已通过', '> 报废单现已进入待处置阶段。' ].join('\n\n') export const buildDisposalRejectedDingTalkContent = (input: { rejectedAt: Date equipmentName: unknown equipmentCode: unknown rejectorName: unknown reason: unknown }) => [ `**驳回时间:** ${formatBeijingDateTime(input.rejectedAt)}`, `**资产:** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`, `**驳回人:** ${escapeNotificationMarkdownInline(input.rejectorName)}`, `**驳回原因:** ${escapeNotificationMarkdownInline(input.reason)}`, '> 资产状态已恢复为申请前状态。' ].join('\n\n') export const buildDisposalCompletedDingTalkContent = (input: { completedAt: Date equipmentName: unknown equipmentCode: unknown completerName: unknown notes: unknown }) => [ `**完成时间:** ${formatBeijingDateTime(input.completedAt)}`, `**资产:** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`, `**完成人:** ${escapeNotificationMarkdownInline(input.completerName)}`, '**处置结果:** 已完成报废', `**完成说明:** ${escapeNotificationMarkdownInline(input.notes, '无')}`, '> 相关资产现已统一标记为已报废。' ].join('\n\n') const getCurrentUser = (res: Response) => ({ id: Number(res.locals.user?.id), role: String(res.locals.user?.role || '') }) const getDisposalVisibility = (res: Response): Prisma.DisposalRecordWhereInput => { const user = getCurrentUser(res) if (!Number.isSafeInteger(user.id) || user.id <= 0) { throw Object.assign(new Error('用户未登录'), { status: 401 }) } if (user.role === 'admin' || user.role === 'administrative') return {} if (user.role === 'it') return { applied_by: user.id } throw Object.assign(new Error('无权查看报废流程'), { status: 403 }) } const DISPOSAL_STATUSES = ['pending', 'approved', 'rejected', 'completed'] as const const parseListPositiveInteger = ( value: unknown, fieldName: string, fallback: number, max?: number ) => { if (value === undefined || value === null || value === '') { if (fallback > 0) return fallback throw Object.assign(new Error(`${fieldName}无效`), { status: 422 }) } if ((typeof value !== 'string' && typeof value !== 'number') || !/^\d+$/.test(String(value))) { throw Object.assign(new Error(`${fieldName}无效`), { status: 422 }) } const parsed = Number(value) if (!Number.isSafeInteger(parsed) || parsed <= 0 || (max !== undefined && parsed > max)) { throw Object.assign(new Error(`${fieldName}无效`), { status: 422 }) } return parsed } const withHistoricalDisposalNotes = (record: T) => ({ ...record, historical_notes: record.status === 'completed' && record.notes && !record.completion_notes ? record.notes : null }) const readDisposalItemSnapshot = (snapshot: string | null): Record | null => { try { const parsed = snapshot ? JSON.parse(snapshot) : {} return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null } catch { return null } } const readDisposalSubmission = (body: Record) => { const reason = typeof body.disposal_reason === 'string' ? body.disposal_reason.trim() : '' const method = typeof body.disposal_method === 'string' ? body.disposal_method.trim() : '' if (!reason || !method) throw new Error('报废原因和处置方式不能为空') if (method.length > 50) throw new Error('处置方式不能超过50个字符') if (body.notes != null && typeof body.notes !== 'string') throw new Error('备注格式无效') return { reason, method, notes: typeof body.notes === 'string' ? body.notes.trim() || null : null } } const writeDisposalSubmission = async ( tx: Prisma.TransactionClient, tree: DisposalTreeItem[], userId: number, input: ReturnType, estimatedValue = 0 ) => { const root = tree[0] const codeById = new Map(tree.map(item => [item.id, item.equipment_code])) const disposal = await tx.disposalRecord.create({ data: { equipment_id: root.id, equipment_code: root.equipment_code, disposal_reason: input.reason, disposal_method: input.method, estimated_value: estimatedValue, applied_by: userId, pre_status: root.status, notes: input.notes, items: { create: tree.map(item => ({ equipment_id: item.id, equipment_code: item.equipment_code, equipment_name: item.equipment_name, parent_equipment_id: item.parent_id, parent_equipment_code: item.parent_id === null ? null : codeById.get(item.parent_id) || null, pre_status: item.status, snapshot_json: JSON.stringify({ equipment_code: item.equipment_code, equipment_name: item.equipment_name, parent_id: item.parent_id, department_id: item.department_id, storage_location_id: item.storage_location_id, status: item.status, total_quantity: item.total_quantity, remaining_quantity: item.remaining_quantity }) })) }, actions: { create: { action_type: 'applied', operator_id: userId, from_status: null, to_status: 'pending', detail: input.reason } } }, select: { id: true, applied_at: true } }) for (const item of tree) await updateEquipmentLifecycle(tx, item, '待报废', item.status) return disposal } export const createDisposal = async (req: Request, res: Response) => { try { const { equipment_id, item_ids, estimated_value } = req.body as Record const userId = Number(res.locals.user?.id) const rootId = Number(equipment_id) if (!userId) return errorResponse(res, '用户未登录', 401) if (!Number.isInteger(rootId) || rootId <= 0) { return errorResponse(res, '请选择要报废的主资产', 422) } const input = readDisposalSubmission(req.body) const estimatedValue = Number(estimated_value ?? 0) if (!Number.isFinite(estimatedValue) || estimatedValue < 0) { return errorResponse(res, '残值估价必须是大于或等于0的有效数字', 422) } const createdId = await prisma.$transaction(async (tx) => { const tree = await loadAndLockAssetTree(tx, rootId) const root = tree[0] if (root.parent_id) { throw new Error('挂载中的子资产不能单独申请报废,请先卸载') } const requestedIds = Array.isArray(item_ids) ? [...new Set(item_ids.map(Number).filter((id) => Number.isInteger(id) && id > 0))] : [rootId] assertDisposalItemsConfirmed(tree, requestedIds) const blocked = getDisposalBlockedReason(tree) if (blocked) throw new Error(blocked) const occupancy = await getDisposalOccupancy(tx, tree.map(item => item.id)) const occupied = getDisposalBlockedReason(tree, occupancy) if (occupied) throw new Error(occupied) const disposal = await writeDisposalSubmission(tx, tree, userId, input, estimatedValue) const recipients = await getSubmissionRecipients(tx, userId) await createBusinessNotification(tx, { eventType: 'disposal_applied', businessType: 'disposal', businessId: disposal.id, title: `待审批报废:${root.equipment_name}`, content: `${res.locals.user?.name || res.locals.user?.username} 提交了 ${root.equipment_code} 的报废申请`, level: 'warning', actionUrl: `/workflows/disposals/${disposal.id}`, stationRecipients: recipients.stationRecipients, dingTalkRecipients: recipients.dingTalkRecipients, metadata: { equipment_code: root.equipment_code }, dingTalk: { title: '资产报废待审批', content: buildDisposalAppliedDingTalkContent({ appliedAt: disposal.applied_at, equipmentName: root.equipment_name, equipmentCode: root.equipment_code, applicantName: res.locals.user?.name || res.locals.user?.username, reason: input.reason }), actionTitle: '立即审批', messageVersion: 'v1' } }) return disposal.id }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }) const disposal = await prisma.disposalRecord.findUnique({ where: { id: createdId }, include: disposalInclude }) await logOperation( userId, res.locals.user?.username || res.locals.user?.name || 'unknown', '报废申请', `申请报废资产 ${disposal?.equipment_code},原因:${input.reason}`, rootId, disposal?.equipment_code, req.ip ) successResponse(res, disposal, '报废申请创建成功') } catch (error: any) { console.error('[创建报废申请失败]', error?.message || error) errorResponse(res, error.message || '创建报废申请失败', error.status || 422) } } const isEquipmentId = (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value > 0 export const previewBatchDisposal = async (req: Request, res: Response) => { try { if (!isEquipmentId(getCurrentUser(res).id)) return errorResponse(res, '用户未登录', 401) const { equipment_ids = [], equipment_codes = [] } = req.body || {} if (!Array.isArray(equipment_ids) || !equipment_ids.every(isEquipmentId) || !Array.isArray(equipment_codes) || !equipment_codes.every(code => typeof code === 'string' && code.trim())) { return errorResponse(res, '请提供有效的资产ID或编码', 422) } const limitMessage = `每批须包含 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个资产` const codes: string[] = equipment_codes.map(code => code.trim()) const uniqueIds = [...new Set(equipment_ids)] const uniqueCodes = new Map() for (const code of codes) { const key = code.toLowerCase() if (!uniqueCodes.has(key)) uniqueCodes.set(key, code) } if (uniqueIds.length + uniqueCodes.size === 0 || uniqueIds.length > MAX_DISPOSAL_BATCH_ROOTS || uniqueCodes.size > MAX_DISPOSAL_BATCH_ROOTS) { return errorResponse(res, limitMessage, 422) } const roots = await prisma.equipment.findMany({ where: { OR: [{ id: { in: uniqueIds } }, { equipment_code: { in: [...uniqueCodes.values()] } }] }, select: disposalTreeSelect }) const byId = new Map(roots.map(root => [root.id, root])) const byCode = new Map(roots.map(root => [root.equipment_code.toLowerCase(), root])) const inputs = [ ...equipment_ids.map(id => ({ key: `id:${id}`, label: String(id), root: byId.get(id), isCode: false })), ...codes.map(code => ({ key: `code:${code.toLowerCase()}`, label: code, root: byCode.get(code.toLowerCase()), isCode: true })) ] const seen = new Set() const duplicateCodes = new Map() const distinctInputs = inputs.filter(({ key, label, root, isCode }) => { const identity = root ? `id:${root.id}` : key if (seen.has(identity)) { const code = root?.equipment_code || label if ((root || isCode) && !duplicateCodes.has(code.toLowerCase())) duplicateCodes.set(code.toLowerCase(), code) return false } seen.add(identity) return true }) if (distinctInputs.length > MAX_DISPOSAL_BATCH_ROOTS) return errorResponse(res, limitMessage, 422) const trees = await loadDisposalTrees(prisma, roots) const treeIds = [...new Set([...trees.values()].flatMap(tree => tree.map(item => item.id)))] const occupancy = treeIds.length ? await getDisposalOccupancy(prisma, treeIds) : undefined const returnIds = [...new Set(roots.filter(isDisposalAutoReturnRoot) .flatMap(root => trees.get(root.id)!.map(item => item.id)))] const returnBorrows = await loadDisposalAutoReturnBorrows(prisma, returnIds) const candidates = distinctInputs.map(({ label, root }) => { const tree = root ? trees.get(root.id)! : [] const autoReturn = root && occupancy ? getDisposalAutoReturn(tree, occupancy, returnBorrows) : undefined return { equipment_id: root?.id ?? null, equipment_code: root?.equipment_code ?? label, equipment_name: root?.equipment_name ?? '', status: root?.status ?? '未找到', items: tree.map(({ id, equipment_code, equipment_name, total_quantity }) => ({ id, equipment_code, equipment_name, total_quantity })), blocked_reason: root ? getDisposalBlockedReason(tree, occupancy) : '未找到资产', ...(autoReturn ? { auto_return_token: autoReturn.token } : {}) } }) successResponse(res, { candidates, duplicate_codes: [...duplicateCodes.values()] }, '批量预检完成') } catch (error: any) { errorResponse(res, error.message || '批量报废预检失败', error.status || 422) } } export const createBatchDisposal = async (req: Request, res: Response) => { try { const userId = getCurrentUser(res).id if (!isEquipmentId(userId)) return errorResponse(res, '用户未登录', 401) const { assets } = req.body || {} if (!Array.isArray(assets) || assets.length < 1 || assets.length > MAX_DISPOSAL_BATCH_ROOTS) { return errorResponse(res, `每批须包含 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个主资产`, 422) } const input = readDisposalSubmission(req.body) const rootIds: number[] = [] const confirmed = new Map; autoReturnToken?: string }>() const lockedIds = new Set() for (const asset of assets) { if (!isEquipmentId(asset?.equipment_id) || !Array.isArray(asset.item_ids) || !asset.item_ids.every(isEquipmentId) || !asset.item_ids.includes(asset.equipment_id)) { return errorResponse(res, '请逐项确认报废明细,明细必须包含主资产', 422) } if (confirmed.has(asset.equipment_id)) return errorResponse(res, '批量报废包含重复主资产', 422) if (asset.auto_return_token !== undefined && (typeof asset.auto_return_token !== 'string' || !/^[a-f0-9]{64}$/.test(asset.auto_return_token))) { return errorResponse(res, '自动归还确认凭据无效,请重新预检', 422) } for (const id of asset.item_ids as number[]) { if (lockedIds.has(id)) return errorResponse(res, '批量报废明细包含重复资产', 422) lockedIds.add(id) } rootIds.push(asset.equipment_id) confirmed.set(asset.equipment_id, { itemIds: asset.item_ids, autoReturnToken: asset.auto_return_token, quantities: asset.confirmed_quantities === undefined ? undefined : readConfirmedDisposalQuantities(asset.confirmed_quantities) }) } const disposalIds = await prisma.$transaction(async tx => { // All confirmed assets are locked in ID order. Re-read the current trees // after locking; any unconfirmed descendant aborts before the first write. await lockEquipmentRows(tx, [...lockedIds]) const roots = await tx.equipment.findMany({ where: { id: { in: rootIds } }, select: disposalTreeSelect }) if (roots.length !== rootIds.length) throw new DisposalConflictError('有主资产已不存在,请重新预检') const originalDepartments = new Map(roots.map(root => [root.id, root.department_id])) const departmentIds = [...new Set(roots.flatMap(root => root.department_id === null ? [] : [root.department_id]))] const departments = departmentIds.length ? await tx.department.findMany({ where: { id: { in: departmentIds } }, select: { id: true, name: true } }) : [] const departmentNames = new Map(departments.map(department => [department.id, department.name])) const holders = new Map() let trees = await loadDisposalTrees(tx, roots) for (const id of rootIds) { const tree = trees.get(id)! const confirmation = confirmed.get(id)! if (!confirmation.autoReturnToken) { const blocked = getDisposalBlockedReason(tree) if (blocked) throw new DisposalConflictError(`${tree[0].equipment_code}:${blocked}`) } assertDisposalItemsConfirmed(tree, confirmation.itemIds) if (confirmation.quantities) assertConfirmedDisposalQuantities(tree, confirmation.quantities) } let occupancy = await getDisposalOccupancy(tx, [...lockedIds]) const returnRoots = rootIds.filter(id => confirmed.get(id)!.autoReturnToken) if (returnRoots.length) { const returnBorrows = await loadDisposalAutoReturnBorrows(tx, returnRoots.flatMap(id => confirmed.get(id)!.itemIds), true) const returns = returnRoots.map(id => { const items = trees.get(id)! const eligible = getDisposalAutoReturn(items, occupancy, returnBorrows) if (!eligible || eligible.token !== confirmed.get(id)!.autoReturnToken) { throw new DisposalConflictError(`${items[0].equipment_code}:借用或资产状态已变化,请重新预检后确认归还`) } return { items, borrowRecord: eligible.record } }) for (const { items, borrowRecord } of returns) { holders.set(items[0].id, borrowRecord.person_nickname.trim() || borrowRecord.person_name.trim() || '未登记领用人') await completeLockedBorrowReturn(tx, { items, borrowRecord, returnCondition: '正常', operatedBy: userId, reason: '批量报废前归还入库', requireUnreturned: true }) } const returnedRoots = await tx.equipment.findMany({ where: { id: { in: rootIds } }, select: disposalTreeSelect }) trees = await loadDisposalTrees(tx, returnedRoots) occupancy = await getDisposalOccupancy(tx, [...lockedIds]) } for (const id of rootIds) { const tree = trees.get(id)! const blocked = getDisposalBlockedReason(tree, occupancy) if (blocked) throw new DisposalConflictError(`${tree[0].equipment_code}:${blocked}`) } const created = [] for (const id of rootIds) created.push(await writeDisposalSubmission(tx, trees.get(id)!, userId, input)) const codes = rootIds.map(id => trees.get(id)![0].equipment_code) const ids = created.map(row => row.id) const userName = res.locals.user?.username || res.locals.user?.name || 'unknown' await tx.operationLog.createMany({ data: codes.map((code, index) => ({ user_id: userId, username: userName, operation_type: '报废申请', operation_details: `申请报废资产 ${code},原因:${input.reason}`, equipment_id: rootIds[index], equipment_code: code, ip_address: req.ip || null })) }) const recipients = await getSubmissionRecipients(tx, userId) const preview = codes.slice(0, 10).join('、') + (codes.length > 10 ? ` 等 ${codes.length} 个` : '') const [content, ...additionalContents] = buildBatchDisposalAppliedDingTalkContents({ appliedAt: created[0].applied_at, applicantName: res.locals.user?.name || userName, reason: input.reason, assets: rootIds.map(id => { const tree = trees.get(id)! const root = tree[0] const departmentId = originalDepartments.get(id) return { code: root.equipment_code, name: root.equipment_name, department: departmentId == null ? undefined : departmentNames.get(departmentId), holder: holders.get(id), accessoryCount: tree.length - 1 } }) }) await createBusinessNotification(tx, { ...recipients, eventType: 'disposal_applied', businessType: 'disposal', businessId: ids[0], title: `待审批报废:${ids.length} 笔`, content: `${res.locals.user?.name || userName} 提交了 ${ids.length} 笔报废申请:${preview}`, level: 'warning', actionUrl: '/workflows/disposals', metadata: { disposal_ids: ids, equipment_codes: codes, count: ids.length }, dingTalk: { title: '批量报废待审批', actionTitle: '查看待审批', messageVersion: 'columns-v3', content, additionalContents } }) return ids }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted, timeout: 30000 }) successResponse(res, { count: disposalIds.length, disposal_ids: disposalIds }, '批量报废申请创建成功') } catch (error: any) { console.error('[批量创建报废申请失败]', error?.message || error) errorResponse(res, error.message || '批量创建报废申请失败', error.status || 422) } } export const getDisposalList = async (req: Request, res: Response) => { try { const { page = 1, pageSize = 10, status, keyword, equipment_id, scope } = req.query const currentPage = parseListPositiveInteger(page, '页码', 1) const currentPageSize = parseListPositiveInteger(pageSize, '每页数量', 10, 100) const currentUser = getCurrentUser(res) if (!Number.isInteger(currentUser.id) || currentUser.id <= 0) { return errorResponse(res, '用户未登录', 401) } const resolvedScope = String(scope || (currentUser.role === 'admin' ? 'all' : currentUser.role === 'administrative' ? 'pending' : 'mine')) const validScopes = ['all', 'mine', 'pending', 'processed'] if (!validScopes.includes(resolvedScope)) { return errorResponse(res, '报废列表范围无效', 422) } const summaryConditions: Prisma.DisposalRecordWhereInput[] = [getDisposalVisibility(res)] if (currentUser.role === 'administrative' && resolvedScope === 'all') { return errorResponse(res, '行政仅可查看本人发起、全部待审批和全部已处理报废流程', 403) } if (currentUser.role !== 'it') { if (resolvedScope === 'mine') { summaryConditions.push({ applied_by: currentUser.id }) } else if (resolvedScope === 'pending') { summaryConditions.push({ status: 'pending' }) } else if (resolvedScope === 'processed') { summaryConditions.push({ status: { in: ['approved', 'rejected', 'completed'] } }) } } const normalizedStatus = String(status || '').trim() if (normalizedStatus && !DISPOSAL_STATUSES.includes(normalizedStatus as any)) { return errorResponse(res, '报废状态无效', 422) } if (equipment_id !== undefined && equipment_id !== '') { summaryConditions.push({ equipment_id: parseListPositiveInteger(equipment_id, '资产ID', 0) }) } const normalizedKeyword = String(keyword || '').trim() if (normalizedKeyword) { const keywordWhere = [ { equipment_code: { contains: normalizedKeyword } }, { disposal_reason: { contains: normalizedKeyword } }, { items: { some: { equipment_code: { contains: normalizedKeyword } } } } ] summaryConditions.push({ OR: keywordWhere }) } const summaryWhere: Prisma.DisposalRecordWhereInput = summaryConditions.length > 0 ? { AND: summaryConditions } : {} const where: Prisma.DisposalRecordWhereInput = normalizedStatus ? { AND: [summaryWhere, { status: normalizedStatus }] } : summaryWhere const skip = (currentPage - 1) * currentPageSize const [list, total, statusGroups] = await Promise.all([ prisma.disposalRecord.findMany({ where, skip, take: currentPageSize, orderBy: [{ created_at: 'desc' }, { id: 'desc' }], include: { equipment: { select: { equipment_name: true, equipment_type: true, unit_price: true } }, applier: { select: { id: true, name: true, username: true } }, approver: { select: { id: true, name: true, username: true } }, completer: { select: { id: true, name: true, username: true } }, _count: { select: { items: true } } } }), prisma.disposalRecord.count({ where }), prisma.disposalRecord.groupBy({ by: ['status'], where: summaryWhere, _count: { _all: true } }) ]) const summary = { total: 0, pending: 0, approved: 0, rejected: 0, completed: 0 } for (const group of statusGroups) { const count = group._count._all summary.total += count if (DISPOSAL_STATUSES.includes(group.status as any)) { summary[group.status as (typeof DISPOSAL_STATUSES)[number]] = count } } successResponse( res, { list: list.map(withHistoricalDisposalNotes), total, page: currentPage, pageSize: currentPageSize, summary }, '获取成功' ) } catch (error: any) { errorResponse(res, error.message || '获取报废记录列表失败', error.status || 500) } } export const getDisposalDetail = async (req: Request, res: Response) => { try { const visibility = getDisposalVisibility(res) const disposalId = parseListPositiveInteger(req.params.id, '报废记录ID', 0) const disposal = await prisma.disposalRecord.findUnique({ where: { id: disposalId }, include: disposalInclude }) if (!disposal) return errorResponse(res, '报废记录不存在', 404) if (visibility.applied_by && disposal.applied_by !== visibility.applied_by) { return errorResponse(res, '无权查看该报废申请', 403) } successResponse(res, { ...withHistoricalDisposalNotes(disposal), requires_quantity_confirmation: disposal.items.some(item => { const snapshot = readDisposalItemSnapshot(item.snapshot_json) return snapshot !== null && snapshot.total_quantity === undefined }) }, '获取成功') } catch (error: any) { errorResponse(res, error.message || '获取报废记录详情失败', error.status || 500) } } const disposalDecisionInclude = { items: { include: { equipment: true } } } as const type DisposalDecisionRecord = Prisma.DisposalRecordGetPayload<{ include: typeof disposalDecisionInclude }> const getDisposalDecisionRoot = (disposal: DisposalDecisionRecord, expectedStatus: string, equipmentIds: Set) => { if (disposal.status !== expectedStatus) throw new DisposalConflictError('该申请已被其他人处理,请刷新后查看') const root = disposal.items.find(item => item.equipment_id === disposal.equipment_id)?.equipment if (!root || root.parent_id !== null || !equipmentIds.has(root.id) || disposal.items.some(item => !equipmentIds.has(item.equipment_id))) { throw new DisposalConflictError('报废明细范围已变化或缺少主资产,请先核查') } return root } const assertDisposalDecisionTree = (disposal: DisposalDecisionRecord, tree: DisposalTreeItem[]) => { assertDisposalItemsConfirmed(tree, disposal.items.map(item => item.equipment_id)) const changedItem = disposal.items.find(item => item.equipment.status !== '待报废' || item.equipment.parent_id !== item.parent_equipment_id) if (changedItem) throw new DisposalConflictError(`资产 ${changedItem.equipment_code} 的状态或挂载关系已变化,请先核查`) } const loadLockedDisposalDecision = async (tx: Prisma.TransactionClient, id: number, expectedStatus: string) => { const initial = await tx.disposalRecord.findUnique({ where: { id }, include: disposalDecisionInclude }) if (!initial) throw Object.assign(new Error('报废记录不存在'), { status: 404 }) const equipmentIds = new Set([initial.equipment_id, ...initial.items.map(item => item.equipment_id)]) await lockEquipmentRows(tx, [...equipmentIds]) const disposal = await tx.disposalRecord.findUnique({ where: { id }, include: disposalDecisionInclude }) if (!disposal) throw new DisposalConflictError('该申请已被其他人处理,请刷新后查看') const root = getDisposalDecisionRoot(disposal, expectedStatus, equipmentIds) const trees = await loadDisposalTrees(tx, [root]) assertDisposalDecisionTree(disposal, trees.get(root.id)!) return disposal } const verifyDisposalQuantities = async ( tx: Prisma.TransactionClient, disposal: DisposalDecisionRecord, confirmation?: Map ) => { if (confirmation) assertConfirmedDisposalQuantities(disposal.items.map(item => item.equipment), confirmation) let restoredSnapshot = false for (const item of disposal.items) { const { total_quantity, remaining_quantity } = item.equipment if (total_quantity < 1 || remaining_quantity !== total_quantity) { throw new DisposalConflictError(`资产 ${item.equipment_code} 的库存与报废数量不一致,请先核查`) } const snapshot = readDisposalItemSnapshot(item.snapshot_json) if (!snapshot) { throw new DisposalConflictError(`资产 ${item.equipment_code} 的报废快照无法读取,请先核查`) } if (snapshot.total_quantity === undefined) { if (!confirmation) { throw new DisposalConflictError(`资产 ${item.equipment_code} 的历史报废申请未记录数量,请由审批人逐件核对并确认`) } await tx.disposalItem.update({ where: { id: item.id }, data: { snapshot_json: JSON.stringify({ ...snapshot, total_quantity, remaining_quantity }) } }) restoredSnapshot = true } else if (snapshot.total_quantity !== total_quantity || (snapshot.remaining_quantity !== undefined && snapshot.remaining_quantity !== remaining_quantity)) { throw new DisposalConflictError(`资产 ${item.equipment_code} 的数量与报废快照不一致,请先核查`) } } return restoredSnapshot } const assertConfirmedDisposalQuantities = ( items: Array>, confirmation: Map ) => { if (confirmation.size !== items.length) { throw new DisposalConflictError('确认数量的资产范围已变化,请刷新后逐件核对') } const changed = items.find(item => confirmation.get(item.id) !== item.total_quantity) if (changed) { throw new DisposalConflictError(`资产 ${changed.equipment_code} 的数量与本次确认不一致,请刷新后重新核对`) } } const readConfirmedDisposalQuantities = (input: unknown) => { if (!Array.isArray(input) || input.length === 0) { throw Object.assign(new Error('请逐件确认报废资产数量'), { status: 422 }) } const confirmed = new Map() for (const item of input) { const id = item?.equipment_id const quantity = item?.total_quantity if (!Number.isSafeInteger(id) || id < 1 || !Number.isSafeInteger(quantity) || quantity < 1 || confirmed.has(id)) { throw Object.assign(new Error('报废数量确认无效,每件资产须提供唯一 ID 和正整数数量'), { status: 422 }) } confirmed.set(id, quantity) } return confirmed } const readDisposalDecision = (body: { approved?: unknown; reject_reason?: unknown }) => { const { approved, reject_reason } = body if (typeof approved !== 'boolean') { throw Object.assign(new Error('审批结果必须明确为通过或驳回'), { status: 422 }) } const rejectReason = typeof reject_reason === 'string' ? reject_reason.trim() : '' if (!approved && !rejectReason) { throw Object.assign(new Error('驳回原因不能为空'), { status: 422 }) } return { approved, rejectReason } } type DisposalDecision = ReturnType const writeDisposalDecision = async ( tx: Prisma.TransactionClient, disposal: DisposalDecisionRecord, decision: DisposalDecision, userId: number, approvedAt: Date, confirmation?: Map ) => { const { approved, rejectReason } = decision if (approved) await verifyDisposalQuantities(tx, disposal, confirmation) const nextStatus = approved ? 'approved' : 'rejected' const updated = await tx.disposalRecord.updateMany({ where: { id: disposal.id, status: 'pending' }, data: { status: nextStatus, approved_by: userId, approved_at: approvedAt, reject_reason: approved ? null : rejectReason } }) if (updated.count !== 1) { throw new DisposalConflictError('该申请已被其他人处理,请刷新后查看') } if (!approved) { for (const item of disposal.items) { await updateEquipmentLifecycle(tx, item.equipment, item.pre_status, '待报废', item.parent_equipment_id) } } await tx.disposalAction.create({ data: { disposal_id: disposal.id, action_type: nextStatus, operator_id: userId, from_status: 'pending', to_status: nextStatus, detail: approved ? null : rejectReason } }) } const getDisposalDecisionOperation = (disposal: DisposalDecisionRecord, approved: boolean) => ({ operation_type: approved ? '报废审批通过' : '报废审批驳回', operation_details: `${approved ? '批准' : '驳回'}资产 ${disposal.equipment_code} 的报废申请` }) export const approveDisposal = async (req: Request, res: Response) => { try { const disposalId = Number(req.params.id) const body = (req.body || {}) as { approved?: boolean reject_reason?: string confirmed_quantities?: unknown reconfirm_quantities?: boolean } const decision = readDisposalDecision(body) const { approved, rejectReason } = decision const { confirmed_quantities, reconfirm_quantities } = body const userId = Number(res.locals.user?.id) if (reconfirm_quantities === true && !approved) { return errorResponse(res, '数量复核必须明确确认通过', 422) } const confirmation = approved && (confirmed_quantities !== undefined || reconfirm_quantities === true) ? readConfirmedDisposalQuantities(confirmed_quantities) : undefined if (reconfirm_quantities === true) { await prisma.$transaction(async tx => { const disposal = await loadLockedDisposalDecision(tx, disposalId, 'approved') if (!await verifyDisposalQuantities(tx, disposal, confirmation)) { throw new DisposalConflictError('该报废单已记录数量,请刷新后查看') } await tx.disposalAction.create({ data: { disposal_id: disposalId, operator_id: userId, action_type: 'quantity_confirmed', from_status: 'approved', to_status: 'approved', detail: JSON.stringify(disposal.items.map(item => ({ equipment_id: item.equipment_id, total_quantity: item.equipment.total_quantity }))) } }) }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }) return successResponse(res, null, '报废数量已复核') } const result = await prisma.$transaction(async (tx) => { const disposal = await loadLockedDisposalDecision(tx, disposalId, 'pending') const approvedAt = new Date() await writeDisposalDecision(tx, disposal, decision, userId, approvedAt, confirmation) const recipients = await getResultRecipients(tx, disposal.applied_by) const rootItem = disposal.items.find((item) => item.equipment_id === disposal.equipment_id) await createBusinessNotification(tx, { eventType: approved ? 'disposal_approved' : 'disposal_rejected', businessType: 'disposal', businessId: disposal.id, title: approved ? `报废已审批:${disposal.equipment_code}` : `报废已驳回:${disposal.equipment_code}`, content: approved ? '报废申请已审批通过,等待完成处置' : `驳回原因:${rejectReason}`, level: approved ? 'success' : 'warning', actionUrl: `/workflows/disposals/${disposal.id}`, stationRecipients: recipients.stationRecipients, dingTalkRecipients: recipients.dingTalkRecipients, dingTalk: approved ? { title: '资产报废审批已通过', content: buildDisposalApprovedDingTalkContent({ approvedAt, equipmentName: rootItem?.equipment.equipment_name, equipmentCode: disposal.equipment_code, approverName: res.locals.user?.name || res.locals.user?.username }), actionTitle: '查看审批结果', messageVersion: 'v1' } : { title: '资产报废申请已驳回', content: buildDisposalRejectedDingTalkContent({ rejectedAt: approvedAt, equipmentName: rootItem?.equipment.equipment_name, equipmentCode: disposal.equipment_code, rejectorName: res.locals.user?.name || res.locals.user?.username, reason: rejectReason }), actionTitle: '查看申请', messageVersion: 'v1' } }) return disposal }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }) const operation = getDisposalDecisionOperation(result, approved) await logOperation( userId, res.locals.user?.username || res.locals.user?.name || 'unknown', operation.operation_type, operation.operation_details, result.equipment_id, result.equipment_code, req.ip ) successResponse(res, null, approved ? '审批通过' : '已驳回') } catch (error: any) { errorResponse(res, error.message || '审批失败', error.status || 500) } } const throwBatchDisposalConflict = (equipmentCode: string, error: unknown): never => { if (error instanceof DisposalConflictError) { throw new DisposalConflictError(`${equipmentCode}:${error.message}`) } throw error } const loadLockedBatchDisposalDecisions = async (tx: Prisma.TransactionClient, disposalIds: number[]) => { const initial = await tx.disposalRecord.findMany({ where: { id: { in: disposalIds } }, select: { id: true, equipment_id: true, equipment_code: true, items: { select: { equipment_id: true } } } }) const initialById = new Map(initial.map(disposal => [disposal.id, disposal])) const equipmentIdsByDisposal = new Map>() const equipmentIds = new Set() for (const id of disposalIds) { const disposal = initialById.get(id) if (!disposal) throw new DisposalConflictError(`报废单 ${id} 不存在,请刷新列表`) const ids = new Set([disposal.equipment_id, ...disposal.items.map(item => item.equipment_id)]) for (const equipmentId of ids) { if (equipmentIds.has(equipmentId)) { throw new DisposalConflictError(`${disposal.equipment_code}:本批报废单的资产范围重叠,请逐单核查`) } equipmentIds.add(equipmentId) } equipmentIdsByDisposal.set(id, ids) } await lockEquipmentRows(tx, [...equipmentIds]) const current = await tx.disposalRecord.findMany({ where: { id: { in: disposalIds } }, include: disposalDecisionInclude }) const currentById = new Map(current.map(disposal => [disposal.id, disposal])) const decisions = disposalIds.map(id => { const disposal = currentById.get(id) const equipmentCode = initialById.get(id)!.equipment_code if (!disposal) throw new DisposalConflictError(`${equipmentCode}:报废单已移除,请刷新列表`) try { const root = getDisposalDecisionRoot(disposal, 'pending', equipmentIdsByDisposal.get(id)!) return { disposal, root } } catch (error) { return throwBatchDisposalConflict(equipmentCode, error) } }) const trees = await loadDisposalTrees(tx, decisions.map(({ root }) => root)) return decisions.map(({ disposal, root }) => { try { assertDisposalDecisionTree(disposal, trees.get(root.id)!) return disposal } catch (error) { return throwBatchDisposalConflict(disposal.equipment_code, error) } }) } const notifyBatchDisposalDecisions = async ( tx: Prisma.TransactionClient, disposals: DisposalDecisionRecord[], { approved, rejectReason }: DisposalDecision, operatorName: string, decidedAt: Date ) => { const byApplicant = new Map() for (const disposal of disposals) { const group = byApplicant.get(disposal.applied_by) if (group) group.push(disposal) else byApplicant.set(disposal.applied_by, [disposal]) } const statusText = approved ? '已通过' : '已驳回' for (const [applicantId, group] of byApplicant) { const codes = group.map(disposal => disposal.equipment_code) const summary = codes.slice(0, 10).join('、') + (codes.length > 10 ? ` 等 ${codes.length} 个` : '') const recipients = await getResultRecipients(tx, applicantId) const title = `报废批量审批${statusText}:${group.length} 笔` await createBusinessNotification(tx, { ...recipients, eventType: approved ? 'disposal_approved' : 'disposal_rejected', businessType: 'disposal', businessId: group[0].id, title, content: `${group.length} 笔报废申请${statusText}(${summary})${approved ? ',等待处置' : `。驳回原因:${rejectReason}`}`, level: approved ? 'success' : 'warning', actionUrl: group.length === 1 ? `/workflows/disposals/${group[0].id}` : '/workflows/disposals?scope=processed', metadata: { disposal_ids: group.map(disposal => disposal.id), equipment_codes: codes, count: group.length }, dingTalk: { title, actionTitle: '查看审批结果', messageVersion: 'v1', content: [ `**审批时间:** ${formatBeijingDateTime(decidedAt)}`, `**审批人:** ${escapeNotificationMarkdownInline(operatorName)}`, `**审批结果:** ${group.length} 笔${statusText}(${escapeNotificationMarkdownInline(summary)})`, approved ? '> 报废单现已进入待处置阶段。' : `**驳回原因:** ${escapeNotificationMarkdownInline(rejectReason)}` ].join('\n\n') } }) } } export const approveBatchDisposal = async (req: Request, res: Response) => { try { const { id: userId } = getCurrentUser(res) if (!isEquipmentId(userId)) return errorResponse(res, '用户未登录', 401) const body = req.body || {} const disposalIds = body.disposal_ids if (!Array.isArray(disposalIds) || disposalIds.length < 1 || disposalIds.length > MAX_DISPOSAL_BATCH_ROOTS || !disposalIds.every(isEquipmentId) || new Set(disposalIds).size !== disposalIds.length) { return errorResponse(res, `每批须提供 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个不重复的有效报废单 ID`, 422) } const decision = readDisposalDecision(body) const operator = res.locals.user const operatorName = operator?.name || operator?.username || 'unknown' await prisma.$transaction(async tx => { const disposals = await loadLockedBatchDisposalDecisions(tx, disposalIds) const decidedAt = new Date() for (const disposal of disposals) { try { await writeDisposalDecision(tx, disposal, decision, userId, decidedAt) } catch (error) { throwBatchDisposalConflict(disposal.equipment_code, error) } } await tx.operationLog.createMany({ data: disposals.map(disposal => ({ ...getDisposalDecisionOperation(disposal, decision.approved), user_id: userId, username: operator?.username || operatorName, equipment_id: disposal.equipment_id, equipment_code: disposal.equipment_code, ip_address: req.ip || null })) }) await notifyBatchDisposalDecisions(tx, disposals, decision, operatorName, decidedAt) }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted, timeout: 30000 }) successResponse(res, { count: disposalIds.length, disposal_ids: disposalIds }, decision.approved ? '批量审批通过' : '批量驳回成功') } catch (error: any) { errorResponse(res, error.message || '批量审批失败', error.status || 500) } } export const completeDisposal = async (req: Request, res: Response) => { try { const disposalId = Number(req.params.id) const { actual_value, completion_notes, notes } = req.body as Record const userId = Number(res.locals.user?.id) const actualValue = actual_value === undefined ? undefined : Number(actual_value) if (actualValue !== undefined && (!Number.isFinite(actualValue) || actualValue < 0)) { return errorResponse(res, '实际处置价值必须是大于或等于0的有效数字', 422) } const result = await prisma.$transaction(async (tx) => { const disposal = await loadLockedDisposalDecision(tx, disposalId, 'approved') await verifyDisposalQuantities(tx, disposal) const completedAt = new Date() const updated = await tx.disposalRecord.updateMany({ where: { id: disposalId, status: 'approved' }, data: { status: 'completed', actual_value: actualValue !== undefined ? actualValue : disposal.estimated_value, completed_at: completedAt, completed_by: userId, completion_notes: completion_notes?.trim() || notes?.trim() || null } }) if (updated.count !== 1) { throw new DisposalConflictError('该申请状态已变化,请刷新后查看') } for (const item of disposal.items) { await updateEquipmentLifecycle( tx, item.equipment, '已报废', '待报废', item.parent_equipment_id ) } await tx.disposalAction.create({ data: { disposal_id: disposalId, action_type: 'completed', operator_id: userId, from_status: 'approved', to_status: 'completed', detail: completion_notes?.trim() || notes?.trim() || null } }) const recipients = await getResultRecipients(tx, disposal.applied_by) const rootItem = disposal.items.find((item) => item.equipment_id === disposal.equipment_id) await createBusinessNotification(tx, { eventType: 'disposal_completed', businessType: 'disposal', businessId: disposal.id, title: `报废处置已完成:${disposal.equipment_code}`, content: completion_notes?.trim() || notes?.trim() || '资产已完成报废处置', level: 'success', actionUrl: `/workflows/disposals/${disposal.id}`, stationRecipients: recipients.stationRecipients, dingTalkRecipients: recipients.dingTalkRecipients, dingTalk: { title: '资产报废处置已完成', content: buildDisposalCompletedDingTalkContent({ completedAt, equipmentName: rootItem?.equipment.equipment_name, equipmentCode: disposal.equipment_code, completerName: res.locals.user?.name || res.locals.user?.username, notes: completion_notes?.trim() || notes?.trim() }), actionTitle: '查看结果', messageVersion: 'v1' } }) return disposal }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }) await logOperation( userId, res.locals.user?.username || res.locals.user?.name || 'unknown', '报废完成', `完成资产 ${result.equipment_code} 的报废处置`, result.equipment_id, result.equipment_code, req.ip ) successResponse(res, null, '报废处置完成') } catch (error: any) { errorResponse(res, error.message || '完成报废处置失败', error.status || 500) } } export const getEquipmentDisposalHistory = async (req: Request, res: Response) => { try { const visibility = getDisposalVisibility(res) const equipmentId = parseListPositiveInteger(req.params.equipment_id, '资产ID', 0) const history = await prisma.disposalRecord.findMany({ where: { AND: [visibility, { OR: [ { equipment_id: equipmentId }, { items: { some: { equipment_id: equipmentId } } } ] }] }, orderBy: { created_at: 'desc' }, include: { applier: { select: { id: true, name: true } }, approver: { select: { id: true, name: true } }, completer: { select: { id: true, name: true } }, items: true, actions: { orderBy: { created_at: 'asc' } } } }) successResponse(res, history, '获取成功') } catch (error: any) { errorResponse(res, error.message || '获取报废历史失败', error.status || 500) } }