暂时提交

src/main/java/com/steerinfo/dil/mapper/RulesMapper.java

@@ -0,0 +1,38 @@
+package com.steerinfo.dil.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 规则方法
+ * @ author    :TXF
+ * @ time      :2021/11/16 14:28
+ */
+
+@Mapper
+public interface RulesMapper {
+    //根据物资Id、门岗规则 查询门岗id (可能会查询出多个)
+    List<Map<String, Object>> queryGatepostByMaterialId(Map<String, Object> map);
+
+    //通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个称
+    List<Integer> queryTruckCalculate(Map<String, Object> map);
+
+    //查询当前物资是否为最后一拼（是否还有未装车实绩）
+    List<Map<String, Object>> judgeLastMaterial(BigDecimal orderId);
+
+    //通过门岗ID 和 网格类型 匹配 网格主键
+    BigDecimal getGridIdByGatepostIdAndGridType(Map<String, Object> map);
+
+
+    //通过物资Id查询仓库是否有货 或者 是否有多个仓库有货
+    List<Integer> getWarehouseIdByMaterialId(Integer materialId);
+
+    //通过仓库Id 和 物资Id 查询垛位 层次 月台 仓库
+    List<Map<String, Object>> getStackGradation(Map<String, Object> map);
+
+    //通过月台Id 查询月台当前排队车辆数
+    BigDecimal queueCountByPlatformId(BigDecimal platformId);
+}

src/main/java/com/steerinfo/dil/mapper/TmstruckLeaveFactoryResultMapper.java

@@ -18,12 +18,6 @@ public interface TmstruckLeaveFactoryResultMapper extends IBaseMapper<TmstruckLe
     //查询采购所有的出厂实绩、
     List<Map<String, Object>> getCGLeaveFactoryResult(Map<String, Object> map);
 
-    //根据运输订单Id查询物资Id
-    BigDecimal queryOrderMesByOrderId(String orderNumber);
-
-    //根据物资Id、门岗规则 查询门岗id (可能会查询出多个)
-    List<Map<String, Object>> queryGatepostByMaterialId(Map<String, Object> map);
-
     //查询运输路线是否为出厂
     Integer selectTransportRoute(String orderNumber);
 

src/main/java/com/steerinfo/dil/mapper/TmstruckWeightResultMapper.java

@@ -41,8 +41,6 @@ public interface TmstruckWeightResultMapper extends IBaseMapper<TmstruckWeightRe
     //查询订单下所有的物资件数和物资理重
     List<Map<String, Object>> getMaterialMes(Integer orderId);
 
-    //通过物资ID查询应该在哪个汽车衡计量
-    List<Integer> getCalculateIdByMaterial(BigDecimal material);
 
     //通过运输订单id获取路段顺序号、物资类型、计量实绩主键、line_id
     Map<String, BigDecimal> selectByOrderId(BigDecimal orderId);

src/main/java/com/steerinfo/dil/mapper/UtilsMapper.java

@@ -4,6 +4,7 @@ import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Select;
 
 import java.math.BigDecimal;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -36,4 +37,13 @@ public interface UtilsMapper {
 
     //通过月台名称查找月台Id platformName
     Integer queryPlatformIdByName(String platformName);
+
+    //根据运输订单Id查询物资Id
+    BigDecimal queryOrderMesByOrderId(String orderNumber);
+
+    //查询当前路段顺序号
+    Integer getLineSequenceByOrderId(BigDecimal orderId);
+
+    //查询订单跟订单物资中间表 查询是否有多个物资Id
+    List<Integer> getAllMaterialId(Map<String, Object> map);
 }

src/main/java/com/steerinfo/dil/service/IRulesService.java

@@ -0,0 +1,36 @@
+package com.steerinfo.dil.service;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @ author    :TXF
+ * @ time      :2021/11/16 14:30
+ */
+
+public interface IRulesService {
+    //通过运输订单号查询物资并根据门岗规则计算出厂门岗
+    int calculateGatepost(Map<String, Object> map);
+
+    //通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个称
+    List<Integer> queryTruckCalculate(Map<String, Object> map);
+
+    //查询当前物资是否为最后一拼（是否还有未装车实绩）
+    List<Map<String, Object>> judgeLastMaterial(BigDecimal orderId);
+
+    //通过物资Id查询仓库是否有货 或者 是否有多个仓库有货
+    List<Integer> getWarehouseIdByMaterialId(Integer materialId);
+
+    //通过仓库Id 和 物资Id 查询垛位 层次 月台 仓库
+    List<Map<String, Object>> getStackGradation(Map<String, Object> map);
+
+    //通过月台Id 查询月台当前排队车辆数
+    BigDecimal queueCountByPlatformId(BigDecimal platformId);
+
+    //通过排队规则查询月台ID  materialIdList：运单关联的所有物资
+    Map<String, Object> getPlatId(Integer materialId);
+
+    //计算物资优先级顺序 并计算装车点
+    Map<String, Object> calculateMaterialPriority(List<Map<String, Object>> mapList);
+}

src/main/java/com/steerinfo/dil/service/ITmstruckWeightResultService.java

