dashbord: 添加新的查询接口

backgroud-gateway/src/main/resources/application.yml

@@ -2,11 +2,11 @@ server:
   port: ${SERVER_PORT:8088}
 spring:
   application:
-    name: backgroud-gateway
+    name: background-gateway
   cloud:
     nacos:
       discovery:
-        server-addr: ${NACOS_ADDR:localhost:8848}
+        server-addr: ${NACOS_ADDR:106.55.99.175:8845}
         ip: ${NACOS_IP:127.0.0.1}
         username: ${NACOS_USERNAME:nacos}
         password: ${NACOS_PASSWORD:Nacos@123!}
@@ -26,16 +26,16 @@ spring:
         locator:
           enabled: true
       routes:
-        - id: gateway
+        - id: gateway-user
           uri: lb://background-user
           order: 1
           predicates:
             - Path=/user-api/**
-        - id: test
-          uri: https://www.baidu.com/
-          order: 1
-          predicates:
-            - Path=/test-api/**
+#        - id: test
+#          uri: https://www.baidu.com/
+#          order: 1
+#          predicates:
+#            - Path=/test-api/**
 #  redis:
 #    host: ${REDIS_HOST:47.93.102.223}
 #    port: ${REDIS_PORT:16379}

background-common/src/main/java/cn/kdan/compdf/config/JwtConfig.java

@@ -26,7 +26,7 @@ public class JwtConfig {
 
         // 加密
         byte[] keyBytes = AuthEnum.secret.getBytes();
-        // 获得密钥对象
+        // 获得密钥对象9
         SecretKey key = Keys.hmacShaKeyFor(keyBytes);
 
         String token = Jwts.builder()

background-mybatis/src/main/java/cn/kdan/compdf/config/MybatisPlusMetaObjectHandler.java

@@ -20,14 +20,14 @@ public class MybatisPlusMetaObjectHandler implements MetaObjectHandler {
         LocalDateTime now = LocalDateTime.now();
 //        metaObject.setValue("createdBy", username);
 //        metaObject.setValue("updatedBy", username);
-        metaObject.setValue("creationTime", now);
-        metaObject.setValue("updateTime", now);
+        metaObject.setValue("createDate", now);
+        metaObject.setValue("updateDate", now);
     }
 
     @Override
     public void updateFill(MetaObject metaObject) {
 //        metaObject.setValue("updatedBy", getUsername());
-        metaObject.setValue("updateTime", LocalDateTime.now());
+        metaObject.setValue("updateDate", LocalDateTime.now());
     }
 
 }

background-redis/src/main/java/cn/kdan/compdf/config/CustomizedRedisCache.java

@@ -0,0 +1,55 @@
+package cn.kdan.compdf.config;
+
+import org.springframework.core.convert.ConversionService;
+import org.springframework.data.redis.cache.RedisCache;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+
+/**
+ * @author ComPDFKit-WPH 2022/10/20
+ */
+public class CustomizedRedisCache extends RedisCache {
+    private static final String WILD_CARD = "*";
+    private final String name;
+    private final RedisCacheWriter cacheWriter;
+    private final ConversionService conversionService;
+
+    protected CustomizedRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
+        super(name, cacheWriter, cacheConfig);
+        this.name = name;
+        this.cacheWriter = cacheWriter;
+        this.conversionService = cacheConfig.getConversionService();
+    }
+
+    @Override
+    public void evict(Object key) {
+        if (key instanceof String) {
+            String keyString = key.toString();
+            if (keyString.endsWith(WILD_CARD)) {
+                evictLikeSuffix(keyString);
+                return;
+            }
+            if (keyString.startsWith(WILD_CARD)) {
+                evictLikePrefix(keyString);
+                return;
+            }
+        }
+        super.evict(key);
+    }
+
+    /**
+     * 前缀匹配 * * @param key
+     */
+    public void evictLikePrefix(String key) {
+        byte[] pattern = this.conversionService.convert(this.createCacheKey(key), byte[].class);
+        this.cacheWriter.clean(this.name, pattern);
+    }
+
+    /**
+     * 后缀匹配 * * @param key
+     */
+    public void evictLikeSuffix(String key) {
+        byte[] pattern = this.conversionService.convert(this.createCacheKey(key), byte[].class);
+        this.cacheWriter.clean(this.name, pattern);
+    }
+}

