完善保险端前后端和养殖端小程序

This commit is contained in:
xuqiuyun
2025-09-22 19:09:45 +08:00
parent 02a25515a9
commit 325c114c38
256 changed files with 48348 additions and 4444 deletions

View File

@@ -0,0 +1,477 @@
const InstallationTask = require('../models/InstallationTask');
const User = require('../models/User');
const { Op, sequelize } = require('sequelize');
const logger = require('../utils/logger');
class InstallationTaskController {
// 获取待安装任务列表
async getInstallationTasks(req, res) {
try {
const {
page = 1,
pageSize = 10,
policyNumber,
customerName,
installationStatus,
priority,
keyword,
startDate,
endDate
} = req.query;
const offset = (page - 1) * pageSize;
const limit = parseInt(pageSize);
// 构建查询条件
const whereConditions = {};
if (policyNumber) {
whereConditions.policyNumber = { [Op.like]: `%${policyNumber}%` };
}
if (customerName) {
whereConditions.customerName = { [Op.like]: `%${customerName}%` };
}
if (installationStatus) {
whereConditions.installationStatus = installationStatus;
}
if (priority) {
whereConditions.priority = priority;
}
// 关键字搜索(搜索申请单号、保单编号、客户姓名等)
if (keyword) {
whereConditions[Op.or] = [
{ applicationNumber: { [Op.like]: `%${keyword}%` } },
{ policyNumber: { [Op.like]: `%${keyword}%` } },
{ customerName: { [Op.like]: `%${customerName}%` } },
{ productName: { [Op.like]: `%${keyword}%` } }
];
}
if (startDate && endDate) {
whereConditions.taskGeneratedTime = {
[Op.between]: [new Date(startDate), new Date(endDate)]
};
}
const { count, rows } = await InstallationTask.findAndCountAll({
where: whereConditions,
order: [['taskGeneratedTime', 'DESC']],
offset,
limit
});
res.json({
code: 200,
status: 'success',
message: '获取待安装任务列表成功',
data: {
list: rows,
total: count,
page: parseInt(page),
pageSize: limit,
totalPages: Math.ceil(count / limit)
}
});
} catch (error) {
logger.error('获取待安装任务列表失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取待安装任务列表失败',
error: error.message
});
}
}
// 创建待安装任务
async createInstallationTask(req, res) {
try {
const {
applicationNumber,
policyNumber,
productName,
customerName,
idType,
idNumber,
livestockSupplyType,
pendingDevices,
installationStatus = '待安装',
priority = '中',
assignedTo,
taskGeneratedTime = new Date()
} = req.body;
// 验证必填字段
if (!applicationNumber || !policyNumber || !productName || !customerName) {
return res.status(400).json({
code: 400,
status: 'error',
message: '申请单号、保单编号、产品名称、客户姓名为必填项'
});
}
// 检查申请单号是否已存在
const existingTask = await InstallationTask.findOne({
where: { applicationNumber }
});
if (existingTask) {
return res.status(409).json({
code: 409,
status: 'error',
message: '该申请单号已存在待安装任务'
});
}
const installationTask = await InstallationTask.create({
applicationNumber,
policyNumber,
productName,
customerName,
idType: idType || '身份证',
idNumber: idNumber || '',
livestockSupplyType,
pendingDevices: pendingDevices ? JSON.stringify(pendingDevices) : null,
installationStatus,
priority,
assignedTo,
taskGeneratedTime,
createdBy: req.user?.id
});
res.status(201).json({
code: 201,
status: 'success',
message: '创建待安装任务成功',
data: installationTask
});
} catch (error) {
logger.error('创建待安装任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '创建待安装任务失败',
error: error.message
});
}
}
// 获取待安装任务详情
async getInstallationTaskById(req, res) {
try {
const { id } = req.params;
const installationTask = await InstallationTask.findByPk(id, {
include: [
{
model: User,
as: 'technician',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'updater',
attributes: ['id', 'username', 'real_name']
}
]
});
if (!installationTask) {
return res.status(404).json({
code: 404,
status: 'error',
message: '待安装任务不存在'
});
}
res.json({
code: 200,
status: 'success',
message: '获取待安装任务详情成功',
data: installationTask
});
} catch (error) {
logger.error('获取待安装任务详情失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取待安装任务详情失败',
error: error.message
});
}
}
// 更新待安装任务
async updateInstallationTask(req, res) {
try {
const { id } = req.params;
const updateData = { ...req.body };
// 添加更新人信息
updateData.updatedBy = req.user?.id;
// 处理设备数据
if (updateData.pendingDevices) {
updateData.pendingDevices = JSON.stringify(updateData.pendingDevices);
}
// 处理安装完成时间
if (updateData.installationStatus === '已安装' && !updateData.installationCompletedTime) {
updateData.installationCompletedTime = new Date();
}
const [updatedCount] = await InstallationTask.update(updateData, {
where: { id }
});
if (updatedCount === 0) {
return res.status(404).json({
code: 404,
status: 'error',
message: '待安装任务不存在或未做任何修改'
});
}
// 获取更新后的任务
const updatedTask = await InstallationTask.findByPk(id);
res.json({
code: 200,
status: 'success',
message: '更新待安装任务成功',
data: updatedTask
});
} catch (error) {
logger.error('更新待安装任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '更新待安装任务失败',
error: error.message
});
}
}
// 删除待安装任务
async deleteInstallationTask(req, res) {
try {
const { id } = req.params;
const deletedCount = await InstallationTask.destroy({
where: { id }
});
if (deletedCount === 0) {
return res.status(404).json({
code: 404,
status: 'error',
message: '待安装任务不存在'
});
}
res.json({
code: 200,
status: 'success',
message: '删除待安装任务成功'
});
} catch (error) {
logger.error('删除待安装任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '删除待安装任务失败',
error: error.message
});
}
}
// 批量操作待安装任务
async batchOperateInstallationTasks(req, res) {
try {
const { ids, operation, data } = req.body;
if (!ids || !Array.isArray(ids) || ids.length === 0) {
return res.status(400).json({
code: 400,
status: 'error',
message: '任务ID列表不能为空'
});
}
let result;
switch (operation) {
case 'assign':
if (!data.assignedTo) {
return res.status(400).json({
code: 400,
status: 'error',
message: '分配操作需要指定分配给的用户'
});
}
result = await InstallationTask.update(
{ assignedTo: data.assignedTo, updatedBy: req.user?.id },
{ where: { id: ids } }
);
break;
case 'updateStatus':
if (!data.installationStatus) {
return res.status(400).json({
code: 400,
status: 'error',
message: '状态更新操作需要指定新状态'
});
}
result = await InstallationTask.update(
{ installationStatus: data.installationStatus, updatedBy: req.user?.id },
{ where: { id: ids } }
);
break;
case 'delete':
result = await InstallationTask.destroy({ where: { id: ids } });
break;
default:
return res.status(400).json({
code: 400,
status: 'error',
message: '不支持的操作类型'
});
}
res.json({
code: 200,
status: 'success',
message: `批量${operation}操作完成`,
data: { affectedRows: result[0] || result }
});
} catch (error) {
logger.error('批量操作待安装任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '批量操作失败',
error: error.message
});
}
}
// 导出待安装任务数据
async exportInstallationTasks(req, res) {
try {
const { ids } = req.query;
let where = {};
if (ids) {
where.id = { [Op.in]: ids.split(',') };
}
const tasks = await InstallationTask.findAll({
where,
include: [
{
model: User,
as: 'technician',
attributes: ['username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['username', 'real_name']
}
],
order: [['taskGeneratedTime', 'DESC']]
});
res.json({
code: 200,
status: 'success',
message: '导出待安装任务数据成功',
data: tasks
});
} catch (error) {
logger.error('导出待安装任务数据失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '导出数据失败',
error: error.message
});
}
}
// 获取任务统计信息
async getInstallationTaskStats(req, res) {
try {
// 按状态统计
const statusStats = await InstallationTask.findAll({
attributes: [
'installationStatus',
[sequelize.fn('COUNT', sequelize.col('id')), 'count']
],
group: ['installationStatus'],
raw: true
});
// 按优先级统计
const priorityStats = await InstallationTask.findAll({
attributes: [
'priority',
[sequelize.fn('COUNT', sequelize.col('id')), 'count']
],
group: ['priority'],
raw: true
});
// 总数统计
const total = await InstallationTask.count();
// 本月新增任务
const thisMonth = await InstallationTask.count({
where: {
taskGeneratedTime: {
[Op.gte]: new Date(new Date().getFullYear(), new Date().getMonth(), 1)
}
}
});
res.json({
code: 200,
status: 'success',
message: '获取任务统计信息成功',
data: {
total,
thisMonth,
statusStats,
priorityStats
}
});
} catch (error) {
logger.error('获取任务统计信息失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取统计信息失败',
error: error.message
});
}
}
}
module.exports = new InstallationTaskController();