@@ -33,8 +33,6 @@ public interface ITmstruckWeightResultService{
     //新增计皮计毛实绩
     int addWeightResult(Map<String, Object> map);
 
-    //通过物资ID查询应该在哪个汽车衡计量
-    int getCalculateIdByMaterial(BigDecimal materialId);
     /**
      *通过运输订单判断下一步是否需要计量,更新汽车衡到计量实绩中
      */

src/main/java/com/steerinfo/dil/service/IUtilsService.java

@@ -1,6 +1,7 @@
 package com.steerinfo.dil.service;
 
 import java.math.BigDecimal;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -30,4 +31,11 @@ public interface IUtilsService {
 
     //通过月台名称查找月台Id platformName
     Integer queryPlatformIdByName(String platformName);
+
+    //查询当前路段顺序号
+    Integer getLineSequenceByOrderId(BigDecimal orderId);
+
+    //查询订单跟订单物资中间表 查询是否有多个物资Id
+    List<Integer> getAllMaterialId(Map<String, Object> map);
+
 }

src/main/java/com/steerinfo/dil/service/impl/RulesServiceImpl.java

@@ -0,0 +1,235 @@
+package com.steerinfo.dil.service.impl;
+
+import com.steerinfo.dil.mapper.RulesMapper;
+import com.steerinfo.dil.mapper.TmstruckLeaveFactoryResultMapper;
+import com.steerinfo.dil.mapper.UtilsMapper;
+import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
+import com.steerinfo.dil.service.IRulesService;
+import com.steerinfo.dil.util.DataChange;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+/**
+ * @ author    :TXF
+ * @ time      :2021/11/16 14:30
+ */
+
+@Service(value = "rulesService")
+public class RulesServiceImpl implements IRulesService {
+    @Autowired
+    private UtilsMapper utilsMapper;
+
+    @Autowired
+    private RulesMapper rulesMapper;
+
+    @Autowired
+    private TmstruckLeaveFactoryResultMapper tmstruckLeaveFactoryResultMapper;
+
+    /**
+     * 通过运输订单号查询物资并根据门岗规则计算出厂门岗
+     * @param map
+     * @return
+     */
+    public int calculateGatepost(Map<String, Object> map){
+        BigDecimal materialId = utilsMapper.queryOrderMesByOrderId((String) map.get("orderNumber"));
+        Map<String, Object> map1 = new HashMap<>();
+        map1.put("materialId", materialId);
+        //类型为出厂
+        map1.put("type", 1);
+        List<Map<String, Object>> list = rulesMapper.queryGatepostByMaterialId(map1);
+        for (Map<String, Object> mes : list) {
+            //从数据库中获取门岗开始时间结束时间 若当前时间满足该门岗进门时间 则下放 暂不考虑门岗优先级
+            boolean judgeTime = judgeTime((String)mes.get("startTime"), (String)mes.get("endTime"));
+            if(judgeTime){
+                //更新出厂实绩门岗ID
+                //通过运输订单号获取出厂实绩ID
+                Map<String, Object> map2 = tmstruckLeaveFactoryResultMapper.selectResultId((String) map.get("orderNumber"));
+                TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
+                tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(map2.get("resultId")));
+                tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(mes.get("gatepostId")));
+                return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
+            }
+        }
+        return 1;
+    }
+
+    /**
+     * 判断当前时间是否在时间区间范围内
+     * @param startTime
+     * @param endTime
+     * @return
+     */
+    public boolean judgeTime(String startTime, String endTime){
+        SimpleDateFormat sdf = new SimpleDateFormat("HHmmss");
+        String format = sdf.format(new Date());
+        int begin = Integer.parseInt(startTime);
+        int end = Integer.parseInt(endTime);
+        int now = Integer.parseInt(format);
+        if(begin < end){
+            return now < end && now >= begin;
+        }else {
+            return now < end || now >= begin;
+        }
+    }
+
+
+    /**
+     * 通过物资ID 和 计量类型 查找汽车衡
+     * @param materialId 物资Id
+     * @param type 1: 进厂秤  2：出厂秤  3：中转
+     * @return 汽车衡
+     */
+    public int calculateWeighbridge(BigDecimal materialId, Integer type){
+        Map<String, Object> map = new HashMap<>();
+        map.put("nature", type);
+        map.put("materialId", materialId);
+        List<Integer> calculateList = rulesMapper.queryTruckCalculate(map);
+        //暂时不考虑优先级 随机进行取值
+        int size = calculateList.size();
+        if(size == 0){
+            return 13; //没有查询到汽车衡  则使用备用秤
+        }if(size == 1){
+            return calculateList.get(0);
+        }
+        return calculateList.get(new Random().nextInt(size));
+    }
+
+    /**
+     * 通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个
+     * @param map
+     * @return
+     */
+    @Override
+    public List<Integer> queryTruckCalculate(Map<String, Object> map) {
+        return rulesMapper.queryTruckCalculate(map);
+    }
+
+    /**
+     * 查询当前物资是否为最后一拼（是否还有未装车实绩）
+     * @param orderId
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> judgeLastMaterial(BigDecimal orderId) {
+        return rulesMapper.judgeLastMaterial(orderId);
+    }
+
+
+    /*=========================仓库排队规则=========================*/
+
+    /**
+     *通过物资Id查询仓库是否有货 或者 是否有多个仓库有货
+     * @param materialId 物资ID
+     * @return
+     */
+    @Override
+    public List<Integer> getWarehouseIdByMaterialId(Integer materialId) {
+        return rulesMapper.getWarehouseIdByMaterialId(materialId);
+    }
+
+    /**
+     * 通过仓库Id 和 物资Id 查询垛位 层次 月台 仓库
+     * @param map MaterialId 物资ID warehouseId 仓库ID
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> getStackGradation(Map<String, Object> map) {
+        return rulesMapper.getStackGradation(map);
+    }
+
+    /**
+     * 通过月台Id 查询月台当前排队车辆数
+     * @param platformId 月台ID
+     * @return
+     */
+    @Override
+    public BigDecimal queueCountByPlatformId(BigDecimal platformId) {
+        return rulesMapper.queueCountByPlatformId(platformId);
+    }
+
+
+    /**
+     * 获取月台Id 通过物资ID 根据排队规则 获取车辆该去哪个月台
+     * 规则：不同物资在不同仓库 -->  遍历仓库通过物资Id和仓库Id查找对应的仓储网格表
+     *       --> 找出多条数据 也就是说多个月台可以装  --> 遍历月台查看每个月台的排队车辆数 寻找最小的排队车辆数的月台
+     *       --> 返回物资ID 和 月台ID
+     * @param materialId 物资ID
+     * @return 月台ID
+     */
+    public Map<String, Object> getPlatId(Integer materialId){
+        Map<String, Object> map = new HashMap<>();
+        Integer platId = null;
+        //一种物资可能在多个仓库中
+        List<Integer> warehouseList = getWarehouseIdByMaterialId(materialId);
+        int countNum = 1000; //初始化比较值
+        for (Integer warehouseId : warehouseList) {
+            HashMap<String, Object> hashMap = new HashMap<>();
+            hashMap.put("materialId", materialId);
+            hashMap.put("warehouseId", warehouseId);
+            //通过物资Id和仓库ID对仓储网格表 再次进行查询并筛选出层次号最高的几条数据
+            List<Map<String, Object>> mesList = getStackGradation(hashMap);
+            //遍历筛选出来的月台 查看当前月台排队车辆数
+            for (Map<String, Object> mesMap : mesList) {
+                BigDecimal platformId = DataChange.dataToBigDecimal(mesMap.get("platformId"));
+                //通过月台ID 和 网格类型 查找当前网格Id
+                hashMap.put("queueLocationId", platformId);
+                hashMap.put("gridType", 1);
+                BigDecimal gridId = rulesMapper.getGridIdByGatepostIdAndGridType(hashMap);
+                //取得排队车辆数
+                int count = queueCountByPlatformId(gridId).intValue();
+                map.put("count", count);
+                //如果当前月台排队车数为0 则直接选择这个月台
+                if(count == 0){
+                    platId = platformId.intValue();
+                    map.put("loadingId", platId);
+                    return map;
+                }
+                //如果排队车辆数小于上个月台排队车辆数
+                if(count < countNum){
+                    countNum = count; //取代比较数
+                    platId = platformId.intValue(); //替换月台ID
+                    map.put("loadingId", platId);
+                }
+            }
+        }
+        return map;
+    }
+
+
+    /**
+     * 计算物资优先级顺序 并计算装车点
+     * @param mapList
+     */
+    public Map<String, Object> calculateMaterialPriority(List<Map<String, Object>> mapList){
+        int compareNum = 100; //优先级比较基准数初始值
+        int compareNum2 = 0; //车辆排队序号
+        Map<String, Object> map = new HashMap<>();
+        for (Map<String, Object> mesMap : mapList) {
+            int materialOrder = DataChange.dataToBigDecimal(mesMap.get("materialOrder")).intValue();
+            if(materialOrder < compareNum){
+                //通过当前物资Id查找装车点
+                Map<String, Object> loadingIdMap = getPlatId(DataChange.dataToBigDecimal(map.get("materialId")).intValue());
+                mesMap.put("loadingId", loadingIdMap.get("loadingId"));
+                compareNum = materialOrder; //替换比较数
+                compareNum2 = (int) loadingIdMap.get("count"); //添加车辆排队比较数
+                map = mesMap;
+            }
+            if(materialOrder == compareNum){//如果优先级相同 计算当前月台排队车辆数
+                //通过当前物资Id查找装车点
+                Map<String, Object> loadingIdMap = getPlatId(DataChange.dataToBigDecimal(map.get("materialId")).intValue());
+                int count = (int) loadingIdMap.get("count");
+                mesMap.put("loadingId", loadingIdMap.get("loadingId"));
+                //如果当前排队车辆数小于上一排队车辆数
+                if(count < compareNum2){
+                    map = mesMap;//更换要返回的map
+                    compareNum2 = count;//替换排队比较数
+                }
+            }
+        }
+        return map;
+    }
+}

