Merge branch 'HEAD' of https://git.steerinfo.com/caol/jg_wzjl_api.git

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/meterwork/meterworkcaractualfirst/controller/MeterWorkCarActualFirstController.java

@@ -852,7 +852,7 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
         return rm;
     }
 
-    @ApiOperation(value = "内倒车辆洁净")
+    @ApiOperation(value = "智能终端混装混卸")
     @Transactional
     @PostMapping(value = "/doAddNetHZHX", produces = "application/json;charset=UTF-8")
     public RESTfulResult doAddNetHZHX(@RequestBody CommonCombination<MeterWorkCarActualFirst, MeterWorkCarActual,MeterWorkCarActualFirst, MeterMonitorNote> com) {

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;

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

@@ -192,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);
@@ -1034,7 +1038,7 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
 
             //1、存储当前计量的数据
             SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
-            String afl = formatter.format(secondDb.getCreateTime());
+            String afl = formatter.format(new Date());
             String no = meterWorkCarActualFirstMapper.getNewID(afl);
             secondDb.setActualFirstNo(formatter.format(new Date()) + no);
             secondDb.setValueFlag("2");//洁净
@@ -1060,6 +1064,12 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
                 meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(firstUpdate);
             }
 
+            //判断洁净数据是否匹配委托
+            if (StringUtils.isNotEmpty(netDb.getPredictionNo())) {
+                MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(firstUpdate.getActualFirstNo(), netDb.getPredictionNo());
+                meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
+            }
+
             // 判断当前数据是否存在委托
             if (netDb.getPredictionNo() != null && "".equals(netDb.getPredictionNo())) {
                 MeterWorkCarActualFirst gross = meterWorkCarActualFirstMapper.selectByPrimaryKey(netDb.getActualFirst1No());
@@ -2498,51 +2508,39 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
 
         //0、存储当前计量的数据
         SimpleDateFormat formatterOne = new SimpleDateFormat("yyyyMMdd");
-        String aflOne = formatterOne.format(onceDb.getCreateTime());
+        String aflOne = formatterOne.format(new Date());
         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);
 
         //1、存储当前计量的数据
         SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
-        String afl = formatter.format(secondDb.getCreateTime());
+        String afl = formatter.format(new Date());
         String no = meterWorkCarActualFirstMapper.getNewID(afl);
-        secondDb.setActualFirstNo(formatter.format(new Date()) + no);
+        String secondDbno = formatter.format(new Date()) + no;
+        secondDb.setActualFirstNo(secondDbno);
         secondDb.setValueFlag("2");//洁净
         meterWorkCarActualFirstMapper.insertSelective(secondDb);
 
         //修改一次计量数据为洁净
         MeterWorkCarActualFirst firstUpdate = new MeterWorkCarActualFirst();
-        //2、存储洁净数据
-        if (secondDb.getMeterWeight().equals(netDb.getTareWeight())) {
-            //二次重量如果跟皮重一样
-            netDb.setActualFirst2No(secondDb.getActualFirstNo());
-            firstUpdate.setActualFirstNo(netDb.getActualFirst1No());
+        //判断两次一次数据哪个是皮哪个是毛
+        if (secondDb.getMeterWeight().compareTo(onceDb.getMeterWeight()) == 1) {
+            netDb.setActualFirst1No(secondDbno);
+            netDb.setActualFirst2No(onceDbnoOne);
         } else {
-            netDb.setActualFirst1No(secondDb.getActualFirstNo());
-            firstUpdate.setActualFirstNo(netDb.getActualFirst2No());
+            netDb.setActualFirst1No(onceDbnoOne);
+            netDb.setActualFirst2No(secondDbno);
         }
 
-        //3、修改第一次存储的计量数据状态为洁净
-        if (firstUpdate.getActualFirstNo() != null) {
-            firstUpdate.setValueFlag("2");
-            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(firstUpdate);
-        }
-
-        // 判断当前数据是否存在委托
-        if (netDb.getPredictionNo() != null && "".equals(netDb.getPredictionNo())) {
-            MeterWorkCarActualFirst gross = meterWorkCarActualFirstMapper.selectByPrimaryKey(netDb.getActualFirst1No());
-            if ((gross.getPredictionNo() == null || "".equals(gross.getPredictionNo()))) {
-                // 如果毛重数据还未匹配委托，则匹配委托操作
-                MeterWorkCarActualFirst meca1 = meterWorkCarActualFirstMapper.selectAndMatch(gross.getActualFirstNo(), netDb.getPredictionNo());
-                meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meca1);
-                PreTrackScale preTrackScale = new PreTrackScale();
-                preTrackScale.setValueFlag("2");
-                preTrackScale.setUploadFlag("1");
-                preTrackScaleMapper.updateByPrimaryKeySelective(preTrackScale);
-            }
-        }
+        //修改委托状态
+        PreTrackScale preTrackScale = new PreTrackScale();
+        preTrackScale.setPredictionNo(netDb.getPredictionNo());
+        preTrackScale.setValueFlag("2");
+        preTrackScale.setUploadFlag("1");
+        preTrackScaleMapper.updateByPrimaryKeySelective(preTrackScale);
 
         String no1 = meterWorkCarActualMapper.getNewID(afl);
         netDb.setActualNo(afl + no1);
@@ -2790,7 +2788,7 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
 
             //判断是否为混装逻辑
             if(mwcaf1.getMeterWeight().compareTo(mwcaf2.getMeterWeight()) == -1 || mwcaf1.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == -1 || mwcaf2.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == -1){
-                return "不为混装逻辑！！";
+                return "不为混卸逻辑！！";
             }
 
             //判断一次数据是否存在
@@ -3072,14 +3070,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) {
@@ -3088,39 +3086,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;
@@ -3129,12 +3126,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);
 
         //修改委托为已使用状态
@@ -3168,5 +3172,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;
+//    }
 }
 

src/main/java/com/steerinfo/meterwork/meterworkhookactfirst/controller/MeterWorkHookActFirstController.java

@@ -362,5 +362,26 @@ public class MeterWorkHookActFirstController extends BaseRESTfulController {
         return rm;
     }
 
+    @ApiOperation(value = "吊钩秤洁净", notes = "根据MeterWorkHookActFirst对象创建")
+    @PostMapping(value = "/doAddWfStatic")
+    public RESTfulResult doAddWfStatic(@RequestBody MeterWorkHookActFirst model) {
+        RESTfulResult rm = failed();
+        try {
+            String no = meterWorkHookActFirstService.doAddWfStatic(model);
+            if (com.steerinfo.util.StringUtils.isEmpty(no)) {
+                return failed(null, "新增数据失败");
+            }
+            return success(no);
+        } catch (MarkerMetException e) {
+            e.printStackTrace();
+            rm.setMessage(e.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！");
+        } finally {
+
+        }
+        return rm;
+    }
 
 }

