后端修改

src/main/java/com/steerinfo/meterwork/meterworkcaractual/mapper/MeterWorkCarActualMapper.xml

@@ -3470,6 +3470,9 @@
   <select id="likeByDesc" parameterType="java.util.HashMap" resultMap="BaseResultMap">
     <include refid="select"/>
     <include refid="whereLike"/>
+    <if test="flag != null and flag != ''">
+      and value_flag != '0'
+    </if>
     order by net_time desc
   </select>
 

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

@@ -117,6 +117,23 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
         }
     }
 
+    @ApiOperation(value = "获取列表", notes = "分页模糊查询")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer")
+    })
+    //@RequiresPermissions("meterworkcaractualfirst:view")
+    @PostMapping(value = "/ApplikeByDesc")
+    public RESTfulResult ApplikeByDesc(@RequestBody HashMap parmas) {
+        try {
+            PageList<MeterWorkCarActualFirst> list = meterWorkCarActualFirstService.ApplikeByDesc(parmas, Integer.parseInt(parmas.get("pageNum").toString()), Integer.parseInt(parmas.get("pagesize").toString()));
+            return success(list);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
+
     @ApiOperation(value = "获取列表", notes = "分页模糊查询")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),

src/main/java/com/steerinfo/meterwork/meterworkcaractualfirst/mapper/MeterWorkCarActualFirstMapper.java

@@ -75,6 +75,7 @@ public interface MeterWorkCarActualFirstMapper extends IBaseMapper<MeterWorkCarA
     void repairPre(Map<String, Object> map);
 
     List<MeterWorkCarActualFirst> likeByDesc(Map<String, Object> params);
+    List<MeterWorkCarActualFirst> ApplikeByDesc(Map<String, Object> params);
 
     List<MeterWorkCarActualFirst> selectById(List<String> actualNoList);
 }

src/main/java/com/steerinfo/meterwork/meterworkcaractualfirst/mapper/MeterWorkCarActualFirstMapper.xml

@@ -2843,6 +2843,18 @@
   <select id="likeByDesc" parameterType="java.util.HashMap" resultMap="BaseResultMap">
     <include refid="select"/>
     <include refid="whereLike"/>
+    <if test="flag != null and flag != ''">
+      and value_flag != '0'
+    </if>
+    order by create_time desc
+  </select>
+
+  <select id="likeByDesc" parameterType="java.util.HashMap" resultMap="BaseResultMap">
+    <include refid="select"/>
+    <include refid="whereLike"/>
+    <if test="flag != null and flag != ''">
+      and value_flag != '0'
+    </if>
     order by create_time desc
   </select>
 </mapper>

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

@@ -126,6 +126,7 @@ public interface IMeterWorkCarActualFirstService extends IBaseService<MeterWorkC
     RESTfulResult addEmergency(List<MeterWorkCarActualFirst> meterWorkCarActualFirsts)  throws Exception;
 
     PageList<MeterWorkCarActualFirst> likeByDesc(Map<String, Object> var1, Integer pageNum, Integer pageSize);
+    PageList<MeterWorkCarActualFirst> ApplikeByDesc(Map<String, Object> var1, Integer pageNum, Integer pageSize);
 
     RESTfulResult doNetByFirst(MeterWorkCarActualFirst grossModel, MeterWorkCarActualFirst tareModel, PreTrackScale scale);
 

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

@@ -60,6 +60,7 @@ import com.steerinfo.util.HttpRequest;
 import com.steerinfo.util.StringUtils;
 import io.micrometer.core.instrument.Meter;
 import oracle.jdbc.proxy.annotation.Pre;
+import org.apache.shiro.crypto.hash.Hash;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Scheduled;
@@ -3759,6 +3760,34 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         return pageInfo;
     }
 