src/main/java/com/steerinfo/dil/service/impl/TmstruckLeaveFactoryResultServiceImpl.java

@@ -169,53 +169,6 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
         return i;
     }
 
-    /**
-     * 通过运输订单号查询物资并根据门岗规则计算出厂门岗
-     * @param map
-     * @return
-     */
-    public int calculateGatepost(Map<String, Object> map){
-        BigDecimal materialId = tmstruckLeaveFactoryResultMapper.queryOrderMesByOrderId((String) map.get("orderNumber"));
-        Map<String, Object> map1 = new HashMap<>();
-        map1.put("materialId", materialId);
-        //类型为出厂
-        map1.put("type", 1);
-        List<Map<String, Object>> list = tmstruckLeaveFactoryResultMapper.queryGatepostByMaterialId(map1);
-        for (Map<String, Object> mes : list) {
-            //从数据库中获取门岗开始时间结束时间 若当前时间满足该门岗进门时间 则下放 暂不考虑门岗优先级
-            boolean judgeTime = judgeTime((String)mes.get("startTime"), (String)mes.get("endTime"));
-            if(judgeTime){
-                //更新出厂实绩门岗ID
-                //通过运输订单号获取出厂实绩ID
-                Map<String, Object> map2 = tmstruckLeaveFactoryResultMapper.selectResultId((String) map.get("orderNumber"));
-                TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
-                tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(map2.get("resultId")));
-                tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(mes.get("gatepostId")));
-                return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
-            }
-        }
-        return 0;
-    }
-
-    /**
-     * 判断当前时间是否在时间区间范围内
-     * @param startTime
-     * @param endTime
-     * @return
-     */
-    public boolean judgeTime(String startTime, String endTime){
-        SimpleDateFormat sdf = new SimpleDateFormat("HHmmss");
-        String format = sdf.format(new Date());
-        int begin = Integer.parseInt(startTime);
-        int end = Integer.parseInt(endTime);
-        int now = Integer.parseInt(format);
-        if(begin < end){
-            return now < end && now >= begin;
-        }else {
-            return now < end || now >= begin;
-        }
-    }
-
     /**
      * 更新出厂实绩
      * @param mapValue {运输订单号:orderNumber 门岗名称:gatepostName}
@@ -229,7 +182,7 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
         if(gatepostId != null){
             tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
         }
-        //设置常规字段
+        //设置常规字段 添加 出厂时间 和 出厂方式
         tmstruckLeaveFactoryResult.setResultOutGateTime(new Date());
         tmstruckLeaveFactoryResult.setResultOutMode("手动抬杠");
         tmstruckLeaveFactoryResult.setInsertUsername("admin");

src/main/java/com/steerinfo/dil/service/impl/TmstruckLoadResultServiceImpl.java

@@ -282,7 +282,7 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
     }
 
     /**
-     * 修改装车作业点 多个装车点随机分配给多个装车实绩
+     * 修改装车作业点
      * @param mapList
      * @return
      */

src/main/java/com/steerinfo/dil/service/impl/TmstruckTotalResultServiceImpl.java

@@ -47,7 +47,7 @@ public class TmstruckTotalResultServiceImpl implements ITmstruckTotalResultServi
     }
     /**
      * 展示包月实绩列表
-     * @param map
+     * @param mapValue
      * @return
      */
     public List<Map<String, Object>> getTmstruckMonthResult(Map<String, Object> mapValue) {

src/main/java/com/steerinfo/dil/service/impl/TmstruckWeightResultServiceImpl.java

@@ -1,5 +1,6 @@
 package com.steerinfo.dil.service.impl;
 
+import com.steerinfo.dil.mapper.RulesMapper;
 import com.steerinfo.dil.mapper.TmstruckReceiptResultMapper;
 import com.steerinfo.dil.mapper.TmstruckWeightResultMapper;
 import com.steerinfo.dil.model.TmstruckReceiptResult;
@@ -42,7 +43,12 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
     private UtilsServiceImpl utilsService;
 
     @Autowired
-    private TmstruckLeaveFactoryResultServiceImpl tmstruckLeaveFactoryResultService;
+    private RulesServiceImpl rulesService;
+
+    @Autowired
+    private RulesMapper rulesMapper;
+
+
     /**
      * 查询所有计毛实绩
      * @param map
@@ -134,22 +140,11 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         return tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);
     }
 
-    /**
-     * 通过物资ID获取对应汽车衡 如果有多个汽车衡中随机选择
-     * @param materialId
-     * @return
-     */
-    @Override
-    public int getCalculateIdByMaterial(BigDecimal materialId) {
-        List<Integer> calculateIdList = tmstruckWeightResultMapper.getCalculateIdByMaterial(materialId);
-        return calculateIdList.get((int)(Math.random()*calculateIdList.size()));
-    }
-
     /**
      * 更新计毛实绩 采集需要的数据
      *  运输订单号
      *  汽车衡编号
-     *  //物资名称
+     *  物资名称
      *  毛重
      *  毛重时间
      *  磅单号
@@ -164,36 +159,24 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         map.put("materialId", materialId);
         //通过传来的运输订单号与物资ID查询计重实绩
         map.putAll(tmstruckWeightResultMapper.selectTotalIdByOrderNo(map));
-        BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
-        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-        //添加毛重
-        DecimalFormat df =  new DecimalFormat("0.00");
-        String resultGrossWeight = df.format((double) map.get("resultGrossWeight"));
-        tmstruckWeightResult.setResultGrossWeight(new BigDecimal(resultGrossWeight));
-        //添加毛重时间
-        long resultGrossWeightTime = (long) map.get("resultGrossWeightTime");
-        tmstruckWeightResult.setResultGrossWeightTime(new Date(resultGrossWeightTime));
-
-        //通过汽车衡编号查询汽车衡ID
-        Integer calculateId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("truckCalculateNumber"));
-        //添加计毛汽车衡
-        if(calculateId != null){
-            tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(calculateId));
-        }
+        generateMaoWeightResult(map, tmstruckWeightResult);
         Integer lineSequence = null; //路段顺序号
+        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
         switch (orderType.intValue()){
-            //如果订单类型为销售订单 则执行销售订单计皮规则 resultTareWeight
             case 1:
-                //计算净重  从map中获取皮重 tareWeight
-                double netWeight = ((BigDecimal) map.get("resultGrossWeight")).doubleValue() - ((Double) map.get("tareWeight"));
-                String resultNetWeight = df.format(netWeight);
-                tmstruckWeightResult.setResultNetWeight(new BigDecimal(resultNetWeight));
-                addUpdateRegularField(tmstruckWeightResult); //插入第二次计重时间
-//                lineSequence = 5; //设置路段顺序号为5：出厂
+                //添加第二次计量常规字段
+                addUpdateRegularField(tmstruckWeightResult);
+                //查询当前订单路段顺序号 +1 代表本阶段已完成
+                lineSequence = utilsService.getLineSequenceByOrderId(orderId) + 1;
+                //查询当前计毛是否为最后一拼（针对多拼） （查询是否还有装车实绩没有数据）
+                List<Map<String, Object>> list = rulesMapper.judgeLastMaterial(orderId);
+                if(list.size() != 0){
+                    //如果还有未装车的实绩 则代表还有未装车的物资 计算各个物资装车点 并更新到装车实绩中
+                    
+                }
                 break;
             case 2:
-                break;
             case 3:
                 break;
             case 4:
@@ -202,9 +185,8 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 6:
             case 7:
             case 8: //采购订单记录计毛为第一次计重 添加磅单号
-                tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
                 addInsertRegularField(tmstruckWeightResult); //插入第一次计重时间常规字段
-                lineSequence = 5; //设置路段顺序号为3：卸货
+                lineSequence = utilsService.getLineSequenceByOrderId(orderId) + 1;
                 break;
             case 9:
                 break;
@@ -213,7 +195,6 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 11:
                 break;
         }
-
         int i = tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
         //更新订单路段顺序号
         int i2 = utilsService.updateOrderLineSequence(map, lineSequence);
@@ -221,15 +202,36 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
     }
 
     /**
-     * 通过物资名称和规格型号查询物资Id
-     * 物资名称：materialName   规格型号：materialSpecification
+     * 生成计毛实体类
+     * @param map
      * @return
      */
-    public int queryMaterialIdByMNameAndCode(Map<String, Object> map){
-        return tmstruckWeightResultMapper.getMaterialIdByMaterialNameAndSpe(map);
+    public void generateMaoWeightResult(Map<String, Object> map, TmstruckWeightResult tmstruckWeightResult){
+        //添加磅单号
+        tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
+        //添加查询出来的主键
+        BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
+        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
+        //添加毛重
+        DecimalFormat df =  new DecimalFormat("0.00");
+        String resultGrossWeight = df.format((double) map.get("resultGrossWeight"));
+        tmstruckWeightResult.setResultGrossWeight(new BigDecimal(resultGrossWeight));
+        //添加毛重时间
+        long resultGrossWeightTime = (long) map.get("resultGrossWeightTime");
+        tmstruckWeightResult.setResultGrossWeightTime(new Date(resultGrossWeightTime));
+        //添加净重 (如果传入的净重不为0)
+        BigDecimal resultNetWeight = DataChange.dataToBigDecimal(map.get("resultNetWeight"));
+        if(resultNetWeight.intValue() != 0){
+            tmstruckWeightResult.setResultNetWeight(resultNetWeight);
+        }
+        //通过汽车衡编号查询汽车衡ID
+        Integer calculateId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("truckCalculateNumber"));
+        //添加计毛汽车衡
+        if(calculateId != null){
+            tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(calculateId));
+        }
     }
 
