修改了智能终端接口和车辆信息接口

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

@@ -349,6 +349,8 @@ public class MeterBaseCarController extends BaseRESTfulController {
             trave.put("travellingMerchantPossword",params.get("password"));
             List<MeterBaseTravellingMerchant> meterBaseTravellingMerchant = meterBaseTravellingMerchantMapper.selectByParameters(trave);
             if (meterBaseTravellingMerchant.size()>0){
+                MeterBaseTravellingMerchant mbtm = meterBaseTravellingMerchant.get(0);
+                ssodata = mbtm;
                 userType = "2";
             }
 

src/main/java/com/steerinfo/baseinfo/meterbasecar/mapper/MeterBaseCarMapper.xml

@@ -5,7 +5,7 @@
     <id column="PK_NO" jdbcType="VARCHAR" property="pkNo" />
     <result column="CAR_NO" jdbcType="VARCHAR" property="carNo" />
     <result column="MNEMONIC_CODE" jdbcType="VARCHAR" property="mnemonicCode" />
-    <result column="CUSTOMER_SUPPLIER_NO" jdbcType="VARCHAR" property="batchDeleteSelf" />
+    <result column="CUSTOMER_SUPPLIER_NO" jdbcType="VARCHAR" property="customerSupplierNo" />
     <result column="CUSTOMER_SUPPLIER_NAME" jdbcType="VARCHAR" property="customerSupplierName" />
     <result column="CAR_TYPE_NO" jdbcType="VARCHAR" property="carTypeNo" />
     <result column="CAR_TYPE_NAME" jdbcType="VARCHAR" property="carTypeName" />

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

@@ -909,6 +909,27 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
         }
     }
 
+    @ApiOperation(value = "双委托匹配洁净", notes = "双委托匹配洁净")
+    //@RequiresPermissions("meterworkcaractual:view")
+    @PostMapping(value = "/doubleEntrustmentMatch")
+    public RESTfulResult doubleEntrustmentMatch(@RequestBody HashMap parmas) {
+        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();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
+
     @ApiOperation(value = "双委托洁净")
     @Transactional
     @PostMapping(value = "/doNetAddTwo", produces = "application/json;charset=UTF-8")

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

@@ -93,6 +93,8 @@ public interface IMeterWorkCarActualFirstService extends IBaseService<MeterWorkC
 
     RESTfulResult doAddLianDaWf(MeterWorkCarActualFirst one, MeterMonitorNote two) throws Exception;
 
+//    RESTfulResult doNetMass(MeterWorkCarActualFirst one, MeterWorkCarActual two, PreTrackScale three, PreTrackScale four) throws Exception;
+
     RESTfulResult doNetAddTwo(MeterWorkCarActualFirst one, MeterWorkCarActual two, PreTrackScale three, PreTrackScale four) throws Exception;
 
     RESTfulResult doAddNetLianDaWf(MeterWorkCarActualFirst one, MeterWorkCarActual two, MeterMonitorNote three) throws Exception;
@@ -110,4 +112,5 @@ 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);
 }

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

