后端修改

src/main/java/com/steerinfo/baseinfo/meterbasecar/controller/MeterBaseCarController.java

@@ -233,7 +233,8 @@ public class MeterBaseCarController extends BaseRESTfulController {
                 for (MeterBaseDriver driver : driverList) {
                     // 检查司机是否存在
                     HashMap query = new HashMap();
-                    query.put("carNo", params.get("carNo").toString());
+                    query.put("carId", params.get("carNo").toString());
+                    query.put("driverName", driver.getDriverName());
                     query.put("telNum", driver.getTelNum());
                     query.put("validFlag", "0");
 
@@ -247,8 +248,9 @@ public class MeterBaseCarController extends BaseRESTfulController {
 //                        driver.setId(sdf.format(new Date()) + no);
                         driver.setId(params.get("carNo").toString() + driver.getTelNum());
                         driver.setCarId(params.get("carNo").toString());
+                        driver.setDriverName(driver.getDriverName());
+                        driver.setTelNum(driver.getTelNum());
                         driver.setValidFlag("0");
-
                         driver.setCreateManNo("admin");
                         driver.setCreateManName("admins");
                         driver.setCreateTime(new Date());

src/main/java/com/steerinfo/meterwork/meterworkcaractual/controller/MeterWorkCarActualController.java

@@ -469,6 +469,22 @@ throw new MarkerMetException(500, "操作异常！！");
         return rm;
     }
 
+    @ApiOperation(value = "特殊委托解除洁净", notes = "将洁净后的数据进行还原")
+    @PostMapping(value = "/specialRemove")
+    public RESTfulResult specialRemove(@RequestBody HashMap params) {
+        RESTfulResult rm = failed();
+        try {
+            rm = meterWorkCarActualService.specialRemove(params);
+        } catch (MarkerMetException e) {
+            e.printStackTrace();
+            rm.setMessage(e.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！");
+        }
+        return rm;
+    }
+
     @ApiOperation(value = "查询计量票据录入数据")
     @PostMapping(value = "/selectManualData")
     @Transactional(rollbackFor = Exception.class)

src/main/java/com/steerinfo/meterwork/meterworkcaractual/service/IMeterWorkCarActualService.java

@@ -7,7 +7,9 @@ import com.steerinfo.meterwork.meterworkcaractual.model.MeterWorkCarActual;
 import com.steerinfo.meterwork.meterworkcaractualfirst.model.MeterWorkCarActualFirst;
 import com.steerinfo.util.CommonPage;
 import io.micrometer.core.instrument.Meter;
+import org.apache.shiro.crypto.hash.Hash;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -55,6 +57,8 @@ public interface IMeterWorkCarActualService extends IBaseService<MeterWorkCarAct
 
     int remove(List<MeterWorkCarActual> models);
 
+    RESTfulResult specialRemove(HashMap map);
+
     MeterWorkCarActual termclean(String actualFirstNo, String dataNo);
 
     RESTfulResult doQueryWf(CommonPage<MeterWorkCarActual> oci);

src/main/java/com/steerinfo/meterwork/meterworkcaractual/service/impl/MeterWorkCarActualServiceImpl.java

@@ -21,7 +21,6 @@ import com.steerinfo.meterwork.meterworkcaractualfirst.mapper.MeterWorkCarActual
 import com.steerinfo.meterwork.meterworkcaractualfirst.model.MeterWorkCarActualFirst;
 import com.steerinfo.meterwork.meterworkcaractualfirst.service.IMeterWorkCarActualFirstService;
 import com.steerinfo.meterwork.meterworkprelink.mapper.MeterWorkPreLinkMapper;
-import com.steerinfo.meterwork.meterworkprelink.model.MeterWorkPreLink;
 import com.steerinfo.meterwork.meterworkprelink.service.IMeterWorkPreLinkService;
 import com.steerinfo.meterwork.meterworkrailwayactual.mapper.MeterWorkRailwayActualMapper;
 import com.steerinfo.meterwork.meterworkrailwayactual.model.MeterWorkRailwayActual;
@@ -484,6 +483,135 @@ public class MeterWorkCarActualServiceImpl extends BaseServiceImpl<MeterWorkCarA
         }
     }
 
+    @Override
+    public RESTfulResult specialRemove(HashMap params) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+        rm.setData(null);
+        rm.setCode("500");
+        String type = params.get("type") == null ? "" : params.get("type").toString();
+        MeterWorkCarActual actualModel01 = meterWorkCarActualMapper.selectByPrimaryKey(params.get("actualNo01").toString());
+        MeterWorkCarActual actualModel02 = meterWorkCarActualMapper.selectByPrimaryKey(params.get("actualNo02").toString());
+        List<MeterWorkCarActual> models = new ArrayList<MeterWorkCarActual>();
+        models.add(actualModel01);
+        models.add(actualModel02);
+
+        if(models == null || models.size() == 0) {
+            rm.setMessage("参数为空，请确认！！！");
+            return rm;
+        }
+
+        //models必须是2个，而且他们的预报组合号一致
+        if(models.size() != 2 && models.get(0).getPredictionCombination().equals(models.get(1).getPredictionCombination())){
+            rm.setMessage("必须选择两个预报组合号一致的洁净数据!!!");
+            return rm;
+        }
+
+        switch(type){
+            case "5": {
+                //类型为双委托类型
+                for (MeterWorkCarActual model: models) {
+                    if(!model.getPredictionType().equals("5")) {
+                           rm.setMessage("选中的计量数据当中有一条或多条不是双委托洁净数据，请确认！！");
+                           return rm;
+                    }
+                }
+                for (MeterWorkCarActual model: models) {
+                    //循环每一个洁净记录
+                    //判断委托是否为双委托组合的第二个委托，是：删除一次数据和洁净记录、否：修改一次记录、
+                    String combination = model.getPredictionCombination();
+                    String[] param = combination.split(",");
+
+                    if(model.getPredictionNo().equals(param[1])){
+                        // 改委托
+                        if (StringUtils.isNotEmpty(model.getPredictionNo())) {
+                            PreTrackScale scale = preTrackScaleMapper.selectByPrimaryKey(model.getPredictionNo());
+                            scale.setValueFlag("1");
+                            scale.setUploadFlag("1");
+                            scale.setUpdateTime(new Date());
+                            scale.setUpdateManNo("system");
+                            scale.setUpdateManName("双委托解除操作");
+                            preTrackScaleMapper.updateByPrimaryKeySelective(scale);
+                        }
+                        // 删一次
+                        MeterWorkCarActualFirst firstGross = meterWorkCarActualFirstMapper.selectByPrimaryKey(model.getActualFirst1No());
+                        MeterWorkCarActualFirst firstTare = meterWorkCarActualFirstMapper.selectByPrimaryKey(model.getActualFirst2No());
+                        boolean flag = firstGross.getPredictionNo().equals(model.getPredictionNo());
+                        if(flag){
+                            meterWorkCarActualFirstMapper.deleteByPrimaryKey(model.getActualFirst1No());
+                        }
+                        if(firstTare.getPredictionNo().equals(model.getPredictionNo())){
+                            meterWorkCarActualFirstMapper.deleteByPrimaryKey(model.getActualFirst2No());
+                        }
+
+                        // 删洁净
+                        meterWorkCarActualMapper.deleteByPrimaryKey(model.getActualNo());
+                    }
+                    else {
+                        // 清空毛重数据中的委托信息
+                        MeterWorkCarActualFirst mwcafg = meterWorkCarActualFirstMapper.selectAndRemove(model.getActualFirst1No());
+                        if (mwcafg == null) {
+                            rm.setMessage("未查询到相应的毛重数据！！");
+                            return rm;
+                        }
+                        mwcafg.setValueFlag(DbConstants.VALID);
+                        mwcafg.setNote(model.getNote());
+                        mwcafg.setUpdateManName("system");
+                        mwcafg.setUpdateManName("双委托解除更新");
+                        mwcafg.setUpdateTime(new Date());
+                        mwcafg.setIsPreScale("0");
+                        meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcafg);
+                        //皮重
+                        MeterWorkCarActualFirst mwcaft = meterWorkCarActualFirstMapper.selectAndRemove(model.getActualFirst2No());
+                        if (mwcaft == null) {
+                            rm.setMessage("未查询到相应的皮重数据！！");
+                            return rm;
+                        }
+                        mwcaft.setValueFlag(DbConstants.VALID);
+                        mwcaft.setUpdateManName("system");
+                        mwcaft.setUpdateManName("双委托解除更新");
+                        mwcaft.setNote(model.getNote());
+                        mwcaft.setUpdateTime(new Date());
+                        mwcaft.setIsPreScale("0");
+                        meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaft);
+                        //修改预报
+                        if (StringUtils.isNotEmpty(model.getPredictionNo())) {
+                            PreTrackScale scale = preTrackScaleMapper.selectByPrimaryKey(model.getPredictionNo());
+                            scale.setValueFlag("1");
+                            scale.setUploadFlag("1");
+                            scale.setUpdateTime(new Date());
+                            scale.setUpdateManNo("system");
+                            scale.setUpdateManName("双委托解除操作");
+                            preTrackScaleMapper.updateByPrimaryKeySelective(scale);
+                        }
+                        meterWorkCarActualMapper.deleteByPrimaryKey(model.getActualNo());
+                    }
+                }
+                rm.setSucceed();
+                rm.setMessage("操作成功！！");
+                rm.setCode("200");
+            }
+            break;
+            case "6": {         //类型为混卸类型
+                for (MeterWorkCarActual model: models) {
+                    if(!model.getPredictionType().equals("6")) {
+                        rm.setMessage("选中的计量数据当中有一条或多条不是混卸委托洁净数据，请确认！！");
+                    }
+                }
+            }
+            break;
+            case "7": {         //类型为混卸类型
+                for (MeterWorkCarActual model: models) {
+                    if(!model.getPredictionType().equals("6")) {
+                        rm.setMessage("选中的计量数据当中有一条或多条不是混装委托洁净数据，请确认！！");
+                    }
+                }
+            }
+            break;
+        }
+        return rm;
+    }
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public int manualInput (MeterWorkCarActual model) {
@@ -605,6 +733,7 @@ public class MeterWorkCarActualServiceImpl extends BaseServiceImpl<MeterWorkCarA
         grossrow.setUpdateTime(new Date());
         grossrow.setUpdateManName(userName + ": 洁净数据解除委托操作");
         grossrow.setUpdateManNo(userId);
+        grossrow.setIsPreScale("0");
         meterWorkCarActualFirstMapper.updateByPrimaryKey(grossrow);
 
         // 皮重

src/main/java/com/steerinfo/meterwork/meterworkcaractualfirst/controller/MeterWorkCarActualFirstController.java

@@ -913,17 +913,15 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
     //@RequiresPermissions("meterworkcaractual:view")
     @PostMapping(value = "/doubleEntrustmentMatch")
     public RESTfulResult doubleEntrustmentMatch(@RequestBody HashMap parmas) {
+        RESTfulResult rm = failed();
         try {
             String actualNo1 = parmas.get("actualNo1").toString();
             String actualNo2 = parmas.get("actualNo2").toString();
             String predictionNo1 = parmas.get("predictionNo1").toString();
             String predictionNo2 = parmas.get("predictionNo2").toString();
 
-            String msg = meterWorkCarActualFirstService.doubleEntrustmentMatch(actualNo1, actualNo2,predictionNo1,predictionNo2);
-            if (msg != "" || !msg.equals("")){
-                return failed(null,msg);
-            }
-            return success();
+            rm = meterWorkCarActualFirstService.doubleEntrustmentMatch(actualNo1, actualNo2,predictionNo1,predictionNo2);
+            return rm;
         } catch (Exception ex) {
             ex.printStackTrace();
             throw new MarkerMetException(500, "操作异常！！");

src/main/java/com/steerinfo/meterwork/meterworkcaractualfirst/service/IMeterWorkCarActualFirstService.java

@@ -117,7 +117,7 @@ public interface IMeterWorkCarActualFirstService extends IBaseService<MeterWorkC
 
     String mixedDischarge(String actualNo1, String actualNo2,String actualNo3, String predictionNo1,String predictionNo2);
 
-    String doubleEntrustmentMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2);
+    RESTfulResult doubleEntrustmentMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2);
 
     RESTfulResult addEmergency(List<MeterWorkCarActualFirst> meterWorkCarActualFirsts)  throws Exception;
 }

