548 lines
14 KiB
JavaScript
548 lines
14 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const Joi = require('joi');
|
|
|
|
// 模拟质量检测数据
|
|
let qualityRecords = [
|
|
{
|
|
id: 1,
|
|
orderId: 1,
|
|
inspectionCode: 'QC001',
|
|
inspectorName: '张检验员',
|
|
inspectionDate: '2024-01-15',
|
|
inspectionLocation: '山东省济南市历城区牲畜养殖基地',
|
|
cattleCount: 50,
|
|
samplingCount: 5,
|
|
inspectionType: 'pre_transport',
|
|
healthStatus: 'healthy',
|
|
quarantineCertificate: 'QC001_certificate.pdf',
|
|
vaccineRecords: [
|
|
{
|
|
vaccineName: '口蹄疫疫苗',
|
|
vaccineDate: '2024-01-01',
|
|
batchNumber: 'VAC20240101'
|
|
}
|
|
],
|
|
diseaseTests: [
|
|
{
|
|
testName: '布鲁氏菌病检测',
|
|
result: 'negative',
|
|
testDate: '2024-01-10'
|
|
},
|
|
{
|
|
testName: '结核病检测',
|
|
result: 'negative',
|
|
testDate: '2024-01-10'
|
|
}
|
|
],
|
|
weightCheck: {
|
|
averageWeight: 450,
|
|
weightRange: '420-480',
|
|
weightVariance: 15
|
|
},
|
|
qualityGrade: 'A',
|
|
qualityScore: 95,
|
|
issues: [],
|
|
recommendations: [
|
|
'建议继续保持当前饲养标准',
|
|
'注意观察牲畜健康状况'
|
|
],
|
|
photos: [
|
|
'inspection_001_1.jpg',
|
|
'inspection_001_2.jpg'
|
|
],
|
|
status: 'passed',
|
|
createdAt: new Date('2024-01-15'),
|
|
updatedAt: new Date('2024-01-15')
|
|
},
|
|
{
|
|
id: 2,
|
|
orderId: 2,
|
|
inspectionCode: 'QC002',
|
|
inspectorName: '李检验员',
|
|
inspectionDate: '2024-01-16',
|
|
inspectionLocation: '内蒙古呼和浩特市草原牧场',
|
|
cattleCount: 80,
|
|
samplingCount: 8,
|
|
inspectionType: 'pre_transport',
|
|
healthStatus: 'healthy',
|
|
quarantineCertificate: 'QC002_certificate.pdf',
|
|
vaccineRecords: [
|
|
{
|
|
vaccineName: '口蹄疫疫苗',
|
|
vaccineDate: '2023-12-15',
|
|
batchNumber: 'VAC20231215'
|
|
}
|
|
],
|
|
diseaseTests: [
|
|
{
|
|
testName: '布鲁氏菌病检测',
|
|
result: 'negative',
|
|
testDate: '2024-01-12'
|
|
}
|
|
],
|
|
weightCheck: {
|
|
averageWeight: 480,
|
|
weightRange: '450-520',
|
|
weightVariance: 20
|
|
},
|
|
qualityGrade: 'A',
|
|
qualityScore: 92,
|
|
issues: [
|
|
{
|
|
type: 'minor',
|
|
description: '个别牲畜体重偏轻',
|
|
solution: '加强营养补充'
|
|
}
|
|
],
|
|
recommendations: [
|
|
'对体重偏轻的牲畜进行重点关注',
|
|
'适当调整饲料配比'
|
|
],
|
|
photos: [
|
|
'inspection_002_1.jpg',
|
|
'inspection_002_2.jpg',
|
|
'inspection_002_3.jpg'
|
|
],
|
|
status: 'passed',
|
|
createdAt: new Date('2024-01-16'),
|
|
updatedAt: new Date('2024-01-16')
|
|
}
|
|
];
|
|
|
|
// 验证schemas
|
|
const inspectionCreateSchema = Joi.object({
|
|
orderId: Joi.number().integer().required(),
|
|
inspectorName: Joi.string().min(2).max(50).required(),
|
|
inspectionDate: Joi.date().iso().required(),
|
|
inspectionLocation: Joi.string().min(5).max(200).required(),
|
|
cattleCount: Joi.number().integer().min(1).required(),
|
|
samplingCount: Joi.number().integer().min(1).required(),
|
|
inspectionType: Joi.string().valid('pre_transport', 'during_transport', 'post_transport', 'arrival').required()
|
|
});
|
|
|
|
const qualityResultSchema = Joi.object({
|
|
healthStatus: Joi.string().valid('healthy', 'sick', 'quarantine').required(),
|
|
qualityGrade: Joi.string().valid('A+', 'A', 'B+', 'B', 'C', 'D').required(),
|
|
qualityScore: Joi.number().min(0).max(100).required(),
|
|
weightCheck: Joi.object({
|
|
averageWeight: Joi.number().min(0),
|
|
weightRange: Joi.string(),
|
|
weightVariance: Joi.number().min(0)
|
|
}),
|
|
diseaseTests: Joi.array().items(Joi.object({
|
|
testName: Joi.string().required(),
|
|
result: Joi.string().valid('positive', 'negative', 'inconclusive').required(),
|
|
testDate: Joi.date().iso().required()
|
|
})),
|
|
issues: Joi.array().items(Joi.object({
|
|
type: Joi.string().valid('critical', 'major', 'minor').required(),
|
|
description: Joi.string().required(),
|
|
solution: Joi.string()
|
|
})),
|
|
recommendations: Joi.array().items(Joi.string())
|
|
});
|
|
|
|
// 获取质量检测列表
|
|
router.get('/', (req, res) => {
|
|
try {
|
|
const {
|
|
page = 1,
|
|
pageSize = 20,
|
|
keyword,
|
|
inspectionType,
|
|
qualityGrade,
|
|
status,
|
|
startDate,
|
|
endDate
|
|
} = req.query;
|
|
|
|
let filteredRecords = [...qualityRecords];
|
|
|
|
// 关键词搜索
|
|
if (keyword) {
|
|
filteredRecords = filteredRecords.filter(record =>
|
|
record.inspectionCode.includes(keyword) ||
|
|
record.inspectorName.includes(keyword) ||
|
|
record.inspectionLocation.includes(keyword)
|
|
);
|
|
}
|
|
|
|
// 检测类型筛选
|
|
if (inspectionType) {
|
|
filteredRecords = filteredRecords.filter(record => record.inspectionType === inspectionType);
|
|
}
|
|
|
|
// 质量等级筛选
|
|
if (qualityGrade) {
|
|
filteredRecords = filteredRecords.filter(record => record.qualityGrade === qualityGrade);
|
|
}
|
|
|
|
// 状态筛选
|
|
if (status) {
|
|
filteredRecords = filteredRecords.filter(record => record.status === status);
|
|
}
|
|
|
|
// 时间范围筛选
|
|
if (startDate) {
|
|
filteredRecords = filteredRecords.filter(record =>
|
|
new Date(record.inspectionDate) >= new Date(startDate)
|
|
);
|
|
}
|
|
|
|
if (endDate) {
|
|
filteredRecords = filteredRecords.filter(record =>
|
|
new Date(record.inspectionDate) <= new Date(endDate)
|
|
);
|
|
}
|
|
|
|
// 分页处理
|
|
const startIndex = (page - 1) * pageSize;
|
|
const endIndex = startIndex + parseInt(pageSize);
|
|
const paginatedRecords = filteredRecords.slice(startIndex, endIndex);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
list: paginatedRecords,
|
|
pagination: {
|
|
page: parseInt(page),
|
|
pageSize: parseInt(pageSize),
|
|
total: filteredRecords.length,
|
|
totalPages: Math.ceil(filteredRecords.length / pageSize)
|
|
}
|
|
}
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '获取质量检测列表失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 获取质量检测详情
|
|
router.get('/:id', (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const record = qualityRecords.find(r => r.id === parseInt(id));
|
|
|
|
if (!record) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: '质量检测记录不存在'
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
data: record
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '获取质量检测详情失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 创建质量检测记录
|
|
router.post('/', (req, res) => {
|
|
try {
|
|
const { error, value } = inspectionCreateSchema.validate(req.body);
|
|
if (error) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: '参数验证失败',
|
|
errors: error.details.map(detail => detail.message)
|
|
});
|
|
}
|
|
|
|
const inspectionCode = `QC${String(Date.now()).slice(-6)}`;
|
|
|
|
const newRecord = {
|
|
id: Math.max(...qualityRecords.map(r => r.id)) + 1,
|
|
...value,
|
|
inspectionCode,
|
|
healthStatus: 'pending',
|
|
quarantineCertificate: '',
|
|
vaccineRecords: [],
|
|
diseaseTests: [],
|
|
weightCheck: null,
|
|
qualityGrade: '',
|
|
qualityScore: 0,
|
|
issues: [],
|
|
recommendations: [],
|
|
photos: [],
|
|
status: 'pending',
|
|
createdAt: new Date(),
|
|
updatedAt: new Date()
|
|
};
|
|
|
|
qualityRecords.push(newRecord);
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
message: '质量检测记录创建成功',
|
|
data: newRecord
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '创建质量检测记录失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 更新质量检测结果
|
|
router.put('/:id/result', (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const { error, value } = qualityResultSchema.validate(req.body);
|
|
|
|
if (error) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: '参数验证失败',
|
|
errors: error.details.map(detail => detail.message)
|
|
});
|
|
}
|
|
|
|
const recordIndex = qualityRecords.findIndex(r => r.id === parseInt(id));
|
|
if (recordIndex === -1) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: '质量检测记录不存在'
|
|
});
|
|
}
|
|
|
|
// 根据检测结果确定状态
|
|
let status = 'passed';
|
|
if (value.healthStatus === 'sick' || value.qualityScore < 60) {
|
|
status = 'failed';
|
|
} else if (value.healthStatus === 'quarantine' || value.issues.some(issue => issue.type === 'critical')) {
|
|
status = 'quarantine';
|
|
}
|
|
|
|
qualityRecords[recordIndex] = {
|
|
...qualityRecords[recordIndex],
|
|
...value,
|
|
status,
|
|
updatedAt: new Date()
|
|
};
|
|
|
|
res.json({
|
|
success: true,
|
|
message: '质量检测结果更新成功',
|
|
data: qualityRecords[recordIndex]
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '更新质量检测结果失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 上传检测照片
|
|
router.post('/:id/photos', (req, res) => {
|
|
try {
|
|
const { id } = req.params;
|
|
const { photos } = req.body;
|
|
|
|
if (!Array.isArray(photos) || photos.length === 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: '照片列表不能为空'
|
|
});
|
|
}
|
|
|
|
const recordIndex = qualityRecords.findIndex(r => r.id === parseInt(id));
|
|
if (recordIndex === -1) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: '质量检测记录不存在'
|
|
});
|
|
}
|
|
|
|
qualityRecords[recordIndex].photos = [...qualityRecords[recordIndex].photos, ...photos];
|
|
qualityRecords[recordIndex].updatedAt = new Date();
|
|
|
|
res.json({
|
|
success: true,
|
|
message: '照片上传成功',
|
|
data: {
|
|
photos: qualityRecords[recordIndex].photos
|
|
}
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '上传照片失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 获取质量统计
|
|
router.get('/stats/overview', (req, res) => {
|
|
try {
|
|
const totalInspections = qualityRecords.length;
|
|
const passedCount = qualityRecords.filter(r => r.status === 'passed').length;
|
|
const failedCount = qualityRecords.filter(r => r.status === 'failed').length;
|
|
const quarantineCount = qualityRecords.filter(r => r.status === 'quarantine').length;
|
|
const pendingCount = qualityRecords.filter(r => r.status === 'pending').length;
|
|
|
|
// 平均质量分数
|
|
const completedRecords = qualityRecords.filter(r => r.qualityScore > 0);
|
|
const averageScore = completedRecords.length > 0
|
|
? completedRecords.reduce((sum, r) => sum + r.qualityScore, 0) / completedRecords.length
|
|
: 0;
|
|
|
|
// 质量等级分布
|
|
const gradeDistribution = qualityRecords
|
|
.filter(r => r.qualityGrade)
|
|
.reduce((dist, record) => {
|
|
dist[record.qualityGrade] = (dist[record.qualityGrade] || 0) + 1;
|
|
return dist;
|
|
}, {});
|
|
|
|
// 检测类型分布
|
|
const typeDistribution = qualityRecords.reduce((dist, record) => {
|
|
dist[record.inspectionType] = (dist[record.inspectionType] || 0) + 1;
|
|
return dist;
|
|
}, {});
|
|
|
|
// 合格率
|
|
const passRate = totalInspections > 0 ? Math.round((passedCount / totalInspections) * 100) : 0;
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
totalInspections,
|
|
passedCount,
|
|
failedCount,
|
|
quarantineCount,
|
|
pendingCount,
|
|
averageScore: Math.round(averageScore * 10) / 10,
|
|
passRate,
|
|
gradeDistribution,
|
|
typeDistribution
|
|
}
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '获取质量统计失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 获取质量趋势报告
|
|
router.get('/reports/trend', (req, res) => {
|
|
try {
|
|
const { period = 'month' } = req.query;
|
|
|
|
// 按时间分组统计
|
|
const now = new Date();
|
|
const trends = [];
|
|
|
|
if (period === 'month') {
|
|
// 最近12个月
|
|
for (let i = 11; i >= 0; i--) {
|
|
const date = new Date(now.getFullYear(), now.getMonth() - i, 1);
|
|
const monthRecords = qualityRecords.filter(r => {
|
|
const recordDate = new Date(r.inspectionDate);
|
|
return recordDate.getMonth() === date.getMonth() &&
|
|
recordDate.getFullYear() === date.getFullYear();
|
|
});
|
|
|
|
const passed = monthRecords.filter(r => r.status === 'passed').length;
|
|
const total = monthRecords.length;
|
|
const averageScore = monthRecords.length > 0
|
|
? monthRecords.reduce((sum, r) => sum + (r.qualityScore || 0), 0) / monthRecords.length
|
|
: 0;
|
|
|
|
trends.push({
|
|
period: `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`,
|
|
totalInspections: total,
|
|
passedCount: passed,
|
|
passRate: total > 0 ? Math.round((passed / total) * 100) : 0,
|
|
averageScore: Math.round(averageScore * 10) / 10
|
|
});
|
|
}
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
period,
|
|
trends
|
|
}
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '获取质量趋势报告失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 获取检测标准配置
|
|
router.get('/standards', (req, res) => {
|
|
try {
|
|
const standards = {
|
|
weightStandards: {
|
|
cattle: {
|
|
min: 400,
|
|
max: 600,
|
|
optimal: 500
|
|
}
|
|
},
|
|
healthRequirements: [
|
|
{
|
|
name: '口蹄疫疫苗',
|
|
required: true,
|
|
validityDays: 365
|
|
},
|
|
{
|
|
name: '布鲁氏菌病检测',
|
|
required: true,
|
|
validityDays: 30
|
|
},
|
|
{
|
|
name: '结核病检测',
|
|
required: true,
|
|
validityDays: 30
|
|
}
|
|
],
|
|
gradingCriteria: {
|
|
'A+': { minScore: 95, description: '优质级' },
|
|
'A': { minScore: 85, description: '良好级' },
|
|
'B+': { minScore: 75, description: '合格级' },
|
|
'B': { minScore: 65, description: '基本合格级' },
|
|
'C': { minScore: 50, description: '待改进级' },
|
|
'D': { minScore: 0, description: '不合格级' }
|
|
}
|
|
};
|
|
|
|
res.json({
|
|
success: true,
|
|
data: standards
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: '获取检测标准失败',
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
module.exports = router; |