0.0.2.0

排名和调度面板添加时间条件和组条件搜索

frontend/src/components/Charts/Line.vue

@@ -7,6 +7,7 @@
 <script>
 import * as G2 from '@antv/g2'
 import { getLineDispatchQuantity } from '@/api/manage'
+
 const DataSet = require('@antv/data-set')
 
 export default {
@@ -22,8 +23,13 @@ export default {
     this.createView()
   },
   methods: {
-    getLineDispatchQuantity () {
+    getLineDispatchQuantity (groupName, type = 'day', startTime, endTime) {
-      getLineDispatchQuantity().then(res => {
+      getLineDispatchQuantity({
+        'groupName': groupName,
+        'type': type,
+        'startTime': startTime,
+        'endTime': endTime
+      }).then(res => {
         this.viewCharts(res.data)
       })
     },
@@ -36,7 +42,7 @@ export default {
         fields: ['success', 'fail'], // 展开字段集
         key: 'name',
         value: 'viewTotal',
-        retains: [ 'total', 'createDt' ]
+        retains: ['total', 'createDt']
       })
 
       console.log(dv.rows)

frontend/src/views/dashboard/Analysis.vue

@@ -51,13 +51,13 @@
         <a-tabs default-active-key="1" size="large" :tab-bar-style="{marginBottom: '24px', paddingLeft: '16px'}">
           <div class="extra-wrapper" slot="tabBarExtraContent">
             <div class="extra-item">
-              <a>{{ $t('dashboard.analysis.all-day') }}</a>
+              <a href="#" @click="dataHandler('day')">{{ $t('dashboard.analysis.all-day') }}</a>
-              <a>{{ $t('dashboard.analysis.all-week') }}</a>
+              <a href="#" @click="dataHandler('week')">{{ $t('dashboard.analysis.all-week') }}</a>
-              <a>{{ $t('dashboard.analysis.all-month') }}</a>
+              <a href="#" @click="dataHandler('month')">{{ $t('dashboard.analysis.all-month') }}</a>
-              <a>{{ $t('dashboard.analysis.all-year') }}</a>
+              <a href="#" @click="dataHandler('year')">{{ $t('dashboard.analysis.all-year') }}</a>
             </div>
             <div class="extra-item">
-              <a-range-picker :style="{width: '256px'}" />
+              <a-range-picker :style="{width: '256px'}" @change="dateChange" />
             </div>
             <a-select placeholder="请输入组名称" @change="value => handleChange(value)" :style="{width: '256px'}">
               <a-select-option v-for="item in groupNameList" :value="item" :key="item">{{ item }}</a-select-option>
@@ -66,10 +66,10 @@
           <a-tab-pane loading="true" :tab="$t('dashboard.analysis.sales')" key="1">
             <a-row>
               <a-col :xl="16" :lg="12" :md="12" :sm="24" :xs="24">
-                <g2-line/>
+                <g2-line ref="viewChart" />
               </a-col>
               <a-col :xl="8" :lg="12" :md="12" :sm="24" :xs="24">
-                <rank-list :title="$t('dashboard.analysis.sales-ranking')" :list="rankList"/>
+                <rank-list :title="$t('dashboard.analysis.sales-ranking')" :list="rankList" />
               </a-col>
             </a-row>
           </a-tab-pane>
@@ -80,7 +80,6 @@
 </template>
 
 <script>
-// import moment from 'moment'
 import {
   ChartCard,
   MiniArea,
@@ -132,12 +131,40 @@ export default {
       pieStyle: {
         stroke: '#fff',
         lineWidth: 1
-      }
+      },
+      value: ''
     }
   },
-  computed: {
+  computed: {},
-  },
   methods: {
+    dataHandler (type) {
+      this.$refs.viewChart.getLineDispatchQuantity(this.value, type)
+      this.getRankSceneQuantity(this.value, type)
+    },
+    handleChange (value) {
+      this.value = value
+      this.$refs.viewChart.getLineDispatchQuantity(value)
+      this.getRankSceneQuantity(this.value)
+    },
+    dateChange (date, dateString) {
+      this.$refs.viewChart.getLineDispatchQuantity('others', new Date(dateString[0]).getTime(), new Date(dateString[1]).getTime())
+      this.getRankSceneQuantity(this.value, new Date(dateString[0]).getTime(), new Date(dateString[1]).getTime())
+    },
+    getRankSceneQuantity (groupName, type = 'day', startTime, endTime) {
+      rankSceneQuantity({
+        'groupName': groupName,
+        'type': type,
+        'startTime': startTime,
+        'endTime': endTime
+      }).then(res => {
+        res.data.forEach(res => {
+          this.rankList.push({
+            name: res.groupName + '/' + res.sceneName,
+            total: res.total
+          })
+        })
+      })
+    }
   },
   created () {
     getAllGroupNameList().then(res => {
@@ -156,15 +183,6 @@ export default {
       this.countActivePodQuantity = res.data
     })
 
-    rankSceneQuantity().then(res => {
-      res.data.forEach(res => {
-        this.rankList.push({
-          name: res.groupName + '/' + res.sceneName,
-          total: res.total
-        })
-      })
-    })
-
     setTimeout(() => {
       this.loading = !this.loading
     }, 1000)
@@ -172,8 +190,8 @@ export default {
 }
 </script>
 
-<style lang="less" scoped>
+<style lang='less' scoped>
-  .extra-wrapper {
+.extra-wrapper {
   line-height: 55px;
   padding-right: 24px;
 
@@ -185,34 +203,36 @@ export default {
       margin-left: 24px;
     }
   }
-  }
+}
 
-  .antd-pro-pages-dashboard-analysis-twoColLayout {
+.antd-pro-pages-dashboard-analysis-twoColLayout {
   position: relative;
   display: flex;
   display: block;
   flex-flow: row wrap;
-  }
+}
 
-  .antd-pro-pages-dashboard-analysis-salesCard {
+.antd-pro-pages-dashboard-analysis-salesCard {
   height: calc(100% - 24px);
+
   /deep/ .ant-card-head {
     position: relative;
   }
-  }
+}
 
-  .dashboard-analysis-iconGroup {
+.dashboard-analysis-iconGroup {
   i {
     margin-left: 16px;
-      color: rgba(0,0,0,.45);
+    color: rgba(0, 0, 0, .45);
     cursor: pointer;
     transition: color .32s;
     color: black;
   }
-  }
+}
-  .analysis-salesTypeRadio {
+
+.analysis-salesTypeRadio {
   position: absolute;
   right: 54px;
   bottom: 12px;
-  }
+}
 </style>

x-retry-server/src/main/java/com/x/retry/server/persistence/mybatis/mapper/RetryTaskLogMapper.java

@@ -7,6 +7,7 @@ import com.x.retry.server.web.model.response.DispatchQuantityResponseVO;
 import com.x.retry.server.web.model.response.SceneQuantityRankResponseVO;
 import org.apache.ibatis.annotations.Param;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 public interface RetryTaskLogMapper extends BaseMapper<RetryTaskLog> {
@@ -19,9 +20,16 @@ public interface RetryTaskLogMapper extends BaseMapper<RetryTaskLog> {
 
     long countTaskByRetryStatus(@Param("retryStatus") Integer retryStatus);
 
-    List<SceneQuantityRankResponseVO> rankSceneQuantity(@Param("groupName") String groupName);
+    List<SceneQuantityRankResponseVO> rankSceneQuantity(@Param("groupName") String groupName,
+                                                        @Param("startTime")LocalDateTime startTime,
+                                                        @Param("endTime")LocalDateTime endTime
+                                                        );
 
     List<DispatchQuantityResponseVO> lineDispatchQuantity(@Param("groupName") String groupName,
-                                                          @Param("retryStatus") Integer retryStatus);
+                                                          @Param("retryStatus") Integer retryStatus,
+                                                          @Param("type") String type,
+                                                          @Param("startTime")LocalDateTime startTime,
+                                                          @Param("endTime")LocalDateTime endTime
+    );
 
 }

x-retry-server/src/main/java/com/x/retry/server/service/DashBoardService.java

@@ -19,8 +19,8 @@ public interface DashBoardService {
 
     ActivePodQuantityResponseVO countActivePod();
 
-    List<SceneQuantityRankResponseVO> rankSceneQuantity(String groupName);
+    List<SceneQuantityRankResponseVO> rankSceneQuantity(String groupName, String type, String startTime, String endTime);
 
-    List<DispatchQuantityResponseVO> lineDispatchQuantity(String groupName);
+    List<DispatchQuantityResponseVO> lineDispatchQuantity(String groupName, String type, String startTime, String endTime);
 
 }

x-retry-server/src/main/java/com/x/retry/server/service/impl/DashBoardServiceImpl.java

@@ -8,15 +8,20 @@ import com.x.retry.server.persistence.mybatis.mapper.ServerNodeMapper;
 import com.x.retry.server.persistence.mybatis.po.RetryTaskLog;
 import com.x.retry.server.persistence.mybatis.po.ServerNode;
 import com.x.retry.server.service.DashBoardService;
+import com.x.retry.server.web.model.enums.DateTypeEnum;
 import com.x.retry.server.web.model.response.ActivePodQuantityResponseVO;
 import com.x.retry.server.web.model.response.DispatchQuantityResponseVO;
 import com.x.retry.server.web.model.response.SceneQuantityRankResponseVO;
 import com.x.retry.server.web.model.response.TaskQuantityResponseVO;
+import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -79,20 +84,49 @@ public class DashBoardServiceImpl implements DashBoardService {
     }
 
     @Override
-    public List<SceneQuantityRankResponseVO> rankSceneQuantity(String groupName) {
+    public List<SceneQuantityRankResponseVO> rankSceneQuantity(String groupName, String type, String startTime, String endTime) {
-        return retryTaskLogMapper.rankSceneQuantity(groupName);
+        LocalDateTime startDateTime = LocalDateTime.now();
+        if (StringUtils.isNotBlank(startTime)) {
+            startDateTime = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        }
+
+        LocalDateTime endDateTime = LocalDateTime.now();
+        if (StringUtils.isNotBlank(endTime)) {
+            endDateTime = LocalDateTime.parse(endTime, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        }
+
+        DateTypeEnum dateTypeEnum = DateTypeEnum.valueOf(type.toUpperCase());
+        startDateTime = dateTypeEnum.getStartTime().apply(startDateTime);
+        endDateTime = dateTypeEnum.getEndTime().apply(endDateTime);
+
+        return retryTaskLogMapper.rankSceneQuantity(groupName, startDateTime, endDateTime);
     }
 
     @Override
-    public List<DispatchQuantityResponseVO> lineDispatchQuantity(String groupName) {
+    public List<DispatchQuantityResponseVO> lineDispatchQuantity(String groupName, String type, String startTime, String endTime) {
 
-        List<DispatchQuantityResponseVO> totalDispatchQuantityResponseList = retryTaskLogMapper.lineDispatchQuantity(groupName, null);
+        DateTypeEnum dateTypeEnum = DateTypeEnum.valueOf(type.toUpperCase());
 
-        List<DispatchQuantityResponseVO> successDispatchQuantityResponseList = retryTaskLogMapper.lineDispatchQuantity(groupName, RetryStatusEnum.FINISH.getLevel());
+        LocalDateTime startDateTime = LocalDateTime.now();
-        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = successDispatchQuantityResponseList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        if (StringUtils.isNotBlank(startTime)) {
+            startDateTime = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        }
+
+        LocalDateTime endDateTime = LocalDateTime.now();
+        if (StringUtils.isNotBlank(endTime)) {
+            endDateTime = LocalDateTime.parse(endTime, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        }
+
+        startDateTime = dateTypeEnum.getStartTime().apply(startDateTime);
+        endDateTime = dateTypeEnum.getEndTime().apply(endDateTime);
+
+        List<DispatchQuantityResponseVO> totalDispatchQuantityResponseList = retryTaskLogMapper.lineDispatchQuantity(groupName, null, type, startDateTime, endDateTime);
+
+        List<DispatchQuantityResponseVO> successDispatchQuantityResponseList = retryTaskLogMapper.lineDispatchQuantity(groupName, RetryStatusEnum.FINISH.getLevel(), type, startDateTime, endDateTime);
+        Map<String, DispatchQuantityResponseVO> successDispatchQuantityResponseVOMap = successDispatchQuantityResponseList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
         for (DispatchQuantityResponseVO dispatchQuantityResponseVO : totalDispatchQuantityResponseList) {
 
-            DispatchQuantityResponseVO quantityResponseVO = dispatchQuantityResponseVOMap.get(dispatchQuantityResponseVO.getCreateDt());
+            DispatchQuantityResponseVO quantityResponseVO = successDispatchQuantityResponseVOMap.get(dispatchQuantityResponseVO.getCreateDt());
             if (Objects.isNull(dispatchQuantityResponseVO)) {
                 dispatchQuantityResponseVO.setSuccess(0L);
             } else {
@@ -103,6 +137,9 @@ public class DashBoardServiceImpl implements DashBoardService {
 
         }
 
-        return totalDispatchQuantityResponseList;
+        dateTypeEnum.getConsumer().accept(totalDispatchQuantityResponseList);
+
+        return totalDispatchQuantityResponseList.stream().sorted(Comparator.comparing(DispatchQuantityResponseVO::getCreateDt)).collect(Collectors.toList());
     }
+
 }

x-retry-server/src/main/java/com/x/retry/server/web/controller/DashBoardController.java

@@ -46,14 +46,21 @@ public class DashBoardController {
     @LoginRequired
     @GetMapping("/scene/rank")
     public List<SceneQuantityRankResponseVO> rankSceneQuantity(@RequestParam(value = "groupName", required = false)
-                                                      String groupName) {
+                                                                       String groupName,
-        return dashBoardService.rankSceneQuantity(groupName);
+                                                               @RequestParam(value = "type") String type,
+                                                               @RequestParam(value = "startTime", required = false) String startTime,
+                                                               @RequestParam(value = "endTime", required = false) String endTime) {
+        return dashBoardService.rankSceneQuantity(groupName, type, startTime, endTime);
     }
 
-    @LoginRequired
+    //    @LoginRequired
     @GetMapping("/dispatch/line")
     public List<DispatchQuantityResponseVO> lineDispatchQuantity(@RequestParam(value = "groupName", required = false)
-                                                                       String groupName) {
+                                                                         String groupName,
-        return dashBoardService.lineDispatchQuantity(groupName);
+                                                                 @RequestParam(value = "type") String type,
+                                                                 @RequestParam(value = "startTime", required = false) String startTime,
+                                                                 @RequestParam(value = "endTime", required = false) String endTime
+    ) {
+        return dashBoardService.lineDispatchQuantity(groupName, type, startTime, endTime);
     }
 }

x-retry-server/src/main/java/com/x/retry/server/web/model/enums/DateTypeEnum.java

@@ -0,0 +1,171 @@
+package com.x.retry.server.web.model.enums;
+
+import com.x.retry.server.web.model.response.DispatchQuantityResponseVO;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAdjusters;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * @author: byteblogs
+ * @date: 2020/1/19 20:36
+ */
+public enum DateTypeEnum {
+    /**
+     * 天
+     */
+    DAY(dispatchQuantityResponseVOList -> {
+        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = dispatchQuantityResponseVOList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        for (int i = 0; i < 24; i++) {
+
+            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("HH");
+            String format = LocalDateTime.of(LocalDate.now(), LocalTime.MIN).plusHours(i).format(dateTimeFormatter);
+            DispatchQuantityResponseVO dispatchQuantityResponseVO = dispatchQuantityResponseVOMap.get(format);
+            if (Objects.isNull(dispatchQuantityResponseVO)) {
+                dispatchQuantityResponseVO = new DispatchQuantityResponseVO();
+                dispatchQuantityResponseVO.setFail(0L);
+                dispatchQuantityResponseVO.setSuccess(0L);
+                dispatchQuantityResponseVO.setCreateDt(format);
+                dispatchQuantityResponseVOList.add(dispatchQuantityResponseVO);
+            }
+        }
+    }, (startTime) -> {
+        return LocalDateTime.of(startTime.toLocalDate(), LocalTime.MIN);
+    }, (endTime) -> {
+        return LocalDateTime.of(endTime.toLocalDate(), LocalTime.MAX);
+    }),
+    /**
+     * 星期
+     */
+    WEEK(dispatchQuantityResponseVOList -> {
+        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = dispatchQuantityResponseVOList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        for (int i = 0; i < 7; i++) {
+
+            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+            String format = LocalDateTime.of(LocalDate.now().with(DayOfWeek.of(1)), LocalTime.MIN).plusDays(i).format(dateTimeFormatter);
+            DispatchQuantityResponseVO dispatchQuantityResponseVO = dispatchQuantityResponseVOMap.get(format);
+            if (Objects.isNull(dispatchQuantityResponseVO)) {
+                dispatchQuantityResponseVO = new DispatchQuantityResponseVO();
+                dispatchQuantityResponseVO.setFail(0L);
+                dispatchQuantityResponseVO.setSuccess(0L);
+                dispatchQuantityResponseVO.setCreateDt(format);
+                dispatchQuantityResponseVOList.add(dispatchQuantityResponseVO);
+            }
+        }
+    }, (startTime) -> {
+        return LocalDateTime.of(startTime.toLocalDate().with(DayOfWeek.of(1)), LocalTime.MIN);
+    }, (endTime) -> {
+        return LocalDateTime.of(endTime.toLocalDate().with(DayOfWeek.of(7)), LocalTime.MAX);
+    }),
+
+    /**
+     * 月
+     */
+    MONTH(dispatchQuantityResponseVOList -> {
+        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = dispatchQuantityResponseVOList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        int curMonth = LocalDateTime.now().with(TemporalAdjusters.lastDayOfMonth()).getDayOfMonth();
+        for (int i = 0; i < curMonth; i++) {
+
+            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+            String format = LocalDateTime.of(LocalDate.now().with(TemporalAdjusters.firstDayOfMonth()), LocalTime.MIN).plusDays(i).format(dateTimeFormatter);
+            DispatchQuantityResponseVO dispatchQuantityResponseVO = dispatchQuantityResponseVOMap.get(format);
+            if (Objects.isNull(dispatchQuantityResponseVO)) {
+                dispatchQuantityResponseVO = new DispatchQuantityResponseVO();
+                dispatchQuantityResponseVO.setFail(0L);
+                dispatchQuantityResponseVO.setSuccess(0L);
+                dispatchQuantityResponseVO.setCreateDt(format);
+                dispatchQuantityResponseVOList.add(dispatchQuantityResponseVO);
+            }
+        }
+    }, (startTime) -> {
+        return LocalDateTime.of(startTime.toLocalDate().with(TemporalAdjusters.firstDayOfMonth()), LocalTime.MIN);
+    }, (endTime) -> {
+        return LocalDateTime.of(endTime.toLocalDate().with(TemporalAdjusters.lastDayOfMonth()), LocalTime.MAX);
+    }),
+
+    /**
+     * 年
+     */
+    YEAR(dispatchQuantityResponseVOList -> {
+        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = dispatchQuantityResponseVOList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        for (int i = 0; i < 12; i++) {
+
+            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM");
+            String format = LocalDateTime.of(LocalDate.now().with(TemporalAdjusters.firstDayOfYear()), LocalTime.MIN).plusMonths(i).format(dateTimeFormatter);
+            DispatchQuantityResponseVO dispatchQuantityResponseVO = dispatchQuantityResponseVOMap.get(format);
+            if (Objects.isNull(dispatchQuantityResponseVO)) {
+                dispatchQuantityResponseVO = new DispatchQuantityResponseVO();
+                dispatchQuantityResponseVO.setFail(0L);
+                dispatchQuantityResponseVO.setSuccess(0L);
+                dispatchQuantityResponseVO.setCreateDt(format);
+                dispatchQuantityResponseVOList.add(dispatchQuantityResponseVO);
+            }
+        }
+    }, (startTime) -> {
+        return LocalDateTime.of(startTime.toLocalDate().with(TemporalAdjusters.firstDayOfYear()), LocalTime.MIN);
+    }, (endTime) -> {
+        return LocalDateTime.of(endTime.toLocalDate().with(TemporalAdjusters.lastDayOfYear()), LocalTime.MAX);
+    }),
+
+    /**
+     * 其他类型
+     */
+    OTHERS(dispatchQuantityResponseVOList -> {
+        Map<String, DispatchQuantityResponseVO> dispatchQuantityResponseVOMap = dispatchQuantityResponseVOList.stream().collect(Collectors.toMap(DispatchQuantityResponseVO::getCreateDt, i -> i));
+        for (int i = 0; i < 24; i++) {
+
+            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd 00:00:00");
+            String format = LocalDateTime.of(LocalDate.now(), LocalTime.MIN).plusHours(i).format(dateTimeFormatter);
+            DispatchQuantityResponseVO dispatchQuantityResponseVO = dispatchQuantityResponseVOMap.get(format);
+            if (Objects.isNull(dispatchQuantityResponseVO)) {
+                dispatchQuantityResponseVO = new DispatchQuantityResponseVO();
+                dispatchQuantityResponseVO.setFail(0L);
+                dispatchQuantityResponseVO.setSuccess(0L);
+                dispatchQuantityResponseVO.setCreateDt(format);
+                dispatchQuantityResponseVOList.add(dispatchQuantityResponseVO);
+            }
+        }
+    }, (startTime) -> {
+        if (Objects.isNull(startTime)) {
+            return LocalDateTime.now();
+        }
+        return startTime;
+    }, (endTime) -> {
+        if (Objects.isNull(endTime)) {
+            return LocalDateTime.now();
+        }
+        return endTime;
+    });
+
+    private Consumer<List<DispatchQuantityResponseVO>> consumer;
+    private Function<LocalDateTime, LocalDateTime> startTime;
+    private Function<LocalDateTime, LocalDateTime> endTime;
+
+    DateTypeEnum(Consumer<List<DispatchQuantityResponseVO>> listConsumer, Function<LocalDateTime, LocalDateTime> startTime, Function<LocalDateTime, LocalDateTime> endTime) {
+        this.consumer = listConsumer;
+        this.startTime = startTime;
+        this.endTime = endTime;
+
+    }
+
+    public Function<LocalDateTime, LocalDateTime> getStartTime() {
+        return startTime;
+    }
+
+    public Function<LocalDateTime, LocalDateTime> getEndTime() {
+        return endTime;
+    }
+
+    public Consumer<List<DispatchQuantityResponseVO>> getConsumer() {
+        return consumer;
+    }
+}

x-retry-server/src/main/resources/mapper/RetryTaskLogMapper.xml

@@ -45,28 +45,50 @@
         from (
         select group_name, scene_name, biz_id, count(*)
         from retry_task_log
-        group by group_name, scene_name, biz_id) a
         <where>
             <if test="groupName != '' and groupName != null">
                 group_name = #{groupName}
             </if>
+            and create_dt >= #{startTime} and create_dt &lt;= #{endTime}
         </where>
+        group by group_name, scene_name, biz_id) a
         group by group_name, scene_name
         order by total desc;
     </select>
     <select id="lineDispatchQuantity"
             resultType="com.x.retry.server.web.model.response.DispatchQuantityResponseVO">
-        select distinct(create_dt), count(*) total
+        select
+        distinct(create_dt), count(*) total
         from (
-                 select group_name, scene_name, biz_id, DATE_FORMAT(create_dt, '%Y-%m-%d') as create_dt, count(*)
+        select group_name, scene_name, biz_id,
+        <choose>
+            <when test="type == 'day'">
+                DATE_FORMAT(create_dt,'%H')
+            </when>
+            <when test="type == 'week'">
+                DATE_FORMAT(create_dt,'%Y-%m-%d')
+            </when>
+            <when test="type =='month'">
+                DATE_FORMAT(create_dt,'%Y-%m-%d')
+            </when>
+            <when test="type == 'year'">
+                DATE_FORMAT(create_dt,'%Y-%m')
+            </when>
+            <otherwise>
+                DATE_FORMAT(create_dt,'%Y-%m-%d')
+            </otherwise>
+        </choose>
+        as create_dt, count(*)
         from retry_task_log
         <where>
             <if test="groupName != '' and groupName != null">
                 group_name = #{groupName}
             </if>
             <if test="retryStatus!=null ">
-                         retry_status = #{retryStatus}
+               and retry_status = #{retryStatus}
             </if>
+
+            and create_dt >= #{startTime} and create_dt &lt;= #{endTime}
         </where>
         group by group_name, scene_name, biz_id, create_dt) a
         group by create_dt