修改装车、计量

pom.xml

@@ -124,7 +124,7 @@
                     <!--包名-->
                     <targetPackage>com.steerinfo.dil</targetPackage>
                     <tables>
-                        <param>TMSTRUCK_WEIGHT_RESULT</param>
+                        <param>TMSTRUCK_LOAD_RESULT</param>
                     </tables>
                 </configuration>
                 <executions>

src/main/java/com/steerinfo/dil/controller/DropDownController.java

@@ -26,7 +26,6 @@ import java.util.Map;
 public class DropDownController extends BaseRESTfulController {
 
     //********************************运输计划下拉框接口******************************************
-
     @Autowired
     DropDownServiceImpl dropDownService;
 
@@ -124,4 +123,18 @@ public class DropDownController extends BaseRESTfulController {
         List<Map<String, Object>> mes = dropDownService.getUnloadPoint(type);
         return success(mes);
     }
+
+    @ApiOperation(value="查询订单下的物资")
+    @GetMapping("/getOrderMaterial/{orderId}")
+    public RESTfulResult getOrderMaterial(@PathVariable("orderId") Integer orderId){
+        List<Map<String, Object>> mes = dropDownService.getOrderMaterial(orderId);
+        return success(mes);
+    }
+
+    @ApiOperation(value="查询仓库下所有月台")
+    @GetMapping("/getPlatformIdByWarehouse/{warehouseId}")
+    public RESTfulResult getPlatformIdByWarehouse(@PathVariable("warehouseId") Integer warehouseId){
+        List<Map<String, Object>> mes = dropDownService.getPlatformIdByWarehouse(warehouseId);
+        return success(mes);
+    }
 }

src/main/java/com/steerinfo/dil/controller/TmstruckLoadResultController.java

@@ -56,6 +56,62 @@ public class TmstruckLoadResultController extends BaseRESTfulController {
         return success(i);
     }
 
+    @ApiOperation(value="查询所有正在排队的销售订单")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
+            @ApiImplicitParam(name = "apiId(227)", value = "动态表头", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
+    })
+    @PostMapping("/getSaleOrderOnQueue")
+    public RESTfulResult getSaleOrderOnQueue(@RequestBody(required=false) Map<String,Object> mapValue,
+                                          Integer apiId,
+                                          Integer pageNum,
+                                          Integer pageSize,
+                                          String con){
+        //框计算
+        if(con != null){
+            if(!"undefined".equals(con)){
+                String index="get_sale_queue_list";//设置要查询的索引名称
+                return success(esFeign.getConResult(mapValue,index,apiId,pageNum,pageSize,con));//获取查询结果
+            }
+        }
+        //不分页筛选数据
+        List<Map<String, Object>> allQueueSaleOrder = null;
+        //如果有条件查询则跳过初始化，和创建索引
+        if(mapValue.size() == 0){
+            //将查询结果存入索引中
+            allQueueSaleOrder = tmstruckLoadResultService.getSaleOrderOnQueue(mapValue);
+            Map<String, Object> map = new HashMap<>();
+            //添加索引
+            map.put("index","get_sale_queue_list");
+            //添加id
+            map.put("indexId","saleOrderQueueId");
+            allQueueSaleOrder.add(map);
+            //新建索引
+            esFeign.insertIndex(allQueueSaleOrder);
+            //删除
+            allQueueSaleOrder.remove(allQueueSaleOrder.size()-1);
+        }
+        if(allQueueSaleOrder == null)
+            allQueueSaleOrder = tmstruckLoadResultService.getSaleOrderOnQueue(mapValue);
+        PageHelper.startPage(pageNum,pageSize);
+        //分页数据
+        List<Map<String, Object>> queueSaleOrder = tmstruckLoadResultService.getSaleOrderOnQueue(mapValue);
+        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allQueueSaleOrder,queueSaleOrder);
+        return success(pageList);
+    }
+
+    @ApiOperation(value="修改装车点和装车顺序：销售钢材专用 ")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "map", value = "", required = false, dataType = "Map"),
+    })
+    @PostMapping("/updateLoadingIdAndLoadSq")
+    public RESTfulResult updateLoadingIdAndLoadSq(@RequestBody(required=false) Map<String, Object> map){
+        int i = tmstruckLoadResultService.updateLoadingIdAndLoadSq(map);
+        return success(i);
+    }
+
     @ApiOperation(value="查询所有装车实绩")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
@@ -186,7 +242,7 @@ public class TmstruckLoadResultController extends BaseRESTfulController {
     })
     @PostMapping("/updateLoadResultList")
     public RESTfulResult updateLoadResultList(@RequestBody(required = false) List<Map<String, Object>> mapList){
-        int i = tmstruckLoadResultService.updateLoadingId(mapList);
+        int i = tmstruckLoadResultService.updateLoadingIds(mapList);
         return success(i);
     }
 

src/main/java/com/steerinfo/dil/controller/TmstruckWeightResultController.java

@@ -183,7 +183,7 @@ public class TmstruckWeightResultController extends BaseRESTfulController {
      */
     @PostMapping("/updateTruckCalculate/{orderId}")
     public RESTfulResult updateTruckCalculate(@PathVariable("orderId") Integer orderId){
-        int i=tmstruckWeightResultService.isNextNeedJl(new BigDecimal(orderId));
+        int i =0;
         return  success(i);
     }
 }

src/main/java/com/steerinfo/dil/feign/QmsFeign.java

@@ -0,0 +1,20 @@
+package com.steerinfo.dil.feign;
+
+import com.steerinfo.framework.controller.RESTfulResult;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.Map;
+
+/**
+ * @ author    :TXF
+ * @ time      :2021/11/19 16:28
+ */
+
+@FeignClient(value = "dil-trick-queue-dev", url = "${openfeign.QmsFeign.url}")
+public interface QmsFeign {
+    //远程调用新增运输订单
+    @PostMapping("api/v1/queueTruck/qmsqueueresults/utilscontroller/addQueueResultByCk")
+    RESTfulResult addQueueResultByCk(@RequestBody Map<String,Object> mapValue);
+}

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

@@ -45,11 +45,17 @@ public interface DropDownMapper {
     List<Map<String, Object>> getPlatformId();
 
     //装货地点下拉框
-    List<Map<String,Object>>   getLoadedPlace();
+    List<Map<String,Object>>  getLoadedPlace();
 
     //外轮船名下拉框
     List<Map<String,Object>> getForeignName();
 
-    //查询卸货点（通过类型判断）
+    //查询卸货点 或 装货点（通过类型判断）
     List<Map<String, Object>> getUnloadPoint(Integer type);
+
+    //通过订单Id查询装车的物资
+    List<Map<String, Object>> getOrderMaterial(Integer orderId);
+
+    //通过仓库ID查询月台ID
+    List<Map<String, Object>> getPlatformIdByWarehouse(Integer warehouseId);
 }

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

@@ -20,7 +20,7 @@ public interface RulesMapper {
     //通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个称
     List<Integer> queryTruckCalculate(Map<String, Object> map);
 
-    //查询当前物资是否为最后一拼（是否还有未装车实绩）
+    //查询未装车实绩
     List<Map<String, Object>> judgeLastMaterial(BigDecimal orderId);
 
     //通过门岗ID 和 网格类型 匹配 网格主键

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

@@ -29,4 +29,7 @@ public interface TmstruckLeaveFactoryResultMapper extends IBaseMapper<TmstruckLe
 
     //销售物流查询所有的出厂实绩
     List<Map<String,Object>> selectAllLeaveFacatoryForSale(Map<String,Object> map);
+
+    //通过总实绩Id
+    BigDecimal getResultIdByTotalId(Integer resultTotalId);
 }

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

@@ -32,8 +32,8 @@ public interface TmstruckLoadResultMapper extends IBaseMapper<TmstruckLoadResult
     //通过订单ID查询批次ID
     BigDecimal getBatchIdByOrderId(BigDecimal orderId);
 
-    //通过订单Id查询装车实绩Id  一个订单可能会有多个装车实绩
-    Integer getLoadResultIdList(Map<String, Object> map);
+    //通过订单Id 和物资ID 查询装车实绩Id  一个订单可能会有多个装车实绩
+    Integer getLoadResultId(Map<String, Object> map);
 
     //根据运输订单号查找运输订单类型
     Integer selectOrderTypeByOrderNumber(String oderNumber);
@@ -80,9 +80,16 @@ public interface TmstruckLoadResultMapper extends IBaseMapper<TmstruckLoadResult
     //通过物资ID和总实绩Id查询唯一的装车实绩Id
     Integer getLoadResultIdByMIdAndTotalId(@Param("resultTotalId") Integer resultTotalId, @Param("materialId") Integer materialId);
 
+    //通过物资ID和订单Id查询唯一的装车实绩Id
+    Integer getLoadIdByOrderIdAndMId(Map<String, Object> map);
+
     //通过物资ID和运输订单号 查找最先扫描Id
     Map<String, Object> getMinScanIdByOrderNum(Map<String, Object> map);
 
     //通过物资唯一编码 查找物资ID
     BigDecimal getMaterialIdByMaterialCode(String materialOnlyCode);
+
+    //查询所有正在进行进厂排队的销售订单
+    List<Map<String, Object>> getSaleOrderOnQueue(Map<String, Object> map);
+
 }

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

@@ -17,6 +17,12 @@ public interface TmstruckWeightResultMapper extends IBaseMapper<TmstruckWeightRe
     @Select("select seq_tmstruck_weight_result.nextval from dual")
     BigDecimal selectMaxId();
 
+    //通过物资ID或运输订单ID查询计量实绩ID
+    Integer getWeightIdByMaterialIdAndOrderId(Map<String, Object> map);
+
+    //通过运输订单号和查询订单Id 和物资ID (针对单拼)
+    Map<String, Object> getOrderIdAndMaterialIdByOrderNum(String orderNumber);
+
     //通过物资名称和规格型号查询物资Id
     Integer getMaterialIdByMaterialNameAndSpe(Map<String, Object> map);
 

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