src/main/java/com/steerinfo/meterwork/meterworkcaractualfirst/service/impl/MeterWorkCarActualFirstServiceImpl.java

@@ -2845,6 +2845,10 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             scale.setUpdateManNo("system");
             scale.setUpdateManName("二次计量洁净更新");
             scale.setUploadFlag("1");
+            scale.setValueFlag("2");
+            //预报类型：双委托（5）、预报组合：A预报，B预报
+            scale.setPredictionType("7");
+            scale.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             preTrackScaleMapper.updateByPrimaryKeySelective(scale);
 
             PreTrackScale scale1 = new PreTrackScale();
@@ -2854,6 +2858,9 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             scale1.setUpdateManNo("system");
             scale1.setUpdateManName("二次计量洁净更新");
             scale1.setUploadFlag("1");
+            scale1.setValueFlag("2");
+            scale1.setPredictionType("7");
+            scale1.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             preTrackScaleMapper.updateByPrimaryKeySelective(scale1);
 
             //更新一次数据
@@ -2863,6 +2870,8 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf1.setUpdateManName("二次计量洁净更新");
             mwcaf1.setUpdateTime(new Date());
             mwcaf1.setIsPreScale("1");
+            mwcaf1.setPredictionType("7");
+            mwcaf1.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf1);
             //更新第一次皮重数据
             mwcaf2.setValueFlag(DbConstants.NET);
