as

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

@@ -68,6 +68,45 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
     }
 
 
+    @ApiOperation(value="用于计时判断")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
+    })
+    @PostMapping("/JudgeTimeTask")
+    public RESTfulResult JudgeTimeTask(@RequestBody(required=false) Map<String,Object> mapValue) throws Exception {
+        int i=0;
+        try {
+            i=tmstruckTimeTaskResultService.JudgeTimeTask(mapValue);
+        } catch (Exception e) {
+            return failed(e.getMessage());
+        }
+        return success(i);
+    }
+
+
+
+
+
+
+
+
+    @ApiOperation(value="用于计时暂停判断")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
+    })
+    @PostMapping("/JudgeTimeTaskPause")
+    public RESTfulResult JudgeTimeTaskPause(@RequestBody(required=false) Map<String,Object> mapValue) throws Exception {
+        int i=0;
+        try {
+            i=tmstruckTimeTaskResultService.JudgeTimeTaskPause(mapValue);
+        } catch (Exception e) {
+            return failed(e.getMessage());
+        }
+        return success(i);
+    }
+
+
+
 
 
     @ApiOperation(value="用车单位确认开始")
@@ -90,7 +129,7 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
         return success(i);
     }
 
-    @ApiOperation(value="用车单位确认暂停申请开始")
+    @ApiOperation(value="暂停计时")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "mapValue", value = "运输订单号", required = false, dataType = "Map"),
     })