background-redis/src/main/java/cn/kdan/compdf/config/CustomizedRedisCacheManager.java

@@ -0,0 +1,78 @@
+package cn.kdan.compdf.config;
+
+import org.springframework.data.redis.cache.RedisCache;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * @author ComPDFKit-WPH 2022/10/20
+ */
+public class CustomizedRedisCacheManager extends RedisCacheManager {
+    private final RedisCacheWriter cacheWriter;
+    private final RedisCacheConfiguration defaultCacheConfig;
+    private final Map<String, RedisCacheConfiguration> initialCaches = new LinkedHashMap<>();
+    private boolean enableTransactions;
+
+    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
+        super(cacheWriter, defaultCacheConfiguration);
+        this.cacheWriter = cacheWriter;
+        this.defaultCacheConfig = defaultCacheConfiguration;
+    }
+
+    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, String... initialCacheNames) {
+        super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
+        this.cacheWriter = cacheWriter;
+        this.defaultCacheConfig = defaultCacheConfiguration;
+    }
+
+    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, String... initialCacheNames) {
+        super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
+        this.cacheWriter = cacheWriter;
+        this.defaultCacheConfig = defaultCacheConfiguration;
+    }
+
+    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
+        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
+        this.cacheWriter = cacheWriter;
+        this.defaultCacheConfig = defaultCacheConfiguration;
+    }
+
+    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) {
+        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
+        this.cacheWriter = cacheWriter;
+        this.defaultCacheConfig = defaultCacheConfiguration;
+    }
+
+    /**
+     * 这个构造方法最重要
+     **/
+    public CustomizedRedisCacheManager(RedisConnectionFactory redisConnectionFactory, RedisCacheConfiguration cacheConfiguration) {
+        this(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), cacheConfiguration);
+    }
+
+    /**
+     * 覆盖父类创建RedisCache
+     */
+    @Override
+    protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
+        return new CustomizedRedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
+    }
+
+    @Override
+    public Map<String, RedisCacheConfiguration> getCacheConfigurations() {
+        Map<String, RedisCacheConfiguration> configurationMap = new HashMap<>(getCacheNames().size());
+        getCacheNames().forEach(it -> {
+            RedisCache cache = CustomizedRedisCache.class.cast(lookupCache(it));
+            configurationMap.put(it, cache != null ? cache.getCacheConfiguration() : null);
+        });
+        return Collections.unmodifiableMap(configurationMap);
+    }
+}

background-redis/src/main/java/cn/kdan/compdf/config/RedisConfig.java

@@ -1,11 +1,21 @@
 package cn.kdan.compdf.config;
 
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.CacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.*;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
 
 /**
  * @author ZhouQiang 2022/7/4
@@ -63,4 +73,19 @@ public class RedisConfig {
         stringRedisTemplate.setConnectionFactory(factory);
         return stringRedisTemplate;
     }
+
+
+    @Bean
+    public CacheManager oneDayCacheManager(RedisConnectionFactory factory) {
+        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
+        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); //解决查询缓存转换异常的问题
+        ObjectMapper om = new ObjectMapper();
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jackson2JsonRedisSerializer.setObjectMapper(om);
+        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofDays(1))
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)).computePrefixWith(name -> name + ":").disableCachingNullValues();
+        return new CustomizedRedisCacheManager(factory, config);
+    }
 }

background-user/src/main/java/cn/kdan/compdf/config/RedisConstantServer.java

@@ -6,6 +6,15 @@ package cn.kdan.compdf.config;
 public class RedisConstantServer {
     private RedisConstantServer(){}
 
-    public static final String DASHBOARD_ANALYSIS_DATA = "dashboard:analysis:data";
+    public static final String DASHBOARD = "dashboard:";
 
+    public static final String DASHBOARD_ANALYSIS_DATA = DASHBOARD+ "analysis:data";
+
+    public static final String DASHBOARD_SUCCESS_DATA = DASHBOARD+"success:data";
+
+    public static final String DASHBOARD_FAIL_DATA = DASHBOARD+"fail:data";
+
+    public static final String DASHBOARD_ERROR_RATIO_DATA = DASHBOARD+"error:ratio:data";
+
+    public static final String DASHBOARD_AVERAGE_PROCESS_DATA = DASHBOARD+"average:processTime:ratio:data";
 }

background-user/src/main/java/cn/kdan/compdf/controller/v1/BackgroundConvertDataController.java

@@ -3,37 +3,79 @@ package cn.kdan.compdf.controller.v1;
 import cn.kdan.compdf.base.R;
 import cn.kdan.compdf.entity.BackgroundConvertData;
 import cn.kdan.compdf.entity.dto.AnalysisDataDTO;
+import cn.kdan.compdf.entity.dto.DashboardDetailedDataDTO;
 import cn.kdan.compdf.entity.dto.DashboardQueryDTO;
 import cn.kdan.compdf.enums.AuthEnum;
 import cn.kdan.compdf.service.BackgroundConvertDataService;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletRequest;
-import java.time.LocalDateTime;
-import java.time.temporal.ChronoUnit;
+import java.util.List;
 
 /**
  * @author comPDF-Kit WPH 2022-10-09
  */
 @RestController
 @RequestMapping("/v1/convert-data")
