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

package com.jeesite.modules.mes.web;

import com.jeesite.common.collect.ListUtils;
import com.jeesite.common.collect.MapUtils;
import com.jeesite.common.config.Global;
import com.jeesite.common.entity.Page;
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.common.utils.excel.ExcelExport;
import com.jeesite.common.web.BaseController;
import com.jeesite.modules.file.entity.FileUpload;
import com.jeesite.modules.file.service.FileUploadService;
import com.jeesite.modules.mes.entity.*;
import com.jeesite.modules.mes.resp.CommonResp;
import com.jeesite.modules.mes.service.*;
import com.jeesite.modules.mes.util.CommonUitl;
import com.jeesite.modules.sys.entity.User;
import com.jeesite.modules.sys.utils.UserUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 返工记录表Controller
 * @author mes
 * @version 2023-12-04
 */
@Controller
@RequestMapping(value = "${adminPath}/mes/mesRepair")
public class MesRepairController extends BaseController {

	@Autowired
	private MesRepairService mesRepairService;
	@Autowired
	private MesProductService mesProductService;
	@Autowired
	private MesProductRecordService mesProductRecordService;
	@Autowired
	private MesRepairOprnoService mesRepairOprnoService;
	@Autowired
	private MesRepairSopService mesRepairSopService;
	@Autowired
	private FileUploadService fileUploadService;
	@Autowired
	private MesDeviceService mesDeviceService;
	@Autowired
	private MesQualityService mesQualityService;
	@Autowired
	private MesRepairItemsService mesRepairItemsService;
	@Autowired
	private MesRepairQualityService mesRepairQualityService;
	@Autowired
	private MesLineProcessService mesLineProcessService;

	@Autowired
	private MesLineService mesLineService;

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

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

	/**
	 * 查询列表数据
	 */
	@RequiresPermissions("mes:mesRepair:view")
	@RequestMapping(value = "listData")
	@ResponseBody
	public Page<MesRepair> listData(MesRepair mesRepair, HttpServletRequest request, HttpServletResponse response) {
		mesRepair.setPage(new Page<>(request, response));
		Page<MesRepair> page = mesRepairService.findPage(mesRepair);
		return page;
	}

	@RequestMapping(value = {"fx1", ""})
	public String fx1() {
		return "modules/mes/mesRepairFx1";
	}
	@RequestMapping(value = {"fx2", ""})
	public String fx2() {
		return "modules/mes/mesRepairFx2";
	}
	@RequestMapping(value = {"fx3", ""})
	public String fx3() {
		return "modules/mes/mesRepairFx3";
	}
	@RequestMapping(value = {"fx4", ""})
	public String fx4() {
		return "modules/mes/mesRepairFx4";
	}

	/**
	 * 查看编辑表单
	 */
	@RequiresPermissions("mes:mesRepair:view")
	@RequestMapping(value = "form")
	public String form(MesRepair mesRepair, Model model) {
		model.addAttribute("mesRepair", mesRepair);
		return "modules/mes/mesRepairForm";
	}

	@RequiresPermissions("mes:mesRepair:view")
	@RequestMapping(value = "detail")
	public String detail(MesRepair mesRepair, Model model, HttpServletRequest req) {

		if(!StringUtils.isEmpty(mesRepair.getSops())){
			MesRepairSop mesRepairSop = new MesRepairSop();
			String[] ids = mesRepair.getSops().split(",");
			mesRepairSop.getSqlMap().getWhere().and("id", QueryType.IN,ids);
			List<MesRepairSop> sopLists = mesRepairSopService.findList(mesRepairSop);
			String host = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort() + "/js";
			for (MesRepairSop sp:sopLists){
				FileUpload fu = new FileUpload();
				fu.setBizKey(sp.getId());
				fu.setBizType("mesRepairSop_image");
				List<FileUpload> finfo = fileUploadService.findList(fu);
				List imgList = ListUtils.newArrayList();
				for (FileUpload fi:finfo){
//					Map<String, Object> map1 = MapUtils.newHashMap();
//					map1.put("id",fi.getFileEntity().getFileId());
//					map1.put("url",host + fi.getFileUrl());
//					map1.put("name",fi.getFileName());
//					map1.put("size",fi.getFileEntity().getFileSize());

					imgList.add(host + fi.getFileUrl());
				}
				sp.setImgList(imgList);
			}
			mesRepair.setSopList(sopLists);
		}
		MesRepairQuality mesRepairQuality = new MesRepairQuality();
		mesRepairQuality.setRepairId(mesRepair.getId());
		MesRepairQuality quality = mesRepairQualityService.findInfo(mesRepairQuality);
		model.addAttribute("mesRepair", mesRepair);
		model.addAttribute("quality", quality);
		return "modules/mes/mesRepairInfo";
	}