+    @Override
+    public PageList<MeterWorkCarActualFirst> ApplikeByDesc(Map<String, Object> params, Integer pageNum, Integer pageSize) {
+        PageHelper.startPage(pageNum, pageSize);
+        List<MeterWorkCarActualFirst> rows = meterWorkCarActualFirstMapper.likeByDesc(params);
+        //移除所有期限皮数据
+
+        for(int i = 0; i < rows.size(); i++){
+            if(rows.get(0).getWeightType().equals("2")) {
+                rows.remove(i);
+            }
+        }
+        params.put("weightType", "2");
+        List<MeterWorkCarActualFirst> firstList = meterWorkCarActualFirstMapper.likeByDesc(params);
+        rows.add(firstList.get(0));
+
+        /*Collections.sort(rows, new Comparator<MeterWorkCarActualFirst>() {
+            @Override
+            public int compare(MeterWorkCarActualFirst o1, MeterWorkCarActualFirst o2) {
+                //这里使用时间字段排序 如果要用其他字段直接从bean实体中取
+                return o2.getCreateTime().compareTo(o1.getCreateTime());
+                //上面使用的是降序排序，如果正序 直接使用o1-o2即可
+            }
+        });*/
+
+        PageList pageInfo = new PageList(rows);
+        return pageInfo;
+    }
+
     @Override
     @Transactional(value = "tm", rollbackFor = Exception.class)
     public RESTfulResult doNetAddMuch(MeterWorkCarActualFirst actualFirst) throws Exception {

src/main/java/com/steerinfo/meterwork/meterworkrailwayactfirst/controller/MeterWorkRailwayActFirstController.java

@@ -25,6 +25,7 @@ import com.steerinfo.meterwork.meterworkrailwayreceived.model.MeterWorkRailwayRe
 import com.steerinfo.pretrack.prerailwayscale.model.PreRailwayScale;
 import com.steerinfo.pretrack.pretrackscale.model.PreTrackScale;
 import com.steerinfo.util.StringUtils;
+import io.micrometer.core.instrument.Meter;
 import io.swagger.annotations.ApiImplicitParam;
 import io.swagger.annotations.ApiImplicitParams;
 import io.swagger.annotations.ApiOperation;
@@ -829,6 +830,20 @@ throw new MarkerMetException(500, "操作异常！！");
         }
     }
 
+    @ApiOperation(value = "智能终端混装混卸--智能计量(记录)")
+    @Transactional
+    @PostMapping(value = "/doAddNetHZHXTwo", produces = "application/json;charset=UTF-8")
+    public RESTfulResult doAddNetHZHXTwo(@RequestBody CommonCombination<PreRailwayScale, MeterWorkRailwayActFirst,MeterWorkRailwayActFirst, MeterMonitorNote> com) {
+        try {
+            RESTfulResult rm = meterWorkRailwayActFirstService.doAddNetHZHXTwo(com.getOne(), com.getTwo(), com.getThree(), com.getFour(), com.getSOne());
+            return rm;
+        } catch (Exception e) {
+            e.printStackTrace();
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return failed(null, "操作异常，请确认！");
+        }
+    }
+
     @ApiOperation(value = "双委托洁净--远程计量")
     @Transactional
     @PostMapping(value = "/doNetAddTwo", produces = "application/json;charset=UTF-8")
@@ -843,6 +858,20 @@ throw new MarkerMetException(500, "操作异常！！");
         }
     }
 
+    @ApiOperation(value = "双委托洁净--智能计量(记录)")
+    @Transactional
+    @PostMapping(value = "/doNetAddTwoDouble", produces = "application/json;charset=UTF-8")
+    public RESTfulResult doNetAddTwoDouble(@RequestBody CommonCombination<PreRailwayScale, PreRailwayScale, MeterWorkRailwayActFirst, MeterWorkRailwayActFirst> com) {
+        try {
+            RESTfulResult rm = meterWorkRailwayActFirstService.doNetAddTwoDouble(com.getOne(), com.getTwo(), com.getThree(), com.getFour());
+            return rm;
+        } catch (Exception e) {
+            e.printStackTrace();
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return failed(null, "操作异常，请确认！");
+        }
+    }
+
     @ApiOperation(value = "轨道衡双委托匹配洁净", notes = "轨道衡双委托匹配洁净")
     //@RequiresPermissions("meterworkcaractual:view")
     @PostMapping(value = "/doubleEntrustMatch")

src/main/java/com/steerinfo/meterwork/meterworkrailwayactfirst/service/IMeterWorkRailwayActFirstService.java

@@ -97,6 +97,9 @@ public interface IMeterWorkRailwayActFirstService extends IBaseService<MeterWork
     RESTfulResult doAddNetHZHX(MeterWorkRailwayActFirst first02, MeterWorkRailwayActual carModel, MeterWorkRailwayActFirst first03,  MeterMonitorNote note);
     RESTfulResult doNetAddTwo(MeterWorkRailwayActFirst one, MeterWorkRailwayActual two, PreRailwayScale three, PreRailwayScale four);
 
