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

package com.jeesite.modules.mes.web;

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

import com.jeesite.common.lang.ObjectUtils;
import com.jeesite.common.lang.StringUtils;
import com.jeesite.modules.erp.entity.MesProductOrder;
import com.jeesite.modules.erp.service.MesProductOrderService;
import com.jeesite.modules.mes.entity.MesLine;
import com.jeesite.modules.mes.entity.MesProduct;
import com.jeesite.modules.mes.resp.BindMaterialResp;
import com.jeesite.modules.mes.resp.CommonResp;
import com.jeesite.modules.mes.resp.ParamsResp;
import com.jeesite.modules.mes.service.MesLineProcessMaterialService;
import com.jeesite.modules.mes.service.MesLineService;
import com.jeesite.modules.mes.service.MesProductRecordService;
import com.jeesite.modules.mes.service.MesProductService;
import com.jeesite.modules.sys.entity.User;
import com.jeesite.modules.sys.utils.UserUtils;
import com.jeesite.modules.utils.ErrorMsg;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
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 com.jeesite.common.config.Global;
import com.jeesite.common.entity.Page;
import com.jeesite.common.lang.DateUtils;
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.mes.entity.MesOrderSn;
import com.jeesite.modules.mes.service.MesOrderSnService;

/**
 * 生产订单工件表Controller
 * @author sxl
 * @version 2026-07-18
 */
@Controller
@RequestMapping(value = "${adminPath}/mes/mesOrderSn")
public class MesOrderSnController extends BaseController {

	@Autowired
	private MesOrderSnService mesOrderSnService;
	@Autowired
	private MesProductOrderService mesProductOrderService;
	@Autowired
	private MesProductService mesProductService;
	@Autowired
	private MesLineService mesLineService;
	@Autowired
	private MesProductRecordService mesProductRecordService;
	@Autowired
	private MesLineProcessMaterialService mesLineProcessMaterialService;
	@Lazy
	@Autowired
	private MesProductRecordController mesProductRecordController;

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

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

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

	/**
	 * 导出数据
	 */
	@RequiresPermissions("mes:mesOrderSn:view")
	@RequestMapping(value = "exportData")
	public void exportData(MesOrderSn mesOrderSn, HttpServletResponse response) {
		mesOrderSn.setPage(null);
		List<MesOrderSn> list = mesOrderSnService.findList(mesOrderSn);
		String fileName = "生产订单工件表" + DateUtils.getDate("yyyyMMddHHmmss") + ".xlsx";
		try (ExcelExport ee = new ExcelExport("生产订单工件表", MesOrderSn.class)) {
			ee.setDataList(list).write(response, fileName);
		}
	}

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

	/**
	 * 保存数据
	 */
	@RequiresPermissions("mes:mesOrderSn:edit")
	@PostMapping(value = "save")
	@ResponseBody
	public String save(@Validated MesOrderSn mesOrderSn) {
		mesOrderSnService.save(mesOrderSn);
		return renderResult(Global.TRUE, text("保存生产订单工件表成功！"));
	}

	/**
	 * 删除数据
	 */
	@RequiresPermissions("mes:mesOrderSn:edit")
	@RequestMapping(value = "delete")
	@ResponseBody
	public String delete(MesOrderSn mesOrderSn) {
		mesOrderSnService.delete(mesOrderSn);
		return renderResult(Global.TRUE, text("删除生产订单工件表成功！"));
	}