-
     /**
      * 更新计皮实绩  需要采集的数据
      * 运输订单号 orderNumber
@@ -237,6 +239,7 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
      * 皮重 resultTareWeight
      * 皮重时间 resultTareWeightTime
      * 净重
+     * 物资名称   物资规格型号
      * @param map
      * @return
      */
@@ -249,27 +252,16 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         map.put("materialId", materialId);
         //通过传来的运输订单号与物资ID查询计重实绩
         map.putAll(tmstruckWeightResultMapper.selectTotalIdByOrderNo(map));
-        BigDecimal resultId = (BigDecimal) map.get("weightTaskResultId");
-        tmstruckWeightResult.setWeightTaskResultId(resultId);
-        //添加皮重
-        DecimalFormat df =  new DecimalFormat("0.00");
-        String resultTareWeight = df.format((double) map.get("resultTareWeight"));
-        tmstruckWeightResult.setResultTareWeight(new BigDecimal(resultTareWeight));
-        //添加皮重时间
-        long resultTareWeightTime = (long) map.get("resultTareWeightTime");
-        tmstruckWeightResult.setResultTareWeightTime(new Date(resultTareWeightTime));
-        //通过汽车衡编号查询汽车衡ID 添加计皮汽车衡
-        Integer calculateId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("truckCalculateNumber"));
-        if(calculateId != null){
-            tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(calculateId));
-        }
+        generatePiWeightResult(map, tmstruckWeightResult);
         int i = 0;
         Integer lineSequence = null; //路段顺序号
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
         switch (orderType.intValue()){
-            case 1: //销售订单计皮为第一次计重
-                tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
+            case 1:
+                //销售订单计皮为第一次计重
                 addInsertRegularField(tmstruckWeightResult);// 添加插入常规字段 就是第一次计重时间
+                //查询当前订单路段顺序号 +1 代表本阶段已完成
+                lineSequence = utilsService.getLineSequenceByOrderId(DataChange.dataToBigDecimal(map.get("orderId"))) + 1;
                 break;
             case 2:
                 break;
@@ -280,22 +272,14 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 5:
             case 6:
             case 7:
-            case 8:  //如果订单类型为采购订单 则执行采购订单计皮规则
-                //计算净重  先从map中获取毛重 grossWeight
-                double netWeight = ((BigDecimal) map.get("grossWeight")).doubleValue() - ((Double) map.get("resultTareWeight"));
-                String resultNetWeight = df.format(netWeight);
-                tmstruckWeightResult.setResultNetWeight(new BigDecimal(resultNetWeight));
+            case 8:
+                //如果订单类型为采购订单 则执行采购订单计皮规则
                 addUpdateRegularField(tmstruckWeightResult); // 添加更新常规字段 就是第二次计重时间
                 //计皮作业完成后自动完成签收
-                TmstruckReceiptResult tmstruckReceiptResult = new TmstruckReceiptResult();
-                tmstruckReceiptResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
-                tmstruckReceiptResult.setStatus(new BigDecimal(1));
-                tmstruckReceiptResult.setInsertUsername("admin");
-                tmstruckReceiptResult.setInsertTime(new Date());
-                i += tmstruckReceiptResultMapper.updateByTotalResultId(tmstruckReceiptResult);
-                lineSequence = 5; // 出厂
+                i += autoReceipt(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                 //计皮完成后计算出厂门岗并更新实绩出厂门岗ID
-                i += tmstruckLeaveFactoryResultService.calculateGatepost(map);
+                i += rulesService.calculateGatepost(map);
+                lineSequence = 5; // 出厂
                 break;
             case 9:
                 break;
@@ -310,6 +294,50 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         return i;
     }
 
+
+    /**
+     * 生成计皮实绩
+     * @param tmstruckWeightResult
+     * @return
+     */
+    public void generatePiWeightResult(Map<String, Object> map, TmstruckWeightResult tmstruckWeightResult){
+        //添加磅单号
+        tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
+        //添加查询出来的主键
+        BigDecimal resultId = (BigDecimal) map.get("weightTaskResultId");
+        tmstruckWeightResult.setWeightTaskResultId(resultId);
+        //添加皮重
+        DecimalFormat df =  new DecimalFormat("0.00");
+        String resultTareWeight = df.format((double) map.get("resultTareWeight"));
+        tmstruckWeightResult.setResultTareWeight(new BigDecimal(resultTareWeight));
+        //添加皮重时间
+        long resultTareWeightTime = (long) map.get("resultTareWeightTime");
+        tmstruckWeightResult.setResultTareWeightTime(new Date(resultTareWeightTime));
+        //添加净重 (如果传入的净重不为0)
+        BigDecimal resultNetWeight = DataChange.dataToBigDecimal(map.get("resultNetWeight"));
+        if(resultNetWeight.intValue() != 0){
+            tmstruckWeightResult.setResultNetWeight(resultNetWeight);
+        }
+        //通过汽车衡编号查询汽车衡ID 添加计皮汽车衡
+        Integer calculateId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("truckCalculateNumber"));
+        if(calculateId != null){
+            tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(calculateId));
+        }
+    }
+
+    /**
+     * 自动签收
+     * @return
+     */
+    public int autoReceipt(BigDecimal resultTotalId){
+        TmstruckReceiptResult tmstruckReceiptResult = new TmstruckReceiptResult();
+        tmstruckReceiptResult.setResultTotalId(resultTotalId);
+        tmstruckReceiptResult.setStatus(new BigDecimal(1));
+        tmstruckReceiptResult.setInsertUsername("admin");
+        tmstruckReceiptResult.setInsertTime(new Date());
+        return tmstruckReceiptResultMapper.updateByTotalResultId(tmstruckReceiptResult);
+    }
+
     /**
      * 添加首次计重时的常规字段
      * @param tmstruckWeightResult

src/main/java/com/steerinfo/dil/service/impl/UtilsServiceImpl.java

@@ -8,6 +8,7 @@ import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -90,5 +91,25 @@ public class UtilsServiceImpl implements IUtilsService {
         return utilsMapper.queryPlatformIdByName(platformName);
     }
 
+    /**
+     * 查询路段顺序号
+     * @param orderId
+     * @return
+     */
+    @Override
+    public Integer getLineSequenceByOrderId(BigDecimal orderId) {
+        return utilsMapper.getLineSequenceByOrderId(orderId);
+    }
+
+    /**
+     * 查询订单中所需要运输的物资  物资表对订单表 一对多
+     * @param map 运输订单号 orderNumber
+     * @return
+     */
+    @Override
+    public List<Integer> getAllMaterialId(Map<String, Object> map) {
+        return utilsMapper.getAllMaterialId(map);
+    }
+
 
 }

