后端修改

src/main/java/com/steerinfo/baseinfo/meterbaseversions/controller/MeterBaseVersionsController.java

@@ -116,7 +116,7 @@ public class MeterBaseVersionsController extends BaseRESTfulController {
       return success();
     }
 
-    @ApiOperation(value="根据版本编号返回最新的APP版本对象", notes="根据url的id来指定删除对象")
+    @ApiOperation(value="添加APP版本对象", notes="添加APP版本对象")
     @ApiImplicitParams({
             @ApiImplicitParam(paramType = "path", name = "id", value = "ID", required = true, dataType = "String"),
             @ApiImplicitParam(name = "meterBaseVersions", value = "详细实体meterBaseVersions", required = true, dataType = "MeterBaseVersions")
@@ -125,10 +125,10 @@ public class MeterBaseVersionsController extends BaseRESTfulController {
     public RESTfulResult checkAdd(@RequestBody MeterBaseVersions model){
         RESTfulResult rm = failed();
         rm = meterBaseVersionsService.checkAdd(model);
-        return success();
+        return rm;
     }
 
-    @ApiOperation(value="根据版本编号返回最新的APP版本对象", notes="根据url的id来指定删除对象")
+    @ApiOperation(value="根据版本编号返回最新的APP版本对象", notes="根据版本编号返回最新的APP版本对象")
     @PostMapping(value = "selectByVersionNo")//String
     public RESTfulResult selectByVersionNo(@RequestParam String versionNo){
         RESTfulResult rm = failed();
@@ -137,6 +137,18 @@ public class MeterBaseVersionsController extends BaseRESTfulController {
             return rm;
         }
         rm = meterBaseVersionsService.selectByVersionNo(versionNo);
-        return success();
+        return rm;
+    }
+
+    @ApiOperation(value="根据版本编号废除版本信息", notes="根据url的versionNo废除指定对象")
+    @PostMapping(value = "updateValueFlag")//String
+    public RESTfulResult updateValueFlag(@RequestParam String versionNo){
+        RESTfulResult rm = failed();
+        if(com.steerinfo.util.StringUtils.isEmpty(versionNo)){
+            rm.setMessage("版本编号不能为空！！");
+            return rm;
+        }
+        rm = meterBaseVersionsService.updateValueFlag(versionNo);
+        return rm;
     }
 }

src/main/java/com/steerinfo/baseinfo/meterbaseversions/mapper/MeterBaseVersionsMapper.java

@@ -9,4 +9,5 @@ import org.apache.ibatis.annotations.Mapper;
 public interface MeterBaseVersionsMapper extends IBaseMapper<MeterBaseVersions, String> {
     String GetNewID();
     MeterBaseVersions selectNewVersion();
+
 }

src/main/java/com/steerinfo/baseinfo/meterbaseversions/mapper/MeterBaseVersionsMapper.xml

@@ -475,7 +475,7 @@
 
   <select id="selectNewVersion" resultMap="BaseResultMap">
     <include refid="select"/>
-    where validFlag = '1'
-    order by create_time DESC
+    where valid_flag = '1'
+        and versions_number in (select max(versions_number) from meter_base_versions where valid_flag = '1')
   </select>
 </mapper>

src/main/java/com/steerinfo/baseinfo/meterbaseversions/service/IMeterBaseVersionsService.java

@@ -24,4 +24,6 @@ public interface IMeterBaseVersionsService extends IBaseService<MeterBaseVersion
     RESTfulResult checkAdd(MeterBaseVersions model);
 
     RESTfulResult selectByVersionNo(String versionNo);
+
+    RESTfulResult updateValueFlag(String versionNo);
 }

src/main/java/com/steerinfo/baseinfo/meterbaseversions/service/impl/MeterBaseVersionsServiceImpl.java

@@ -52,25 +52,28 @@ public class MeterBaseVersionsServiceImpl extends BaseServiceImpl<MeterBaseVersi
         }
         //获取最新的版本对象
         MeterBaseVersions versionModel = meterBaseVersionsMapper.selectNewVersion();
-        String no = meterBaseVersionsMapper.GetNewID();
-        model.setVersionsNo(no);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
+        model.setVersionsNo(sdf.format(new Date()));
         //首次新增版本信息，版本号默认为1、后续新增版本信息，版本号加1
         if(versionModel == null){
-            model.setVersionsNo("1");
+            model.setVersionsNumber("1");
         }else{
-            Long num = Long.parseLong(versionModel.getVersionsNo()) + 1;
-            model.setVersionsNo(String.valueOf(num));
+            Long num = Long.parseLong(versionModel.getVersionsNumber()) + 1;
+            model.setVersionsNumber(String.valueOf(num));
         }
         model.setValidFlag("1");
         UserPayload payload = UserPayload.getCurrUser();
         String userId = payload.getId();
         String userName = payload.getUserName();
