计划管理模块(第三级拆分数量问题解决)、工单管理(工单修改功能完成)

op-modules/op-plan/src/main/java/com/op/plan/controller/ProOrderWorkorderController.java

@@ -2,6 +2,8 @@ package com.op.plan.controller;
 
 import java.util.List;
 import javax.servlet.http.HttpServletResponse;
+
+import com.op.plan.domain.dto.SplitOrderDTO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -33,6 +35,50 @@ public class ProOrderWorkorderController extends BaseController {
 	@Autowired
 	private IProOrderWorkorderService proOrderWorkorderService;
 
+	/**
+	 * 校验工单是否可以修改
+	 * 如果工单已生成湿料计划则不允许修改
+	 *
+	 * @return
+	 */
+	@GetMapping("/checkWorkOrder/{id}")
+	public AjaxResult checkWorkOrder(@PathVariable("id") String id){
+		return proOrderWorkorderService.checkWorkOrder(id);
+	}
+
+	/**
+	 * 提交修改工单接口
+	 *
+	 * @param splitOrderDTO
+	 * @return
+	 */
+	@PostMapping("/subChangeWorkOrder")
+	public AjaxResult subChangeWorkOrder(@RequestBody SplitOrderDTO splitOrderDTO){
+		return proOrderWorkorderService.subChangeWorkOrder(splitOrderDTO);
+	}
+
+	/**
+	 * 通过子工单获取批次信息list（父工单批次信息）
+	 *
+	 * @param proOrderWorkorder
+	 * @return
+	 */
+	@PostMapping("/getWorkBatchList")
+	public AjaxResult getWorkBatchList(@RequestBody ProOrderWorkorder proOrderWorkorder){
+		return proOrderWorkorderService.getWorkBatchList(proOrderWorkorder);
+	}
+
+	/**
+	 * 通过子工单信息查询订单信息和工单信息
+	 *
+	 * @param proOrderWorkorder
+	 * @return
+	 */
+	@PostMapping("/getOrderAndWorkInfo")
+	public AjaxResult getOrderAndWorkInfo(@RequestBody ProOrderWorkorder proOrderWorkorder){
+		return proOrderWorkorderService.getOrderAndWorkInfo(proOrderWorkorder);
+	}
+
 	/**
 	 * 查询生产工单列表
 	 */

op-modules/op-plan/src/main/java/com/op/plan/domain/dto/SplitOrderDTO.java

@@ -1,6 +1,7 @@
 package com.op.plan.domain.dto;
 
 import com.op.plan.domain.Batch;
+import com.op.plan.domain.ProOrderWorkorder;
 
 import java.util.Date;
 import java.util.List;
@@ -22,17 +23,14 @@ public class SplitOrderDTO {
     // 工艺编码
     private String routeCode;
 
-    @Override
+    private ProOrderWorkorder proOrderWorkorder;
-    public String toString() {
+
-        return "SplitOrderDTO{" +
+    public ProOrderWorkorder getProOrderWorkorder() {
-                "formFields=" + formFields +
+        return proOrderWorkorder;
-                ", prodLineCode='" + prodLineCode + '\'' +
+    }
-                ", productDate=" + productDate +
+
-                ", shiftId='" + shiftId + '\'' +
+    public void setProOrderWorkorder(ProOrderWorkorder proOrderWorkorder) {
-                ", splitNum=" + splitNum +
+        this.proOrderWorkorder = proOrderWorkorder;
-                ", product=" + product +
-                ", routeCode='" + routeCode + '\'' +
-                '}';
     }
 
     public String getRouteCode() {

op-modules/op-plan/src/main/java/com/op/plan/mapper/ProOrderWorkorderBatchMapper.java

@@ -1,5 +1,6 @@
 package com.op.plan.mapper;
 
+import com.op.plan.domain.Batch;
 import com.op.plan.domain.ProOrderWorkorderBatch;
 import org.apache.ibatis.annotations.Mapper;
 
@@ -61,4 +62,19 @@ public interface ProOrderWorkorderBatchMapper {
      */
     public int deleteProOrderWorkorderBatchByWorkorderIds(String[] workorderIds);
 
+    /**
+     * 通过父工单id查询批次信息list
+     *
+     * @param workorderId
+     * @return
+     */
+    List<Batch> selectWorkOrderBatchList(String workorderId);
+
+    /**
+     * 查询除了该工单s下的所有批次号
+     * @param workorderIds
+     * @return
+     */
+    List<String> selectCodeByWorkOrderIds(String[] workorderIds);
+
 }

op-modules/op-plan/src/main/java/com/op/plan/mapper/ProWetMaterialPlanDetailMapper.java

@@ -2,6 +2,7 @@ package com.op.plan.mapper;
 
 
 import com.op.plan.domain.ProWetMaterialPlanDetail;
+import org.apache.ibatis.annotations.Mapper;
 
 import java.util.List;
 
@@ -11,6 +12,7 @@ import java.util.List;
  * @author Open Platform
  * @date 2023-07-27
  */
+@Mapper
 public interface ProWetMaterialPlanDetailMapper {
     /**
      * 查询配料计划明细
@@ -67,4 +69,11 @@ public interface ProWetMaterialPlanDetailMapper {
      * @return
      */
     List<ProWetMaterialPlanDetail> selectProWetMaterialPlanDetailListById(String id);
+
+    /**
+     * 通过工单id查询湿料计划详情
+     * @param id
+     * @return
+     */
+    ProWetMaterialPlanDetail selectProWetMaterialPlanDetailByWorkId(String id);
 }

op-modules/op-plan/src/main/java/com/op/plan/service/IProOrderWorkorderService.java

@@ -1,7 +1,9 @@
 package com.op.plan.service;
 
 
+import com.op.common.core.web.domain.AjaxResult;
 import com.op.plan.domain.ProOrderWorkorder;
+import com.op.plan.domain.dto.SplitOrderDTO;
 
 import java.util.List;
 
@@ -62,8 +64,41 @@ public interface IProOrderWorkorderService {
 
     /**
      * 下发生产工单
+     *
      * @param workorderIds
      * @return
      */
     public int downProOrderWorkorderByWorkorderIds(String[] workorderIds);
+
+    /**
+     * 通过工单信息查询订单信息和工单信息
+     *
+     * @param proOrderWorkorder
+     * @return
+     */
+    AjaxResult getOrderAndWorkInfo(ProOrderWorkorder proOrderWorkorder);
+
+    /**
+     * 通过子工单获取批次信息list（父工单批次信息）
+     *
+     * @param proOrderWorkorder
+     * @return
+     */
+    AjaxResult getWorkBatchList(ProOrderWorkorder proOrderWorkorder);
+
+    /**
+     * 提交修改工单接口
+     *
+     * @param splitOrderDTO
+     * @return
+     */
+    AjaxResult subChangeWorkOrder(SplitOrderDTO splitOrderDTO);
+
+    /**
+     * 校验工单是否可以修改
+     * 如果工单已生成湿料计划则不允许修改
+     *
+     * @return
+     */
+    AjaxResult checkWorkOrder(String id);
 }

op-modules/op-plan/src/main/java/com/op/plan/service/impl/ProOrderServiceImpl.java

@@ -88,6 +88,12 @@ public class ProOrderServiceImpl implements IProOrderService {
             // 父工单code
             StringBuilder parentOrder = new StringBuilder("0");
             boolean run = true;
+
+            // 设置换算基数，用于获得换算值
+            Long quantity = proOrder.getQuantity();
+
+            // 获取单位换算值
+            Long conver = 1L;
             while (run) {
                 // 先进行当前订单拆分操作
                 // 1.设置工单信息，并更新订单信息至数据库
@@ -99,11 +105,13 @@ public class ProOrderServiceImpl implements IProOrderService {
                 // 将工单信息更新至数据库
                 proOrderWorkorderMapper.insertProOrderWorkorder(workOrder);
                 // 生成批次表信息并更新至数据库
-                setBatch(workBatch, splitOrderDTO.getFormFields(), workOrder.getWorkorderId());
+                setBatch(workBatch, splitOrderDTO.getFormFields(), workOrder.getWorkorderId(),conver);
 
                 // 如果存在子节点
                 if (proOrder.getChildren() != null) {
                     ProOrderDTO newProOrder = (ProOrderDTO) proOrder.getChildren().get(0);
+                    // 更新换算值
+                    conver = (newProOrder.getQuantity() / quantity);
                     // 将child信息重新赋值给proOrder
                     BeanUtils.copyProperties(newProOrder, proOrder);
                     // 存放父工单code
@@ -417,7 +425,7 @@ public class ProOrderServiceImpl implements IProOrderService {
      * @param batchList
      * @param workOrderId
      */
-    private void setBatch(ProOrderWorkorderBatch workBatch, List<Batch> batchList, String workOrderId) {
+    private void setBatch(ProOrderWorkorderBatch workBatch, List<Batch> batchList, String workOrderId,Long conver) {
         // 工单id
         workBatch.setWorkorderId(workOrderId);
 
@@ -428,23 +436,10 @@ public class ProOrderServiceImpl implements IProOrderService {
             // 获取批次号
             workBatch.setBatchCode(batch.getBatchCode());
             // 获取批次数量
-            workBatch.setBatchQuantity(batch.getBatchQuantity());
+            workBatch.setBatchQuantity(batch.getBatchQuantity()*conver);
             // 更新至数据库
             proOrderWorkorderBatchMapper.insertProOrderWorkorderBatch(workBatch);
         }
-
-//        // 产品类型
-//        for (int i = 0; i < batchList.size(); i++) {
-//            // 生成批次id
-//            workBatch.setBatchId(IdUtils.fastSimpleUUID());
-//            Batch batch = batchList.get(i);
-//            // 获取批次号
-//            workBatch.setBatchCode(batch.getBatchCode());
-//            // 获取批次数量
-//            workBatch.setBatchQuantity(batch.getBatchQuantity());
-//            // 更新至数据库
-//            proOrderWorkorderBatchMapper.insertProOrderWorkorderBatch(workBatch);
-//        }
     }
 
     /**

op-modules/op-plan/src/main/java/com/op/plan/service/impl/ProOrderWorkorderServiceImpl.java

@@ -3,13 +3,13 @@ package com.op.plan.service.impl;
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.op.common.core.context.SecurityContextHolder;
 import com.op.common.core.utils.DateUtils;
+import com.op.common.core.utils.bean.BeanUtils;
 import com.op.common.core.utils.uuid.IdUtils;
-import com.op.plan.domain.ProOrderWorkorder;
+import com.op.common.core.web.domain.AjaxResult;
-import com.op.plan.domain.ProWorkorderProcessDetail;
+import com.op.plan.domain.*;
-import com.op.plan.mapper.ProOrderMapper;
+import com.op.plan.domain.dto.ProOrderDTO;
-import com.op.plan.mapper.ProOrderWorkorderBatchMapper;
+import com.op.plan.domain.dto.SplitOrderDTO;
-import com.op.plan.mapper.ProOrderWorkorderMapper;
+import com.op.plan.mapper.*;
-import com.op.plan.mapper.ProWorkorderProcessDetailMapper;
 import com.op.plan.service.IProOrderWorkorderService;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -17,8 +17,10 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
+
+import static com.op.common.core.web.domain.AjaxResult.error;
+import static com.op.common.core.web.domain.AjaxResult.success;
 
 
 /**
@@ -37,6 +39,10 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
     private ProOrderMapper proOrderMapper;
     @Autowired
     private ProWorkorderProcessDetailMapper proWorkorderProcessDetailMapper;
+    @Autowired
+    private ProWetMaterialPlanDetailMapper proWetMaterialPlanDetailMapper;
+
+
     /**
      * 查询生产工单
      *
@@ -182,4 +188,289 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
         //下达工单
         return proOrderWorkorderMapper.downProOrderWorkorderByWorkorderIds(workorderIds);
     }
+
+    /**
+     * 通过工单信息查询订单信息和工单信息
+     *
+     * @param proOrderWorkorder
+     * @return
+     */
+    @Override
+    @DS("#header.poolName")
+    public AjaxResult getOrderAndWorkInfo(ProOrderWorkorder proOrderWorkorder) {
+        boolean run = true;
+        while (run) {
+            ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder());
+            // 如果存在父工单
+            if (fatherWorkOrder != null ){
+                BeanUtils.copyProperties(fatherWorkOrder,proOrderWorkorder);
+            }else {
+                run = false;
+            }
+        }
+        // 通过母订单id查询母订单详情
+        ProOrder proOrder = proOrderMapper.selectProOrderById(proOrderWorkorder.getOrderId());
+        // 递归查询子订单
+        recursiveQueryChildOrder(proOrder);
+        // 通过获取到的工单信息获取父工单
+        formatProOrderWorkorder(proOrderWorkorder);
+
+        Map orderAndWork = new HashMap();
+        orderAndWork.put("order",proOrder);
+        orderAndWork.put("workOrder",proOrderWorkorder);
+
+        return success(orderAndWork);
+    }
+
+    /**
+     * 通过子工单获取批次信息list（父工单批次信息）
+     *
+     * @param proOrderWorkorder
+     * @return
+     */
+    @Override
+    @DS("#header.poolName")
+    public AjaxResult getWorkBatchList(ProOrderWorkorder proOrderWorkorder) {
+        boolean run = true;
+        while (run){
+            ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder());
+            // 如果存在父工单
+            if (fatherWorkOrder != null){
+                BeanUtils.copyProperties(fatherWorkOrder,proOrderWorkorder);
+            }else {
+                run = false;
+            }
+        }
+        // 通过父工单id查询对应批次信息list
+        return success(proOrderWorkorderBatchMapper.selectWorkOrderBatchList(proOrderWorkorder.getWorkorderId()));
+    }
+
+    /**
+     * 提交修改工单接口
+     *
+     * @param splitOrderDTO
+     * @return
+     */
+    @Override
+    @DS("#header.poolName")
+    @Transactional
+    public AjaxResult subChangeWorkOrder(SplitOrderDTO splitOrderDTO) {
+
+        // 获得子工单对象——(这里没有用BeanUtils是因为若依与这个冲突造成死循环得到错误的结果)
+        ProOrderWorkorder proWorkOrder = splitOrderDTO.getProOrderWorkorder();
+        // 通过子工单获得所有工单信息,并将所有工单信息放入list中
+        List<ProOrderWorkorder> workOrderList = new ArrayList<>();
+        // 将获得的工单的id存放
+        List<String> ids = new ArrayList<>();
+        boolean getworkOrder = true;
+        // 将工单放入list
+        workOrderList.add(proWorkOrder);
+        // 将id放入
+        ids.add(proWorkOrder.getWorkorderId());
+
+        // 用于循环
+        ProOrderWorkorder childWorkOrder = new ProOrderWorkorder();
+        BeanUtils.copyProperties(proWorkOrder,childWorkOrder);
+
+        while (getworkOrder) {
+            // 通过parentOrder查询父工单信息
+            ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(childWorkOrder.getParentOrder());
+            if (fatherWorkOrder != null){
+                // 将重置对象
+                BeanUtils.copyProperties(fatherWorkOrder,childWorkOrder);
+                // 将工单放入list
+                workOrderList.add(fatherWorkOrder);
+                // 将id放入
+                ids.add(fatherWorkOrder.getWorkorderId());
+            }else {
+                // 终止循环
+                getworkOrder = false;
+            }
+        }
+
+        boolean checkout = true;
+
+        // 校验批次编号是否存在（重复问题）
+        String[] workorderIds = (String[]) ids.toArray(new String[ids.size()]);
+        List<String> batchCodes = proOrderWorkorderBatchMapper.selectCodeByWorkOrderIds(workorderIds);
+        for (int i = 0; i < batchCodes.size(); i++) {
+            for (int j = 0; j < splitOrderDTO.getFormFields().size(); j++) {
+                if (batchCodes.get(i).equals(splitOrderDTO.getFormFields().get(j).getBatchCode())) {
+                    checkout = false;
+                }
+            }
+        }
+
+//        for (ProOrderWorkorder proOrderWorkorder : workOrderList){
+//            System.out.println("这里是你的工单！！！！！"+proOrderWorkorder.getWorkorderCode());
+//            System.out.println("这里是工单拆分数量！！！！！！"+proOrderWorkorder.getQuantitySplit());
+//        }
+
+        if (checkout){
+            // 删除所有工单s下的批次信息
+            int i = proOrderWorkorderBatchMapper.deleteProOrderWorkorderBatchByWorkorderIds(workorderIds);
+            // 创建订单信息，并将信息copy进去
+            ProOrder proOrder = new ProOrder();
+            BeanUtils.copyProperties(splitOrderDTO.getProduct(),proOrder);
+            // 设置换算基数，用于获得换算值
+            Long quantity = proOrder.getQuantity();
+            // 创建批次表通用对象
+            ProOrderWorkorderBatch workBatch = setCommonBatchAttribute();
+            boolean run = true;
+            // 获取单位换算值
+            Long conver = 1L;
+            int index = workOrderList.size();
+            while (run) {
+                // 获得对应工单
+                ProOrderWorkorder proOrderWorkorder = workOrderList.get(--index);
+                // 更新订单
+                proOrder.setUpdateBy(SecurityContextHolder.getUserName());
+                proOrder.setUpdateTime(DateUtils.getNowDate());
+                proOrder.setQuantitySplit(proOrder.getQuantitySplit()+Long.valueOf(proOrder.getAtrr1()));
+                proOrderMapper.updateProOrder(proOrder);
+                // 设置工单信息
+                proOrderWorkorder.setUpdateBy(SecurityContextHolder.getUserName());
+                proOrderWorkorder.setUpdateTime(DateUtils.getNowDate());
+                // 拆分数量
+                proOrderWorkorder.setQuantitySplit(Long.valueOf(proOrder.getAtrr1()));
+                // 2.将工单信息更新至数据库
+                if (splitOrderDTO.getProdLineCode() != null){
+                    proOrderWorkorder.setProdLineCode(splitOrderDTO.getProdLineCode());
+                }
+                if (splitOrderDTO.getProductDate() != null){
+                    proOrderWorkorder.setProductDate(splitOrderDTO.getProductDate());
+                }
+                if (splitOrderDTO.getShiftId() != null){
+                    proOrderWorkorder.setShiftId(splitOrderDTO.getShiftId());
+                }
+                if (splitOrderDTO.getRouteCode() != null){
+                    proOrderWorkorder.setRouteCode(splitOrderDTO.getRouteCode());
+                }
+                proOrderWorkorderMapper.updateProOrderWorkorder(proOrderWorkorder);
+
+//                System.out.println("这里是workorderCode------------》"+proOrderWorkorder.getWorkorderCode());
+                // 生成对应批次表
+                workBatch.setWorkorderId(proOrderWorkorder.getWorkorderId());
+
+                // 生成批次表信息并更新至数据库
+                for (Batch batch : splitOrderDTO.getFormFields()) {
+                    // 生成批次id
+                    workBatch.setBatchId(IdUtils.fastSimpleUUID());
+                    // 生成批次号
+                    workBatch.setBatchCode(batch.getBatchCode());
+                    // 生成批次数量
+                    workBatch.setBatchQuantity(batch.getBatchQuantity()*conver);
+                    // 更新至数据库
+                    proOrderWorkorderBatchMapper.insertProOrderWorkorderBatch(workBatch);
+
+                    // 测试
+//                    System.out.println("这里是workorderId----------->"+workBatch.getWorkorderId());
+//                    System.out.println("这里是拆分数量----------->"+workBatch.getBatchQuantity());
+                }
+
+                // 如果存在子节点
+                if (proOrder.getChildren().size()>0){
+                    ProOrderDTO newProOrder = (ProOrderDTO) proOrder.getChildren().get(0);
+                    // 更新换算值
+                    conver = (newProOrder.getQuantity() / quantity);
+                    // 将child信息重新赋值给proOrder
+                    BeanUtils.copyProperties(newProOrder, proOrder);
+                } else {
+                    // 结束循环
+                    run = false;
+                }
+            }
+            return success();
+        }
+
+
+        return error(500, "批次号不能重复");
+    }
+
+    /**
+     * 校验工单是否可以修改
+     * 如果工单已生成湿料计划则不允许修改
+     *
+     * @return
+     */
+    @Override
+    @DS("#header.poolName")
+    public AjaxResult checkWorkOrder(String id) {
+        ProWetMaterialPlanDetail proWetMaterialPlanDetail = proWetMaterialPlanDetailMapper.selectProWetMaterialPlanDetailByWorkId(id);
+        if (proWetMaterialPlanDetail != null){
+            return error(500,"工单已有湿料计划！不可修改！");
+        }
+        return success();
+    }
+
+    /**
+     * 格式化工单信息（递归处理）
+     *
+     * @param proOrderWorkorder
+     */
+    private void formatProOrderWorkorder(ProOrderWorkorder proOrderWorkorder) {
+        // 通过班次id查询班次名称
+        String shiftDesc = proOrderMapper.selectShiftNameById(proOrderWorkorder.getShiftId());
+        // 通过设备code查询出机型名称
+        String prodLineName = proOrderMapper.selectProdLineName(proOrderWorkorder.getProdLineCode());
+        // 通过工单id查询批次号
+        List<String> batchCodeList = proOrderMapper.selectBatchCodesById(proOrderWorkorder.getWorkorderId());
+        List<StringBuilder> batchCodes = new ArrayList<>();
+        // 格式化数据
+        for (String batchCode : batchCodeList) {
+            batchCodes.add(new StringBuilder(batchCode).append(";").append("\n"));
+        }
+        // 将查询结果设置到当前工单对象
+        proOrderWorkorder.setShiftDesc(shiftDesc);
+        proOrderWorkorder.setProdLineCode(prodLineName);
+        proOrderWorkorder.setBatchCodeList(batchCodes);
+
+        // 通过母工单workorder_id查询子工单
+        List<ProOrderWorkorder> childWorkorders = proOrderWorkorderMapper.selectChildWorkOrder(proOrderWorkorder.getWorkorderCode());
+        if (!childWorkorders.isEmpty()) {
+            for (ProOrderWorkorder childWorkorder : childWorkorders) {
+                formatProOrderWorkorder(childWorkorder); // 递归处理子工单
+            }
+            proOrderWorkorder.setChildren(childWorkorders); // 设置子工单列表
+        }
+    }
+
+    /**
+     * 查询订单方法（递归）
+     *
+     * @param proOrder
+     */
+    private void recursiveQueryChildOrder(ProOrder proOrder) {
+        // 查询子订单列表
+        List<ProOrder> childOrders = proOrderMapper.selectChildProOrderByCode(proOrder.getOrderCode());
+        if (!childOrders.isEmpty()) {
+            // 递归处理子订单
+            for (ProOrder childOrder : childOrders) {
+                recursiveQueryChildOrder(childOrder);
+            }
+            // 将子订单列表设置到当前订单对象
+            proOrder.setChildren(childOrders);
+        }
+    }
+
+    /**
+     * 设置批次表通用
+     *
+     * @return
+     */
+    private ProOrderWorkorderBatch setCommonBatchAttribute() {
+        ProOrderWorkorderBatch workBatch = new ProOrderWorkorderBatch();
+        // 更新者
+        workBatch.setUpdateBy(SecurityContextHolder.getUserName());
+        // 创建更新时间
+        workBatch.setUpdateTime(DateUtils.getNowDate());
+        // 设置创建时间
+        workBatch.setCreateTime(DateUtils.getNowDate());
+        // 创建者
+        workBatch.setCreateBy(SecurityContextHolder.getUserName());
+        // 设置单据状态（1正常）
+        workBatch.setStatus("1");
+        return workBatch;
+    }
+
 }

op-modules/op-plan/src/main/resources/mapper/plan/ProOrderMapper.xml

@@ -188,7 +188,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 	<update id="updateProOrder" parameterType="ProOrder">
 		update pro_order
 		<trim prefix="SET" suffixOverrides=",">
-			<if test="planFactoryCode != null">plan_factoryCode = #{planFactoryCode},</if>
+			<if test="planFactoryCode != null">plan_factory_code = #{planFactoryCode},</if>
 			<if test="factoryCode != null">factory_code = #{factoryCode},</if>
 			<if test="orderType != null">order_type = #{orderType},</if>
 			<if test="orderCode != null">order_code = #{orderCode},</if>
@@ -214,6 +214,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 		</trim>
 		where id = #{id}
 	</update>
+
 	<update id="updateOrder">
 		update pro_order
 		<trim prefix="SET" suffixOverrides=",">

op-modules/op-plan/src/main/resources/mapper/plan/ProOrderWorkorderBatchMapper.xml

@@ -48,6 +48,22 @@
         where workorder_id = #{workorderId}
     </select>
 
+    <select id="selectWorkOrderBatchList" resultType="com.op.plan.domain.Batch">
+        select batch_code AS 'batchCode',batch_quantity AS 'batchQuantity'
+        from pro_order_workorder_batch
+        where workorder_id = #{workorderId}
+    </select>
+
+    <select id="selectCodeByWorkOrderIds" resultType="java.lang.String">
+        select batch_code
+        from pro_order_workorder_batch
+        where workorder_id not in
+        <foreach item="workorderId" collection="array" open="(" separator="," close=")">
+            #{workorderId}
+        </foreach>
+    </select>
+
+
     <insert id="insertProOrderWorkorderBatch" parameterType="ProOrderWorkorderBatch">
         insert into pro_order_workorder_batch
         <trim prefix="(" suffix=")" suffixOverrides=",">
@@ -120,4 +136,5 @@
             #{workorderId}
         </foreach>
     </delete>
+
 </mapper>

op-modules/op-plan/src/main/resources/mapper/plan/ProWetMaterialPlanDetailMapper.xml

@@ -71,6 +71,12 @@
         where p.wet_material_plan_id = #{id}
     </select>
 
+    <select id="selectProWetMaterialPlanDetailByWorkId"
+            resultType="com.op.plan.domain.ProWetMaterialPlanDetail">
+        <include refid="selectProWetMaterialPlanDetailVo"/>
+        where workorder_id = #{id}
+    </select>
+
     <insert id="insertProWetMaterialPlanDetail" parameterType="ProWetMaterialPlanDetail">
         insert into pro_wet_material_plan_detail
         <trim prefix="(" suffix=")" suffixOverrides=",">