303 lines
10 KiB
TypeScript
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 || '批量导入失败')
|
|
}
|
|
}
|