src/main/java/com/steerinfo/meterwork/meterworkhookactfirst/mapper/MeterWorkHookActFirstMapper.java

@@ -8,6 +8,7 @@ import java.util.HashMap;
 import java.util.List;
 
 import com.steerinfo.meterwork.meterworkrailwayactfirst.model.MeterWorkRailwayActFirst;
+import com.steerinfo.meterwork.meterworkrailwayactual.model.MeterWorkRailwayActual;
 import org.apache.ibatis.annotations.Mapper;
 
 @Mapper
@@ -21,4 +22,6 @@ public interface MeterWorkHookActFirstMapper extends IBaseMapper<MeterWorkHookAc
     MeterWorkHookActFirst selectAndMatch(String actualFirstNo, String predictionNo);
 
     List<MeterWorkHookActFirst> distinctCarNo(HashMap<String, Object> obj);
+
+    List<MeterWorkHookActFirst> selectBy(HashMap<String, Object> param);
 }

src/main/java/com/steerinfo/meterwork/meterworkhookactfirst/mapper/MeterWorkHookActFirstMapper.xml

@@ -1908,4 +1908,36 @@
       and  CREATE_TIME  >= TO_DATE(#{startTime}, 'yyyy-MM-dd HH24:mi:ss') and CREATE_TIME  <=  TO_DATE(#{endTime}, 'yyyy-MM-dd HH24:mi:ss')
     </if>
   </select>
+
+  <select id="selectBy" parameterType="java.util.HashMap" resultMap="BaseResultMap">
+    <include refid="select"/>
+    <where>
+      ROUND(TO_NUMBER(sysdate - CREATE_TIME)) <![CDATA[ <= ]]> 30
+      <if test="predictionNo != null and predictionNo != ''">
+        and PREDICTION_NO = #{predictionNo}
+      </if>
+      <if test="weightType != null and weightType != ''">
+        and WEIGHT_TYPE = #{weightType}
+      </if>
+      <if test="railwayNo != null and railwayNo != ''">
+        and RAILWAY_NO = #{railwayNo}
+      </if>
+      <if test="railwayCarriageNo != null and railwayCarriageNo != ''">
+        and RAILWAY_CARRIAGE_NO = #{railwayCarriageNo}
+      </if>
+      <if test="valueFlag != null and valueFlag != ''">
+        and VALUE_FLAG = #{valueFlag}
+      </if>
+      <if test="valueFlag == null or valueFlag == ''">
+        and VALUE_FLAG in('0','2')
+      </if>
+      <if test="matterNo != null and matterNo != ''">
+        and MATTER_NO = #{matterNo}
+      </if>
+      <if test="matterName != null and matterName != ''">
+        and MATTER_NAME = #{matterName}
+      </if>
+    </where>
+    order by CREATE_TIME desc
+  </select>
 </mapper>

src/main/java/com/steerinfo/meterwork/meterworkhookactfirst/service/IMeterWorkHookActFirstService.java

@@ -44,4 +44,6 @@ public interface IMeterWorkHookActFirstService extends IBaseService<MeterWorkHoo
     int remove(MeterWorkHookActFirst model);
 
     List<String> distinctCarNo(String railwayNo, String startTime, String endTime);
+
+    String doAddWfStatic(MeterWorkHookActFirst firstHook) throws Exception;
 }

src/main/java/com/steerinfo/meterwork/meterworkhookactfirst/service/impl/MeterWorkHookActFirstServiceImpl.java

@@ -1,27 +1,39 @@
 package com.steerinfo.meterwork.meterworkhookactfirst.service.impl;
 
+import com.steerinfo.baseinfo.meterbasevideoinfo.mapper.MeterBaseVideoinfoMapper;
+import com.steerinfo.baseinfo.meterbasevideoinfo.model.MeterBaseVideoinfo;
 import com.steerinfo.framework.mapper.IBaseMapper;
 import com.steerinfo.framework.service.impl.BaseServiceImpl;
 import com.steerinfo.framework.service.pagehelper.PageHelper;
 import com.steerinfo.framework.service.pagehelper.PageList;
 import com.steerinfo.framework.user.UserPayload;
+import com.steerinfo.framework.utils.collection.ListUtils;
 import com.steerinfo.meterwork.constants.DbConstants;
 import com.steerinfo.meterwork.except.MarkerMetException;
 import com.steerinfo.meterwork.meterworkhookactfirst.mapper.MeterWorkHookActFirstMapper;
 import com.steerinfo.meterwork.meterworkhookactfirst.model.MeterWorkHookActFirst;
 import com.steerinfo.meterwork.meterworkhookactfirst.service.IMeterWorkHookActFirstService;
+import com.steerinfo.meterwork.meterworkhookactual.mapper.MeterWorkHookActualMapper;
+import com.steerinfo.meterwork.meterworkhookactual.model.MeterWorkHookActual;
+import com.steerinfo.meterwork.meterworkimage.mapper.MeterWorkImageMapper;
+import com.steerinfo.meterwork.meterworkimage.model.MeterWorkImage;
+import com.steerinfo.meterwork.meterworkrailwayactfirst.model.MeterWorkRailwayActFirst;
+import com.steerinfo.meterwork.meterworkrailwayactual.model.MeterWorkRailwayActual;
 import com.steerinfo.pretrack.prehookscale.mapper.PreHookScaleMapper;
 import com.steerinfo.pretrack.prehookscale.model.PreHookScale;
+import com.steerinfo.pretrack.prerailwayscale.model.PreRailwayScale;
+import com.steerinfo.util.FieldsCollector;
 import com.steerinfo.util.StringUtils;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
+import java.lang.reflect.Field;
+import java.math.BigDecimal;
 import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -46,6 +58,15 @@ public class MeterWorkHookActFirstServiceImpl extends BaseServiceImpl<MeterWorkH
     @Resource
     private PreHookScaleMapper preHookScaleMapper;
 
+    @Resource
+    private MeterWorkImageMapper meterWorkImageMapper;
+
+    @Resource
+    private MeterBaseVideoinfoMapper meterBaseVideoinfoMapper;
+
+    @Resource
+    private MeterWorkHookActualMapper meterWorkHookActualMapper;
+
     @Override
     protected IBaseMapper<MeterWorkHookActFirst, String> getMapper() {
         return meterWorkHookActFirstMapper;
@@ -458,4 +479,369 @@ public class MeterWorkHookActFirstServiceImpl extends BaseServiceImpl<MeterWorkH
         List<String> list = meterWorkHookActFirstMapper.distinctCarNo(obj).stream().map(MeterWorkHookActFirst::getRailwayNo).collect(Collectors.toList());
         return list;
     }
