bugfix-476: 积分规则唯一性校验修改

yudao-module-member/yudao-module-member-impl/src/main/java/cn/iocoder/yudao/module/member/dal/redis/scoreRule/ScoreRuleRedisDao.java

@@ -37,6 +37,7 @@ public class ScoreRuleRedisDao {
     }
 
     public ScoreRuleDO getEnableScoreRule(ScoreRuleTypeEnum type, TransportTypeEnum transportType) {
+        ScoreRuleDO useScoreRuleDO;
         // 如果transportType不为空则是订单V值类型
         if (transportType == null) {
             String redisKey = formatKey(type.getValue(), null);
@@ -44,15 +45,20 @@ public class ScoreRuleRedisDao {
             if (scoreRuleJson == null) {
                 return null;
             }
-            return JsonUtils.parseObject(scoreRuleJson, ScoreRuleDO.class);
+            useScoreRuleDO = JsonUtils.parseObject(scoreRuleJson, ScoreRuleDO.class);
         } else {
             String redisKey = formatKey(type.getValue(), transportType.getValue());
             String scoreRuleJson = stringRedisTemplate.opsForValue().get(redisKey);
             if (scoreRuleJson == null) {
                 return null;
             }
-            return JsonUtils.parseObject(scoreRuleJson, ScoreRuleDO.class);
+            useScoreRuleDO = JsonUtils.parseObject(scoreRuleJson, ScoreRuleDO.class);
         }
+        // 如果当前时间不在规则时间区间
+        if (System.currentTimeMillis() < useScoreRuleDO.getStartTime().getTime() || System.currentTimeMillis() > useScoreRuleDO.getEndTime().getTime()) {
+            return null;
+        }
+        return useScoreRuleDO;
     }
 
     public ScoreRuleDO getEnableScoreRule(ScoreRuleTypeEnum type) {
@@ -72,7 +78,7 @@ public class ScoreRuleRedisDao {
         scoreRuleDO.setDescZh(null);
         if (scoreRuleDO.getType() == ScoreRuleTypeEnum.ORDER_V.getValue()) {
             ScoreRuleOrderVExtraVO scoreRuleOrderVExtraVO = JsonUtils.parseObject(scoreRuleDO.getExtra(), ScoreRuleOrderVExtraVO.class);
-            stringRedisTemplate.opsForValue().set(formatKey(scoreRuleDO.getType(), scoreRuleOrderVExtraVO.getTransportType()), JsonUtils.toJsonString(scoreRuleDO));
+            stringRedisTemplate.opsForValue().set(formatKey(scoreRuleDO.getType(), scoreRuleOrderVExtraVO.getTransportType()), JsonUtils.toJsonString(scoreRuleDO), 24L, TimeUnit.HOURS);
         }
         stringRedisTemplate.opsForValue().set(formatKey(scoreRuleDO.getType(), null), JsonUtils.toJsonString(scoreRuleDO), 24L, TimeUnit.HOURS);
     }

yudao-module-member/yudao-module-member-impl/src/main/java/cn/iocoder/yudao/module/member/service/scoreRule/ScoreRuleServiceImpl.java

@@ -42,6 +42,7 @@ import org.springframework.validation.annotation.Validated;
 
 import javax.annotation.Resource;
 import java.time.Instant;
+import java.time.LocalDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -101,9 +102,6 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
         }
         //如果是启用，校验同一个规则下，有效期内有没有重复的规则设置，分享不校验。海运空运分开算
         if (scoreRuleIn.getStatus() == ScoreRuleStatusEnum.ENABLED.getValue() && scoreRuleIn.getType() != ScoreRuleTypeEnum.SHARE.getValue()) {
-            LambdaQuery<ScoreRuleDO> scoreRuleDOLambdaQuery = new LambdaQuery<>();
-            scoreRuleDOLambdaQuery.eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue())
-                    .eq(ScoreRuleDO::getType, scoreRuleIn.getType());
             if (scoreRuleIn.getType() == ScoreRuleTypeEnum.ORDER_V.getValue()) {
                 ScoreRuleOrderVExtraVO extraOrderV = scoreRuleIn.getExtraOrderV();
                 if (extraOrderV == null) {
@@ -113,24 +111,54 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
                 if (transportType != TransportTypeEnum.OCEAN_LCL.getValue() && transportType != TransportTypeEnum.SPECIAL_LINE_AIR_FREIGHT.getValue()) {
                     throw exception(SCORE_RULE_TRANSPORT_TYPE_ERROR);
                 }
-                List<ScoreRuleDO> scoreRuleDOS = scoreRuleMapper.selectList(scoreRuleDOLambdaQuery);
-                if (scoreRuleDOS != null && !scoreRuleDOS.isEmpty()) {
-                    for (ScoreRuleDO scoreRuleDO : scoreRuleDOS) {
-                        ScoreRuleOrderVExtraVO bean = JSONUtil.toBean(scoreRuleDO.getExtra(), ScoreRuleOrderVExtraVO.class);
-                        if (Objects.equals(bean.getTransportType(), transportType)) {
-                            throw exception(SCORE_RULE_UNIQUE_CHECK_ERROR);
-                        }
+                scoreRuleUniqueCheck(scoreRuleIn.getType(), transportType, scoreRuleIn.getStartTime(), scoreRuleIn.getEndTime(), null);
+            } else {
+                scoreRuleUniqueCheck(scoreRuleIn.getType(), null, scoreRuleIn.getStartTime(), scoreRuleIn.getEndTime(), null);
+            }
+        }
+    }
+
+    /**
+     * 积分规则唯一性校验
+     *
+     * @param type              类型
+     * @param transportType     运输类型（订单V值传）
+     * @param newScoreRuleStart 新积分规则开始时间
+     * @param delayId           延期时的规则id
+     */
+    private void scoreRuleUniqueCheck(Integer type, Integer transportType, Date newScoreRuleStart, Date newScoreRuleEnd, Long delayId) {
+        LambdaQuery<ScoreRuleDO> scoreRuleDOLambdaQuery = new LambdaQuery<>();
+        scoreRuleDOLambdaQuery.eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue())
+                .eq(ScoreRuleDO::getType, type);
+        if (delayId != null) {
+            scoreRuleDOLambdaQuery.ne(ScoreRuleDO::getId, delayId);
+        }
+        List<ScoreRuleDO> scoreRuleDOS = scoreRuleMapper.selectList(scoreRuleDOLambdaQuery);
+        if (transportType != null) {
+            if (scoreRuleDOS != null && !scoreRuleDOS.isEmpty()) {
+                for (ScoreRuleDO scoreRuleDO : scoreRuleDOS) {
+                    ScoreRuleOrderVExtraVO bean = JSONUtil.toBean(scoreRuleDO.getExtra(), ScoreRuleOrderVExtraVO.class);
+                    if (Objects.equals(bean.getTransportType(), transportType) && verifyTimeOverlap(newScoreRuleStart, newScoreRuleEnd, scoreRuleDO)) {
+                        throw exception(SCORE_RULE_UNIQUE_CHECK_ERROR);
                     }
                 }
-            } else {
-                Long count = scoreRuleMapper.selectCount(scoreRuleDOLambdaQuery);
-                if (count > 0) {
+            }
+        } else {
+            for (ScoreRuleDO scoreRuleDO : scoreRuleDOS) {
+                if (verifyTimeOverlap(newScoreRuleStart, newScoreRuleEnd, scoreRuleDO)) {
                     throw exception(SCORE_RULE_UNIQUE_CHECK_ERROR);
                 }
             }
         }
     }
 
+    /**
+     * 校验规则时间区间是否有交集
+     */
+    private boolean verifyTimeOverlap(Date newScoreRuleStart, Date newScoreRuleEnd, ScoreRuleDO oldScoreRule) {
+        return newScoreRuleStart.before(oldScoreRule.getEndTime()) && newScoreRuleEnd.after(oldScoreRule.getStartTime());
+    }
+
 
     @Override
     public void updateScoreRule(ScoreRuleUpdateReqVO updateReqVO) {
@@ -352,21 +380,17 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
         if (oldStatus == ScoreRuleStatusEnum.ENABLED.getValue() && scoreRuleStatusReqVO.getStatus() == ScoreRuleStatusEnum.CLOSED.getValue()) {
             upScoreRuleDO.setStatus(scoreRuleStatusReqVO.getStatus());
         } else if (oldStatus == ScoreRuleStatusEnum.DISABLED.getValue() && scoreRuleStatusReqVO.getStatus() == ScoreRuleStatusEnum.ENABLED.getValue()) {
-            //如果是启用，校验同一个规则下，有效期内有没有重复的规则设置，分享不校验
-            if (scoreRuleDO.getType() != ScoreRuleTypeEnum.SHARE.getValue()) {
-                LambdaQuery<ScoreRuleDO> scoreRuleDOLambdaQuery = new LambdaQuery<>();
-                scoreRuleDOLambdaQuery.eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue())
-                        .eq(ScoreRuleDO::getType, scoreRuleDO.getType())
-                        .eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue());
-                Long count = scoreRuleMapper.selectCount(scoreRuleDOLambdaQuery);
-                if (count > 0) {
-                    throw exception(SCORE_RULE_UNIQUE_CHECK_ERROR);
-                }
-            }
             // 如果结束时间比当前时间早，不允许启用
             if (scoreRuleDO.getEndTime() != null && scoreRuleDO.getEndTime().before(new Date())) {
                 throw exception(SCORE_RULE_TIME_ERROR);
             }
+            //如果是启用，校验同一个规则下，有效期内有没有重复的规则设置，分享不校验
+            if (scoreRuleDO.getType() == ScoreRuleTypeEnum.ORDER_V.getValue()) {
+                ScoreRuleOrderVExtraVO extraOrderV = JSONUtil.toBean(scoreRuleDO.getExtra(), ScoreRuleOrderVExtraVO.class);
+                scoreRuleUniqueCheck(scoreRuleDO.getType(), extraOrderV.getTransportType(), scoreRuleDO.getStartTime(), scoreRuleDO.getEndTime(), null);
+            } else {
+                scoreRuleUniqueCheck(scoreRuleDO.getType(), null, scoreRuleDO.getStartTime(), scoreRuleDO.getEndTime(), null);
+            }
             upScoreRuleDO.setStatus(scoreRuleStatusReqVO.getStatus());
         } else {
             throw exception(SCORE_RULE_STATUS_ERROR);
@@ -401,10 +425,17 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
             throw exception(SCORE_RULE_STATUS_NOT_ENABLE);
         }
         Instant now = Instant.now();
-        //结束时间不能小于当前时间
+        // 结束时间不能小于当前时间
         if (!delayReqVO.getEndTime().toInstant().isAfter(now) || !delayReqVO.getEndTime().toInstant().isAfter(scoreRuleDO.getStartTime().toInstant())) {
             throw exception(SCORE_RULE_TIME_ERROR);
         }
+        // 新时间区间规则唯一校验
+        if (scoreRuleDO.getType() == ScoreRuleTypeEnum.ORDER_V.getValue()) {
+            ScoreRuleOrderVExtraVO extraOrderV = JSONUtil.toBean(scoreRuleDO.getExtra(), ScoreRuleOrderVExtraVO.class);
+            scoreRuleUniqueCheck(scoreRuleDO.getType(), extraOrderV.getTransportType(), scoreRuleDO.getStartTime(), delayReqVO.getEndTime(), scoreRuleDO.getId());
+        } else {
+            scoreRuleUniqueCheck(scoreRuleDO.getType(), null, scoreRuleDO.getStartTime(), delayReqVO.getEndTime(), scoreRuleDO.getId());
+        }
         ScoreRuleDO upScoreRuleDO = new ScoreRuleDO();
         upScoreRuleDO.setId(delayReqVO.getId());
         upScoreRuleDO.setEndTime(delayReqVO.getEndTime());
@@ -417,8 +448,11 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
             throw exception(SCORE_RULE_TRANSPORT_TYPE_ERROR);
         }
         LambdaQuery<ScoreRuleDO> lambdaQuery = new LambdaQuery<>();
