后端修改

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

@@ -134,6 +134,21 @@ public class MeterBaseCarController extends BaseRESTfulController {
         return success(meterBaseCar);
     }
 
+    @ApiOperation(value = "APP修改车辆信息", notes = "根据MeterBaseCar对象创建")
+    @ApiImplicitParam(name = "meterBaseCar", value = "详细实体meterBaseCar", required = true, dataType = "MeterBaseCar")
+    @PostMapping(value = "/updateCar")
+    public RESTfulResult updateCar(@RequestBody MeterBaseCar model) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+        try{
+            rm = meterBaseCarService.updateCar(model);
+        }catch(Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，" + rm.getMessage());
+        }
+        return rm;
+    }
+
     @ApiOperation(value = "获取详细信息", notes = "根据url的id来获取详细信息")
     @ApiImplicitParam(paramType = "path", name = "id", value = "ID", required = true, dataType = "String")
     //@RequiresPermissions("meterbasecar:view")
@@ -242,12 +257,18 @@ public class MeterBaseCarController extends BaseRESTfulController {
         try {
             SSOUtil ssoUtil = new SSOUtil();
             HashMap ssoMap = ssoUtil.ssoRegister(params);
-            // sso注册成功或者没有注册成功都新增车辆和司机信息
-            if (ssoMap.get("code").equals("1") && !"账号已被注册".equals(ssoMap.get("msg").toString()) && false) {
+
+            String carNo = params.get("carNo").toString();
+            HashMap queryCarMap = new HashMap();
+            queryCarMap.put("carNo", carNo);
+            queryCarMap.put("validFlag", "0");
+            //查询服役状态的车辆信息
+            List<MeterBaseCar> carList = meterBaseCarService.query(queryCarMap);
+            // sso注册成功或者没有注册成功都新增车辆和司机信息(保证测试机也能注册，并且车辆停役的也能启用)
+            if (ssoMap.get("code").equals("1") && "账号已被注册".equals(ssoMap.get("msg").toString()) && carList.size() >= 1) {
                 rm.setMessage(ssoMap.get("msg").toString());
                 return rm;
             } else {
-                String carNo = params.get("carNo").toString();
                 HashMap queryCar = new HashMap();
                 queryCar.put("carNo", carNo);
                 queryCar.put("validFlag", "0");
@@ -270,6 +291,14 @@ public class MeterBaseCarController extends BaseRESTfulController {
                     car.setUsetDepartment(params.get("unitName").toString());
                     car.setCarTypeNo(params.get("carTypeNo").toString());
                     car.setCarTypeName(params.get("carTypeName").toString());
+                    if(car.getUsetDepartmentNo() != null && StringUtils.isNotEmpty(car.getUsetDepartmentNo())) {
+                        //111111：对应内部倒运;
+                        if(car.getUsetDepartmentNo().equals("111111")) {
+                            car.setUsetDepartmentNo("888888");
+                            car.setCarTypeNo("001004003");
+                            car.setCarTypeName("内部");
+                        }
+                    }
                     if(params.get("carSelfWeight") != null ) {
                         if(!StringUtils.isEmpty(params.get("carSelfWeight").toString())) {
                             car.setCarSelfWeight(new BigDecimal(params.get("carSelfWeight").toString()));
@@ -323,6 +352,15 @@ public class MeterBaseCarController extends BaseRESTfulController {
                     car.setUsetDepartment(params.get("unitName").toString());
                     car.setCarTypeNo(params.get("carTypeNo").toString());
                     car.setCarTypeName(params.get("carTypeName").toString());
+
+                    if(car.getUsetDepartmentNo() != null && StringUtils.isNotEmpty(car.getUsetDepartmentNo())) {
+                        //111111：对应内部倒运;888888：对应外进外发
+                        if(car.getUsetDepartmentNo().equals("111111")) {
+                            car.setUsetDepartmentNo("888888");
+                            car.setCarTypeNo("001004003");
+                            car.setCarTypeName("内部");
+                        }
+                    }
                     if(params.get("carSelfWeight") != null ) {
                         if(!StringUtils.isEmpty(params.get("carSelfWeight").toString())) {
                             car.setCarSelfWeight(new BigDecimal(params.get("carSelfWeight").toString()));
@@ -344,20 +382,20 @@ public class MeterBaseCarController extends BaseRESTfulController {
                 }
 
                 //润源公司（吉瑞）
-                if(car.getUsetDepartmentNo() != null && StringUtils.isNotEmpty(car.getUsetDepartmentNo())) {
-                    if(!car.getUsetDepartmentNo().equals("123456")) {
-                        //查询该车辆是否为内部车辆，内部车辆不允许批量注册司机和修改司机信息
-                        HashMap<String, Object> findCar = new HashMap<>();
-                        findCar.put("carNo", carNo);
-                        findCar.put("validFlag", "0");
-                        findCar.put("carTypeNo", "001004003");
-                        List<MeterBaseCar> carModel = meterBaseCarMapper.selectByParameters(findCar);
-                        if(carModel.size() >= 1) {
-                            rm.setMessage("内部车辆不允许批量注册司机和修改司机信息，请联系车辆管理部门");
-                            return rm;
-                        }
-                    }
-                }
+//                if(car.getUsetDepartmentNo() != null && StringUtils.isNotEmpty(car.getUsetDepartmentNo())) {
+//                    if(!car.getUsetDepartmentNo().equals("123456")) {
+//                        //查询该车辆是否为内部车辆，内部车辆不允许批量注册司机和修改司机信息
+//                        HashMap<String, Object> findCar = new HashMap<>();
+//                        findCar.put("carNo", carNo);
+//                        findCar.put("validFlag", "0");
+//                        findCar.put("carTypeNo", "001004003");
+//                        List<MeterBaseCar> carModel = meterBaseCarMapper.selectByParameters(findCar);
+//                        if(carModel.size() >= 1) {
+//                            rm.setMessage("内部车辆不允许批量注册司机和修改司机信息，请联系车辆管理部门");
+//                            return rm;
+//                        }
+//                    }
+//                }
 
                 // 拆分司机list，新增司机表
                 List<MeterBaseDriver> driverList = JSONObject.parseArray(params.get("driverList").toString(), MeterBaseDriver.class);
@@ -1208,4 +1246,5 @@ public class MeterBaseCarController extends BaseRESTfulController {
         }
     }
 
+
 }

src/main/java/com/steerinfo/baseinfo/meterbasecar/service/IMeterBaseCarService.java

@@ -42,4 +42,5 @@ public interface IMeterBaseCarService extends IBaseService<MeterBaseCar, String>
     List<MeterBaseCar> queryForNoPage(HashMap<String, Object> parmas);
 
     RESTfulResult getUnitByCar(String CarNo);
+    RESTfulResult updateCar(MeterBaseCar model);
 }

src/main/java/com/steerinfo/baseinfo/meterbasecar/service/impl/MeterBaseCarServiceImpl.java

@@ -285,7 +285,7 @@ public class MeterBaseCarServiceImpl extends BaseServiceImpl<MeterBaseCar, Strin
                         }
                         if(model.get("carTypeNo") != null) {
                             if(StringUtils.isNotEmpty(model.get("carTypeNo").toString())) {
-                                car.setCarTypeNo("00" + model.get("carTypeNo").toString());
+                                car.setCarTypeNo(model.get("carTypeNo").toString());
                             }
                         }
                         if(model.get("carTypeName") != null) {
@@ -424,6 +424,32 @@ public class MeterBaseCarServiceImpl extends BaseServiceImpl<MeterBaseCar, Strin
         return rm;
     }
 
+    @Override
+    @Transactional
+    public RESTfulResult updateCar(MeterBaseCar model) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+        try{
+            HashMap<String, Object> obj = new HashMap<>();
+            obj.put("carNo", model.getCarNo());
+            List<MeterBaseCar> carList = meterBaseCarMapper.selectByParameters(obj);
+            if(carList.size() >= 1) {
+                model.setPkNo(carList.get(0).getPkNo());
+                meterBaseCarMapper.updateByPrimaryKeySelective(model);
+                rm.setSucceed(true);
+                rm.setData(model);
+                rm.setMessage("操作成功");
+            }else {
+                rm.setMessage(model.getCarNo() + "车号信息不存在");
+            }
+        }catch(Exception e) {
+            e.printStackTrace();
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            rm.setMessage("操作异常，" + e.getMessage());
+        }
+        return rm;
+    }
+
     private String check(MeterBaseCar model)
     {
         if (model == null){

src/main/java/com/steerinfo/baseinfo/meterbasemattermap/controller/MeterBaseMatterMapController.java

@@ -1,5 +1,6 @@
 package com.steerinfo.baseinfo.meterbasemattermap.controller;
 
+import com.steerinfo.baseinfo.meterbasecar.model.MeterBaseCar;
 import com.steerinfo.framework.controller.BaseRESTfulController;
 import com.steerinfo.framework.controller.RESTfulResult;
 import com.steerinfo.framework.service.pagehelper.PageList;
@@ -11,6 +12,7 @@ import com.steerinfo.meterwork.meterworkprewgttype.model.MeterWorkPreWgttype;
 import io.swagger.annotations.ApiImplicitParam;
 import io.swagger.annotations.ApiImplicitParams;
 import io.swagger.annotations.ApiOperation;
+import oracle.jdbc.proxy.annotation.Post;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -113,19 +115,19 @@ public class MeterBaseMatterMapController extends BaseRESTfulController {
     }
 
     @ApiOperation(value="更新详细信息", notes="根据url的id来指定更新对象，并根据传过来的meterBaseMatterMap信息来更新详细信息")
-    @ApiImplicitParams({
-            @ApiImplicitParam(paramType = "path", name = "id", value = "ID", required = true, dataType = "String"),
-            @ApiImplicitParam(name = "meterBaseMatterMap", value = "详细实体meterBaseMatterMap", required = true, dataType = "MeterBaseMatterMap")
-    })
-    //@RequiresPermissions("meterbasemattermap:update")
-    @PutMapping(value = "/isDoublePre", produces  = "application/json;charset=UTF-8")
-    public boolean isDoublePre(@RequestParam String carNo){
+    @PostMapping(value = "/isDoublePre", produces  = "application/json;charset=UTF-8")
+    public RESTfulResult isDoublePre(@RequestBody MeterBaseCar model){
+        RESTfulResult rm = new RESTfulResult();
         try {
-            return meterBaseMatterMapService.isDoublePre(carNo);
-        }
-        catch (Exception e){
+            rm = meterBaseMatterMapService.isDoublePre(model.getCarNo());
+            return rm;
+        }catch (Exception e){
+            rm.setCode("500");
+            rm.setSucceed(false);
+            rm.setData(null);
+            rm.setMessage("操作失败--》" + e.getMessage());
             e.printStackTrace();
-            return false;
+            return rm;
         }
     }
 }

src/main/java/com/steerinfo/baseinfo/meterbasemattermap/service/IMeterBaseMatterMapService.java

@@ -22,5 +22,5 @@ import java.math.BigDecimal;
  * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
  */
 public interface IMeterBaseMatterMapService extends IBaseService<MeterBaseMatterMap, String>{
-    boolean isDoublePre(String carNo);
+    RESTfulResult isDoublePre(String carNo);
 }

src/main/java/com/steerinfo/baseinfo/meterbasemattermap/service/impl/MeterBaseMatterMapServiceImpl.java

@@ -13,11 +13,13 @@ import com.steerinfo.meterwork.meterworkcaractualfirst.model.MeterWorkCarActualF
 import com.steerinfo.meterwork.meterworkprewgttype.mapper.MeterWorkPreWgttypeMapper;
 import com.steerinfo.meterwork.meterworkprewgttype.model.MeterWorkPreWgttype;
 import com.steerinfo.pretrack.prerailwayscale.mapper.PreRailwayScaleMapper;
+import com.steerinfo.pretrack.pretrackscale.mapper.PreTrackScaleMapper;
 import com.steerinfo.pretrack.pretrackscale.model.PreTrackScale;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
 import java.util.Date;
 import java.math.BigDecimal;
 import java.util.HashMap;
@@ -49,7 +51,7 @@ public class MeterBaseMatterMapServiceImpl extends BaseServiceImpl<MeterBaseMatt
     ComBaseInfoMapper comBaseInfoMapper;
 
     @Resource
-    PreRailwayScaleMapper preRailwayScaleMapper;
+    PreTrackScaleMapper preTrackScaleMapper;
 
     @Resource
     MeterWorkCarActualFirstMapper meterWorkCarActualFirstMapper;
@@ -60,8 +62,13 @@ public class MeterBaseMatterMapServiceImpl extends BaseServiceImpl<MeterBaseMatt
     }
 
     @Override
-    public boolean isDoublePre(String carNo) {
+    public RESTfulResult isDoublePre(String carNo) {
+        RESTfulResult rm = new RESTfulResult();
         try {
+            List<PreTrackScale> tempList = new ArrayList<PreTrackScale>();
+            rm.setCode("0");
+            rm.setMessage("操作成功");
+            rm.setSucceed(true);
             //查询车辆是否为内倒双委托车辆
             HashMap preBase = new HashMap();
             preBase.put("pBaseCode","001047");
@@ -69,14 +76,19 @@ public class MeterBaseMatterMapServiceImpl extends BaseServiceImpl<MeterBaseMatt
             preBase.put("baseName",carNo);
             List<ComBaseInfo> cbis = comBaseInfoMapper.selectByParameters(preBase);
             if(cbis.size() != 1){
-                return false;
+                rm.setData(null);
+                return rm;
             }
             //查询车辆已选择的委托并拿到委托的发货单位和物料编号
             HashMap preSel = new HashMap();
             preSel.put("carNo",carNo);
             preSel.put("lineDesc","1");
             preSel.put("valueFlag","1");
-            List<PreTrackScale> ptsSel = preRailwayScaleMapper.selectByParameters(preSel);
+            List<PreTrackScale> ptsSel = preTrackScaleMapper.selectByParameters(preSel);
+            if(ptsSel.size() < 1) {
+                rm.setData(null);
+                return rm;
+            }
             String forwardingUnitNo = ptsSel.get(0).getForwardingUnitNo();
             String matterNo = ptsSel.get(0).getMatterNo();
             String receivingUintNo = ptsSel.get(0).getReceivingUintNo();
@@ -87,22 +99,29 @@ public class MeterBaseMatterMapServiceImpl extends BaseServiceImpl<MeterBaseMatt
             preBaseUnit.put("baseName",forwardingUnitNo);
             List<ComBaseInfo> cbisUnit = comBaseInfoMapper.selectByParameters(preBaseUnit);
             if(cbisUnit.size() != 1){
-                return false;
+                rm.setData(null);
+                return rm;
             }
             //查询改成已选择是皮重还是毛重
             HashMap preMap = new HashMap();
             preMap.put("carNo",carNo);
             preMap.put("valueFlag","1");
             List<MeterWorkPreWgttype> mwpws = meterWorkPreWgttypeMapper.selectByParameters(preMap);
+            //当选择的是毛重时
             if(mwpws.get(0).getWeightTypeNo().equals("001033001")){
+                //判断未被选择的委托中是否存在跟已选择的委托存在双委托关系
                 HashMap preNoSel = new HashMap();
-                preSel.put("carNo",carNo);
-                preSel.put("valueFlag","1");
-                List<PreTrackScale> pts = preRailwayScaleMapper.selectByParameters(preSel);
-                for (PreTrackScale model : pts){
-                    if((model.getForwardingUnitNo().equals(receivingUintNo) && model.getMatterNo().equals(matterNo)) ||
-                            (model.getReceivingUintNo().equals(forwardingUnitNo) && model.getMatterNo().equals(matterNo))){
-                        return true;
+                preNoSel.put("carNo",carNo);
+                preNoSel.put("valueFlag","1");
+                preNoSel.put("lineDesc","0");
+                List<PreTrackScale> pts = preTrackScaleMapper.selectByParameters(preNoSel);
+                if(pts.size() > 0) {
+                    //循环判断是否有满足的双委托，有则计数
+                    for (PreTrackScale model : pts){
+                        if((model.getForwardingUnitNo().equals(receivingUintNo) && model.getMatterNo().equals(matterNo)) ||
+                                (model.getReceivingUintNo().equals(forwardingUnitNo) && model.getMatterNo().equals(matterNo))){
+                            tempList.add(model);
+                        }
                     }
                 }
                 //查询映射物料编号
@@ -110,25 +129,126 @@ public class MeterBaseMatterMapServiceImpl extends BaseServiceImpl<MeterBaseMatt
                 matterMap.put("matterNo1",matterNo);
                 matterMap.put("valueFlag","1");
                 List<MeterBaseMatterMap> mbmm = meterBaseMatterMapMapper.selectByParameters(matterMap);
-                for (MeterBaseMatterMap model : mbmm){
-
+                if(mbmm.size() > 0){
+                    for(MeterBaseMatterMap map : mbmm){
+                        //判断未被选择的委托中是否存在跟映射关系已选择的委托存在双委托关系
+                        HashMap preNoSelMbmm = new HashMap();
+                        preNoSelMbmm.put("carNo",carNo);
+                        preNoSelMbmm.put("valueFlag","1");
+                        preNoSelMbmm.put("lineDesc","0");
+                        preNoSelMbmm.put("matterNo",map.getMaaterNo2());
+                        List<PreTrackScale> ptsMbmm = preTrackScaleMapper.selectByParameters(preNoSelMbmm);
+                        if(ptsMbmm.size() > 0){
+                            for (PreTrackScale model : ptsMbmm){
+                                if((model.getForwardingUnitNo().equals(receivingUintNo) && model.getMatterNo().equals(map.getMaaterNo2())) ||
+                                        (model.getReceivingUintNo().equals(forwardingUnitNo) && model.getMatterNo().equals(map.getMaaterNo2()))){
+                                    tempList.add(model);
+                                }
+                            }
+                        }
+                    }
                 }
             }
+            //当选择的是皮重时
             else {
-                List<MeterWorkCarActualFirst> meterWorkCarActualFirsts = meterWorkCarActualFirstMapper.selectByCarNo(carNo);
-                for (MeterWorkCarActualFirst model :meterWorkCarActualFirsts){
-                    if(model.getPredictionType().equals("")){
-                        break;
+                List<MeterWorkCarActualFirst> mwcaf = meterWorkCarActualFirstMapper.selectByCarNo(carNo);
+                if(mwcaf.size() == 0){
+                    rm.setData(null);
+                    return rm;
+                }
+                else if(mwcaf.size() == 1) {
+                    for (MeterWorkCarActualFirst model : mwcaf){
+                        if(model.getWeightType() == "0" && !model.getPredictionType().equals("")){
+                            //判断未被选择的委托中是否存在跟已选择的委托存在双委托关系
+                            HashMap preNoSel = new HashMap();
+                            preNoSel.put("carNo",carNo);
+                            preNoSel.put("valueFlag","1");
+                            preNoSel.put("lineDesc","0");
+                            List<PreTrackScale> pts = preTrackScaleMapper.selectByParameters(preNoSel);
+                            if(pts.size() > 0) {
+                                //循环判断是否有满足的双委托，有则计数
+                                for (PreTrackScale modelPre : pts){
+                                    if((modelPre.getForwardingUnitNo().equals(receivingUintNo) && modelPre.getMatterNo().equals(model.getMatterNo())) ||
+                                            (modelPre.getReceivingUintNo().equals(forwardingUnitNo) && modelPre.getMatterNo().equals(model.getMatterNo()))){
+                                        tempList.add(modelPre);
+                                    }
+                                }
+                            }
+                            //查询映射物料编号
+                            HashMap matterMap = new HashMap();
+                            matterMap.put("matterNo1",model.getMatterNo());
+                            matterMap.put("valueFlag","1");
+                            List<MeterBaseMatterMap> mbmm = meterBaseMatterMapMapper.selectByParameters(matterMap);
+                            if(mbmm.size() > 0){
+                                for(MeterBaseMatterMap map : mbmm){
+                                    //判断未被选择的委托中是否存在跟映射关系已选择的委托存在双委托关系
+                                    HashMap preNoSelMbmm = new HashMap();
+                                    preNoSelMbmm.put("carNo",carNo);
+                                    preNoSelMbmm.put("valueFlag","1");
+                                    preNoSelMbmm.put("lineDesc","0");
+                                    preNoSelMbmm.put("matterNo",map.getMaaterNo2());
+                                    List<PreTrackScale> ptsMbmm = preTrackScaleMapper.selectByParameters(preNoSelMbmm);
+                                    if(ptsMbmm.size() > 0){
+                                        for (PreTrackScale modelPre : ptsMbmm){
+                                            if((model.getForwardingUnitNo().equals(receivingUintNo) && model.getMatterNo().equals(map.getMaaterNo2())) ||
+                                                    (model.getReceivingUintNo().equals(forwardingUnitNo) && model.getMatterNo().equals(map.getMaaterNo2()))){
+                                                tempList.add(modelPre);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
-                    else {
-                        return false;
+                }
+                else {
+                    rm.setData(null);
+                    return rm;
+                }
+            }
+
+            if(tempList.size() > 0){
+                String matter = "";
+                String forwarding = "";
+                String receiving = "";
+                boolean flag = true;
+                for (PreTrackScale item : tempList)
+                {
+                    if (matter == "" && forwarding == "" && receiving == "")
+                    {
+                        matter = item.getMatterNo();
+                        forwarding = item.getForwardingUnitNo();
+                        receiving = item.getReceivingUintNo();
+                    }
+                    else
+                    {
+                        if (matter == item.getMatterNo() && forwarding == item.getForwardingUnitNo() && receiving == item.getReceivingUintNo())
+                        { }
+                        else
+                        {
+                            flag = false;
+                        }
                     }
                 }
+                if(flag){
+                    rm.setData(tempList.get(0));
+                }
+                else {
+                    rm.setData(null);
+                }
+            }
+            else {
+                rm.setData(null);
             }
-            return true;
+            return rm;
         }
         catch (Exception e){
-            return false;
+            rm.setCode("500");
+            rm.setSucceed(false);
+            rm.setData(null);
+            rm.setMessage("操作失败--》" + e.getMessage());
+            e.printStackTrace();
+            return rm;
         }
     }
 }

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

@@ -1335,9 +1335,9 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
 
     @ApiOperation(value = "内倒双委托---不使用期限皮结净，保存两条一次毛重")
     @PostMapping(value = "/doDoubleAdd", produces = "application/json;charset=UTF-8")
-    public RESTfulResult doDoubleAdd(@RequestBody MeterWorkCarActualFirst model, PreTrackScale scale01, PreTrackScale scale02) {
+    public RESTfulResult doDoubleAdd(@RequestBody CommonCombination<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, String> com) {
         try {
-            RESTfulResult rm = meterWorkCarActualFirstService.doDoubleAdd(model, scale01, scale02);
+            RESTfulResult rm = meterWorkCarActualFirstService.doDoubleAdd(com.getOne(), com.getTwo(), com.getThree());
             return rm;
         } catch (Exception e) {
             e.printStackTrace();
@@ -1347,9 +1347,9 @@ public class MeterWorkCarActualFirstController extends BaseRESTfulController {
 
     @ApiOperation(value = "内倒双委托---使用期限皮结净,直接保存四条数据和两个结净")
     @PostMapping(value = "/doTermTareNetDouble", produces = "application/json;charset=UTF-8")
-    public RESTfulResult doTermTareNetDouble(@RequestBody PreTrackScale scale, MeterWorkCarActualFirst model) {
+    public RESTfulResult doTermTareNetDouble(@RequestBody CommonCombination<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, String> com) {
         try {
-            RESTfulResult rm = meterWorkCarActualFirstService.doTermTareNetDouble(model, scale);
+            RESTfulResult rm = meterWorkCarActualFirstService.doTermTareNetDouble(com.getOne(), com.getTwo(), com.getThree());
             return rm;
         } catch (Exception e) {
             e.printStackTrace();

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

@@ -145,7 +145,7 @@ public interface IMeterWorkCarActualFirstService extends IBaseService<MeterWorkC
     RESTfulResult doNetByTermData(HashMap<String, Object> params);
 
     RESTfulResult doDoubleAdd(MeterWorkCarActualFirst model, PreTrackScale scale01, PreTrackScale scale02);
-    RESTfulResult doTermTareNetDouble(MeterWorkCarActualFirst model, PreTrackScale scale);
+    RESTfulResult doTermTareNetDouble(MeterWorkCarActualFirst model, PreTrackScale scale01, PreTrackScale scale02);
 
     RESTfulResult countFirstByCar(HashMap<String, Object> parmas);
 }

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

@@ -5498,80 +5498,101 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         return rm;
     }
 
+    //内倒双委托---不使用期限皮结净，保存两条一次毛重
     @Override
     @Transactional(rollbackFor = Exception.class)
     public RESTfulResult doDoubleAdd(MeterWorkCarActualFirst model, PreTrackScale scale01, PreTrackScale scale02) {
         RESTfulResult rm = new RESTfulResult();
         rm.setFailed();
         try{
+            //插入一次毛重数据
+            model.setActualFirstNo(PublicMethod.IdCreate(3));
+            model.setValueFlag("1");
+            meterWorkCarActualFirstMapper.insertSelective(model);
 
             PreTrackScale pre01 = preTrackScaleMapper.selectByPrimaryKey(scale01.getPredictionNo());
             PreTrackScale pre02 = preTrackScaleMapper.selectByPrimaryKey(scale02.getPredictionNo());
-            if(StringUtils.isNotEmpty(model.getPredictionNo())){
-                MeterWorkCarActualFirst copyFirst01 = new MeterWorkCarActualFirst();
-                MeterWorkCarActualFirst copyFirst02 = new MeterWorkCarActualFirst();
-                MeterWorkCarActualFirst modelTemp01 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale01.getPredictionNo());
-                BeanUtils.copyProperties(modelTemp01, copyFirst01);
-                MeterWorkCarActualFirst modelTemp02 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale02.getPredictionNo());
-                BeanUtils.copyProperties(modelTemp02, copyFirst02);
-
-                copyFirst01.setActualFirstNo(PublicMethod.IdCreate(3));
-                copyFirst01.setMeterMode("2");
-                copyFirst01.setWeightType("0");
-                copyFirst01.setDataSource("1");
-                copyFirst01.setValueFlag("1");
-                copyFirst01.setIsPreScale("1");
-                copyFirst01.setPredictionType("5");
-                copyFirst01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
-                copyFirst01.setCreateManNo("system");
-                copyFirst01.setCreateManName("system");
-                copyFirst01.setCreateTime(new Date());
-                meterWorkCarActualFirstMapper.insertSelective(model);
+            if(pre01 != null && pre02 != null) {
+                if(pre01.getValueFlag().equals("2") || pre01.getValueFlag().equals("3")) {
+                    rm.setMessage(pre01.getPredictionNo() + "委托信息已使用或已作废");
+                    return rm;
+                }else if(pre02.getValueFlag().equals("2") || pre02.getValueFlag().equals("3")) {
+                    rm.setMessage(pre02.getPredictionNo() + "委托信息已使用或已作废");
+                    return rm;
+                }
+            }else if(pre01 == null){
+                rm.setMessage(pre01.getPredictionNo() + "委托信息不存在");
+                return rm;
+            }else if(pre02 == null) {
+                rm.setMessage(pre02.getPredictionNo() + "委托信息不存在");
+                return rm;
+            }
 
-                copyFirst02.setActualFirstNo(PublicMethod.IdCreate(3));
-                copyFirst02.setMeterMode("2");
-                copyFirst02.setWeightType("0");
-                copyFirst02.setDataSource("1");
-                copyFirst02.setValueFlag("1");
-                copyFirst02.setIsPreScale("1");
-                copyFirst02.setPredictionType("5");
-                copyFirst02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
-                copyFirst02.setCreateManNo("system");
-                copyFirst02.setCreateManName("system");
-                copyFirst02.setCreateTime(new Date());
-                copyFirst02.setNote("内倒双委托一次复制:" + model.getActualFirstNo());
-                meterWorkCarActualFirstMapper.insertSelective(model);
+            MeterWorkCarActualFirst copyFirst01 = new MeterWorkCarActualFirst();
+            MeterWorkCarActualFirst copyFirst02 = new MeterWorkCarActualFirst();
+            MeterWorkCarActualFirst modelTemp01 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(modelTemp01, copyFirst01);
+            MeterWorkCarActualFirst modelTemp02 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(modelTemp02, copyFirst02);
+
+            copyFirst01.setMeterMode("2");
+            copyFirst01.setWeightType("0");
+            copyFirst01.setDataSource("1");
+            copyFirst01.setValueFlag("1");
+            copyFirst01.setIsPreScale("1");
+            copyFirst01.setPredictionType("5");
+            copyFirst01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            copyFirst01.setCreateManNo("system");
+            copyFirst01.setCreateManName("system");
+            copyFirst01.setCreateTime(new Date());
+            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(copyFirst01);
+
+            copyFirst02.setActualFirstNo(PublicMethod.IdCreate(3));
+            copyFirst02.setMeterMode("2");
+            copyFirst02.setWeightType("0");
+            copyFirst02.setDataSource("1");
+            copyFirst02.setValueFlag("1");
+            copyFirst02.setIsPreScale("1");
+            copyFirst02.setPredictionType("5");
+            copyFirst02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            copyFirst02.setCreateManNo("system");
+            copyFirst02.setCreateManName("system");
+            copyFirst02.setCreateTime(new Date());
+            copyFirst02.setNote("内倒双委托一次复制:" + copyFirst01.getActualFirstNo());
+            meterWorkCarActualFirstMapper.insertSelective(copyFirst02);
+
+            //预约信息重置委托
+            pre01.setPredictionType("5");
+            pre01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            pre01.setMeasureStation(model.getBaseSpotNo());
+            pre01.setMeasureStationName(model.getBaseSpotName());
+            pre01.setUpdateManNo("system");
+            pre01.setUpdateManName("system");
+            pre01.setUpdateTime(new Date());
+            pre01.setValueFlag("4");
+            pre01.setUploadFlag("1");
+            pre01.setLineDesc("0");
+            preTrackScaleMapper.updateByPrimaryKeySelective(pre01);
+
+            pre02.setPredictionType("5");
+            pre02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            pre02.setMeasureStation(model.getBaseSpotNo());
+            pre02.setMeasureStationName(model.getBaseSpotName());
+            pre02.setUpdateManNo("system");
+            pre02.setUpdateManName("system");
+            pre02.setUpdateTime(new Date());
+            pre02.setValueFlag("4");
+            pre02.setUploadFlag("1");
+            pre02.setLineDesc("0");
+            preTrackScaleMapper.updateByPrimaryKeySelective(pre02);
+
+            updatePreWeight(pre01.getCarNo());
+            updatePreWeight(pre02.getCarNo());
 
-                //预约信息重置委托
-                pre01.setPredictionType("5");
-                pre01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
-                pre01.setMeasureStation(model.getBaseSpotNo());
-                pre01.setMeasureStationName(model.getBaseSpotName());
-                pre01.setUpdateManNo("SYSTEM");
-                pre01.setUpdateManName("system");
-                pre01.setUpdateTime(new Date());
-                pre01.setValueFlag("4");
-                pre01.setUploadFlag("1");
-                pre01.setLineDesc("0");
-                preTrackScaleMapper.updateByPrimaryKeySelective(pre01);
-
-                pre02.setPredictionType("5");
-                pre02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
-                pre02.setMeasureStation(model.getBaseSpotNo());
-                pre02.setMeasureStationName(model.getBaseSpotName());
-                pre02.setUpdateManNo("SYSTEM");
-                pre02.setUpdateManName("system");
-                pre02.setUpdateTime(new Date());
-                pre02.setValueFlag("4");
-                pre02.setUploadFlag("1");
-                pre02.setLineDesc("0");
-                preTrackScaleMapper.updateByPrimaryKeySelective(pre02);
-
-                rm.setSucceed(true);
-                rm.setCode("200");
-                rm.setData(model.getActualFirstNo());
-                rm.setMessage("操作成功");
-            }
+            rm.setSucceed(true);
+            rm.setCode("200");
+            rm.setData(model.getActualFirstNo());
+            rm.setMessage("操作成功");
         }catch(Exception e) {
             e.printStackTrace();
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -5580,48 +5601,195 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
         return rm;
     }
 
+    //内倒双委托---使用期限皮结净,直接保存四条数据和两个结净
     @Override
-    public RESTfulResult doTermTareNetDouble(MeterWorkCarActualFirst model, PreTrackScale scale) {
+    @Transactional(rollbackFor = Exception.class)
+    public RESTfulResult doTermTareNetDouble(MeterWorkCarActualFirst model, PreTrackScale scale01, PreTrackScale scale02) {
         RESTfulResult rm = new RESTfulResult();
         rm.setFailed();
         try{
+            //插入一次毛重数据
+            model.setActualFirstNo(PublicMethod.IdCreate(3));
+            model.setValueFlag("1");
+            meterWorkCarActualFirstMapper.insertSelective(model);
 
-            PreTrackScale pre = preTrackScaleMapper.selectByPrimaryKey(model.getPredictionNo());
-            if(StringUtils.isNotEmpty(model.getPredictionNo())){
-                MeterWorkCarActualFirst modelTemp = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale.getPredictionNo());
-                BeanUtils.copyProperties(modelTemp, model);
-                String no = PublicMethod.IdCreate(3);
-                model.setActualFirstNo(no);
-                model.setMeterMode("2");
-                model.setWeightType("0");
-                model.setDataSource("1");
-                model.setValueFlag("1");
-                model.setIsPreScale("1");
-                model.setPredictionType("5");
-                model.setCreateManNo("SYSTEM");
-                model.setCreateManName("system");
-                model.setCreateTime(new Date());
-                meterWorkCarActualFirstMapper.insertSelective(model);
-                model.setNote("内倒双委托一次复制:" + model.getActualFirstNo());
-                model.setActualFirstNo(PublicMethod.IdCreate(3));
-                meterWorkCarActualFirstMapper.insertSelective(model);
-                //预约信息重置委托
-                pre.setPredictionType("5");
-                pre.setMeasureStation(model.getBaseSpotNo());
-                pre.setMeasureStationName(model.getBaseSpotName());
-                pre.setUpdateManNo("SYSTEM");
-                pre.setUpdateManName("system");
-                pre.setUpdateTime(new Date());
-                pre.setValueFlag("4");
-                pre.setUploadFlag("1");
-                pre.setLineDesc("0");
-                preTrackScaleMapper.updateByPrimaryKeySelective(pre);
+            PreTrackScale pre01 = preTrackScaleMapper.selectByPrimaryKey(scale01.getPredictionNo());
+            PreTrackScale pre02 = preTrackScaleMapper.selectByPrimaryKey(scale02.getPredictionNo());
+            if(pre01 != null && pre02 != null) {
+                if(pre01.getValueFlag().equals("2") || pre01.getValueFlag().equals("3")) {
+                    rm.setMessage(pre01.getPredictionNo() + "委托信息已使用或已作废");
+                    return rm;
+                }else if(pre02.getValueFlag().equals("2") || pre02.getValueFlag().equals("3")) {
+                    rm.setMessage(pre02.getPredictionNo() + "委托信息已使用或已作废");
+                    return rm;
+                }
+            }else if(pre01 == null){
+                rm.setMessage(pre01.getPredictionNo() + "委托信息不存在");
+                return rm;
+            }else if(pre02 == null) {
+                rm.setMessage(pre02.getPredictionNo() + "委托信息不存在");
+                return rm;
+            }
 
-                rm.setSucceed(true);
-                rm.setCode("200");
-                rm.setData(model.getActualFirstNo());
-                rm.setMessage("操作成功");
+            HashMap<String, Object> obj = new HashMap<>();
+            obj.put("carNo", model.getCarNo());
+            obj.put("valueFlag", "0");
+            List<MeterBaseTermTareData> tareDataList = meterBaseTermTareDataMapper.selectByParameters(obj);
+            if(tareDataList.size() < 1) {
+                rm.setMessage(model.getCarNo() + "车号期限皮重已过期或者未查找到期限皮中信息，不允许双委托计量");
+                return rm;
             }
+            MeterBaseTermTareData termData = tareDataList.get(0);
+
+            //插入期限皮重信息
+            MeterWorkCarActualFirst tareFirst = new MeterWorkCarActualFirst();
+            tareFirst.setActualFirstNo(PublicMethod.IdCreate(3));
+            tareFirst.setMeterTypeNo(model.getMeterTypeNo());
+            tareFirst.setMeterTypeName(model.getMeterTypeName());
+            tareFirst.setBaseSpotNo(termData.getBaseSpotNo());
+            tareFirst.setBaseSpotName(termData.getBaseSpotName());
+            tareFirst.setCarNo(termData.getCarNo());
+            tareFirst.setCreateTime(termData.getMeterTime());
+            tareFirst.setCreateManNo(termData.getCreateManNo());
+            tareFirst.setCreateManName(termData.getCreateManName());
+            tareFirst.setMeterWeight(termData.getMeterWeight());
+            tareFirst.setWeightType("2");//期限皮重
+            tareFirst.setValueFlag("1");//结净
+            tareFirst.setDataSource("1");
+            meterWorkCarActualFirstMapper.insertSelective(tareFirst);
+
+            MeterWorkCarActualFirst grossFirst01 = new MeterWorkCarActualFirst();
+            MeterWorkCarActualFirst grossFirst02 = new MeterWorkCarActualFirst();
+
+            //期限皮重信息保存
+            MeterWorkCarActualFirst tareFirst01 = new MeterWorkCarActualFirst();
+            MeterWorkCarActualFirst tareFirst02 = new MeterWorkCarActualFirst();
+
+            MeterWorkCarActual actualRow01 = new MeterWorkCarActual();
+            MeterWorkCarActual actualRow02 = new MeterWorkCarActual();
+
+            MeterWorkCarActualFirst modelTemp01 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(modelTemp01, grossFirst01);
+            MeterWorkCarActualFirst modelTemp02 = meterWorkCarActualFirstMapper.selectAndMatch(model.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(modelTemp02, grossFirst02);
+
+            MeterWorkCarActualFirst tareFirstTemp01 = meterWorkCarActualFirstMapper.selectAndMatch(tareFirst.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(tareFirstTemp01, tareFirst01);
+            MeterWorkCarActualFirst tareFirstTemp02 = meterWorkCarActualFirstMapper.selectAndMatch(tareFirst.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(tareFirstTemp02, tareFirst02);
+
+            grossFirst01.setMeterMode("2");
+            grossFirst01.setWeightType("0");
+            grossFirst01.setDataSource("1");
+            grossFirst01.setValueFlag("2");
+            grossFirst01.setIsPreScale("1");
+            grossFirst01.setPredictionType("5");
+            grossFirst01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            grossFirst01.setCreateManNo("system");
+            grossFirst01.setCreateManName("system");
+            grossFirst01.setCreateTime(new Date());
+            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(grossFirst01);
+
+            grossFirst02.setActualFirstNo(PublicMethod.IdCreate(3));
+            grossFirst02.setMeterMode("2");
+            grossFirst02.setWeightType("0");
+            grossFirst02.setDataSource("1");
+            grossFirst02.setValueFlag("2");
+            grossFirst02.setIsPreScale("1");
+            grossFirst02.setPredictionType("5");
+            grossFirst02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            grossFirst02.setCreateManNo("system");
+            grossFirst02.setCreateManName("system");
+            grossFirst02.setCreateTime(new Date());
+            grossFirst02.setNote("内倒双委托一次复制:" + grossFirst01.getActualFirstNo());
+            meterWorkCarActualFirstMapper.insertSelective(grossFirst02);
+
+
+            tareFirst01.setIsPreScale("1");
+            tareFirst01.setMeterMode("2");
+            tareFirst01.setValueFlag("2");
+            tareFirst01.setPredictionType("5");
+            tareFirst01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(tareFirst01);
+
+            tareFirst02.setActualFirstNo(PublicMethod.IdCreate(3));
+            tareFirst02.setIsPreScale("1");
+            tareFirst02.setValueFlag("2");
+            tareFirst02.setMeterMode("2");
+            tareFirst02.setPredictionType("5");
+            tareFirst02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            meterWorkCarActualFirstMapper.insertSelective(tareFirst02);
+
+            MeterWorkCarActual actualRowTemp01 = meterWorkCarActualMapper.manualAddPre(grossFirst01.getActualFirstNo(), tareFirst01.getActualFirstNo(), scale01.getPredictionNo());
+            BeanUtils.copyProperties(actualRowTemp01, actualRow01);
+            MeterWorkCarActual actualRowTemp02 = meterWorkCarActualMapper.manualAddPre(grossFirst02.getActualFirstNo(), tareFirst02.getActualFirstNo(), scale02.getPredictionNo());
+            BeanUtils.copyProperties(actualRowTemp02, actualRow02);
+
+            actualRow01.setActualNo(PublicMethod.IdCreate(3));
+            actualRow01.setNetMode(DbConstants.TYPE);
+            actualRow01.setNote("内倒双委托期限皮匹配结净");
+            actualRow01.setUploadFlag("1");
+            actualRow01.setIsPreScale("1");
+            actualRow01.setValueFlag("1");
+            actualRow01.setNetSpot3No(grossFirst01.getBaseSpotNo());
+            actualRow01.setNetSpot3Name(grossFirst01.getBaseSpotName());
+            actualRow01.setNetTime(grossFirst01.getCreateTime());
+            actualRow01.setCreateManName(grossFirst01.getCreateManName());
+            actualRow01.setCreateTime(grossFirst01.getCreateTime());
+            actualRow01.setPredictionType("5");
+            actualRow01.setPredictionNo(grossFirst01.getPredictionNo());
+            actualRow01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            actualRow01.setNetWeight(grossFirst01.getMeterWeight().subtract(tareFirst01.getMeterWeight()));
+            meterWorkCarActualMapper.insertSelective(actualRow01);
+
+            actualRow02.setActualNo(PublicMethod.IdCreate(3));
+            actualRow02.setNetMode(DbConstants.TYPE);
+            actualRow02.setNote("内倒双委托期限皮匹配结净");
+            actualRow02.setUploadFlag("1");
+            actualRow02.setIsPreScale("1");
+            actualRow02.setValueFlag("1");
+            actualRow02.setNetSpot3No(grossFirst02.getBaseSpotNo());
+            actualRow02.setNetSpot3Name(grossFirst02.getBaseSpotName());
+            actualRow02.setNetTime(grossFirst02.getCreateTime());
+            actualRow02.setCreateManName(grossFirst02.getCreateManName());
+            actualRow02.setCreateTime(grossFirst02.getCreateTime());
+            actualRow02.setPredictionType("5");
+            actualRow02.setPredictionNo(grossFirst02.getPredictionNo());
+            actualRow02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            actualRow02.setNetWeight(grossFirst02.getMeterWeight().subtract(tareFirst02.getMeterWeight()));
+            meterWorkCarActualMapper.insertSelective(actualRow02);
+
+            //预约信息重置委托
+            pre01.setPredictionType("5");
+            pre01.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            pre01.setMeasureStation(model.getBaseSpotNo());
+            pre01.setMeasureStationName(model.getBaseSpotName());
+            pre01.setUpdateManNo("system");
+            pre01.setUpdateManName("system");
+            pre01.setUpdateTime(new Date());
+            pre01.setValueFlag("2");
+            pre01.setUploadFlag("1");
+            pre01.setLineDesc("0");
+            preTrackScaleMapper.updateByPrimaryKeySelective(pre01);
+
+            pre02.setPredictionType("5");
+            pre02.setPredictionCombination(scale01.getPredictionNo() + "," + scale02.getPredictionNo());
+            pre02.setMeasureStation(model.getBaseSpotNo());
+            pre02.setMeasureStationName(model.getBaseSpotName());
+            pre02.setUpdateManNo("system");
+            pre02.setUpdateManName("system");
+            pre02.setUpdateTime(new Date());
+            pre02.setValueFlag("2");
+            pre02.setUploadFlag("1");
+            pre02.setLineDesc("0");
+            preTrackScaleMapper.updateByPrimaryKeySelective(pre02);
+            updatePreWeight(pre01.getCarNo());
+            updatePreWeight(pre02.getCarNo());
+
+            rm.setSucceed(true);
+            rm.setCode("200");
+            rm.setData(model.getActualFirstNo());
+            rm.setMessage("操作成功");
         }catch(Exception e) {
             e.printStackTrace();
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

src/main/java/com/steerinfo/meterwork/meterworkoldandnew/mapper/MeterWorkOldAndNewMapper.xml

@@ -66,6 +66,12 @@
         <if test="matterName != null and matterName != ''">
             and matter_name LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and NET_WEIGHT/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and NET_WEIGHT/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -132,6 +138,12 @@
         <if test="matterName != null and matterName != ''">
             and FS_MATERIALNAME LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and FS_NETWEIGHT >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and FS_NETWEIGHT &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryFirstNew" parameterType="java.util.HashMap" resultType="HashMap">
@@ -192,6 +204,12 @@
         <if test="matterName != null and matterName != ''">
             and matter_name LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and meter_weight/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and meter_weight/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryFirstOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -251,6 +269,12 @@
         <if test="matterName != null and matterName != ''">
             and materialName LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and weight >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and weight &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="countNew" parameterType="java.util.HashMap" resultType="HashMap">
@@ -391,6 +415,7 @@
         SENDER_REMARK,
         RECEIVING_UINT_NAME,
         RECEIVER_REMARK,
+        MATTER_NO,
         MATTER_NAME,
         '新系统' as remark
         from METER_WORK_RAILWAY_ACTUAL
@@ -440,6 +465,12 @@
         <if test="senderRemark != null and senderRemark != ''">
             and RECEIVER_REMARK LIKE '%${senderRemark}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and NET_WEIGHT/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and NET_WEIGHT/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -460,7 +491,8 @@ FS_SENDERNAME FORWARDING_UNIT_NAME,
 FS_SENDERREMARK SENDER_REMARK,
 FS_RECEIVERNAME RECEIVING_UINT_NAME,
 FS_RECEIVERREMARK RECEIVER_REMARK,
-FS_MATERIALNAME MATTER_NAME,
+        FS_MATERIAL MATTER_NO,
+        FS_MATERIALNAME MATTER_NAME,
 '老系统' as remark
 from JGWEIGHT.VIEW_TRAIN_NET
 where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or FS_BALANCETYPE='铁水轨道衡')
@@ -509,6 +541,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="senderRemark != null and senderRemark != ''">
             and fs_senderRemark LIKE '%${senderRemark}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and FN_NETWEIGHT >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and FN_NETWEIGHT &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayFirstNew" parameterType="java.util.HashMap" resultType="HashMap">
@@ -568,6 +606,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="matterName != null and matterName != ''">
             and matter_name LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and meter_weight/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and meter_weight/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayFirstOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -627,6 +671,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="matterName != null and matterName != ''">
             and FS_materialName LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and FN_weight >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and FN_weight &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="countRailwayNew" parameterType="java.util.HashMap" resultType="HashMap">
@@ -765,6 +815,7 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         SENDER_REMARK,
         RECEIVING_UINT_NAME,
         RECEIVER_REMARK,
+        MATTER_NO,
         MATTER_NAME,
         '新系统' as remark
         from METER_WORK_RAILWAY_ACTUAL
@@ -814,6 +865,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="senderRemark != null and senderRemark != ''">
             and RECEIVER_REMARK LIKE '%${senderRemark}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and NET_WEIGHT/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and NET_WEIGHT/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayDynamicOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -834,6 +891,7 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         FS_SENDERREMARK SENDER_REMARK,
         FS_RECEIVERNAME RECEIVING_UINT_NAME,
         FS_RECEIVERREMARK RECEIVER_REMARK,
+        FS_MATERIAL MATTER_NO,
         FS_MATERIALNAME MATTER_NAME,
         '老系统' as remark
         from JGWEIGHT.VIEW_TRAIN_DYNAMIC_NET
@@ -884,6 +942,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="senderRemark != null and senderRemark != ''">
             and fs_senderRemark LIKE '%${senderRemark}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and FN_NETWEIGHT >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and FN_NETWEIGHT &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayDynamicFirstNew" parameterType="java.util.HashMap" resultType="HashMap">
@@ -903,7 +967,7 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         '' sender_remark,
         '新系统' remark
         from METER_WORK_RAILWAY_RECEIVED
-        where VALUE_FLAG in ('1') and RAILWAY_TYPE_NO in ('001019002', '001019004')
+        where VALUE_FLAG in ('1') and RAILWAY_TYPE_NO in ('001019002', '001019004') AND RAILWAY_NO IS NOT NULL
         <if test="remark != null and remark != ''">
             and '新系统' LIKE '%${remark}%'
         </if>
@@ -940,6 +1004,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="matterName != null and matterName != ''">
             and matter_name LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and meter_weight/1000 >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and meter_weight/1000 &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="doQueryRailwayDynamicFirstOld" parameterType="java.util.HashMap" resultType="HashMap">
@@ -1000,6 +1070,12 @@ where FS_ISVALID = '1' and FS_DELETEDTAG = 'N' and (FS_BALANCETYPE='静态' or F
         <if test="matterName != null and matterName != ''">
             and FS_materialName LIKE '%${matterName}%'
         </if>
+        <if test="minWgt != null and minWgt != ''">
+            and FN_weight >= '${minWgt}'
+        </if>
+        <if test="maxWgt != null and maxWgt != ''">
+            and FN_weight &lt;= '${maxWgt}'
+        </if>
     </select>
 
     <select id="countRailwayDynamicNew" parameterType="java.util.HashMap" resultType="HashMap">

src/main/java/com/steerinfo/meterwork/meterworkrailwayactual/service/impl/MeterWorkRailwayActualServiceImpl.java

@@ -225,9 +225,8 @@ public class MeterWorkRailwayActualServiceImpl extends BaseServiceImpl<MeterWork
                     rm.setMessage("未找到结净计量数据，请确认！！！");
                     return rm;
                 }
-                if (modelTemp.getPredictionNo() == null || "".equals(modelTemp.getPredictionNo())
-                        || "2".equals(modelTemp.getValueFlag()) || "0".equals(modelTemp.getValueFlag())) {
-                    rm.setMessage("只有已匹配委托且有效未发布的数据才能进行作废操作");
+                if ("2".equals(modelTemp.getValueFlag()) || "0".equals(modelTemp.getValueFlag())) {
+                    rm.setMessage("只有有效未发布的数据才能进行作废操作");
                     return rm;
                 }
             }
@@ -3517,13 +3516,13 @@ public class MeterWorkRailwayActualServiceImpl extends BaseServiceImpl<MeterWork
                 MeterWorkRailwayActual actualRow = meterWorkRailwayActualMapper.cleanPredcition(modelTemp.getActualNo());
                 actualRow.setUploadFlag("1");
                 actualRow.setValueFlag("0");
+                actualRow.setIsPreSacale("0");
                 actualRow.setUpdateManNo(userId);
                 actualRow.setUpdateManName(userName);
                 actualRow.setUpdateTime(new Date());
                 actualRow.setNote("动态衡毛皮分解");
-                actualRow.setIsPreSacale("0");
-//                meterWorkRailwayActualMapper.updateByPrimaryKey(actualRow);
-                meterWorkRailwayActualMapper.deleteByPrimaryKey(actualRow.getActualNo());
+                meterWorkRailwayActualMapper.updateByPrimaryKey(actualRow);
+//                meterWorkRailwayActualMapper.deleteByPrimaryKey(actualRow.getActualNo());
             }
             rm.setSucceed(true);
             rm.setMessage("毛皮分解成功");

src/main/java/com/steerinfo/meterwork/meterworkrailwayreceived/controller/MeterWorkRailwayReceivedController.java

@@ -266,6 +266,24 @@ public class MeterWorkRailwayReceivedController extends BaseRESTfulController {
         return rm;
     }
 
+    @ApiOperation(value="批量更新信息", notes="根据url的id来指定更新对象，并根据传过来的meterWorkRailwayReceived信息来更新详细信息")
+    @PostMapping(value = "/batchMatchPre", produces  = "application/json;charset=UTF-8")
+    public RESTfulResult matchPre(@RequestBody List<MeterWorkRailwayReceived> models){
+        RESTfulResult rm = new RESTfulResult();
+        try {
+            rm = meterWorkRailwayReceivedService.batchMatchPre(models);
+        } catch (MarkerMetException e) {
+            e.printStackTrace();
+            rm.setMessage(e.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            rm.setMessage("操作异常，请确认！");
+        } finally {
+
+        }
+        return rm;
+    }
+
     @ApiOperation(value="更新详细信息", notes="根据url的id来指定更新对象，并根据传过来的meterWorkRailwayReceived信息来更新详细信息")
     @PostMapping(value = "/removeList", produces  = "application/json;charset=UTF-8")
     public RESTfulResult removeList(@RequestBody List<MeterWorkRailwayReceived> models){

src/main/java/com/steerinfo/meterwork/meterworkrailwayreceived/service/IMeterWorkRailwayReceivedService.java

@@ -31,6 +31,7 @@ public interface IMeterWorkRailwayReceivedService extends IBaseService<MeterWork
     RESTfulResult updateListStart(List<MeterWorkRailwayReceived> models);
     RESTfulResult RemovePre(List<MeterWorkRailwayReceived> models);
     RESTfulResult matchPre(MeterWorkRailwayReceived model);
+    RESTfulResult batchMatchPre(List<MeterWorkRailwayReceived> models);
     RESTfulResult addList(List<MeterWorkRailwayReceived> models);
 
 }

src/main/java/com/steerinfo/meterwork/meterworkrailwayreceived/service/impl/MeterWorkRailwayReceivedServiceImpl.java

@@ -1,6 +1,7 @@
 package com.steerinfo.meterwork.meterworkrailwayreceived.service.impl;
 
 import cn.hutool.db.handler.HandleHelper;
+import com.github.pagehelper.util.StringUtil;
 import com.steerinfo.baseinfo.meterbaseoperationlog.mapper.MeterBaseOperationLogMapper;
 import com.steerinfo.baseinfo.meterbaseoperationlog.model.MeterBaseOperationLog;
 import com.steerinfo.baseinfo.meterbaserailwayaiweight.mapper.MeterBaseRailwayAiweightMapper;
@@ -496,4 +497,40 @@ public class MeterWorkRailwayReceivedServiceImpl extends BaseServiceImpl<MeterWo
         }
         return rm;
     }
+
+    @Override
+    @Transactional
+    public RESTfulResult batchMatchPre(List<MeterWorkRailwayReceived> models) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setFailed();
+        try{
+            int count = 0;
+            for(MeterWorkRailwayReceived model: models) {
+                MeterWorkRailwayReceived modelTemp = meterWorkRailwayReceivedMapper.selectByPrimaryKey(model.getActualFirstNo());
+                if(StringUtil.isEmpty(modelTemp.getPredictionNo())) {
+                    PreRailwayScale scale = preRailwayScaleMapper.selectByPrimaryKey(model.getPredictionNo());
+                    scale.setValueFlag("4");
+                    preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+                    model.setRailwayNo(scale.getRailwayNo());
+                    model.setMatterNo(scale.getMatterNo());
+                    model.setMatterName(scale.getMatterName());
+                    model.setReceivingUintNo(scale.getReceivingUintNo());
+                    model.setReceivingUintName(scale.getReceivingUintName());
+                    model.setForwardingUnitNo(scale.getForwardingUnitNo());
+                    model.setForwardingUnitName(scale.getForwardingUnitName());
+                    meterWorkRailwayReceivedMapper.updateByPrimaryKeySelective(model);
+                    count ++;
+                }
+            }
+            rm.setSucceed();
+            rm.setMessage("操作成功,共有" + count + "条数据匹配委托成功");
+            rm.setCode("200");
+            rm.setData(null);
+        }catch(Exception e) {
+            e.printStackTrace();
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            rm.setMessage("操作异常");
+        }
+        return rm;
+    }
 }