GuDingZiChan/backend/src/controllers/disposalController.ts
2026-11-12 15:36:41 +08:00

1483 lines
66 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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 { PERMISSIONS, roleHasPermission } from '../utils/permissions'
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 = <T extends { id: number }>(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 canReadDisposal = (visibility: Prisma.DisposalRecordWhereInput, record: { applied_by: number }) =>
!visibility.applied_by || visibility.applied_by === record.applied_by
const DISPOSAL_STATUSES = ['pending', 'approved', 'rejected', 'completed', 'cancelled'] 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 = <T extends {
status: string
notes?: string | null
completion_notes?: string | null
}>(record: T) => ({
...record,
historical_notes:
record.status === 'completed' && record.notes && !record.completion_notes
? record.notes
: null
})
const readDisposalItemSnapshot = (snapshot: string | null): Record<string, unknown> | 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<string, unknown>) => {
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<typeof readDisposalSubmission>, 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,
confirmed_quantities
} = req.body as Record<string, any>
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)
if (confirmed_quantities == null) return errorResponse(res, '缺少报废数量确认,请刷新页面后逐件核对数量', 422)
const quantities = readConfirmedDisposalQuantities(confirmed_quantities)
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)
assertConfirmedDisposalQuantities(tree, quantities)
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 {
const user = getCurrentUser(res)
if (!isEquipmentId(user.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<string, string>()
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<string>()
const duplicateCodes = new Map<string, string>()
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 visibility = roleHasPermission(user.role, PERMISSIONS.NOTIFICATIONS_VIEW) ? getDisposalVisibility(res) : undefined
const candidates = distinctInputs.map(({ label, root }) => {
const tree = root ? trees.get(root.id)! : []
const autoReturn = root && occupancy ? getDisposalAutoReturn(tree, occupancy, returnBorrows) : undefined
const blockingAsset = occupancy && tree.find(item => occupancy.disposal.has(item.id))
const blocker = blockingAsset && occupancy?.disposal.get(blockingAsset.id)
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) : '未找到资产',
...(blocker ? { blocking_disposal: {
id: visibility && canReadDisposal(visibility, blocker) ? blocker.id : null,
status: blocker.status
} } : {}),
...(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<number, {
itemIds: number[]
quantities?: Map<number, number>
autoReturn?: { token: string; condition: '正常' | '损坏' }
}>()
const lockedIds = new Set<number>()
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)
}
if (asset.auto_return_token && asset.auto_return_condition !== '正常' && asset.auto_return_condition !== '损坏') {
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,
autoReturn: asset.auto_return_token
? { token: asset.auto_return_token, condition: asset.auto_return_condition } : undefined,
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<number, string>()
let trees = await loadDisposalTrees(tx, roots)
for (const id of rootIds) {
const tree = trees.get(id)!
const confirmation = confirmed.get(id)!
if (!confirmation.autoReturn) {
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)!.autoReturn)
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)
const { token, condition } = confirmed.get(id)!.autoReturn!
if (!eligible || eligible.token !== token) {
throw new DisposalConflictError(`${items[0].equipment_code}:借用或资产状态已变化,请重新预检后确认归还`)
}
return { items, borrowRecord: eligible.record, condition }
})
for (const { items, borrowRecord, condition } of returns) {
holders.set(items[0].id, borrowRecord.person_nickname.trim() || borrowRecord.person_name.trim() || '未登记领用人')
await completeLockedBorrowReturn(tx, {
items, borrowRecord, returnCondition: condition, 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', 'cancelled'] } })
}
}
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,
cancelled: 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 (!canReadDisposal(visibility, disposal)) {
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<number>) => {
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<number, number>
) => {
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<Pick<DisposalTreeItem, 'id' | 'equipment_code' | 'total_quantity'>>,
confirmation: Map<number, number>
) => {
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<number, number>()
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<typeof readDisposalDecision>
const restoreDisposalPreStatuses = async (tx: Prisma.TransactionClient, disposal: DisposalDecisionRecord) => {
for (const item of disposal.items) {
await updateEquipmentLifecycle(tx, item.equipment, item.pre_status, '待报废', item.parent_equipment_id)
}
}
const writeDisposalDecision = async (
tx: Prisma.TransactionClient,
disposal: DisposalDecisionRecord,
decision: DisposalDecision,
userId: number,
approvedAt: Date,
confirmation?: Map<number, number>
) => {
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) await restoreDisposalPreStatuses(tx, disposal)
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 readBatchDisposalIds = (value: unknown): number[] => {
if (!Array.isArray(value) || value.length < 1 || value.length > MAX_DISPOSAL_BATCH_ROOTS ||
!value.every(isEquipmentId) || new Set(value).size !== value.length) {
throw Object.assign(new Error(`每批须提供 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个不重复的有效报废单 ID`), { status: 422 })
}
return value
}
const loadLockedBatchDisposalDecisions = async (
tx: Prisma.TransactionClient, disposalIds: number[], expectedStatus: 'pending' | 'approved'
) => {
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<number, Set<number>>()
const equipmentIds = new Set<number>()
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, expectedStatus, 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 groupDisposalsByApplicant = (disposals: DisposalDecisionRecord[]) => {
const byApplicant = new Map<number, DisposalDecisionRecord[]>()
for (const disposal of disposals) {
const group = byApplicant.get(disposal.applied_by)
if (group) group.push(disposal)
else byApplicant.set(disposal.applied_by, [disposal])
}
return byApplicant
}
const notifyBatchDisposalDecisions = async (
tx: Prisma.TransactionClient,
disposals: DisposalDecisionRecord[],
{ approved, rejectReason }: DisposalDecision,
operatorName: string,
decidedAt: Date
) => {
const statusText = approved ? '已通过' : '已驳回'
for (const [applicantId, group] of groupDisposalsByApplicant(disposals)) {
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 = readBatchDisposalIds(body.disposal_ids)
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, 'pending')
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 cancelDisposal = async (req: Request, res: Response) => {
try {
const { id: userId } = getCurrentUser(res)
if (!isEquipmentId(userId)) return errorResponse(res, '用户未登录', 401)
const disposalId = parseListPositiveInteger(req.params.id, '报废记录ID', 0)
const reason = typeof req.body?.cancel_reason === 'string' ? req.body.cancel_reason.trim() : ''
if (!reason) return errorResponse(res, '撤销原因不能为空', 422)
const operator = res.locals.user?.name || res.locals.user?.username
await prisma.$transaction(async tx => {
const disposal = await loadLockedDisposalDecision(tx, disposalId, 'approved')
const updated = await tx.disposalRecord.updateMany({
where: { id: disposalId, status: 'approved', completed_at: null },
data: { status: 'cancelled' }
})
if (updated.count !== 1) throw new DisposalConflictError('该申请已处置或状态已变化,请刷新后查看')
await restoreDisposalPreStatuses(tx, disposal)
await tx.disposalAction.create({
data: {
disposal_id: disposalId, operator_id: userId, action_type: 'cancelled',
from_status: 'approved', to_status: 'cancelled', detail: reason
}
})
await tx.operationLog.create({
data: {
user_id: userId, username: res.locals.user?.username || operator || 'unknown',
operation_type: '报废撤销', operation_details: `撤销资产 ${disposal.equipment_code} 的报废申请,原因:${reason}`,
equipment_id: disposal.equipment_id, equipment_code: disposal.equipment_code, ip_address: req.ip || null
}
})
const recipients = await getResultRecipients(tx, disposal.applied_by)
const root = disposal.items.find(item => item.equipment_id === disposal.equipment_id)?.equipment
await createBusinessNotification(tx, {
...recipients, eventType: 'disposal_cancelled', businessType: 'disposal', businessId: disposalId,
title: `报废已撤销:${disposal.equipment_code}`, content: `撤销原因:${reason}`,
level: 'warning', actionUrl: `/workflows/disposals/${disposalId}`,
dingTalk: {
title: '资产报废已撤销', actionTitle: '查看结果',
content: [
`**资产:** ${assetNotificationName(root?.equipment_name, disposal.equipment_code)}`,
`**撤销人:** ${escapeNotificationMarkdownInline(operator)}`,
`**撤销原因:** ${escapeNotificationMarkdownInline(reason)}`
].join('\n\n')
}
})
}, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted })
successResponse(res, null, '报废已撤销')
} catch (error: any) {
errorResponse(res, error.message || '撤销报废失败', error.status || 500)
}
}
const writeDisposalCompletion = async (
tx: Prisma.TransactionClient,
disposal: DisposalDecisionRecord,
completedBy: number,
completedAt: Date,
completionNotes: string | null,
actualValue?: number
) => {
await verifyDisposalQuantities(tx, disposal)
const updated = await tx.disposalRecord.updateMany({
where: { id: disposal.id, status: 'approved', completed_at: null },
data: {
status: 'completed', actual_value: actualValue ?? disposal.estimated_value,
completed_at: completedAt, completed_by: completedBy, completion_notes: completionNotes
}
})
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: disposal.id, action_type: 'completed', operator_id: completedBy,
from_status: 'approved', to_status: 'completed', detail: completionNotes
}
})
}
const notifyBatchDisposalCompletions = async (
tx: Prisma.TransactionClient,
disposals: DisposalDecisionRecord[],
operatorName: string,
completedAt: Date,
completionNotes: string
) => {
for (const [applicantId, group] of groupDisposalsByApplicant(disposals)) {
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 = `报废处置已完成:${group.length} 笔`
await createBusinessNotification(tx, {
...recipients, eventType: 'disposal_completed', businessType: 'disposal', businessId: group[0].id,
title, level: 'success',
content: `${group.length} 笔报废申请已完成处置(${summary})。完成说明:${completionNotes}`,
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(completedAt)}`,
`**完成人:** ${escapeNotificationMarkdownInline(operatorName)}`,
`**处置结果:** ${group.length} 笔已完成报废(${escapeNotificationMarkdownInline(summary)})`,
`**完成说明:** ${escapeNotificationMarkdownInline(completionNotes)}`
].join('\n\n')
}
})
}
}
export const completeBatchDisposal = async (req: Request, res: Response) => {
try {
const { id: userId } = getCurrentUser(res)
if (!isEquipmentId(userId)) return errorResponse(res, '用户未登录', 401)
const body = req.body || {}
const disposalIds = readBatchDisposalIds(body.disposal_ids)
const completionNotes = typeof body.completion_notes === 'string' ? body.completion_notes.trim() : ''
if (!completionNotes) return errorResponse(res, '完成说明不能为空', 422)
const operator = res.locals.user
const operatorName = operator?.name || operator?.username || 'unknown'
await prisma.$transaction(async tx => {
const disposals = await loadLockedBatchDisposalDecisions(tx, disposalIds, 'approved')
const completedAt = new Date()
for (const disposal of disposals) {
try {
await writeDisposalCompletion(tx, disposal, userId, completedAt, completionNotes)
} catch (error) {
throwBatchDisposalConflict(disposal.equipment_code, error)
}
}
await tx.operationLog.createMany({ data: disposals.map(disposal => ({
user_id: userId, username: operator?.username || operatorName,
operation_type: '报废完成', operation_details: `完成资产 ${disposal.equipment_code} 的报废处置`,
equipment_id: disposal.equipment_id, equipment_code: disposal.equipment_code, ip_address: req.ip || null
})) })
await notifyBatchDisposalCompletions(tx, disposals, operatorName, completedAt, completionNotes)
}, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted, timeout: 30000 })
successResponse(res, { count: disposalIds.length, disposal_ids: disposalIds }, '批量报废处置完成')
} 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<string, any>
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')
const completedAt = new Date()
const completionNotes = completion_notes?.trim() || notes?.trim() || null
await writeDisposalCompletion(tx, disposal, userId, completedAt, completionNotes, actualValue)
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: completionNotes || '资产已完成报废处置',
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: completionNotes
}),
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)
}
}