+@RequiredArgsConstructor
 public class BackgroundConvertDataController {
 
     private final BackgroundConvertDataService backgroundConvertDataService;
 
-    public BackgroundConvertDataController(BackgroundConvertDataService backgroundConvertDataService) {
-        this.backgroundConvertDataService = backgroundConvertDataService;
-    }
-
-
+    /**
+     * 获取统计信息
+     */
     @GetMapping("/getAnalysisData-byDay")
     public R<AnalysisDataDTO> getAnalysisData(DashboardQueryDTO dashboardQueryDTO, HttpServletRequest request){
-        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
+//        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
         AnalysisDataDTO analysisData = backgroundConvertDataService.getAnalysisData(dashboardQueryDTO);
         return R.ok(analysisData);
     }
 
+    /**
+     * 获取成功数时间节点数据集合
+     */
+    @GetMapping("/getSuccessfulRequestDetailedData")
+    public R<List<DashboardDetailedDataDTO>> getSuccessfulRequestDetailedData(DashboardQueryDTO dashboardQueryDTO, HttpServletRequest request){
+//        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
+        List<DashboardDetailedDataDTO> successfulRequestDetailedData = backgroundConvertDataService.getSuccessfulRequestDetailedData(dashboardQueryDTO);
+        return R.ok(successfulRequestDetailedData);
+    }
+    /**
+     * 获取失败数时间节点数据集合
+     */
+    @GetMapping("/getErrorRequestDetailedData")
+    public R<List<DashboardDetailedDataDTO>> getErrorRequestDetailedData(DashboardQueryDTO dashboardQueryDTO, HttpServletRequest request){
+//        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
+        List<DashboardDetailedDataDTO> errorRequestDetailedData = backgroundConvertDataService.getErrorRequestDetailedData(dashboardQueryDTO);
+        return R.ok(errorRequestDetailedData);
+    }
+    /**
+     * 获取失败率时间节点数据集合
+     */
+    @GetMapping("/getErrorRatioDetailedData")
+    public R<List<DashboardDetailedDataDTO>> getErrorRatioDetailedData(DashboardQueryDTO dashboardQueryDTO, HttpServletRequest request){
+//        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
+        List<DashboardDetailedDataDTO> errorRatioDetailedData = backgroundConvertDataService.getErrorRatioDetailedData(dashboardQueryDTO);
+        return R.ok(errorRatioDetailedData);
+    }
+    /**
+     * 获取转档时长时间节点数据集合
+     */
+    @GetMapping("/getAverageProcessTimeDetailedData")
+    public R<List<DashboardDetailedDataDTO>> getAverageProcessTimeDetailedData(DashboardQueryDTO dashboardQueryDTO, HttpServletRequest request){
+//        dashboardQueryDTO.setTenantId(new Long(request.getHeader(AuthEnum.USER_TENANT_ID_HEADER)));
+        List<DashboardDetailedDataDTO> averageProcessTimeDetailedData = backgroundConvertDataService.getAverageProcessTimeDetailedData(dashboardQueryDTO);
+        return R.ok(averageProcessTimeDetailedData);
+    }
+
+    @GetMapping("/test")
+    public void test(){
+        backgroundConvertDataService.test();
+    }
+
 
 
     /**

background-user/src/main/java/cn/kdan/compdf/entity/BackgroundConvertData.java

@@ -6,6 +6,8 @@ import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.math.BigDecimal;
 
@@ -57,5 +59,5 @@ public class BackgroundConvertData extends BaseEntity{
     /**
      * 同步时间段
      */
-    private Date syncTime;
+    private LocalDateTime syncTime;
 }