View File

@@ -0,0 +1,527 @@
const { SupervisoryTask, User } = require('../models');
const { Op } = require('sequelize');
/**
* 监管任务控制器
*/
class SupervisoryTaskController {
/**
* 获取监管任务列表(支持分页和搜索)
*/
static async getList(req, res) {
try {
const {
page = 1,
limit = 10,
policyNumber = '',
customerName = '',
taskStatus = '',
priority = '',
dateRange = '',
sortBy = 'createdAt',
sortOrder = 'DESC'
} = req.query;
// 构建查询条件
const where = {};
if (policyNumber) {
where.policyNumber = { [Op.like]: `%${policyNumber}%` };
}
if (customerName) {
where.customerName = { [Op.like]: `%${customerName}%` };
}
if (taskStatus) {
where.taskStatus = taskStatus;
}
if (priority) {
where.priority = priority;
}
// 日期范围筛选
if (dateRange) {
const [startDate, endDate] = dateRange.split(',');
if (startDate && endDate) {
where.createdAt = {
[Op.between]: [new Date(startDate), new Date(endDate)]
};
}
}
// 分页参数
const offset = (parseInt(page) - 1) * parseInt(limit);
// 查询数据
const { count, rows } = await SupervisoryTask.findAndCountAll({
where,
include: [
{
model: User,
as: 'assignedUser',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['id', 'username', 'real_name']
}
],
order: [[sortBy, sortOrder.toUpperCase()]],
limit: parseInt(limit),
offset
});
res.json({
code: 200,
status: 'success',
message: '获取监管任务列表成功',
data: {
list: rows,
total: count,
page: parseInt(page),
limit: parseInt(limit),
totalPages: Math.ceil(count / parseInt(limit))
}
});
} catch (error) {
console.error('获取监管任务列表失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取监管任务列表失败',
error: error.message
});
}
}
/**
* 根据ID获取监管任务详情
*/
static async getById(req, res) {
try {
const { id } = req.params;
const task = await SupervisoryTask.findByPk(id, {
include: [
{
model: User,
as: 'assignedUser',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'updater',
attributes: ['id', 'username', 'real_name']
}
]
});
if (!task) {
return res.status(404).json({
code: 404,
status: 'error',
message: '监管任务不存在'
});
}
res.json({
code: 200,
status: 'success',
message: '获取监管任务详情成功',
data: task
});
} catch (error) {
console.error('获取监管任务详情失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取监管任务详情失败',
error: error.message
});
}
}
/**
* 创建新的监管任务
*/
static async create(req, res) {
try {
const {
applicationNumber,
policyNumber,
productName,
insurancePeriod,
customerName,
idType,
idNumber,
applicableSupplies,
supervisorySuppliesQuantity,
taskStatus = '待处理',
priority = '中',
assignedTo,
dueDate,
notes
} = req.body;
// 验证必填字段
if (!applicationNumber || !policyNumber || !productName || !customerName || !idNumber) {
return res.status(400).json({
code: 400,
status: 'error',
message: '申请单号、保单编号、产品名称、客户姓名和证件号码为必填项'
});
}
// 检查申请单号是否已存在
const existingTask = await SupervisoryTask.findOne({
where: { applicationNumber }
});
if (existingTask) {
return res.status(409).json({
code: 409,
status: 'error',
message: '该申请单号已存在监管任务'
});
}
// 创建监管任务
const task = await SupervisoryTask.create({
applicationNumber,
policyNumber,
productName,
insurancePeriod,
customerName,
idType,
idNumber,
applicableSupplies: JSON.stringify(applicableSupplies),
supervisorySuppliesQuantity: parseInt(supervisorySuppliesQuantity) || 0,
taskStatus,
priority,
assignedTo,
dueDate: dueDate ? new Date(dueDate) : null,
notes,
createdBy: req.user?.id
});
// 查询完整的任务信息(包含关联数据)
const createdTask = await SupervisoryTask.findByPk(task.id, {
include: [
{
model: User,
as: 'assignedUser',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['id', 'username', 'real_name']
}
]
});
res.status(201).json({
code: 201,
status: 'success',
message: '创建监管任务成功',
data: createdTask
});
} catch (error) {
console.error('创建监管任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '创建监管任务失败',
error: error.message
});
}
}
/**
* 更新监管任务
*/
static async update(req, res) {
try {
const { id } = req.params;
const updateData = { ...req.body };
// 添加更新人信息
updateData.updatedBy = req.user?.id;
// 处理适用生资数据
if (updateData.applicableSupplies) {
updateData.applicableSupplies = JSON.stringify(updateData.applicableSupplies);
}
// 处理截止日期
if (updateData.dueDate) {
updateData.dueDate = new Date(updateData.dueDate);
}
// 处理完成时间
if (updateData.taskStatus === '已完成' && !updateData.completedAt) {
updateData.completedAt = new Date();
}
const [updatedCount] = await SupervisoryTask.update(updateData, {
where: { id }
});
if (updatedCount === 0) {
return res.status(404).json({
code: 404,
status: 'error',
message: '监管任务不存在或未做任何修改'
});
}
// 查询更新后的任务信息
const updatedTask = await SupervisoryTask.findByPk(id, {
include: [
{
model: User,
as: 'assignedUser',
attributes: ['id', 'username', 'real_name']
},
{
model: User,
as: 'updater',
attributes: ['id', 'username', 'real_name']
}
]
});
res.json({
code: 200,
status: 'success',
message: '更新监管任务成功',
data: updatedTask
});
} catch (error) {
console.error('更新监管任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '更新监管任务失败',
error: error.message
});
}
}
/**
* 删除监管任务
*/
static async delete(req, res) {
try {
const { id } = req.params;
const deletedCount = await SupervisoryTask.destroy({
where: { id }
});
if (deletedCount === 0) {
return res.status(404).json({
code: 404,
status: 'error',
message: '监管任务不存在'
});
}
res.json({
code: 200,
status: 'success',
message: '删除监管任务成功'
});
} catch (error) {
console.error('删除监管任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '删除监管任务失败',
error: error.message
});
}
}
/**
* 批量创建监管任务
*/
static async bulkCreate(req, res) {
try {
const { tasks } = req.body;
if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
return res.status(400).json({
code: 400,
status: 'error',
message: '请提供有效的任务数据数组'
});
}
// 验证并处理任务数据
const processedTasks = tasks.map(task => ({
...task,
applicableSupplies: JSON.stringify(task.applicableSupplies || []),
supervisorySuppliesQuantity: parseInt(task.supervisorySuppliesQuantity) || 0,
taskStatus: task.taskStatus || '待处理',
priority: task.priority || '中',
dueDate: task.dueDate ? new Date(task.dueDate) : null,
createdBy: req.user?.id
}));
const createdTasks = await SupervisoryTask.bulkCreate(processedTasks, {
ignoreDuplicates: true,
returning: true
});
res.status(201).json({
code: 201,
status: 'success',
message: `批量创建监管任务成功,共创建${createdTasks.length}条记录`,
data: {
count: createdTasks.length,
tasks: createdTasks
}
});
} catch (error) {
console.error('批量创建监管任务失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '批量创建监管任务失败',
error: error.message
});
}
}
/**
* 导出监管任务数据
*/
static async export(req, res) {
try {
const { ids, ...filters } = req.query;
let where = {};
// 如果指定了ID列表则只导出指定的任务
if (ids) {
where.id = { [Op.in]: ids.split(',').map(id => parseInt(id)) };
} else {
// 否则根据筛选条件导出
if (filters.policyNumber) {
where.policyNumber = { [Op.like]: `%${filters.policyNumber}%` };
}
if (filters.customerName) {
where.customerName = { [Op.like]: `%${filters.customerName}%` };
}
if (filters.taskStatus) {
where.taskStatus = filters.taskStatus;
}
}
const tasks = await SupervisoryTask.findAll({
where,
include: [
{
model: User,
as: 'assignedUser',
attributes: ['username', 'real_name']
},
{
model: User,
as: 'creator',
attributes: ['username', 'real_name']
}
],
order: [['createdAt', 'DESC']]
});
res.json({
code: 200,
status: 'success',
message: '导出监管任务数据成功',
data: tasks
});
} catch (error) {
console.error('导出监管任务数据失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '导出监管任务数据失败',
error: error.message
});
}
}
/**
* 获取任务统计信息
*/
static async getStatistics(req, res) {
try {
// 按状态统计
const statusStats = await SupervisoryTask.findAll({
attributes: [
'taskStatus',
[SupervisoryTask.sequelize.fn('COUNT', SupervisoryTask.sequelize.col('id')), 'count']
],
group: ['taskStatus']
});
// 按优先级统计
const priorityStats = await SupervisoryTask.findAll({
attributes: [
'priority',
[SupervisoryTask.sequelize.fn('COUNT', SupervisoryTask.sequelize.col('id')), 'count']
],
group: ['priority']
});
// 总数统计
const total = await SupervisoryTask.count();
res.json({
code: 200,
status: 'success',
message: '获取任务统计信息成功',
data: {
total,
statusStats: statusStats.map(item => ({
status: item.taskStatus,
count: parseInt(item.dataValues.count)
})),
priorityStats: priorityStats.map(item => ({
priority: item.priority,
count: parseInt(item.dataValues.count)
}))
}
});
} catch (error) {
console.error('获取任务统计信息失败:', error);
res.status(500).json({
code: 500,
status: 'error',
message: '获取任务统计信息失败',
error: error.message
});
}
}
}
module.exports = SupervisoryTaskController;