feat: add the logic "expire" to ComparisonIgnoreCategory

arex-web-api/src/main/java/com/arextest/web/api/service/beans/ExpandableBeanConfiguration.java

@@ -3,6 +3,7 @@
 import com.arextest.common.cache.CacheProvider;
 import com.arextest.config.repository.impl.SystemConfigurationRepositoryImpl;
 import com.arextest.web.core.business.ConfigLoadService;
+import com.arextest.web.core.business.filesystem.FileSystemService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@@ -38,4 +39,10 @@ public SystemConfigBootstrap systemConfigBootstrap(
     return new SystemConfigBootstrap(configLoadService, systemConfigurationRepository);
   }
 
+  @Bean
+  @ConditionalOnMissingBean(FileSystemService.class)
+  public FileSystemService fileSystemService() {
+    return new FileSystemService();
+  }
+
 }

arex-web-api/src/main/java/com/arextest/web/api/service/controller/ReportQueryController.java

@@ -450,6 +450,7 @@ public Response syncResponse(@Valid @RequestBody OverwriteContractRequestType re
     return ResponseUtils.successResponse(schemaInferService.overwriteContract(requestType));
   }
 
+  // todo from storage to get it
   @GetMapping("/listCategoryType")
   @ResponseBody
   public Response listCategoryType() {

arex-web-api/src/main/java/com/arextest/web/api/service/controller/config/ComparisonExclusionsController.java

@@ -7,11 +7,7 @@
 import com.arextest.web.model.contract.contracts.config.replay.ComparisonExclusionsConfiguration;
 import com.arextest.web.model.contract.contracts.config.replay.QueryComparisonRequestType;
 import java.util.List;
-import javax.annotation.Resource;
-import lombok.Getter;
-import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -24,13 +20,13 @@
 public class ComparisonExclusionsController extends
     AbstractConfigurableController<ComparisonExclusionsConfiguration> {
 
-  @Getter
-  @Resource
-  ComparisonExclusionsConfigurableHandler comparisonExclusionsConfigurableHandler;
+  ComparisonExclusionsConfigurableHandler exclusionsHandler;
 
-  public ComparisonExclusionsController(
-      @Autowired ConfigurableHandler<ComparisonExclusionsConfiguration> configurableHandler) {
+  protected ComparisonExclusionsController(
+      ConfigurableHandler<ComparisonExclusionsConfiguration> configurableHandler,
+      ComparisonExclusionsConfigurableHandler exclusionsHandler) {
     super(configurableHandler);
+    this.exclusionsHandler = exclusionsHandler;
   }
 
   @Deprecated
@@ -42,12 +38,9 @@ public final Response useResultList(@RequestParam String appId,
     if (StringUtils.isEmpty(appId)) {
       return InvalidResponse.REQUESTED_APP_ID_IS_EMPTY;
     }
-    List<ComparisonExclusionsConfiguration> configs =
-        getComparisonExclusionsConfigurableHandler().useResultAsList(appId, operationId);
-    if (filterExpired && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonExclusionsConfigurableHandler().removeDetailsExpired(config));
-    }
+    List<ComparisonExclusionsConfiguration> configs = exclusionsHandler.useResultAsList(appId,
+        operationId);
+    exclusionsHandler.removeDetailsExpired(configs, filterExpired);
     return ResponseUtils.successResponse(configs);
   }
 
@@ -64,25 +57,19 @@ public final Response queryByInterfaceId(@RequestParam String interfaceId,
     if (StringUtils.isEmpty(interfaceId)) {
       return InvalidResponse.REQUESTED_INTERFACE_ID_IS_EMPTY;
     }
-    List<ComparisonExclusionsConfiguration> configs =
-        getComparisonExclusionsConfigurableHandler().queryByInterfaceId(interfaceId);
-    if (filterExpired && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonExclusionsConfigurableHandler().removeDetailsExpired(config));
-    }
+    List<ComparisonExclusionsConfiguration> configs = exclusionsHandler.queryByInterfaceId(
+        interfaceId);
+    exclusionsHandler.removeDetailsExpired(configs, filterExpired);
     return ResponseUtils.successResponse(configs);
   }
 
   @PostMapping("/queryComparisonConfig")
   @ResponseBody
   public Response queryComparisonConfig(@RequestBody QueryComparisonRequestType request) {
-    List<ComparisonExclusionsConfiguration> configs = getComparisonExclusionsConfigurableHandler().queryComparisonConfig(
+    List<ComparisonExclusionsConfiguration> configs = exclusionsHandler.queryComparisonConfig(
         request.getAppId(), request.getOperationId(), request.getOperationType(),
         request.getOperationName());
-    if (Boolean.TRUE.equals(request.getFilterExpired()) && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonExclusionsConfigurableHandler().removeDetailsExpired(config));
-    }
+    exclusionsHandler.removeDetailsExpired(configs, request.getFilterExpired());
     return ResponseUtils.successResponse(configs);
   }
 

arex-web-api/src/main/java/com/arextest/web/api/service/controller/config/ComparisonIgnoreCategoryController.java

@@ -6,10 +6,8 @@
 import com.arextest.web.core.business.config.replay.ComparisonIgnoreCategoryConfigurableHandler;
 import com.arextest.web.model.contract.contracts.config.replay.ComparisonIgnoreCategoryConfiguration;
 import com.arextest.web.model.contract.contracts.config.replay.QueryComparisonRequestType;
-import javax.annotation.Resource;
-import lombok.Getter;
+import java.util.List;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -27,32 +25,39 @@
 public class ComparisonIgnoreCategoryController
     extends AbstractConfigurableController<ComparisonIgnoreCategoryConfiguration> {
 
-  @Getter
-  @Resource
-  ComparisonIgnoreCategoryConfigurableHandler configurableHandler;
+  ComparisonIgnoreCategoryConfigurableHandler ignoreCategoryHandler;
 
   protected ComparisonIgnoreCategoryController(
-      @Autowired ConfigurableHandler<ComparisonIgnoreCategoryConfiguration> configurableHandler) {
+      ConfigurableHandler<ComparisonIgnoreCategoryConfiguration> configurableHandler,
+      ComparisonIgnoreCategoryConfigurableHandler ignoreCategoryHandler) {
     super(configurableHandler);
+    this.ignoreCategoryHandler = ignoreCategoryHandler;
   }
 
   /**
    * query config which is compareConfig =1
    */
   @RequestMapping("/queryByInterfaceId")
   @ResponseBody
-  public final Response queryByInterfaceId(@RequestParam String interfaceId) {
+  public final Response queryByInterfaceId(@RequestParam String interfaceId,
+      @RequestParam(defaultValue = "false") Boolean filterExpired) {
     if (StringUtils.isEmpty(interfaceId)) {
       return InvalidResponse.REQUESTED_INTERFACE_ID_IS_EMPTY;
     }
-    return ResponseUtils.successResponse(getConfigurableHandler().queryByInterfaceId(interfaceId));
+
+    List<ComparisonIgnoreCategoryConfiguration> configs = ignoreCategoryHandler.queryByInterfaceId(
+        interfaceId);
+    ignoreCategoryHandler.removeDetailsExpired(configs, filterExpired);
+    return ResponseUtils.successResponse(configs);
   }
 
   @PostMapping("/queryComparisonConfig")
   @ResponseBody
   public Response queryComparisonConfig(@RequestBody QueryComparisonRequestType request) {
-    return ResponseUtils.successResponse(
-        this.configurableHandler.queryComparisonConfig(request.getAppId(),
-            request.getOperationId(), request.getOperationType(), request.getOperationName()));
+    List<ComparisonIgnoreCategoryConfiguration> configs =
+        this.ignoreCategoryHandler.queryComparisonConfig(request.getAppId(),
+            request.getOperationId(), request.getOperationType(), request.getOperationName());
+    ignoreCategoryHandler.removeDetailsExpired(configs, request.getFilterExpired());
+    return ResponseUtils.successResponse(configs);
   }
 }

arex-web-api/src/main/java/com/arextest/web/api/service/controller/config/ComparisonRootTransformController.java

@@ -12,7 +12,6 @@
 import java.util.List;
 import java.util.stream.Collectors;
 import javax.annotation.Resource;
-import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -32,17 +31,12 @@ public Response queryComparisonConfig(@RequestBody QueryComparisonRequestType re
     List<ComparisonTransformConfiguration> configs = comparisonTransformConfigurableHandler.
         queryComparisonConfig(request.getAppId(), request.getOperationId(),
             request.getOperationType(), request.getOperationName());
-    if (Boolean.TRUE.equals(request.getFilterExpired()) && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> comparisonTransformConfigurableHandler.removeDetailsExpired(config));
-    }
+    comparisonTransformConfigurableHandler.removeDetailsExpired(configs,
+        request.getFilterExpired());
     List<ComparisonRootTransformConfiguration> rootTransformConfigurations = configs.stream()
-        .map(ConfigComparisonTransformMapper.INSTANCE::requestTypeFromDto).filter(item -> {
-          if (item.getTransformMethodName() != null) {
-            return true;
-          }
-          return false;
-        }).collect(Collectors.toList());
+        .map(ConfigComparisonTransformMapper.INSTANCE::requestTypeFromDto)
+        .filter(item -> item.getTransformMethodName() != null)
+        .collect(Collectors.toList());
     return ResponseUtils.successResponse(rootTransformConfigurations);
   }
 

arex-web-api/src/main/java/com/arextest/web/api/service/controller/config/ComparisonTransformController.java

@@ -7,11 +7,7 @@
 import com.arextest.web.model.contract.contracts.config.replay.ComparisonTransformConfiguration;
 import com.arextest.web.model.contract.contracts.config.replay.QueryComparisonRequestType;
 import java.util.List;
-import javax.annotation.Resource;
-import lombok.Getter;
-import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -25,13 +21,13 @@
 public class ComparisonTransformController extends
     AbstractConfigurableController<ComparisonTransformConfiguration> {
 
-  @Getter
-  @Resource
-  ComparisonTransformConfigurableHandler comparisonTransformConfigurableHandler;
+  ComparisonTransformConfigurableHandler transformHandler;
 
   public ComparisonTransformController(
-      @Autowired ConfigurableHandler<ComparisonTransformConfiguration> configurableHandler) {
+      ConfigurableHandler<ComparisonTransformConfiguration> configurableHandler,
+      ComparisonTransformConfigurableHandler transformHandler) {
     super(configurableHandler);
+    this.transformHandler = transformHandler;
   }
 
   @Deprecated
@@ -44,11 +40,8 @@ public final Response useResultList(@RequestParam String appId,
       return InvalidResponse.REQUESTED_APP_ID_IS_EMPTY;
     }
     List<ComparisonTransformConfiguration> configs =
-        getComparisonTransformConfigurableHandler().useResultAsList(appId, operationId);
-    if (filterExpired && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonTransformConfigurableHandler().removeDetailsExpired(config));
-    }
+        transformHandler.useResultAsList(appId, operationId);
+    transformHandler.removeDetailsExpired(configs, filterExpired);
     return ResponseUtils.successResponse(configs);
   }
 