+        // 查询状态为启用，类型为订单V值，当前时间在规则时间区间内的规则
         lambdaQuery.eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue())
-                .eq(ScoreRuleDO::getType, ScoreRuleTypeEnum.ORDER_V.getValue());
+                .eq(ScoreRuleDO::getType, ScoreRuleTypeEnum.ORDER_V.getValue())
+                .lt(ScoreRuleDO::getStartTime, LocalDateTime.now())
+                .gt(ScoreRuleDO::getEndTime, LocalDateTime.now());
         List<ScoreRuleDO> scoreRuleDOS = scoreRuleMapper.selectList(lambdaQuery);
         if (!CollectionUtil.isEmpty(scoreRuleDOS)) {
             for (ScoreRuleDO scoreRuleDO : scoreRuleDOS) {
@@ -437,15 +471,14 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
         if (enableScoreRule == null) {
             enableScoreRule = selectOne(new LambdaQuery<ScoreRuleDO>()
                     .eq(ScoreRuleDO::getType, scoreRuleType.getValue())
-                    .eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue()));
+                    .eq(ScoreRuleDO::getStatus, ScoreRuleStatusEnum.ENABLED.getValue())
+                    .lt(ScoreRuleDO::getStartTime, LocalDateTime.now())
+                    .gt(ScoreRuleDO::getEndTime, LocalDateTime.now()));
             if (enableScoreRule == null) {
                 return null;
             }
             scoreRuleRedisDao.setEnableScoreRule(enableScoreRule);
         }
-        if (!enableScoreRule.getEndTime().after(new Date()) || !enableScoreRule.getStartTime().before(new Date())) {
-            return null;
-        }
         return enableScoreRule;
     }
 
@@ -462,9 +495,6 @@ public class ScoreRuleServiceImpl extends AbstractService<ScoreRuleMapper, Score
                     }
                     scoreRuleRedisDao.setEnableScoreRule(enableScoreRule);
                 }
-                if (!enableScoreRule.getEndTime().after(new Date()) || !enableScoreRule.getStartTime().before(new Date())) {
-                    return null;
-                }
                 return enableScoreRule;
             case RECOMMEND:
             case REGISTER: