mescloud/src/main/java/com/jeesite/modules/mes/web/MesLineProcessController.java

package com.jeesite.modules.mes.web;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSON;
import com.jeesite.common.collect.ListUtils;
import com.jeesite.common.collect.MapUtils;
import com.jeesite.common.lang.DateUtils;
import com.jeesite.common.lang.ObjectUtils;
import com.jeesite.common.lang.StringUtils;
import com.jeesite.common.mybatis.mapper.query.QueryType;
import com.jeesite.modules.mes.dao.MesLineDao;
import com.jeesite.modules.mes.dao.MesLineProcessDao;
import com.jeesite.modules.mes.dao.MesLineProcessUserDao;
import com.jeesite.modules.mes.entity.*;
import com.jeesite.modules.mes.resp.CommonResp;
import com.jeesite.modules.mes.resp.ComListResp;
import com.jeesite.modules.mes.service.*;
import com.jeesite.modules.mes.util.CommonUitl;
import com.jeesite.modules.mes.util.CopyUtil;
import com.jeesite.modules.sys.entity.EmpUser;
import com.jeesite.modules.sys.entity.User;
import com.jeesite.modules.sys.service.UserService;
import com.jeesite.modules.sys.utils.UserUtils;
import io.swagger.models.auth.In;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import com.jeesite.common.config.Global;
import com.jeesite.common.entity.Page;
import com.jeesite.common.web.BaseController;
import org.springframework.web.multipart.MultipartFile;

/**
 * 生成工序表Controller
 * @author hzd
 * @version 2023-06-18
 */
@Controller
@RequestMapping(value = "${adminPath}/mes/mesLineProcess")
public class MesLineProcessController extends BaseController {

	@Autowired
	private MesLineProcessService mesLineProcessService;

	@Autowired
	private MesLineService mesLineService;

	@Autowired
	private MesProductRecordService mesProductRecordService;

	@Autowired
	private MesProductHeliumService mesProductHeliumService;
	@Autowired
	private MesSkillService mesSkillService;
	@Autowired
	private MesUserSkillService mesUserSkillService;

	/**
	 * JAR管理页面
	 */
	@RequestMapping(value = "jarManagement")
	public String jarManagement(MesLineProcess mesLineProcess, Model model) {
		model.addAttribute("mesLineProcess", mesLineProcess);
		return "modules/mes/mesLineProcessJarManagement";
	}

	/**
	 * 获取数据
	 */
	@ModelAttribute
	public MesLineProcess get(String id, boolean isNewRecord) {
		return mesLineProcessService.get(id, isNewRecord);
	}