background-user/src/main/java/cn/kdan/compdf/entity/dto/DashboardDetailedDataDTO.java

@@ -1,8 +1,6 @@
 package cn.kdan.compdf.entity.dto;
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.ToString;
+import lombok.*;
 
 /**
  * @author ComPDFKit-WPH 2022/10/10
@@ -12,6 +10,9 @@ import lombok.ToString;
 @Data
 @ToString
 @EqualsAndHashCode
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
 public class DashboardDetailedDataDTO {
 
     /**

background-user/src/main/java/cn/kdan/compdf/service/BackgroundConvertDataService.java

@@ -57,4 +57,6 @@ public interface BackgroundConvertDataService extends IService<BackgroundConvert
      * @return 行列值集合A
      */
     List<DashboardDetailedDataDTO> getAverageProcessTimeDetailedData(DashboardQueryDTO queryDTO);
+
+    void test();
 }

background-user/src/main/java/cn/kdan/compdf/service/impl/BackgroundConvertDataServiceImpl.java

@@ -15,14 +15,18 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.Value;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
+import javax.cache.annotation.CacheRemove;
 import java.math.BigDecimal;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -38,13 +42,13 @@ public class BackgroundConvertDataServiceImpl extends ServiceImpl<BackgroundConv
     }
 
     @Override
-    @Cacheable(value = RedisConstantServer.DASHBOARD_ANALYSIS_DATA, key = "#queryDTO.tenantId", unless = "#result == null")
+    @Cacheable(value = RedisConstantServer.DASHBOARD_ANALYSIS_DATA,cacheManager = "oneDayCacheManager", key = "T(String).valueOf(#queryDTO.toString())", unless = "#result == null")
     public AnalysisDataDTO getAnalysisData(DashboardQueryDTO queryDTO) {
         // 获取一个查询query
         LambdaQueryWrapper<BackgroundConvertData> queryWrapper = getDashboardQueryWrapper(queryDTO);
 
         List<BackgroundConvertData> backgroundConvertData = this.baseMapper.selectList(queryWrapper);
-        if (backgroundConvertData == null){
+        if (backgroundConvertData == null || backgroundConvertData.size() <= 0) {
             return null;
         }
         long fileTotal = 0; // 文件总数
@@ -69,46 +73,317 @@ public class BackgroundConvertDataServiceImpl extends ServiceImpl<BackgroundConv
     }
 
     @Override
+    @Cacheable(value = RedisConstantServer.DASHBOARD_SUCCESS_DATA,cacheManager = "oneDayCacheManager", key = "T(String).valueOf(#queryDTO.toString())", unless = "#result == null")
     public List<DashboardDetailedDataDTO> getSuccessfulRequestDetailedData(DashboardQueryDTO queryDTO) {
         LambdaQueryWrapper<BackgroundConvertData> queryWrapper = getDashboardQueryWrapper(queryDTO);
         // 添加select 查询参数
-        queryWrapper.select(BackgroundConvertData::getFileSuccessTotal)
-                .select(BackgroundConvertData::getSyncTime);
+        queryWrapper.select(BackgroundConvertData::getFileSuccessTotal,BackgroundConvertData::getSyncTime);
         // 查询数据
         List<BackgroundConvertData> backgroundConvertData = this.baseMapper.selectList(queryWrapper);
         // 判断查询类型
-        switch (queryDTO.getQueryType()){
-            case 0: break;
-            case 1: break;
-            default: throw new CommonException(ResponseEnum.SYSTEM_ERROR);
-        }
-
+        LocalDateTime nowTime = LocalDateTime.now();
+        // 减去分钟数
+        nowTime = nowTime.minus(nowTime.getMinute(), ChronoUnit.MINUTES);
+        // 返回数据集合
+        List<DashboardDetailedDataDTO> dataDTOS = new ArrayList<>();
 
-
-        return null;
+        int successTotal = 0;
+        switch (queryDTO.getQueryType()) {
+            case 0:
+                if (queryDTO.getDays() == 1) {
+                    for (int i = 0; i < 24; i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                successTotal += backgroundConvertDatum.getFileSuccessTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(successTotal + "").build());
+                        successTotal = 0;
+                    }
+                } else {
+                    for (int i = 0; i < queryDTO.getDays(); i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                successTotal += backgroundConvertDatum.getFileSuccessTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(successTotal + "").build());
+                        successTotal = 0;
+                    }
+                }
+                break;
+            case 1:
+                LocalDateTime startDateTime = queryDTO.getStartDateTime();
+                LocalDateTime endDateTime = queryDTO.getEndDateTime();
+                Duration duration = Duration.between(startDateTime, endDateTime);
+                long days = duration.toDays(); //相差的天数
+                if (days == 0L) {
+                    for (int i = 0; i < nowTime.getHour(); i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                successTotal += backgroundConvertDatum.getFileSuccessTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(successTotal + "").build());
+                        successTotal = 0;
+                    }
+                } else {
+                    for (int i = 0; i < days; i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = endDateTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                successTotal += backgroundConvertDatum.getFileSuccessTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(successTotal + "").build());
+                        successTotal = 0;
+                    }
+                }
+                break;
+            default:
+                throw new CommonException(ResponseEnum.SYSTEM_ERROR);
+        }
+        return dataDTOS;
     }
 
     @Override