@@ -165,13 +204,13 @@ public class TmstruckTimeTaskResultController extends BaseRESTfulController {
                                           Integer pageNum,
                                           Integer pageSize,
                                           String con,
-                                          String orgCode
+                                          String userId
     ){
         if (con!=null&&!con.equals("undifined")&&!con.equals("")){
             mapValue.put("con","%" + con + "%");
         }
-        if (orgCode!=null&&!orgCode.equals("undifined")&&!con.equals("")){
+        if (userId!=null&&!userId.equals("undifined")&&!con.equals("")){
-            mapValue.put("userId",orgCode);
+            mapValue.put("userId",userId);
         }
         PageHelper.startPage(pageNum,pageSize);
         //分页数据

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

@@ -22,6 +22,9 @@ public interface TmstruckTimeTaskResultMapper extends IBaseMapper<TmstruckTimeTa
     //查询上一次用车单位确认暂停结束时间
     Map<String, Object> getLastTimeout(BigDecimal resultTotalId);
 
+    //查询上一次用车单位确认暂停 确认结束时间
+    Map<String, Object> getLastTimeEnd(BigDecimal resultTotalId);
+
     //查询用车单位确认开始时间
     Map<String, Object> getStartTime(BigDecimal resultTotalId);
 

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

@@ -106,11 +106,21 @@ public interface UtilsMapper {
     Map<String,Object> timeTaskResult(BigDecimal orderId);
 
     //根据运输订单id查找订单类型
-   Map<String,Object> getTimeStatus(Map<String,Object> map);
+    Map<String,Object> getTimeStatus(Map<String,Object> map);
+
+    //通过运输订单号查找内转类型
+    BigDecimal getInwardType(BigDecimal orderId);
 
     //根据运输订单id查找两次计时作业实绩
    Map<String,Object> FristTimeTask(Map<String,Object> map);
 
+   //根据运输订单id查找计时暂停时间
+    List<Map<String,Object>> TimeTaskPause(Map<String,Object> map);
+
    //通过运输订单id查找计时是否开始
     BigDecimal getTime(BigDecimal orderId);
+
+    BigDecimal getInwardStartTime(BigDecimal orderId);
+
+    BigDecimal getInwardEndTime(BigDecimal orderId);
 }

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

@@ -52,6 +52,11 @@ public interface ITmstruckTimeTaskResultService {
     //新增作业实绩
     int addTimeTaskResult(Map<String,Object> map) throws Exception;
 
+    int JudgeTimeTask(Map<String, Object> mapValue) throws Exception;
+
+    int JudgeTimeTaskPause(Map<String, Object> mapValue) throws Exception;
+
+
     //修改计时作业
 //    int updateTimeTaskResult(Map<String,Object> map);
 }

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

@@ -341,8 +341,8 @@ public class TmstruckMeasureCommissionServiceImpl implements ITmstruckMeasureCom
 //        System.out.println(measureCommission);
 //        return 1;
         /*访问接口发送数据*/
-//        return sendMesToMeasure(measureCommission);
+        return sendMesToMeasure(measureCommission);
-        return 1;
+
 
     }
 

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

@@ -42,103 +42,132 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
 
     /**
      * 通用生成实例数据
+     *
      * @param map
      * @return
      */
-    public TmstruckTimeTaskResult generateTimeTaskResult(Map<String, Object> map, Integer timeType){
+    public TmstruckTimeTaskResult generateTimeTaskResult(Map<String, Object> map) {
         TmstruckTimeTaskResult tmstruckTimeTaskResult = new TmstruckTimeTaskResult();
         //获取主键ID
         tmstruckTimeTaskResult.setId(tmstruckTimeTaskResultMapper.selectMaxId());
         String orderNumber = (String) map.get("orderNumber");
+        BigDecimal inwardType = DataChange.dataToBigDecimal(map.get("inwardType"));
         //通过运输订单号查询总实绩ID等数据
         map.putAll(tmstruckTimeTaskResultMapper.getResultTotalIdByOrderNum(orderNumber));
         tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
         //生成时间
         tmstruckTimeTaskResult.setResultTime(new Date());
+        //生成订单结束
+        tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
         //设置时间类型
-        tmstruckTimeTaskResult.setResultTimeType(new BigDecimal(timeType));
+        tmstruckTimeTaskResult.setResultTimeType(inwardType);
+        String personnelSsoId =(String) map.get("personnelSsoId");
+        tmstruckTimeTaskResult.setInsertUsername(personnelSsoId);
+        tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
         return tmstruckTimeTaskResult;
     }
 
     /**
      * 司机申请开始
+     *
      * @param map
      * @return
      */
     @Override
     public int applyStartTime(Map<String, Object> map) {
         //设置时间类型 0
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 0);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
     /**
      * 用车单位确认开始
+     *
      * @param map
      * @return
      */
     @Override
     public int unitSureStartTime(Map<String, Object> map) {
         //设置时间类型 1
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 1);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
     /**
      * 司机申请暂停
+     *
      * @param map
      * @return
      */
     @Override
     public int applyStartTimeout(Map<String, Object> map) {
         //设置时间类型 4
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 4);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
     /**
      * 用车单位确认
+     *
      * @param map
      * @return
      */
     @Override
     public int unitSureStartTimeout(Map<String, Object> map) {
         //设置时间类型 5
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 5);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
     /**
      * 司机申请暂停结束
+     *
      * @param map
      * @return
      */
     @Override
     public int applyEndTimeout(Map<String, Object> map) {
         //设置时间类型 6
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 6);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
     /**
      * 用车单位确认暂停结束
+     *
      * @param map
      * @return
      */
     @Override
     public int unitSureEndTimeout(Map<String, Object> map) {
-        //设置时间类型 7
+        int i=0;
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 7);
+        //map中传输的参数为InwardType,orderNumber
-        //查询上一次结束的时间
+        //根据运输订单号查找订单id
-        Map<String, Object> timeMap = tmstruckTimeTaskResultMapper.getLastTimeout(tmstruckTimeTaskResult.getResultTotalId());
+        //如果订单类型为5
-        Object resultTime = timeMap.get("resultTime");
+        String personnelSsoId =(String) map.get("personnelSsoId");
-        if(resultTime != null){
+        String orderNumber =(String) map.get("orderNumber");
-            Date lastTimeout = (Date) resultTime;
+        BigDecimal inwardType =DataChange.dataToBigDecimal(map.get("inwardType"));
-            //计算相差时间戳 存入当前实绩中  更精确
+        if (inwardType.intValue()==5){
-            long differenceTime = new Date().getTime() - lastTimeout.getTime();
+            generateTimeTaskResult(map);
-            tmstruckTimeTaskResult.setResultValue(new BigDecimal(differenceTime));
+        }else if (inwardType.intValue()==7){
+            TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
+            //生成计时实绩暂停
+            //根据运输订单号查找总实绩id
+            BigDecimal totalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
+            //根据总实绩id查找开始时间
+            Map<String, Object> lastTimeout = tmstruckTimeTaskResultMapper.getLastTimeout(totalId);
+            Date startTime =(Date) lastTimeout.get("resultTime");
+            //根据总实绩id查找结束时间
+            Map<String, Object> lastTimeEnd = tmstruckTimeTaskResultMapper.getLastTimeEnd(totalId);
+            Date EndTime = (Date) lastTimeEnd.get("resultTime");
+            long dueTime=EndTime.getTime()-startTime.getTime();
+            tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResult.getTimeTaskResultId());
+            tmstruckTimeTaskResult.setResultValue(new BigDecimal((dueTime/(1000*60))));
+            tmstruckTimeTaskResult.setUpdateTime(new Date());
+            i+=tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
         }
-        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
+
+        return i;
     }
 
     /**
@@ -149,7 +178,7 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
     @Override
     public int applyEndTime(Map<String, Object> map) {
         //设置时间类型 2
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 2);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
     }
 
@@ -161,7 +190,7 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
     @Override
     public int unitSureEndTime(Map<String, Object> map) {
         //设置时间类型 3
-        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map, 3);
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
         //查询当前车辆排队开始时间 计算出总时长
         Map<String, Object> startTimeMap = tmstruckTimeTaskResultMapper.getStartTime(tmstruckTimeTaskResult.getResultTotalId());
         Date endTime = new Date();
@@ -202,66 +231,98 @@ public class TmstruckTimeTaskResultServiceImpl implements ITmstruckTimeTaskResul
     @Override
     @Transactional(rollbackFor = Exception.class)
     public int addTimeTaskResult(Map<String, Object> map) throws Exception {
+           //判断是否是计时开始还是计时结束
         int i=0;
-        Date resultTime2 = null;
+        BigDecimal inwardType =DataChange.dataToBigDecimal(map.get("inwardTypes")) ;
-        Date resultTime1;
+        String orderNumber = (String) map.get("orderNumber");
-        String orderNumber =(String)map.get("orderNumber");
+        String personnelSsoId = (String) map.get("personnelSsoId");
         BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
-        TmstruckTimeTaskResult tmstruckTimeTaskResult=new TmstruckTimeTaskResult();
+        TmstruckTimeTaskResult tmstruckTimeTaskResult = new TmstruckTimeTaskResult();
         BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
-        map.put("orderId",orderId);
+        map.put("orderId", orderId);
         //根据运输订单id查找实绩中是否已经含有计时结束的实绩，如果有则抛出异常
         int countEndTimeNum = tmstruckTimeTaskResultMapper.CountTimeTaskByOrderId(orderId);
-        if (countEndTimeNum>=1){
+        if (countEndTimeNum >= 1) {
             throw new Exception("请勿重复计时");
         }
-        //根据运输订单号判断是否计时开始
+        if (inwardType.intValue()==1){
-        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());
+            tmstruckTimeTaskResult.setInsertUsername(personnelSsoId);
             //新增第一条计时实绩
             i += tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
-        }else {
+        }else if (inwardType.intValue()==3){
-            //已经有计时开始时间
-            //新增第二条实绩，计时结束
             tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(resultTotalId));
             //获取计时结束的订单类型
             tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResultMapper.selectMaxId());
             tmstruckTimeTaskResult.setResultTime(new Date());
             tmstruckTimeTaskResult.setResultTimeType(new BigDecimal(3));
-            i += tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
+            tmstruckTimeTaskResult.setInsertUsername(personnelSsoId);
-            //此时获取他的上一条实绩生成计时时间
+            tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
-        }
+            //获取最新暂停结束确认时间
-        //判断如果计时结束则生成作业时长，根据运输订单号查找作业是否结束
+            Map<String, Object> map2 = new HashMap<>();
-        Map<String,Object> timeStatus = utilsMapper.getTimeStatus(map);
+            map2.put("type", 7);
-        //首先判断计时是否开始,如果计时开始则生成计时结束实绩
+            map2.put("orderId", orderId);
-        //通过运输订单id和实绩结束状态查找时间实绩id
+            List<Map<String, Object>> List = utilsMapper.TimeTaskPause(map2);
-        resultTime1 =(Date) timeStatus.get("resultTime");
+            Map<String, Object> map4 = List.get(0);
-        Map<String, Object> timeTask = utilsMapper.FristTimeTask(map);
+            BigDecimal resultPauseTimeEnd = DataChange.dataToBigDecimal( map4.get("resultPauseTime"));
-        //获取计时开始时间
-        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");
+            Date resultTime2 = (Date) timeMaps.get("resultTime");
-            BigDecimal timeResultId = (BigDecimal) timeMaps.get("timeResultId");
+            Map<String, Object> timeStatus = utilsMapper.getTimeStatus(map);
-            long dateTime = resultTime2.getTime() - resultTime1.getTime();
+            Date  resultTime1 = (Date) timeStatus.get("resultTime");
-            tmstruckTimeTaskResult.setTimeTaskResultId(timeResultId);
+            long dateTime1 = resultTime2.getTime() - resultTime1.getTime();
-            tmstruckTimeTaskResult.setResultValue(new BigDecimal(dateTime / 3600000));
+            BigDecimal dateTime3 = new BigDecimal(dateTime1 / (1000 * 60));
+            int Time1 = dateTime3.intValue() - resultPauseTimeEnd.intValue();
+            tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResult.getTimeTaskResultId());
+            tmstruckTimeTaskResult.setResultValue(new BigDecimal((Time1)));
             tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
-            tmstruckTimeTaskResult.setUpdateTime(new Date());
+            tmstruckTimeTaskResult.setUpdateUsername(personnelSsoId);
-             i+=tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
+            i += tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
             map.put("orderStatus", 2);
             utilsMapper.updateOrderStatusByOrderIdOrNum(map);
         }
-        return i;
+            return i;
+        }
+
+   //通过运输订单号判断计时是否开始
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int JudgeTimeTask(Map<String, Object> mapValue) throws Exception {
+        String orderNumber =(String)mapValue.get("orderNumber");
+        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
+        //通过运输订单号查找当前是第几次
+        BigDecimal inwardType = utilsMapper.getInwardType(orderId);
+        if (inwardType!=null){
+            throw new Exception("计时已经开始");
+        }
+        return inwardType.intValue();
     }
 
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int JudgeTimeTaskPause(Map<String, Object> mapValue) throws Exception {
+        String orderNumber =(String)mapValue.get("orderNumber");
+        int i=0;
+        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
+        //通过运输订单号查找当前是第几次
+        BigDecimal inwardStartTime = utilsMapper.getInwardStartTime(orderId);
+//        System.out.println(inwardStartTime);
+        BigDecimal inwardEndTime = utilsMapper.getInwardEndTime(orderId);
+//        System.out.println(inwardEndTime);
+        int Time=inwardEndTime.intValue()-inwardStartTime.intValue();
+//        System.out.println(Time);
+       if (Time==0) {
+           i=0;
+       }else if (Time==-1){
+           i=1;
+       }else {
+           i=3;
+       }
+        return i;
+    }
 }

src/main/resources/application-dev.yml

@@ -31,15 +31,15 @@ openfeign:
   WMSFeign:
     url: ${WMSFEIGN_URL:172.16.33.162:8012}
   OmsFeign:
-    url: ${OMSFEIGN_URL:192.168.1.113:8016}
+    url: ${OMSFEIGN_URL:172.16.33.162:8016}
   JoinFeign:
-    url: ${JOINFEIGN_URL:localhost:8006}
+    url: ${JOINFEIGN_URL:172.16.33.162:8006}
   QmsFeign:
     url: ${QMSFEIGN_URL:172.16.33.162:8017}
   ImFeign:
     url: ${IMFEIGN_URL:172.16.33.166:8055}
   AmsFeign:
-    url: ${AMSFEIGN_URL:localhost:8015}
+    url: ${AMSFEIGN_URL:172.16.33.162:8015}
 
 server:
   port: 8008

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

@@ -626,6 +626,19 @@
     where rownum = 1
   </select>
 
+
+  <select id="getLastTimeEnd" parameterType="java.math.BigDecimal" resultType="java.util.Map">
+    select *
+    from(
+          SELECT TTTR.RESULT_TIME "resultTime"
+          FROM TMSTRUCK_TIME_TASK_RESULT TTTR
+          WHERE TTTR.RESULT_TOTAL_ID = #{resultTotalId}
+            AND TTTR.RESULT_TIME_TYPE = 7
+          ORDER BY "resultTime" DESC
+        )
+    where rownum = 1
+  </select>
+
 <!--  查询用车单位确认开始时间-->
   <select id="getStartTime" parameterType="java.math.BigDecimal" resultType="java.util.Map">
     SELECT TTTR.RESULT_TIME "resultTime"
@@ -654,61 +667,68 @@
 
   <!-- 查询计时作业 -->
   <select id="getAllTimeTaskResult" resultType="java.util.Map">
-        select RC.CAPACITY_NUMBER "capacityNumber",
+    select RC.CAPACITY_NUMBER "capacityNumber",
-               OO.ORDER_NUMBER "orderNumber",
+           OO.ORDER_ID "orderId",
-               CONCAT(TTTR.RESULT_VALUE,RUOM.UNIT_OF_MEASURE_NAME)  AS "resultTime",
+    OO.ORDER_NUMBER "orderNumber",
-               RCT.CAPACITY_TYPE_NAME "capacityTypeName",
+    CONCAT(TTTR.RESULT_VALUE,RUOM.UNIT_OF_MEASURE_NAME)  AS "resultTime",
-               TTTR.INSERT_TIME "insertTime",
+    RCT.CAPACITY_TYPE_NAME "capacityTypeName",
-           (
+    TTTR.INSERT_TIME "insertTime",
-           SELECT TTTR2.RESULT_TIME
+    (
-           FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
+    SELECT TTTR2.RESULT_TIME
-           WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
+    FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
-          AND TTTR2.RESULT_TIME_TYPE = 1
+    WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-         ) "startTime",
+    AND TTTR2.RESULT_TIME_TYPE = 1
-        (
+    ) "startTime",
-         SELECT TTTR2.RESULT_TIME
+    (
-         FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
+    SELECT TTTR2.RESULT_TIME
-         WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
+    FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
-         AND TTTR2.RESULT_TIME_TYPE = 3
+    WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-         ) "endTime",
+    AND TTTR2.RESULT_TIME_TYPE = 3
-          RM.MATERIAL_NAME "materialName",
+    ) "endTime",
-          RS.SHIPPER_NAME "shipperName",
+    (
-          RW.WAREHOUSE_NAME "unloadPointName",
+    SELECT count(TTTR2.RESULT_VALUE)
-          RW2.WAREHOUSE_NAME "loadPointName"
+    FROM TMSTRUCK_TIME_TASK_RESULT TTTR2
-        from OMSTRUCK_ORDER OO
+    WHERE TTTR2.RESULT_TOTAL_ID = TTTR.RESULT_TOTAL_ID
-        LEFT JOIN AMSTRUCK_INWARD_PLAN AIP
+    AND TTTR2.RESULT_TIME_TYPE = 7
-        ON AIP.PLAN_ID=OO.ORDER_PLAN_ID
+    ) "pauseTime",
-        LEFT JOIN AMSTRUCK_REQUIREMENT_PLAN ARP
+    RM.MATERIAL_NAME "materialName",
-        ON ARP.PLAN_ID=AIP.PLAN_ID
+    RS.SHIPPER_NAME "shipperName",
-        LEFT JOIN AMSTRUCK_INWARD_REQUIREMENT AIR
+    RW.WAREHOUSE_NAME "unloadPointName",
-        ON AIR.REQUIREMENT_ID=ARP.REQUIREMENT_ID
+    RW2.WAREHOUSE_NAME "loadPointName"
-        LEFT JOIN AMSTRUCK_REQUIREMENT_MATERIAL ARM
+    from OMSTRUCK_ORDER OO
-        ON ARM.REQUIREMENT_ID=AIR.REQUIREMENT_ID
+    LEFT JOIN AMSTRUCK_INWARD_PLAN AIP
-         LEFT JOIN RMS_WAREHOUSE RW
+    ON AIP.PLAN_ID=OO.ORDER_PLAN_ID
-            ON ARM.REQUIREMENT_UNLOAD_UNIT_ID =RW.WAREHOUSE_ID
+    LEFT JOIN AMSTRUCK_REQUIREMENT_PLAN ARP
-            LEFT JOIN RMS_WAREHOUSE RW2
+    ON ARP.PLAN_ID=AIP.PLAN_ID
-            ON RW2.WAREHOUSE_ID=ARM.REQUIREMENT_PLATFORM_ID
+    LEFT JOIN AMSTRUCK_INWARD_REQUIREMENT AIR
-        LEFT JOIN RMS_MATERIAL RM
+    ON AIR.REQUIREMENT_ID=ARP.REQUIREMENT_ID
-        ON RM.MATERIAL_ID=ARM.MATERIAL_ID
+    LEFT JOIN AMSTRUCK_REQUIREMENT_MATERIAL ARM
-        LEFT JOIN RMS_SHIPPER RS
+    ON ARM.REQUIREMENT_ID=AIR.REQUIREMENT_ID
-        ON RS.SHIPPER_ID = AIR.REQUIREMENT_SHIPPER_ID
+    LEFT JOIN RMS_WAREHOUSE RW
-        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+    ON ARM.REQUIREMENT_UNLOAD_UNIT_ID =RW.WAREHOUSE_ID
-        ON TTR.ORDER_ID=OO.ORDER_ID
+    LEFT JOIN RMS_WAREHOUSE RW2
-        LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
+    ON RW2.WAREHOUSE_ID=ARM.REQUIREMENT_PLATFORM_ID
-        ON  TTR.RESULT_TOTAL_ID=TTTR.RESULT_TOTAL_ID
+    LEFT JOIN RMS_MATERIAL RM
-        LEFT JOIN RMS_UNIT_OF_MEASURE RUOM
+    ON RM.MATERIAL_ID=ARM.MATERIAL_ID
-        ON TTTR.RESULT_UOM_ID=RUOM.UNIT_OF_MEASURE_ID
+    LEFT JOIN RMS_SHIPPER RS
-        LEFT JOIN  RMS_CAPACITY RC
+    ON RS.SHIPPER_ID = AIR.REQUIREMENT_SHIPPER_ID
-        ON RC.CAPACITY_ID=OO.CAPACITY_ID
+    LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
-        LEFT JOIN RMS_CAPACITY_TYPE RCT
+    ON TTR.ORDER_ID=OO.ORDER_ID
-        ON RCT.CAPACITY_TYPE_ID=RC.CAPACITY_TYPE_ID
+    LEFT JOIN TMSTRUCK_TIME_TASK_RESULT TTTR
-        where TTTR.RESULT_TIME_TYPE = 3  AND   TTTR.RESULT_VALUE IS NOT NULL
+    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">
+    <if test="userId!=null">
-      AND oo.INSERT_USERNAME LIKE #{orgCode}
+      AND oo.INSERT_USERNAME LIKE #{userId}
     </if>
     <where>
       <if test="orderNumber != null">

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

@@ -353,31 +353,42 @@
                       RCT.CAPACITY_TYPE_NAME       "capacityTypeName",
                       RS.SHIPPER_NAME              "shipperName",
                       AIR.REQUIREMENT_WORK_CONTENT "requirmentWorkContent",
-                      AIR.INSERT_TIME           "insertTime"
+                      AIR.INSERT_TIME           "insertTime",
-               FROM AMSTRUCK_INWARD_REQUIREMENT AIR
+                      (
-                        LEFT JOIN OMSTRUCK_ORDER OO
+                          select TWR.RESULT_NET_WEIGHT
-                                  ON OO.ORDER_PLAN_ID = AIR.PURCHASE_ORDER_ID
+                          from  TMSTRUCK_WEIGHT_RESULT TWR
-                        LEFT JOIN OMSTRUCK_ORDER_MATERIAL OOM
+                          where TWR.RESULT_TOTAL_ID=TWR2.RESULT_TOTAL_ID
-                                  ON OO.ORDER_ID = OOM.ORDER_ID
+                          and   TWR.RESULT_NET_WEIGHT is not null
-                        LEFT JOIN RMS_MATERIAL RM
+                      )
-                                  ON RM.MATERIAL_ID = OOM.MATERIAL_ID
+                    "netweight"
-                        LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
+                   FROM AMSTRUCK_INWARD_PLAN AIP
-                                  ON TTR.ORDER_ID = OO.ORDER_ID
+                   LEFT JOIN OMSTRUCK_ORDER OO
-                        LEFT JOIN TMSTRUCK_UNLOAD_RESULT TUR
+                   ON OO.ORDER_PLAN_ID = AIP.PLAN_ID
-                                  ON TTR.RESULT_TOTAL_ID = TUR.RESULT_TOTAL_ID
+                   LEFT JOIN AMSTRUCK_REQUIREMENT_PLAN ARP
-                        LEFT JOIN TMSTRUCK_LOAD_RESULT TLR
+                   ON ARP.PLAN_ID=AIP.PLAN_ID
-                                  ON TLR.RESULT_TOTAL_ID = TTR.RESULT_TOTAL_ID
+                   LEFT JOIN AMSTRUCK_INWARD_REQUIREMENT AIR
-                        LEFT JOIN RMS_WAREHOUSE RW1
+                   ON AIR.REQUIREMENT_ID=ARP.REQUIREMENT_ID
-                                  ON TLR.LOADING_ID = RW1.WAREHOUSE_ID
+                   LEFT JOIN OMSTRUCK_ORDER_MATERIAL OOM
-                        LEFT JOIN RMS_WAREHOUSE RW2
+                   ON OO.ORDER_ID = OOM.ORDER_ID
-                                  ON RW2.WAREHOUSE_ID = TUR.RESULT_UNLOAD_PLACE_ID
+                   LEFT JOIN AMSTRUCK_REQUIREMENT_MATERIAL ARM
-                        LEFT JOIN RMS_CAPACITY RC
+                   ON ARM.REQUIREMENT_ID=AIR.REQUIREMENT_ID
-                                  ON OO.CAPACITY_ID = RC.CAPACITY_ID
+                   LEFT JOIN RMS_MATERIAL RM
-                        LEFT JOIN RMS_CAPACITY_TYPE RCT
+                   ON RM.MATERIAL_ID = OOM.MATERIAL_ID
-                                  ON RCT.CAPACITY_TYPE_ID = RC.CAPACITY_TYPE_ID
+                   LEFT JOIN TMSTRUCK_TOTAL_RESULT TTR
-                        LEFT JOIN RMS_SHIPPER RS
+                   ON TTR.ORDER_ID = OO.ORDER_ID
-                                  ON AIR.REQUIREMENT_SHIPPER_ID = RS.SHIPPER_ID
+                   LEFT JOIN TMSTRUCK_WEIGHT_RESULT TWR2
-               WHERE AIR.REQUIREMENT_TYPE = '计次'
+                   ON TTR.RESULT_TOTAL_ID = TWR2.RESULT_TOTAL_ID
+                   LEFT JOIN RMS_WAREHOUSE RW1
+                   ON ARM.REQUIREMENT_PLATFORM_ID = RW1.WAREHOUSE_ID
+                   LEFT JOIN RMS_WAREHOUSE RW2
+                   ON ARM.REQUIREMENT_UNLOAD_UNIT_ID = RW2.WAREHOUSE_ID
+                   LEFT JOIN RMS_CAPACITY RC
+                   ON OO.CAPACITY_ID = RC.CAPACITY_ID
+                   LEFT JOIN RMS_CAPACITY_TYPE RCT
+                   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 = 2
            )
     <where>
         <if test="materialName != null">

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

@@ -287,7 +287,7 @@
         order by "insertTime" desc
      </if>
     </select>
-<!-- 根据运输订单id查找两次计时作业id-->
+<!-- 根据运输订单id查找计时结束时间-->
     <select id="FristTimeTask" resultType="java.util.Map" parameterType="java.util.Map">
         select   TTTR.RESULT_TIME "resultTime",
                  TTTR.TIME_TASK_RESULT_ID "timeResultId"
@@ -305,7 +305,7 @@
         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
+        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">
@@ -315,4 +315,41 @@
         ON OO.ORDER_ID=TTR.ORDER_ID
        WHERE  OO.ORDER_ID=#{orderId}
     </select>
+    <select id="getInwardType" resultType="java.math.BigDecimal" parameterType="java.math.BigDecimal">
+        select TTTR.RESULT_TIME_TYPE "resultType"
+        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>
+    <select id="TimeTaskPause" resultType="java.util.Map" parameterType="java.util.Map">
+        select sum(TTTR.RESULT_VALUE) "resultPauseTime"
+        from OMSTRUCK_ORDER OO
+        left join TMSTRUCK_TOTAL_RESULT TTR
+        ON TTR.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= #{type}
+    </select>
+    <select id="getInwardStartTime" resultType="java.math.BigDecimal" parameterType="java.math.BigDecimal">
+        select COUNT(TTTR.TIME_TASK_RESULT_ID)
+        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  = 5
+    </select>
+
+    <select id="getInwardEndTime" resultType="java.math.BigDecimal" parameterType="java.math.BigDecimal">
+        select COUNT(TTTR.TIME_TASK_RESULT_ID)
+        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  = 7
+    </select>
 </mapper>