@@ -66,24 +59,18 @@ public final Response queryByInterfaceId(@RequestParam String interfaceId,
       return InvalidResponse.REQUESTED_INTERFACE_ID_IS_EMPTY;
     }
     List<ComparisonTransformConfiguration> configs =
-        getComparisonTransformConfigurableHandler().queryByInterfaceId(interfaceId);
-    if (filterExpired && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonTransformConfigurableHandler().removeDetailsExpired(config));
-    }
+        transformHandler.queryByInterfaceId(interfaceId);
+    transformHandler.removeDetailsExpired(configs, filterExpired);
     return ResponseUtils.successResponse(configs);
   }
 
   @PostMapping("/queryComparisonConfig")
   @ResponseBody
   public Response queryComparisonConfig(@RequestBody QueryComparisonRequestType request) {
-    List<ComparisonTransformConfiguration> configs = getComparisonTransformConfigurableHandler().
+    List<ComparisonTransformConfiguration> configs = transformHandler.
         queryComparisonConfig(request.getAppId(), request.getOperationId(),
             request.getOperationType(), request.getOperationName());
-    if (Boolean.TRUE.equals(request.getFilterExpired()) && CollectionUtils.isNotEmpty(configs)) {
-      configs.removeIf(
-          config -> getComparisonTransformConfigurableHandler().removeDetailsExpired(config));
-    }
+    transformHandler.removeDetailsExpired(configs, request.getFilterExpired());
     return ResponseUtils.successResponse(configs);
   }
 