+    @Cacheable(value = RedisConstantServer.DASHBOARD_FAIL_DATA,cacheManager = "oneDayCacheManager", key = "T(String).valueOf(#queryDTO.toString())", unless = "#result == null")
     public List<DashboardDetailedDataDTO> getErrorRequestDetailedData(DashboardQueryDTO queryDTO) {
-        return null;
+        LambdaQueryWrapper<BackgroundConvertData> queryWrapper = getDashboardQueryWrapper(queryDTO);
+        // 添加select 查询参数
+        queryWrapper.select(BackgroundConvertData::getFileFailedTotal,BackgroundConvertData::getSyncTime);
+        // 查询数据
+        List<BackgroundConvertData> backgroundConvertData = this.baseMapper.selectList(queryWrapper);
+        // 判断查询类型
+        LocalDateTime nowTime = LocalDateTime.now();
+        // 减去分钟数
+        nowTime = nowTime.minus(nowTime.getMinute(), ChronoUnit.MINUTES);
+        // 返回数据集合
+        List<DashboardDetailedDataDTO> dataDTOS = new ArrayList<>();
+
+        int fileFailedTotal = 0;
+        switch (queryDTO.getQueryType()) {
+            case 0:
+                if (queryDTO.getDays() == 1) {
+                    for (int i = 0; i < 24; i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                fileFailedTotal += backgroundConvertDatum.getFileFailedTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(fileFailedTotal + "").build());
+                        fileFailedTotal = 0;
+                    }
+                } else {
+                    for (int i = 0; i < queryDTO.getDays(); i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                fileFailedTotal += backgroundConvertDatum.getFileFailedTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(fileFailedTotal + "").build());
+                        fileFailedTotal = 0;
+                    }
+                }
+                break;
+            case 1:
+                LocalDateTime startDateTime = queryDTO.getStartDateTime();
+                LocalDateTime endDateTime = queryDTO.getEndDateTime();
+                Duration duration = Duration.between(startDateTime, endDateTime);
+                long days = duration.toDays(); //相差的天数
+                if (days == 0L) {
+                    for (int i = 0; i < nowTime.getHour(); i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                fileFailedTotal += backgroundConvertDatum.getFileFailedTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(fileFailedTotal + "").build());
+                        fileFailedTotal = 0;
+                    }
+                } else {
+                    for (int i = 0; i < days; i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = endDateTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                fileFailedTotal += backgroundConvertDatum.getFileFailedTotal();
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(fileFailedTotal + "").build());
+                        fileFailedTotal = 0;
+                    }
+                }
+                break;
+            default:
+                throw new CommonException(ResponseEnum.SYSTEM_ERROR);
+        }
+        return dataDTOS;
     }
 
     @Override