	/**
	 * 查询列表
	 */
	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = {"list", ""})
	public String list(MesLineProcess mesLineProcess, Model model) {
		model.addAttribute("mesLineProcess", mesLineProcess);

		// 获取生产线数据
		List<MesLine> lineList = mesLineService.findList(new MesLine());
		model.addAttribute("lineList", lineList);

		return "modules/mes/mesLineProcessList";
	}

	/**
	 * 查询列表数据
	 */
	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "listData")
	@ResponseBody
	public Page<MesLineProcess> listData(MesLineProcess mesLineProcess, HttpServletRequest request, HttpServletResponse response) {
//		System.out.println(request.getParameterMap());
		mesLineProcess.getSqlMap().getWhere().and("a.pid",QueryType.IS_NULL,"");
		mesLineProcess.setPage(new Page<>(request, response));
		Page<MesLineProcess> page = mesLineProcessService.findPage(mesLineProcess);
		return page;
	}

	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = {"sublist", ""})
	public String sublist(MesLineProcess mesLineProcess, Model model) {
		model.addAttribute("mesLineProcess", mesLineProcess);

		MesLineProcess mesLineProcess2 = new MesLineProcess();
		mesLineProcess2.setId(mesLineProcess.getPid());
		MesLineProcess mlInfo = mesLineProcessService.get(mesLineProcess2);
		model.addAttribute("mlInfo", mlInfo);

		// 获取生产线数据
		List<MesLine> lineList = mesLineService.findList(new MesLine());
		model.addAttribute("lineList", lineList);

		return "modules/mes/mesLineProcessSublist";
	}

	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "listData2")
	@ResponseBody
	public Page<MesLineProcess> listData2(MesLineProcess mesLineProcess, HttpServletRequest request, HttpServletResponse response) {
		mesLineProcess.setPage(new Page<>(request, response));
		Page<MesLineProcess> page = mesLineProcessService.findPage(mesLineProcess);
		return page;
	}

	/**
	 * 查询子表数据
	 */
	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "mesLineProcessUserListData")
	@ResponseBody
	public Page<MesLineProcessUser> subListData(MesLineProcessUser mesLineProcessUser, HttpServletRequest request, HttpServletResponse response) {
		mesLineProcessUser.setPage(new Page<>(request, response));
		Page<MesLineProcessUser> page = mesLineProcessService.findSubPage(mesLineProcessUser);
		return page;
	}

	/**
	 * 查看编辑表单
	 */
	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "form")
	public String form(MesLineProcess mesLineProcess, Model model) {
		model.addAttribute("mesLineProcess", mesLineProcess);
		// 获取生产线数据
		List<MesLine> lineList = mesLineService.findList(new MesLine());
		model.addAttribute("lineList", lineList);

		return "modules/mes/mesLineProcessForm";
	}

	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "subform")
	public String subform(MesLineProcess mesLineProcess, Model model) {

		MesLineProcess mesLineProcess2 = new MesLineProcess();
		mesLineProcess2.setId(mesLineProcess.getPid());
		MesLineProcess mlInfo = mesLineProcessService.get(mesLineProcess2);
		model.addAttribute("mlInfo", mlInfo);
		mesLineProcess.setLineId(mlInfo.getLineId());
		mesLineProcess.setTitle(mlInfo.getTitle());
		model.addAttribute("mesLineProcess", mesLineProcess);
		// 获取生产线数据
		List<MesLine> lineList = mesLineService.findList(new MesLine());
		model.addAttribute("lineList", lineList);

		return "modules/mes/mesLineProcessSubform";
	}

	/**
	 * 保存数据
	 */
	@RequiresPermissions("mes:mesLineProcess:edit")
	@PostMapping(value = "save")
	@ResponseBody
	public String save(@Validated MesLineProcess mesLineProcess) {
		mesLineProcessService.save(mesLineProcess);
		return renderResult(Global.TRUE, text("保存生成工序表成功！"));
	}

	/**
	 * 停用数据
	 */
	@RequiresPermissions("mes:mesLineProcess:edit")
	@RequestMapping(value = "disable")
	@ResponseBody
	public String disable(MesLineProcess mesLineProcess) {
		mesLineProcess.setStatus(MesLineProcess.STATUS_DISABLE);
		mesLineProcessService.updateStatus(mesLineProcess);
		return renderResult(Global.TRUE, text("停用生成工序表成功"));
	}

	/**
	 * 启用数据
	 */
	@RequiresPermissions("mes:mesLineProcess:edit")
	@RequestMapping(value = "enable")
	@ResponseBody
	public String enable(MesLineProcess mesLineProcess) {
		mesLineProcess.setStatus(MesLineProcess.STATUS_NORMAL);
		mesLineProcessService.updateStatus(mesLineProcess);
		return renderResult(Global.TRUE, text("启用生成工序表成功"));
	}

	/**
	 * 删除数据
	 */
	@RequiresPermissions("mes:mesLineProcess:edit")
	@RequestMapping(value = "delete")
	@ResponseBody
	public String delete(MesLineProcess mesLineProcess) {
		mesLineProcessService.delete(mesLineProcess);
		return renderResult(Global.TRUE, text("删除生成工序表成功！"));
	}

	/**
	 * 获取树结构数据
	 * @param excludeCode 排除的Code
	 * @param isShowCode 是否显示编码（true or 1：显示在左侧；2：显示在右侧；false or null：不显示）
	 * @return
	 */
	@RequiresPermissions("mes:mesLineProcess:view")
	@RequestMapping(value = "treeData")
	@ResponseBody
	public List<Map<String, Object>> treeData(String excludeCode, String isShowCode) {
		List<Map<String, Object>> mapList = ListUtils.newArrayList();

		MesLine ml = new MesLine();
		ml.setStatus("0");
		List<MesLine> mlist = mesLineService.findList(ml);
		for (int i=0; i<mlist.size(); i++){
			MesLine e = mlist.get(i);
			Map<String, Object> map = MapUtils.newHashMap();
			map.put("id", e.getId());
			map.put("pId", "0");
			map.put("name", e.getTitle());
			mapList.add(map);

			MesLineProcess mlp = new MesLineProcess();
			mlp.setStatus("0");
			mlp.setLineId(e.getId());
			List<MesLineProcess> list = mesLineProcessService.findListOrder(mlp);

			for (int j=0; j<list.size(); j++){
				MesLineProcess p = list.get(j);
				Map<String, Object> map2 = MapUtils.newHashMap();
				map2.put("id", p.getId());
				map2.put("pId", e.getId());
				map2.put("name", p.getTitle());
				mapList.add(map2);
			}

		}

		return mapList;
	}

	@RequestMapping(value = "all")
	@ResponseBody
	public CommonResp all(MesLineProcess mesLineProcess) {
		mesLineProcess.setStatus("0");
		List<MesLineProcess> lists = mesLineProcessService.findList(mesLineProcess);

		// 列表复制
		List<ComListResp> result = CopyUtil.copyList(lists, ComListResp.class);
		CommonResp<List<ComListResp>> resp = new CommonResp<>();
		resp.setData(result);
		resp.setResult(Global.TRUE);
		return resp;
	}
	//	@RequiresPermissions("mes:mesLineProcess:api")
	@RequestMapping(value = "processList")
	@ResponseBody
	public CommonResp processList(HttpServletRequest req) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
//		User user = UserUtils.getUser();
//		MesLineProcessUser mesLineProcessUser = new MesLineProcessUser();
//		mesLineProcessUser.setUserCode(user.getUserCode());
//		List<MesLineProcessUser> list = mesLineProcessService.findSubListOrder(mesLineProcessUser);
//		List<String> ids = new ArrayList<>();
//		for (MesLineProcessUser item:list){
//			ids.add(item.getId());
//		}
//		Map<String, Object> map = MapUtils.newHashMap();
//		if(!ids.isEmpty()){
//			MesLineProcess mesLineProcess = new MesLineProcess();
//			mesLineProcess.getSqlMap().getWhere().and("id", QueryType.IN,ids);
//			List<MesLineProcess> list1 = mesLineProcessService.findList(mesLineProcess);
//			map.put("lists", list1);
//		}else {
//			List<MesLineProcess> list1 = new ArrayList<>();
//			map.put("lists", list1);
//		}
		Map<String, Object> map = MapUtils.newHashMap();
		MesLineProcess mesLineProcess = new MesLineProcess();
		mesLineProcess.setStatus("0");
		mesLineProcess.getSqlMap().getWhere().and("a.pid",QueryType.IS_NOT_NULL,"");
		List<MesLineProcess> lists = mesLineProcessService.findList(mesLineProcess);
		if(ListUtils.isEmpty(lists)){
			List<MesLineProcess> list1 = new ArrayList<>();
			map.put("lists", list1);
		}else{
			map.put("lists", lists);
		}
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}
	@RequiresPermissions("mes:mesLineProcess:api")
	@PostMapping(value = "editDevices")
	@ResponseBody
	public String editDevices(@Validated MesLineProcess mesLineProcess, HttpServletRequest req) {
		String id = req.getParameter("id");
		if(id.isEmpty()){
			return renderResult(Global.FALSE, text("id不能为空"));
		}
		mesLineProcessService.save(mesLineProcess);
		return renderResult(Global.TRUE, text("修改成功！"));
	}

	/**
	 * 获取工人权限
	 */
	@RequestMapping(value = "userAuth")
	@ResponseBody
	public CommonResp userAuth(HttpServletRequest request) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		String oprno =request.getParameter("oprno");
		String lineSn =request.getParameter("lineSn");
		String OldOprno = "";
		if (oprno.length()>5){
			OldOprno = oprno.substring(0, oprno.length() - 1);
		}else {
			OldOprno = oprno;
		}
		String type =request.getParameter("type");

		Map<String, Object> map = MapUtils.newHashMap();
		if(StringUtils.isEmpty(oprno) || StringUtils.isEmpty(lineSn)){
			resp.setMessage("参数为空");
			resp.setResult(Global.FALSE);
			return  resp;
		}
		User user = UserUtils.getUser();
		if(user.getUserCode().equals("system")){ // 超级管理员
			map.put("auth",2);
			resp.setData(map);
			resp.setResult(Global.TRUE);
			return resp;
		}

		MesLineProcessUser mesLineProcessUser = new MesLineProcessUser();
		mesLineProcessUser.setUserCode(user.getUserCode());
		if(type.equals("1")){ // 质量
			String[] ids = new String[]{"1","2"};
			mesLineProcessUser.getSqlMap().getWhere().and("auth",QueryType.IN,ids);
		}else{ // 生产
			String[] ids = new String[]{"0","2"};
			mesLineProcessUser.getSqlMap().getWhere().and("auth",QueryType.IN,ids);
		}
		List<MesLineProcessUser> list = mesLineProcessService.findSubListOrder(mesLineProcessUser);
		logger.info("list:"+ JSON.toJSONString(list));
		if(ListUtils.isEmpty(list)){
			map.put("auth",0);
			resp.setData(map);
			resp.setResult(Global.TRUE);
			return resp;
		}

		//工人技能检验
		if (!mesSkillService.checkUserSkill(lineSn, oprno, user.getUserCode())) {
			map.put("auth",0);
			resp.setData(map);
			resp.setResult(Global.TRUE);
			return resp;
		}

		List<String> mlps = new ArrayList<>();
		for(MesLineProcessUser mesLineProcessUser1:list){
			mlps.add(mesLineProcessUser1.getLineProcessId());
		}

		logger.info("mlps:"+ JSON.toJSONString(mlps));
		Integer auth = 0;
		MesLineProcess mesLineProcess = new MesLineProcess();
		mesLineProcess.getSqlMap().getWhere().and("id", QueryType.IN,mlps);
		mesLineProcess.setOprno(OldOprno);
		mesLineProcess.setLineSn(lineSn);
		MesLineProcess mesLineProcess1 = mesLineProcessService.findInfo(mesLineProcess);
		logger.info("mesLineProcess1:"+ JSON.toJSONString(mesLineProcess1));
		if(!ObjectUtils.isEmpty(mesLineProcess1)){
			auth = 1;
		}

		map.put("auth",auth);
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}

	@RequiresPermissions("mes:mesLineProcess:jph")
	@RequestMapping(value = "jph")
	public String jph(MesLineProcess mesLineProcess, Model model) {
		model.addAttribute("mesLineProcess", mesLineProcess);
		// 获取生产线数据
		List<MesLine> lineList = mesLineService.findList(new MesLine());
		model.addAttribute("lineList", lineList);

		return "modules/mes/mesLineProcessJph";
	}

	@RequestMapping(value = "jphData")
	@ResponseBody
	public CommonResp jphData(HttpServletRequest request) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		String oprno =request.getParameter("oprno");
		String lineSn =request.getParameter("lineSn");

		String[] xdata = new String[24];
		String[] ydata = new String[24];
		String today = CommonUitl.getToday();
		for (int i=0; i<24;i++){
			xdata[i] = (i+1)+"点";
			String sdate = today +" "+ (i>9?i+":00:00":"0"+i+":00:00");
			int j = i + 1;
			String edate = today +" "+ (j>9?j+":00:00":"0"+j+":00:00");
			String jph = "";
			if(lineSn.equals("LB") && oprno.equals("OP220")){
				jph = mesProductHeliumService.getJpDate(oprno,lineSn,sdate,edate);
			}else{
				jph = mesProductRecordService.getJpDate(oprno,lineSn,sdate,edate);
			}

			ydata[i] = jph;
		}


		Map<String, Object> map = MapUtils.newHashMap();
		map.put("xdata",xdata);
		map.put("ydata",ydata);
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}

	@Autowired
	private UserService userService;
	@Autowired
	private MesLineProcessUserDao mesLineProcessUserDao;

	@RequestMapping({"formAuth"})
	public String form(EmpUser empUser, String op, Model model) {

		User user = userService.get(empUser.getUserCode());
		MesLineProcessUser mesLineProcessUser = new MesLineProcessUser();
		User user1 = new User();
		user1.setUserCode(user.getUserCode());
		mesLineProcessUser.setUserCode(user.getUserCode());
		List<MesLineProcessUser> list = this.mesLineProcessUserDao.findList(mesLineProcessUser);
		List<String> lineProcessIds = new ArrayList<>();
		if (list.size() > 0){
			for (MesLineProcessUser lineProcessUser : list) {
				lineProcessIds.add(lineProcessUser.getLineProcessId());
			}
		}
		model.addAttribute("oprnoList", lineProcessIds);

		model.addAttribute("empUser", user);
//		model.addAttribute("ctrlPermi", Global.getConfig("user.adminCtrlPermi", "2"));
		return "modules/mes/mesUserAuthProcess";
	}

	@PostMapping(value = "save2")
	@ResponseBody
	public String save2(MesLineProcess mesLineProcess) {
		//1.根据userCode删除对应的mesLineProcessUser
		MesLineProcessUser mesLineProcessUser = new MesLineProcessUser();
		User user = new User();
		user.setUserCode(mesLineProcess.getUserCode());
		mesLineProcessUser.setUserCode(mesLineProcess.getUserCode());
		mesLineProcessUserDao.deleteByEntity(mesLineProcessUser);
		//2.添加
		if (StringUtils.isNotEmpty(mesLineProcess.getUserProcessString())){
			for (String s : mesLineProcess.getUserProcessString().split(",")) {
				MesLineProcessUser mesLineProcessUser1 = new MesLineProcessUser();
				MesLineProcess mesLineProcess1 = new MesLineProcess();
				mesLineProcess1.setId(s);
				mesLineProcessUser1.setUserCode(mesLineProcess.getUserCode());
				mesLineProcessUser1.setLineProcessId(mesLineProcess1.getId());
				mesLineProcessUserDao.insert(mesLineProcessUser1);
			}
		}
		return renderResult(Global.TRUE, text("保存成功！"));
	}



	// 获取所有子工位
	@RequestMapping(value = "getAllSonOpron")
	@ResponseBody
	public CommonResp getAllSonOpron() {
		CommonResp<List<MesLineProcess>> resp = new CommonResp<>();
		resp.setData(mesLineProcessService.getAllSonOpron());
		resp.setResult(Global.TRUE);
		return resp;
	}

	// 获取父级工位
	@RequestMapping(value = "getParents")
	@ResponseBody
	public CommonResp getParents(HttpServletRequest request) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		Map<String, Object> map = MapUtils.newHashMap();
		MesLineProcess mesLineProcess = new MesLineProcess();
		mesLineProcess.setStatus("0");
		mesLineProcess.setLineSn("XT");