src/main/java/com/steerinfo/dil/util/DataChange.java

@@ -55,7 +55,7 @@ public class DataChange {
             }
             if(data instanceof Double){
                 Double data3 = (Double) data;
-                return new BigDecimal(data3);
+                return new BigDecimal(data3.toString());
             }
             if(data instanceof BigDecimal){
                 return (BigDecimal) data;

src/main/resources/com/steerinfo/dil/mapper/RulesMapper.xml

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.steerinfo.dil.mapper.RulesMapper">
+
+    <!--  根据物资Id、门岗规则(进或出) 查询门岗id -->
+    <select id="queryGatepostByMaterialId" parameterType="java.util.Map" resultType="java.util.Map">
+        select
+        RG.GATEPOST_ID "gatepostId",
+        RGR.RULES_GATEPOST_START_TIME "startTime",
+        RGR.RULES_GATEPOST_END_TIME "endTime"
+        from RMS_GATEPOST RG
+        left join RMS_GATEPOST_RULES RGR
+        on RGR.GATEPOST_ID = RG.GATEPOST_ID
+        left join RMS_MATERIAL_TYPE RMT
+        on RMT.MATERIAL_TYPE_ID = RGR.MATERIAL_TYPE_ID
+        left join RMS_MATERIAL RM
+        on RM.MATERIAL_TYPE_ID = RMT.MATERIAL_TYPE_ID
+        <where>
+            <if test="materialId != null">
+                RM.MATERIAL_ID = #{materialId}
+            </if>
+            <if test="type != null">
+                and RGR.RULES_GATEPOST_ENTRY_OUT_TYPE = #{type}
+            </if>
+        </where>
+        order by
+        "gatepostId"
+    </select>
+
+<!--  通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个称  -->
+    <select id="queryTruckCalculate" parameterType="java.util.Map" resultType="java.lang.Integer">
+        select
+               RTC.TRUCK_CALCULATE_ID
+        from RMS_MATERIAL RM
+        left join RMS_TRUCK_CALCULATE_MATERIAL RTCM
+        on RTCM.MATERIAL_TYPE_ID = RM.MATERIAL_TYPE_ID
+        left join RMS_TRUCK_CALCULATE RTC
+        on RTC.TRUCK_CALCULATE_ID = RTCM.TRUCK_CALCULATE_ID
+        where RM.MATERIAL_ID = #{materialId}
+          and RTC.NATURE = #{nature}
+          and RTC.TRUCK_CALCULATE_STATUS = 1
+    </select>
+
+
+    <!--   查询订单中还未装车的物资信息  -->
+    <select id="judgeLastMaterial" parameterType="java.math.BigDecimal" resultType="java.util.Map">
+        select TLR.RESULT_ID "resultId",
+               TLR.MATERIAL_ID "materialId",
+               RM.MATERIAL_ORDER "materialOrder"
+        from OMSTRUCK_ORDER OO
+                 left join TMSTRUCK_TOTAL_RESULT TTR
+                           on TTR.ORDER_ID = OO.ORDER_ID
+                 left join TMSTRUCK_LOAD_RESULT TLR
+                           on TLR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+                 left join RMS_MATERIAL RM
+                           on RM.MATERIAL_ID = TLR.MATERIAL_ID
+        where TLR.RESULT_LOAD_START_TIME is null and OO.ORDER_ID = #{orderId}
+    </select>
+
+    <!-- 查询门岗 -->
+    <select id="getGridIdByGatepostIdAndGridType" parameterType="java.util.Map" resultType="java.math.BigDecimal">
+        select QQG.GRID_ID
+        from QMS_QUEUE_GRID QQG
+        where QQG.GRID_TYPE = #{gridType}
+          and QQG.QUEUE_LOCATION_ID = #{queueLocationId}
+    </select>
+
+    <!--  查询仓库是否有货  -->
+    <select id="getWarehouseIdByMaterialId" parameterType="java.util.Map" resultType="int">
+        select distinct RPG.WAREHOUSE_ID "warehouseId"
+        from RMS_MATERIAL_STEEL RMS
+                 left join WMSP_GRID_MATERIAL WGM
+                           on RMS.MATERIAL_STEEL_ID = WGM.MATERIAL_ID
+                 left join RMS_PWAREHOUSE_GRID RPG
+                           on RPG.GRID_ID = WGM.GRID_ID
+        where WGM.DELETED = 0
+          and RMS.MATERIAL_ID = #{materialId}
+    </select>
+
+    <!--  通过仓库Id 和 物资Id 查询垛位 层次 月台  仓库 -->
+    <select id="getStackGradation" parameterType="java.util.Map" resultType="java.util.Map">
+        select RPG.WAREHOUSE_ID          "warehouseId",
+               rpg.GRID_GRADATION_NUMBER "gridGradationNumber",
+               RPG.PLATFORM_ID           "platformId",
+               RPG.STACKING_ID           "stackingId"
+
+        from RMS_MATERIAL_STEEL RMS
+                 left join WMSP_GRID_MATERIAL WGM
+                           on RMS.MATERIAL_STEEL_ID = WGM.MATERIAL_ID
+                 left join RMS_PWAREHOUSE_GRID RPG
+                           on RPG.GRID_ID = WGM.GRID_ID
+        where WGM.DELETED = 0
+          and RMS.MATERIAL_ID = #{materialId}
+          and RPG.WAREHOUSE_ID = #{warehouseId}
+          and RPG.GRID_GRADATION_NUMBER = (
+            select MAX(rpg.GRID_GRADATION_NUMBER)
+            from RMS_MATERIAL_STEEL RMS
+                     left join WMSP_GRID_MATERIAL WGM
+                               on RMS.MATERIAL_STEEL_ID = WGM.MATERIAL_ID
+                     left join RMS_PWAREHOUSE_GRID RPG
+                               on RPG.GRID_ID = WGM.GRID_ID
+            where WGM.DELETED = 0
+              and RMS.MATERIAL_ID = #{materialId}
+              and RPG.WAREHOUSE_ID = #{warehouseId})
+    </select>
+
+    <!--  通过网格ID 查询当前网格排队车辆数  -->
+    <select id="queueCountByPlatformId" parameterType="java.math.BigDecimal" resultType="java.math.BigDecimal">
+        select
+            count(*) "count"
+        from QMS_QUEUE_LIST
+        where GRID_ID = #{gridId}
+          and DELETED = 0
+    </select>
+
+
+</mapper>

src/main/resources/com/steerinfo/dil/mapper/TmstruckLeaveFactoryResultMapper.xml

@@ -534,40 +534,6 @@
         <include refid="orderByOutTime"></include>
     </select>
 
-    <!--  根据运单Id查询物资Id-->
-    <select id="queryOrderMesByOrderId" parameterType="string" resultType="java.math.BigDecimal">
-        select OOM.MATERIAL_ID "materialId"
-        from OMSTRUCK_ORDER OO
-                 left join OMSTRUCK_ORDER_MATERIAL OOM
-                           on OO.ORDER_ID = OOM.ORDER_ID
-        where OO.ORDER_NUMBER = #{orderNumber}
-    </select>
-
-    <!--  根据物资Id、门岗规则(进或出) 查询门岗id -->
-    <select id="queryGatepostByMaterialId" parameterType="java.util.Map" resultType="java.util.Map">
-        select
-        RG.GATEPOST_ID "gatepostId",
-        RGR.RULES_GATEPOST_START_TIME "startTime",
-        RGR.RULES_GATEPOST_END_TIME "endTime"
-        from RMS_GATEPOST RG
-        left join RMS_GATEPOST_RULES RGR
-        on RGR.GATEPOST_ID = RG.GATEPOST_ID
-        left join RMS_MATERIAL_TYPE RMT
-        on RMT.MATERIAL_TYPE_ID = RGR.MATERIAL_TYPE_ID
-        left join RMS_MATERIAL RM
-        on RM.MATERIAL_TYPE_ID = RMT.MATERIAL_TYPE_ID
-        <where>
-            <if test="materialId != null">
-                RM.MATERIAL_ID = #{materialId}
-            </if>
-            <if test="type != null">
-                and RGR.RULES_GATEPOST_ENTRY_OUT_TYPE = #{type}
-            </if>
-        </where>
-        order by
-        "gatepostId"
-    </select>
-
     <!--  通过运输订单号查询 路段顺序号是否为 4 ：已计皮-->
     <select id="selectTransportRoute" parameterType="string" resultType="int">
         select ORDER_LINE_SEQUENCE

src/main/resources/com/steerinfo/dil/mapper/TmstruckLoadResultMapper.xml

@@ -821,6 +821,7 @@
         where OO.ORDER_ID = #{orderId}
           and TLR.MATERIAL_ID = #{materialId}
     </select>
+
     <!--通过运输订单号查找装车实绩id-->
     <select id="selectLoadResultIdByOrderNumber" resultType="java.lang.Integer" parameterType="java.util.Map">
         SELECT TLR.RESULT_ID              "loadResultId",
@@ -832,6 +833,7 @@
                            ON TLR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
         WHERE OO.ORDER_NUMBER = #{orderNumber}
     </select>
+
     <!--内转物流查询汽车装车实绩 -->
     <select id="selectLoadResultForConverted" resultType="java.util.LinkedHashMap">
         select APO.PURCHASE_ORDER_NO       "orderNo",

src/main/resources/com/steerinfo/dil/mapper/TmstruckWeightResultMapper.xml

@@ -862,18 +862,6 @@
         where OO.ORDER_ID = #{orderId}
     </select>
 
-    <!-- 通过物资ID查询可计量的汽车衡 -->
-    <select id="getCalculateIdByMaterial" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
-        select RTC.TRUCK_CALCULATE_ID
-        from RMS_MATERIAL RM
-                 left join RMS_TRUCK_CALCULATE_MATERIAL RTCM
-                           on RM.MATERIAL_TYPE_ID = RTCM.MATERIAL_TYPE_ID
-                 join RMS_TRUCK_CALCULATE RTC
-                      on RTC.TRUCK_CALCULATE_ID = RTCM.TRUCK_CALCULATE_ID and RTC.TRUCK_CALCULATE_STATUS = 0
-        where RM.MATERIAL_ID = #{materialId}
-    </select>
-
-
     <!--计量委托查询所需数据-->
     <!--销售查询计毛 -->
     <select id="selectMakesureGrossForSaleByOrderNumber" parameterType="java.lang.String" resultType="java.util.Map">

src/main/resources/com/steerinfo/dil/mapper/UtilsMapper.xml

@@ -56,4 +56,32 @@
         where RPP.PLATFORM_NAME = #{platformName}
     </select>
 
+
+    <!--  根据运单Id查询物资Id  多拼情况下都是属于钢材 -->
+    <select id="queryOrderMesByOrderId" parameterType="string" resultType="java.math.BigDecimal">
+        select *
+        from (select OOM.MATERIAL_ID "materialId"
+              from OMSTRUCK_ORDER OO
+                       left join OMSTRUCK_ORDER_MATERIAL OOM
+                                 on OO.ORDER_ID = OOM.ORDER_ID
+              where OO.ORDER_NUMBER = #{orderNumber}
+             )
+        where rownum = 1
+    </select>
+
+<!--  通过订单ID查找路段顺序号  -->
+    <select id="getLineSequenceByOrderId" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
+        select OO.ORDER_LINE_SEQUENCE
+        from OMSTRUCK_ORDER OO
+        where ORDER_ID = #{orderId}
+    </select>
+
+    <!--  查询订单有几件物资  -->
+    <select id="getAllMaterialId" parameterType="java.util.Map" resultType="int">
+        select OOM.MATERIAL_ID "materialId"
+        from OMSTRUCK_ORDER OO
+                 left join OMSTRUCK_ORDER_MATERIAL OOM
+                           on OO.ORDER_ID = OOM.ORDER_ID
+        where OO.ORDER_NUMBER = #{orderNumber}
+    </select>
 </mapper>