@@ -2870,6 +2879,8 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf2.setUpdateManName("二次计量洁净更新");
             mwcaf2.setUpdateTime(new Date());
             mwcaf2.setIsPreScale("1");
+            mwcaf2.setPredictionType("7");
+            mwcaf2.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf2);
             //添加第二次毛重数据
             SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
@@ -2881,6 +2892,8 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf3.setUpdateManName("二次计量洁净更新");
             mwcaf3.setUpdateTime(new Date());
             mwcaf3.setIsPreScale("1");
+            mwcaf3.setPredictionType("7");
+            mwcaf3.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.insertSelective(mwcaf3);
             //更新第二次皮重数据
             mwcaf4.setValueFlag(DbConstants.NET);
@@ -2888,6 +2901,8 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf4.setUpdateManName("二次计量洁净更新");
             mwcaf4.setUpdateTime(new Date());
             mwcaf4.setIsPreScale("1");
+            mwcaf4.setPredictionType("7");
+            mwcaf4.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf4);
 
             //添加结净数据
@@ -2901,6 +2916,9 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             actualRow1.setValueFlag("2");
             actualRow1.setCreateManName("洁净");
             actualRow1.setCreateTime(new Date());
+            actualRow1.setPredictionNo("7");
+            actualRow1.setPredictionCombination(predictionNo1 + "," + predictionNo2);
+            actualRow1.setPredictionNo(predictionNo1);
             actualRow1.setNetWeight(mwcaf1.getMeterWeight().subtract(mwcaf2.getMeterWeight()));
             meterWorkCarActualMapper.insertSelective(actualRow1);
 