//		String sn = request.getParameter("sn");
//		String gdStr1 = "0050011000300H718333"; // 箱体
//		if(!StringUtils.isEmpty(sn) && !sn.contains(gdStr1)){
//			mesLineProcess.setLineSn("LB");
//		}
		mesLineProcess.getSqlMap().getWhere().and("a.pid",QueryType.IS_NULL,"");
		List<MesLineProcess> lists = mesLineProcessService.findList(mesLineProcess);
		if(ListUtils.isEmpty(lists)){
			List<MesLineProcess> list1 = new ArrayList<>();
			map.put("lists", list1);
		}else{
			map.put("lists", lists);
		}
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}

	@Autowired
	MesLineProcessDao mesLineProcessDao;
	@Autowired
	MesLineDao mesLineDao;

	//上传jar包
	@PostMapping(value = "uploadjar")
	@ResponseBody
	public CommonResp upload(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
		CommonResp resp = new CommonResp();
		try {
			if (file.isEmpty()) {
				resp.setResult(Global.FALSE);
				resp.setMessage("上传文件不能为空");
				return resp;
			}

			String fileName = file.getOriginalFilename();
//			if (fileName == null || !fileName.endsWith(".jar")) {
//				resp.setResult(Global.FALSE);
//				resp.setMessage("只能上传jar文件");
//				return resp;
//			}

			String id = request.getParameter("id");//工位主键ID
			// 1. 获取旧的jar包路径，以便后续清理
			MesLineProcess oldProcess = mesLineProcessService.get(id);
			String oldJarPath = (oldProcess != null) ? oldProcess.getJarPath() : null;

			// 2. 准备保存路径 (D:/mescloud/userfiles/jar/yyyyMMdd/)
			String baseDir = Global.getConfig("file.baseDir", "D:/mescloud");
			String relativePath = "userfiles/jar/" + DateUtils.getDate("yyyyMMdd") + "/";
			String realPath = baseDir + (baseDir.endsWith("/") ? "" : "/") + relativePath;

			File dir = new File(realPath);
			if (!dir.exists()) {
				dir.mkdirs();
			}

			// 3. 生成新文件名并保存到本地
			String saveFileName = System.currentTimeMillis() + "_" + fileName;
			String pathname = realPath + saveFileName;
			logger.info("上传文件保存路径：" + pathname);
			File dest = new File(pathname);
			file.transferTo(dest);

			// 4. 更新数据库记录，确保主键唯一对应
			mesLineProcessDao.updateJarPathById(id, pathname);

			// 5. 上传成功后，清理旧的物理文件
			if (StringUtils.isNotBlank(oldJarPath)) {
				File oldFile = new File(oldJarPath);
				if (oldFile.exists()) {
					if (oldFile.delete()) {
						logger.info("旧JAR包物理文件删除成功: " + oldJarPath);
					}
				}
			}

			resp.setData("/" + relativePath + saveFileName);
			resp.setResult(Global.TRUE);
			resp.setMessage("上传成功");
			return resp;
		} catch (Exception e) {
			logger.error("上传jar包失败", e);
			resp.setResult(Global.FALSE);
			resp.setMessage("上传失败: " + e.getMessage());
			return resp;
		}
	}

	/**
	 * 下载jar包
	 */
	@PostMapping(value = "downloadJar")
	public void downloadJar(HttpServletRequest request, HttpServletResponse response) {
		try {
			String sn = request.getParameter("sn"); // 生产线编号
			String oprno = request.getParameter("oprno"); // 生产工位号

			if (StringUtils.isBlank(sn) || StringUtils.isBlank(oprno)) {
				return;
			}

			// 根据产线编号查询产线id
			MesLine mesLine = mesLineDao.selectIdBysn(sn);
			if (mesLine == null) {
				return;
			}

			// 从数据库获取jar包路径
			String jarPath = mesLineProcessDao.getJarPath(mesLine.getId(), oprno);
			if (StringUtils.isBlank(jarPath)) {
				return;
			}

			File file = new File(jarPath);
			if (!file.exists()) {
				return;
			}

			// 设置响应头
			String fileName = file.getName();
			// 去掉时间戳前缀 (如 1715760000000_test.jar -> test.jar)
			if (fileName.contains("_")) {
				fileName = fileName.substring(fileName.indexOf("_") + 1);
			}

			response.reset();
			response.setContentType("application/octet-stream");
			response.setCharacterEncoding("utf-8");
			response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));

			// 读取文件并写入响应流
			try (InputStream is = new FileInputStream(file);
				 OutputStream os = response.getOutputStream()) {
				byte[] buffer = new byte[1024];
				int len;
				while ((len = is.read(buffer)) != -1) {
					os.write(buffer, 0, len);
				}
				os.flush();
			}
		} catch (Exception e) {
			logger.error("下载jar包失败", e);
		}
	}

	/**
	 * 删除jar包
	 */
	@PostMapping(value = "deleteJar")
	@ResponseBody
	public CommonResp deleteJar(HttpServletRequest request) {
		CommonResp resp = new CommonResp();
		try {
			String id = request.getParameter("id"); // 工位主键ID

			if (StringUtils.isBlank(id)) {
				resp.setResult(Global.FALSE);
				resp.setMessage("ID不能为空");
				return resp;
			}

			// 1. 获取当前工位信息
			MesLineProcess mesLineProcess = mesLineProcessService.get(id);
			if (mesLineProcess == null) {
				resp.setResult(Global.FALSE);
				resp.setMessage("工位不存在");
				return resp;
			}
			
			String jarPath = mesLineProcess.getJarPath();
			
			// 2. 尝试删除物理文件
			if (StringUtils.isNotBlank(jarPath)) {
				File file = new File(jarPath);
				if (file.exists()) {
					file.delete();
				}
			}

			// 3. 清除数据库记录
			mesLineProcessDao.updateJarPathById(id, null);

			resp.setResult(Global.TRUE);
			resp.setMessage("删除成功");
			return resp;
		} catch (Exception e) {
			logger.error("删除jar包失败", e);
			resp.setResult(Global.FALSE);
			resp.setMessage("删除失败: " + e.getMessage());
			return resp;
		}
	}
}