合并分支

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

@@ -242,6 +242,30 @@ public class StatisticalReportController extends BaseRESTfulController {
         return success(pageList);
     }
 
+    @ApiOperation(value="查询零星内转统计报表")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
+            @ApiImplicitParam(name = "apiId", value = "动态表头", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "status", value = "状态码", required = false, dataType = "Integer"),
+    })
+    @PostMapping("/getLXInwardReport")
+    public RESTfulResult getLXInwardReport(@RequestBody(required=false) Map<String,Object> mapValue,
+                                            Integer apiId,
+                                            Integer pageNum,
+                                            Integer pageSize,
+                                            String startTime,
+                                            String endTime
+    ){
+        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
+        PageHelper.startPage(pageNum, pageSize);
+        //分页数据
+        List<Map<String, Object>> report = statisticalReportService.getLXInwardReport(mapValue);
+        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null, report);
+        return success(pageList);
+    }
+
     @ApiOperation(value="查询内转统计报表")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),

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

@@ -125,16 +125,6 @@ public class TmstruckLoadResultController extends BaseRESTfulController {
         return success(pageList);
     }
 
-    @ApiOperation(value="新增CG汽车装车实绩")
-    @ApiImplicitParams({
-            @ApiImplicitParam(name = "mapValue", value = "", required = false, dataType = "Map"),
-    })
-    @PostMapping("/addCGLoadResult")
-    public RESTfulResult addCGLoadResult(@RequestBody(required=false) Map<String,Object> mapValue){
-        int i = tmstruckLoadResultService.addCGLoadResult(mapValue);
-        return success(i);
-    }
-
     @ApiOperation(value="销售新增钢材装车实绩 ")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "map", value = "", required = false, dataType = "Map"),
@@ -151,13 +141,19 @@ public class TmstruckLoadResultController extends BaseRESTfulController {
     })
     @PostMapping("/addSale2LoadResult")
     public RESTfulResult addSale2LoadResult(@RequestBody(required=false) Map<String, Object> map){
-        int i = 0;
         try {
-            i = tmstruckLoadResultService.addXS2LoadResult(map);
+            int i = tmstruckLoadResultService.addXS2LoadResult(map);
+            if(i > 0){
+                return success("装货成功");
+            }else if(i == -2){
+                return failed("已装过此物资");
+            }else {
+                return failed("装货异常，请联系管理员！");
+            }
         } catch (Exception e) {
-            e.printStackTrace();
+            System.out.println(e.getMessage());
         }
-        return success(i);
+        return failed("装货异常，请联系管理员！");
     }
 
 

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

@@ -52,6 +52,24 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
         return success(i);
     }
 
+    @ApiOperation(value="用于计时新增")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
+    })
+    @PostMapping("/addTimeTaskResult")
+    public RESTfulResult addTimeTaskResult(@RequestBody(required=false) Map<String,Object> mapValue) throws Exception {
+        int i=0;
+        try {
+            i=tmstruckTimeTaskResultService.addTimeTaskResult(mapValue);
+        } catch (Exception e) {
+            return failed(e.getMessage());
+        }
+        return success(i);
+    }
+
+
+
+
     @ApiOperation(value="用车单位确认开始")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
@@ -112,6 +130,17 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
         return success(i);
     }
 
+//
+//    @ApiOperation(value="计时修改")
+//    @ApiImplicitParams({
+//            @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
+//    })
+//    @PostMapping("/updateTimeTaskResult")
+//    public RESTfulResult updateTimeTaskResult(@RequestBody(required=false) Map<String,Object> mapValue){
+//        int i = tmstruckTimeTaskResultService.updateTimeTaskResult(mapValue);
+//        return success(i);
+//    }
+
     @ApiOperation(value="用车单位确认结束")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
@@ -122,10 +151,10 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
         return success(i);
     }
 
-    @ApiOperation(value="查询计皮实绩")
+    @ApiOperation(value="查询计时作业")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
-            @ApiImplicitParam(name = "apiId(363)", value = "动态表头", required = false, dataType = "Integer"),
+            @ApiImplicitParam(name = "apiId(456)", value = "动态表头", required = false, dataType = "Integer"),
             @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
             @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
             @ApiImplicitParam(name = "status", value = "状态码", required = false, dataType = "Integer"),
@@ -135,8 +164,15 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
                                           Integer apiId,
                                           Integer pageNum,
                                           Integer pageSize,
-                                          String con
+                                          String con,
+                                          String orgCode
     ){
+        if (con!=null&&!con.equals("undifined")&&!con.equals("")){
+            mapValue.put("con","%" + con + "%");
+        }
+        if (orgCode!=null&&!orgCode.equals("undifined")&&!con.equals("")){
+            mapValue.put("userId",orgCode);
+        }
         PageHelper.startPage(pageNum,pageSize);
         //分页数据
         List<Map<String, Object>> result = tmstruckTimeTaskResultService.getAllTimeTaskResult(mapValue);
@@ -144,4 +180,7 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
         return success(pageList);
     }
 
+
+
+
 }

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

@@ -87,7 +87,13 @@ public class TmstruckUnloadResultController extends BaseRESTfulController {
     @PostMapping("/updateUnloadResult")
     public RESTfulResult updateUnloadResult(@RequestBody Map<String, Object> mapValue){
         int i = tmstruckUnloadResultService.updateUnloadResult(mapValue);
-        return success(i);
+        if(i > 0){
+            return success("卸货成功！");
+        }else if(i == -2){
+            return failed("已卸过此物资");
+        }else {
+            return failed("卸货失败，请联系管理员！");
+        }
     }
 
 

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

@@ -40,4 +40,6 @@ public interface StatisticalReportMapper {
     List<Map<String, Object>> getLoading(Map<String, Object> mapValue);
 
     List<Map<String, Object>> getUnLoading(Map<String, Object> mapValue);
+
+    List<Map<String, Object>> getLXReportResult(Map<String, Object> mapValue);
 }

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

@@ -123,4 +123,6 @@ public interface TmstruckLoadResultMapper extends IBaseMapper<TmstruckLoadResult
     //修改装货路段顺序号
     int updateSqe(@Param("orderId")BigDecimal orderId);
 
+    //查询这个物资是否已经装过了
+    Integer checkMaterialIdLoad(@Param("resultTotalId") BigDecimal resultTotalId,@Param("materialId") BigDecimal materialId);
 }

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

@@ -32,7 +32,7 @@ public interface TmstruckMeasureCommissionMapper extends IBaseMapper<TmstruckMea
     Integer getReceiveIdByOrderId(BigDecimal orderId);
 
     //通过订单ID查询发货单位ID
-    Integer getShipperIdByOrderId(BigDecimal orderId);
+    Map<String, Object> getShipperIdByOrderId(BigDecimal orderId);
 
     //销售查询计毛
     Map<String, Object> selectMakesureGrossForSaleByOrderNumber(Map<String, Object> map);

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

@@ -31,4 +31,7 @@ public interface TmstruckTimeTaskResultMapper extends IBaseMapper<TmstruckTimeTa
     //查询计时作业
     List<Map<String, Object>> getAllTimeTaskResult(Map<String, Object> map);
 
+    //根据运输订单id查找实绩中是否含有已经计时结束的实绩
+    int CountTimeTaskByOrderId(BigDecimal orderId);
+
 }

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

@@ -3,6 +3,7 @@ package com.steerinfo.dil.mapper;
 import com.steerinfo.dil.model.TmstruckUnloadResult;
 import com.steerinfo.framework.mapper.IBaseMapper;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
 
 import java.math.BigDecimal;
@@ -55,4 +56,7 @@ public interface TmstruckUnloadResultMapper extends IBaseMapper<TmstruckUnloadRe
 
     //根据总实绩ID查询是否有净重
     Integer getNetWeightByTotalId(BigDecimal totalId);
+
+    //查询这个物资是否已经卸过了
+    Integer checkMaterialIdUnload(@Param("resultTotalId") BigDecimal resultTotalId,@Param("materialId") BigDecimal materialId);
 }

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

@@ -4,6 +4,7 @@ import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
 
+import javax.management.monitor.StringMonitor;
 import java.math.BigDecimal;
 import java.util.List;
 import java.util.Map;