+    @Cacheable(value = RedisConstantServer.DASHBOARD_ERROR_RATIO_DATA,cacheManager = "oneDayCacheManager", key = "T(String).valueOf(#queryDTO.toString())", unless = "#result == null")
     public List<DashboardDetailedDataDTO> getErrorRatioDetailedData(DashboardQueryDTO queryDTO) {
-        return null;
+        List<DashboardDetailedDataDTO> successfulRequestDetailedData = this.getSuccessfulRequestDetailedData(queryDTO);
+        List<DashboardDetailedDataDTO> errorRequestDetailedData = this.getErrorRequestDetailedData(queryDTO);
+        List<DashboardDetailedDataDTO> dataDTOS = new ArrayList<>();
+        for (int i = 0; i < successfulRequestDetailedData.size(); i++) {
+
+            int fileTotal = Integer.parseInt(successfulRequestDetailedData.get(i).getYData()) + Integer.parseInt(errorRequestDetailedData.get(i).getYData());
+
+            dataDTOS.add(DashboardDetailedDataDTO.builder()
+                    .xData(successfulRequestDetailedData.get(i).getXData())
+                    .yData(fileTotal == 0 ? "0.00" : new BigDecimal(String.format("%.2f",Integer.parseInt(errorRequestDetailedData.get(i).getYData()) * 100.00
+                            / fileTotal)).toString())
+                    .build());
+        }
+        return dataDTOS;
     }
 
     @Override
+    @Cacheable(value = RedisConstantServer.DASHBOARD_AVERAGE_PROCESS_DATA,cacheManager = "oneDayCacheManager", key = "T(String).valueOf(#queryDTO.toString())", unless = "#result == null")
     public List<DashboardDetailedDataDTO> getAverageProcessTimeDetailedData(DashboardQueryDTO queryDTO) {
-        return null;
+        LambdaQueryWrapper<BackgroundConvertData> queryWrapper = getDashboardQueryWrapper(queryDTO);
+        // 添加select 查询参数
+        queryWrapper.select(BackgroundConvertData::getFileConvertTime,BackgroundConvertData::getSyncTime);
+        // 查询数据
+        List<BackgroundConvertData> backgroundConvertData = this.baseMapper.selectList(queryWrapper);
+        // 判断查询类型
+        LocalDateTime nowTime = LocalDateTime.now();
+        // 减去分钟数
+        nowTime = nowTime.minus(nowTime.getMinute(), ChronoUnit.MINUTES);
+        // 返回数据集合
+        List<DashboardDetailedDataDTO> dataDTOS = new ArrayList<>();
+
+        BigDecimal convertTime = new BigDecimal(0);
+        switch (queryDTO.getQueryType()) {
+            case 0:
+                if (queryDTO.getDays() == 1) {
+                    for (int i = 0; i < 24; i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                convertTime = convertTime.add(backgroundConvertDatum.getFileConvertTime());
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(convertTime.toString()).build());
+                        convertTime = new BigDecimal(0);
+                    }
+                } else {
+                    for (int i = 0; i < queryDTO.getDays(); i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                convertTime = convertTime.add(backgroundConvertDatum.getFileConvertTime());
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(convertTime.toString()).build());
+                        convertTime = new BigDecimal(0);
+                    }
+                }
+                break;
+            case 1:
+                LocalDateTime startDateTime = queryDTO.getStartDateTime();
+                LocalDateTime endDateTime = queryDTO.getEndDateTime();
+                Duration duration = Duration.between(startDateTime, endDateTime);
+                long days = duration.toDays(); //相差的天数
+                if (days == 0L) {
+                    for (int i = 0; i < nowTime.getHour(); i++) {
+                        // 减去 i 小时时间
+                        LocalDateTime minus = nowTime.minus(i, ChronoUnit.HOURS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1小时
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusHours(1))) {
+                                convertTime = convertTime.add(backgroundConvertDatum.getFileConvertTime());
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(convertTime.toString()).build());
+                        convertTime = new BigDecimal(0);
+                    }
+                } else {
+                    for (int i = 0; i < days; i++) {
+                        // 减去 i 天时间
+                        LocalDateTime minus = endDateTime.minus(i, ChronoUnit.DAYS);
+                        for (BackgroundConvertData backgroundConvertDatum : backgroundConvertData) {
+                            // 如果同步时间大于当前 minus 并且小于 minus+1天
+                            if (backgroundConvertDatum.getSyncTime().isAfter(minus) && backgroundConvertDatum.getSyncTime().isBefore(minus.plusDays(1))) {
+                                convertTime = convertTime.add(backgroundConvertDatum.getFileConvertTime());
+                            }
+                        }
+                        dataDTOS.add(DashboardDetailedDataDTO.builder()
+                                .xData(minus.toString())
+                                .yData(convertTime.toString()).build());
+                        convertTime = new BigDecimal(0);
+                    }
+                }
+                break;
+            default:
+                throw new CommonException(ResponseEnum.SYSTEM_ERROR);
+        }
+        return dataDTOS;
+    }
+
+    @Override
+    @CacheEvict(cacheNames = RedisConstantServer.DASHBOARD+"*" ,allEntries = true)
+    public void test() {
+        System.out.println("删除");
     }
 