@@ -2914,6 +2932,9 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             actualRow2.setValueFlag("2");
             actualRow2.setCreateManName("洁净");
             actualRow2.setCreateTime(new Date());
+            actualRow2.setPredictionNo("7");
+            actualRow2.setPredictionCombination(predictionNo1 + "," + predictionNo2);
+            actualRow2.setPredictionNo(predictionNo2);
             actualRow2.setNetWeight(mwcaf3.getMeterWeight().subtract(mwcaf4.getMeterWeight()));
             meterWorkCarActualMapper.insertSelective(actualRow2);
         }
@@ -2925,7 +2946,10 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
     }
 
     @Override
-    public String doubleEntrustmentMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2) {
+    public RESTfulResult doubleEntrustmentMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+
         try{
             //查询出一次计量数据
             MeterWorkCarActualFirst mwcaf01 = meterWorkCarActualFirstMapper.selectByPrimaryKey(actualNo1);
@@ -2943,33 +2967,44 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
 
             BigDecimal num01 = mwcaf01.getMeterWeight().subtract(mwcaf03.getMeterWeight()).abs();
             if(mwcaf01 == null || mwcaf03 == null ){
-                return "一次计量数据为空,请确认！!";
+                rm.setMessage("一次计量数据为空,请确认！!");
+                return rm;
             }
             //判断毛重必须大于皮重
             if(num01.compareTo(BigDecimal.valueOf(0)) == -1){
-                return "第一个一次计量重量一定要大于第二条一次计量重量！!";
+                rm.setMessage("第一个一次计量重量一定要大于第二条一次计量重量！!");
+                return rm;
             }
             if(pts01 == null || pts02 == null){
-                return "委托信息为空,请确认！！";
+                rm.setMessage("委托信息为空,请确认！！");
+                return rm;
+            }
+            if(!pts01.getPredictionType().equals("5") || !pts02.getPredictionType().equals("5")){
+                rm.setMessage("委托信息不是双委托，请确认");
+                return rm;
             }
             if(!mwcaf01.getCarNo().equals(mwcaf03.getCarNo())){
-                return "车号不一致,不能匹配洁净！！";
+                rm.setMessage("车号不一致,不能匹配洁净！！");
+                return rm;
             }
             //洁净数据不能小于400
             if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
-                return "选择的两条一次计量数据不能小于400！！";
+                rm.setMessage("选择的两条一次计量数据不能小于400！！");
+                return rm;
             }
             if(pts01.getValueFlag().equals("2") || pts02.getValueFlag().equals("2")){
-                return "委托信息已使用！！";
+                rm.setMessage("委托信息已使用！！");
+                return rm;
             }
 
             if(pts01.getValueFlag().equals("3") || pts02.getValueFlag().equals("3")){
-                return "委托信息已作废！！";
+                rm.setMessage("委托信息已作废！！");
+                return rm;
             }
             if(mwcaf01.getValueFlag().equals("2") || mwcaf03.getValueFlag().equals("2")){
-                return "一次计量数据已洁净！！";
+                rm.setMessage("一次计量数据已洁净！！");
+                return rm;
             }
-
             //将委托中的编号和收发货的等数据拷贝进一次数据中
             MeterWorkCarActualFirst first1 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo1, predictionNo1);
             BeanUtils.copyProperties(first1,mwcaf01);
