12.19

三、Service 层核心文件（必替换）

1. TaskService.java（新增客户查询方法）
   java
   运行
   package com.company.detection.service;

import com.company.detection.entity.Task;

import java.util.List;

public interface TaskService {
String generateTaskId(); // 生成唯一任务编号
int addTask(Task task);
List queryPendingConfirmTasks();
int confirmTask(String id, String state);
int assignTask(String id, String manageId, String inspectorId);
List queryTasksByRole(String userId, Integer userCategory, Integer groupNo, String state);
int updateTaskForm(Task task);
int deleteTaskForm(String id);
int approveTask(String id, String state, String rejectReason);
Task queryTaskDetail(String id);
List statCompletedTasks(String startDate, String endDate);
// 新增：委托客户查询自己的任务
List queryTasksByClient(String clientName);
}
2. TaskServiceImpl.java（添加状态校验 + 实现新增方法）
java
运行
package com.company.detection.service.impl;

import com.company.detection.dao.TaskDao;
import com.company.detection.dao.impl.TaskDaoImpl;
import com.company.detection.entity.Task;
import com.company.detection.service.TaskService;
import com.company.detection.util.DBUtil;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;

public class TaskServiceImpl implements TaskService {
private TaskDao taskDao = new TaskDaoImpl();

// 优化后：生成唯一任务编号（调用存储过程，避免重复）
@Override
public String generateTaskId() {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
    String year = sdf.format(new Date());
    // 调用存储过程获取自增序列
    Integer seq = getTaskSeq();
    String seqStr = String.format("%05d", seq);
    return "XT-" + year + "-" + seqStr;
}

// 调用存储过程获取序列
private Integer getTaskSeq() {
    Connection conn = null;
    CallableStatement cs = null;
    ResultSet rs = null;
    Integer seq = 1;
    try {
        conn = DBUtil.getConnection();
        cs = conn.prepareCall("{CALL get_task_seq(?)}");
        cs.registerOutParameter(1, java.sql.Types.INTEGER);
        cs.execute();
        seq = cs.getInt(1);
    } catch (SQLException e) {
        e.printStackTrace();
        // 异常时用随机数兜底
        seq = new Random().nextInt(99999) + 1;
    } finally {
        DBUtil.close(rs, cs, conn);
    }
    return seq;
}

@Override
public int addTask(Task task) {
    if (task == null || task.getClientName() == null || task.getItemName() == null) {
        return 0;
    }
    // 自动生成任务编号和委托时间
    task.setId(generateTaskId());
    task.setCommitDate(new SimpleDateFormat("yyyyMMdd").format(new Date()));
    return taskDao.addTask(task);
}

@Override
public List<Task> queryPendingConfirmTasks() {
    return taskDao.queryPendingConfirmTasks();
}

@Override
public int confirmTask(String id, String state) {
    if (id == null || state == null) {
        return 0;
    }
    return taskDao.confirmTask(id, state);
}

@Override
public int assignTask(String id, String manageId, String inspectorId) {
    if (id == null || (manageId == null && inspectorId == null)) {
        return 0;
    }
    return taskDao.assignTask(id, manageId, inspectorId);
}

@Override
public List<Task> queryTasksByRole(String userId, Integer userCategory, Integer groupNo, String state) {
    if (userId == null || userCategory == null) {
        return null;
    }
    return taskDao.queryTasksByRole(userId, userCategory, groupNo, state);
}

// 修正：添加状态校验（仅允许进行中、经理待审核、已退回）
@Override
public int updateTaskForm(Task task) {
    if (task == null || task.getId() == null) {
        return 0;
    }
    // 先查询任务当前状态
    Task currentTask = taskDao.queryTaskDetail(task.getId());
    if (currentTask == null) {
        return 0;
    }
    // 允许修改的状态列表
    List<String> allowStates = Arrays.asList("进行中", "经理待审核", "已退回");
    if (!allowStates.contains(currentTask.getState())) {
        return 0; // 状态不允许，返回失败
    }
    return taskDao.updateTaskForm(task);
}

// 修正：添加状态校验
@Override
public int deleteTaskForm(String id) {
    if (id == null) {
        return 0;
    }
    Task currentTask = taskDao.queryTaskDetail(id);
    if (currentTask == null) {
        return 0;
    }
    List<String> allowStates = Arrays.asList("进行中", "经理待审核", "已退回");
    if (!allowStates.contains(currentTask.getState())) {
        return 0;
    }
    return taskDao.deleteTaskForm(id);
}

@Override
public int approveTask(String id, String state, String rejectReason) {
    if (id == null || state == null) {
        return 0;
    }
    return taskDao.approveTask(id, state, rejectReason);
}

@Override
public Task queryTaskDetail(String id) {
    if (id == null) {
        return null;
    }
    return taskDao.queryTaskDetail(id);
}

@Override
public List<Task> statCompletedTasks(String startDate, String endDate) {
    if (startDate == null || endDate == null || startDate.length() != 8 || endDate.length() != 8) {
        return null;
    }
    return taskDao.statCompletedTasks(startDate, endDate);
}

// 新增：实现客户查询任务方法
@Override
public List<Task> queryTasksByClient(String clientName) {
    if (clientName == null || clientName.trim().isEmpty()) {
        return null;
    }
    return taskDao.queryTasksByClient(clientName);
}

}
四、Servlet 层核心文件（必替换）
ClientServlet.java（修正客户查询逻辑）
java
运行
package com.company.detection.controller;