@@ -72,6 +72,8 @@ import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static java.lang.Math.abs;
+
 /**
  * MeterWorkCarActualFirst服务实现：
  *
@@ -190,6 +192,10 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
 
             //当存储一次数据或者结净时，将本车辆的预处理重量改为已使用
             updatePreWeight(model.getCarNo());
+            model.setValueFlag("1");
+            if(StringUtils.isNotEmpty(model.getPredictionNo())){
+                model.setIsPreScale("1");
+            }
             int num = meterWorkCarActualFirstMapper.insertSelective(model);
             rm.setData(model.getActualFirstNo());
             rm.setMessage(enStr);
@@ -2498,7 +2504,8 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         SimpleDateFormat formatterOne = new SimpleDateFormat("yyyyMMdd");
         String aflOne = formatterOne.format(onceDb.getCreateTime());
         String noOne = meterWorkCarActualFirstMapper.getNewID(aflOne);
-        onceDb.setActualFirstNo(formatterOne.format(new Date()) + noOne);
+        String onceDbnoOne = formatterOne.format(new Date()) + noOne;
+        onceDb.setActualFirstNo(onceDbnoOne);
         onceDb.setValueFlag("2");//洁净
         meterWorkCarActualFirstMapper.insertSelective(onceDb);
 
@@ -2506,26 +2513,21 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
         String afl = formatter.format(secondDb.getCreateTime());
         String no = meterWorkCarActualFirstMapper.getNewID(afl);
-        secondDb.setActualFirstNo(formatter.format(new Date()) + no);
+        String secondDbno = formatterOne.format(new Date()) + noOne;
+        secondDb.setActualFirstNo(secondDbno);
         secondDb.setValueFlag("2");//洁净
         meterWorkCarActualFirstMapper.insertSelective(secondDb);
 
         //修改一次计量数据为洁净
         MeterWorkCarActualFirst firstUpdate = new MeterWorkCarActualFirst();
         //2、存储洁净数据
-        if (secondDb.getMeterWeight().equals(netDb.getTareWeight())) {
+        if (secondDb.getMeterWeight().compareTo(netDb.getTareWeight()) == 1) {
             //二次重量如果跟皮重一样
-            netDb.setActualFirst2No(secondDb.getActualFirstNo());
-            firstUpdate.setActualFirstNo(netDb.getActualFirst1No());
+            netDb.setActualFirst1No(secondDbno);
+            netDb.setActualFirst2No(onceDbnoOne);
         } else {
-            netDb.setActualFirst1No(secondDb.getActualFirstNo());
-            firstUpdate.setActualFirstNo(netDb.getActualFirst2No());
-        }
-
-        //3、修改第一次存储的计量数据状态为洁净
-        if (firstUpdate.getActualFirstNo() != null) {
-            firstUpdate.setValueFlag("2");
-            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(firstUpdate);
+            netDb.setActualFirst1No(onceDbnoOne);
+            netDb.setActualFirst2No(secondDbno);
         }
 
         // 判断当前数据是否存在委托
@@ -2895,7 +2897,7 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
             actualRow2.setActualNo(sdf.format(new Date()) + no1);
             actualRow2.setNetTime(new Date());
             actualRow2.setNetMode(DbConstants.TYPE);
-            actualRow2.setNote("混装结净");
+            actualRow2.setNote(" 结净");
             actualRow2.setUploadFlag("1");
             actualRow2.setIsPreScale("1");
             actualRow2.setNetWeight(mwcaf3.getMeterWeight().subtract(mwcaf4.getMeterWeight()));
@@ -2908,6 +2910,152 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         return "";
     }
 
+    @Override
+    public String doubleEntrustmentMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2) {
+        try{
+            //查询出一次计量数据
+            MeterWorkCarActualFirst mwcaf01 = meterWorkCarActualFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkCarActualFirst mwcaf02 = meterWorkCarActualFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkCarActualFirst mwcaf03 = meterWorkCarActualFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkCarActualFirst mwcaf04 = meterWorkCarActualFirstMapper.selectByPrimaryKey(actualNo2);
+
+            //查询出所有委托信息
+            PreTrackScale pts01 = preTrackScaleMapper.selectByPrimaryKey(predictionNo1);
+            PreTrackScale pts02 = preTrackScaleMapper.selectByPrimaryKey(predictionNo2);
+
+            //定义两个洁净类
+            MeterWorkCarActual actualRow1 = new MeterWorkCarActual();
+            MeterWorkCarActual actualRow2 = new MeterWorkCarActual();
+
+            BigDecimal num01 = mwcaf01.getMeterWeight().subtract(mwcaf03.getMeterWeight()).abs();
+            if(mwcaf01 == null || mwcaf03 == null ){
+                return "一次计量数据为空,请确认！!";
+            }
+            //判断毛重必须大于皮重
+            if(num01.compareTo(BigDecimal.valueOf(0)) == -1){
+                return "第一个一次计量重量一定要大于第二条一次计量重量！!";
+            }
+            if(pts01 == null || pts02 == null){
+                return "委托信息为空,请确认！！";
+            }
+            if(!mwcaf01.getCarNo().equals(mwcaf03.getCarNo())){
+                return "车号不一致,不能匹配洁净！！";
+            }
+            //洁净数据不能小于400
+            if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
+                return "选择的两条一次计量数据不能小于400！！";
+            }
+            if(pts01.getValueFlag().equals("2") || pts02.getValueFlag().equals("2")){
+                return "委托信息已使用！！";
+            }
+
+            if(pts01.getValueFlag().equals("3") || pts02.getValueFlag().equals("3")){
+                return "委托信息已作废！！";
+            }
+            if(mwcaf01.getValueFlag().equals("2") || mwcaf03.getValueFlag().equals("2")){
+                return "一次计量数据已洁净！！";
+            }
+
+            //将委托中的编号和收发货的等数据拷贝进一次数据中
+            MeterWorkCarActualFirst first1 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo1, predictionNo1);
+            BeanUtils.copyProperties(first1,mwcaf01);
+            MeterWorkCarActualFirst first2 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo2, predictionNo1);
+            BeanUtils.copyProperties(first2, mwcaf02);
+            MeterWorkCarActualFirst first3 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo1, predictionNo2);
+            BeanUtils.copyProperties(first3,mwcaf03);
+            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.setUploadFlag("1");
+            preTrackScaleMapper.updateByPrimaryKeySelective(scale);
+
+            PreTrackScale scale1 = new PreTrackScale();
+            scale1.setPredictionNo(predictionNo2);
+            scale1.setValueFlag(DbConstants.NET);
+            scale1.setUpdateTime(new Date());
+            scale1.setUpdateManNo("system");
+            scale1.setUpdateManName("二次计量洁净更新");
+            scale1.setUploadFlag("1");
+            preTrackScaleMapper.updateByPrimaryKeySelective(scale1);
+
+            //更新一次数据
+            //更新第一次毛重数据库
+            mwcaf01.setValueFlag(DbConstants.NET);
+            mwcaf01.setUpdateManName("system");
+            mwcaf01.setUpdateManName("二次计量洁净更新");
+            mwcaf01.setUpdateTime(new Date());
+            mwcaf01.setIsPreScale("1");
+            meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf01);
+            //更新第一次皮重数据库
+            mwcaf02.setValueFlag(DbConstants.NET);
+            mwcaf02.setUpdateManName("system");
+            mwcaf02.setUpdateManName("二次计量洁净更新");
+            mwcaf02.setUpdateTime(new Date());
+            mwcaf02.setIsPreScale("1");
+            meterWorkCarActualFirstMapper.updateByPrimaryKey(mwcaf02);
+            //添加第一次毛重数据库
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            String afl = sdf.format(new Date());
+            String actualFirstNo = sdf.format(new Date()) + meterWorkCarActualFirstMapper.getNewID(afl);
+            mwcaf03.setActualFirstNo(actualFirstNo);
+            mwcaf03.setValueFlag(DbConstants.NET);
+            mwcaf03.setUpdateManName("system");
+            mwcaf03.setUpdateManName("二次计量洁净更新");
+            mwcaf03.setUpdateTime(new Date());
+            mwcaf03.setIsPreScale("1");
+            meterWorkCarActualFirstMapper.insertSelective(mwcaf03);
+            //添加第二次皮重数据库
+            SimpleDateFormat sdf01 = new SimpleDateFormat("yyyyMMdd");
+            String afl01 = sdf01.format(new Date());
+            String actualSecondNo = sdf01.format(new Date()) + meterWorkCarActualFirstMapper.getNewID(afl01);
+            mwcaf04.setActualFirstNo(actualSecondNo);
+            mwcaf04.setValueFlag(DbConstants.NET);
+            mwcaf04.setUpdateManName("system");
+            mwcaf04.setUpdateManName("二次计量洁净更新");
+            mwcaf04.setUpdateTime(new Date());
+            mwcaf04.setIsPreScale("1");
+            meterWorkCarActualFirstMapper.insertSelective(mwcaf04);
+
+            //添加结净数据
+            String no = meterWorkCarActualMapper.getNewID(sdf.format(new Date()));
+            actualRow1.setActualNo(sdf.format(new Date()) + no);
+            actualRow1.setNetTime(new Date());
+            actualRow1.setNetMode(DbConstants.TYPE);
+            actualRow1.setNote("双委托匹配洁净");
+            actualRow1.setUploadFlag("1");
+            actualRow1.setIsPreScale("1");
+            actualRow1.setNetWeight(mwcaf01.getMeterWeight().subtract(mwcaf02.getMeterWeight()));
+            meterWorkCarActualMapper.insertSelective(actualRow1);
+
+            String no1 = meterWorkCarActualMapper.getNewID(sdf.format(new Date()));
+            actualRow2.setActualNo(sdf.format(new Date()) + no1);
+            actualRow2.setNetTime(new Date());
+            actualRow2.setNetMode(DbConstants.TYPE);
+            actualRow2.setNote("双委托匹配洁净");
+            actualRow2.setUploadFlag("1");
+            actualRow2.setIsPreScale("1");
+            actualRow2.setNetWeight(mwcaf03.getMeterWeight().subtract(mwcaf04.getMeterWeight()));
+            meterWorkCarActualMapper.insertSelective(actualRow2);
+        }catch(Exception e){
+            e.printStackTrace();
+            return "操作异常，请确认";
+        }
+        return "";
+    }
+
     @Override
     public RESTfulResult doNetAddTwo(MeterWorkCarActualFirst one, MeterWorkCarActual two, PreTrackScale three, PreTrackScale four) throws Exception {
         RESTfulResult rm = new RESTfulResult();
@@ -2924,14 +3072,14 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         //修改一次计量数据为洁净
         MeterWorkCarActualFirst firstUpdate = new MeterWorkCarActualFirst();
         //2、存储洁净数据
-        if (one.getMeterWeight().equals(two.getTareWeight())) {
-            //二次重量如果跟皮重一样
-            two.setActualFirst2No(one.getActualFirstNo());
-            firstUpdate.setActualFirstNo(two.getActualFirst1No());
-        } else {
-            two.setActualFirst1No(one.getActualFirstNo());
+        if(two.getActualFirst1No().equals("")){
+            two.setActualFirst1No(formatter.format(new Date()) + no);
             firstUpdate.setActualFirstNo(two.getActualFirst2No());
         }
+        else{
+            two.setActualFirst2No(formatter.format(new Date()) + no);
+            firstUpdate.setActualFirstNo(two.getActualFirst1No());
+        }
 
         //3、修改第一次存储的计量数据状态为洁净
         if (firstUpdate.getActualFirstNo() != null) {
@@ -2940,39 +3088,38 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         }
 
         //4、判断第一次计量数据是否匹配委托
-        MeterWorkCarActualFirst mwca1 = meterWorkCarActualFirstMapper.selectByPrimaryKey(two.getActualFirst1No());
-        if(mwca1.getPredictionNo().equals("")){
+        MeterWorkCarActualFirst mwca1 = meterWorkCarActualFirstMapper.selectByPrimaryKey(firstUpdate.getActualFirstNo());
+        if(StringUtils.isEmpty(mwca1.getPredictionNo())){
             MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(firstUpdate.getActualFirstNo(), three.getPredictionNo());
             meca1.setIsPreScale("1");
             meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
         }
         //5、判断这次一次计量数据是否匹配委托
-        if (one.getPredictionNo().equals("")){
-            MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(one.getActualFirstNo(), three.getPredictionNo());
+        if (StringUtils.isEmpty(one.getPredictionNo())){
+            MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(formatter.format(new Date()) + no, three.getPredictionNo());
             meca1.setIsPreScale("1");
             meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
         }
 
         //6、插入另外两条一次数据，并匹配委托
-        MeterWorkCarActualFirst mwcaf1 = meterWorkCarActualFirstMapper.selectAndMatch(one.getActualFirstNo(), four.getPredictionNo());
+        MeterWorkCarActualFirst mwcaf1 = meterWorkCarActualFirstMapper.selectAndMatch(formatter.format(new Date()) + no, four.getPredictionNo());
+        String nomwcaf1 = meterWorkCarActualFirstMapper.getNewID(afl);
+        mwcaf1.setActualFirstNo(formatter.format(new Date()) + nomwcaf1);
         mwcaf1.setIsPreScale("1");
         meterWorkCarActualFirstMapper.insertSelective(mwcaf1);
         MeterWorkCarActualFirst mwcaf2 = meterWorkCarActualFirstMapper.selectAndMatch(firstUpdate.getActualFirstNo(), four.getPredictionNo());
+        String nomwcaf2 = meterWorkCarActualFirstMapper.getNewID(afl);
         mwcaf2.setIsPreScale("1");
+        mwcaf2.setActualFirstNo(formatter.format(new Date()) + nomwcaf2);
         meterWorkCarActualFirstMapper.insertSelective(mwcaf2);
 
 
-        //7、判断洁净数据是否匹配委托
-        if(two.getPredictionNo().equals("")){
-            MeterWorkCarActual mwcaOld = meterWorkCarActualMapper.mathPredcition(two.getActualNo(), three.getPredictionNo());
-            BeanUtils.copyProperties(mwcaOld,two);
-        }
-
-        //8、插入洁净数据
+        //7、插入洁净数据
         String no1 = meterWorkCarActualMapper.getNewID(afl);
         two.setActualNo(afl + no1);
         two.setIsPreScale("1");
         two.setUploadFlag("1");
+        two.setValueFlag("1");
         if (two != null && two.getNetWeight() != null) {
             //2021年3月7日 净重保留两位小数；
             BigDecimal net;
@@ -2981,12 +3128,19 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         }
         meterWorkCarActualMapper.insert(two);
 
+        //8、判断洁净数据是否匹配委托
+        if(StringUtils.isEmpty(two.getPredictionNo())){
+            MeterWorkCarActual mwcaOld = meterWorkCarActualMapper.mathPredcition(afl + no1, three.getPredictionNo());
+            BeanUtils.copyProperties(mwcaOld,two);
+            meterWorkCarActualMapper.updateByPrimaryKeySelective(two);
+        }
 
         //9、复制一份新的洁净数据并匹配委托
-        MeterWorkCarActual mwcaNew = meterWorkCarActualMapper.mathPredcition(two.getActualNo(),four.getPredictionNo());
+        MeterWorkCarActual mwcaNew = meterWorkCarActualMapper.mathPredcition(afl + no1,four.getPredictionNo());
         mwcaNew.setActualNo(formatter.format(new Date()) + meterWorkCarActualMapper.getNewID(afl));
         mwcaNew.setIsPreScale("1");
         mwcaNew.setUploadFlag("1");
+        mwcaNew.setValueFlag("1");
         meterWorkCarActualMapper.insertSelective(mwcaNew);
 
         //修改委托为已使用状态
@@ -3020,5 +3174,107 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         rm.setMessage(flag);
         return rm;
     }
+
+//    @Override
+//    public RESTfulResult doNetMass(MeterWorkCarActualFirst one, MeterWorkCarActual two, PreTrackScale three, PreTrackScale four) throws Exception {
+//        RESTfulResult rm = new RESTfulResult();
+//        rm.setCode("200");
+//
+//        //1、存储当前计量的数据
+//        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
+//        String afl = formatter.format(one.getCreateTime());
+//        String no = meterWorkCarActualFirstMapper.getNewID(afl);
+//        String actualNo = formatter.format(new Date()) + no;
+//        one.setActualFirstNo(actualNo);
+//        one.setValueFlag("2");//洁净
+//        meterWorkCarActualFirstMapper.insertSelective(one);
+//
+//        //2、存储第二次一次数据编号
+//        two.setActualFirst2No(actualNo);
+//
+//        //2、修改第一次存储的计量数据状态为洁净
+//        MeterWorkCarActualFirst firstUpdate = new MeterWorkCarActualFirst();
+//        firstUpdate.setActualFirstNo(two.getActualFirst1No());
+//        firstUpdate.setValueFlag("2");
+//        meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(firstUpdate);
+//
+//
+//        //4、判断第一次计量数据是否匹配委托
+//        MeterWorkCarActualFirst mwca1 = meterWorkCarActualFirstMapper.selectByPrimaryKey(firstUpdate.getActualFirstNo());
+//        if(StringUtils.isEmpty(mwca1.getPredictionNo())){
+//            MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(firstUpdate.getActualFirstNo(), three.getPredictionNo());
+//            meca1.setIsPreScale("1");
+//            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
+//        }
+//        //5、判断这次一次计量数据是否匹配委托
+//        if (StringUtils.isEmpty(one.getPredictionNo())){
+//            MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(actualNo, three.getPredictionNo());
+//            meca1.setIsPreScale("1");
+//            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
+//        }
+//
+//        //复制此次计量数据并设置类型为毛重
+//        MeterWorkCarActualFirst actualFirstNew = new MeterWorkCarActualFirst();
+//        String noNew = meterWorkCarActualFirstMapper.getNewID(afl);
+//        String actualNoNew = formatter.format(new Date()) + noNew;
+//        actualFirstNew.setActualFirstNo(actualNoNew);
+//        actualFirstNew.setWeightType("0");
+//        meterWorkCarActualFirstMapper.insertSelective(actualFirstNew);
+//
+//        //将新加的毛重数据匹配第二条委托
+//        MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(actualNoNew, four.getPredictionNo());
+//        meca1.setIsPreScale("1");
+//        meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
+//
+//        //7、判断洁净数据是否匹配委托
+//        if(StringUtils.isEmpty(two.getPredictionNo())){
+//            MeterWorkCarActual mwcaOld = meterWorkCarActualMapper.manualAddPre(two.getActualFirst1No(),two.getActualFirst2No(), three.getPredictionNo());
+//            BeanUtils.copyProperties(mwcaOld,two);
+//        }
+//
+//        //8、插入洁净数据
+//        String no1 = meterWorkCarActualMapper.getNewID(afl);
+//        two.setActualNo(afl + no1);
+//        two.setIsPreScale("1");
+//        two.setUploadFlag("1");
+//        if (two != null && two.getNetWeight() != null) {
+//            //2021年3月7日 净重保留两位小数；
+//            BigDecimal net;
+//            net = new BigDecimal(String.valueOf(two.getNetWeight())).setScale(2, BigDecimal.ROUND_HALF_UP);
+//            two.setNetWeight(net);
+//        }
+//        meterWorkCarActualMapper.insert(two);
+//
+//        //修改委托为已使用状态
+//        three.setValueFlag("4");
+//        three.setUploadFlag("1");
+//        preTrackScaleMapper.updateByPrimaryKeySelective(three);
+//        four.setValueFlag("4");
+//        four.setUploadFlag("1");
+//        preTrackScaleMapper.updateByPrimaryKeySelective(four);
+//
+//        //10、保存图片
+//        SaveImg(one);
+//
+//        //11、修改计量监控
+//        updateMonitor(one.getBaseSpotNo());
+//
+//        //12、当存储一次数据或者结净时，将本车辆的预处理重量改为已使用
+//        updatePreWeight(one.getCarNo());
+//
+//        updateMonitorOver(one.getActualFirstNo(), one.getBaseSpotNo());
+//
+//        //重量类型为毛重则调用接口为
+//        String flag = "";
+//
+//        //补充附加重量的数据
+//        if (StringUtils.isNotEmpty(one.getAddWgtPk())) {
+//            insertAddWgtNo(one.getActualFirstNo(), one.getAddWgtPk(), one.getCreateManNo(), one.getCreateManName());
+//        }
+//
+//        rm.setData(one.getActualFirstNo());
+//        rm.setMessage(flag);
+//        return rm;
+//    }
 }