	/**
	 * 生产订单绑定工件码（OP100 工位质量校验通过后方可绑定；绑定成功后提交 OP100 工位结果为 OK）
	 * @param mesOrderSn
	 * @return
	 */
	@RequestMapping(value = "bandSn")
	@ResponseBody
	@Transactional
	public String bandSn(MesOrderSn mesOrderSn) {
		if (mesOrderSn == null || StringUtils.isBlank(mesOrderSn.getOrderId())) {
			return renderResult(Global.FALSE, text("订单编码不能为空！"));
		}
		if (StringUtils.isBlank(mesOrderSn.getSn())) {
			return renderResult(Global.FALSE, text("工件码不能为空！"));
		}
		String sn = mesOrderSn.getSn();

		// 判定工件是否存在，并解析产线编号（质量校验需要 lineSn）
		MesProduct mesProductQuery = new MesProduct();
		mesProductQuery.setSn(sn);
		List<MesProduct> productList = mesProductService.findList(mesProductQuery);
		if (productList == null || productList.isEmpty() || ObjectUtils.isEmpty(productList.get(0))) {
			return renderResult(Global.FALSE, text("工件不存在！"));
		}
		MesProduct mesProduct = productList.get(0);
		MesLine mesLine = new MesLine();
		mesLine.setProductCate(mesProduct.getCate());
		mesLine.setStatus("0");
		MesLine lineInfo = mesLineService.findInfo(mesLine);
		if (ObjectUtils.isEmpty(lineInfo) || StringUtils.isEmpty(lineInfo.getSn())) {
			return renderResult(Global.FALSE, text("产线信息不存在！"));
		}
		String lineSn = lineInfo.getSn();

		// OP100 质量校验（按子工位 OP100A）；允许本工位已加工（OK/NG）时仍可绑定订单
		String userCode = "";
		User user = UserUtils.getUser();
		if (user != null && StringUtils.isNotEmpty(user.getUserCode())) {
			userCode = user.getUserCode();
		}
		String ret = mesProductRecordController.checkQualityCommon("OP100A", sn, lineSn, userCode);
		String checkret = ret.substring(3, 5);
		if (!"UD".equals(checkret) && !"OK".equalsIgnoreCase(checkret) && !"NG".equalsIgnoreCase(checkret)) {
			String lx = ret.substring(0, 3);
			return renderResult(Global.FALSE, text(ErrorMsg.getErrorMsg(checkret, lx)));
		}

		MesOrderSn query = new MesOrderSn();
		query.setSn(sn);
		List<MesOrderSn> list = mesOrderSnService.findList(query);
		if(!list.isEmpty()){
			return renderResult(Global.FALSE, text("该工件已和生产订单绑定！"));
		}

		// 校验已绑定数量是否已达订单生产数量，相同则不允许再绑定
		MesProductOrder orderQuery = new MesProductOrder();
		orderQuery.setSn(mesOrderSn.getOrderId());
		List<MesProductOrder> orderList = mesProductOrderService.findList(orderQuery);
		if (orderList == null || orderList.isEmpty() || ObjectUtils.isEmpty(orderList.get(0))) {
			return renderResult(Global.FALSE, text("生产订单不存在！"));
		}
		Integer orderNums = orderList.get(0).getNums();
		if (orderNums == null) {
			return renderResult(Global.FALSE, text("生产订单数量未配置！"));
		}
		MesOrderSn boundQuery = new MesOrderSn();
		boundQuery.setOrderId(mesOrderSn.getOrderId());
		long boundCount = mesOrderSnService.findCount(boundQuery);
		if (boundCount >= orderNums) {
			return renderResult(Global.FALSE, text("该订单已绑定数量已达生产数量，不允许再绑定！"));
		}

		try {
			mesOrderSnService.save(mesOrderSn);
			// 绑定成功后，将 OP100 工位结果提交为 OK
			List<ParamsResp> params = new ArrayList<>();
			List<BindMaterialResp> bmlists = mesLineProcessMaterialService.getBindMaterial("OP100A", lineSn);
			mesProductRecordService.updateRecordResult(sn, "OP100A", "100000", mesOrderSn.getOrderId(), "OK",
					userCode, params, lineSn, true, bmlists, null);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return renderResult(Global.FALSE, text(StringUtils.isNotEmpty(e.getMessage()) ? e.getMessage() : "操作失败！"));
		}
		return renderResult(Global.TRUE, text("保存成功！"));
	}

	/**
	 * 根据工件码判断是否已在生产订单工件表中存在
	 * @param sn 工件码
	 * @return result=true 表示已存在，false 表示不存在
	 */
	@RequestMapping(value = "existBySn")
	@ResponseBody
	public String existBySn(String sn) {
		if (StringUtils.isBlank(sn)) {
			return renderResult(Global.FALSE, text("工件码不能为空！"));
		}
		MesOrderSn query = new MesOrderSn();
		query.setSn(sn);
		if (mesOrderSnService.findCount(query) > 0) {
			return renderResult(Global.TRUE, text("该工件码已存在！"));
		}
		return renderResult(Global.FALSE, text("该工件码不存在！"));
	}

	/**
	 * 生产订单列表
	 * @param mesProductOrder
	 * @return
	 */
	@RequestMapping(value = "orderList")
	@ResponseBody
	public CommonResp<List<Map<String, Object>>> orderList(MesProductOrder mesProductOrder) {
		CommonResp<List<Map<String, Object>>> resp = new CommonResp<>();
		//展示所有未结束的订单（产线编号以 B0110 开头）
		mesProductOrder.setState("1");//0=草稿 1=下发 2=完成
		mesProductOrder.getSqlMap().getWhere().and("a.line_sn", QueryType.RIGHT_LIKE, "B0110");
		List<MesProductOrder> list = mesProductOrderService.findList(mesProductOrder);
		List<Map<String, Object>> data = new ArrayList<>();
		for (MesProductOrder order : list) {
			Map<String, Object> item = new HashMap<>();
			item.put("orderId", order.getSn());
			MesOrderSn query = new MesOrderSn();
			query.setOrderId(order.getSn());
			item.put("qty", mesOrderSnService.findCount(query));
			data.add(item);
		}
		resp.setData(data);
		resp.setResult(Global.TRUE);
		resp.setMessage("操作成功！");
		return resp;
	}

}