@@ -60,6 +61,8 @@ public interface UtilsMapper {
     //通过运输订单号查询总实绩ID
     BigDecimal getTotalIdByOrderNumber(String orderNumber);
 
+
+
     //通过总实绩ID查找订单类型
     Map<String, Object> getOrderTypeByTotalId(BigDecimal resultTotalId);
 
@@ -92,4 +95,22 @@ public interface UtilsMapper {
 
     //通过车牌号查询运力ID
     BigDecimal getCapacityIdByNum(String capacityNumber);
+
+    //查询最近进厂门岗
+    Integer getLastGatepostId(BigDecimal resultTotalId);
+
+    //查询零星是否多拼或没有净重的物资
+    Integer getNextMaterialId(BigDecimal orderId);
+
+    //通过运输订单id查找计时作业实绩
+    Map<String,Object> timeTaskResult(BigDecimal orderId);
+
+    //根据运输订单id查找订单类型
+   Map<String,Object> getTimeStatus(Map<String,Object> map);
+
+    //根据运输订单id查找两次计时作业实绩
+   Map<String,Object> FristTimeTask(Map<String,Object> map);
+
+   //通过运输订单id查找计时是否开始
+    BigDecimal getTime(BigDecimal orderId);
 }

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

@@ -35,6 +35,8 @@ public interface IStatisticalReportService {
 
     List<Map<String, Object>> getPurInwardReport(Map<String, Object> mapValue);
 
+    List<Map<String, Object>> getLXInwardReport( Map<String, Object> mapValue);
+
     //查看内转统计报表
     List<Map<String, Object>> getInwardReport(Map<String, Object> mapValue);
 

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

@@ -29,9 +29,6 @@ public interface ITmstruckLoadResultService{
     //生成装车实绩(销售)
     int addLoadResult(Map<String, Object> map);
 
-    //新增采购装车实绩
-    int addCGLoadResult(Map<String, Object> map);
-
     //修改销售装车实绩  （如果是多种物资【多拼】，通过物资Id和运输订单号来确定唯一的装车实绩进行修改）
     int addXSLoadResult(Map<String, Object> map);
 

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

@@ -48,4 +48,10 @@ public interface ITmstruckTimeTaskResultService {
 
     //查询计时作业
     List<Map<String, Object>> getAllTimeTaskResult(Map<String, Object> map);
+
+    //新增作业实绩
+    int addTimeTaskResult(Map<String,Object> map) throws Exception;
+
+    //修改计时作业
+//    int updateTimeTaskResult(Map<String,Object> map);
 }

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

@@ -138,6 +138,23 @@ public class StatisticalReportImpl implements IStatisticalReportService {
         return inwardReportResult;
     }
 
+    //采购内转统计报表
+    @Override
+    public List<Map<String, Object>> getLXInwardReport( Map<String, Object> mapValue) {
+        List<Map<String, Object>> lxReportResult = statisticalReportMapper.getLXReportResult(mapValue);
+        for (Map<String,Object>inwardReport:lxReportResult
+        ) {
+
+            BigDecimal netWeightSecond = DataChange.dataToBigDecimal(inwardReport.get("netWeightSecond"));
+            BigDecimal netWeightFirst = DataChange.dataToBigDecimal(inwardReport.get("netWeightFirst"));
+            BigDecimal netTract = netWeightSecond.subtract(netWeightFirst).divide(new BigDecimal(1), 2, 4);
+            //第二次净重减第一次净重
+            inwardReport.put("newTract",netTract);
+            calculateDifferenceTime(inwardReport);
+        }
+        return lxReportResult;
+    }
+
     @Override
     public List<Map<String, Object>> getInwardReport(Map<String, Object> mapValue) {
         return statisticalReportMapper.getInwardReport(mapValue);

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

@@ -120,9 +120,8 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
                 return tmstruckEnfactoryResultMapper.getInFactoryMaterialEnFactoryResult(map); //apiId:357
             case 12:
             case 13:
-            case 15:
-            case 16:
-            case 19:
+            case 14:
+            case 100:
                 return tmstruckEnfactoryResultMapper.getSporadicSuppliesEnFactoryResult(map);// apiId:416
         }
         return null;
@@ -156,10 +155,10 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
         Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
         String capacityNumber = (String) mesMap.get("capacityNumber");
         BigDecimal resultTotalId = DataChange.dataToBigDecimal(mesMap.get("totalId"));
-        Integer orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
+        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
         if(orderType == 11){
             //内转订单类型  没有生成实绩 直接新增
-            Integer sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
+            int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
             sqe = sqe + 1;
             map.put("resultId", tmstruckEnfactoryResultMapper.selectMaxId());  //插入进厂实绩Id
             map.put("Sqe", sqe); //查询路段顺序号 + 1
@@ -183,8 +182,6 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
             }
         }
         map.putAll(selectMap);
-        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
-
         //判断委托是否发送成功
         int checkMeasureCommission = 0;
         switch (orderType){
@@ -198,9 +195,6 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
                 break;
             case 2:
             case 3:
-                //通过物资ID查询订单ID（针对单拼）
-                List<Integer> materialIdList = utilsMapper.getMaterialIdByOrderId(orderId);
-                map.put("materialId", materialIdList.get(0));
                 checkMeasureCommission = tmstruckMeasureCommissionService.addXSMeasureCommission(map); //添加计皮委托
                 break;
             case 5:
@@ -226,17 +220,19 @@ public class TmstruckEnfactoryResultServiceImpl implements ITmstruckEnfactoryRes
                 break;
             case 12:
             case 13:
-            case 16:
-            case 15:
-            case 20:
+            case 14:
                 //发送计量委托(查询物资顺序第一个装卸货的物资)
-                //拿到需要计量的物资ID
                 Integer materialId = utilsMapper.getLxFirstMaterialId(DataChange.dataToBigDecimal(map.get("orderId")));
                 map.put("materialId", materialId);
-                checkMeasureCommission += tmstruckMeasureCommissionService.addLXMeasureCommission(map);
+                checkMeasureCommission += tmstruckMeasureCommissionService.sendMeasureCommissionByGatepost(map);
+                break;
+            case 20:
+                checkMeasureCommission += tmstruckMeasureCommissionService.sendMeasureCommissionByGatepost(map);
         }
         if(checkMeasureCommission == 0){
             throw new Exception("委托发送失败");
+        }else if (checkMeasureCommission == -2){
+            throw new Exception("没有获取到门岗");
         }
         i += tmstruckEnfactoryResultMapper.updateByPrimaryKeySelective(generateEnFactoryResult(map)); //添加进厂实绩
         //修改路段顺序号

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

@@ -146,9 +146,8 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
                 return tmstruckLeaveFactoryResultMapper.getInFactoryOutFactoryResult(map); //apiId:361
             case 12:
             case 13:
-            case 15:
-            case 16:
-            case 19:
+            case 14:
+            case 100:
                  return tmstruckLeaveFactoryResultMapper.getSporadicLeaveFactory(map);//apiId:421
         }
         return null;
@@ -169,11 +168,11 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
         orderNumber = orderNumber.substring(0, orderNumber.length() - 1);
         //通过订单号查询订单类型 及总实绩Id
         Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
-        Integer orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
+        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
         String capacityNumber = (String) mesMap.get("capacityNumber");
         if(orderType == 11){
             //内转订单类型 没有生成实绩 直接新增
-            Integer sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
+            int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
             sqe = sqe + 1;
             map.put("resultId",tmstruckLeaveFactoryResultMapper.selectMaxId());//出厂实绩ID
             map.put("Sqe",sqe);//查询路段顺序号+1
@@ -261,15 +260,12 @@ public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFact
                 break;
             case 12:
             case 13:
-            case 15:
-            case 16:
+            case 14:
                 //关闭当前订单
                 i += utilsService.closeOrderNormally(map);
                 //生成新的零星订单
                 omsFeign.pushMessageToDriver(map);
                 break;
-
-
         }
         utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "出厂");
         return i;

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

@@ -110,9 +110,8 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
                 return tmstruckLoadResultMapper.getInFactoryLoadResult(map); //apiId = 359
             case 12:
             case 13:
-            case 15:
-            case 16:
-            case 19:
+            case 14:
+            case 100:
                  return tmstruckLoadResultMapper.getSporadicSuppliesLoadResult(map); //apiId = 430
         }
         return null;
@@ -120,63 +119,6 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
 
 
 