+
     /**
      * 获取Dashboard 查询使用的LambdaQueryWrapper
+     *
      * @param queryDTO 查询参数
      * @return Dashboard 查询使用的LambdaQueryWrapper
      */
-    private LambdaQueryWrapper<BackgroundConvertData> getDashboardQueryWrapper(DashboardQueryDTO queryDTO){
+    private LambdaQueryWrapper<BackgroundConvertData> getDashboardQueryWrapper(DashboardQueryDTO queryDTO) {
         LambdaQueryWrapper<BackgroundConvertData> queryWrapper = new LambdaQueryWrapper<>();
         // 查询类型
         Integer queryType = queryDTO.getQueryType();
@@ -118,6 +393,7 @@ public class BackgroundConvertDataServiceImpl extends ServiceImpl<BackgroundConv
             Integer days = queryDTO.getDays();
             if (days > 30 || days < 1) {
                 days = 30;
+                queryDTO.setDays(30);
             }
             LocalDateTime nowDateTime = LocalDateTime.now();
             LocalDateTime minus = nowDateTime.minus(days, ChronoUnit.DAYS);
@@ -132,9 +408,11 @@ public class BackgroundConvertDataServiceImpl extends ServiceImpl<BackgroundConv
             } else if (startDateTime.equals(endDateTime)) {
                 // 开始时间等于结束时间
                 endDateTime = endDateTime.plusDays(1);
+                queryDTO.setEndDateTime(endDateTime.plusDays(1));
             } else if (Duration.between(startDateTime, endDateTime).toDays() > 30) {
                 // 开始时间和结束时间大于30天
                 startDateTime = endDateTime.minus(30, ChronoUnit.DAYS);
+                queryDTO.setStartDateTime(endDateTime.minus(30, ChronoUnit.DAYS));
             }
             queryWrapper.ge(BackgroundConvertData::getSyncTime, startDateTime)
                     .le(BackgroundConvertData::getSyncTime, endDateTime);
@@ -154,8 +432,11 @@ public class BackgroundConvertDataServiceImpl extends ServiceImpl<BackgroundConv
     }
 
     public static void main(String[] args) {
-        LocalDateTime nowDateTime = LocalDateTime.now();
-        LocalDateTime minus = nowDateTime.minus(20, ChronoUnit.DAYS);
-        System.out.println(minus.toString());
+//        String format = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH"));
+//        LocalDateTime minus = DateUtil.toLocalDateTime(format, "yyyy-MM-dd HH");
+//        LocalDateTime minus = nowDateTime.minus(20, ChronoUnit.DAYS);
+        LocalDateTime minus = LocalDateTime.now();
+        LocalDateTime minus1 = minus.minus(minus.getMinute(), ChronoUnit.MINUTES);
+        System.out.println(minus1.toString());
     }
 }

background-user/src/main/resources/application.yml

@@ -9,7 +9,7 @@ spring:
     time-zone: GMT+8
   datasource:
     driver-class-name: com.mysql.cj.jdbc.Driver
-    url: jdbc:mysql://${DB_URL:106.55.99.175:33065/compdfkit_saas_background}?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
+    url: jdbc:mysql://${DB_URL:106.55.99.175:3306/compdfkit_saas_background}?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
     username: ${DB_USERNAME:root}
     password: ${DB_PASSWORD:root123}
     hikari:
@@ -23,6 +23,19 @@ spring:
       max-lifetime: 540000
       # \u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4
       connection-timeout: 60000
+  cloud:
+    nacos:
+      discovery:
+        server-addr: ${NACOS_ADDR:106.55.99.175:8845}
+        ip: ${NACOS_IP:127.0.0.1}
+        username: ${NACOS_USERNAME:nacos}
+        password: ${NACOS_PASSWORD:Nacos@123!}
+#      config:
+#        server-addr: ${spring.cloud.nacos.discovery.server-addr}
+#        username: ${spring.cloud.nacos.discovery.username}
+#        password: ${spring.cloud.nacos.discovery.password}
+#        file-extension: yml
+#        refresh-enabled: true
 #  redis:
 #    host: ${REDIS_HOST:47.93.102.223}
 #    port: ${REDIS_PORT:16379}