@@ -38,7 +38,7 @@ public interface UtilsMapper {
     //通过月台名称查找月台Id platformName
     Integer queryPlatformIdByName(String platformName);
 
-    //根据运输订单Id查询物资Id
+    //根据运输订单号查询物资Id
     BigDecimal queryOrderMesByOrderId(String orderNumber);
 
     //查询当前路段顺序号
@@ -46,4 +46,10 @@ public interface UtilsMapper {
 
     //查询订单跟订单物资中间表 查询是否有多个物资Id
     List<Integer> getAllMaterialId(Map<String, Object> map);
+
+    //通过总实绩Id查询订单Id
+    Integer getOrderIdByTotalId(Integer resultTotalId);
+
+    //通过运输订单号查询订单ID
+    BigDecimal getOrderIdByOrderNumber(String orderNumber);
 }

src/main/java/com/steerinfo/dil/model/TmstruckLoadResult.java

@@ -100,9 +100,9 @@ public class TmstruckLoadResult implements IBasePO<BigDecimal> {
     private String insertUpdateRemark;
 
     /**
-     * 状态：0 ：正常 1：逻辑删除(STATUS,DECIMAL,0)
+     * 状态：0 ：正常 1：逻辑删除 (STATUS,DECIMAL,0)
      */
-    @ApiModelProperty(value="状态：0 ：正常 1：逻辑删除",required=false)
+    @ApiModelProperty(value="状态：0 ：正常 1：逻辑删除 ",required=false)
     private BigDecimal status;
 
     /**
@@ -123,6 +123,12 @@ public class TmstruckLoadResult implements IBasePO<BigDecimal> {
     @ApiModelProperty(value="物资ID",required=false)
     private BigDecimal materialId;
 
+    /**
+     * 装车顺序(LOADING_SEQUENCE,DECIMAL,0)
+     */
+    @ApiModelProperty(value="装车顺序",required=false)
+    private BigDecimal loadingSequence;
+
     private static final long serialVersionUID = 1L;
 
     @Override
@@ -287,6 +293,14 @@ public class TmstruckLoadResult implements IBasePO<BigDecimal> {
         this.materialId = materialId;
     }
 
+    public BigDecimal getLoadingSequence() {
+        return loadingSequence;
+    }
+
+    public void setLoadingSequence(BigDecimal loadingSequence) {
+        this.loadingSequence = loadingSequence;
+    }
+
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -312,6 +326,7 @@ public class TmstruckLoadResult implements IBasePO<BigDecimal> {
         sb.append(", resultMeasuredTonnage=").append(resultMeasuredTonnage);
         sb.append(", loadingId=").append(loadingId);
         sb.append(", materialId=").append(materialId);
+        sb.append(", loadingSequence=").append(loadingSequence);
         sb.append(", serialVersionUID=").append(serialVersionUID);
         sb.append("]");
         return sb.toString();

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

@@ -44,4 +44,10 @@ public interface DropDownService {
 
     //查询卸货点（通过类型判断）
     List<Map<String, Object>> getUnloadPoint(Integer type);
+
+    //通过订单Id查询装车的物资
+    List<Map<String, Object>> getOrderMaterial(Integer orderId);
+
+    //通过仓库ID查询月台ID
+    List<Map<String, Object>> getPlatformIdByWarehouse(Integer warehouseId);
 }

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

@@ -33,4 +33,7 @@ public interface IRulesService {
 
     //计算物资优先级顺序 并计算装车点
     Map<String, Object> calculateMaterialPriority(List<Map<String, Object>> mapList);
+
+    //计算装车顺序
+    Map<String, Object> calculateMaterial(List<Map<String, Object>> mapList);
 }

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

@@ -45,7 +45,7 @@ public interface ITmstruckLoadResultService{
     int deleteLoadResult(Integer resultId);
 
     //修改装车作业作业点
-    int updateLoadingId(List<Map<String, Object>> map);
+    int updateLoadingIds(List<Map<String, Object>> map);
 
     //销售查询所有的装车实绩
     List<Map<String,Object>> selectLoadResultForSale(Map<String,Object> map);
@@ -67,6 +67,13 @@ public interface ITmstruckLoadResultService{
 
     //内转物流火车装车新增装车实绩
     int addLoadResultForConverted(Map<String,Object> map);
+
     //销售物流新增装车实绩
     int addLoadResultForSale(Map<String,Object> map);
+
+    //查询所有正在进行进厂排队的销售订单
+    List<Map<String, Object>> getSaleOrderOnQueue(Map<String, Object> map);
+
+    //修改装车点和装车顺序
+    int updateLoadingIdAndLoadSq(Map<String, Object> map);
 }

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

@@ -33,8 +33,4 @@ public interface ITmstruckWeightResultService{
     //新增计皮计毛实绩
     int addWeightResult(Map<String, Object> map);
 
-    /**
-     *通过运输订单判断下一步是否需要计量,更新汽车衡到计量实绩中
-     */
-    int isNextNeedJl(BigDecimal bigDecimal);
 }

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

@@ -27,7 +27,7 @@ public interface IUtilsService {
     Integer queryWarehouseIdByName(String warehouseName);
 
     //用于更新路段顺序号
-    int updateOrderLineSequence(Map<String, Object> map, Integer lineSequence);
+    int updateOrderLineSequence(Map<String, Object> map);
 
     //通过月台名称查找月台Id platformName
     Integer queryPlatformIdByName(String platformName);
@@ -38,4 +38,6 @@ public interface IUtilsService {
     //查询订单跟订单物资中间表 查询是否有多个物资Id
     List<Integer> getAllMaterialId(Map<String, Object> map);
 
+    //通过总实绩Id查询订单Id
+    Integer getOrderIdByTotalId(Integer resultTotalId);
 }

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

@@ -137,4 +137,25 @@ public class DropDownServiceImpl implements DropDownService {
     }
 
 
+    /**
+     * 查询订单下关联的物资
+     * @param orderId
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> getOrderMaterial(Integer orderId) {
+        return dropDownMapper.getOrderMaterial(orderId);
+    }
+
+    /**
+     * 查询仓库对应的月台
+     * @param warehouseId
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> getPlatformIdByWarehouse(Integer warehouseId) {
+        return dropDownMapper.getPlatformIdByWarehouse(warehouseId);
+    }
+
+
 }

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

@@ -79,15 +79,12 @@ public class RulesServiceImpl implements IRulesService {
 
     /**
      * 通过物资ID 和 计量类型 查找汽车衡
-     * @param materialId 物资Id
-     * @param type 1: 进厂秤  2：出厂秤  3：中转
+        materialId 物资Id
+        nature 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);
+    public int calculateWeighbridge(Map<String, Object> map){
+        List<Integer> calculateList = queryTruckCalculate(map);
         //暂时不考虑优先级 随机进行取值
         int size = calculateList.size();
         if(size == 0){
@@ -109,7 +106,7 @@ public class RulesServiceImpl implements IRulesService {
     }
 
     /**
-     * 查询当前物资是否为最后一拼（是否还有未装车实绩）
+     * 查询未装车实绩
      * @param orderId
      * @return
      */
@@ -201,10 +198,10 @@ public class RulesServiceImpl implements IRulesService {
 
 
     /**
-     * 计算物资优先级顺序 并计算装车点
+     * 计算物资优先级顺序 并计算装车点  传入多个物资ID
      * @param mapList
      */
-    public Map<String, Object> calculateMaterialPriority(List<Map<String, Object>> mapList){
+    public Map<String, Object> calculateMaterialPriority (List<Map<String, Object>> mapList){
         int compareNum = 100; //优先级比较基准数初始值
         int compareNum2 = 0; //车辆排队序号
         Map<String, Object> map = new HashMap<>();
@@ -232,4 +229,22 @@ public class RulesServiceImpl implements IRulesService {
         }
         return map;
     }
+
+    /**
+     * 计算装车顺序
+     * @return
+     */
+    public Map<String, Object> calculateMaterial(List<Map<String, Object>> mapList){
+        int compareNum = 100; //比较基准数
+        //传入多个未装车的装车物资ID以及装车顺序
+        Map<String, Object> map = null;
+        for (Map<String, Object> mesMap : mapList) {
+            //获取装车顺序 顺序小的先装
+            BigDecimal loadingSequence = DataChange.dataToBigDecimal(mesMap.get("loadingSequence"));
+            if(loadingSequence.intValue() < compareNum){
+                map = mesMap;
+            }
+        }
+        return map;
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.steerinfo.dil.service.impl;
 
+import com.steerinfo.dil.mapper.RulesMapper;
 import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
 import com.steerinfo.dil.mapper.TmstruckWeightResultMapper;
 import com.steerinfo.dil.model.TmstruckEnfactoryResult;
@@ -11,6 +12,7 @@ import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -42,6 +44,8 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
     @Autowired
     private UtilsServiceImpl utilsService;
 
+    @Autowired
+    private RulesServiceImpl rulesService;
 
 
     /**
@@ -140,15 +144,44 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
         String orderNumber = (String) map.get("orderNumber");
         map.putAll(tmstruckEnfactoryResultMapper.selectEnFactoryResultId(orderNumber));
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
+        i += updateEnFactoryResultByPDA(map); //添加进厂实绩
+        //发计毛委托 计算添加汽车衡
         switch (orderType.intValue()){
             case 1:
-            case 4:
-            case 11:
-                i += updateEnFactoryResultByPDA(map); //添加进厂实绩
+                List<Map<String, Object>> mapList = rulesService.judgeLastMaterial(DataChange.dataToBigDecimal(map.get("orderId")));
+                if(mapList.size() == 1){
+                    //如果是单拼 不需要走计算 直接走钢材的汽车衡
+                    Map<String, Object> mesMap = new HashMap<>();
+                    mesMap.put("materialId",mapList.get(0).get("materialId"));
+                    mesMap.put("nature", 1);
+                    //计算计皮汽车衡
+                    int tarePlaceId = rulesService.calculateWeighbridge(mesMap);
+                    mesMap.put("tarePlaceId", tarePlaceId);
+                    //更新汽车衡
+                    i += tmstruckWeightResultService.updateWeightResult(mesMap);
+                }else {
+                    //如果是多拼
+                    Map<String, Object> mesMap = rulesService.calculateMaterial(mapList);
+                    //获取物资ID
+                    HashMap<String, Object> calculateMap = new HashMap<>();
+                    calculateMap.put("materialId", mesMap.get("materialId"));
+                    calculateMap.put("nature", 1); // 1：进厂秤
+                    //计算计皮汽车衡
+                    int tarePlaceId = rulesService.calculateWeighbridge(calculateMap);
+                    calculateMap.put("tarePlaceId", tarePlaceId);
+                    //更新汽车衡
+                    i += tmstruckWeightResultService.updateWeightResult(calculateMap);
+                }
                 i += tmstruckMeasureCommissionService.addPiMeasureCommission(map); //添加计皮委托
-                i += utilsService.updateOrderLineSequence(map, 4);//修改路段顺序号 4：计皮
                 break;
             case 2:
+            case 3:
+                //计算计皮汽车衡并更新计量实绩
+                i += tmstruckWeightResultService.calculateTruckCalculateByOne(map, 1);
+                //焦炭 水渣 只会有一种物资
+                i += tmstruckMeasureCommissionService.addPiMeasureCommission(map); //添加计皮委托
+                break;
+            case 4:
                 break;
             case 5:
             case 6:
@@ -157,11 +190,13 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
             case 9:
                 i += updateEnFactoryResultByPDA(map); //添加进厂实绩
                 i += tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
-                i += utilsService.updateOrderLineSequence(map, 2);//修改路段顺序号 2：计毛
                 break;
             case 10: // 采购内转（老区-厂内）
                 break;
+            case 11:
         }
+        //路段顺序号 + 1
+        i += utilsService.updateOrderLineSequence(map);
         return i;
     }
 
@@ -184,7 +219,6 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
             case 11:
                 i += updateEnFactoryResultByMJ(map); //添加进厂实绩
                 i += tmstruckMeasureCommissionService.addPiMeasureCommission(map); //添加计皮委托
-                i += utilsService.updateOrderLineSequence(map, 4);//修改路段顺序号 4：计皮
                 break;
             case 2:
                 break;
@@ -195,8 +229,6 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
             case 9:
                 i += updateEnFactoryResultByMJ(map); //添加进厂实绩
                 i += tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
-                i += utilsService.updateOrderLineSequence(map, 2);//修改路段顺序号 2：计毛
-                i += tmstruckWeightResultService.isNextNeedJl(DataChange.dataToBigDecimal(map.get("orderId")));
                 break;
             case 10: // 采购内转（老区-厂内）
                 break;

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

@@ -166,6 +166,8 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
                 break;
             case 11:
         }
+        //路段顺序号 + 1
+        i += utilsService.updateOrderLineSequence(map);
         return i;
     }
 
@@ -189,4 +191,19 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
         tmstruckLeaveFactoryResult.setInsertTime(new Date());
         return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
     }
+
+    /**
+     * 通过总实绩Id修改出厂实绩出厂门岗
+     * @param resultTotalId
+     * @param gatepostId
+     * @return
+     */
+    public int updateLeaveFactoryGatepostId(Integer resultTotalId, Integer gatepostId){
+        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
+        //通过总实绩ID查询出产实绩
+        BigDecimal resultId = tmstruckLeaveFactoryResultMapper.getResultIdByTotalId(resultTotalId);
+        tmstruckLeaveFactoryResult.setResultId(resultId);
+        tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
+        return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
+    }
 }

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

@@ -43,13 +43,20 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
     @Autowired
     private UtilsServiceImpl utilsService;
 
+    @Autowired
+    private RulesServiceImpl rulesService;
+
     @Autowired
     private WmshBoundFeign wmshBoundFeign;
 
     @Autowired
     private WMSFeign wmsFeign;
 
+    @Autowired
+    private TmstruckWeightResultServiceImpl tmstruckWeightResultService;
 
+    @Autowired
+    private TmstruckMeasureCommissionServiceImpl tmstruckMeasureCommissionService;
     /**
      * 查询所有装车实绩
      * @param map
@@ -148,7 +155,20 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
     }
 
     /**
-     * 修改销售钢材装车实绩  （如果是多种物资【多拼】，通过物资Id和运输订单号来确定唯一的装车实绩进行修改）
+     * 更新装车实绩表
+     * @return
+     */
+    public int updateLoadingId(Map<String, Object> map){
+        //获取装车实绩Id  订单ID 物资ID
+        Integer loadResultId = tmstruckLoadResultMapper.getLoadResultId(map);
+        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
+        tmstruckLoadResult.setResultId(new BigDecimal(loadResultId));
+        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
+        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+    }
+
+    /**
+     * PDA新增销售钢材装车实绩  （如果是多种物资【多拼】，通过物资Id和运输订单号来确定唯一的装车实绩进行修改）
      *  materialOnlyCode 物资唯一编码  orderNumber 运输订单号 resultMeasuredTonnage 物资件数
      *  insertUpdateRemark 备注  platformName 月台名称
      * @param map
@@ -159,6 +179,7 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         BigDecimal materialId = tmstruckLoadResultMapper.getMaterialIdByMaterialCode((String) map.get("materialOnlyCode"));
         //通过运输订单号查找总实绩ID
         Integer resultTotalId = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
+        map.put("resultTotalId", resultTotalId);
         //通过总实绩ID与物资ID查找 装车实绩主键ID
         Integer resultId = tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId, materialId.intValue());
         TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
@@ -189,19 +210,26 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         }
         // 添加备注
         tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
-        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        //更新汽车衡
+        i += tmstruckWeightResultService.calculateTruckCalculate(map, resultTotalId);
+        //发送计毛委托 订单类型：1
+        map.put("orderTypee", 1);
+        tmstruckMeasureCommissionService.addMaoMeasureCommission(map);
+        return i;
     }
 
     /**
-     * 修改销售钢渣、水渣、危化品装车实绩
+     * PDA新增销售钢渣、水渣、危化品装车实绩
      * loadStartTime 装车开始时间   resultMeasuredTonnage 计量吨位
      * warehouseName  仓库名称      orderNumber 运输订单号   insertUpdateRemark 备注
      * @param map
      * @return
      */
     public int addXS2LoadResult(Map<String, Object> map){
-        //通过运输订单号 查询 总实绩ID
+        //通过运输订单号 查询 总实绩ID、订单类型
         Integer resultTotalId = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
+        Integer orderType = tmstruckLoadResultMapper.selectOrderTypeByOrderNumber((String) map.get("orderNumber"));
         //查询装车实绩ID
         Integer resultId = tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId, null);
         TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
@@ -227,7 +255,14 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
             tmstruckLoadResult.setLoadingId(new BigDecimal(warehouseId));
         }
         tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
-        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        //装车成功后计算计毛汽车衡（出厂：2）
+        i += tmstruckWeightResultService.calculateTruckCalculateByOne(map, 2);
+        //发送计毛委托
+        map.put("resultTotalId", resultTotalId);
+        map.put("orderTypee", orderType);
+        tmstruckMeasureCommissionService.addMaoMeasureCommission(map);
+        return i;
     }
 
     /**
@@ -257,6 +292,8 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
     }
 
+
+
     /**
      * 通过ID查询装车实绩
      *
@@ -287,13 +324,13 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
      * @return
      */
     @Override
-    public int updateLoadingId(List<Map<String, Object>> mapList) {
+    public int updateLoadingIds(List<Map<String, Object>> mapList) {
         int i = 0;
         //获取所有装车实绩ID
         for (Map<String, Object> map : mapList) {
             TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
             //通过传过来的物资ID（一个订单中物资ID唯一） 和订单Id 寻找装车实绩ID
-            Integer resultIdList = tmstruckLoadResultMapper.getLoadResultIdList(map);
+            Integer resultIdList = tmstruckLoadResultMapper.getLoadResultId(map);
             tmstruckLoadResult.setResultId(new BigDecimal(resultIdList));
             //获取算出来的装车点
             tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
@@ -494,4 +531,39 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         return i;
 }
 
+    /**
+     * 查询所有正在排队的销售订单
+     * @param map
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> getSaleOrderOnQueue(Map<String, Object> map) {
+        return tmstruckLoadResultMapper.getSaleOrderOnQueue(map);
+    }
+
+
+    /**
+     * 修改装车点和装车顺序
+     * @param map
+     * @return
+     */
+    public int updateLoadingIdAndLoadSq(Map<String, Object> map){
+        //前端传来数据结构类型为 {order: Integer, list: List<Map<String, Object>>}
+        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
+        List<Map<String, Object>> list = (List<Map<String, Object>>) map.get("list");
+        int i = 0;
+        for (Map<String, Object> mesMap : list) {
+            mesMap.put("orderId", orderId);
+            //通过物资ID和订单ID查询装车实绩ID
+            Integer resultId = tmstruckLoadResultMapper.getLoadIdByOrderIdAndMId(mesMap);
+            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
+            tmstruckLoadResult.setResultId(new BigDecimal(resultId));
+            //设置装车顺序
+            tmstruckLoadResult.setLoadingSequence(DataChange.dataToBigDecimal(mesMap.get("serialNumber")));
+            //设置装车月台
+            tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(mesMap.get("platformId")));
+            i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        }
+        return i;
+    }
 }

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

@@ -146,8 +146,6 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
                 i += updateUnloadResultBy(map); //更新卸货实绩
                 i += tmstruckMeasureCommissionService.addPiMeasureCommission(map); //卸货完成后新增一条计皮委托 并发送计皮委托
                 i += tmstruckReceiptResultService.addReceiptResult(map); //新增完卸车实绩后新增一条收货实绩
-                i += utilsService.updateOrderLineSequence(map, 4);//修改路段顺序号 4：计皮
-                i += tmstruckWeightResultService.isNextNeedJl(DataChange.dataToBigDecimal(map.get("orderId")));//卸货完成后计算计皮汽车衡
                 break;
             case 9:
                 break;
@@ -156,6 +154,8 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
             case 11:
 
         }
+        //路段顺序号 + 1
+        i += utilsService.updateOrderLineSequence(map);
         return i;
     }
 

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

@@ -1,8 +1,10 @@
 package com.steerinfo.dil.service.impl;
 
+import com.steerinfo.dil.feign.QmsFeign;
 import com.steerinfo.dil.mapper.RulesMapper;
 import com.steerinfo.dil.mapper.TmstruckReceiptResultMapper;
 import com.steerinfo.dil.mapper.TmstruckWeightResultMapper;
+import com.steerinfo.dil.mapper.UtilsMapper;
 import com.steerinfo.dil.model.TmstruckReceiptResult;
 import com.steerinfo.dil.model.TmstruckWeightResult;
 import com.steerinfo.dil.service.ITmstruckWeightResultService;
@@ -14,6 +16,7 @@ import org.springframework.transaction.annotation.Transactional;
 import java.math.BigDecimal;
 import java.text.DecimalFormat;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -42,13 +45,23 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
     @Autowired
     private UtilsServiceImpl utilsService;
 
+    @Autowired
+    private UtilsMapper utilsMapper;
+
+    @Autowired
+    private QmsFeign qmsFeign;
+
     @Autowired
     private RulesServiceImpl rulesService;
 
     @Autowired
     private RulesMapper rulesMapper;
 
+    @Autowired
+    private TmstruckLoadResultServiceImpl tmstruckLoadResultService;
 
+    @Autowired
+    private TmstruckLeaveFactoryResultServiceImpl tmstruckLeaveFactoryResultService;
     /**
      * 查询所有计毛实绩
      * @param map
@@ -160,20 +173,33 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         //通过传来的运输订单号与物资ID查询计重实绩
         map.putAll(tmstruckWeightResultMapper.selectTotalIdByOrderNo(map));
         generateMaoWeightResult(map, tmstruckWeightResult);
-        Integer lineSequence = null; //路段顺序号
         BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
+        int i = 0;
         switch (orderType.intValue()){
             case 1:
                 //添加第二次计量常规字段
                 addUpdateRegularField(tmstruckWeightResult);
-                //查询当前订单路段顺序号 +1 代表本阶段已完成
-                lineSequence = utilsService.getLineSequenceByOrderId(orderId) + 1;
                 //查询当前计毛是否为最后一拼（针对多拼） （查询是否还有装车实绩没有数据）
                 List<Map<String, Object>> list = rulesMapper.judgeLastMaterial(orderId);
-                if(list.size() != 0){
+                if(list.size() == 0){
+                    //如果没有未装车的装车实绩则计算出厂门岗并更新出厂实绩
+                    BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
+                    //计算出厂门岗 更新出厂门岗
+                    int gatepostId = rulesService.calculateGatepost(map);
+                    i += tmstruckLeaveFactoryResultService.updateLeaveFactoryGatepostId(resultTotalId.intValue(), gatepostId);
+                }else {
                     //如果还有未装车的实绩 则代表还有未装车的物资 计算各个物资装车点 并更新到装车实绩中
-                    
+                    //如果是多拼 使用多种物资计算第一个装货的物资和装车点
+                    Map<String, Object> platIdMap = rulesService.calculateMaterial(list); //获得materialId  loadingId
+                    platIdMap.put("orderId", map.get("orderId"));
+                    i += tmstruckLoadResultService.updateLoadingId(platIdMap); //更新装货点
+                    //更新下一计量实绩以当前毛重为皮重
+                    platIdMap.put("resultTareWeight", map.get("resultGrossWeight"));
+                    i += updateWeightResult(platIdMap);
+                    //添加仓库排队
+                    platIdMap.put("orderNumber", map.get("orderNumber"));
+                    qmsFeign.addQueueResultByCk(platIdMap);
                 }
                 break;
             case 2:
@@ -186,7 +212,6 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 7:
             case 8: //采购订单记录计毛为第一次计重 添加磅单号
                 addInsertRegularField(tmstruckWeightResult); //插入第一次计重时间常规字段
-                lineSequence = utilsService.getLineSequenceByOrderId(orderId) + 1;
                 break;
             case 9:
                 break;
@@ -195,10 +220,10 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 11:
                 break;
         }
-        int i = tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-        //更新订单路段顺序号
-        int i2 = utilsService.updateOrderLineSequence(map, lineSequence);
-        return i +i2;
+        i += tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
+        //路段顺序号 + 1
+        i += utilsService.updateOrderLineSequence(map);
+        return i;
     }
 
     /**
@@ -239,7 +264,7 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
      * 皮重 resultTareWeight
      * 皮重时间 resultTareWeightTime
      * 净重
-     * 物资名称   物资规格型号
+     * 物资名称:materialName   物资规格:materialSpecification  型号:materialModel
      * @param map
      * @return
      */
@@ -250,22 +275,39 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         //通过物资名称和物资规格查询物资Id
         int materialId = tmstruckWeightResultMapper.getMaterialIdByMaterialNameAndSpe(map);
         map.put("materialId", materialId);
-        //通过传来的运输订单号与物资ID查询计重实绩
+        //通过传来的运输订单号 与 物资ID查询计重实绩ID
         map.putAll(tmstruckWeightResultMapper.selectTotalIdByOrderNo(map));
         generatePiWeightResult(map, tmstruckWeightResult);
         int i = 0;
-        Integer lineSequence = null; //路段顺序号
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
         switch (orderType.intValue()){
             case 1:
                 //销售订单计皮为第一次计重
-                addInsertRegularField(tmstruckWeightResult);// 添加插入常规字段 就是第一次计重时间
-                //查询当前订单路段顺序号 +1 代表本阶段已完成
-                lineSequence = utilsService.getLineSequenceByOrderId(DataChange.dataToBigDecimal(map.get("orderId"))) + 1;
+                addInsertRegularField(tmstruckWeightResult);// 添加插入常规字段 就是第一次计重时间;
+                //查询还未装车的物资
+                List<Map<String, Object>> mapList = rulesService.judgeLastMaterial(DataChange.dataToBigDecimal(map.get("orderId")));
+                if(mapList.size() == 1){
+                    //如果是单拼 则直接
+                    Map<String, Object> mesMap = mapList.get(0);
+                    i += tmstruckLoadResultService.updateLoadingId(mesMap); //更新装货点
+                    //添加仓库排队
+                    mesMap.put("orderNumber", map.get("orderNumber"));
+                    qmsFeign.addQueueResultByCk(mesMap);
+                }else {
+                    //如果是多拼 使用多种物资计算第一个装货的物资和装车点
+                    Map<String, Object> platIdMap = rulesService.calculateMaterial(mapList); //获得materialId  loadingId
+                    platIdMap.put("orderId", map.get("orderId"));
+                    i += tmstruckLoadResultService.updateLoadingId(platIdMap); //更新装货点
+                    //添加仓库排队
+                    platIdMap.put("orderNumber", map.get("orderNumber"));
+                    qmsFeign.addQueueResultByCk(platIdMap);
+                }
                 break;
             case 2:
-                break;
             case 3:
+                //销售订单计皮为第一次计重
+                addInsertRegularField(tmstruckWeightResult);// 添加插入常规字段 就是第一次计重时间;
+                //焦炭、水渣只有一种物资  装货点是通过发运计划的时候填写的
                 break;
             case 4:
                 break;
@@ -279,7 +321,6 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
                 i += autoReceipt(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                 //计皮完成后计算出厂门岗并更新实绩出厂门岗ID
                 i += rulesService.calculateGatepost(map);
-                lineSequence = 5; // 出厂
                 break;
             case 9:
                 break;
@@ -289,8 +330,8 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
                 break;
         }
         i += tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-        //更新订单路段顺序号
-        i += utilsService.updateOrderLineSequence(map, lineSequence);
+        //路段顺序号 + 1
+        i += utilsService.updateOrderLineSequence(map);
         return i;
     }
 
@@ -325,6 +366,27 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         }
     }
 
+    /**
+     * 更新计量实绩  计皮点  计毛点  皮重
+     * @param map
+     */
+    public int updateWeightResult(Map<String, Object> map){
+        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
+        //通过物资ID和运输订单Id修改查找计量实绩ID
+        Integer id = tmstruckWeightResultMapper.getWeightIdByMaterialIdAndOrderId(map);
+        tmstruckWeightResult.setId(new BigDecimal(id));
+        if(map.get("tarePlaceId") != null){ //如果皮重汽车衡不为空 更新皮重汽车衡
+            tmstruckWeightResult.setResultTarePlaceId(DataChange.dataToBigDecimal(map.get("tarePlaceId")));
+        }
+        if(map.get("grossPlaceId") != null){//如果毛重汽车衡不为空 更新毛重汽车衡
+            tmstruckWeightResult.setResultGrossPlaceId(DataChange.dataToBigDecimal(map.get("grossPlaceId")));
+        }
+        if(map.get("resultTareWeight")!= null){ //如果皮重不为空 更新皮重
+            tmstruckWeightResult.setResultTareWeight(DataChange.dataToBigDecimal(map.get("resultTareWeight")));
+        }
+        return tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
+    }
+
     /**
      * 自动签收
      * @return
@@ -356,110 +418,61 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
         tmstruckWeightResult.setUpdateTime(new Date());
         tmstruckWeightResult.setUpdateUsername("admin");
     }
+
     /**
-     *通过运输订单判断下一步是否需要计量,更新汽车衡到计量实绩中
+     * 多拼计算计毛汽车衡
+     * @param map
      */
-    @Override
-    public int isNextNeedJl(BigDecimal orderId) {
-        //通过运输订单id获取路段顺序号、物资类型、计量实绩主键、line_id
-        Map<String,BigDecimal> map = tmstruckWeightResultMapper.selectByOrderId(orderId);
-        //通过运输订单id获取物资的类型
-        BigDecimal materialTypeId = DataChange.dataToBigDecimal(map.get("materialTypeId"));
-        //获取路段顺序号
-        BigDecimal orderLineSequence = DataChange.dataToBigDecimal(map.get("orderLineSequence"));
-        //计量实绩主键
-        BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
-        //line_id
-        BigDecimal lineId=new BigDecimal(map.get("lineId").toString());
-        //通过运输线路判断下一步是否为计量，当前是啥，下下一步是啥
-        //如果下一步为计量，且当前步为进厂，则选择进厂称，如果下下步为出厂则选择出厂称，其他则选择中转称
-        List<BigDecimal> list=getNextStep(lineId,orderLineSequence.intValue());
-        if(list.size()==3){
-            //0:进厂；1：计毛；2：计皮；3：卸货；4：装货；5：出厂
-            if(list.get(1).intValue()==1 || list.get(1).intValue()==2){
-                //如果当前为进厂
-                if(list.get(0).intValue()==0){
-                    //获取到汽车衡id
-                    BigDecimal truckCalculateId =tmstruckWeightResultMapper.getTruckCalculateNumber(materialTypeId,new BigDecimal(1));
-                    //将获取到的汽车衡id更新到计量实绩表中
-                    //如果下一步为计毛作业
-                    if(list.get(1).intValue()==1){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultGrossPlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                    //如果下一步为计皮作业
-                    if(list.get(1).intValue()==2){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultTarePlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                }
-                //如果计量后一步为出厂
-                else if(list.get(2).intValue()==5){
-                    //获取到汽车衡id
-                    BigDecimal truckCalculateId =tmstruckWeightResultMapper.getTruckCalculateNumber(materialTypeId,new BigDecimal(2));
-                    //将获取到的汽车衡id更新到计量实绩表中
-                    //如果下一步为计毛作业
-                    if(list.get(1).intValue()==1){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultGrossPlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                    //如果下一步为计皮作业
-                    if(list.get(1).intValue()==2){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultTarePlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                }else{
-                    //获取到汽车衡id
-                    BigDecimal truckCalculateId =tmstruckWeightResultMapper.getTruckCalculateNumber(materialTypeId,new BigDecimal(3));
-                    //将获取到的汽车衡id更新到计量实绩表中
-                    //如果下一步为计毛作业
-                    if(list.get(1).intValue()==1){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultGrossPlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                    //如果下一步为计皮作业
-                    if(list.get(1).intValue()==2){
-                        //通过订单号获取计量实绩主键，并更新
-                        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
-                        tmstruckWeightResult.setWeightTaskResultId(weightTaskResultId);
-                        tmstruckWeightResult.setResultTarePlaceId(truckCalculateId);
-                        tmstruckWeightResult.setUpdateTime(new Date());
-                        tmstruckWeightResult.setUpdateUsername("admin");
-                        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
-                    }
-                }
-            }
+    public int calculateTruckCalculate(Map<String, Object> map, Integer resultTotalId){
+        //通过总实绩ID查询订单Id
+        Integer orderId = utilsService.getOrderIdByTotalId(resultTotalId);
+        //查询未装车的装车实绩
+        List<Map<String, Object>> list = rulesService.judgeLastMaterial(new BigDecimal(orderId));
+        Map<String, Object> mesMap = new HashMap<>(); //用于查询更新存放数据map
+        mesMap.put("orderId", orderId);
+        int i = 0;
+        if(list.size() == 0){
+            //如果是最后一拼则走出厂称 计算出厂称
+            mesMap.put("materialId", map.get("materialId"));
+            mesMap.put("nature", 1);
+            Integer calculate = rulesService.calculateWeighbridge(mesMap);
+            //更新汽车衡
+            mesMap.put("grossPlaceId", calculate);
+            i += updateWeightResult(mesMap);
         }else {
-            return 0;
+            //如果后面还有物资未装车 则走拼装秤 10号秤 (固定数据)
+            mesMap.put("materialId", map.get("materialId"));
+            mesMap.put("grossPlaceId", 10);
+            i += updateWeightResult(mesMap);
         }
-        return 1;
+        return i;
     }
 
+    /**
+     * 单拼销售计算汽车衡
+     * @return
+     */
+    public int calculateTruckCalculateByOne(Map<String, Object> map, Integer type){
+        String orderNumber = (String) map.get("orderNumber");
+        //通过运输订单号查找物资ID、订单ID
+        Map<String, Object> oIdAndMidMap = tmstruckWeightResultMapper.getOrderIdAndMaterialIdByOrderNum(orderNumber);
+        //通过物资ID计算汽车衡
+        if(type == 1){
+            //1：进厂
+            oIdAndMidMap.put("nature", type); //1: 进厂秤
+            int calculateId = rulesService.calculateWeighbridge(oIdAndMidMap);
+            oIdAndMidMap.put("tarePlaceId", calculateId);
+
+        }else if(type == 2){
+            //2：出厂
+            oIdAndMidMap.put("nature", type); //2: 出厂称
+            int calculateId = rulesService.calculateWeighbridge(oIdAndMidMap);
+            oIdAndMidMap.put("grossPlaceId", calculateId);
+        }
+        return updateWeightResult(oIdAndMidMap);
+    }
+
+
     public List<BigDecimal> getNextStep(BigDecimal lineId, int orderLineSequence) {
         return tmstruckWeightResultMapper.getNextStep(lineId,orderLineSequence);
     }

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

@@ -3,6 +3,7 @@ package com.steerinfo.dil.service.impl;
 import com.steerinfo.dil.mapper.UtilsMapper;
 import com.steerinfo.dil.service.IUtilsService;
 import com.steerinfo.dil.util.DataChange;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTIgnoredError;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -73,12 +74,20 @@ public class UtilsServiceImpl implements IUtilsService {
 
     /**
      * 用于更新路段顺序号
-     * @param map  orderId 运输订单号
+     * @param map 运输订单号 或者是运输订单ID
      * @return
      */
-    public int updateOrderLineSequence(Map<String, Object> map, Integer lineSequence){
-        map.put("orderLineSequence", lineSequence);
-        return utilsMapper.updateLineSeqByOrderIdOrNum(map);
+    public int updateOrderLineSequence(Map<String, Object> map){
+        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
+        if(orderId.intValue() == 0){
+            //如果没有传入运输订单Id则应该传入了运输订单号
+            orderId = utilsMapper.getOrderIdByOrderNumber((String) map.get("orderNumber"));
+        }
+        Integer lineSequence = getLineSequenceByOrderId(orderId);
+        Map<String, Object> mesMap = new HashMap<>();
+        mesMap.put("orderId", orderId);
+        mesMap.put("orderLineSequence", lineSequence + 1);
+        return utilsMapper.updateLineSeqByOrderIdOrNum(mesMap);
     }
 
     /**
@@ -112,4 +121,15 @@ public class UtilsServiceImpl implements IUtilsService {
     }
 
 
+    /**
+     * 通过总实绩ID查询订单Id
+     * @param resultTotalId
+     * @return
+     */
+    @Override
+    public Integer getOrderIdByTotalId(Integer resultTotalId) {
+        return utilsMapper.getOrderIdByTotalId(resultTotalId);
+    }
+
+
 }

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

@@ -117,7 +117,7 @@ public class DataChange {
                     String resultDeduction = df.format(oldDate.doubleValue());
                     map.put(s, resultDeduction);
                 } catch (Exception e) {
-                    e.printStackTrace();
+                    System.out.println("原料扣减量数据有误");
                 }
 
             }

src/main/resources/bootstrap.yml

@@ -29,6 +29,8 @@ openfeign:
     url: ${OMSFEIGN_URL:localhost:8095}
   JoinFeign:
     url: ${JOINFEIGN_URL:localhost:8066}
+  QmsFeign:
+    url: ${QMSFEIGN_URL:localhost:8087}
 
 
 #eureka设置

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

@@ -122,6 +122,7 @@
                DB.RESULT_FOREIGN_SHIP_NAME "label"
         FROM DIL_BATCH DB
     </select>
+
     <!--装货地点下拉框-->
     <select id="getLoadedPlace" resultType="java.util.LinkedHashMap">
         select RAS.ARRIVAL_ID "id",
@@ -137,4 +138,32 @@
         from RMS_WAREHOUSE RW
         where RW.WAREHOUSE_TYPE_ID = #{type}
     </select>
+
+<!-- 查询订单下所有的物资  -->
+    <select id="getOrderMaterial" parameterType="int" resultType="java.util.Map">
+        select
+             OOM.MATERIAL_ID "id",
+             OOM.MATERIAL_ID "value",
+             RM.MATERIAL_NAME "label"
+        from OMSTRUCK_ORDER OO
+        join  OMSTRUCK_ORDER_MATERIAL OOM
+        on OOM.ORDER_ID = OO.ORDER_ID
+        left join RMS_MATERIAL RM
+        on RM.MATERIAL_ID = OOM.MATERIAL_ID
+        where OO.ORDER_ID = #{orderId}
+    </select>
+    
+<!--   查询仓库对应的月台 -->
+    <select id="getPlatformIdByWarehouse" parameterType="int" resultType="java.util.Map">
+        select
+            RPP.PLATFORM_ID "id",
+            RPP.PLATFORM_ID "value",
+            RPP.PLATFORM_NAME "label"
+        from (  SELECT DISTINCT
+                RPG.PLATFORM_ID
+                FROM "RMS_PWAREHOUSE_GRID" RPG
+                WHERE RPG.WAREHOUSE_ID = #{warehouseId} AND PLATFORM_ID IS NOT NULL ) T
+        left join RMS_PWAREHOUSE_PLATFORM RPP
+        on RPP.PLATFORM_ID = T.PLATFORM_ID
+    </select>
 </mapper>

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

@@ -46,7 +46,8 @@
     <select id="judgeLastMaterial" parameterType="java.math.BigDecimal" resultType="java.util.Map">
         select TLR.RESULT_ID "resultId",
                TLR.MATERIAL_ID "materialId",
-               RM.MATERIAL_ORDER "materialOrder"
+               TLR.LOADING_SEQUENCE "loadingSequence",
+               TLR.LOADING_ID "loadingId"
         from OMSTRUCK_ORDER OO
                  left join TMSTRUCK_TOTAL_RESULT TTR
                            on TTR.ORDER_ID = OO.ORDER_ID

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

@@ -741,4 +741,11 @@
             </if>
         </where>
     </select>
+
+<!-- 通过总实绩Id 查询出厂实绩ID   -->
+    <select id="getResultIdByTotalId" parameterType="int" resultType="java.math.BigDecimal">
+        select TLFR.RESULT_ID
+        from TMSTRUCK_LEAVE_FACTORY_RESULT TLFR
+        where TLFR.RESULT_TOTAL_ID = #{resultTotalId}
+    </select>
 </mapper>

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

@@ -2,47 +2,45 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.steerinfo.dil.mapper.TmstruckLoadResultMapper">
     <resultMap id="BaseResultMap" type="com.steerinfo.dil.model.TmstruckLoadResult">
-        <id column="RESULT_ID" jdbcType="DECIMAL" property="resultId"/>
-        <result column="RESULT_TOTAL_ID" jdbcType="DECIMAL" property="resultTotalId"/>
-        <result column="RESULT_LOAD_START_TIME" jdbcType="TIMESTAMP" property="resultLoadStartTime"/>
-        <result column="RESULT_LOAD_END_TIME" jdbcType="TIMESTAMP" property="resultLoadEndTime"/>
-        <result column="RESULT_LOAD_DURATION" jdbcType="DECIMAL" property="resultLoadDuration"/>
-        <result column="LOAD_STANDARD_TIME_ID" jdbcType="DECIMAL" property="loadStandardTimeId"/>
-        <result column="LOADER_ID" jdbcType="DECIMAL" property="loaderId"/>
-        <result column="RESULT_ISCLEAR" jdbcType="VARCHAR" property="resultIsclear"/>
-        <result column="DELETE_NAME" jdbcType="VARCHAR" property="deleteName"/>
-        <result column="DELETE_TIME" jdbcType="TIMESTAMP" property="deleteTime"/>
-        <result column="INSERT_USERNAME" jdbcType="VARCHAR" property="insertUsername"/>
-        <result column="INSERT_TIME" jdbcType="TIMESTAMP" property="insertTime"/>
-        <result column="UPDATE_USERNAME" jdbcType="VARCHAR" property="updateUsername"/>
-        <result column="UPDATE_TIME" jdbcType="TIMESTAMP" property="updateTime"/>
-        <result column="INSERT_UPDATE_REMARK" jdbcType="VARCHAR" property="insertUpdateRemark"/>
-        <result column="STATUS" jdbcType="DECIMAL" property="status"/>
-        <result column="RESULT_MEASURED_TONNAGE" jdbcType="DECIMAL" property="resultMeasuredTonnage"/>
-        <result column="LOADING_ID" jdbcType="DECIMAL" property="loadingId"/>
-        <result column="MATERIAL_ID" jdbcType="DECIMAL" property="materialId"/>
+        <id column="RESULT_ID" jdbcType="DECIMAL" property="resultId" />
+        <result column="RESULT_TOTAL_ID" jdbcType="DECIMAL" property="resultTotalId" />
+        <result column="RESULT_LOAD_START_TIME" jdbcType="TIMESTAMP" property="resultLoadStartTime" />
+        <result column="RESULT_LOAD_END_TIME" jdbcType="TIMESTAMP" property="resultLoadEndTime" />
+        <result column="RESULT_LOAD_DURATION" jdbcType="DECIMAL" property="resultLoadDuration" />
+        <result column="LOAD_STANDARD_TIME_ID" jdbcType="DECIMAL" property="loadStandardTimeId" />
+        <result column="LOADER_ID" jdbcType="DECIMAL" property="loaderId" />
+        <result column="RESULT_ISCLEAR" jdbcType="VARCHAR" property="resultIsclear" />
+        <result column="DELETE_NAME" jdbcType="VARCHAR" property="deleteName" />
+        <result column="DELETE_TIME" jdbcType="TIMESTAMP" property="deleteTime" />
+        <result column="INSERT_USERNAME" jdbcType="VARCHAR" property="insertUsername" />
+        <result column="INSERT_TIME" jdbcType="TIMESTAMP" property="insertTime" />
+        <result column="UPDATE_USERNAME" jdbcType="VARCHAR" property="updateUsername" />
+        <result column="UPDATE_TIME" jdbcType="TIMESTAMP" property="updateTime" />
+        <result column="INSERT_UPDATE_REMARK" jdbcType="VARCHAR" property="insertUpdateRemark" />
+        <result column="STATUS" jdbcType="DECIMAL" property="status" />
+        <result column="RESULT_MEASURED_TONNAGE" jdbcType="DECIMAL" property="resultMeasuredTonnage" />
+        <result column="LOADING_ID" jdbcType="DECIMAL" property="loadingId" />
+        <result column="MATERIAL_ID" jdbcType="DECIMAL" property="materialId" />
+        <result column="LOADING_SEQUENCE" jdbcType="DECIMAL" property="loadingSequence" />
     </resultMap>
     <sql id="columns">
         RESULT_ID, RESULT_TOTAL_ID, RESULT_LOAD_START_TIME, RESULT_LOAD_END_TIME, RESULT_LOAD_DURATION,
-    LOAD_STANDARD_TIME_ID, LOADER_ID, RESULT_ISCLEAR, DELETE_NAME, DELETE_TIME, INSERT_USERNAME, 
-    INSERT_TIME, UPDATE_USERNAME, UPDATE_TIME, INSERT_UPDATE_REMARK, STATUS, RESULT_MEASURED_TONNAGE, 
-    LOADING_ID, MATERIAL_ID
+    LOAD_STANDARD_TIME_ID, LOADER_ID, RESULT_ISCLEAR, DELETE_NAME, DELETE_TIME, INSERT_USERNAME,
+    INSERT_TIME, UPDATE_USERNAME, UPDATE_TIME, INSERT_UPDATE_REMARK, STATUS, RESULT_MEASURED_TONNAGE,
+    LOADING_ID, MATERIAL_ID, LOADING_SEQUENCE
     </sql>
     <sql id="columns_alias">
         t.RESULT_ID, t.RESULT_TOTAL_ID, t.RESULT_LOAD_START_TIME, t.RESULT_LOAD_END_TIME,
-    t.RESULT_LOAD_DURATION, t.LOAD_STANDARD_TIME_ID, t.LOADER_ID, t.RESULT_ISCLEAR, t.DELETE_NAME, 
-    t.DELETE_TIME, t.INSERT_USERNAME, t.INSERT_TIME, t.UPDATE_USERNAME, t.UPDATE_TIME, 
-    t.INSERT_UPDATE_REMARK, t.STATUS, t.RESULT_MEASURED_TONNAGE, t.LOADING_ID, t.MATERIAL_ID
+    t.RESULT_LOAD_DURATION, t.LOAD_STANDARD_TIME_ID, t.LOADER_ID, t.RESULT_ISCLEAR, t.DELETE_NAME,
+    t.DELETE_TIME, t.INSERT_USERNAME, t.INSERT_TIME, t.UPDATE_USERNAME, t.UPDATE_TIME,
+    t.INSERT_UPDATE_REMARK, t.STATUS, t.RESULT_MEASURED_TONNAGE, t.LOADING_ID, t.MATERIAL_ID,
+    t.LOADING_SEQUENCE
     </sql>
     <sql id="select">
-        SELECT
-        <include refid="columns"/>
-        FROM TMSTRUCK_LOAD_RESULT
+        SELECT <include refid="columns" /> FROM TMSTRUCK_LOAD_RESULT
     </sql>
     <sql id="select_alias">
-        SELECT
-        <include refid="columns_alias"/>
-        FROM TMSTRUCK_LOAD_RESULT t
+        SELECT <include refid="columns_alias" /> FROM TMSTRUCK_LOAD_RESULT t
     </sql>
     <sql id="where">
         <where>
@@ -103,6 +101,9 @@
             <if test="materialId != null">
                 and MATERIAL_ID = #{materialId}
             </if>
+            <if test="loadingSequence != null">
+                and LOADING_SEQUENCE = #{loadingSequence}
+            </if>
         </where>
     </sql>
     <sql id="whereLike">
@@ -164,11 +165,13 @@
             <if test="materialId != null">
                 and MATERIAL_ID = #{materialId}
             </if>
+            <if test="loadingSequence != null">
+                and LOADING_SEQUENCE = #{loadingSequence}
+            </if>
         </where>
     </sql>
     <delete id="deleteByPrimaryKey" parameterType="java.math.BigDecimal">
-        delete
-        from TMSTRUCK_LOAD_RESULT
+        delete from TMSTRUCK_LOAD_RESULT
         where RESULT_ID = #{resultId,jdbcType=DECIMAL}
     </delete>
     <delete id="deleteBySelectiveElement" parameterType="java.util.HashMap">
@@ -228,6 +231,9 @@
         <if test="materialId != null">
             or MATERIAL_ID = #{materialId}
         </if>
+        <if test="loadingSequence != null">
+            or LOADING_SEQUENCE = #{loadingSequence}
+        </if>
     </delete>
     <insert id="insert" parameterType="com.steerinfo.dil.model.TmstruckLoadResult">
         insert into TMSTRUCK_LOAD_RESULT (RESULT_ID, RESULT_TOTAL_ID, RESULT_LOAD_START_TIME,
@@ -236,16 +242,16 @@
                                           DELETE_NAME, DELETE_TIME, INSERT_USERNAME,
                                           INSERT_TIME, UPDATE_USERNAME, UPDATE_TIME,
                                           INSERT_UPDATE_REMARK, STATUS, RESULT_MEASURED_TONNAGE,
-                                          LOADING_ID, MATERIAL_ID)
-        values (#{resultId,jdbcType=DECIMAL}, #{resultTotalId,jdbcType=DECIMAL},
-                #{resultLoadStartTime,jdbcType=TIMESTAMP},
+                                          LOADING_ID, MATERIAL_ID, LOADING_SEQUENCE
+        )
+        values (#{resultId,jdbcType=DECIMAL}, #{resultTotalId,jdbcType=DECIMAL}, #{resultLoadStartTime,jdbcType=TIMESTAMP},
                 #{resultLoadEndTime,jdbcType=TIMESTAMP}, #{resultLoadDuration,jdbcType=DECIMAL},
                 #{loadStandardTimeId,jdbcType=DECIMAL}, #{loaderId,jdbcType=DECIMAL}, #{resultIsclear,jdbcType=VARCHAR},
                 #{deleteName,jdbcType=VARCHAR}, #{deleteTime,jdbcType=TIMESTAMP}, #{insertUsername,jdbcType=VARCHAR},
                 #{insertTime,jdbcType=TIMESTAMP}, #{updateUsername,jdbcType=VARCHAR}, #{updateTime,jdbcType=TIMESTAMP},
-                #{insertUpdateRemark,jdbcType=VARCHAR}, #{status,jdbcType=DECIMAL},
-                #{resultMeasuredTonnage,jdbcType=DECIMAL},
-                #{loadingId,jdbcType=DECIMAL}, #{materialId,jdbcType=DECIMAL})
+                #{insertUpdateRemark,jdbcType=VARCHAR}, #{status,jdbcType=DECIMAL}, #{resultMeasuredTonnage,jdbcType=DECIMAL},
+                #{loadingId,jdbcType=DECIMAL}, #{materialId,jdbcType=DECIMAL}, #{loadingSequence,jdbcType=DECIMAL}
+               )
     </insert>
     <insert id="insertSelective" parameterType="com.steerinfo.dil.model.TmstruckLoadResult">
         insert into TMSTRUCK_LOAD_RESULT
@@ -307,6 +313,9 @@
             <if test="materialId != null">
                 MATERIAL_ID,
             </if>
+            <if test="loadingSequence != null">
+                LOADING_SEQUENCE,
+            </if>
         </trim>
         <trim prefix="values (" suffix=")" suffixOverrides=",">
             <if test="resultId != null">
@@ -366,28 +375,32 @@
             <if test="materialId != null">
                 #{materialId,jdbcType=DECIMAL},
             </if>
+            <if test="loadingSequence != null">
+                #{loadingSequence,jdbcType=DECIMAL},
+            </if>
         </trim>
     </insert>
     <update id="updateByPrimaryKey" parameterType="com.steerinfo.dil.model.TmstruckLoadResult">
         update TMSTRUCK_LOAD_RESULT
-        set RESULT_TOTAL_ID         = #{resultTotalId,jdbcType=DECIMAL},
-            RESULT_LOAD_START_TIME  = #{resultLoadStartTime,jdbcType=TIMESTAMP},
-            RESULT_LOAD_END_TIME    = #{resultLoadEndTime,jdbcType=TIMESTAMP},
-            RESULT_LOAD_DURATION    = #{resultLoadDuration,jdbcType=DECIMAL},
-            LOAD_STANDARD_TIME_ID   = #{loadStandardTimeId,jdbcType=DECIMAL},
-            LOADER_ID               = #{loaderId,jdbcType=DECIMAL},
-            RESULT_ISCLEAR          = #{resultIsclear,jdbcType=VARCHAR},
-            DELETE_NAME             = #{deleteName,jdbcType=VARCHAR},
-            DELETE_TIME             = #{deleteTime,jdbcType=TIMESTAMP},
-            INSERT_USERNAME         = #{insertUsername,jdbcType=VARCHAR},
-            INSERT_TIME             = #{insertTime,jdbcType=TIMESTAMP},
-            UPDATE_USERNAME         = #{updateUsername,jdbcType=VARCHAR},
-            UPDATE_TIME             = #{updateTime,jdbcType=TIMESTAMP},
-            INSERT_UPDATE_REMARK    = #{insertUpdateRemark,jdbcType=VARCHAR},
-            STATUS                  = #{status,jdbcType=DECIMAL},
+        set RESULT_TOTAL_ID = #{resultTotalId,jdbcType=DECIMAL},
+            RESULT_LOAD_START_TIME = #{resultLoadStartTime,jdbcType=TIMESTAMP},
+            RESULT_LOAD_END_TIME = #{resultLoadEndTime,jdbcType=TIMESTAMP},
+            RESULT_LOAD_DURATION = #{resultLoadDuration,jdbcType=DECIMAL},
+            LOAD_STANDARD_TIME_ID = #{loadStandardTimeId,jdbcType=DECIMAL},
+            LOADER_ID = #{loaderId,jdbcType=DECIMAL},
+            RESULT_ISCLEAR = #{resultIsclear,jdbcType=VARCHAR},
+            DELETE_NAME = #{deleteName,jdbcType=VARCHAR},
+            DELETE_TIME = #{deleteTime,jdbcType=TIMESTAMP},
+            INSERT_USERNAME = #{insertUsername,jdbcType=VARCHAR},
+            INSERT_TIME = #{insertTime,jdbcType=TIMESTAMP},
+            UPDATE_USERNAME = #{updateUsername,jdbcType=VARCHAR},
+            UPDATE_TIME = #{updateTime,jdbcType=TIMESTAMP},
+            INSERT_UPDATE_REMARK = #{insertUpdateRemark,jdbcType=VARCHAR},
+            STATUS = #{status,jdbcType=DECIMAL},
             RESULT_MEASURED_TONNAGE = #{resultMeasuredTonnage,jdbcType=DECIMAL},
-            LOADING_ID              = #{loadingId,jdbcType=DECIMAL},
-            MATERIAL_ID             = #{materialId,jdbcType=DECIMAL}
+            LOADING_ID = #{loadingId,jdbcType=DECIMAL},
+            MATERIAL_ID = #{materialId,jdbcType=DECIMAL},
+            LOADING_SEQUENCE = #{loadingSequence,jdbcType=DECIMAL}
         where RESULT_ID = #{resultId,jdbcType=DECIMAL}
     </update>
     <update id="updateByPrimaryKeySelective" parameterType="com.steerinfo.dil.model.TmstruckLoadResult">
@@ -447,20 +460,23 @@
             <if test="materialId != null">
                 MATERIAL_ID = #{materialId,jdbcType=DECIMAL},
             </if>
+            <if test="loadingSequence != null">
+                LOADING_SEQUENCE = #{loadingSequence,jdbcType=DECIMAL},
+            </if>
         </set>
         where RESULT_ID = #{resultId,jdbcType=DECIMAL}
     </update>
     <select id="selectByPrimaryKey" parameterType="java.math.BigDecimal" resultMap="BaseResultMap">
-        <include refid="select"/>
+        <include refid="select" />
         where RESULT_ID = #{resultId,jdbcType=DECIMAL}
     </select>
     <select id="selectByParameters" parameterType="java.util.HashMap" resultMap="BaseResultMap">
-        <include refid="select"/>
-        <include refid="where"/>
+        <include refid="select" />
+        <include refid="where" />
     </select>
     <select id="selectLikeByParameters" parameterType="java.util.HashMap" resultMap="BaseResultMap">
-        <include refid="select"/>
-        <include refid="whereLike"/>
+        <include refid="select" />
+        <include refid="whereLike" />
     </select>
     <insert id="batchInsert" parameterType="java.util.List">
         insert into TMSTRUCK_LOAD_RESULT
@@ -472,20 +488,20 @@
         INSERT_USERNAME, INSERT_TIME,
         UPDATE_USERNAME, UPDATE_TIME,
         INSERT_UPDATE_REMARK, STATUS, RESULT_MEASURED_TONNAGE,
-        LOADING_ID, MATERIAL_ID)
+        LOADING_ID, MATERIAL_ID, LOADING_SEQUENCE
+        )
         ( <foreach collection="list" item="item" separator="union all">
         select
         #{item.resultId,jdbcType=DECIMAL},
         #{item.resultTotalId,jdbcType=DECIMAL}, #{item.resultLoadStartTime,jdbcType=TIMESTAMP},
         #{item.resultLoadEndTime,jdbcType=TIMESTAMP}, #{item.resultLoadDuration,jdbcType=DECIMAL},
         #{item.loadStandardTimeId,jdbcType=DECIMAL}, #{item.loaderId,jdbcType=DECIMAL},
-        #{item.resultIsclear,jdbcType=VARCHAR}, #{item.deleteName,jdbcType=VARCHAR},
-        #{item.deleteTime,jdbcType=TIMESTAMP},
+        #{item.resultIsclear,jdbcType=VARCHAR}, #{item.deleteName,jdbcType=VARCHAR}, #{item.deleteTime,jdbcType=TIMESTAMP},
         #{item.insertUsername,jdbcType=VARCHAR}, #{item.insertTime,jdbcType=TIMESTAMP},
         #{item.updateUsername,jdbcType=VARCHAR}, #{item.updateTime,jdbcType=TIMESTAMP},
-        #{item.insertUpdateRemark,jdbcType=VARCHAR}, #{item.status,jdbcType=DECIMAL},
-        #{item.resultMeasuredTonnage,jdbcType=DECIMAL},
-        #{item.loadingId,jdbcType=DECIMAL}, #{item.materialId,jdbcType=DECIMAL} from dual
+        #{item.insertUpdateRemark,jdbcType=VARCHAR}, #{item.status,jdbcType=DECIMAL}, #{item.resultMeasuredTonnage,jdbcType=DECIMAL},
+        #{item.loadingId,jdbcType=DECIMAL}, #{item.materialId,jdbcType=DECIMAL}, #{item.loadingSequence,jdbcType=DECIMAL}
+        from dual
     </foreach> )
     </insert>
     <update id="batchUpdate" parameterType="java.util.List">
@@ -567,6 +583,10 @@
         <foreach close="end" collection="list" index="index" item="item" open="case RESULT_ID" separator=" ">
             when #{item.resultId,jdbcType=DECIMAL} then #{item.materialId,jdbcType=DECIMAL}
         </foreach>
+        ,LOADING_SEQUENCE=
+        <foreach close="end" collection="list" index="index" item="item" open="case RESULT_ID" separator=" ">
+            when #{item.resultId,jdbcType=DECIMAL} then #{item.loadingSequence,jdbcType=DECIMAL}
+        </foreach>
         where RESULT_ID in
         <foreach close=")" collection="list" index="index" item="item" open="(" separator=",">
             #{item.resultId,jdbcType=DECIMAL}
@@ -581,7 +601,6 @@
     </delete>
     <!-- 友情提示！！！-->
     <!-- 请将自己写的代码放在此标签之下，方便以后粘贴复制。-->
-
     <sql id="orderBy">
         <if test="orderField != null and orderField != ''">
             order by "${orderField}"
@@ -811,7 +830,7 @@
     </select>
 
     <!--  通过订单ID 和物资Id 查询装车实绩ID 可能会有多条-->
-    <select id="getLoadResultIdList" parameterType="java.util.Map" resultType="java.lang.Integer">
+    <select id="getLoadResultId" parameterType="java.util.Map" resultType="java.lang.Integer">
         select TLR.RESULT_ID
         from OMSTRUCK_ORDER OO
                  left join TMSTRUCK_TOTAL_RESULT TTR
@@ -1054,4 +1073,78 @@
         where MATERIAL_ONLY_CODE = #{materialOnlyCode}
     </select>
 
+<!--   查询所有正在进行进厂排队的销售订单  -->
+    <select id="getSaleOrderOnQueue" parameterType="java.util.Map" resultType="java.util.Map">
+        select *
+        from (
+                 select OO.ORDER_ID        "orderId",
+                        OO.ORDER_NUMBER    "orderNumber",
+                        ASO.SALE_NUMBER    "saleNumber",
+                        RCD.DRIVER_NAME    "driverName",
+                        RC.CAPACITY_NUMBER "capacityNumber",
+                        OO.ORDER_ISSUE_TIME "orderIssueTime"
+                 from OMSTRUCK_ORDER OO
+                          left join AMS_SALE_ORDER_MATERIAL ASOM
+                                    on ASOM.SALE_ORDER_MATERIAL_ID = OO.ORDER_PLAN_ID
+                          left join AMS_SALE_ORDER ASO
+                                    on ASO.SALE_ORDER_ID = ASOM.SALE_ORDER_ID
+                          left join RMS_DRIVER_CAPACITY RDC
+                                    on RDC.DRIVER_CAPACITY_ID = OO.DRIVER_CAPACITY_ID
+                          left join RMS_CAR_DRIVER RCD
+                                    on RCD.DRIVER_ID = RDC.DRIVER_ID
+                          left join RMS_CAPACITY RC
+                                    on RDC.CAPACITY_ID = RC.CAPACITY_ID
+                 where OO.ORDER_ID in (select OO.ORDER_ID
+                                       from QMS_QUEUE_RESULT QQR
+                                                left join TMSTRUCK_TOTAL_RESULT TTR
+                                                          on TTR.RESULT_TOTAL_ID = QQR.RESULT_TOTAL_ID
+                                                left join OMSTRUCK_ORDER OO
+                                                          on OO.ORDER_ID = TTR.ORDER_ID
+                                       where QQR.RESULT_START_TIME is not null
+                                         and QQR.RESULT_END_TIME is null
+                                         and OO.ORDER_TYPE = 1)
+             )
+        <where>
+            <if test="orderNumber != null">
+                <foreach collection="orderNumber" item="item" open="(" separator="or" close=")">
+                    "orderNumber" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="saleNumber != null">
+                and
+                <foreach collection="saleNumber" item="item" open="(" separator="or" close=")">
+                    "saleNumber" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="driverName != null">
+                and
+                <foreach collection="driverName" item="item" open="(" separator="or" close=")">
+                    "driverName" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="capacityNumber != null">
+                and
+                <foreach collection="capacityNumber" item="item" open="(" separator="or" close=")">
+                    "capacityNumber" like '%${item}%'
+                </foreach>
+            </if>
+        </where>
+        <include refid="orderBy"></include>
+        <if test="orderField == null  ">
+            order by "orderIssueTime" desc
+        </if>
+    </select>
+
+<!--    通过订单Id和物资Id确定唯一的装车实绩Id -->
+    <select id="getLoadIdByOrderIdAndMId" parameterType="java.util.Map" resultType="java.lang.Integer">
+        select TLR.RESULT_ID
+        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
+        where OO.ORDER_ID = #{orderId}
+          and TLR.MATERIAL_ID = #{materialId}
+    </select>
+
 </mapper>

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

@@ -618,8 +618,6 @@
         select OO.ORDER_ID               "orderId",
                OO.ORDER_TYPE             "orderTypee",
                TWR.WEIGHT_TASK_RESULT_ID "weightTaskResultId",
-               TWR.RESULT_GROSS_WEIGHT   "grossWeight",
-               TWR.RESULT_TARE_WEIGHT    "tareWeight",
                TTR.RESULT_TOTAL_ID       "resultTotalId"
         from OMSTRUCK_ORDER OO
                  left join TMSTRUCK_TOTAL_RESULT TTR
@@ -1344,7 +1342,40 @@
     <select id="getMaterialIdByMaterialNameAndSpe" parameterType="java.util.Map" resultType="java.lang.Integer">
         select RM.MATERIAL_ID
         from RMS_MATERIAL RM
-        where RM.MATERIAL_NAME = #{materialName} and RM.MATERIAL_SPECIFICATION = #{materialSpecification}
+        <where>
+            <if test="materialName != null">
+                RM.MATERIAL_NAME = #{materialName}
+            </if>
+            <if test="materialSpecification != null">
+                and RM.MATERIAL_SPECIFICATION = #{materialSpecification}
+            </if>
+            <if test="materialModel != null">
+                and RM.MATERIAL_MODEL = #{materialModel}
+            </if>
+        </where>
+    </select>
+
+<!--   通过物资Id和运输订单id 查询计量实绩Id -->
+    <select id="getWeightIdByMaterialIdAndOrderId" parameterType="java.util.Map" resultType="java.lang.Integer">
+        select
+               TWR.WEIGHT_TASK_RESULT_ID "weightTaskResultId"
+        from OMSTRUCK_ORDER OO
+        left join TMSTRUCK_TOTAL_RESULT TTR
+        on OO.ORDER_ID = TTR.ORDER_ID
+        left join TMSTRUCK_WEIGHT_RESULT TWR
+        on TWR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        where OO.ORDER_ID = #{orderId} and TWR.MATERIAL_ID = #{materialId}
+</select>
+
+<!--    通过运输订单号和查询订单Id 和物资ID (针对单拼)  -->
+    <select id="getOrderIdAndMaterialIdByOrderNum" parameterType="string" resultType="java.util.Map">
+        select
+               OO.ORDER_ID "orderId",
+               OOM.MATERIAL_ID "materialId"
+        from OMSTRUCK_ORDER OO
+        left join OMSTRUCK_ORDER_MATERIAL OOM
+        on OOM.ORDER_ID = OO.ORDER_ID
+        where OO.ORDER_NUMBER = #{orderNumber}
     </select>
 
 </mapper>

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

@@ -33,13 +33,7 @@
     <update id="updateLineSeqByOrderIdOrNum" parameterType="java.util.Map">
         update OMSTRUCK_ORDER OO
         set OO.ORDER_LINE_SEQUENCE = #{orderLineSequence}
-        where
-        <if test="orderId != null">
-            OO.ORDER_ID = #{orderId}
-        </if>
-        <if test="orderNumber != null">
-            and  OO.ORDER_NUMBER = #{orderNumber}
-        </if>
+        where OO.ORDER_ID = #{orderId}
     </update>
 
 <!--   通过仓库名称查询仓库Id -->
@@ -73,7 +67,14 @@
     <select id="getLineSequenceByOrderId" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
         select OO.ORDER_LINE_SEQUENCE
         from OMSTRUCK_ORDER OO
-        where ORDER_ID = #{orderId}
+        <where >
+              <if test="orderId != null">
+                  ORDER_ID = #{orderId}
+              </if>
+              <if test="orderNumber != null">
+                  and OO.ORDER_NUMBER = #{orderNumber}
+              </if>
+        </where>
     </select>
 
     <!--  查询订单有几件物资  -->
@@ -84,4 +85,18 @@
                            on OO.ORDER_ID = OOM.ORDER_ID
         where OO.ORDER_NUMBER = #{orderNumber}
     </select>
+
+<!--  通过总实绩Id查询运输订单ID  -->
+    <select id="getOrderIdByTotalId" resultType="java.lang.Integer">
+        select TTR.ORDER_ID
+        from TMSTRUCK_TOTAL_RESULT TTR
+        where TTR.RESULT_TOTAL_ID = #{resultTotalId}
+    </select>
+
+<!--  通过运输订单号查询运输订单ID  -->
+    <select id="getOrderIdByOrderNumber" parameterType="string" resultType="java.math.BigDecimal">
+        select OO.ORDER_ID
+        from OMSTRUCK_ORDER OO
+        where OO.ORDER_NUMBER = #{orderNumber}
+    </select>
 </mapper>