GuDingZiChan/backend/src/utils/disposalSubmission.ts

157 lines
7.0 KiB
TypeScript

import { Prisma } from '@prisma/client'
import { buildReturnConfirmationToken, getReturnChildrenDiff } from './returnSnapshot'
export const MAX_DISPOSAL_BATCH_ROOTS = 500
export const disposalTreeSelect = {
id: true, equipment_code: true, equipment_name: true, equipment_model: true, equipment_type: true, parent_id: true,
department_id: true, storage_location_id: true, status: true, mount_status: true,
total_quantity: true, remaining_quantity: true, unit_price: true, updated_at: true
} as const
export type DisposalTreeItem = Prisma.EquipmentGetPayload<{ select: typeof disposalTreeSelect }>
export class DisposalConflictError extends Error {
status = 409
}
const blockedStatuses = new Set(['已借出', '维护中', '待报废', '已报废', '已丢失'])
// One lookup per depth across the entire set of candidates, not per asset.
export const loadDisposalTrees = async (client: Prisma.TransactionClient, roots: DisposalTreeItem[]) => {
const byParent = new Map<number, DisposalTreeItem[]>()
const visited = new Set(roots.map(root => root.id))
let frontier = [...visited]
while (frontier.length > 0) {
const children = await client.equipment.findMany({
where: { parent_id: { in: frontier } }, select: disposalTreeSelect, orderBy: { id: 'asc' }
})
frontier = []
for (const child of children) {
const parentId = child.parent_id!
const siblings = byParent.get(parentId)
if (siblings) siblings.push(child)
else byParent.set(parentId, [child])
if (!visited.has(child.id)) {
visited.add(child.id)
frontier.push(child.id)
}
}
}
return new Map(roots.map(root => {
const tree = [root]
const seen = new Set([root.id])
for (const item of tree) {
for (const child of byParent.get(item.id) || []) {
if (seen.has(child.id)) throw new DisposalConflictError('资产挂载关系存在循环,请先核查')
seen.add(child.id)
tree.push(child)
}
}
return [root.id, tree] as const
}))
}
export const getDisposalOccupancy = async (client: Prisma.TransactionClient, ids: number[]) => {
const equipmentIds = { in: ids }
const [loans, maintenance, disposals] = await Promise.all([
client.borrowRecord.findMany({ where: { equipment_id: equipmentIds, status: '已借出' }, select: { equipment_id: true }, distinct: ['equipment_id'] }),
client.maintenanceRecord.findMany({ where: { equipment_id: equipmentIds, status: 'in_progress' }, select: { equipment_id: true }, distinct: ['equipment_id'] }),
client.disposalRecord.findMany({
where: { status: { in: ['pending', 'approved'] }, OR: [{ equipment_id: equipmentIds }, { items: { some: { equipment_id: equipmentIds } } }] },
select: { equipment_id: true, items: { where: { equipment_id: equipmentIds }, select: { equipment_id: true } } }
})
])
return {
borrowed: new Set(loans.map(row => row.equipment_id)),
maintenance: new Set(maintenance.map(row => row.equipment_id)),
disposal: new Set(disposals.flatMap(row => [row.equipment_id, ...row.items.map(item => item.equipment_id)]))
}
}
type DisposalBorrow = {
id: number
equipment_id: number
person_id: number
return_time: Date | null
children_snapshot: string | null
updated_at: Date
}
export const isDisposalAutoReturnRoot = (root: DisposalTreeItem) =>
root.parent_id === null && root.mount_status !== 'mounted' &&
root.status === '已借出' && root.total_quantity === 1 && root.remaining_quantity === 0
export const loadDisposalAutoReturnBorrows = async (
client: Prisma.TransactionClient, ids: number[], lock = false
) => {
const byAsset = new Map<number, DisposalBorrow[]>()
if (!ids.length) return byAsset
const rows = await client.$queryRaw<DisposalBorrow[]>(Prisma.sql`
SELECT id, equipment_id, person_id, return_time, children_snapshot, updated_at
FROM borrow_record
WHERE equipment_id IN (${Prisma.join(ids)}) AND status = ${'已借出'}
ORDER BY id ${lock ? Prisma.sql`FOR UPDATE` : Prisma.empty}
`)
for (const row of rows) {
const group = byAsset.get(row.equipment_id)
if (group) group.push(row)
else byAsset.set(row.equipment_id, [row])
}
return byAsset
}
export const getDisposalAutoReturn = (
tree: DisposalTreeItem[],
occupancy: Awaited<ReturnType<typeof getDisposalOccupancy>>,
borrows: Awaited<ReturnType<typeof loadDisposalAutoReturnBorrows>>
) => {
const [root, ...children] = tree
if (!isDisposalAutoReturnRoot(root) || tree.some(item => occupancy.maintenance.has(item.id) || occupancy.disposal.has(item.id))) {
return undefined
}
const records = borrows.get(root.id)
if (records?.length !== 1 || records[0].return_time !== null || children.some(item =>
item.mount_status !== 'mounted' || item.status !== '已借出' || item.total_quantity <= 0 ||
item.remaining_quantity !== 0 || borrows.has(item.id)
)) return undefined
const record = records[0]
if (children.length && !record.children_snapshot) return undefined
try {
if (getReturnChildrenDiff(tree, record)) return undefined
} catch (error) {
if ((error as { status?: number }).status === 409) return undefined
throw error
}
return { record, token: buildReturnConfirmationToken(tree, record) }
}
export const getDisposalBlockedReason = (tree: DisposalTreeItem[], occupancy?: Awaited<ReturnType<typeof getDisposalOccupancy>>) => {
const root = tree[0]
if (root.parent_id !== null && root.status !== '已报废') return '挂载中的子资产不能单独申请报废,请先卸载'
const blocked = tree.find(item => blockedStatuses.has(item.status))
if (blocked) return blocked.status === '维护中'
? '资产正在维修中,请先完成或取消维修'
: `资产 ${blocked.equipment_code} 当前为${blocked.status},不能申请报废`
if (tree.some(item => occupancy?.borrowed.has(item.id))) return '资产树存在未归还记录,不能申请报废'
if (tree.some(item => occupancy?.maintenance.has(item.id))) return '资产树存在进行中的维修,请先完成或取消维修'
if (tree.some(item => occupancy?.disposal.has(item.id))) return '资产树已有进行中的报废申请'
const invalidInventory = tree.find(item => item.total_quantity < 1 || item.remaining_quantity !== item.total_quantity)
if (invalidInventory) return `资产 ${invalidInventory.equipment_code} 库存与报废数量不一致,请先核查`
return null
}
export const assertDisposalItemsConfirmed = (tree: DisposalTreeItem[], requestedIds: number[]) => {
if (!requestedIds.includes(tree[0].id)) throw new Error('报废明细必须包含主资产')
const treeIds = new Set(tree.map(item => item.id))
if (requestedIds.some(id => !treeIds.has(id))) {
throw new DisposalConflictError('报废明细包含不属于当前资产树的资产,请重新核对')
}
const requested = new Set(requestedIds)
const omitted = tree.filter(item => !requested.has(item.id))
if (omitted.length > 0) throw new DisposalConflictError(
`配件 ${omitted.map(item => item.equipment_code).join('、')} 仍处于挂载状态;请先卸载未勾选配件或重新核对后提交`
)
}