import com.company.detection.entity.Task;
import com.company.detection.entity.User;
import com.company.detection.service.TaskService;
import com.company.detection.service.impl.TaskServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.List;

@WebServlet("/client/*")
public class ClientServlet extends HttpServlet {
private TaskService taskService = new TaskServiceImpl();

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    request.setCharacterEncoding("UTF-8");
    String pathInfo = request.getPathInfo();
    HttpSession session = request.getSession();
    User loginUser = (User) session.getAttribute("loginUser");

    // 权限校验：未登录跳转登录页
    if (loginUser == null || loginUser.getUserCategory() != 3) {
        response.sendRedirect(request.getContextPath() + "/login.jsp");
        return;
    }

    // 提交委托申请
    if ("/submitTask".equals(pathInfo)) {
        Task task = new Task();
        task.setClientName(request.getParameter("clientName"));
        task.setItemName(request.getParameter("itemName"));
        task.setItemContent(request.getParameter("itemContent"));

        int result = taskService.addTask(task);
        if (result > 0) {
            System.out.println("客户" + loginUser.getUserName() + "提交委托申请，任务编号：" + task.getId());
            request.setAttribute("successMsg", "委托申请提交成功！");
        } else {
            request.setAttribute("errorMsg", "提交失败，请重试！");
        }
        request.getRequestDispatcher("/client/submitTask.jsp").forward(request, response);
    }

    // 查看进度（客户查询自己提交的任务）
    else if ("/viewProgress".equals(pathInfo)) {
        List<Task> tasks = taskService.queryTasksByClient(loginUser.getUserName());
        request.setAttribute("tasks", tasks);
        request.getRequestDispatcher("/client/viewProgress.jsp").forward(request, response);
    }

    // 查询结果（仅已完成+当前客户提交的任务）
    else if ("/queryResult".equals(pathInfo)) {
        String taskId = request.getParameter("taskId");
        Task task = taskService.queryTaskDetail(taskId);
        // 双重校验：任务存在+已完成+委托单位匹配当前客户
        if (task != null && "已完成".equals(task.getState()) 
            && task.getClientName().equals(loginUser.getUserName())) {
            request.setAttribute("task", task);
        } else {
            request.setAttribute("errorMsg", "无权限查看该任务结果或任务未完成！");
        }
        request.getRequestDispatcher("/client/queryResult.jsp").forward(request, response);
    }
}

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    doPost(request, response);
}

}