GuDingZiChan/backend/src/controllers/batchController.ts

331 lines
11 KiB
TypeScript

import { 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 { assertReturnStorageDepartmentContract } from '../utils/borrowDepartment'
import { buildSyncedBusinessDepartmentWhere } from '../utils/organization'
import {
borrowAssetTree,
finalizeNormalReturnState,
recordReturnToStorage,
transferAssetTree
} from '../services/assetMovementService'
const buildBorrowNotes = (notes?: string, isLongTerm?: boolean) => {
const longTerm = Boolean(isLongTerm)
return longTerm && notes
? `${notes};在职长期`
: longTerm
? '在职长期'
: notes || undefined
}
const batchBorrowTransaction = async (
equipmentId: number,
person: any,
expectedReturnTime?: string,
isLongTerm?: boolean,
notes?: string
) => {
const finalNotes = buildBorrowNotes(notes, isLongTerm)
return prisma.$transaction(
(tx) => borrowAssetTree(tx, {
rootEquipmentId: equipmentId,
person,
expectedReturnTime: isLongTerm
? null
: (expectedReturnTime ? new Date(expectedReturnTime) : null),
isLongTerm,
notes: finalNotes
}),
{ isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }
)
}
const batchReturnTransaction = async (
equipment: any,
borrowRecord: any,
returnCondition: string,
notes: string | undefined,
operatedBy: number
) => {
return prisma.$transaction(async (tx) => {
const { items } = await recordReturnToStorage(tx, {
rootEquipmentId: equipment.id,
operatedBy,
reason: notes || '批量归还入仓'
})
const currentRoot = items[0]
const updatedRecord = await tx.borrowRecord.updateMany({
where: {
id: borrowRecord.id,
equipment_id: currentRoot.id,
status: '已借出'
},
data: {
return_time: new Date(),
status: '已归还',
return_condition: returnCondition,
notes
}
})
if (updatedRecord.count !== 1) {
throw new Error('该借用记录已归还,请刷新后重试')
}
await finalizeNormalReturnState(tx, currentRoot)
})
}
// 批量借出
export const batchBorrow = async (req: Request, res: Response) => {
try {
const { equipment_ids, person_id, expected_return_time, is_long_term, notes } = req.body
if (!Array.isArray(equipment_ids) || equipment_ids.length === 0) {
return errorResponse(res, '请选择要借出的资产')
}
const person = await prisma.person.findUnique({ where: { id: Number(person_id) } })
if (!person || person.status !== 'active') {
return errorResponse(res, '使用者不存在或已禁用')
}
const results: any[] = []
let successCount = 0
let failedCount = 0
for (const equipmentId of equipment_ids) {
try {
const equipment = await prisma.equipment.findUnique({ where: { id: Number(equipmentId) } })
if (!equipment) {
results.push({ equipment_id: equipmentId, status: 'failed', message: '资产不存在' })
failedCount++
continue
}
if (equipment.parent_id) {
results.push({
equipment_id: equipmentId,
equipment_code: equipment.equipment_code,
status: 'failed',
message: '该子资产当前已挂载,请先卸载后再借用'
})
failedCount++
continue
}
if (equipment.status !== '可用' || equipment.remaining_quantity <= 0) {
results.push({ equipment_id: equipmentId, equipment_code: equipment.equipment_code, status: 'failed', message: '资产不可借用' })
failedCount++
continue
}
await batchBorrowTransaction(
equipment.id,
person,
expected_return_time,
is_long_term,
notes
)
results.push({ equipment_id: equipmentId, equipment_code: equipment.equipment_code, status: 'success', message: '借出成功' })
successCount++
} catch (error: any) {
results.push({ equipment_id: equipmentId, status: 'failed', message: error.message })
failedCount++
}
}
// 记录操作日志
const userId = res.locals.user?.id
const username = res.locals.user?.username || res.locals.user?.name || 'unknown'
const successCodes = results.filter(r => r.status === 'success').map(r => r.equipment_code).join(', ')
if (successCount > 0) {
await logOperation(
userId,
username,
'批量借出',
`批量借出 ${successCount} 件资产给 ${person.real_name}(${person.nickname}),资产编码:${successCodes}`,
undefined,
undefined,
req.ip
)
}
successResponse(res, { success_count: successCount, failed_count: failedCount, results }, '批量借出完成')
} catch (error: any) {
errorResponse(res, error.message || '批量借出失败')
}
}
// 批量归还
export const batchReturn = async (req: Request, res: Response) => {
try {
const { equipment_ids, return_condition = '正常', notes } = req.body
try {
assertReturnStorageDepartmentContract(req.body || {})
} catch (error: any) {
return errorResponse(res, error.message || '归还入仓部门契约无效', 422)
}
if (!Array.isArray(equipment_ids) || equipment_ids.length === 0) {
return errorResponse(res, '请选择要归还的资产')
}
const results: any[] = []
const operatedBy = Number(res.locals.user?.id)
let successCount = 0
let failedCount = 0
for (const equipmentId of equipment_ids) {
try {
const equipment = await prisma.equipment.findUnique({ where: { id: Number(equipmentId) } })
if (!equipment) {
results.push({ equipment_id: equipmentId, status: 'failed', message: '资产不存在' })
failedCount++
continue
}
const activeBorrowRecords = await prisma.borrowRecord.findMany({
where: { equipment_id: equipment.id, status: '已借出' },
orderBy: { borrow_time: 'desc' },
take: 2
})
const borrowRecord = activeBorrowRecords[0]
if (!borrowRecord) {
results.push({ equipment_id: equipmentId, equipment_code: equipment.equipment_code, status: 'failed', message: '未找到借用记录' })
failedCount++
continue
}
if (activeBorrowRecords.length > 1) {
results.push({ equipment_id: equipmentId, equipment_code: equipment.equipment_code, status: 'failed', message: '存在多条未归还记录,请使用单个归还' })
failedCount++
continue
}
await batchReturnTransaction(equipment, borrowRecord, return_condition, notes, operatedBy)
results.push({ equipment_id: equipmentId, equipment_code: equipment.equipment_code, status: 'success', message: '归还成功' })
successCount++
} catch (error: any) {
results.push({ equipment_id: equipmentId, status: 'failed', message: error.message })
failedCount++
}
}
// 记录操作日志
const userId = res.locals.user?.id
const username = res.locals.user?.username || res.locals.user?.name || 'unknown'
const successCodes = results.filter(r => r.status === 'success').map(r => r.equipment_code).join(', ')
if (successCount > 0) {
await logOperation(
userId,
username,
'批量归还',
`批量归还 ${successCount} 件资产,归还状态:${return_condition},资产编码:${successCodes}`,
undefined,
undefined,
req.ip
)
}
successResponse(res, { success_count: successCount, failed_count: failedCount, results }, '批量归还完成')
} catch (error: any) {
errorResponse(res, error.message || '批量归还失败')
}
}
// 批量转移部门
export const batchTransfer = async (req: Request, res: Response) => {
try {
const { equipment_ids, department_id, target_type = 'department', reason } = req.body
if (!Array.isArray(equipment_ids) || equipment_ids.length === 0) {
return errorResponse(res, '请选择要转移的资产')
}
if (!reason || typeof reason !== 'string' || !reason.trim()) {
return errorResponse(res, '调拨原因不能为空', 422)
}
if (!['department', 'idle'].includes(target_type)) {
return errorResponse(res, '调拨目标类型无效', 422)
}
const department = target_type === 'department'
? await prisma.department.findFirst({
where: {
id: Number(department_id),
status: 'active',
...buildSyncedBusinessDepartmentWhere()
}
})
: null
if (target_type === 'department' && !department) {
return errorResponse(res, '目标部门不存在或已停用', 422)
}
const operatedBy = Number(res.locals.user?.id)
const results: any[] = []
let successCount = 0
let failedCount = 0
for (const equipmentId of equipment_ids) {
try {
const movement = await prisma.$transaction(
(tx) => transferAssetTree(tx, {
rootEquipmentId: Number(equipmentId),
actionType: target_type === 'idle' ? 'idle' : 'transfer',
toDepartmentId: department?.id || null,
toDepartmentName: department?.name || null,
operatedBy,
reason: reason.trim()
}),
{ isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted }
)
results.push({
equipment_id: equipmentId,
equipment_code: movement.items[0]?.equipment_code,
status: 'success',
message: target_type === 'idle' ? '已转为闲置' : '转移成功'
})
successCount++
} catch (error: any) {
results.push({ equipment_id: equipmentId, status: 'failed', message: error.message })
failedCount++
}
}
// 记录操作日志
const userId = operatedBy
const username = res.locals.user?.username || res.locals.user?.name || 'unknown'
const successCodes = results.filter(r => r.status === 'success').map(r => r.equipment_code).join(', ')
if (successCount > 0) {
await logOperation(
userId,
username,
'批量转移',
target_type === 'idle'
? `批量将 ${successCount} 件资产转为闲置,资产编码:${successCodes}`
: `批量转移 ${successCount} 件资产到部门 ${department?.name || ''},资产编码:${successCodes}`,
undefined,
undefined,
req.ip
)
}
successResponse(res, { success_count: successCount, failed_count: failedCount, results }, '批量转移完成')
} catch (error: any) {
errorResponse(res, error.message || '批量转移失败')
}
}