	/**
	 * 导出数据
	 */
	@RequiresPermissions("mes:mesRepair:view")
	@RequestMapping(value = "exportData")
	public void exportData(MesRepair mesRepair, HttpServletResponse response) {
		List<MesRepair> list = mesRepairService.findList(mesRepair);
		String fileName = "返修记录" + DateUtils.getDate("yyyyMMddHHmmss") + ".xlsx";
		try(ExcelExport ee = new ExcelExport("返修记录", MesRepair.class)){
			ee.setDataList(list).write(response, fileName);
		}
	}

	/**
	 * 保存数据
	 */
	@RequiresPermissions("mes:mesRepair:edit")
	@PostMapping(value = "save")
	@ResponseBody
	public String save(@Validated MesRepair mesRepair) {
		mesRepairService.save(mesRepair);
		return renderResult(Global.TRUE, text("保存返工记录表成功！"));
	}

	/**
	 * 删除数据
	 */
	@RequiresPermissions("mes:mesRepair:edit")
	@RequestMapping(value = "delete")
	@ResponseBody
	public String delete(MesRepair mesRepair) {
		mesRepairService.delete(mesRepair);
		return renderResult(Global.TRUE, text("删除返工记录表成功！"));
	}

	@RequestMapping(value = "getRepair")
	@ResponseBody
	public CommonResp getRepair(MesDevice mesDevice, MesRepairSop mesRepairSop, MesRepairOprno mesRepairOprno, MesRepair mesRepair, MesProductRecord mesProductRecord, MesProduct mesProduct, HttpServletRequest req) {
		CommonResp<Map<String, Object>> resp1 = new CommonResp<>();
		resp1.setResult(Global.FALSE);
		String sn = req.getParameter("sn");
		String fxOprno = req.getParameter("fxOprno");

		if(StringUtils.isEmpty(sn)){
			resp1.setMessage("参数错误");
			return resp1;
		}
		if(StringUtils.isEmpty(fxOprno)){
			resp1.setMessage("参数错误");
			return resp1;
		}

		mesProduct.setSn(sn);
		MesProduct pd = mesProductService.findInfo(mesProduct);
		if(ObjectUtils.isEmpty(pd)){
			resp1.setMessage("产品信息不存在");
			return resp1;
		}
		if(!pd.getState().equals("0") && !pd.getState().equals("2")){
			resp1.setMessage("当前工件不能返修");
			return resp1;
		}
		mesRepair.setSn(sn);
		mesRepair.setFxOprno(fxOprno);
		mesRepair.getSqlMap().getWhere().and("a.state",QueryType.NE,3); // 排除已修复的
		CommonResp<MesRepair> resp = new CommonResp<>();

		MesRepair mesRepair1 = mesRepairService.findInfo(mesRepair);
		mesProductRecord.setSn(sn);
		mesProductRecord.setContent("NG");
		if (mesRepair1!=null){
			mesProductRecord.setOprno(mesRepair1.getOprno());
		}
		MesProductRecord ngInfo = mesProductRecordService.findInfo(mesProductRecord);
		if(ObjectUtils.isEmpty(ngInfo)){
			resp1.setMessage("当前工件不需要返修");
			return resp1;
		}

//		mesRepairOprno.setSn(fxOprno);
//		MesRepairOprno rno = mesRepairOprnoService.findInfo(mesRepairOprno);
//		if(ObjectUtils.isEmpty(rno)){
//			resp1.setMessage("请先设置返修管理工位");
//			return resp1;
//		}
//		String[] rnos = rno.getOprnos().split(",");
//		Boolean qx = false;
//		for (String value : rnos) {
//			if(value.equals(CommonUitl.formatOprno(ngInfo.getOprno()))){
//				qx = true;
//			}
//		}
//		if(!qx){
//			resp1.setMessage("没有返修项");
//			return resp1;
//		}
//		MesDevice deviceInfo = mesDeviceService.findInfoBySn(ngInfo.getLineSn()+ngInfo.getOprno());
		MesLineProcess mpl = new MesLineProcess();
		mpl.setLineSn(ngInfo.getLineSn());
		mpl.setOprno(ngInfo.getOprno());
		MesLineProcess lpinfo = mesLineProcessService.findInfo(mpl);
		if(ObjectUtils.isEmpty(lpinfo)){
			resp1.setMessage("参数错误");
			return resp1;
		}
		if(ObjectUtils.isEmpty(mesRepair1)){
//			mesRepair.setState("1");
//			mesRepair.setOprno(ngInfo.getOprno());
//			MesProductRecord mesProductRecord_1 = new MesProductRecord();
//			mesProductRecord_1.setSn(sn);
//			MesProductRecord oneP = mesProductRecordService.findInfo(mesProductRecord_1);
//			mesRepair.setLineSn(oneP.getLineSn());
////			mesRepairService.save(mesRepair);
//			mesRepair.setSn(sn);
//			mesRepair.setFxOprno(fxOprno);
//			MesRepair new_mesRepair1 = mesRepairService.findInfo(mesRepair);
//			new_mesRepair1.setTitle(lpinfo.getTitle());
//			pd.setState("2");
			resp1.setMessage("当前工件"+ngInfo.getOprno()+"工位需要先进行不良处理!");
			return resp1;
//			mesProductService.save(pd);
//			resp.setData(new_mesRepair1);
		}else {
			if(!StringUtils.isEmpty(mesRepair1.getSops())){
				String[] ids = mesRepair1.getSops().split(",");
				mesRepairSop.getSqlMap().getWhere().and("id", QueryType.IN,ids);
				List<MesRepairSop> sopLists = mesRepairSopService.findList(mesRepairSop);
				String host = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort() + "/js";
				for (MesRepairSop sp:sopLists){
					FileUpload fu = new FileUpload();
					fu.setBizKey(sp.getId());
					fu.setBizType("mesRepairSop_image");
					List<FileUpload> finfo = fileUploadService.findList(fu);
					List imgList = ListUtils.newArrayList();
					for (FileUpload fi:finfo){
//					Map<String, Object> map1 = MapUtils.newHashMap();
//					map1.put("id",fi.getFileEntity().getFileId());
//					map1.put("url",host + fi.getFileUrl());
//					map1.put("name",fi.getFileName());
//					map1.put("size",fi.getFileEntity().getFileSize());

						imgList.add(host + fi.getFileUrl());
					}
					sp.setImgList(imgList);
				}
				mesRepair1.setSopList(sopLists);
			}
			mesRepair1.setTitle(lpinfo.getTitle());
			resp.setData(mesRepair1);

		}
		resp.setResult(Global.TRUE);
		return resp;

	}
	@RequestMapping(value = "infoByRepair")
	@ResponseBody
	public CommonResp infoByRepair(HttpServletRequest req) {
		String sn = req.getParameter("sn");
		String oprno = CommonUitl.formatOprno(req.getParameter("oprno"));
		CommonResp<Map<String, Object>> resp = new CommonResp<>();

		if(StringUtils.isEmpty(sn)){
			resp.setResult(Global.FALSE);
			resp.setMessage("参数错误");
			return resp;
		}

		if(sn.length() != 28) { // 不是箱体
			MesProductRecord mpr = mesProductRecordService.findSnByMsn(sn);
			if(!org.springframework.util.ObjectUtils.isEmpty(mpr)){
				sn = mpr.getSn();
			}
		}

		MesProduct mesProduct1 = new MesProduct();
		mesProduct1.setSn(sn);
		MesProduct mesProduct = mesProductService.findInfo(mesProduct1);
		if(ObjectUtils.isEmpty(mesProduct)){
			resp.setResult(Global.FALSE);
			resp.setMessage("产品记录不存在");
			return resp;
		}

		MesProductRecord mesProductRecord = new MesProductRecord();
		mesProductRecord.setSn(sn);
		mesProductRecord.setOprno(oprno);
//		mesProductRecord.setCraft("100000");
//		mesProductRecord.getSqlMap().getWhere().and("content", QueryType.NE,"UDF");
		List<MesProductRecord> lists = mesProductRecordService.findList(mesProductRecord);

//		List<String> oprnos = new ArrayList<>();
//		List<Object> records = new ArrayList<>();
		List<MesProductRecord> nlists = new ArrayList<>();
		for(MesProductRecord mesProductRecord1:lists){
			String op = mesProductRecord1.getCraft().substring(0,1).trim();
			if(op.equals("1") || op.equals("5")){
				nlists.add(mesProductRecord1);
			}
		}

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

	@RequestMapping(value = "cjjl")
	@ResponseBody
	public CommonResp cjjl(MesRepairItems mesRepairItems, MesQuality mesQuality, HttpServletRequest req) {
		String sn = req.getParameter("sn");
		String oprno = CommonUitl.formatOprno(req.getParameter("oprno"));
		CommonResp<Map<String, Object>> resp = new CommonResp<>();

		if(StringUtils.isEmpty(sn)){
			resp.setResult(Global.FALSE);
			resp.setMessage("参数错误");
			return resp;
		}

		if(sn.length() != 28) { // 不是箱体
			MesProductRecord mpr = mesProductRecordService.findSnByMsn(sn);
			if(!org.springframework.util.ObjectUtils.isEmpty(mpr)){
				sn = mpr.getSn();
			}
		}

		MesProduct mesProduct1 = new MesProduct();
		mesProduct1.setSn(sn);
		MesProduct mesProduct = mesProductService.findInfo(mesProduct1);
		if(ObjectUtils.isEmpty(mesProduct)){
			resp.setResult(Global.FALSE);
			resp.setMessage("产品记录不存在");
			return resp;
		}

		mesQuality.setSn(sn);
		mesQuality.setOprno(oprno);
		MesQuality qualityInfo = mesQualityService.findInfo(mesQuality);
		if(!ObjectUtils.isEmpty(qualityInfo)){
			String[] itemsId = qualityInfo.getItems().split(",");
			mesRepairItems.getSqlMap().getWhere().and("id", QueryType.IN,itemsId);
			List<MesRepairItems> itemsList = mesRepairItemsService.findList(mesRepairItems);
			qualityInfo.setMesRepairItemsList(itemsList);
		}
		Map<String, Object> map = MapUtils.newHashMap();
		map.put("lists", qualityInfo);
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}


	@RequestMapping(value = "sopList")
	@ResponseBody
	public CommonResp sopList(MesRepairSop mesRepairSop, HttpServletRequest req) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		List<MesRepairSop> sopLists = mesRepairSopService.findList(mesRepairSop);
		String host = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort() + "/js";
		for (MesRepairSop sp:sopLists){
			FileUpload fu = new FileUpload();
			fu.setBizKey(sp.getId());
			fu.setBizType("mesRepairSop_image");
			List<FileUpload> finfo = fileUploadService.findList(fu);
			List imgList = ListUtils.newArrayList();
			for (FileUpload fi:finfo){
//					Map<String, Object> map1 = MapUtils.newHashMap();
//					map1.put("id",fi.getFileEntity().getFileId());
//					map1.put("url",host + fi.getFileUrl());
//					map1.put("name",fi.getFileName());
//					map1.put("size",fi.getFileEntity().getFileSize());

				imgList.add(host + fi.getFileUrl());
			}
			sp.setImgList(imgList);
		}
		Map<String, Object> map = MapUtils.newHashMap();
		map.put("lists", sopLists);
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}
	@PostMapping(value = "editRepair1")
	@ResponseBody
	public String editRepair1(@Validated MesRepair mesRepair, HttpServletRequest req) {
		mesRepairService.save(mesRepair);
		return renderResult(Global.TRUE, text("修改成功！"));
	}
	@PostMapping(value = "editRepair")
	@ResponseBody
	public String editRepair(@Validated MesRepair mesRepair, HttpServletRequest req) {
		MesRepairQuality mesRepairQuality= new MesRepairQuality();
		mesRepairQuality.setRepairId(mesRepair.getId());
		MesRepairQuality rq = mesRepairQualityService.findById(mesRepairQuality);
		if (ObjectUtils.isEmpty(rq)) {
			return renderResult(Global.FALSE, text("返修质量未检查"));
		}
		mesRepairService.save(mesRepair);

		MesProductRecord mesProductRecord = new MesProductRecord();
		mesProductRecord.setSn(mesRepair.getSn());
		mesProductRecord.setOprno(mesRepair.getOprno());
		mesProductRecord.setCraft("100000");
		MesProductRecord pp = mesProductRecordService.findInfo(mesProductRecord);

		MesProduct mesProduct = new MesProduct();
		mesProduct.setSn(mesRepair.getSn());
		MesProduct pt = mesProductService.findInfo(mesProduct);
		if(mesRepair.getResult().equals("1")){
			pp.setContent("OK");
			if(mesRepair.getLineSn().equals("XT")){
				if(mesRepair.getOprno().equals("OP400")){
					pt.setState("0"); // 框架自OP250后的返修，需要再次做总成气密
				}

				ArrayList<String> oprnos = new ArrayList<String>();
				oprnos.add("OP260");
				oprnos.add("OP270");
				oprnos.add("OP280");
				oprnos.add("OP290");
				oprnos.add("OP300");
				oprnos.add("OP310");
//				oprnos.add("OP320");
				String oprno = CommonUitl.formatOprno(mesRepair.getOprno());
				if(oprnos.contains(oprno)){ // 重置总成气密结果为未过站
					String cateSn = mesLineService.findInfoCate(mesRepair.getLineSn()).trim();
					MesProductRecord mesProductRecord1 = new MesProductRecord();
					mesProductRecord1.setSn(mesRepair.getSn());
					mesProductRecord1.setOprno("OP400");
					mesProductRecord1.setCateSn(cateSn);
					List<MesProductRecord> lists = mesProductRecordService.findList(mesProductRecord1);
					for (MesProductRecord mesProductRecord2:lists){
						mesProductRecord2.setContent("UDF");
						mesProductRecordService.update(mesProductRecord2);
					}
				}
			}else{
				if(mesRepair.getOprno().equals("OP220")){
					pt.setState("1");
				}else {
					pt.setState("0");
				}
			}

			if(CommonUitl.formatOprno(mesRepair.getOprno()).equals("OP310")){ // GP12要重新检查
				pp.setContent("UDF");
			}

			mesProductRecordService.update(pp);
		}else if (mesRepair.getResult().equals("2")){
			if(mesRepair.getLineSn().equals("XT")){
				if(mesRepair.getOprno().equals("OP310")){
					pt.setState("4");
				}
			}else{
				if(mesRepair.getOprno().equals("OP220")){
					pt.setState("4");
				}
			}
		}
		mesProductService.save(pt);
		return renderResult(Global.TRUE, text("修改成功！"));
	}