+    RESTfulResult doAddNetHZHXTwo(PreRailwayScale scale, MeterWorkRailwayActFirst first01, MeterWorkRailwayActFirst first02,  MeterMonitorNote note, String flag);
+    RESTfulResult doNetAddTwoDouble(PreRailwayScale scale01, PreRailwayScale scale02,  MeterWorkRailwayActFirst first01, MeterWorkRailwayActFirst first02);
+
     String doubleEntrustMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2);
     String mixedLoading(String actualNo1, String actualNo2, String actualNo3, String predictionNo1,String predictionNo2);
     String mixedDischarge(String actualNo1, String actualNo2, String actualNo3, String predictionNo1, String predictionNo2);

src/main/java/com/steerinfo/meterwork/meterworkrailwayactfirst/service/impl/MeterWorkRailwayActFirstServiceImpl.java

@@ -936,6 +936,622 @@ public class MeterWorkRailwayActFirstServiceImpl extends BaseServiceImpl<MeterWo
         }
     }
 
+    @Override
+    public RESTfulResult doAddNetHZHXTwo(PreRailwayScale scale, MeterWorkRailwayActFirst first01, MeterWorkRailwayActFirst first02, MeterMonitorNote note, String flag) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+
+        HashMap<String, Object> map = new HashMap<>();
+        List<MeterWorkRailwayActFirst> firsts = new ArrayList<>();
+        List<MeterWorkRailwayActual> actuals = new ArrayList<>();
+        try {
+
+            if(StringUtils.isEmpty(scale.getPredictionNo())){
+                //获取两个一次重量的差值
+                BigDecimal num01 = first01.getMeterWeight().subtract(first02.getMeterWeight()).abs();
+                //判断两个一次车辆是否一致
+                if(!first01.getRailwayNo().equals(first02.getRailwayNo())){
+                    rm.setMessage("两条一次计量数据车号不一致,请确认！！");
+                    return rm;
+                }
+                //洁净数据不能小于400
+                if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
+                    rm.setMessage("选择的两条一次计量数据不能小于400kg，请确认！！");
+                    return rm;
+                }
+                //一次数据是否为有效
+                if(first01.getValueFlag().equals("2") || first01.getValueFlag().equals("0")){
+                    rm.setMessage("选择的一次计量数据已作废或者已洁净，请确认！！");
+                    return rm;
+                }
+
+                SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+                String afl = sdf.format(new Date());
+
+                //存储当前计量的数据
+                String firstNo01 = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+                first02.setActualFirstNo(firstNo01);
+                meterWorkRailwayActFirstMapper.insertSelective(first02);
+
+                MeterWorkRailwayActual actualRow = new MeterWorkRailwayActual();
+                MeterWorkRailwayActFirst model01 = new MeterWorkRailwayActFirst();
+                MeterWorkRailwayActFirst model02 = new MeterWorkRailwayActFirst();
+
+                //判断当前一次重量类型、0：毛重，则为混装操作、1：常规皮重，则为混卸操作
+                if (first01.getWeightType().equals("1")) {      //混装
+                    //毛重一次
+                    model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+                    //皮重一次
+                    model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+
+                    //修改委托状态
+                    //将委托中的编号和收发货的等数据拷贝进一次数据中
+                    /*MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first1, model01);
+                    MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first2, model02);*/
+
+                    //修改委托编号
+                    scale.setValueFlag(DbConstants.NET);
+                    scale.setUpdateTime(new Date());
+                    scale.setUpdateManNo("system");
+                    scale.setUpdateManName("智能计量混装洁净更新");
+                    scale.setUploadFlag("1");
+                    scale.setPredictionType("7");
+                    preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+                    //修改毛重一次数据状态
+                    model01.setValueFlag(DbConstants.NET);
+                    model01.setUpdateManName("system");
+                    model01.setUpdateManName("智能计量混装洁净更新");
+                    model01.setUpdateTime(new Date());
+                    model01.setWeightType("0");
+                    model01.setIsPreSacale("0");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model01);
+                    //修改皮重一次数据状态
+                    model02.setValueFlag(DbConstants.NET);
+                    model02.setUpdateManName("system");
+                    model02.setUpdateManName("智能计量混装洁净更新");
+                    model02.setUpdateTime(new Date());
+                    model02.setWeightType("1");
+                    model02.setIsPreSacale("0");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model02);
+
+                    MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAdd(model01.getActualFirstNo(), model02.getActualFirstNo());
+                    BeanUtils.copyProperties(mwca1, actualRow);
+                    //保存洁净
+                    String no = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+                    actualRow.setActualNo(sdf.format(new Date()) + no);
+                    actualRow.setNetTime(new Date());
+                    actualRow.setNetMode(DbConstants.TYPE);
+                    actualRow.setNote("智能计量混装匹配洁净");
+                    actualRow.setNetMode("4");
+                    actualRow.setUploadFlag("1");
+                    actualRow.setValueFlag("1");
+                    actualRow.setIsPreSacale("0");
+                    meterWorkRailwayActualMapper.insertSelective(actualRow);
+
+                } else if (first01.getWeightType().equals("0")) {         //混卸
+                    //毛重一次
+                    model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+                    //皮重一次
+                    model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+
+                    //修改委托状态
+                    //将委托中的编号和收发货的等数据拷贝进一次数据中
+                    /*MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first1, model01);
+                    MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first2, model02);*/
+
+                    //修改委托编号
+                    scale.setValueFlag(DbConstants.NET);
+                    scale.setUpdateTime(new Date());
+                    scale.setUpdateManNo("system");
+                    scale.setUpdateManName("智能计量混卸洁净更新");
+                    scale.setUploadFlag("1");
+                    scale.setPredictionType("6");
+                    preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+                    //修改毛重一次数据状态
+                    model01.setValueFlag(DbConstants.NET);
+                    model01.setUpdateManName("system");
+                    model01.setUpdateManName("智能计量混卸洁净更新");
+                    model01.setUpdateTime(new Date());
+                    model01.setWeightType("0");
+                    model01.setIsPreSacale("0");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model01);
+                    //修改皮重一次数据状态
+                    model02.setValueFlag(DbConstants.NET);
+                    model02.setUpdateManName("system");
+                    model02.setUpdateManName("智能计量混卸洁净更新");
+                    model02.setUpdateTime(new Date());
+                    model02.setWeightType("1");
+                    model02.setIsPreSacale("0");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model02);
+
+                    MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAdd(model01.getActualFirstNo(), model02.getActualFirstNo());
+                    BeanUtils.copyProperties(mwca1, actualRow);
+
+                    //保存洁净
+                    String no = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+                    actualRow.setActualNo(sdf.format(new Date()) + no);
+                    actualRow.setNetTime(new Date());
+                    actualRow.setNetMode(DbConstants.TYPE);
+                    actualRow.setNote("智能计量混卸匹配洁净");
+                    actualRow.setNetMode("6");
+                    actualRow.setUploadFlag("1");
+                    actualRow.setValueFlag("1");
+                    actualRow.setIsPreSacale("0");
+                    meterWorkRailwayActualMapper.insertSelective(actualRow);
+                }
+
+                //存储当前计量的数据
+                if(flag.equals("0")) {
+                    if(first01.getWeightType().equals("0")) {
+                        first02.setUpdateManName("system");
+                        first02.setUpdateManName("智能计量混卸一次复制");
+                    }else {
+                        first02.setUpdateManName("system");
+                        first02.setUpdateManName("智能计量混装一次复制");
+                    }
+                    String firstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+                    first02.setActualFirstNo(firstNo);
+                    first02.setPredictionNo("混装混卸复制");
+                    first02.setValueFlag("1");
+                    meterWorkRailwayActFirstMapper.insertSelective(first02);
+                }else {
+                    first02.setPredictionNo("");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(first02);
+                }
+            /*//6、修改计量监控
+            updateMonitor(first02.getBaseSpotNo());
+            //保存日志
+            saveNote(note);
+            updateMonitorOver(first02.getActualFirstNo(), first02.getBaseSpotNo());
+
+            //补充附加重量的数据
+            if (StringUtils.isNotEmpty(first02.getAddWgtPk())) {
+                insertAddWgtNo(first02.getActualFirstNo(), first02.getAddWgtPk(), first02.getCreateManNo(), first02.getCreateManName());
+            }*/
+                firsts.add(first02);
+                actuals.add(actualRow);
+                map.put("firsts", firsts);
+                map.put("actuals", actuals);
+
+                rm.setSucceed();
+                rm.setData(map);
+                rm.setCode("200");
+                rm.setMessage("操作成功！！");
+                return rm;
+            }else {
+                if(scale == null){
+                    rm.setMessage("未找到相应的委托信息,请确认！！");
+                    return rm;
+                }else {
+                    //委托信息是否为有效数据
+                    if(scale.getValueFlag().equals("2") || scale.getValueFlag().equals("3")){
+                        rm.setMessage("委托信息已使用或者已作废！！");
+                        return rm;
+                    }
+                }
+                //获取两个一次重量的差值
+                BigDecimal num01 = first01.getMeterWeight().subtract(first02.getMeterWeight()).abs();
+                //判断两个一次车辆是否一致
+                if(!first01.getRailwayNo().equals(first02.getRailwayNo())){
+                    rm.setMessage("两条一次计量数据车号不一致,请确认！！");
+                    return rm;
+                }
+                //洁净数据不能小于400
+                if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
+                    rm.setMessage("选择的两条一次计量数据不能小于400kg，请确认！！");
+                    return rm;
+                }
+                //一次数据是否为有效
+                if(first01.getValueFlag().equals("2") || first01.getValueFlag().equals("0")){
+                    rm.setMessage("选择的一次计量数据已作废或者已洁净，请确认！！");
+                    return rm;
+                }
+
+                SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+                String afl = sdf.format(new Date());
+
+                //存储当前计量的数据
+                String firstNo01 = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+                first02.setActualFirstNo(firstNo01);
+                meterWorkRailwayActFirstMapper.insertSelective(first02);
+
+                MeterWorkRailwayActual actualRow = new MeterWorkRailwayActual();
+                MeterWorkRailwayActFirst model01 = new MeterWorkRailwayActFirst();
+                MeterWorkRailwayActFirst model02 = new MeterWorkRailwayActFirst();
+
+                //判断当前一次重量类型、0：毛重，则为混装操作、1：常规皮重，则为混卸操作
+                if (first01.getWeightType().equals("1")) {      //混装
+                    //毛重一次
+                    model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+                    //皮重一次
+                    model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+
+                    //修改委托状态
+                    //将委托中的编号和收发货的等数据拷贝进一次数据中
+                    MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first1, model01);
+                    MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first2, model02);
+
+                    //修改委托编号
+                    scale.setValueFlag(DbConstants.NET);
+                    scale.setUpdateTime(new Date());
+                    scale.setUpdateManNo("system");
+                    scale.setUpdateManName("智能计量混装洁净更新");
+                    scale.setUploadFlag("1");
+                    scale.setPredictionType("7");
+                    preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+                    //修改毛重一次数据状态
+                    model01.setValueFlag(DbConstants.NET);
+                    model01.setUpdateManName("system");
+                    model01.setUpdateManName("智能计量混装洁净更新");
+                    model01.setUpdateTime(new Date());
+                    model01.setWeightType("0");
+                    model01.setIsPreSacale("1");
+                    model01.setPredictionNo(scale.getPredictionNo());
+                    model01.setPredictionType("7");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model01);
+                    //修改皮重一次数据状态
+                    model02.setValueFlag(DbConstants.NET);
+                    model02.setUpdateManName("system");
+                    model02.setUpdateManName("智能计量混装洁净更新");
+                    model02.setUpdateTime(new Date());
+                    model02.setWeightType("1");
+                    model02.setIsPreSacale("1");
+                    model02.setPredictionNo(scale.getPredictionNo());
+                    model02.setPredictionType("7");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model02);
+
+                    MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(model01.getActualFirstNo(), model02.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(mwca1, actualRow);
+                    //保存洁净
+                    String no = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+                    actualRow.setActualNo(sdf.format(new Date()) + no);
+                    actualRow.setNetTime(new Date());
+                    actualRow.setNetMode(DbConstants.TYPE);
+                    actualRow.setNote("智能计量混装匹配洁净");
+                    actualRow.setNetMode("4");
+                    actualRow.setUploadFlag("1");
+                    actualRow.setValueFlag("1");
+                    actualRow.setIsPreSacale("1");
+                    actualRow.setPredictionNo(scale.getPredictionNo());
+                    actualRow.setPredictionType("7");
+                    actualRow.setNetWeight(model01.getMeterWeight().subtract(model02.getMeterWeight()));
+                    meterWorkRailwayActualMapper.insertSelective(actualRow);
+
+                } else if (first01.getWeightType().equals("0")) {         //混卸
+                    //毛重一次
+                    model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+                    //皮重一次
+                    model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+
+                    //修改委托状态
+                    //将委托中的编号和收发货的等数据拷贝进一次数据中
+                    MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first1, model01);
+                    MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale.getPredictionNo());
+                    BeanUtils.copyProperties(first2, model02);
+
+                    //修改委托编号
+                    scale.setValueFlag(DbConstants.NET);
+                    scale.setUpdateTime(new Date());
+                    scale.setUpdateManNo("system");
+                    scale.setUpdateManName("智能计量混卸洁净更新");
+                    scale.setUploadFlag("1");
+                    scale.setPredictionType("6");
+                    preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+                    //修改毛重一次数据状态
+                    model01.setValueFlag(DbConstants.NET);
+                    model01.setUpdateManName("system");
+                    model01.setUpdateManName("智能计量混卸洁净更新");
+                    model01.setUpdateTime(new Date());
+                    model01.setWeightType("0");
+                    model01.setIsPreSacale("1");
+                    model01.setPredictionNo(scale.getPredictionNo());
+                    model01.setPredictionType("6");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model01);
+                    //修改皮重一次数据状态
+                    model02.setValueFlag(DbConstants.NET);
+                    model02.setUpdateManName("system");
+                    model02.setUpdateManName("智能计量混卸洁净更新");
+                    model02.setUpdateTime(new Date());
+                    model02.setWeightType("1");
+                    model02.setIsPreSacale("1");
+                    model02.setPredictionNo(scale.getPredictionNo());
+                    model02.setPredictionType("6");
+                    meterWorkRailwayActFirstMapper.updateByPrimaryKeySelective(model02);
+
+                    MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(model01.getActualFirstNo(), model02.getActualFirstNo(),  scale.getPredictionNo());
+                    BeanUtils.copyProperties(mwca1, actualRow);
+
+                    //保存洁净
+                    String no = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+                    actualRow.setActualNo(sdf.format(new Date()) + no);
+                    actualRow.setNetTime(new Date());
+                    actualRow.setNetMode(DbConstants.TYPE);
+                    actualRow.setNote("智能计量混卸匹配洁净");
+                    actualRow.setNetMode("5");
+                    actualRow.setUploadFlag("1");
+                    actualRow.setValueFlag("1");
+                    actualRow.setIsPreSacale("1");
+                    actualRow.setPredictionNo(scale.getPredictionNo());
+                    actualRow.setPredictionType("6");
+                    actualRow.setNetWeight(model01.getMeterWeight().subtract(model02.getMeterWeight()));
+                    meterWorkRailwayActualMapper.insertSelective(actualRow);
+                }
+
+                //存储当前计量的数据
+                if(flag.equals("0")) {
+                    if(first01.getWeightType().equals("0")) {
+                        first02.setUpdateManName("system");
+                        first02.setUpdateManName("智能计量混卸一次复制");
+                    }else {
+                        first02.setUpdateManName("system");
+                        first02.setUpdateManName("智能计量混装一次复制");
+                    }
+                    String firstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+                    first02.setActualFirstNo(firstNo);
+                    first02.setPredictionNo("混装混卸复制");
+                    first02.setValueFlag("1");
+                    meterWorkRailwayActFirstMapper.insertSelective(first02);
+                }
+            /*//6、修改计量监控
+            updateMonitor(first02.getBaseSpotNo());
+            //保存日志
+            saveNote(note);
+            updateMonitorOver(first02.getActualFirstNo(), first02.getBaseSpotNo());
+
+            //补充附加重量的数据
+            if (StringUtils.isNotEmpty(first02.getAddWgtPk())) {
+                insertAddWgtNo(first02.getActualFirstNo(), first02.getAddWgtPk(), first02.getCreateManNo(), first02.getCreateManName());
+            }*/
+                firsts.add(first02);
+                actuals.add(actualRow);
+                map.put("firsts", firsts);
+                map.put("actuals", actuals);
+
+                rm.setSucceed();
+                rm.setData(map);
+                rm.setCode("200");
+                rm.setMessage("操作成功！！");
+                return rm;
+            }
+        }catch(Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！！>>>>" + e.getMessage());
+            return rm;
+        }
+    }
+
+    @Override
+    public RESTfulResult doNetAddTwoDouble(PreRailwayScale scale01, PreRailwayScale scale02, MeterWorkRailwayActFirst first01, MeterWorkRailwayActFirst first02) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+
+        HashMap<String, Object> map = new HashMap<>();
+        List<MeterWorkRailwayActFirst> firsts = new ArrayList<>();
+        List<MeterWorkRailwayActual> actuals = new ArrayList<>();
+        try{
+            if(scale01 == null || scale02 == null){
+                rm.setMessage("未找到相应的委托信息,请确认！！");
+                return rm;
+            }else {
+                //委托信息是否为有效数据
+                if(scale01.getValueFlag().equals("2") || scale02.getValueFlag().equals("2")){
+                    rm.setMessage("委托信息已使用！！");
+                    return rm;
+                }
+                if(scale01.getValueFlag().equals("3") || scale02.getValueFlag().equals("3")){
+                    rm.setMessage("委托信息已作废！！");
+                    return rm;
+                }
+                //判断双委托 物料相同、A委托的收货单位是B委托的发货单位 或者 B委托的收货单位是A委托的发货货单位
+                if(!(scale01.getMatterNo().equals(scale02.getMatterNo()) &&
+                        (scale01.getReceivingUintNo().equals(scale02.getForwardingUnitNo()) ||
+                                scale01.getForwardingUnitNo().equals(scale02.getReceivingUintNo())))) {
+                    rm.setMessage("委托信息不符合双委托规则，请确认!!");
+                    return rm;
+                }
+            }
+            //获取两个一次重量的差值
+            BigDecimal num01 = first01.getMeterWeight().subtract(first02.getMeterWeight()).abs();
+            //判断两个一次车辆是否一致
+            if(!first01.getRailwayNo().equals(first02.getRailwayNo())){
+                rm.setMessage("两条一次计量数据车号不一致,请确认！！");
+                return rm;
+            }
+            //洁净数据不能小于400
+            if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
+                rm.setMessage("选择的两条一次计量数据不能小于400kg，请确认！！");
+                return rm;
+            }
+            //一次数据是否为有效
+            if(first01.getValueFlag().equals("2") || first01.getValueFlag().equals("0")){
+                rm.setMessage("选择的一次计量数据已作废或者已洁净，请确认！！");
+                return rm;
+            }
+
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            String afl = sdf.format(new Date());
+
+            //存储当前计量的数据
+            String firstNo01 = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            first02.setActualFirstNo(firstNo01);
+            meterWorkRailwayActFirstMapper.insertSelective(first02);
+
+            MeterWorkRailwayActFirst model01 = new MeterWorkRailwayActFirst();
+            MeterWorkRailwayActFirst model02 = new MeterWorkRailwayActFirst();
+
+            MeterWorkRailwayActual actualRow1 = new MeterWorkRailwayActual();
+            MeterWorkRailwayActual actualRow2 = new MeterWorkRailwayActual();
+            if(first01.getWeightType().equals("0")){
+                //毛重一次
+                model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+                //皮重一次
+                model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+            }else if(first01.getWeightType().equals("1")) {
+                //毛重一次
+                model01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first02.getActualFirstNo());
+                //皮重一次
+                model02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(first01.getActualFirstNo());
+            }
+
+            MeterWorkRailwayActFirst model03 = new MeterWorkRailwayActFirst();
+            MeterWorkRailwayActFirst model04 = new MeterWorkRailwayActFirst();
+
+            //将委托中的编号和收发货的等数据拷贝进一次数据中
+            MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(first1,model01);
+            MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(first2, model02);
+            MeterWorkRailwayActFirst first3 = meterWorkRailwayActFirstMapper.selectAndMatch(model01.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(first3,model03);
+            MeterWorkRailwayActFirst first4 = meterWorkRailwayActFirstMapper.selectAndMatch(model02.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(first4, model04);
+
+            //更新预报数据
+            scale01.setValueFlag(DbConstants.NET);
+            scale01.setUpdateTime(new Date());
+            scale01.setUpdateManNo("system");
+            scale01.setUpdateManName("智能计量双委托洁净更新");
+            scale01.setUploadFlag("1");
+            scale01.setPredictionType("5");
+            scale01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale01);
+
+            scale02.setValueFlag(DbConstants.NET);
+            scale02.setUpdateTime(new Date());
+            scale02.setUpdateManNo("system");
+            scale02.setUpdateManName("智能计量双委托洁净更新");
+            scale02.setUploadFlag("1");
+            scale02.setPredictionType("5");
+            scale02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale02);
+
+            //更新一次数据
+            //更新第一次毛重数据库
+            model01.setValueFlag(DbConstants.NET);
+            model01.setUpdateManName("system");
+            model01.setUpdateManName("智能计量双委托洁净更新");
+            model01.setUpdateTime(new Date());
+            model01.setWeightType("0");
+            model01.setIsPreSacale("1");
+            model01.setPredictionNo(scale01.getPredictionNo());
+            model01.setPredictionType("5");
+            model01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(model01);
+            //更新第一次皮重数据库
+            model02.setValueFlag(DbConstants.NET);
+            model02.setUpdateManName("system");
+            model02.setUpdateManName("智能计量双委托洁净更新");
+            model02.setUpdateTime(new Date());
+            model02.setWeightType("1");
+            model02.setIsPreSacale("1");
+            model02.setPredictionNo(scale01.getPredictionNo());
+            model02.setPredictionType("5");
+            model02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(model02);
+            //添加第一次毛重数据库
+            String actualFirstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            model03.setActualFirstNo(actualFirstNo);
+            model03.setValueFlag(DbConstants.NET);
+            model03.setUpdateManName("system");
+            model03.setUpdateManName("智能计量双委托洁净更新");
+            model03.setWeightType("0");
+            model03.setUpdateTime(new Date());
+            model03.setIsPreSacale("1");
+            model03.setPredictionNo(scale02.getPredictionNo());
+            model03.setPredictionType("5");
+            model03.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkRailwayActFirstMapper.insertSelective(model03);
+            //添加第二次皮重数据库
+            String actualSecondNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            model04.setActualFirstNo(actualSecondNo);
+            model04.setValueFlag(DbConstants.NET);
+            model04.setUpdateManName("system");
+            model04.setUpdateManName("智能计量双委托洁净更新");
+            model04.setWeightType("1");
+            model04.setUpdateTime(new Date());
+            model04.setIsPreSacale("1");
+            model04.setPredictionNo(scale02.getPredictionNo());
+            model04.setPredictionType("5");
+            model04.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkRailwayActFirstMapper.insertSelective(model04);
+
+            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+            MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(model01.getActualFirstNo(), model02.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(mwca1, actualRow1);
+            MeterWorkRailwayActual mwca2 = meterWorkRailwayActualMapper.manualAddPre(model03.getActualFirstNo(), model04.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(mwca2, actualRow2);
+
+            //添加结净数据
+            String no = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+            actualRow1.setActualNo(sdf.format(new Date()) + no);
+            actualRow1.setNetTime(new Date());
+            actualRow1.setNetMode(DbConstants.TYPE);
+            actualRow1.setNote("智能计量双委托匹配洁净");
+            actualRow1.setNetMode("3");
+            actualRow1.setUploadFlag("1");
+            actualRow1.setValueFlag("1");
+            actualRow1.setIsPreSacale("1");
+            actualRow1.setPredictionNo(scale01.getPredictionNo());
+            actualRow1.setPredictionNo(scale01.getPredictionNo());
+            actualRow1.setPredictionType("5");
+            actualRow1.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            actualRow1.setNetWeight(model01.getMeterWeight().subtract(model02.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow1);
+
+            String no1 = meterWorkRailwayActualMapper.getNewID(sdf.format(new Date()));
+            actualRow2.setActualNo(sdf.format(new Date()) + no1);
+            actualRow2.setNetTime(new Date());
+            actualRow2.setNetMode(DbConstants.TYPE);
+            actualRow2.setNote("智能计量双委托匹配洁净");
+            actualRow2.setNetMode("3");
+            actualRow2.setValueFlag("1");
+            actualRow2.setUploadFlag("1");
+            actualRow2.setIsPreSacale("1");
+            actualRow2.setPredictionNo(scale02.getPredictionNo());
+            actualRow2.setPredictionType("5");
+            actualRow2.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            actualRow2.setNetWeight(model03.getMeterWeight().subtract(model04.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow2);
+
+            /*//11、修改计量监控
+            updateMonitor(one.getBaseSpotNo());
+            //12、当存储一次数据或者结净时，将本车辆的预处理重量改为已使用
+            updatePreWeight(one.getCarNo());
+            updateMonitorOver(one.getActualFirstNo(), one.getBaseSpotNo());
+            //补充附加重量的数据
+            if (StringUtils.isNotEmpty(one.getAddWgtPk())) {
+                insertAddWgtNo(one.getActualFirstNo(), one.getAddWgtPk(), one.getCreateManNo(), one.getCreateManName());
+            }*/
+            firsts.add(model01);
+            firsts.add(model02);
+            actuals.add(actualRow1);
+            actuals.add(actualRow2);
+            map.put("firsts", firsts);
+            map.put("actuals", actuals);
+
+            rm.setSucceed();
+            rm.setData(map);
+            rm.setCode("200");
+            rm.setMessage("操作成功！！");
+            return rm;
+        }catch(Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！！>>>>" + e.getMessage());
+            return rm;
+        }
+    }
+
     @Override
     public String doubleEntrustMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2) {
 
@@ -966,7 +1582,7 @@ public class MeterWorkRailwayActFirstServiceImpl extends BaseServiceImpl<MeterWo
             //判断双委托 物料相同、A委托的收货单位是B委托的发货单位 或者 B委托的收货单位是A委托的发货单位
             if(!(pts01.getMatterNo().equals(pts02.getMatterNo()) &&
                     (pts01.getReceivingUintNo().equals(pts02.getForwardingUnitNo()) ||
-                            pts02.getForwardingUnitNo().equals(pts01.getReceivingUintNo())))) {
+                            pts01.getForwardingUnitNo().equals(pts02.getReceivingUintNo())))) {
                 return "委托信息不符合双委托规则，请确认!!";
             }