-    /**
-     * 新增采购装车实绩  / 内转装车实绩
-     * @param map  resultMeasuredTonnage ：计量吨位  portId：港口ID
-     *             resultLoadStartTime：装车时间 resultIsclear：是否清场
-     */
-    @Transactional
-    public int addCGLoadResult(Map<String,Object> map){
-        //通过运输订单号 或 运单Id 查询实绩总表ID  此方法在 进厂作业mapper中
-        Map<String,Object> orderMap = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
-        BigDecimal totalId = (BigDecimal) orderMap.get("resultTotalId");
-        //通过实绩总表ID查询装车实绩ID
-        BigDecimal loadResultId = tmstruckLoadResultMapper.getResultId(totalId);
-
-        TmstruckLoadResult tmstruckLoadResult = tmstruckLoadResultMapper.selectByPrimaryKey(loadResultId);
-        //添加主键Id
-//        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
-        //新增计量吨位 装车所装的重量
-        BigDecimal resultMeasuredTonnage = DataChange.dataToBigDecimal(map.get("resultMeasuredTonnage"));
-        tmstruckLoadResult.setResultMeasuredTonnage(resultMeasuredTonnage);
-        tmstruckLoadResult.setStatus(new BigDecimal(0));
-//        tmstruckLoadResult.setResultTotalId(totalId);
-        String resultIsclear = (String) (map.get("resultIsclear"));
-        tmstruckLoadResult.setResultIsclear(resultIsclear);
-        tmstruckLoadResult.setResultLoadEndTime(new Date((long) map.get("resultLoadStartTime")));
-        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
-        //根据订单ID查询订单类型
-        Integer orderType = tmstruckLoadResultMapper.getOrderType(totalId);
-        if(orderType == 8){
-            tmstruckLoadResult.setSegmentSqe(new BigDecimal(1));
-        }
-        Object portId = map.get("portId"); //获取港口
-        if(portId != null){
-            //通过订单ID获取批次Id
-            BigDecimal batchId = tmstruckLoadResultMapper.getBatchIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
-            if(batchId != null){
-                Map<String, Object> hashMap = new HashMap<>();
-                hashMap.put("batchId", batchId);
-                hashMap.put("portId", portId);
-                hashMap.put("resultTonnage",resultMeasuredTonnage);
-                hashMap.put("isClean", resultIsclear);
-                wmshBoundFeign.addResult(hashMap);
-                // 通过港口ID查询仓库表中的港存库ID
-                BigDecimal warehouseId = tmstruckLoadResultMapper.getWarehouseIdByPortId(DataChange.dataToBigDecimal(portId));
-                tmstruckLoadResult.setLoadingId(warehouseId); // 添加装货点为港口
-            }
-        }
-        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
-        String capacityNumber = (String) orderMap.get("capacityNumber");
-        utilsService.pushMesToWebsocket(capacityNumber,"装货！");
-        //修改订单状态为执行中 1
-//        int i1 = utilsService.updateOrderStatus(map, 1);
-        //修改运力状态为执行中 1
-//        int i2 = utilsService.updateCapacityStatus(map, 1);
-        return i ;
-    }
-
-
     /**
      * 更新装车实绩表
      * @return
@@ -262,10 +204,10 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         //通过订单号查询订单类型 及总实绩Id
         Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
         String capacityNumber = (String) mesMap.get("capacityNumber");
-        BigDecimal orderType = DataChange.dataToBigDecimal(mesMap.get("orderType"));
+        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
         BigDecimal resultTotalId = DataChange.dataToBigDecimal(mesMap.get("totalId"));
-        if(orderType.intValue() == 11){
-            Integer sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
+        if(orderType == 11){
+            int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
             sqe = sqe + 1;
             map.put("resultId",tmstruckLoadResultMapper.selectMaxId());
             map.put("Sqe",sqe);//查询路段顺序号+1
@@ -278,8 +220,13 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
             utilsService.pushMesToWebsocket(capacityNumber, "装货");
             return i;
         }
-        //通过运输订单号 查询 总实绩ID、订单类型
-        Map<String,Object> orderMap = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
+        //如果是零星多拼订单 需要查询这个物资是否已经装过了
+        if(orderType == 12 || orderType == 13){
+            Integer checkMaterial = tmstruckLoadResultMapper.checkMaterialIdLoad(resultTotalId, DataChange.dataToBigDecimal(map.get("materialId")));
+            if(checkMaterial != null){
+                return -2;
+            }
+        }
         //查询装车实绩ID
         map.putAll(tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId.intValue(), null));
         TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
@@ -305,20 +252,20 @@ public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService
         // 更新装货点
         tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("warehouseId")));
         //更新路段顺序号
-        int i = utilsService.updateOrderLineSequence(map);
+        utilsService.updateOrderLineSequence(map);
         //判断是否为未装货
         if (map.get("insertUpdateRemark")!=null) {
             String insertUpdateRemark = (String) map.get("insertUpdateRemark");
-            if("未装货".equals(insertUpdateRemark) && orderType.intValue() != 11){
-                loadJudge(orderMap);
+            if("未装货".equals(insertUpdateRemark)){
+                loadJudge(mesMap);
             }
             tmstruckLoadResult.setInsertUpdateRemark(insertUpdateRemark);
         }
         tmstruckLoadResult.setCaseNumber((String) map.get("caseNumber"));
-        i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
+        tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
         //推送消息到websocket
         utilsService.pushMesToWebsocket(capacityNumber, "装货");
-        return i;
+        return 1;
     }
 
     //内转添加装货实绩

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

@@ -12,6 +12,7 @@ import com.steerinfo.dil.service.ITmstruckMeasureCommissionService;
 import com.steerinfo.dil.util.DataChange;
 import com.steerinfo.dil.util.HTTPRequestUtils;
 import com.sun.java.swing.plaf.motif.MotifMenuBarUI;
+import io.swagger.models.auth.In;
 import org.apache.poi.ss.formula.functions.T;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -19,6 +20,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.net.Inet4Address;
 import java.util.*;
 
 /**
@@ -61,6 +63,30 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
     //给达兴发委托
     private static final List<Integer> judgeDaXinNum = Arrays.asList(7, 18);
 
+    private static final String judgeCoke = "一厂焦炭库";
+
+    //根据门来判断委托发送依据
+    private static final List<Integer> daGangGatepost = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 14);
+    private static final List<Integer> daXingGatepost = Arrays.asList(8, 9, 10, 11, 12, 13);
+
+    /**
+     * 根据门岗发送委托
+     * @Author TXF
+     * @Date 2022/3/15 11:14
+     * @param map
+     * @return
+     **/
+    public int sendMeasureCommissionByGatepost(Map<String, Object> map){
+        int gatepostId = DataChange.dataToBigDecimal(map.get("gatepostId")).intValue();
+        if(daGangGatepost.contains(gatepostId)){ //给达钢发送委托
+            return sendMeasureCommissionMes(map);
+        }else if(daXingGatepost.contains(gatepostId)){  //给达兴发送委托
+            return sendDXMeasureCommissionMes(map);
+        }
+        return -2; //返回-2为没有获取到门岗ID
+    }
+
+
     /**
      * 查询计量委托 0 ：计皮     1：计毛
      * @param map orderTypee 订单类型   type 是计皮还是计毛
@@ -111,7 +137,13 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
         int i = 0;
         //发送数据给计量系统 必要数据 orderTypee：订单类型  resultTotalId： 总实绩Id   orderId
         //获取当前订单是属于哪个厂区订单
-        Integer shipperId = tmstruckMeasureCommissionMapper.getShipperIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
+        Map<String, Object> mesMap = tmstruckMeasureCommissionMapper.getShipperIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
+        if(map.get("saleWarehouse") != null){
+            if(judgeCoke.equals(map.get("saleWarehouse"))){ //如果是一厂焦炭库则向达钢发送委托
+                return sendMeasureCommissionMes(map);
+            }
+        }
+        int shipperId = DataChange.dataToBigDecimal(mesMap.get("shipperId")).intValue();
         if(shipperId == 1){
             //发送委托给达州钢铁
             i += sendMeasureCommissionMes(map);
@@ -129,7 +161,7 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
      * @return
      */
     public int addLXMeasureCommission(Map<String, Object> map){
-        Integer orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
+        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
         BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
         int i = 0;
         if(orderType == 12) {
@@ -216,7 +248,7 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
     public int sendMeasureCommissionMes(Map<String, Object> map){
         Map<String, Object> measureCommission = null;
         //查询计量委托
-        Integer orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
+        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
         switch (orderType){
             case 1:
                 break;
@@ -267,50 +299,29 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
                 measureCommission.put("IsAssembly", false);
                 measureCommission.put("deliveryMethod", "磅重交货");
                 measureCommission.put("packagesNum", 0);
+                System.out.println(measureCommission);
                 break;
             case 12:
-            case 13:
-                 //内转零星进厂（老厂区）
-                //零星计量委托(老厂区)
-                measureCommission = tmstruckMeasureCommissionMapper.sproadicMeasure(map);
-                if(measureCommission == null){
-                    return 0;
-                }
-                measureCommission.put("isRelationEAS",false);
-                measureCommission.put("flowTo","进厂");
-                measureCommission.put("isDel", false);
-                measureCommission.put("isInsert", true);
-                measureCommission.put("IsAssembly", false);
-                measureCommission.put("deliveryMethod", "磅重交货");
-                measureCommission.put("packagesNum", 0);
-                break;
-            case 15:
-                //零星计量委托(老厂区)  会有多拼
+            case 13:     //零星进厂、出厂
+            case 14:
                 measureCommission = tmstruckMeasureCommissionMapper.sproadicMeasure(map);
                 if(measureCommission == null){
                     return 0;
                 }
+                measureCommission.put("steelyardNum", "null");
+                measureCommission.put("demo", "无");
                 measureCommission.put("isRelationEAS",false);
-                measureCommission.put("flowTo","进厂");
-                measureCommission.put("isDel", false);
-                measureCommission.put("isInsert", true);
-                measureCommission.put("deliveryMethod", "磅重交货");
-                measureCommission.put("packagesNum", 0);
-                System.out.println(measureCommission);
-                break;
-            case 16:
-                //零星计量委托(老厂区)  会有多拼
-                measureCommission = tmstruckMeasureCommissionMapper.sproadicMeasure(map);
-                if(measureCommission == null){
-                    return 0;
+                if(orderType == 12){
+                    measureCommission.put("flowTo","进厂");
+                }else if(orderType == 13){
+                    measureCommission.put("flowTo","出厂");
+                }else {
+                    measureCommission.put("flowTo","中转");
                 }
-                measureCommission.put("isRelationEAS",false);
-                measureCommission.put("flowTo","出厂");
                 measureCommission.put("isDel", false);
                 measureCommission.put("isInsert", true);
                 measureCommission.put("deliveryMethod", "磅重交货");
                 measureCommission.put("packagesNum", 0);
-                System.out.println(measureCommission);
                 break;
             case 20://采购内转委托总厂区
                 measureCommission=tmstruckMeasureCommissionMapper.purchaseXqCgNzMeasure(map);
@@ -385,10 +396,9 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
                 }
                 measureCommission.put("ended", "0");
                 break;
-            case 12:
+            case 12: // 零星订单
             case 13:
-            case 15:
-            case 16:
+            case 14:
                 measureCommission = tmstruckMeasureCommissionMapper.sporadicDXMeasure(map);
                 if(measureCommission == null)
                     return 0;
@@ -405,6 +415,8 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
         if(measureCommission != null)
             map.put("materialId", measureCommission.get("item"));
         addMeasureCommission(map); // 添加计量委托
+//        System.out.println(measureCommission);
+//        return 1;
         /*访问接口发送数据*/
         return sendMesToDXMeasure(measureCommission);
     }
@@ -477,7 +489,9 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
         int i=0;
         //获取订单类型
         BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
-        map.putAll(utilsMapper.getOrderMesByOrderId(orderId));
+        if(map.get("materialId") == null){
+            map.putAll(utilsMapper.getOrderMesByOrderId(orderId));
+        }
         BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
         //根据运输订单id查找运输订单号
         switch (orderType.intValue()){
@@ -493,6 +507,26 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
                 break;
             case 12:
             case 13:
+                //如果是自动发送委托 查询最近进厂的门岗
+                if(map.get("materialId") != null){
+                    Integer gatepostId = utilsMapper.getLastGatepostId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
+                    if(gatepostId == null){
+                        map.put("gatepostId", 1); //一般零星多拼只存在于老厂
+                    }else {
+                        map.put("gatepostId", gatepostId);
+                    }
+                }else {
+                    //手动发送委托
+                    Integer materialId = utilsMapper.getNextMaterialId(orderId);
+                    if(materialId == null) {
+                        return 0;
+                    }else {
+                        map.put("materialId", materialId);
+                        map.put("gatepostId", 1);
+                    }
+                }
+                i+=sendMeasureCommissionByGatepost(map);
+                break;
             case 15:
             case 20:
             case 16: //发送计量委托(查询物资顺序第一个装卸货的物资)

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

@@ -1,15 +1,18 @@
 package com.steerinfo.dil.service.impl;
 
 import com.steerinfo.dil.mapper.TmstruckTimeTaskResultMapper;
+import com.steerinfo.dil.mapper.UtilsMapper;
 import com.steerinfo.dil.model.TmstruckTimeTaskResult;
 import com.steerinfo.dil.service.ITmstruckTimeTaskResultService;
 
 import com.steerinfo.dil.util.DataChange;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -31,6 +34,10 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
 
     @Autowired
     private TmstruckTimeTaskResultMapper tmstruckTimeTaskResultMapper;
+    @Autowired
+    private UtilsMapper utilsMapper;
+    @Autowired
+    private UtilsServiceImpl utilsService;
 
 
     /**
@@ -187,5 +194,74 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
         return tmstruckTimeTaskResultMapper.getAllTimeTaskResult(map);
     }
 
+    /**
+     * 添加计时作业实绩
+     * @param map
+     * @return
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int addTimeTaskResult(Map<String, Object> map) throws Exception {
+        int i=0;
+        Date resultTime2 = null;
+        Date resultTime1;
+        String orderNumber =(String)map.get("orderNumber");
+        BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult=new TmstruckTimeTaskResult();
+        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
+        map.put("orderId",orderId);
+        //根据运输订单id查找实绩中是否已经含有计时结束的实绩，如果有则抛出异常
+        int countEndTimeNum = tmstruckTimeTaskResultMapper.CountTimeTaskByOrderId(orderId);
+        if (countEndTimeNum>=1){
+            throw new Exception("请勿重复计时");
+        }
+        //根据运输订单号判断是否计时开始
+        BigDecimal Time = utilsMapper.getTime(orderId);
+        if (Time==null) {
+            tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResultMapper.selectMaxId());
+            tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(resultTotalId));
+            //获取计时开始的订单类型
+            BigDecimal inwardType = DataChange.dataToBigDecimal(map.get("inwardType"));
+            tmstruckTimeTaskResult.setResultTimeType(inwardType);
+            tmstruckTimeTaskResult.setResultTime(new Date());
+            tmstruckTimeTaskResult.setInsertTime(new Date());
+            //新增第一条计时实绩
+            i += tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
+        }else {
+            //已经有计时开始时间
+            //新增第二条实绩，计时结束
+            tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(resultTotalId));
+            //获取计时结束的订单类型
+            tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResultMapper.selectMaxId());
+            tmstruckTimeTaskResult.setResultTime(new Date());
+            tmstruckTimeTaskResult.setResultTimeType(new BigDecimal(3));
+            i += tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
+            //此时获取他的上一条实绩生成计时时间
+        }
+        //判断如果计时结束则生成作业时长，根据运输订单号查找作业是否结束
+        Map<String,Object> timeStatus = utilsMapper.getTimeStatus(map);
+        //首先判断计时是否开始,如果计时开始则生成计时结束实绩
+        //通过运输订单id和实绩结束状态查找时间实绩id
+        resultTime1 =(Date) timeStatus.get("resultTime");
+        Map<String, Object> timeTask = utilsMapper.FristTimeTask(map);
+        //获取计时开始时间
+        if (resultTime1!=null&&timeTask!=null) {//生成计时结束时间得同时.生成作业时长
+            BigDecimal timeTaskresultId = DataChange.dataToBigDecimal(timeTask.get("timeResultId"));
+            map.put("timeTaskresultId",timeTaskresultId);
+            Map<String, Object> timeMaps = utilsMapper.FristTimeTask(map);
+            resultTime2 = (Date) timeMaps.get("resultTime");
+            BigDecimal timeResultId = (BigDecimal) timeMaps.get("timeResultId");
+            long dateTime = resultTime2.getTime() - resultTime1.getTime();
+            tmstruckTimeTaskResult.setTimeTaskResultId(timeResultId);
+            tmstruckTimeTaskResult.setResultValue(new BigDecimal(dateTime / 3600000));
+            tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
+            tmstruckTimeTaskResult.setUpdateTime(new Date());
+             i+=tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
+            map.put("orderStatus", 2);
+            utilsMapper.updateOrderStatusByOrderIdOrNum(map);
+        }
+        return i;
+    }
+
 
 }

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

@@ -120,9 +120,8 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
                 return tmstruckUnloadResultMapper.getInFactoryUnloadResult(map); //apiId:360
             case 12:
             case 13:
-            case 15:
-            case 16:
-            case 19:
+            case 14:
+            case 100:
                 return  tmstruckUnloadResultMapper.getSporadicSuppliesUnloadResult(map);//apiId:389
         }
         return null;
@@ -136,14 +135,13 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
     @Override
     @Transactional
     public int updateUnloadResult(Map<String, Object> map) {
-        int i = 0;
         //通过运输订单号查询订单类型
         String orderNumber = (String) map.get("orderNumber");
         //通过订单号查询订单类型 及总实绩Id
         Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
-        BigDecimal orderType = DataChange.dataToBigDecimal(mesMap.get("orderType"));
+        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
         //判断是不是内转
-        if(orderType.intValue() == 11){
+        if(orderType == 11){
             //如果是内转新增卸货实绩
             Integer sqe = utilsMapper.getLineSequenceByOrderNumber((String) map.get("orderNumber"));
             sqe = sqe == null ? 1 : sqe +1;
@@ -152,7 +150,7 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
             map.put("Sqe",sqe);
             map.put("totalId",totalId);
             TmstruckUnloadResult tmstruckUnloadResult = generateUnload(map);
-            i += tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
+            tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
             //更新路段顺序号
             //内转只要是卸货都直接关闭订单 事务跨服务更改同表同一行数据 不能调用 会锁行
             //查询是否有净重 如果没有净重更新路段顺序号需要继续回皮 有就结束订单
@@ -165,29 +163,36 @@ public class TmstruckUnloadResultServiceImpl implements ITmstruckUnloadResultSer
             }
             //卸货成功后推送消息给websocket
             utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "卸货");
-            return i;
+            return 1;
+        }
+        //如果是零星多拼订单 需要查询这个物资是否已经卸过了
+        if(orderType == 12 || orderType == 13){
+            Integer checkMaterial = tmstruckUnloadResultMapper.checkMaterialIdUnload(DataChange.dataToBigDecimal(mesMap.get("totalId")), DataChange.dataToBigDecimal(map.get("materialId")));
+            if(checkMaterial != null){
+                return -2;
+            }
         }
         map.putAll(tmstruckUnloadResultMapper.selectTotalIdByOrderNo((String) map.get("orderNumber")));
-        i += updateUnloadResultBy(map); //更新卸货实绩
+        updateUnloadResultBy(map); //更新卸货实绩
         //路段顺序号 + 1
-        i += utilsService.updateOrderLineSequence(map);
-        switch (orderType.intValue()){
+        utilsService.updateOrderLineSequence(map);
+        switch (orderType){
             case 5:
             case 6:
             case 7:
             case 8:
             case 9:
             case 10:
-            case 15:
+            case 12:
             case 17:
             case 18:
             case 20:
-                i += tmstruckReceiptResultService.addReceiptResult(map); //新增完卸车实绩后新增一条收货实绩
+                tmstruckReceiptResultService.addReceiptResult(map); //新增完卸车实绩后新增一条收货实绩
                 break;
         }
         //卸货成功后推送消息给websocket
         utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "卸货");
-        return i;
+        return 1;
     }
 
     /*

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

@@ -135,9 +135,8 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
                 return tmstruckWeightResultMapper.getInFactoryJiLiangResult(map);       //apiId: 358
             case 12:
             case 13:
-            case 15:
-            case 16:
-            case 19:
+            case 14:
+            case 100:
                 return tmstruckWeightResultMapper.getSporadicSuppliesJiMiaoResult(map); //apiId:405
 
         }
@@ -173,13 +172,10 @@ public class TmstruckWeightResultServiceImpl implements ITmstruckWeightResultSer
             case 11:
                 break;
             case 12:
-//                return tmstruckWeightResultMapper.getSporadicSuppliesJiPiResult(map);//apiId:392
             case 13:
-//                return tmstruckWeightResultMapper.getFactorySkinSporadicJIPi(map); //apiId=401
-            case 15:
+            case 14:
+            case 100:
             case 20:
-            case 16:
-            case 19:
                 return tmstruckWeightResultMapper.getFactorySkinSporadicWeight(map); //apiId=401
         }
         return null;

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

@@ -47,7 +47,7 @@ public class HTTPRequestUtils {
         //指定报文头【Content-type】、【User-Agent】
 //        httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
         httpPost.setHeader("Content-type", "application/json");
-        httpPost.setHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
+        httpPost.setHeader("-UserAgent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
 
         //执行请求操作，并拿到结果（同步阻塞）
         CloseableHttpResponse response = client.execute(httpPost);

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

@@ -1077,10 +1077,14 @@
             TWR.RESULT_TARE_WEIGHT_TIME  "resultTareWeightTime",
             TWR.RESULT_TARE_WEIGHT      "resultTareWeight",
             TWR.RESULT_GROSS_WEIGHT_TIME "resultGrossWeightTime",
-            TWR.RESULT_GROSS_WEIGHT     "resultGrossWeight"
+            TWR.RESULT_GROSS_WEIGHT     "resultGrossWeight",
+            PI.TRUCK_CALCULATE_NUMBER   "piTruckCalculateNumber",
+            MAO.TRUCK_CALCULATE_NUMBER  "maoTruckCalculateNumber"
             from OMSTRUCK_ORDER OO
             left join TMSTRUCK_TOTAL_RESULT TTR on OO.ORDER_ID = TTR.ORDER_ID
             left join TMSTRUCK_WEIGHT_RESULT  TWR  on TTR.RESULT_TOTAL_ID = TWR.RESULT_TOTAL_ID
+            left join RMS_TRUCK_CALCULATE PI on TWR.RESULT_TARE_PLACE_ID = PI.TRUCK_CALCULATE_ID
+            left join RMS_TRUCK_CALCULATE MAO on TWR.RESULT_GROSS_PLACE_ID = MAO.TRUCK_CALCULATE_ID
             left join RMS_CAPACITY RC on OO.CAPACITY_ID = RC.CAPACITY_ID
             left join AMSTRUCK_INWARD_PLAN AIP on AIP.PLAN_ID = OO.ORDER_PLAN_ID
             left join AMSTRUCK_REQUIREMENT_PLAN ARP on AIP.PLAN_ID = ARP.PLAN_ID
@@ -1299,4 +1303,132 @@
             </if>
         </where>
     </select>
+
+
+    <select id="getLXReportResult" parameterType="map" resultType="java.util.LinkedHashMap">
+        SELECT
+               *
+        FROM (
+        SELECT
+        OO.ORDER_ID                   "orderId",
+        RM.MATERIAL_NAME              "materialName",
+        RC.CAPACITY_NUMBER            "capacityNo",
+        RS.SUPPLIER_NAME              "supplierName",
+        OO.ORDER_NUMBER               "orderNumber",
+        RCE.CONSIGNEE_COMPANY_NAME    "consigneeName",
+        TTR.RESULT_TOTAL_ID           "totalResultId",
+        TER1.RESULT_ENTRY_MODE        "entryModeFirst",
+        TER1.RESULT_ENTRY_GATE_TIME   "entryGateTimeFirst",
+        RG1.GATEPOST_NAME             "entryGatepostNameFirst",
+        TWR1.RESULT_TARE_WEIGHT       "tareWeightFirst",
+        TWR1.RESULT_TARE_WEIGHT_TIME  "tareWeightTimeFirst",
+        RTC1.TRUCK_CALCULATE_NUMBER   "tareTruckCalculateFirst",
+        TLR.RESULT_LOAD_END_TIME      "loadTime",
+        RW.WAREHOUSE_NAME             "loadPoint",
+        TWR2.RESULT_GROSS_WEIGHT      "grossWeightFirst",
+        TWR2.RESULT_GROSS_WEIGHT_TIME "grossWeigtTimeFirst",
+        RTC2.TRUCK_CALCULATE_NUMBER   "grossTruckCalculateFirst",
+        TWR2.RESULT_NET_WEIGHT        "netWeightFirst",
+        TLFR1.RESULT_OUT_GATE_TIME    "outGatepostTimeFirst",
+        TLFR1.RESULT_OUT_MODE         "outModeFirst",
+        RG2.GATEPOST_NAME            "gatepostNameFirst",
+        TER2.RESULT_ENTRY_MODE        "entryModeSecond",
+        TER2.RESULT_ENTRY_GATE_TIME   "resultEntryGateTime",
+        TER2.RESULT_ENTRY_GATE_TIME   "entryGateTimeSecond",
+        RG3.GATEPOST_NAME             "entryGatepostNameSecond",
+        TWR3.RESULT_GROSS_WEIGHT      "grossWeightSecond",
+        TWR3.RESULT_GROSS_WEIGHT_TIME "grossWeigtTimeSecond",
+        RTC3.TRUCK_CALCULATE_NUMBER   "grossTruckCalculateSecond",
+        TUR.RESULT_END_TIME           "unloadTime",
+        RW2.WAREHOUSE_NAME            "unloadPoint",
+        TWR4.RESULT_TARE_WEIGHT       "tareWeightSecond",
+        TWR4.RESULT_TARE_WEIGHT_TIME  "tareWeightTimeSecond",
+        TWR4.RESULT_NET_WEIGHT        "netWeightSecond",
+        RTC4.TRUCK_CALCULATE_NUMBER   "tareTruckCalculateSecond",
+        TLFR2.RESULT_OUT_GATE_TIME    "outGatepostTimeSecond",
+        TLFR2.RESULT_OUT_GATE_TIME    "resultOutGateTime",
+        TLFR2.RESULT_OUT_MODE         "outModeSecond",
+        RG4.GATEPOST_NAME             "gatepostNameSecond"
+        FROM OMSTRUCK_ORDER OO
+        LEFT JOIN OMSTRUCK_ORDER_MATERIAL OOM ON OOM.ORDER_ID = OO.ORDER_ID
+        LEFT JOIN RMS_MATERIAL RM ON RM.MATERIAL_ID = OOM.MATERIAL_ID
+        LEFT JOIN RMS_CAPACITY RC ON RC.CAPACITY_ID = OO.CAPACITY_ID
+        LEFT JOIN AMSTRUCK_SPORADIC_ORDER ASO ON ASO.SPORADIC_ORDER_ID = OO.ORDER_PLAN_ID
+        LEFT JOIN RMS_SUPPLIER RS ON RS.SUPPLIER_ID = ASO.SEND_UNIT_ID
+        LEFT JOIN RMS_CONSIGNEE RCE ON RCE.CONSIGNEE_ID = ASO.SPORADIC_ORDER_ID
+        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR ON TTR.ORDER_ID = OO.ORDER_ID
+        LEFT JOIN TMSTRUCK_ENFACTORY_RESULT TER1  ON TER1.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_GATEPOST RG1 ON RG1.GATEPOST_ID = TER1.GATEPOST_ID
+        LEFT JOIN TMSTRUCK_WEIGHT_RESULT TWR1  ON TWR1.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_TRUCK_CALCULATE RTC1  ON RTC1.TRUCK_CALCULATE_ID = TWR1.RESULT_TARE_PLACE_ID
+        LEFT JOIN TMSTRUCK_LOAD_RESULT TLR  ON TLR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_WAREHOUSE RW ON RW.WAREHOUSE_ID = TLR.LOADING_ID
+        LEFT JOIN TMSTRUCK_WEIGHT_RESULT TWR2 ON TWR2.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_TRUCK_CALCULATE RTC2 ON RTC2.TRUCK_CALCULATE_ID = TWR2.RESULT_GROSS_PLACE_ID
+        LEFT JOIN TMSTRUCK_LEAVE_FACTORY_RESULT TLFR1  ON TLFR1.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_GATEPOST RG2 ON TLFR1.GATEPOST_ID = RG2.GATEPOST_ID
+        LEFT JOIN TMSTRUCK_ENFACTORY_RESULT TER2 ON TER2.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_GATEPOST RG3  ON RG3.GATEPOST_ID = TER2.GATEPOST_ID
+        LEFT JOIN TMSTRUCK_WEIGHT_RESULT TWR3  ON TWR3.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_TRUCK_CALCULATE RTC3 ON RTC3.TRUCK_CALCULATE_ID = TWR3.RESULT_GROSS_PLACE_ID
+        LEFT JOIN TMSTRUCK_UNLOAD_RESULT TUR  ON TUR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_WAREHOUSE RW2 ON RW2.WAREHOUSE_ID = TUR.RESULT_UNLOAD_PLACE_ID
+        LEFT JOIN TMSTRUCK_WEIGHT_RESULT TWR4 ON TWR4.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_TRUCK_CALCULATE RTC4  ON RTC4.TRUCK_CALCULATE_ID = TWR4.RESULT_TARE_PLACE_ID
+        LEFT JOIN TMSTRUCK_LEAVE_FACTORY_RESULT TLFR2  ON TLFR2.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_GATEPOST RG4  ON TLFR2.GATEPOST_ID = RG4.GATEPOST_ID
+        WHERE OO.ORDER_TYPE = 14
+        AND TER1.SEGMEN_SQE = 1
+        AND TWR1.TARE_SEGMENT_SQE = 2
+        AND TLR.SEGMENT_SQE = 3
+        AND TWR2.GROSS_SEGMENT_SQE = 4
+        AND TLFR1.SEGMENT_SQE = 5
+        AND TER2.SEGMEN_SQE = 6
+        AND TWR3.GROSS_SEGMENT_SQE = 7
+        AND TUR.SEGMENT_SQE = 8
+        AND TWR4.TARE_SEGMENT_SQE = 9
+        AND TLFR2.SEGMENT_SQE = 10
+        AND TWR2.RESULT_GROSS_WEIGHT_TIME IS NOT NULL
+        <if test="oneDate != null">
+            and to_date(#{oneDate}, 'yyyy-mm-dd hh24:mi:ss') &lt;= TWR4.RESULT_TARE_WEIGHT_TIME
+        </if>
+        <if test="startDate != null">
+            and to_date(#{startDate}, 'yyyy-mm-dd hh24:mi:ss') &lt;= TWR4.RESULT_TARE_WEIGHT_TIME
+            and to_date(#{endDate}, 'yyyy-mm-dd hh24:mi:ss') >= TWR4.RESULT_TARE_WEIGHT_TIME
+        </if>
+        )
+        <where>
+            <if test="consigneeName != null">
+                <foreach collection="consigneeName" item="item" open="(" separator="or" close=")">
+                    "consigneeName" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="supplierName != null">
+                and
+                <foreach collection="supplierName" item="item" open="(" separator="or" close=")">
+                    "supplierName" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="materialName != null">
+                and
+                <foreach collection="materialName" item="item" open="(" separator="or" close=")">
+                    "materialName" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="orderNumber != null">
+                <foreach collection="orderNumber" item="item" open="(" separator="or" close=")">
+                    "orderNumber" like '%${item}%'
+                </foreach>
+            </if>
+            <if test="capacityNo != null">
+                and
+                <foreach collection="capacityNo" item="item" open="(" separator="or" close=")">
+                    "capacityNo" like '%${item}%'
+                </foreach>
+            </if>
+        </where><include refid="orderBy"></include>
+        <if test="orderField == null">
+            order by "outGatepostTimeFirst" desc, "entryGateTimeFirst" desc
+        </if>
+    </select>
 </mapper>

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

@@ -1224,7 +1224,7 @@
         left join OMSTRUCK_ORDER_MATERIAL OOM
         ON OOM.ORDER_ID=OO.ORDER_ID
         left join RMS_MATERIAL RM
-        ON RM.MATERIAL_ID=OOM.MATERIAL_ID
+        ON RM.MATERIAL_ID = OOM.MATERIAL_ID
         left join AMSTRUCK_SPORADIC_ORDER ASO
         on OO.ORDER_PLAN_ID = ASO.SPORADIC_ORDER_ID
         left join AMSTRUCK_SPORADIC_MATERIAL ASM
@@ -1233,7 +1233,13 @@
         on RG.GATEPOST_ID = TER.GATEPOST_ID
         left join RMS_CAPACITY RC
         on RC.CAPACITY_ID = OO.CAPACITY_ID
-        WHERE OO.ORDER_TYPE = #{orderTypee} and TER.RESULT_ENTRY_GATE_TIME IS NOT NULL
+        WHERE TER.RESULT_ENTRY_GATE_TIME IS NOT NULL
+            <if test="orderTypee != 100">
+                AND OO.ORDER_TYPE = #{orderTypee}
+            </if>
+            <if test="orderTypee == 100">
+                AND OO.ORDER_TYPE in (12, 13 ,14)
+            </if>
             <if test="oneDate != null">
                 and to_date(#{oneDate}, 'yyyy-mm-dd hh24:mi:ss') &lt;= TER.RESULT_ENTRY_GATE_TIME
             </if>

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

@@ -1153,7 +1153,12 @@
         left join RMS_GATEPOST RG
         on RG.GATEPOST_ID = TLFR.GATEPOST_ID
         where RESULT_OUT_GATE_TIME is not null
-        and OO.ORDER_TYPE = #{orderTypee}
+            <if test="orderTypee != 100">
+            AND OO.ORDER_TYPE = #{orderTypee}
+            </if>
+            <if test="orderTypee == 100">
+            AND OO.ORDER_TYPE in (12, 13 ,14)
+            </if>
             <if test="userId!=null">
              AND ASO.INSERT_USERNAME=#{userId}
             </if>

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

@@ -1117,15 +1117,16 @@
 
   <!--  通过物资ID和总实绩Id查询唯一的装车实绩Id  -->
   <select id="getLoadResultIdByMIdAndTotalId" parameterType="int" resultType="java.util.Map">
+    select
+    *
+    from(
     select TLR.RESULT_ID "resultId",
     TLR.SEGMENT_SQE "segmentSqe"
     from TMSTRUCK_LOAD_RESULT TLR
-    <where>
-      TLR.RESULT_TOTAL_ID = #{resultTotalId}
-      <if test="materialId != null">
-        and TLR.MATERIAL_ID = #{materialId}
-      </if>
-    </where>
+    where TLR.RESULT_TOTAL_ID = #{resultTotalId} and TLR.RESULT_LOAD_END_TIME is null
+     order by TLR.SEGMENT_SQE
+    )
+    where rownum = 1
   </select>
 
   <!--    通过物资唯一编码 查找物资ID -->
@@ -1438,8 +1439,8 @@
     ON RC.CAPACITY_ID = OO.CAPACITY_ID
     LEFT JOIN RMS_WAREHOUSE RW
     ON RW.WAREHOUSE_ID = TLR.LOADING_ID
-    WHERE OO.ORDER_TYPE = 11
-    AND TLR.RESULT_LOAD_END_TIME IS NOT NULL
+    WHERE OO.ORDER_TYPE = #{orderTypee}
+  AND TLR.RESULT_LOAD_START_TIME IS NOT NULL
     )
     <where>
       <if test="resultLoadEndTime != null">
@@ -1541,8 +1542,14 @@
     on OO.ORDER_PLAN_ID = ASO.SPORADIC_ORDER_ID
     left join RMS_CAPACITY RC
     on RC.CAPACITY_ID = OO.CAPACITY_ID
-    where TLR.STATUS = #{status} and OO.ORDER_TYPE = #{orderTypee}
-    and TLR.RESULT_LOAD_START_TIME IS NOT NULL
+    where TLR.STATUS = #{status}
+          and TLR.RESULT_LOAD_START_TIME IS NOT NULL
+    <if test="orderTypee != 100">
+      AND OO.ORDER_TYPE = #{orderTypee}
+    </if>
+    <if test="orderTypee == 100">
+      AND OO.ORDER_TYPE in (12, 13 ,14)
+    </if>
     <if test="userId!=null">
       AND  ASO.INSERT_USERNAME=#{userId}
     </if>
@@ -1652,4 +1659,12 @@
         ) - 1
     where OO.ORDER_ID = #{orderId}
   </update>
+
+  <select id="checkMaterialIdLoad" resultType="java.lang.Integer">
+    select TLR.RESULT_ID
+    from TMSTRUCK_LOAD_RESULT TLR
+    where TLR.RESULT_TOTAL_ID = #{resultTotalId}
+        and  TLR.MATERIAL_ID = #{materialId}
+  </select>
+
 </mapper>

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

@@ -902,13 +902,15 @@
                 and rownum = 1
     </select>
 <!--  通过订单ID查询发货单位ID  -->
-    <select id="getShipperIdByOrderId" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
-        select ASO.SHIPPER_ID
+    <select id="getShipperIdByOrderId" parameterType="java.math.BigDecimal" resultType="java.util.Map">
+        select ASO.SHIPPER_ID "shipperId",
+               ASM.SALE_WAREHOUSE   "saleWarehouse"
         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 AMS_SALE_MATERIAL ASM on ASM.SALE_ORDER_ID = ASO.SALE_ORDER_ID
         where OO.ORDER_ID = #{orderId}
     </select>
 
@@ -935,37 +937,31 @@
         where oo.order_id = #{orderId} and oom.material_id = #{materialId}
     </select>
     <select id="sproadicMeasure" parameterType="map" resultType="java.util.Map">
-        select RM.MATERIAL_NAME "materiaName",
-               OO.ORDER_NUMBER "transportNum",
-               RC.CAPACITY_NUMBER "carNum",
-               RS.SUPPLIER_NAME "sendUnit",
-               RC2.CONSIGNEE_COMPANY_NAME "ReceivUnit",
-               RM.MATERIAL_ID "materialId",
-               CONCAT(RM.MATERIAL_SPECIFICATION,RM.MATERIAL_MODEL) "goodsType",
-               TWR.INSERT_UPDATE_REMARK    "demo",
-               RC2.CONSIGNEE_COMPANY_NAME  "unloadPlace",
-               RTC.TRUCK_CALCULATE_NUMBER  "steelyardNum"
+        select RM.MATERIAL_NAME                                     "materiaName",
+               OO.ORDER_NUMBER                                      "transportNum",
+               RC.CAPACITY_NUMBER                                   "carNum",
+               RS.SUPPLIER_NAME                                     "sendUnit",
+               RC2.CONSIGNEE_COMPANY_NAME                           "ReceivUnit",
+               RM.MATERIAL_ID                                       "materialId",
+               CONCAT(RM.MATERIAL_SPECIFICATION, RM.MATERIAL_MODEL) "goodsType",
+               RC2.CONSIGNEE_COMPANY_NAME                           "unloadPlace"
 
         from OMSTRUCK_ORDER OO
-        left join TMSTRUCK_TOTAL_RESULT TTR
-        ON TTR.ORDER_ID=OO.ORDER_ID
-        left join TMSTRUCK_WEIGHT_RESULT TWR
-        on TTR.RESULT_TOTAL_ID = TWR.RESULT_TOTAL_ID
-        left join RMS_TRUCK_CALCULATE RTC
-        on RTC.TRUCK_CALCULATE_ID = TWR.RESULT_GROSS_PLACE_ID
-        LEFT JOIN OMSTRUCK_ORDER_MATERIAL oom
-        ON OO.ORDER_ID=oom.ORDER_ID
-        LEFT JOIN RMS_CAPACITY RC
-        ON RC.CAPACITY_ID=OO.CAPACITY_ID
-        LEFT JOIN RMS_MATERIAL RM
-        ON RM.MATERIAL_ID=oom.MATERIAL_ID
-        LEFT JOIN AMSTRUCK_SPORADIC_ORDER ASO
-        ON ASO.SPORADIC_ORDER_ID=OO.ORDER_PLAN_ID
-        LEFT JOIN  RMS_SUPPLIER RS
-        ON  RS.SUPPLIER_ID=ASO.SEND_UNIT_ID
-        LEFT JOIN RMS_CONSIGNEE RC2
-         ON RC2.CONSIGNEE_ID=ASO.RECEIVE_UNIT_ID
-         WHERE OO.ORDER_ID=#{orderId} and  TWR.RESULT_NET_WEIGHT is null
+                 left join TMSTRUCK_TOTAL_RESULT TTR
+                           ON TTR.ORDER_ID = OO.ORDER_ID
+                 LEFT JOIN OMSTRUCK_ORDER_MATERIAL oom
+                           ON OO.ORDER_ID = oom.ORDER_ID
+                 LEFT JOIN RMS_CAPACITY RC
+                           ON RC.CAPACITY_ID = OO.CAPACITY_ID
+                 LEFT JOIN RMS_MATERIAL RM
+                           ON RM.MATERIAL_ID = oom.MATERIAL_ID
+                 LEFT JOIN AMSTRUCK_SPORADIC_ORDER ASO
+                           ON ASO.SPORADIC_ORDER_ID = OO.ORDER_PLAN_ID
+                 LEFT JOIN RMS_SUPPLIER RS
+                           ON RS.SUPPLIER_ID = ASO.SEND_UNIT_ID
+                 LEFT JOIN RMS_CONSIGNEE RC2
+                           ON RC2.CONSIGNEE_ID = ASO.RECEIVE_UNIT_ID
+        WHERE OO.ORDER_ID = #{orderId} and oom.MATERIAL_ID = #{materialId}
     </select>
 
 

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

@@ -654,61 +654,62 @@
 
   <!-- 查询计时作业 -->
   <select id="getAllTimeTaskResult" resultType="java.util.Map">
-    SELECT *
-    FROM (
-           SELECT
-                  TTTR.TIME_TASK_RESULT_ID  "timeTaskResultId",
-                  TTTR.INSERT_TIME      "insertTime",
-                  OO.ORDER_NUMBER "orderNumber",
-                  RC.CAPACITY_NUMBER "capacityNumber",
-                  RCD.DRIVER_NAME "driverName",
-                  RCT.CAPACITY_TYPE_NAME "capacityTypeName",
-                  RM.MATERIAL_NAME "materialName",
-                  RS.SHIPPER_NAME "shipperName",
-                  (
-                      SELECT TTTR2.RESULT_TIME
-                      FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
-                      WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-                            AND TTTR2.RESULT_TIME_TYPE = 1
-                      ) "startTime",
-                  TTTR.RESULT_TIME "endTime",
-                  TTTR.RESULT_VALUE "timingTime",
-                  (
-                      SELECT FLOOR (SUM(TTTR3.RESULT_VALUE) / 60000)
-                      FROM TMSTRUCK_TIME_TASK_RESULT TTTR3
-                      WHERE TTTR3.RESULT_TIME_TYPE = 7
-                        AND TTTR3.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-                    ) "allTimeout"
-
-           FROM TMSTRUCK_TIME_TASK_RESULT TTTR
-                  LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
-                            ON TTR.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-                  LEFT JOIN OMSTRUCK_ORDER OO
-                            ON OO.ORDER_ID = TTR.ORDER_ID
-                  LEFT JOIN OMSTRUCK_ORDER_MATERIAL OOM
-                            ON OOM.ORDER_ID = OO.ORDER_ID
-                  LEFT JOIN RMS_MATERIAL RM
-                            ON RM.MATERIAL_ID = OOM.MATERIAL_ID
-
-                  LEFT JOIN AMSTRUCK_INWARD_PLAN AIP
-                            ON AIP.PLAN_ID = OO.ORDER_PLAN_ID AND OO.ORDER_TYPE = 11
-                  LEFT JOIN AMSTRUCK_REQUIREMENT_PLAN ARP
-                            ON ARP.PLAN_ID = AIP.PLAN_ID
-                  LEFT JOIN AMSTRUCK_INWARD_REQUIREMENT AIR
-                            ON AIR.REQUIREMENT_ID = ARP.REQUIREMENT_ID
-                  LEFT JOIN RMS_SHIPPER RS
-                            ON RS.SHIPPER_ID = AIR.REQUIREMENT_SHIPPER_ID
-
-                  LEFT JOIN RMS_DRIVER_CAPACITY RDC
-                            ON RDC.DRIVER_CAPACITY_ID = OO.DRIVER_CAPACITY_ID
-                  LEFT JOIN RMS_CAPACITY RC
-                            ON RC.CAPACITY_ID = RDC.CAPACITY_ID
-                  LEFT JOIN RMS_CAR_DRIVER RCD
-                            ON RCD.DRIVER_ID = RDC.DRIVER_ID
-                  LEFT JOIN RMS_CAPACITY_TYPE RCT
-                            ON RCT.CAPACITY_TYPE_ID = RC.CAPACITY_TYPE_ID
-                  WHERE RESULT_TIME_TYPE = 3
-        )
+        select RC.CAPACITY_NUMBER "capacityNumber",
+               OO.ORDER_NUMBER "orderNumber",
+               CONCAT(TTTR.RESULT_VALUE,RUOM.UNIT_OF_MEASURE_NAME)  AS "resultTime",
+               RCT.CAPACITY_TYPE_NAME "capacityTypeName",
+               TTTR.INSERT_TIME "insertTime",
+           (
+           SELECT TTTR2.RESULT_TIME
+           FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
+           WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
+          AND TTTR2.RESULT_TIME_TYPE = 1
+         ) "startTime",
+        (
+         SELECT TTTR2.RESULT_TIME
+         FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
+         WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
+         AND TTTR2.RESULT_TIME_TYPE = 3
+         ) "endTime",
+          RM.MATERIAL_NAME "materialName",
+          RS.SHIPPER_NAME "shipperName",
+          RW.WAREHOUSE_NAME "unloadPointName",
+          RW2.WAREHOUSE_NAME "loadPointName"
+        from OMSTRUCK_ORDER OO
+        LEFT JOIN AMSTRUCK_INWARD_PLAN AIP
+        ON AIP.PLAN_ID=OO.ORDER_PLAN_ID
+        LEFT JOIN AMSTRUCK_REQUIREMENT_PLAN ARP
+        ON ARP.PLAN_ID=AIP.PLAN_ID
+        LEFT JOIN AMSTRUCK_INWARD_REQUIREMENT AIR
+        ON AIR.REQUIREMENT_ID=ARP.REQUIREMENT_ID
+        LEFT JOIN AMSTRUCK_REQUIREMENT_MATERIAL ARM
+        ON ARM.REQUIREMENT_ID=AIR.REQUIREMENT_ID
+         LEFT JOIN RMS_WAREHOUSE RW
+            ON ARM.REQUIREMENT_UNLOAD_UNIT_ID =RW.WAREHOUSE_ID
+            LEFT JOIN RMS_WAREHOUSE RW2
+            ON RW2.WAREHOUSE_ID=ARM.REQUIREMENT_PLATFORM_ID
+        LEFT JOIN RMS_MATERIAL RM
+        ON RM.MATERIAL_ID=ARM.MATERIAL_ID
+        LEFT JOIN RMS_SHIPPER RS
+        ON RS.SHIPPER_ID = AIR.REQUIREMENT_SHIPPER_ID
+        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+        ON TTR.ORDER_ID=OO.ORDER_ID
+        LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+        ON  TTR.RESULT_TOTAL_ID=TTTR.RESULT_TOTAL_ID
+        LEFT JOIN RMS_UNIT_OF_MEASURE RUOM
+        ON TTTR.RESULT_UOM_ID=RUOM.UNIT_OF_MEASURE_ID
+        LEFT JOIN  RMS_CAPACITY RC
+        ON RC.CAPACITY_ID=OO.CAPACITY_ID
+        LEFT JOIN RMS_CAPACITY_TYPE RCT
+        ON RCT.CAPACITY_TYPE_ID=RC.CAPACITY_TYPE_ID
+        where TTTR.RESULT_TIME_TYPE = 3  AND   TTTR.RESULT_VALUE IS NOT NULL
+    <if test="con!=null">
+      AND RC.CAPACITY_NUMBER LIKE #{con} or  RM.MATERIAL_NAME LIKE  #{con}
+      or  RS.SHIPPER_NAME LIKE #{con}
+    </if>
+    <if test="orgCode!=null">
+      AND oo.INSERT_USERNAME LIKE #{orgCode}
+    </if>
     <where>
       <if test="orderNumber != null">
         <foreach collection="orderNumber" item="item" open="(" separator="or" close=")">
@@ -775,5 +776,15 @@
       order by "insertTime" desc
     </if>
   </select>
+<!--  根据运输订单id查找实绩是否已经计时结束-->
+  <select id="CountTimeTaskByOrderId" resultType="java.lang.Integer" parameterType="java.math.BigDecimal">
+    select COUNT(*)
+    from OMSTRUCK_ORDER OO
+    LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+    ON TTR.ORDER_ID=OO.ORDER_ID
+    LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+    ON TTR.RESULT_TOTAL_ID=TTTR.RESULT_TOTAL_ID
+    WHERE OO.ORDER_ID=#{orderId} and TTTR.RESULT_TIME_TYPE=3 and TTTR.RESULT_VALUE IS not NULL
+  </select>
 
 </mapper>

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

@@ -377,8 +377,7 @@
                                   ON RCT.CAPACITY_TYPE_ID = RC.CAPACITY_TYPE_ID
                         LEFT JOIN RMS_SHIPPER RS
                                   ON AIR.REQUIREMENT_SHIPPER_ID = RS.SHIPPER_ID
-               WHERE AIR.REQUIREMENT_TYPE = '计时'
-                 AND OO.ORDER_STATUS = 11
+               WHERE AIR.REQUIREMENT_TYPE = '计次'
            )
     <where>
         <if test="materialName != null">

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

@@ -656,20 +656,27 @@
 
     <!--  通过运输订单号 查询实绩Id、总实绩ID -->
     <select id="selectTotalIdByOrderNo" parameterType="java.lang.String" resultType="java.util.Map">
-        select OO.ORDER_ID         "orderId",
-               OO.ORDER_TYPE       "orderTypee",
-               TUR.RESULT_ID       "resultId",
-               TTR.RESULT_TOTAL_ID "resultTotalId",
-               RC.CAPACITY_NUMBER "capacityNumber",
-               TUR.SEGMENT_SQE      "segmentSqe"
-        from OMSTRUCK_ORDER OO
-                 left join TMSTRUCK_TOTAL_RESULT TTR
-                           on OO.ORDER_ID = TTR.ORDER_ID
-                 left join TMSTRUCK_UNLOAD_RESULT TUR
-                           on TTR.RESULT_TOTAL_ID = TUR.RESULT_TOTAL_ID
-                 left join RMS_CAPACITY RC
-                           on RC.CAPACITY_ID = OO.CAPACITY_ID
-        where OO.ORDER_NUMBER = #{orderNumber}
+        select *
+        from (
+                 select OO.ORDER_ID         "orderId",
+                        OO.ORDER_TYPE       "orderTypee",
+                        TUR.RESULT_ID       "resultId",
+                        TTR.RESULT_TOTAL_ID "resultTotalId",
+                        RC.CAPACITY_NUMBER  "capacityNumber",
+                        TUR.SEGMENT_SQE     "segmentSqe"
+
+                 from OMSTRUCK_ORDER OO
+                          left join TMSTRUCK_TOTAL_RESULT TTR
+                                    on OO.ORDER_ID = TTR.ORDER_ID
+                          left join TMSTRUCK_UNLOAD_RESULT TUR
+                                    on TTR.RESULT_TOTAL_ID = TUR.RESULT_TOTAL_ID
+                          left join RMS_CAPACITY RC
+                                    on RC.CAPACITY_ID = OO.CAPACITY_ID
+                 where OO.ORDER_NUMBER = #{orderNumber}
+                   and TUR.RESULT_END_TIME is null
+                 order by TUR.SEGMENT_SQE
+             )
+        where rownum = 1
     </select>
 
     <!--  通过卸货地点查询 仓库ID-->
@@ -890,8 +897,8 @@
         ON RM.MATERIAL_ID = OOM.MATERIAL_ID
         LEFT JOIN RMS_WAREHOUSE RW
         ON RW.WAREHOUSE_ID = TUR.RESULT_UNLOAD_PLACE_ID
-        WHERE TUR.RESULT_END_TIME IS NOT NULL
-        AND OO.ORDER_TYPE = 11
+        WHERE TUR.RESULT_START_TIME IS NOT NULL
+        AND OO.ORDER_TYPE = #{orderTypee}
         )
         <where>
             <if test="orderNumber != null">
@@ -980,7 +987,12 @@
         LEFT JOIN RMS_WAREHOUSE RW
         ON RW.WAREHOUSE_ID = TUR.RESULT_UNLOAD_PLACE_ID
         WHERE TUR.RESULT_END_TIME IS NOT NULL
-        AND OO.ORDER_TYPE = #{orderTypee}
+        <if test="orderTypee != 100">
+            AND OO.ORDER_TYPE = #{orderTypee}
+        </if>
+        <if test="orderTypee == 100">
+            AND OO.ORDER_TYPE in (12, 13 ,14)
+        </if>
          <if test="userId != null">
              and ASO.INSERT_USERNAME=#{userId}
          </if>
@@ -1063,4 +1075,11 @@
         select COUNT(TWR.RESULT_NET_WEIGHT) from TMSTRUCK_WEIGHT_RESULT TWR  where TWR.RESULT_TOTAL_ID = #{totalId}
     </select>
 
+    <select id="checkMaterialIdUnload" resultType="java.lang.Integer">
+        select TUR.RESULT_ID
+        from TMSTRUCK_UNLOAD_RESULT TUR
+        where TUR.RESULT_TOTAL_ID = #{resultTotalId}
+          and  TUR.MATERIAL_ID = #{materialId}
+    </select>
+
 </mapper>

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

@@ -2099,7 +2099,7 @@
         left join RMS_MATERIAL RM
         on RM.MATERIAL_ID = OOM.MATERIAL_ID
         where RESULT_TARE_WEIGHT_TIME is not null
-        and OO.ORDER_TYPE = 11
+        and OO.ORDER_TYPE = #{orderTypee}
         )
         <where>
             <if test="materialName != null">
@@ -2198,8 +2198,13 @@
         on RC.CAPACITY_ID = OO.CAPACITY_ID
         left join RMS_TRUCK_CALCULATE RTC
         on RTC.TRUCK_CALCULATE_ID = TWR.RESULT_GROSS_PLACE_ID
-        where RESULT_GROSS_WEIGHT_TIME is not null and
-        OO.ORDER_TYPE = #{orderTypee}
+        where RESULT_GROSS_WEIGHT_TIME is not null
+        <if test="orderTypee != 100">
+            AND OO.ORDER_TYPE = #{orderTypee}
+        </if>
+        <if test="orderTypee == 100">
+            AND OO.ORDER_TYPE in (12, 13 ,14)
+        </if>
             <if test="userId!=null">
                 and ASO.INSERT_USERNAME=#{userId}
             </if>
@@ -2393,7 +2398,12 @@
         left join RMS_MATERIAL RM
         on RM.MATERIAL_ID = OOM.MATERIAL_ID
         where RESULT_TARE_WEIGHT_TIME is not null
-              and OO.ORDER_TYPE = #{orderTypee}
+        <if test="orderTypee != 100">
+            AND OO.ORDER_TYPE = #{orderTypee}
+        </if>
+        <if test="orderTypee == 100">
+            AND OO.ORDER_TYPE in (12, 13 ,14)
+        </if>
         <if test="userId!=null">
             and ASO.INSERT_USERNAME=#{userId}
         </if>

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

@@ -199,8 +199,10 @@
     <select id="getOrderTypeByOrderNumber" parameterType="string" resultType="map">
         select OO.ORDER_TYPE "orderType",
                TTR.RESULT_TOTAL_ID "totalId",
+               TTR.RESULT_TOTAL_ID "resultTotalId",
                OO.ORDER_ID      "orderId",
                OO.ORDER_LINE_SEQUENCE "Sqe",
+               OO.LINE_ID           "lineId",
                RC.CAPACITY_NUMBER   "capacityNumber"
         from OMSTRUCK_ORDER OO
         left join TMSTRUCK_TOTAL_RESULT TTR
@@ -219,4 +221,98 @@
     <select id="getCapacityIdByNum" parameterType="string" resultType="java.math.BigDecimal">
         select RC.CAPACITY_ID from RMS_CAPACITY RC where RC.CAPACITY_NUMBER = #{capacityNumber}
     </select>
+
+    <select id="getLastGatepostId" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
+        select *
+        from (
+                 select TER.GATEPOST_ID
+                 from TMSTRUCK_ENFACTORY_RESULT TER
+                 where TER.RESULT_TOTAL_ID = #{resultTotalId}
+                   and TER.RESULT_ENTRY_GATE_TIME is not null
+                 order by TER.SEGMEN_SQE DESC
+             )
+        where rownum = 1
+    </select>
+    <select id="getNextMaterialId" parameterType="java.math.BigDecimal" resultType="java.lang.Integer">
+        select *
+        from (
+                 select OOM.MATERIAL_ID
+                 from OMSTRUCK_ORDER_MATERIAL OOM
+                 where OOM.ORDER_ID = #{orderId}
+                   AND NOT EXISTS(select TWR.MATERIAL_ID
+                                  from TMSTRUCK_TOTAL_RESULT TTR
+                                           left join TMSTRUCK_WEIGHT_RESULT TWR
+                                                     on TWR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+                                  where TTR.ORDER_ID = OOM.ORDER_ID
+                                    and OOM.MATERIAL_ID = TWR.MATERIAL_ID
+                     )
+                 order by OOM.MATERIAL_PRIORITY
+             )
+        where rownum = 1
+    </select>
+
+    <select id="timeTaskResult" resultType="java.util.Map" parameterType="java.math.BigDecimal">
+        select   TTTR.TIME_TASK_RESULT_ID "timeTaskResultId"
+        from OMSTRUCK_ORDER OO
+        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+        ON OO.ORDER_ID=TTR.ORDER_ID
+        LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+        ON TTTR.RESULT_TOTAL_ID=TTR.RESULT_TOTAL_ID
+        where oo.ORDER_ID=#{orderId}
+    </select>
+
+
+    <sql id="orderBy">
+        <if test="orderField != null and orderField != ''">
+            order by "${orderField}"
+            <if test="orderType != null and orderType != ''">
+                ${orderType}
+            </if>
+        </if>
+    </sql>
+
+    <select id="getTimeStatus" resultType="java.util.Map" parameterType="java.util.Map">
+     select TTTR.TIME_TASK_RESULT_ID "timeTaskResultId",
+            TTTR.RESULT_TIME_TYPE "timeType",
+            TTTR.INSERT_TIME "insertTime",
+            TTTR.RESULT_TIME "resultTime"
+     FROM OMSTRUCK_ORDER OO
+     LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+     ON TTR.ORDER_ID=OO.ORDER_ID
+     LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+     ON TTTR.RESULT_TOTAL_ID=TTR.RESULT_TOTAL_ID
+     WHERE  OO.ORDER_ID=#{orderId} and TTTR.RESULT_TIME_TYPE = 1
+     <include refid="orderBy"/>
+     <if test="orderField == null  ">
+        order by "insertTime" desc
+     </if>
+    </select>
+<!-- 根据运输订单id查找两次计时作业id-->
+    <select id="FristTimeTask" resultType="java.util.Map" parameterType="java.util.Map">
+        select   TTTR.RESULT_TIME "resultTime",
+                 TTTR.TIME_TASK_RESULT_ID "timeResultId"
+        from OMSTRUCK_ORDER OO
+                 LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+                           ON OO.ORDER_ID=TTR.ORDER_ID
+                 LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+                           ON TTTR.RESULT_TOTAL_ID=TTR.RESULT_TOTAL_ID
+        where OO.ORDER_ID=#{orderId} and TTTR.RESULT_TIME_TYPE =3
+    </select>
+    <select id="getTime" resultType="java.math.BigDecimal" parameterType="java.math.BigDecimal">
+        select TTTR.TIME_TASK_RESULT_ID "timeTaskResultId"
+        from OMSTRUCK_ORDER OO
+        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+        ON TTR.ORDER_ID=OO.ORDER_ID
+        left join TMSTRUCK_TIME_TASK_RESULT TTTR
+        on  TTR.RESULT_TOTAL_ID=TTTR.RESULT_TOTAL_ID
+        WHERE OO.ORDER_ID=#{orderId} and TTTR.RESULT_TIME_TYPE=1
+    </select>
+<!-- 根据运输订单id查找总实绩id-->
+    <select id="getTotalIdByOrderId" resultType="java.math.BigDecimal" parameterType="java.math.BigDecimal">
+        select TTR.RESULT_TOTAL_ID "resultTotalId"
+        from OMSTRUCK_ORDER OO
+        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+        ON OO.ORDER_ID=TTR.ORDER_ID
+       WHERE  OO.ORDER_ID=#{orderId}
+    </select>
 </mapper>