	// 不良品处理记录
	@RequestMapping(value = "ulist")
	@ResponseBody
	public CommonResp ulist(HttpServletRequest request, HttpServletResponse response) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		Map<String, Object> map = MapUtils.newHashMap();
		User user = UserUtils.getUser();

		MesRepair mesRepair = new MesRepair();
		mesRepair.setCreateBy(user.getUserCode());
		mesRepair.setPage(new Page<>(request, response));
		Page<MesRepair> list = mesRepairService.findPage(mesRepair);
		// 填充责任工位名称
		fillOprnoTitle(list.getList());
		map.put("lists", list);
		resp.setData(map);
		resp.setResult(Global.TRUE);
		return resp;
	}

	private void fillOprnoTitle(List<MesRepair> list) {
		if (ListUtils.isEmpty(list)) {
			return;
		}
		Map<String, String> oprnoTitleMap = new HashMap<>();
		for (MesRepair record : list) {
			if (StringUtils.isBlank(record.getLineSn()) || StringUtils.isBlank(record.getOprno())) {
				record.setOprnoTitle("");
				continue;
			}
			String oprno = CommonUitl.formatOprno(record.getOprno());
			String key = record.getLineSn() + "|" + oprno;
			if (!oprnoTitleMap.containsKey(key)) {
				MesLineProcess mesLineProcess = new MesLineProcess();
				mesLineProcess.setLineSn(record.getLineSn());
				mesLineProcess.setOprno(oprno);
				MesLineProcess mesLineProcess1 = mesLineProcessService.findInfo(mesLineProcess);
				oprnoTitleMap.put(key, ObjectUtils.isEmpty(mesLineProcess1) ? "" : mesLineProcess1.getTitle());
			}
			record.setOprnoTitle(oprnoTitleMap.get(key));
		}
	}

	@RequestMapping(value = "info")
	@ResponseBody
	public CommonResp info(HttpServletRequest request, HttpServletResponse response) {
		CommonResp<MesRepair> resp = new CommonResp<>();
		String id = request.getParameter("id");
		if(StringUtils.isEmpty(id)){
			resp.setResult(Global.FALSE);
			resp.setMessage("参数错误");
			return resp;
		}
		MesRepair mesRepair = new MesRepair();
		mesRepair.setId(id);
		MesRepair info = mesRepairService.get(mesRepair);

		String host = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + "/js";
		FileUpload fu = new FileUpload();
		fu.setBizKey(mesRepair.getId());
		fu.setBizType("mesRepair_image");
		List<FileUpload> finfo = fileUploadService.findList(fu);
		List imgList = ListUtils.newArrayList();
		for (FileUpload fi:finfo){
			Map<String, Object> map1 = MapUtils.newHashMap();
			map1.put("id",fi.getFileEntity().getFileId());
			map1.put("url",host + fi.getFileUrl());
			map1.put("name",fi.getFileName());
			map1.put("size",fi.getFileEntity().getFileSize());
			imgList.add(map1);
		}
		info.setImgList(imgList);
		// 填充责任工位名称
		fillOprnoTitle(ListUtils.newArrayList(info));

		resp.setData(info);
		resp.setResult(Global.TRUE);
		return resp;
	}

	@RequestMapping(value = "saveRepair")
	@ResponseBody
	@Transactional
	public CommonResp saveRepair( HttpServletRequest req) {
		CommonResp<MesRepair> resp = new CommonResp<>();
		resp.setResult(Global.FALSE);
		String sn = req.getParameter("sn");
		String fxOprno = req.getParameter("fxOprno");
		String oprno = req.getParameter("oprno");
		String itemId = req.getParameter("itemId");
		String remark = req.getParameter("remark");
		String type = req.getParameter("type");
		String mesRepair_image = req.getParameter("mesRepair_image");

		if(StringUtils.isEmpty(sn) || StringUtils.isEmpty(fxOprno) || StringUtils.isEmpty(itemId)){
			resp.setMessage("参数错误");
			return resp;
		}

		if (StringUtils.isEmpty(mesRepair_image)){
			resp.setMessage("图片不能为空");
			return resp;
		}

		MesRepairItems mesRepairItems = mesRepairItemsService.get(itemId);
		if(ObjectUtils.isEmpty(mesRepairItems)){
			resp.setMessage("参数错误");
			return resp;
		}

		MesProduct mesProduct = new MesProduct();
		mesProduct.setSn(sn);
		MesProduct pd = mesProductService.findInfo(mesProduct);
		if(ObjectUtils.isEmpty(pd)){
			resp.setMessage("产品信息不存在");
			return resp;
		}
		if(!pd.getState().equals("0") && !pd.getState().equals("2")){
			resp.setMessage("当前工件不能返修");
			return resp;
		}

		MesRepair mesRepair = new MesRepair();
		mesRepair.setSn(sn);
		mesRepair.getSqlMap().getWhere().and("a.state",QueryType.NE,3); // 排除已修复的
		MesRepair mesRepair1 = mesRepairService.findInfo(mesRepair);
		if(!ObjectUtils.isEmpty(mesRepair1)){
			resp.setMessage("该工件返修中");
			return resp;
		}

		MesProductRecord mesProductRecord = new MesProductRecord();
		mesProductRecord.setSn(sn);
		mesProductRecord.setOprno(oprno);
		mesProductRecord.setCraft("100000");
		MesProductRecord ngInfo = mesProductRecordService.findInfo(mesProductRecord);
		if(ObjectUtils.isEmpty(ngInfo)){
			resp.setMessage("当前工件不需要返修");
			return resp;
		}
		if(!ngInfo.getContent().equals("NG")){
			ngInfo.setContent("NG");
			mesProductRecordService.save(ngInfo);
		}

		MesRepair mesRepair2 = new MesRepair();
		mesRepair2.setSn(sn);
		mesRepair2.setFxOprno(fxOprno);
		String lineSn = ngInfo.getLineSn();
		if (StringUtils.isEmpty(lineSn)) {
			lineSn = ngInfo.getCateSn();
		}
		if (StringUtils.isEmpty(lineSn)) {
			lineSn = pd.getCate();
		}
		mesRepair2.setLineSn(mesProductRecordService.normalizeLineSn(lineSn));
		mesRepair2.setItemId(itemId);
		mesRepair2.setRemark(remark);
		mesRepair2.setOprno(oprno);
		mesRepair2.setType(type);
		if(type.equals("1")){ // 在线返修
			mesRepair2.setState("2");
		}else{
			mesRepair2.setState("1");
		}

		mesRepairService.save(mesRepair2);

		pd.setState("2");
		mesProductService.save(pd);

		resp.setResult(Global.TRUE);
		return resp;

	}
}