@@ -93,8 +80,7 @@ public final Response getTransformMethod(@RequestParam String appId) {
     if (StringUtils.isEmpty(appId)) {
       return InvalidResponse.REQUESTED_APP_ID_IS_EMPTY;
     }
-    return ResponseUtils.successResponse(
-        getComparisonTransformConfigurableHandler().getTransformMethodList());
+    return ResponseUtils.successResponse(transformHandler.getTransformMethodList());
   }
 
 }

arex-web-core/src/main/java/com/arextest/web/core/business/config/replay/AbstractComparisonConfigurableHandler.java

@@ -3,7 +3,6 @@
 import com.arextest.config.repository.ConfigRepositoryProvider;
 import com.arextest.web.core.business.config.AbstractConfigurableHandler;
 import com.arextest.web.core.repository.AppContractRepository;
-import com.arextest.web.model.contract.contracts.common.enums.ExpirationType;
 import com.arextest.web.model.contract.contracts.config.replay.AbstractComparisonDetailsConfiguration;
 import com.arextest.web.model.dto.AppContractDto;
 import com.arextest.web.model.enums.ContractTypeEnum;
@@ -16,6 +15,7 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 
 /**
@@ -86,9 +86,10 @@ public List<T> queryComparisonConfig(String appId, String operationId, String op
     return this.useResultAsList(appId, null);
   }
 
-  public boolean removeDetailsExpired(T comparisonDetails) {
-    return comparisonDetails.getExpirationType() == ExpirationType.SOFT_TIME_EXPIRED.getCodeValue()
-        && comparisonDetails.getExpirationDate().getTime() < System.currentTimeMillis();
+  public void removeDetailsExpired(List<T> comparisonDetails, Boolean filterExpired) {
+    if (CollectionUtils.isNotEmpty(comparisonDetails) && Boolean.TRUE.equals(filterExpired)) {
+      comparisonDetails.removeIf(T::expired);
+    }
   }
 
   @Override

arex-web-core/src/main/java/com/arextest/web/core/business/config/replay/ComparisonExclusionsConfigurableHandler.java

@@ -36,9 +36,10 @@ protected ComparisonExclusionsConfigurableHandler(
 
   public List<ComparisonExclusionsConfiguration> queryConfigOfCategory(String appId,
       String operationId, List<String> dependencyIds) {
-    List<ComparisonExclusionsConfiguration> configs = comparisonExclusionsConfigurationRepository.queryConfigOfCategory(
-        appId, operationId, dependencyIds);
-    configs.removeIf(this::removeDetailsExpired);
+    List<ComparisonExclusionsConfiguration> configs =
+        comparisonExclusionsConfigurationRepository.queryConfigOfCategory(appId, operationId,
+            dependencyIds);
+    removeDetailsExpired(configs, true);
     return configs;
   }
 

arex-web-core/src/main/java/com/arextest/web/core/business/config/replay/ComparisonSummaryService.java

@@ -205,6 +205,8 @@ protected void getComparisonExclusionsConfiguration(String interfaceId,
     Set<List<String>> exclusionSet = new HashSet<>();
     List<ComparisonExclusionsConfiguration> comparisonExclusionsConfigurationList =
         exclusionsConfigurableHandler.queryByInterfaceId(interfaceId);
+    exclusionsConfigurableHandler.removeDetailsExpired(comparisonExclusionsConfigurationList
+        , true);
     Optional.ofNullable(comparisonExclusionsConfigurationList).orElse(Collections.emptyList())
         .forEach(item -> {
           exclusionSet.add(item.getExclusions());
@@ -217,6 +219,8 @@ protected void getComparisonInclusionsConfiguration(String interfaceId,
     Set<List<String>> inclusionSet = new HashSet<>();
     List<ComparisonInclusionsConfiguration> comparisonInclusionsConfigurationList =
         inclusionsConfigurableHandler.queryByInterfaceId(interfaceId);
+    inclusionsConfigurableHandler.removeDetailsExpired(
+        comparisonInclusionsConfigurationList, true);
     Optional.ofNullable(comparisonInclusionsConfigurationList).orElse(Collections.emptyList())
         .forEach(item -> {
           inclusionSet.add(item.getInclusions());
@@ -229,6 +233,8 @@ protected void getComparisonListSortConfiguration(String interfaceId,
     Map<List<String>, List<List<String>>> listSortMap = new HashMap<>();
     List<ComparisonListSortConfiguration> comparisonListSortConfigurationList =
         listSortConfigurableHandler.queryByInterfaceId(interfaceId);
+    listSortConfigurableHandler.removeDetailsExpired(
+        comparisonListSortConfigurationList, true);
     Optional.ofNullable(comparisonListSortConfigurationList).orElse(Collections.emptyList())
         .forEach(item -> {
           if (CollectionUtils.isNotEmpty(item.getListPath())) {
@@ -243,6 +249,8 @@ protected void getComparisonReferenceConfiguration(String interfaceId,
     Map<List<String>, List<String>> referenceMap = new HashMap<>();
     List<ComparisonReferenceConfiguration> comparisonReferenceConfigurationList =
         referenceConfigurableHandler.queryByInterfaceId(interfaceId);
+    referenceConfigurableHandler.removeDetailsExpired(
+        comparisonReferenceConfigurationList, true);
     Optional.ofNullable(comparisonReferenceConfigurationList).orElse(Collections.emptyList())
         .forEach(item -> {
           if (CollectionUtils.isNotEmpty(item.getFkPath())) {
@@ -267,17 +275,16 @@ protected Map<String, ReplayCompareConfig.ReplayComparisonItem> buildMultiConfig
     buildComparisonConfig(replayConfigurationMap,
         exclusionsConfigurableHandler.useResultAsList(appId),
         (configurations, summaryConfiguration) -> {
+          exclusionsConfigurableHandler.removeDetailsExpired(configurations, true);
           Set<List<String>> operationExclusion = configurations.stream()
-              .filter(config ->
-                  config.getExpirationType() == ExpirationType.PINNED_NEVER_EXPIRED.getCodeValue()
-                      || config.getExpirationDate().getTime() > System.currentTimeMillis())
               .map(ComparisonExclusionsConfiguration::getExclusions).collect(Collectors.toSet());
           summaryConfiguration.setExclusionList(operationExclusion);
         }, operationInfoMap, appContractDtoMap);
 
     buildComparisonConfig(replayConfigurationMap,
         ignoreCategoryConfigurableHandler.useResultAsList(appId),
         (configurations, summaryConfiguration) -> {
+          ignoreCategoryConfigurableHandler.removeDetailsExpired(configurations, true);
           List<CategoryDetail> ignoreCategoryTypes = configurations.stream()
               .map(ComparisonIgnoreCategoryConfiguration::getIgnoreCategoryDetail)
               .collect(Collectors.toList());

arex-web-core/src/main/java/com/arextest/web/core/business/config/replay/ComparisonTransformConfigurableHandler.java

@@ -45,7 +45,7 @@ public List<ComparisonTransformConfiguration> queryConfigOfCategory(String appId
       String operationId, List<String> dependencyIds) {
     List<ComparisonTransformConfiguration> configs = comparisonTransformConfigurationRepository.queryConfigOfCategory(
         appId, operationId, dependencyIds);
-    configs.removeIf(this::removeDetailsExpired);
+    removeDetailsExpired(configs, true);
     return configs;
   }
 
@@ -74,7 +74,7 @@ public List<String> getTransformMethodList() {
     SystemConfiguration comparePluginInfoConfig = systemConfigurationService.getSystemConfigByKey(
         KeySummary.COMPARE_PLUGIN_INFO);
 
-    return comparePluginInfoConfig ==null || comparePluginInfoConfig.getComparePluginInfo() == null
+    return comparePluginInfoConfig == null || comparePluginInfoConfig.getComparePluginInfo() == null
         ? Collections.emptyList()
         : comparePluginInfoConfig.getComparePluginInfo().getTransMethodList();
   }