+        /*String userId = "admins";
+        String userName = "admins";*/
         model.setCreateManNo(userId);
         model.setCreateManName(userName);
         model.setCreateTime(new Date());
         int i = meterBaseVersionsMapper.insert(model);
         if( i >= 1){
             rm.setSucceed();
+            rm.setCode("200");
             rm.setData(model);
             rm.setMessage("操作成功！！");
         }else{
@@ -83,10 +86,11 @@ public class MeterBaseVersionsServiceImpl extends BaseServiceImpl<MeterBaseVersi
     public RESTfulResult selectByVersionNo(String versionNo) {
         RESTfulResult rm = new RESTfulResult();
         rm.setSucceed();
-
+        rm.setCode("200");
         MeterBaseVersions versionModel = meterBaseVersionsMapper.selectNewVersion();
         Long num = Long.parseLong(versionNo);
-        if(num >= Long.parseLong(versionModel.getVersionsNo())){
+        Long versionNum = Long.parseLong(versionModel.getVersionsNumber());
+        if(num >= versionNum) {
             rm.setMessage("当前版本已是最新版本，无需更新！！");
         }else{
             rm.setMessage("当前版本不是最新版本，请更新！！");
@@ -94,4 +98,28 @@ public class MeterBaseVersionsServiceImpl extends BaseServiceImpl<MeterBaseVersi
         }
         return rm;
     }
+
+    @Override
+    public RESTfulResult updateValueFlag(String versionNo) {
+        RESTfulResult rm = new RESTfulResult();
+        rm.setSucceed();
+        rm.setCode("200");
+        MeterBaseVersions versionModel = meterBaseVersionsMapper.selectByPrimaryKey(versionNo);
+        versionModel.setValidFlag("0");
+        UserPayload payload = UserPayload.getCurrUser();
+        String userId = payload.getId();
+        String userName = payload.getUserName();
+        /*String userId = "admins";
+        String userName = "admins";*/
+        versionModel.setUpdateManNo(userId);
+        versionModel.setCreateManName(userName);
+        versionModel.setUpdateTime(new Date());
+        int i = meterBaseVersionsMapper.updateByPrimaryKey(versionModel);
+        if(i >= 0) {
+            rm.setMessage("废除版本完成！！");
+        }else {
+            rm.setMessage("废除版本失败！！");
+        }
+        return rm;
+    }
 }

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

@@ -3371,6 +3371,7 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
     }
 
     @Override
+    @Transactional(value = "tm", rollbackFor = Exception.class)
     public RESTfulResult doNetAddMuch(MeterWorkCarActualFirst actualFirst) throws Exception {
         try {
             RESTfulResult rm = new RESTfulResult();
@@ -3390,6 +3391,10 @@ public class MeterWorkCarActualFirstServiceImpl extends BaseServiceImpl<MeterWor
                 actualFirst.setValueFlag("2");//洁净
                 meterWorkCarActualFirstMapper.insertSelective(actualFirst);
 
+                //将毛重委托匹配到皮重中
+                MeterWorkCarActualFirst meterWorkCarActualFirst = meterWorkCarActualFirstMapper.selectAndMatch(actualFirst.getActualFirstNo(), model.getPredictionNo());
+                meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(meterWorkCarActualFirst);
+
                 //修改毛重数据状态为结净
                 model.setValueFlag("2");
                 meterWorkCarActualFirstMapper.updateByPrimaryKeySelective(model);

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

@@ -775,4 +775,90 @@ throw new MarkerMetException(500, "操作异常！！");
 throw new MarkerMetException(500, "操作异常！！");
         }
     }