@@ -2980,20 +3015,16 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             MeterWorkCarActualFirst first4 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo2, predictionNo2);
             BeanUtils.copyProperties(first4, mwcaf04);
 
-            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
-            MeterWorkCarActual mwca1 = meterWorkCarActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo1);
-            BeanUtils.copyProperties(mwca1, actualRow1);
-            MeterWorkCarActual mwca2 = meterWorkCarActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo2);
-            BeanUtils.copyProperties(mwca2,actualRow2);
-
             //更新预报数据
             PreTrackScale scale = new PreTrackScale();
             scale.setPredictionNo(predictionNo1);
             scale.setValueFlag(DbConstants.NET);
             scale.setUpdateTime(new Date());
             scale.setUpdateManNo("system");
-            scale.setUpdateManName("二次计量洁净更新");
+            scale.setUpdateManName("双委托洁净更新");
             scale.setUploadFlag("1");
+            scale.setPredictionType("5");
+            scale.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             preTrackScaleMapper.updateByPrimaryKeySelective(scale);
 
             PreTrackScale scale1 = new PreTrackScale();
@@ -3001,24 +3032,32 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             scale1.setValueFlag(DbConstants.NET);
             scale1.setUpdateTime(new Date());
             scale1.setUpdateManNo("system");
-            scale1.setUpdateManName("二次计量洁净更新");
+            scale1.setUpdateManName("双委托洁净更新");
             scale1.setUploadFlag("1");
+            scale1.setPredictionType("5");
+            scale1.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             preTrackScaleMapper.updateByPrimaryKeySelective(scale1);
 
             //更新一次数据
             //更新第一次毛重数据库
             mwcaf01.setValueFlag(DbConstants.NET);
             mwcaf01.setUpdateManName("system");
-            mwcaf01.setUpdateManName("二次计量洁净更新");
+            mwcaf01.setUpdateManName("双委托洁净更新");
             mwcaf01.setUpdateTime(new Date());
             mwcaf01.setIsPreScale("1");