+
+    /**
+     * 吊钩秤计量保存逻辑
+     *
+     * @param model
+     * @return
+     * @throws Exception
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public String doAddWfStatic(MeterWorkHookActFirst model) throws Exception {
+        BigDecimal zero = new BigDecimal(0);
+        String id = "";//需要返回的作业编号
+        if (model == null || StringUtils.isEmpty(model.getPredictionNo())) {
+            throw new MarkerMetException(500, "预报编号为空不允许进行保存操作!");
+        }
+        if (model.getMeterWeight() == null || model.getMeterWeight().compareTo(zero) <= 0) {
+            throw new MarkerMetException(500, "采集重量为空或小于0不允许进行保存操作!");
+        }
+        //验证预报编号与预报的车号是否一致
+        PreHookScale preHookScale = preHookScaleMapper.selectByPrimaryKey(model.getPredictionNo());
+        if (preHookScale == null || StringUtils.isEmpty(preHookScale.getPredictionNo())) {
+            throw new MarkerMetException(500, "未查询到预报编号为【" + model.getPredictionNo() + "】的数据，请刷新后重试!");
+        } else {
+            if (StringUtils.isEmpty(preHookScale.getRailwayNo())) {
+                throw new MarkerMetException(500, "预报【" + model.getPredictionNo() + "】中的车号为空，不允许进行保存操作，请刷新后重试!");
+            } else {
+                if (!preHookScale.getRailwayNo().equals(model.getRailwayNo())) {
+                    throw new MarkerMetException(500, "预报【" + model.getPredictionNo() + "】中的车号【" + preHookScale.getRailwayNo() + "】" +
+                            "与界面车号【" + model.getRailwayNo() + "】不一致，不允许进行保存操作，请刷新后重试!");
+                }
+                if ("3".equals(preHookScale.getValueFlag())) {
+                    throw new MarkerMetException(500, "预报【" + model.getPredictionNo() + "】已被作废，不允许进行保存操作，请重新选择预报!");
+                }
+                if ("2".equals(preHookScale.getValueFlag())) {
+                    throw new MarkerMetException(500, "预报【" + model.getPredictionNo() + "】已经使用（已出净重），不允许再次使用，请重新选择预报或者进行复磅!");
+                }
+            }
+
+        }
+        //验证当前使用的预报号与一次计量的预报号是否一致
+        MeterWorkHookActFirst searchFirst = new MeterWorkHookActFirst();
+        searchFirst.setRailwayNo(model.getRailwayNo());
+        searchFirst.setValueFlag("1");
+        Map<String, Object> mapSearchFirst = FieldsCollector.beanToMap(searchFirst);
+        List<MeterWorkHookActFirst> searchFirstList = meterWorkHookActFirstMapper.selectByParameters(mapSearchFirst);
+        if (searchFirstList != null && searchFirstList.size() > 1) {
+            throw new MarkerMetException(500, "车号【" + model.getRailwayNo() + "】存在【" + searchFirstList.size() + "】条有效数据，不允许计量操作，请先在网页上进行作废!");
+        }
+        if (searchFirstList != null && searchFirstList.size() == 1) {
+            if (!model.getPredictionNo().equals(searchFirstList.get(0).getPredictionNo())) {
+                throw new MarkerMetException(500, "车号【" + model.getRailwayNo() + "】一次计量的预报【"
+                        + searchFirstList.get(0).getPredictionNo() + "】与当前使用的预报【" + model.getPredictionNo() + "】不一致，不允许计量操作，请先在网页上进行修改!");
+            }
+        }
+
+
+        //1、判断是否是二次数据（二次数据需要洁净）
+        HashMap<String, Object> obj = new HashMap<>();
+        obj.put("railwayNo", model.getRailwayNo());
+        obj.put("railwayCarriageNo", model.getRailwayCarriageNo());
+        obj.put("valueFlag", "1");//有效，未洁净
+        List<MeterWorkHookActFirst> mwrafs = meterWorkHookActFirstMapper.selectBy(obj);
+
+        //2、判断是否为混装,若为混装将计量预报分割出
+        ArrayList<String> ids = new ArrayList<>(); //ids用于更新预报操作
+        if (StringUtils.isNotEmpty(model.getPredictionCombination())) {
+            String[] preSclas = model.getPredictionCombination().split(",");
+            Collections.addAll(ids, preSclas);
+        }
+
+        if (mwrafs.size() == 0) {
+            //===========一次计量处理开始==============
+            if (model.getRailwayFactoryWeight() == null || model.getRailwayFactoryWeight().compareTo(zero) <= 0) {
+                //============一毛一皮的计量数据处理开始==============
+                model.setWeightType("0");
+                model.setMeterSortWeight(zero); //分检重量
+                model.setMeterBalanceWeight(model.getMeterWeight()); //结算重量
+                id = doAddWfStaticFrist(model);
+                //3、修改预报状态为【使用中】
+                if (StringUtils.isNotEmpty(model.getPredictionNo())
+                        && model.getPredictionNo().length() > 10) {
+                    ids.add(model.getPredictionNo());
+                    preHookScaleMapper.batchUpdateByIdsForIn(ids);
+                }
+                //============一毛一皮的计量数据处理结束==============
+            } else {
+                //============毛重+自重的计量数据处理开始==============
+                //毛重数据保存
+                model.setWeightType("0");
+                model.setMeterSortWeight(zero); //分检重量
+                model.setMeterBalanceWeight(model.getMeterWeight());//结算重量
+                model.setCreateTime(new Date()); //服务端重新赋值，避免出现皮重比毛重时间晚的情况；2021年6月10日
+                id = doAddWfStaticFrist(model);
+
+                //皮重计量实体的组装；皮重数据保存
+                MeterWorkHookActFirst hookActFirst = new MeterWorkHookActFirst();
+                BeanUtils.copyProperties(model, hookActFirst);
+                hookActFirst.setMeterWeight(model.getRailwayFactoryWeight()); //皮重等于自重
+                hookActFirst.setMeterSortWeight(zero);//分检重量
+                hookActFirst.setMeterBalanceWeight(model.getRailwayFactoryWeight());//结算重量
+                hookActFirst.setWeightType("1");
+                Calendar tareDate = Calendar.getInstance();
+                tareDate.add(Calendar.SECOND, -10);//自重的皮重减10s,用于查询最近的一条毛重数据，保证复磅数据准确
+                hookActFirst.setCreateTime(tareDate.getTime());
+                id = doAddWfStaticFrist(hookActFirst);
+
+                //净重数据保存
+                PreHookScale preHookScales = preHookScaleMapper.selectByPrimaryKey(model.getPredictionNo());
+                doAddWfStaticNet(preHookScales, model, hookActFirst); //预报，毛重，皮重
+
+                //3、修改预报状态为【已使用】
+                if (StringUtils.isNotEmpty(model.getPredictionNo())
+                        && model.getPredictionNo().length() > 10) {
+                    ids.add(model.getPredictionNo());
+                    preHookScaleMapper.batchUpdateByIdsForUsed(ids);
+                }
+                //============毛重+自重的计量数据处理结束==============
+            }
+            //===========一次计量处理结束==============
+        } else {
+            //===========二次计量处理开始==============
+            for (MeterWorkHookActFirst mwraf : mwrafs) {
+                //查询预报信息
+                PreHookScale prs = preHookScaleMapper.selectByPrimaryKey(mwraf.getPredictionNo());
+
+                //保存第二次的一次计量数据；特别说明：先皮后毛不会做分检，所以不需要考虑
+                MeterWorkHookActFirst meterWorkHookActFirst = new MeterWorkHookActFirst();
+                BeanUtils.copyProperties(mwraf, meterWorkHookActFirst);
+                meterWorkHookActFirst.setCreateTime(new Date());
+                meterWorkHookActFirst.setCreateManName(model.getCreateManName());
+                meterWorkHookActFirst.setCreateManNo(model.getCreateManNo());
+                meterWorkHookActFirst.setMeterGroup(model.getMeterGroup());
+                meterWorkHookActFirst.setMeterClass(model.getMeterClass());
+                meterWorkHookActFirst.setBaseSpotNo(model.getBaseSpotNo());
+                meterWorkHookActFirst.setBaseSpotName(model.getBaseSpotName());
+                meterWorkHookActFirst.setWeightType("1"); //假定为皮重，在出净重时会重新调整状态位
+                meterWorkHookActFirst.setMeterWeight(model.getMeterWeight());
+                meterWorkHookActFirst.setMeterSortWeight(zero);
+                meterWorkHookActFirst.setMeterBalanceWeight(meterWorkHookActFirst.getMeterWeight());
+                meterWorkHookActFirst.setPredictionNo(prs.getPredictionNo());
+                meterWorkHookActFirst.setNoticeNo(prs.getNoticeNo());
+                meterWorkHookActFirst.setMatterNo(prs.getMatterNo());
+                meterWorkHookActFirst.setMatterName(prs.getMatterName());
+                meterWorkHookActFirst.setContractNo(prs.getContractNo());
+                meterWorkHookActFirst.setBatchNo(prs.getBatchNo());
+                meterWorkHookActFirst.setCustomerSupplierNo(prs.getCustomerSupplierNo());
+                meterWorkHookActFirst.setCustomerSupplierName(prs.getCustomerSupplierName());
+                meterWorkHookActFirst.setForwardingUnitNo(prs.getForwardingUnitNo());
+                meterWorkHookActFirst.setForwardingUnitName(prs.getForwardingUnitName());
+                meterWorkHookActFirst.setReceivingUintNo(prs.getReceivingUintNo());
+                meterWorkHookActFirst.setReceivingUintName(prs.getReceivingUintName());
+                meterWorkHookActFirst.setMaterialNo(prs.getMaterialNo());
+                meterWorkHookActFirst.setMaterialName(prs.getMaterialName());
+                meterWorkHookActFirst.setSpecNo(prs.getSpecNo());
+                meterWorkHookActFirst.setSpecName(prs.getSpecName());
+                meterWorkHookActFirst.setLoadPointNo(prs.getLoadPointNo());
+                meterWorkHookActFirst.setLoadPointName(prs.getLoadPointName());
+                meterWorkHookActFirst.setSampleNo(prs.getSampleNo());
+                meterWorkHookActFirst.setSampleVoucher(prs.getSampleVoucher());
+                meterWorkHookActFirst.setCarrierUnitNo(prs.getCarrierUnitNo());
+                meterWorkHookActFirst.setCarrierUnitName(prs.getCarrierUnitName());
+                meterWorkHookActFirst.setMeterTypeNo(prs.getMeterTypeNo());
+                meterWorkHookActFirst.setMeterTypeName(prs.getMeterTypeName());
+                meterWorkHookActFirst.setArrival(prs.getArrival());
+                meterWorkHookActFirst.setStation(prs.getStation());
+                meterWorkHookActFirst.setSourceArea(prs.getSourceArea());
+
+                id = doAddWfStaticFrist(meterWorkHookActFirst);
+                //保存洁净数据
+                if (mwraf.getMeterWeight().compareTo(meterWorkHookActFirst.getMeterWeight()) >= 0) {
+                    doAddWfStaticNet(prs, mwraf, meterWorkHookActFirst); //预报，毛重，皮重
+                } else {
+                    doAddWfStaticNet(prs, meterWorkHookActFirst, mwraf);//预报，皮重，毛重
+                }
+            }
+            //3、修改预报状态为【已使用】
+            if (StringUtils.isNotEmpty(model.getPredictionNo())
+                    && model.getPredictionNo().length() > 10) {
+                ids.add(model.getPredictionNo());
+                preHookScaleMapper.batchUpdateByIdsForUsed(ids);
+            }
+        }
+        //===========二次计量处理结束==============
+        //4、保存图片（一、二次计量共用）
+        SaveImg(meterWorkHookActFirstMapper.selectByPrimaryKey(id));
+        return id;
+    }
+
+    //保存计量数据
+    private String doAddWfStaticFrist(MeterWorkHookActFirst model) {
+        //此为第一次计量的数据
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+        String afl = sdf.format(model.getCreateTime());
+        //一次数据
+        String firstNo = meterWorkHookActFirstMapper.getNewID(afl);
+        model.setActualFirstNo(afl + firstNo);
+        model.setValueFlag("1");
+        model.setCheckFlag("0");
+        model.setMeterMode("1");
+        meterWorkHookActFirstMapper.insertSelective(model);
+        return model.getActualFirstNo();
+    }
+
+    /**
+     * 需要两次计量时完善洁净数据
+     *
+     * @param prs 预报
+     * @param one 毛重实体
+     * @param two 皮重实体
+     * @return
+     */
+    private MeterWorkHookActual doAddWfStaticNet(PreHookScale prs, MeterWorkHookActFirst one, MeterWorkHookActFirst two) {
+        MeterWorkHookActual netHook = new MeterWorkHookActual();
+        //补充编号
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+        String afl = sdf.format(new Date());
+        String netNo = meterWorkHookActualMapper.getNewID(afl);
+        netHook.setActualNo(afl + netNo);
+
+        //补充数据
+        netHook.setPredictionNo(prs.getPredictionNo());
+        netHook.setNoticeNo(prs.getNoticeNo());
+        netHook.setMatterNo(prs.getMatterNo());
+        netHook.setMatterName(prs.getMatterName());
+        netHook.setContractNo(prs.getContractNo());
+        netHook.setBatchNo(prs.getBatchNo());
+        netHook.setCustomerSupplierNo(prs.getCustomerSupplierNo());
+        netHook.setCustomerSupplierName(prs.getCustomerSupplierName());
+        netHook.setForwardingUnitNo(prs.getForwardingUnitNo());
+        netHook.setForwardingUnitName(prs.getForwardingUnitName());
+        netHook.setReceivingUintNo(prs.getReceivingUintNo());
+        netHook.setReceivingUintName(prs.getReceivingUintName());
+        netHook.setMaterialNo(prs.getMaterialNo());
+        netHook.setMaterialName(prs.getMaterialName());
+        netHook.setSpecNo(prs.getSpecNo());
+        netHook.setSpecName(prs.getSpecName());
+        netHook.setLoadPointNo(prs.getLoadPointNo());
+        netHook.setLoadPointName(prs.getLoadPointName());
+        netHook.setSampleNo(prs.getSampleNo());
+        netHook.setSampleVoucher(prs.getSampleVoucher());
+        netHook.setCarrierUnitNo(prs.getCarrierUnitNo());
+        netHook.setCarrierUnitName(prs.getCarrierUnitName());
+        netHook.setMeterTypeNo(prs.getMeterTypeNo());
+        netHook.setMeterTypeName(prs.getMeterTypeName());
+        netHook.setStation(prs.getStation());
+        netHook.setArrival(prs.getArrival());
+        netHook.setSourceArea(prs.getSourceArea());
+
+        //将毛重数据补充进来
+        netHook.setRailwayNo(one.getRailwayNo());
+        netHook.setRailwayCarriageNo(one.getRailwayCarriageNo());
+        netHook.setActualFirst1No(one.getActualFirstNo());
+        netHook.setGrossWeight(one.getMeterBalanceWeight());
+        netHook.setGrossManNo(one.getCreateManNo());
+        netHook.setGrossManName(one.getCreateManName());
+        netHook.setGrossTime(one.getCreateTime());
+        netHook.setBaseSpot1No(one.getBaseSpotNo());
+        netHook.setBaseSpot1Name(one.getBaseSpotName());
+        netHook.setGrossClass(one.getMeterClass());
+        netHook.setGrossGroup(one.getMeterGroup());
+        netHook.setGrossMode(one.getMeterMode());
+        netHook.setRailwayTypeNo(one.getRailwayTypeNo());
+        netHook.setRailwayTypeName(one.getRailwayTypeName());
+        netHook.setWaterNum(one.getWaterNum());
+        //将皮重数据补充
+        netHook.setActualFirst2No(two.getActualFirstNo());
+        netHook.setTareWeight(two.getMeterWeight());
+        netHook.setTareManNo(two.getCreateManNo());
+        netHook.setTareManName(two.getCreateManName());
+        netHook.setTareTime(two.getCreateTime());
+        netHook.setBaseSpot2No(two.getBaseSpotNo());
+        netHook.setBaseSpot2Name(two.getBaseSpotName());
+        netHook.setTareClass(two.getMeterClass());
+        netHook.setTareGroup(two.getMeterGroup());
+        netHook.setTareMode(two.getMeterMode());
+        //补充净重数据
+
+        if (one.getCreateTime().after(two.getCreateTime())) {
+            netHook.setNetManNo(one.getCreateManNo());
+            netHook.setNetManName(one.getCreateManName());
+            netHook.setNetTime(one.getCreateTime());
+            netHook.setNetSpot3No(one.getBaseSpotNo());
+            netHook.setNetSpot3Name(one.getBaseSpotName());
+            netHook.setNetClass(one.getMeterClass());
+            netHook.setNetGroup(one.getMeterGroup());
+        } else {
+            netHook.setNetManNo(two.getCreateManNo());
+            netHook.setNetManName(two.getCreateManName());
+            netHook.setNetTime(two.getCreateTime());
+            netHook.setNetSpot3No(two.getBaseSpotNo());
+            netHook.setNetSpot3Name(two.getBaseSpotName());
+            netHook.setNetClass(two.getMeterClass());
+            netHook.setNetGroup(two.getMeterGroup());
+        }
+        netHook.setNetWeight(one.getMeterBalanceWeight().subtract(two.getMeterBalanceWeight()));
+        netHook.setNetMode("1");
+        netHook.setValueFlag("0");
+        netHook.setUploadFlag("0");
+        netHook.setUploadFlag("1");
+        if ("001019002".equals(one.getRailwayTypeNo())) {
+            netHook.setNetTime(new Date()); //动轨的特殊处理
+            //假如一次数据为补录，则洁净数据中的grossModel为3，标识毛重为手工录入的
+            if ("补录".equals(one.getRailwayModelName())) {
+                netHook.setGrossMode("3");
+                //METER_WORK_RAILWAY_ACTUAL_BAR
+                meterWorkHookActualMapper.insertSelectiveBar(netHook);
+            }
+        }
+        meterWorkHookActualMapper.insertSelective(netHook);
+
+
+        //修改一次的状态
+        one.setValueFlag("2");//洁净
+        one.setWeightType("0");//毛重
+        two.setValueFlag("2");//洁净
+        two.setWeightType("1");//皮重
+        meterWorkHookActFirstMapper.updateByPrimaryKeySelective(one);
+        meterWorkHookActFirstMapper.updateByPrimaryKeySelective(two);
+        return netHook;
+    }
+
+    /**
+     * 图片保存信息
+     *
+     * @param oci
+     * @throws Exception
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void SaveImg(MeterWorkHookActFirst oci) throws Exception {
+        //查下当前配置的摄像头有多少个
+        MeterBaseVideoinfo mbv = new MeterBaseVideoinfo();
+        mbv.setPointid(oci.getBaseSpotNo());
+        Map<String, Object> map = FieldsCollector.beanToMap(mbv);
+        List<MeterBaseVideoinfo> lmb = meterBaseVideoinfoMapper.selectByParameters(map);
+        if (ListUtils.isNotEmpty(lmb) && lmb.size() > 0) {
+            MeterBaseVideoinfo mb = lmb.get(0);
+
+            long i = 0;
+            //https://www.cnblogs.com/alice-cj/p/10363356.html
+            Class clazz = mb.getClass();
+            Object obj = clazz.newInstance();
+            Field[] fields = clazz.getDeclaredFields();
+            for (Field field : fields) {
+                if (field.getName().contains("pointname")) {
+                    field.setAccessible(true); // 私有属性必须设置访问权限
+                    Object resultValue = field.get(obj);
+                    if (resultValue != null && resultValue.toString().trim().length() > 0) {
+                        i++;
+                    }
+                }
+            }
+            //METER_WORK_IMAGE
+            MeterWorkImage mwi = new MeterWorkImage();
+            mwi.setActualFirstNo("R" + oci.getActualFirstNo());
+            mwi.setImageTime(oci.getCreateTime());
+            mwi.setImageNum(++i);//因为界面上会存储一个界面截图，所以此处比摄像头要多1条
+            for (int k = 1; k <= i; k++) {
+                Field fName = mwi.getClass().getDeclaredField("imageFile" + i);
+                fName.setAccessible(true);
+                fName.set(mwi, oci.getBaseSpotNo() + "_" + oci.getActualFirstNo() + "_" + i);
+            }
+            meterWorkImageMapper.insertSelective(mwi);
+        }
+    }
 }

src/main/java/com/steerinfo/meterwork/meterworkhookactual/mapper/MeterWorkHookActualMapper.java

@@ -28,4 +28,6 @@ public interface MeterWorkHookActualMapper extends IBaseMapper<MeterWorkHookActu
     MeterWorkHookActual matchPredcition(String actualNo, String predictionNo);
 
     MeterWorkHookActual cleanPredcition(String actualNo);
+
+    void insertSelectiveBar(MeterWorkHookActual netHook);
 }

src/main/java/com/steerinfo/meterwork/meterworkhookactual/mapper/MeterWorkHookActualMapper.xml

@@ -2121,4 +2121,468 @@
            t.update_man_name, t.update_time,t.source_area
     from METER_WORK_HOOK_ACTUAL t where t.actual_no = #{actualNo,jdbcType=VARCHAR}
   </select>
+
+  <insert id="insertSelectiveBar" parameterType="com.steerinfo.meterwork.meterworkrailwayactual.model.MeterWorkRailwayActual">
+    insert into METER_WORK_HOOK_ACTUAL
+    <trim prefix="(" suffix=")" suffixOverrides=",">
+      <if test="actualNo != null">
+        ACTUAL_NO,
+      </if>
+      <if test="predictionNo != null">
+        PREDICTION_NO,
+      </if>
+      <if test="noticeNo != null">
+        NOTICE_NO,
+      </if>
+      <if test="railwayNo != null">
+        RAILWAY_NO,
+      </if>
+      <if test="railwayCarriageNo != null">
+        RAILWAY_CARRIAGE_NO,
+      </if>
+      <if test="matterNo != null">
+        MATTER_NO,
+      </if>
+      <if test="matterName != null">
+        MATTER_NAME,
+      </if>
+      <if test="contractNo != null">
+        CONTRACT_NO,
+      </if>
+      <if test="batchNo != null">
+        BATCH_NO,
+      </if>
+      <if test="customerSupplierNo != null">
+        CUSTOMER_SUPPLIER_NO,
+      </if>
+      <if test="customerSupplierName != null">
+        CUSTOMER_SUPPLIER_NAME,
+      </if>
+      <if test="forwardingUnitNo != null">
+        FORWARDING_UNIT_NO,
+      </if>
+      <if test="forwardingUnitName != null">
+        FORWARDING_UNIT_NAME,
+      </if>
+      <if test="receivingUintNo != null">
+        RECEIVING_UINT_NO,
+      </if>
+      <if test="receivingUintName != null">
+        RECEIVING_UINT_NAME,
+      </if>
+      <if test="materialNo != null">
+        MATERIAL_NO,
+      </if>
+      <if test="materialName != null">
+        MATERIAL_NAME,
+      </if>
+      <if test="specNo != null">
+        SPEC_NO,
+      </if>
+      <if test="specName != null">
+        SPEC_NAME,
+      </if>
+      <if test="loadPointNo != null">
+        LOAD_POINT_NO,
+      </if>
+      <if test="loadPointName != null">
+        LOAD_POINT_NAME,
+      </if>
+      <if test="sampleVoucher != null">
+        SAMPLE_VOUCHER,
+      </if>
+      <if test="carrierUnitNo != null">
+        CARRIER_UNIT_NO,
+      </if>
+      <if test="carrierUnitName != null">
+        CARRIER_UNIT_NAME,
+      </if>
+      <if test="meterTypeNo != null">
+        METER_TYPE_NO,
+      </if>
+      <if test="meterTypeName != null">
+        METER_TYPE_NAME,
+      </if>
+      <if test="meterProcessNo != null">
+        METER_PROCESS_NO,
+      </if>
+      <if test="meterProcessEditionNo != null">
+        METER_PROCESS_EDITION_NO,
+      </if>
+      <if test="actualFirst1No != null">
+        ACTUAL_FIRST1_NO,
+      </if>
+      <if test="grossWeight != null">
+        GROSS_WEIGHT,
+      </if>
+      <if test="grossManNo != null">
+        GROSS_MAN_NO,
+      </if>
+      <if test="grossManName != null">
+        GROSS_MAN_NAME,
+      </if>
+      <if test="grossTime != null">
+        GROSS_TIME,
+      </if>
+      <if test="baseSpot1No != null">
+        BASE_SPOT1_NO,
+      </if>
+      <if test="baseSpot1Name != null">
+        BASE_SPOT1_NAME,
+      </if>
+      <if test="grossClass != null">
+        GROSS_CLASS,
+      </if>
+      <if test="grossGroup != null">
+        GROSS_GROUP,
+      </if>
+      <if test="grossMode != null">
+        GROSS_MODE,
+      </if>
+      <if test="actualFirst2No != null">
+        ACTUAL_FIRST2_NO,
+      </if>
+      <if test="tareWeight != null">
+        TARE_WEIGHT,
+      </if>
+      <if test="tareManNo != null">
+        TARE_MAN_NO,
+      </if>
+      <if test="tareManName != null">
+        TARE_MAN_NAME,
+      </if>
+      <if test="tareTime != null">
+        TARE_TIME,
+      </if>
+      <if test="baseSpot2No != null">
+        BASE_SPOT2_NO,
+      </if>
+      <if test="baseSpot2Name != null">
+        BASE_SPOT2_NAME,
+      </if>
+      <if test="tareClass != null">
+        TARE_CLASS,
+      </if>
+      <if test="tareGroup != null">
+        TARE_GROUP,
+      </if>
+      <if test="tareMode != null">
+        TARE_MODE,
+      </if>
+      <if test="netWeight != null">
+        NET_WEIGHT,
+      </if>
+      <if test="netManNo != null">
+        NET_MAN_NO,
+      </if>
+      <if test="netManName != null">
+        NET_MAN_NAME,
+      </if>
+      <if test="netTime != null">
+        NET_TIME,
+      </if>
+      <if test="netSpot3No != null">
+        NET_SPOT3_NO,
+      </if>
+      <if test="netSpot3Name != null">
+        NET_SPOT3_NAME,
+      </if>
+      <if test="netClass != null">
+        NET_CLASS,
+      </if>
+      <if test="netGroup != null">
+        NET_GROUP,
+      </if>
+      <if test="netMode != null">
+        NET_MODE,
+      </if>
+      <if test="valueFlag != null">
+        VALUE_FLAG,
+      </if>
+      <if test="uploadFlag != null">
+        UPLOAD_FLAG,
+      </if>
+      <if test="checkManNo != null">
+        CHECK_MAN_NO,
+      </if>
+      <if test="checkManName != null">
+        CHECK_MAN_NAME,
+      </if>
+      <if test="checkTime != null">
+        CHECK_TIME,
+      </if>
+      <if test="uploadManNo != null">
+        UPLOAD_MAN_NO,
+      </if>
+      <if test="uploadManName != null">
+        UPLOAD_MAN_NAME,
+      </if>
+      <if test="uploadTime != null">
+        UPLOAD_TIME,
+      </if>
+      <if test="sampleNo != null">
+        SAMPLE_NO,
+      </if>
+      <if test="railwayTypeNo != null">
+        RAILWAY_TYPE_NO,
+      </if>
+      <if test="railwayTypeName != null">
+        RAILWAY_TYPE_NAME,
+      </if>
+      <if test="memo != null">
+        MEMO,
+      </if>
+      <if test="waterNum != null">
+        WATER_NUM,
+      </if>
+      <if test="arrival != null">
+        ARRIVAL,
+      </if>
+      <if test="station != null">
+        STATION,
+      </if>
+      <if test="updateManNo != null">
+        UPDATE_MAN_NO,
+      </if>
+      <if test="updateManName != null">
+        UPDATE_MAN_NAME,
+      </if>
+      <if test="updateTime != null">
+        UPDATE_TIME,
+      </if>
+      <if test="sourceArea != null">
+        SOURCE_AREA,
+      </if>
+    </trim>
+    <trim prefix="values (" suffix=")" suffixOverrides=",">
+      <if test="actualNo != null">
+        #{actualNo,jdbcType=VARCHAR},
+      </if>
+      <if test="predictionNo != null">
+        #{predictionNo,jdbcType=VARCHAR},
+      </if>
+      <if test="noticeNo != null">
+        #{noticeNo,jdbcType=VARCHAR},
+      </if>
+      <if test="railwayNo != null">
+        #{railwayNo,jdbcType=VARCHAR},
+      </if>
+      <if test="railwayCarriageNo != null">
+        #{railwayCarriageNo,jdbcType=VARCHAR},
+      </if>
+      <if test="matterNo != null">
+        #{matterNo,jdbcType=VARCHAR},
+      </if>
+      <if test="matterName != null">
+        #{matterName,jdbcType=VARCHAR},
+      </if>
+      <if test="contractNo != null">
+        #{contractNo,jdbcType=VARCHAR},
+      </if>
+      <if test="batchNo != null">
+        #{batchNo,jdbcType=VARCHAR},
+      </if>
+      <if test="customerSupplierNo != null">
+        #{customerSupplierNo,jdbcType=VARCHAR},
+      </if>
+      <if test="customerSupplierName != null">
+        #{customerSupplierName,jdbcType=VARCHAR},
+      </if>
+      <if test="forwardingUnitNo != null">
+        #{forwardingUnitNo,jdbcType=VARCHAR},
+      </if>
+      <if test="forwardingUnitName != null">
+        #{forwardingUnitName,jdbcType=VARCHAR},
+      </if>
+      <if test="receivingUintNo != null">
+        #{receivingUintNo,jdbcType=VARCHAR},
+      </if>
+      <if test="receivingUintName != null">
+        #{receivingUintName,jdbcType=VARCHAR},
+      </if>
+      <if test="materialNo != null">
+        #{materialNo,jdbcType=VARCHAR},
+      </if>
+      <if test="materialName != null">
+        #{materialName,jdbcType=VARCHAR},
+      </if>
+      <if test="specNo != null">
+        #{specNo,jdbcType=VARCHAR},
+      </if>
+      <if test="specName != null">
+        #{specName,jdbcType=VARCHAR},
+      </if>
+      <if test="loadPointNo != null">
+        #{loadPointNo,jdbcType=VARCHAR},
+      </if>
+      <if test="loadPointName != null">
+        #{loadPointName,jdbcType=VARCHAR},
+      </if>
+      <if test="sampleVoucher != null">
+        #{sampleVoucher,jdbcType=VARCHAR},
+      </if>
+      <if test="carrierUnitNo != null">
+        #{carrierUnitNo,jdbcType=VARCHAR},
+      </if>
+      <if test="carrierUnitName != null">
+        #{carrierUnitName,jdbcType=VARCHAR},
+      </if>
+      <if test="meterTypeNo != null">
+        #{meterTypeNo,jdbcType=VARCHAR},
+      </if>
+      <if test="meterTypeName != null">
+        #{meterTypeName,jdbcType=VARCHAR},
+      </if>
+      <if test="meterProcessNo != null">
+        #{meterProcessNo,jdbcType=VARCHAR},
+      </if>
+      <if test="meterProcessEditionNo != null">
+        #{meterProcessEditionNo,jdbcType=VARCHAR},
+      </if>
+      <if test="actualFirst1No != null">
+        #{actualFirst1No,jdbcType=VARCHAR},
+      </if>
+      <if test="grossWeight != null">
+        #{grossWeight,jdbcType=DECIMAL},
+      </if>
+      <if test="grossManNo != null">
+        #{grossManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="grossManName != null">
+        #{grossManName,jdbcType=VARCHAR},
+      </if>
+      <if test="grossTime != null">
+        #{grossTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="baseSpot1No != null">
+        #{baseSpot1No,jdbcType=VARCHAR},
+      </if>
+      <if test="baseSpot1Name != null">
+        #{baseSpot1Name,jdbcType=VARCHAR},
+      </if>
+      <if test="grossClass != null">
+        #{grossClass,jdbcType=VARCHAR},
+      </if>
+      <if test="grossGroup != null">
+        #{grossGroup,jdbcType=VARCHAR},
+      </if>
+      <if test="grossMode != null">
+        #{grossMode,jdbcType=VARCHAR},
+      </if>
+      <if test="actualFirst2No != null">
+        #{actualFirst2No,jdbcType=VARCHAR},
+      </if>
+      <if test="tareWeight != null">
+        #{tareWeight,jdbcType=DECIMAL},
+      </if>
+      <if test="tareManNo != null">
+        #{tareManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="tareManName != null">
+        #{tareManName,jdbcType=VARCHAR},
+      </if>
+      <if test="tareTime != null">
+        #{tareTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="baseSpot2No != null">
+        #{baseSpot2No,jdbcType=VARCHAR},
+      </if>
+      <if test="baseSpot2Name != null">
+        #{baseSpot2Name,jdbcType=VARCHAR},
+      </if>
+      <if test="tareClass != null">
+        #{tareClass,jdbcType=VARCHAR},
+      </if>
+      <if test="tareGroup != null">
+        #{tareGroup,jdbcType=VARCHAR},
+      </if>
+      <if test="tareMode != null">
+        #{tareMode,jdbcType=VARCHAR},
+      </if>
+      <if test="netWeight != null">
+        #{netWeight,jdbcType=DECIMAL},
+      </if>
+      <if test="netManNo != null">
+        #{netManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="netManName != null">
+        #{netManName,jdbcType=VARCHAR},
+      </if>
+      <if test="netTime != null">
+        #{netTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="netSpot3No != null">
+        #{netSpot3No,jdbcType=VARCHAR},
+      </if>
+      <if test="netSpot3Name != null">
+        #{netSpot3Name,jdbcType=VARCHAR},
+      </if>
+      <if test="netClass != null">
+        #{netClass,jdbcType=VARCHAR},
+      </if>
+      <if test="netGroup != null">
+        #{netGroup,jdbcType=VARCHAR},
+      </if>
+      <if test="netMode != null">
+        #{netMode,jdbcType=VARCHAR},
+      </if>
+      <if test="valueFlag != null">
+        #{valueFlag,jdbcType=VARCHAR},
+      </if>
+      <if test="uploadFlag != null">
+        #{uploadFlag,jdbcType=VARCHAR},
+      </if>
+      <if test="checkManNo != null">
+        #{checkManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="checkManName != null">
+        #{checkManName,jdbcType=VARCHAR},
+      </if>
+      <if test="checkTime != null">
+        #{checkTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="uploadManNo != null">
+        #{uploadManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="uploadManName != null">
+        #{uploadManName,jdbcType=VARCHAR},
+      </if>
+      <if test="uploadTime != null">
+        #{uploadTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="sampleNo != null">
+        #{sampleNo,jdbcType=VARCHAR},
+      </if>
+      <if test="railwayTypeNo != null">
+        #{railwayTypeNo,jdbcType=VARCHAR},
+      </if>
+      <if test="railwayTypeName != null">
+        #{railwayTypeName,jdbcType=VARCHAR},
+      </if>
+      <if test="memo != null">
+        #{memo,jdbcType=VARCHAR},
+      </if>
+      <if test="waterNum != null">
+        #{waterNum,jdbcType=DECIMAL},
+      </if>
+      <if test="arrival != null">
+        #{arrival,jdbcType=VARCHAR},
+      </if>
+      <if test="station != null">
+        #{station,jdbcType=VARCHAR},
+      </if>
+      <if test="updateManNo != null">
+        #{updateManNo,jdbcType=VARCHAR},
+      </if>
+      <if test="updateManName != null">
+        #{updateManName,jdbcType=VARCHAR},
+      </if>
+      <if test="updateTime != null">
+        #{updateTime,jdbcType=TIMESTAMP},
+      </if>
+      <if test="sourceArea != null">
+        #{sourceArea,jdbcType=VARCHAR},
+      </if>
+    </trim>
+  </insert>
 </mapper>

src/main/java/com/steerinfo/pretrack/prehookscale/controller/PreHookScaleController.java

@@ -143,4 +143,24 @@ public class PreHookScaleController extends BaseRESTfulController {
         return rm;
     }
 
+    @ApiOperation(value = "获取预报信息", notes = "根据车号获取预报信息")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "查询页数", dataType = "Integer"),
+            @ApiImplicitParam(name = "pageSize", value = "每页记录数", dataType = "Integer")
+    })
+    @GetMapping(value = "/selectPre")
+    public RESTfulResult selectPre(@RequestParam String railwayNo, Integer pageNum, Integer pageSize) {
+        RESTfulResult rm = failed();
+        try {
+            PageList<PreHookScale> pageInfo = preHookScaleService.selectPre(railwayNo, pageNum, pageSize);
+            return success(pageInfo);
+        } catch (MarkerMetException e) {
+            e.printStackTrace();
+            rm.setMessage(e.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！");
+        }
+        return rm;
+    }
 }

src/main/java/com/steerinfo/pretrack/prehookscale/mapper/PreHookScaleMapper.java

@@ -12,4 +12,10 @@ public interface PreHookScaleMapper extends IBaseMapper<PreHookScale, String> {
     List<PreHookScale> selectlist(String railwayNo);
 
     List<PreHookScale> selectLikeByRailwayNo(String railwayNo, String valueFlag);
+
+    int batchUpdateByIdsForIn(List<String> ids);
+
+    int batchUpdateByIdsForUsed(List<String> ids);
+
+    List<PreHookScale> selectPre(String railwayNo);
 }

src/main/java/com/steerinfo/pretrack/prehookscale/mapper/PreHookScaleMapper.xml

@@ -1544,4 +1544,31 @@
     </where>
     order by CREATE_TIME desc
   </select>
+
+  <select id="selectPre" parameterType="java.lang.String" resultMap="BaseResultMap">
+    <include refid="select"/>
+    where VALUE_FLAG = '1' or VALUE_FLAG = '4'
+    <if test="railwayNo != null and railwayNo != ''">
+      and RAILWAY_NO LIKE '%${railwayNo}'
+    </if>
+    order by CREATE_TIME desc
+  </select>
+
+  <update id="batchUpdateByIdsForIn" parameterType="java.util.List">
+    update PRE_HOOK_SCALE
+    set VALUE_FLAG = '4'
+    where PREDICTION_NO in
+    <foreach collection="list" item="id" open="(" close=")" separator=",">
+      #{id}
+    </foreach>
+  </update>
+
+  <update id="batchUpdateByIdsForUsed" parameterType="java.util.List">
+    update PRE_HOOK_SCALE
+    set VALUE_FLAG = '2'
+    where PREDICTION_NO in
+    <foreach collection="list" item="id" open="(" close=")" separator=",">
+      #{id}
+    </foreach>
+  </update>
 </mapper>

src/main/java/com/steerinfo/pretrack/prehookscale/service/IPreHookScaleService.java

@@ -28,5 +28,7 @@ public interface IPreHookScaleService extends IBaseService<PreHookScale, String>
 
     PageList<PreHookScale> selectlist(String railwayNo, Integer pageNum, Integer pageSize);
 
+    PageList<PreHookScale> selectPre(String railwayNo, Integer pageNum, Integer pageSize);
+
     PageList<PreHookScale> queryLikeForRailwayNo(Map<String, Object> var1, Integer var2, Integer var3);
 }

src/main/java/com/steerinfo/pretrack/prehookscale/service/impl/PreHookScaleServiceImpl.java

@@ -55,6 +55,18 @@ public class PreHookScaleServiceImpl extends BaseServiceImpl<PreHookScale, Strin
         return pageInfo;
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public PageList<PreHookScale> selectPre(String railwayNo, Integer pageNum, Integer pageSize) {
+        if (railwayNo == null && "".equals(railwayNo)) {
+            throw new MarkerMetException(500, "车号为空!!");
+        }
+        PageHelper.startPage(pageNum, pageSize);
+        List<PreHookScale> list = preHookScaleMapper.selectPre(railwayNo);
+        PageList pageInfo = new PageList(list);
+        return pageInfo;
+    }
+
     public PageList<PreHookScale> queryLikeForRailwayNo(Map<String, Object> parameters, Integer pageNum, Integer pageSize) {
         PageHelper.startPage(pageNum, pageSize);
         String railwayNo = (String) parameters.get("railwayNo");