GuDingZiChan/backend/src/controllers/batchImportController.ts

303 lines
10 KiB
TypeScript

import { Request, Response } from 'express'
import prisma from '../utils/prisma'
import { successResponse, errorResponse } from '../utils/response'
import { generateEquipmentCode } from '../utils/equipmentCode'
import { calculateEquipmentValues } from '../utils/assetValue'
import { buildSyncedBusinessDepartmentWhere } from '../utils/organization'
interface PersonImportData {
source_row?: number
nickname: string
real_name: string
job_number?: string
id_number?: string
department?: string
position?: string
phone?: string
email?: string
}
interface EquipmentImportData {
source_row?: number
equipment_name: string
equipment_type: string
equipment_model?: string
department?: string
storage_location?: string
unit_price?: number | string
total_quantity: number
supplier?: string
purchase_date?: string
description?: string
}
const normalizeOptionalText = (value: unknown) => {
if (value === undefined || value === null) return null
const text = String(value).trim()
return text || null
}
const getSourceRow = (value: unknown, index: number) =>
typeof value === 'number' && Number.isSafeInteger(value) && value >= 2 ? value : index + 2
// 批量导入使用者
export const batchImportPersons = async (req: Request, res: Response) => {
try {
const { persons } = req.body as { persons: PersonImportData[] }
if (!persons || !Array.isArray(persons) || persons.length === 0) {
return errorResponse(res, '导入数据不能为空')
}
const activeDepartments = await prisma.department.findMany({
where: {
AND: [buildSyncedBusinessDepartmentWhere(), { status: 'active' }]
},
select: { id: true, name: true }
})
const departmentMap = new Map(activeDepartments.map((department) => [department.name, department.id]))
const results = { success: 0, failed: 0, errors: [] as { row: number; message: string }[] }
for (let i = 0; i < persons.length; i++) {
const person = persons[i]
const rowNum = getSourceRow(person?.source_row, i)
try {
// 验证必填字段
if (!person.nickname || !person.real_name) {
results.errors.push({ row: rowNum, message: '昵称和真实姓名为必填项' })
results.failed++
continue
}
// 检查工号是否重复
const normalizedJobNumber = normalizeOptionalText(person.job_number)
if (normalizedJobNumber) {
const existing = await prisma.person.findUnique({
where: { job_number: normalizedJobNumber }
})
if (existing) {
results.errors.push({ row: rowNum, message: `工号 ${normalizedJobNumber} 已存在` })
results.failed++
continue
}
}
const normalizedDepartment = normalizeOptionalText(person.department)
const matchedDepartmentId = normalizedDepartment
? departmentMap.get(normalizedDepartment) || null
: null
await prisma.$transaction(async (tx) => {
const normalizedIdNumber = normalizeOptionalText(person.id_number)
if (normalizedIdNumber) {
const existingByIdNumber = await tx.person.findUnique({
where: { id_number: normalizedIdNumber }
})
if (existingByIdNumber) {
throw new Error(`身份证号 ${normalizedIdNumber} 已存在`)
}
}
const created = await tx.person.create({
data: {
nickname: person.nickname,
real_name: person.real_name,
job_number: normalizedJobNumber,
id_number: normalizedIdNumber,
department: normalizedDepartment,
main_department_id: matchedDepartmentId,
position: person.position || null,
phone: person.phone || null,
email: person.email || null,
status: 'active'
}
})
if (matchedDepartmentId) {
await tx.personDepartment.create({
data: {
person_id: created.id,
department_id: matchedDepartmentId
}
})
}
})
results.success++
} catch (error: any) {
results.errors.push({ row: rowNum, message: error.message || '创建失败' })
results.failed++
}
}
// 记录操作日志
const user = res.locals.user
await prisma.operationLog.create({
data: {
user_id: user?.id || null,
username: user?.username || 'system',
operation_type: '批量导入使用者',
operation_details: `成功: ${results.success}, 失败: ${results.failed}`,
ip_address: req.ip || req.socket.remoteAddress
}
})
successResponse(res, results, '导入完成')
} catch (error: any) {
errorResponse(res, error.message || '批量导入失败')
}
}
// 批量导入资产
export const batchImportEquipments = async (req: Request, res: Response) => {
try {
const { equipments } = req.body as { equipments: EquipmentImportData[] }
if (!equipments || !Array.isArray(equipments) || equipments.length === 0) {
return errorResponse(res, '导入数据不能为空')
}
// 预加载资产类型、部门、地址映射
const [assetTypes, departments, locations] = await Promise.all([
prisma.assetType.findMany({ where: { status: 'active' } }),
prisma.department.findMany({
where: {
AND: [buildSyncedBusinessDepartmentWhere(), { status: 'active' }]
}
}),
prisma.storageLocation.findMany({ where: { status: 'active' } })
])
const assetTypeMap = new Map(assetTypes.map((type) => [type.name, type]))
const departmentMap = new Map(departments.map(d => [d.name, d.id]))
const locationMap = new Map(locations.map(l => [l.name, l.id]))
const results = { success: 0, failed: 0, errors: [] as { row: number; message: string }[] }
for (let i = 0; i < equipments.length; i++) {
const eq = equipments[i]
const rowNum = getSourceRow(eq?.source_row, i)
try {
// 验证必填字段
if (!eq || !normalizeOptionalText(eq.equipment_name) || !normalizeOptionalText(eq.equipment_type)) {
results.errors.push({ row: rowNum, message: '资产名称、资产类型、数量为必填项' })
results.failed++
continue
}
// 查找资产类型
const assetType = assetTypeMap.get(eq.equipment_type)
if (!assetType) {
results.errors.push({ row: rowNum, message: `资产类型 "${eq.equipment_type}" 不存在` })
results.failed++
continue
}
const quantityInput = eq.total_quantity
const totalQuantity = typeof quantityInput === 'number' || (typeof quantityInput === 'string' && String(quantityInput).trim())
? Number(quantityInput) : NaN
if (!Number.isSafeInteger(totalQuantity) || totalQuantity <= 0) {
results.errors.push({ row: rowNum, message: '数量必须是大于0的整数' })
results.failed++
continue
}
const unitPrice = eq.unit_price === undefined || eq.unit_price === null ? 0 : Number(eq.unit_price)
if (!Number.isFinite(unitPrice) || unitPrice < 0) {
results.errors.push({ row: rowNum, message: '单价必须是大于或等于0的有效数字' })
results.failed++
continue
}
if (assetType.can_be_child && totalQuantity !== 1) {
results.errors.push({ row: rowNum, message: `子资产类型 "${eq.equipment_type}" 导入时数量必须为 1` })
results.failed++
continue
}
// 查找部门(可选)
let departmentId: number | null = null
if (eq.department) {
if (res.locals.user?.role === 'administrative') {
results.errors.push({ row: rowNum, message: '行政导入资产时不能直接分配部门,请导入后由 IT 调拨' })
results.failed++
continue
}
departmentId = departmentMap.get(eq.department) || null
if (!departmentId) {
results.errors.push({ row: rowNum, message: `部门 "${eq.department}" 不存在` })
results.failed++
continue
}
}
// 查找地址(可选)
let locationId: number | null = null
if (eq.storage_location) {
locationId = locationMap.get(eq.storage_location) || null
if (!locationId) {
results.errors.push({ row: rowNum, message: `地址 "${eq.storage_location}" 不存在` })
results.failed++
continue
}
}
// 生成资产编码
const equipmentCode = await generateEquipmentCode(eq.equipment_type, prisma, locationId)
// 计算价值
const values = calculateEquipmentValues({
unitPrice,
totalQuantity,
remainingQuantity: totalQuantity,
status: '可用'
})
await prisma.equipment.create({
data: {
equipment_code: equipmentCode,
equipment_name: eq.equipment_name,
equipment_model: eq.equipment_model || null,
equipment_type: eq.equipment_type,
code_generation_mode: 'auto',
unit_price: unitPrice,
total_quantity: totalQuantity,
remaining_quantity: totalQuantity,
total_value: values.total_value,
borrowed_value: values.borrowed_value,
available_value: values.available_value,
supplier: eq.supplier || null,
purchase_date: eq.purchase_date ? new Date(eq.purchase_date) : null,
description: eq.description || null,
status: '可用',
storage_location_id: locationId,
department_id: departmentId,
asset_type_id: assetType.id
}
})
results.success++
} catch (error: any) {
results.errors.push({ row: rowNum, message: error.message || '创建失败' })
results.failed++
}
}
// 记录操作日志
const user = res.locals.user
await prisma.operationLog.create({
data: {
user_id: user?.id || null,
username: user?.username || 'system',
operation_type: '批量导入资产',
operation_details: `成功: ${results.success}, 失败: ${results.failed}`,
ip_address: req.ip || req.socket.remoteAddress
}
})
successResponse(res, results, '导入完成')
} catch (error: any) {
errorResponse(res, error.message || '批量导入失败')
}
}