+            mwcaf01.setPredictionNo(predictionNo1);
+            mwcaf01.setPredictionType("5");
+            mwcaf01.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf01);
             //更新第一次皮重数据库
             mwcaf02.setValueFlag(DbConstants.NET);
             mwcaf02.setUpdateManName("system");
-            mwcaf02.setUpdateManName("二次计量洁净更新");
+            mwcaf02.setUpdateManName("双委托洁净更新");
             mwcaf02.setUpdateTime(new Date());
             mwcaf02.setIsPreScale("1");
+            mwcaf02.setPredictionNo(predictionNo1);
+            mwcaf02.setPredictionType("5");
+            mwcaf02.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf02);
             //添加第一次毛重数据库
             SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
@@ -3027,9 +3066,12 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf03.setActualFirstNo(actualFirstNo);
             mwcaf03.setValueFlag(DbConstants.NET);
             mwcaf03.setUpdateManName("system");
-            mwcaf03.setUpdateManName("二次计量洁净更新");
+            mwcaf03.setUpdateManName("双委托洁净更新");
             mwcaf03.setUpdateTime(new Date());
             mwcaf03.setIsPreScale("1");
+            mwcaf03.setPredictionNo(predictionNo2);
+            mwcaf03.setPredictionType("5");
+            mwcaf03.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.insertSelective(mwcaf03);
             //添加第二次皮重数据库
             SimpleDateFormat sdf01 = new SimpleDateFormat("yyyyMMdd");
@@ -3038,11 +3080,20 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             mwcaf04.setActualFirstNo(actualSecondNo);
             mwcaf04.setValueFlag(DbConstants.NET);
             mwcaf04.setUpdateManName("system");
-            mwcaf04.setUpdateManName("二次计量洁净更新");
+            mwcaf04.setUpdateManName("双委托洁净更新");
             mwcaf04.setUpdateTime(new Date());
             mwcaf04.setIsPreScale("1");
+            mwcaf04.setPredictionNo(predictionNo2);
+            mwcaf04.setPredictionType("5");
+            mwcaf04.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             meterWorkCarActualFirstMapper.insertSelective(mwcaf04);
 
+            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+            MeterWorkCarActual mwca1 = meterWorkCarActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo1);
+            BeanUtils.copyProperties(mwca1, actualRow1);
+            MeterWorkCarActual mwca2 = meterWorkCarActualMapper.manualAddPre(actualFirstNo, actualSecondNo, predictionNo2);
+            BeanUtils.copyProperties(mwca2,actualRow2);
+
             //添加结净数据
             String no = meterWorkCarActualMapper.getNewID(sdf.format(new Date()));
             actualRow1.setActualNo(sdf.format(new Date()) + no);
@@ -3051,6 +3102,10 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             actualRow1.setNote("双委托匹配洁净");
             actualRow1.setUploadFlag("1");
             actualRow1.setIsPreScale("1");
+            actualRow1.setValueFlag("1");
+            actualRow1.setPredictionNo(predictionNo1);
+            actualRow1.setPredictionType("5");
+            actualRow1.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             actualRow1.setNetWeight(mwcaf01.getMeterWeight().subtract(mwcaf02.getMeterWeight()));
             meterWorkCarActualMapper.insertSelective(actualRow1);
 
@@ -3061,13 +3116,22 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             actualRow2.setNote("双委托匹配洁净");
             actualRow2.setUploadFlag("1");
             actualRow2.setIsPreScale("1");
+            actualRow2.setValueFlag("1");
+            actualRow2.setPredictionNo(predictionNo2);
+            actualRow2.setPredictionType("5");
+            actualRow2.setPredictionCombination(predictionNo1 + "," + predictionNo2);
             actualRow2.setNetWeight(mwcaf03.getMeterWeight().subtract(mwcaf04.getMeterWeight()));
             meterWorkCarActualMapper.insertSelective(actualRow2);
+
+            rm.setSucceed();
+            rm.setMessage("操作成功!!");
+            rm.setCode("200");
+            return rm;
         }catch(Exception e){
             e.printStackTrace();
-            return "操作异常，请确认";
+            rm.setMessage("操作异常，请确认");
+            return rm;
         }
-        return "";
     }
 
     @Override