+
+    @ApiOperation(value = "轨道衡双委托匹配洁净", notes = "轨道衡双委托匹配洁净")
+    //@RequiresPermissions("meterworkcaractual:view")
+    @PostMapping(value = "/doubleEntrustMatch")
+    public RESTfulResult doubleEntrustmentMatch(@RequestBody HashMap parmas) {
+        RESTfulResult rm = failed();
+        try {
+            String actualNo1 = parmas.get("actualNo1").toString();
+            String actualNo2 = parmas.get("actualNo2").toString();
+            String predictionNo1 = parmas.get("predictionNo1").toString();
+            String predictionNo2 = parmas.get("predictionNo2").toString();
+
+            String msg = meterWorkRailwayActFirstService.doubleEntrustMatch(actualNo1, actualNo2,predictionNo1,predictionNo2);
+            rm.setMessage(msg);
+            if (rm.getMessage() != "" || !rm.getMessage().equals("")){
+                return rm;
+            }
+            return success();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
+
+    @ApiOperation(value = "混装", notes = "混装")
+    //@RequiresPermissions("meterworkcaractual:view")
+    @PostMapping(value = "/mixedLoading")
+    public RESTfulResult mixedLoading(@RequestBody HashMap parmas) {
+        try {
+            String actualNo1 = parmas.get("actualNo1").toString();
+            String actualNo2 = parmas.get("actualNo2").toString();
+            String actualNo3 = parmas.get("actualNo3").toString();
+            String predictionNo1 = parmas.get("predictionNo1").toString();
+            String predictionNo2 = parmas.get("predictionNo2").toString();
+            String msg = meterWorkRailwayActFirstService.mixedLoading(actualNo1, actualNo2,actualNo3,predictionNo1,predictionNo2);
+            if (msg != "" || !msg.equals("")){
+                return failed(null,msg);
+            }
+            return success();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
+
+    @ApiOperation(value = "混卸", notes = "混卸")
+    //@RequiresPermissions("meterworkcaractual:view")
+    @PostMapping(value = "/mixedDischarge")
+    public RESTfulResult mixedDischarge(@RequestBody HashMap parmas) {
+        try {
+            String actualNo1 = parmas.get("actualNo1").toString();
+            String actualNo2 = parmas.get("actualNo2").toString();
+            String actualNo3 = parmas.get("actualNo3").toString();
+            String predictionNo1 = parmas.get("predictionNo1").toString();
+            String predictionNo2 = parmas.get("predictionNo2").toString();
+
+            String msg = meterWorkRailwayActFirstService.mixedDischarge(actualNo1, actualNo2,actualNo3,predictionNo1,predictionNo2);
+            if (msg != "" || !msg.equals("")){
+                return failed(null,msg);
+            }
+            return success();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
+
+    @ApiOperation(value = "标识皮重洁净", notes = "标识皮重洁净")
+    //@RequiresPermissions("meterworkcaractual:view")
+    @PostMapping(value = "/fixedTare")
+    public RESTfulResult fixedTare(@RequestBody HashMap parmas) {
+        try {
+            String actualNo = parmas.get("actualNo").toString();
+            String predictionNo = parmas.get("predictionNo").toString();
+            String tareWeight = parmas.get("tareWeight").toString();
+
+            String msg = meterWorkRailwayActFirstService.fixedTare(actualNo, tareWeight, predictionNo);
+            if (msg != "" || !msg.equals("")){
+                return failed(null,msg);
+            }
+            return success();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            throw new MarkerMetException(500, "操作异常！！");
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.steerinfo.meterwork.meterworkrailwayactfirst.service;
 
 import com.steerinfo.baseinfo.meterbaserailwayweight.model.MeterBaseRailwayWeight;
+import com.steerinfo.framework.controller.RESTfulResult;
 import com.steerinfo.framework.service.IBaseService;
 import com.steerinfo.framework.service.pagehelper.PageList;
 import com.steerinfo.meterwork.dto.StaffPerformanceAnalysis;
@@ -81,5 +82,10 @@ public interface IMeterWorkRailwayActFirstService extends IBaseService<MeterWork
     String doUpdateSelfWeight(MeterWorkRailwayActFirst model);
 
 //    PageList<MeterWorkRailwayActFirst> selectTa(HashMap parmas, Integer pageNum, Integer pageSize);
+
+    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);
+    String fixedTare(String actualNo, String tareWeight, String predictionNo);
 }
 

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

@@ -6,6 +6,7 @@ import com.steerinfo.baseinfo.meterbaserailwayweight.mapper.MeterBaseRailwayWeig
 import com.steerinfo.baseinfo.meterbaserailwayweight.model.MeterBaseRailwayWeight;
 import com.steerinfo.baseinfo.meterbasevideoinfo.mapper.MeterBaseVideoinfoMapper;
 import com.steerinfo.baseinfo.meterbasevideoinfo.model.MeterBaseVideoinfo;
+import com.steerinfo.framework.controller.RESTfulResult;
 import com.steerinfo.framework.mapper.IBaseMapper;
 import com.steerinfo.framework.service.impl.BaseServiceImpl;
 import com.steerinfo.framework.service.pagehelper.PageHelper;
@@ -26,6 +27,7 @@ import com.steerinfo.meterwork.meterworkrailwayactual.mapper.MeterWorkRailwayAct
 import com.steerinfo.meterwork.meterworkrailwayactual.model.MeterWorkRailwayActual;
 import com.steerinfo.pretrack.prerailwayscale.mapper.PreRailwayScaleMapper;
 import com.steerinfo.pretrack.prerailwayscale.model.PreRailwayScale;
+import com.steerinfo.pretrack.pretrackscale.model.PreTrackScale;
 import com.steerinfo.util.FieldsCollector;
 import com.steerinfo.util.PublicMethod;
 import com.steerinfo.util.StringUtils;
@@ -467,6 +469,503 @@ public class MeterWorkRailwayActFirstServiceImpl extends BaseServiceImpl<MeterWo
         return model.getActualFirstNo();
     }
 
+    @Override
+    public String doubleEntrustMatch(String actualNo1, String actualNo2, String predictionNo1, String predictionNo2) {
+
+        try{
+            //查询出一次计量数据
+            MeterWorkRailwayActFirst mwcaf01 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkRailwayActFirst mwcaf02 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkRailwayActFirst mwcaf03 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkRailwayActFirst mwcaf04 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            //查询出所有委托信息
+            PreRailwayScale pts01 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo1);
+            PreRailwayScale pts02 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo2);
+            //定义两个洁净类
+            MeterWorkRailwayActual actualRow1 = new MeterWorkRailwayActual();
+            MeterWorkRailwayActual actualRow2 = new MeterWorkRailwayActual();
+            //获取两个一次重量的差值
+            BigDecimal num01 = mwcaf01.getMeterWeight().subtract(mwcaf03.getMeterWeight()).abs();
+            if(mwcaf01 == null || mwcaf03 == null ){
+                return "一次计量数据为空,请确认！!";
+            }
+            //判断毛重必须大于皮重
+            if(num01.compareTo(BigDecimal.valueOf(0)) == -1){
+                return "第一个一次计量重量一定要大于第二条一次计量重量！!";
+            }
+            if(pts01 == null || pts02 == null){
+                return "委托信息为空,请确认！！";
+            }
+            if(!mwcaf01.getRailwayNo().equals(mwcaf03.getRailwayNo())){
+                return "车号不一致,不能匹配洁净！！";
+            }
+            //洁净数据不能小于400
+            if(num01.compareTo(BigDecimal.valueOf(400)) == -1){
+                return "选择的两条一次计量数据不能小于400！！";
+            }
+            if(pts01.getValueFlag().equals("2") || pts02.getValueFlag().equals("2")){
+                return "委托信息已使用！！";
+            }
+
+            if(pts01.getValueFlag().equals("3") || pts02.getValueFlag().equals("3")){
+                return "委托信息已作废！！";
+            }
+            if(mwcaf01.getValueFlag().equals("2") || mwcaf03.getValueFlag().equals("2")){
+                return "一次计量数据已洁净！！";
+            }
+            //将委托中的编号和收发货的等数据拷贝进一次数据中
+            MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo1, predictionNo1);
+            BeanUtils.copyProperties(first1,mwcaf01);
+            MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo1);
+            BeanUtils.copyProperties(first2, mwcaf02);
+            MeterWorkRailwayActFirst first3 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo1, predictionNo2);
+            BeanUtils.copyProperties(first3,mwcaf03);
+            MeterWorkRailwayActFirst first4 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo2);
+            BeanUtils.copyProperties(first4, mwcaf04);
+            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+            MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo1);
+            BeanUtils.copyProperties(mwca1, actualRow1);
+            MeterWorkRailwayActual mwca2 = meterWorkRailwayActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo2);
+            BeanUtils.copyProperties(mwca2,actualRow2);
+            //更新预报数据
+            PreRailwayScale scale = new PreRailwayScale();
+            scale.setPredictionNo(predictionNo1);
+            scale.setValueFlag(DbConstants.NET);
+            scale.setUpdateTime(new Date());
+            scale.setUpdateManNo("system");
+            scale.setUpdateManName("二次计量洁净更新");
+            scale.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+            PreRailwayScale scale1 = new PreRailwayScale();
+            scale1.setPredictionNo(predictionNo2);
+            scale1.setValueFlag(DbConstants.NET);
+            scale1.setUpdateTime(new Date());
+            scale1.setUpdateManNo("system");
+            scale1.setUpdateManName("二次计量洁净更新");
+            scale1.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale1);
+
+            //更新一次数据
+            //更新第一次毛重数据库
+            mwcaf01.setValueFlag(DbConstants.NET);
+            mwcaf01.setUpdateManName("system");
+            mwcaf01.setUpdateManName("二次计量洁净更新");
+            mwcaf01.setUpdateTime(new Date());
+            mwcaf01.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf01);
+            //更新第一次皮重数据库
+            mwcaf02.setValueFlag(DbConstants.NET);
+            mwcaf02.setUpdateManName("system");
+            mwcaf02.setUpdateManName("二次计量洁净更新");
+            mwcaf02.setUpdateTime(new Date());
+            mwcaf02.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf02);
+            //添加第一次毛重数据库
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            String afl = sdf.format(new Date());
+            String actualFirstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            mwcaf03.setActualFirstNo(actualFirstNo);
+            mwcaf03.setValueFlag(DbConstants.NET);
+            mwcaf03.setUpdateManName("system");
+            mwcaf03.setUpdateManName("二次计量洁净更新");
+            mwcaf03.setUpdateTime(new Date());
+            mwcaf03.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.insertSelective(mwcaf03);
+            //添加第二次皮重数据库
+            SimpleDateFormat sdf01 = new SimpleDateFormat("yyyyMMdd");
+            String afl01 = sdf01.format(new Date());
+            String actualSecondNo = sdf01.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl01);
+            mwcaf04.setActualFirstNo(actualSecondNo);
+            mwcaf04.setValueFlag(DbConstants.NET);
+            mwcaf04.setUpdateManName("system");
+            mwcaf04.setUpdateManName("二次计量洁净更新");
+            mwcaf04.setUpdateTime(new Date());
+            mwcaf04.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.insertSelective(mwcaf04);
+
+            //添加结净数据
+            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.setUploadFlag("1");
+            actualRow1.setIsPreSacale("1");
+            actualRow1.setNetWeight(mwcaf01.getMeterWeight().subtract(mwcaf02.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.setUploadFlag("1");
+            actualRow2.setIsPreSacale("1");
+            actualRow2.setNetWeight(mwcaf03.getMeterWeight().subtract(mwcaf04.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow2);
+        }catch(Exception e){
+            e.printStackTrace();
+            return "操作异常，请确认";
+        }
+        return "";
+    }
+
+    @Override
+    public String mixedLoading(String actualNo1, String actualNo2, String actualNo3, String predictionNo1, String predictionNo2) {
+        try{
+            //查询所有的一次数据
+            MeterWorkRailwayActFirst mwcaf1 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkRailwayActFirst mwcaf2 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkRailwayActFirst mwcaf3 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkRailwayActFirst mwcaf4 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo3);
+            //查询所有的委托数据
+            PreRailwayScale pts1 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo1);
+            PreRailwayScale pts2 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo2);
+            //定义新的结净数据实体
+            MeterWorkRailwayActual actualRow1 = new MeterWorkRailwayActual();
+            MeterWorkRailwayActual actualRow2 = new MeterWorkRailwayActual();
+            //判断是否为混装逻辑
+            if(mwcaf1.getMeterWeight().compareTo(mwcaf2.getMeterWeight()) == 1 || mwcaf1.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == 1 || mwcaf2.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == 1){
+                return "不为混装逻辑！！";
+            }
+            //判断一次数据是否存在
+            if (mwcaf1 == null || mwcaf2 == null || mwcaf3 == null || mwcaf4 == null) {
+                return "未查询到相应的一次数据！！";
+            }
+            //判断一次数据是否已结净
+            if (mwcaf1.getValueFlag().equals("2") || mwcaf2.getValueFlag().equals("2") || mwcaf3.getValueFlag().equals("2") || mwcaf4.getValueFlag().equals("2")) {
+                return "存在已结净的一次数据！！";
+            }
+            //判断委托数据是否存在
+            if (pts1 == null || pts2 == null) {
+                return "未查询到相应的委托数据！！";
+            }
+            //判断委托数据是否已使用
+            if (!pts1.getValueFlag().equals("1") || !pts1.getValueFlag().equals("1")) {
+                return "委托不是未使用状态！！";
+            }
+            //将委托中的编号和收发货的等数据拷贝进一次数据中
+            MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo1, predictionNo1);
+            BeanUtils.copyProperties(first1,mwcaf1);
+            MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo1);
+            BeanUtils.copyProperties(first2, mwcaf2);
+            MeterWorkRailwayActFirst first3 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo2);
+            BeanUtils.copyProperties(first3,mwcaf3);
+            MeterWorkRailwayActFirst first4 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo3, predictionNo2);
+            BeanUtils.copyProperties(first4, mwcaf4);
+            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+            MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(actualNo2, actualNo1, predictionNo1);
+            BeanUtils.copyProperties(mwca1, actualRow1);
+            MeterWorkRailwayActual mwca2 = meterWorkRailwayActualMapper.manualAddPre(actualNo3, actualNo2, predictionNo2);
+            BeanUtils.copyProperties(mwca2,actualRow2);
+
+            //更新预报数据
+            PreRailwayScale scale = new PreRailwayScale();
+            scale.setPredictionNo(predictionNo1);
+            scale.setValueFlag(DbConstants.NET);
+            scale.setUpdateTime(new Date());
+            scale.setUpdateManNo("system");
+            scale.setUpdateManName("二次计量洁净更新");
+            scale.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+            PreRailwayScale scale1 = new PreRailwayScale();
+            scale1.setPredictionNo(predictionNo2);
+            scale1.setValueFlag(DbConstants.NET);
+            scale1.setUpdateTime(new Date());
+            scale1.setUpdateManNo("system");
+            scale1.setUpdateManName("二次计量洁净更新");
+            scale1.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale1);
+
+            //更新一次数据
+            //更新第一次皮重数据
+            mwcaf1.setValueFlag(DbConstants.NET);
+            mwcaf1.setUpdateManName("system");
+            mwcaf1.setUpdateManName("二次计量洁净更新");
+            mwcaf1.setUpdateTime(new Date());
+            mwcaf1.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf1);
+            //更新第一次毛重数据
+            mwcaf2.setValueFlag(DbConstants.NET);
+            mwcaf2.setUpdateManName("system");
+            mwcaf2.setUpdateManName("二次计量洁净更新");
+            mwcaf2.setUpdateTime(new Date());
+            mwcaf2.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf2);
+            //添加第二次皮重数据
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            String afl = sdf.format(new Date());
+            String actualFirstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            mwcaf3.setActualFirstNo(actualFirstNo);
+            mwcaf3.setValueFlag(DbConstants.NET);
+            mwcaf3.setUpdateManName("system");
+            mwcaf3.setUpdateManName("二次计量洁净更新");
+            mwcaf3.setUpdateTime(new Date());
+            mwcaf3.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.insertSelective(mwcaf3);
+            //更新第二次毛重数据
+            mwcaf4.setValueFlag(DbConstants.NET);
+            mwcaf4.setUpdateManName("system");
+            mwcaf4.setUpdateManName("二次计量洁净更新");
+            mwcaf4.setUpdateTime(new Date());
+            mwcaf4.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf4);
+
+            //添加结净数据
+            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.setUploadFlag("1");
+            actualRow1.setIsPreSacale("1");
+            actualRow1.setValueFlag("2");
+            actualRow1.setCreateTime(new Date());
+            actualRow1.setCreateManName("洁净");
+            actualRow1.setNetWeight(mwcaf2.getMeterWeight().subtract(mwcaf1.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.setUploadFlag("1");
+            actualRow2.setIsPreSacale("1");
+            actualRow2.setValueFlag("2");
+            actualRow2.setCreateTime(new Date());
+            actualRow2.setCreateManName("洁净");
+            actualRow2.setNetWeight(mwcaf4.getMeterWeight().subtract(mwcaf3.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow2);
+        }
+        catch (Exception e){
+            e.printStackTrace();
+            return "操作异常，请确认";
+        }
+        return "";
+    }
+
+    @Override
+    public String mixedDischarge(String actualNo1, String actualNo2, String actualNo3, String predictionNo1, String predictionNo2) {
+        try{
+            //查询所有的一次数据
+            MeterWorkRailwayActFirst mwcaf1 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo1);
+            MeterWorkRailwayActFirst mwcaf2 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkRailwayActFirst mwcaf3 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo2);
+            MeterWorkRailwayActFirst mwcaf4 = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo3);
+            //查询所有的委托数据
+            PreRailwayScale pts1 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo1);
+            PreRailwayScale pts2 = preRailwayScaleMapper.selectByPrimaryKey(predictionNo2);
+            //定义新的结净数据实体
+            MeterWorkRailwayActual actualRow1 = new MeterWorkRailwayActual();
+            MeterWorkRailwayActual actualRow2 = new MeterWorkRailwayActual();
+            //判断是否为混装逻辑
+            if(mwcaf1.getMeterWeight().compareTo(mwcaf2.getMeterWeight()) == -1 || mwcaf1.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == -1 || mwcaf2.getMeterWeight().compareTo(mwcaf4.getMeterWeight()) == -1){
+                return "不为混卸逻辑！！";
+            }
+            //判断一次数据是否存在
+            if (mwcaf1 == null || mwcaf2 == null || mwcaf3 == null || mwcaf4 == null) {
+                return "未查询到相应的一次数据！！";
+            }
+            //判断一次数据是否已结净
+            if (mwcaf1.getValueFlag().equals("2") || mwcaf2.getValueFlag().equals("2") || mwcaf3.getValueFlag().equals("2") || mwcaf4.getValueFlag().equals("2")) {
+                return "存在已结净的一次数据！！";
+            }
+            //判断委托数据是否存在
+            if (pts1 == null || pts2 == null) {
+                return "未查询到相应的委托数据！！";
+            }
+            //判断委托数据是否已使用
+            if (!pts1.getValueFlag().equals("1") || !pts1.getValueFlag().equals("1")) {
+                return "委托不是未使用状态！！";
+            }
+            //将委托中的编号和收发货的等数据拷贝进一次数据中
+            MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo1, predictionNo1);
+            BeanUtils.copyProperties(first1,mwcaf1);
+            MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo1);
+            BeanUtils.copyProperties(first2, mwcaf2);
+            MeterWorkRailwayActFirst first3 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo2, predictionNo2);
+            BeanUtils.copyProperties(first3,mwcaf3);
+            MeterWorkRailwayActFirst first4 = meterWorkRailwayActFirstMapper.selectAndMatch(actualNo3, predictionNo2);
+            BeanUtils.copyProperties(first4, mwcaf4);
+            //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+            MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(actualNo1, actualNo2, predictionNo1);
+            BeanUtils.copyProperties(mwca1, actualRow1);
+            MeterWorkRailwayActual mwca2 = meterWorkRailwayActualMapper.manualAddPre(actualNo2, actualNo3, predictionNo2);
+            BeanUtils.copyProperties(mwca2,actualRow2);
+
+            //更新预报数据
+            PreRailwayScale scale = new PreRailwayScale();
+            scale.setPredictionNo(predictionNo1);
+            scale.setValueFlag(DbConstants.NET);
+            scale.setUpdateTime(new Date());
+            scale.setUpdateManNo("system");
+            scale.setUpdateManName("二次计量洁净更新");
+            scale.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+            PreRailwayScale scale1 = new PreRailwayScale();
+            scale1.setPredictionNo(predictionNo2);
+            scale1.setValueFlag(DbConstants.NET);
+            scale1.setUpdateTime(new Date());
+            scale1.setUpdateManNo("system");
+            scale1.setUpdateManName("二次计量洁净更新");
+            scale1.setUploadFlag("1");
+            preRailwayScaleMapper.updateByPrimaryKeySelective(scale1);
+
+            //更新一次数据
+            //更新第一次毛重数据
+            mwcaf1.setValueFlag(DbConstants.NET);
+            mwcaf1.setUpdateManNo("system");
+            mwcaf1.setUpdateManName("二次计量洁净更新");
+            mwcaf1.setUpdateTime(new Date());
+            mwcaf1.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf1);
+            //更新第一次皮重数据
+            mwcaf2.setValueFlag(DbConstants.NET);
+            mwcaf2.setUpdateManNo("system");
+            mwcaf2.setUpdateManName("二次计量洁净更新");
+            mwcaf2.setUpdateTime(new Date());
+            mwcaf2.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf2);
+            //添加第二次毛重数据
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            String afl = sdf.format(new Date());
+            String actualFirstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+            mwcaf3.setActualFirstNo(actualFirstNo);
+            mwcaf3.setValueFlag(DbConstants.NET);
+            mwcaf3.setUpdateManNo("system");
+            mwcaf3.setUpdateManName("二次计量洁净更新");
+            mwcaf3.setUpdateTime(new Date());
+            mwcaf3.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.insertSelective(mwcaf3);
+            //更新第二次皮重数据
+            mwcaf4.setValueFlag(DbConstants.NET);
+            mwcaf4.setUpdateManNo("system");
+            mwcaf4.setUpdateManName("二次计量洁净更新");
+            mwcaf4.setUpdateTime(new Date());
+            mwcaf4.setIsPreSacale("1");
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(mwcaf4);
+
+            //添加结净数据
+            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.setUploadFlag("1");
+            actualRow1.setIsPreSacale("1");
+            actualRow1.setValueFlag("2");
+            actualRow1.setCreateManName("洁净");
+            actualRow1.setCreateTime(new Date());
+            actualRow1.setNetWeight(mwcaf1.getMeterWeight().subtract(mwcaf2.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.setUploadFlag("1");
+            actualRow2.setIsPreSacale("1");
+            actualRow2.setValueFlag("2");
+            actualRow2.setCreateManName("洁净");
+            actualRow2.setCreateTime(new Date());
+            actualRow2.setNetWeight(mwcaf3.getMeterWeight().subtract(mwcaf4.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow2);
+        }
+        catch (Exception e){
+            e.printStackTrace();
+            return "操作异常，请确认";
+        }
+        return "";
+    }
+
+    @Override
+    public String fixedTare(String actualNo, String tareWeight, String predictionNo) {
+
+        if(com.steerinfo.util.StringUtils.isEmpty(actualNo)){
+            return "实绩编号不存在，请确认！！";
+        }
+        MeterWorkRailwayActFirst grossModel = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo);
+        if(!grossModel.getValueFlag().equals("1")){
+            return "当前计量数据已洁净，请确认！！";
+        }
+        MeterWorkRailwayActFirst tareModel = meterWorkRailwayActFirstMapper.selectByPrimaryKey(actualNo);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+        String afl = sdf.format(new Date());
+        String firstNo = sdf.format(new Date()) + meterWorkRailwayActFirstMapper.getNewID(afl);
+        tareModel.setActualFirstNo(firstNo);
+        tareModel.setMeterWeight(new BigDecimal(tareWeight));
+        tareModel.setWeightType("4");
+        int i = meterWorkRailwayActFirstMapper.insert(tareModel);
+
+        if(i >= 1){
+            tareModel = meterWorkRailwayActFirstMapper.selectByPrimaryKey(tareModel.getActualFirstNo());
+            MeterWorkRailwayActual actualRow = new MeterWorkRailwayActual();
+
+            PreRailwayScale scale = new PreRailwayScale();
+            if(!com.steerinfo.util.StringUtils.isEmpty(predictionNo)){
+                scale = preRailwayScaleMapper.selectByPrimaryKey(predictionNo);
+            }
+            if(!com.steerinfo.util.StringUtils.isEmpty(predictionNo) && scale != null){  //有预报编号进行预报更新
+                //将委托中的编号和收发货的等数据拷贝进一次数据中
+                MeterWorkRailwayActFirst first1 = meterWorkRailwayActFirstMapper.selectAndMatch(grossModel.getActualFirstNo(), predictionNo);
+                BeanUtils.copyProperties(first1, grossModel);
+                MeterWorkRailwayActFirst first2 = meterWorkRailwayActFirstMapper.selectAndMatch(tareModel.getActualFirstNo(), predictionNo);
+                BeanUtils.copyProperties(first2, tareModel);
+                grossModel.setIsPreSacale("1");
+                tareModel.setIsPreSacale("1");
+
+                //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+                MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAddPre(grossModel.getActualFirstNo(), tareModel.getActualFirstNo(), predictionNo);
+                BeanUtils.copyProperties(mwca1, actualRow);
+                actualRow.setIsPreSacale("1");
+
+                //更新预报数据
+                scale.setPredictionNo(predictionNo);
+                scale.setValueFlag(DbConstants.NET);
+                scale.setUpdateTime(new Date());
+                scale.setUpdateManNo("system");
+                scale.setUpdateManName("二次计量洁净更新");
+                scale.setUploadFlag("1");
+                preRailwayScaleMapper.updateByPrimaryKeySelective(scale);
+
+            }else{
+                //将委托中的编号和收发货单位和一次数据等数据拷贝进结净数据中
+                MeterWorkRailwayActual mwca1 = meterWorkRailwayActualMapper.manualAdd(grossModel.getActualFirstNo(), tareModel.getActualFirstNo());
+                BeanUtils.copyProperties(mwca1, actualRow);
+            }
+            grossModel.setValueFlag(DbConstants.NET);
+            grossModel.setUpdateManNo("system");
+            grossModel.setUpdateManName("二次计量洁净更新");
+            grossModel.setUpdateTime(new Date());
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(grossModel);
+            //更新第一次皮重数据
+            tareModel.setValueFlag(DbConstants.NET);
+            tareModel.setUpdateManNo("system");
+            tareModel.setUpdateManName("二次计量洁净更新");
+            tareModel.setUpdateTime(new Date());
+            meterWorkRailwayActFirstMapper.updateByPrimaryKey(tareModel);
+
+            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.setUploadFlag("1");
+            actualRow.setValueFlag("2");
+            actualRow.setCreateManName("洁净");
+            actualRow.setCreateTime(new Date());
+            actualRow.setNetWeight(grossModel.getMeterWeight().subtract(tareModel.getMeterWeight()));
+            meterWorkRailwayActualMapper.insertSelective(actualRow);
+            return "操作成功";
+        }
+        return "";
+    }
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public List<MeterWorkRailwayActFirst> selectSta(HashMap parmas) {