## 手动开通V1V2单独判断升级；

bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/service/ISaOrderService.java

@@ -693,27 +693,4 @@ public interface ISaOrderService extends IService<SaOrder> {
                            List<BdGrade> gradeList, CuMember updateGradeMember,
                            Integer systemType, Integer isPay);
 
-    /**
-     * 根据盒数计算等级
-     *
-     * @param boxTotal     总盒数
-     * @param gradeList    等级列表（可为空）
-     * @param memberGrade  当前等级 -- 为空则为注册，不为空则为升级
-     * @param checkUpgrade 校验升级
-     * @return
-     */
-    BdGrade getGradeByBox(final Integer boxTotal, List<BdGrade> gradeList, BdGrade memberGrade, boolean checkUpgrade);
-
-    /**
-     * 处理升级盒数基数
-     *
-     * @param cuMember       会员信息
-     * @param memberGrade    会员等级信息
-     * @param gradeList      等级列表
-     * @param boxProductList 盒数商品商品
-     * @param systemType     所属系统
-     * @return
-     */
-    int handleBaseBoxNum(CuMember cuMember, BdGrade memberGrade, List<BdGrade> gradeList, List<String> boxProductList, Integer systemType);
-
 }

bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/service/impl/SaOrderServiceImpl.java

@@ -50,7 +50,6 @@ import com.hzs.member.account.dto.BusinessCommissionDTO;
 import com.hzs.member.account.dto.CuMemberBankParam;
 import com.hzs.member.account.dto.MemberAmountDTO;
 import com.hzs.member.achieve.IMemberAchieveServiceApi;
-import com.hzs.member.base.IMemberLevelServiceApi;
 import com.hzs.member.base.IMemberServiceApi;
 import com.hzs.member.detail.ICuMemberDetailServiceApi;
 import com.hzs.member.detail.ICuMemberServiceLogServiceApi;
@@ -136,8 +135,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
     IScmBillServiceApi scmBillServiceApi;
     @DubboReference
     IGradeServiceApi iGradeServiceApi;
-    @DubboReference
-    IMemberLevelServiceApi iMemberLevelServiceApi;
 
     @Autowired
     private IBdWaresService waresService;
@@ -2631,6 +2628,12 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
         if (ESpecialArea.RETAIL_REGISTER.getValue() == specialArea) {
             // 注册专区直接算等级
             bdGrade = this.getGradeByBox(boxNum, gradeList, null, true);
+            // 特殊等级处理
+            BdGrade tmpGrade = this.handleGradeEnd(gradeList, bdGrade);
+            if (null != isPay && EYesNo.YES.getIntValue() == isPay) {
+                // 支付时才进行处理
+                bdGrade = tmpGrade;
+            }
         } else if (ESpecialArea.RETAIL_UPGRADE.getValue() == specialArea) {
             // 升级专区，一次性补差升级
             if (boxNum == 0) {
@@ -2640,8 +2643,12 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
 
             // 当前会员等级
             BdGrade memberGrade = gradeList.stream().filter(tmpGrade -> tmpGrade.getPkId().equals(updateGradeMember.getPkSettleGrade())).findFirst().get();
-            if (memberGrade.getGradeValue().compareTo(EGrade.MAKER.getValue()) >= 0) {
-                // 会员等级大于等于V3（卓越），不能通过升级进行购买了
+//            if (memberGrade.getGradeValue().compareTo(EGrade.MAKER.getValue()) >= 0) {
+//                // 会员等级大于等于V3（卓越），不能通过升级进行购买了
+//                throw new ServiceException("当前已经是可以购买的最高等级");
+//            }
+            if (memberGrade.getGradeValue().compareTo(EGrade.S_VIP.getValue()) >= 0) {
+                // new 2025.06.25 V1-V3升级多送两级，后续还需要继续购买升级，此处调整逻辑，会员等级大于等于V5（合伙人），不能通过升级进行购买了
                 throw new ServiceException("当前已经是可以购买的最高等级");
             }
 
@@ -2650,30 +2657,25 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
             // 计算等级
             bdGrade = this.getGradeByBox(boxNum + baseBoxNum, gradeList, memberGrade, true);
 
-            // 会员等级 大于等于 购买盒数等级，则不充足升级条件
-            if (memberGrade.getGradeValue().compareTo(bdGrade.getGradeValue()) >= 0) {
+            if (bdGrade.getGradeValue().equals(memberGrade.getGradeValue())
+                    && (EGrade.HAI_FAN.getValue() == bdGrade.getGradeValue() || EGrade.YOU_KE.getValue() == bdGrade.getGradeValue())
+            ) {
+                // 旧等级与新等级相同 并且 旧等级为V1或V2
+                return null;
+            }
+
+            // 特殊等级处理
+            BdGrade tmpGrade = this.handleGradeEnd(gradeList, bdGrade);
+            if (null != isPay && EYesNo.YES.getIntValue() == isPay) {
+                // 支付时才进行处理
+                bdGrade = tmpGrade;
+            }
+
+            // 会员等级 大于等于 购买盒数等级，则不满足升级条件
+            if (memberGrade.getGradeValue().compareTo(tmpGrade.getGradeValue()) >= 0) {
                 return null;
             }
         }
-
-        // TODO 2025.06.14 添加新需求，V1-V3，购买多给两级
-        if (null != isPay && EYesNo.YES.getIntValue() == isPay) {
-            // 支付时才进行处理
-            if (null != bdGrade) {
-                if (EGrade.HAI_FAN.getValue() == bdGrade.getGradeValue()) {
-                    // V1 给 V3
-                    bdGrade = gradeList.stream().filter(tmpData -> EGrade.MAKER.getValue() == tmpData.getGradeValue()).findFirst().get();
-                } else if (EGrade.YOU_KE.getValue() == bdGrade.getGradeValue()) {
-                    // V2 给 V4
-                    bdGrade = gradeList.stream().filter(tmpData -> EGrade.VIP.getValue() == tmpData.getGradeValue()).findFirst().get();
-                } else if (EGrade.MAKER.getValue() == bdGrade.getGradeValue()) {
-                    // V3 给 V5
-                    bdGrade = gradeList.stream().filter(tmpData -> EGrade.S_VIP.getValue() == tmpData.getGradeValue()).findFirst().get();
-                }
-            }
-        }
-
-
         return bdGrade;
     }
 
@@ -2686,8 +2688,7 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
      * @param checkUpgrade 校验升级
      * @return
      */
-    @Override
-    public BdGrade getGradeByBox(final Integer boxTotal, List<BdGrade> gradeList, BdGrade memberGrade, boolean checkUpgrade) {
+    private BdGrade getGradeByBox(final Integer boxTotal, List<BdGrade> gradeList, BdGrade memberGrade, boolean checkUpgrade) {
         if (CollectionUtil.isEmpty(gradeList)) {
             gradeList = iGradeServiceApi.getRetailGradeList().getData();
         }
@@ -2715,7 +2716,9 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
 //            }
 
             // 查询等级比现在当前等级大的，然后倒序排序，再查询 购买盒数 <= 等级盒数 的第一个等级，就是当前升级的等级
-            Optional<BdGrade> gradeOptional = gradeList.stream().filter(tmpGrade -> tmpGrade.getGradeValue() > memberGrade.getGradeValue())
+            Optional<BdGrade> gradeOptional = gradeList.stream()
+                    // new 2025.06.25 V1-V3升级多送两级，需要支持送完还能买，此处暂时注释掉
+//                    .filter(tmpGrade -> tmpGrade.getGradeValue() > memberGrade.getGradeValue())
                     .sorted(Comparator.comparingInt(BdGrade::getGradeValue).reversed())
                     .filter(tmpGrade -> tmpGrade.getBoxNumber() != 0)
                     .filter(tmpGrade -> tmpGrade.getBoxNumber() <= boxTotal).findFirst();
@@ -2734,10 +2737,8 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
      * @param systemType     所属系统
      * @return
      */
-    @Override
-    public int handleBaseBoxNum(CuMember cuMember, BdGrade memberGrade,
-                                List<BdGrade> gradeList, List<String> boxProductList,
-                                Integer systemType) {
+    private int handleBaseBoxNum(CuMember cuMember, BdGrade memberGrade, List<BdGrade> gradeList, List<String> boxProductList,
+                                 Integer systemType) {
         // 升级盒数基数
         int baseBoxNum = 0;
         // 会员所有升级记录
@@ -2748,6 +2749,10 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
                 // 最新一次的手动升级
                 CuMemberLevel lastMemberLevel = lastManualOptional.get();
                 BdGrade lastUpdateGrade = gradeList.stream().filter(tmpGrade -> tmpGrade.getPkId().equals(lastMemberLevel.getNewLevel())).findFirst().get();
+                if (lastUpdateGrade.getGradeValue() >= EGrade.MAKER.getValue()) {
+                    // new 2025.06.25 V1-V3升级多送两级，但手动开到V3及以上，则不能继续购买升级
+                    throw new ServiceException("当前已经是可以购买的最高等级");
+                }
                 // 盒数基数 = 手动升级盒数 + 手动升级之后的升级订单盒数
                 baseBoxNum = lastUpdateGrade.getBoxNumber()
                         + saOrderItemsService.getRetailWaresQuantityNew(cuMember.getPkId(), boxProductList, lastMemberLevel.getUpgradeTime(), Collections.singletonList(EOrderType.RETAIL_UPGRADE.getValue()), systemType);
@@ -2825,130 +2830,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
 //        return 0;
     }
 
-    /**
-     * 旧等级计算处理（累计升级）
-     *
-     * @param cuMember       会员信息
-     * @param memberGrade    会员等级
-     * @param gradeList      等级列表
-     * @param boxProductList 盒数商品列表
-     * @return
-     */
-    private BdGrade handleOldGrade(CuMember cuMember, BdGrade memberGrade, List<BdGrade> gradeList, List<String> boxProductList) {
-        if (memberGrade.getGradeValue().compareTo(EGrade.MAKER.getValue()) > 0) {
-            // 当前等级大于V3，不需要重算
-            return memberGrade;
-        }
-
-        // 查询是否有升级记录
-        List<CuMemberLevel> memberLevelList = iCuMemberDetailServiceApi.getUpgradeList(cuMember.getPkId()).getData();
-        if (CollectionUtil.isNotEmpty(memberLevelList)) {
-            // 有升级记录
-            int baseBoxNum;
-            // 最新一次的手动升级记录
-            Optional<CuMemberLevel> lastManualOptional = memberLevelList.stream().filter(tmpGrade -> tmpGrade.getUpType().equals(EUpgradeType.MANUAL_UPGRADE.getValue())).findFirst();
-            if (lastManualOptional.isPresent()) {
-                // 有手动升级记录
-                CuMemberLevel lastManual = lastManualOptional.get();
-                // 手动升级等级
-                BdGrade lastUpdateGrade = gradeList.stream().filter(tmpGrade -> tmpGrade.getPkId().equals(lastManual.getNewLevel())).findFirst().get();
-                // 升级之后购买的订单盒数
-                int newBoxNumber = saOrderItemsService.getRetailWaresQuantity(cuMember.getPkId(), boxProductList, lastManual.getUpgradeTime(),
-                        Arrays.asList(EOrderType.RETAIL_REGISTER.getValue(), EOrderType.RETAIL_UPGRADE.getValue()), cuMember.getSystemType());
-                // 基数盒数 = 手动升级的等级盒数 + 手动升级之后购买的盒数
-                baseBoxNum = lastUpdateGrade.getBoxNumber() + newBoxNumber;
-            } else {
-                // 没有手动升级记录
-                // 基数盒数 = 购买的盒数
-                baseBoxNum = saOrderItemsService.getRetailWaresQuantity(cuMember.getPkId(), boxProductList, null,
-                        Arrays.asList(EOrderType.RETAIL_REGISTER.getValue(), EOrderType.RETAIL_UPGRADE.getValue()), cuMember.getSystemType());
-            }
-
-            // 计算的等级
-            return this.getGradeByBox(baseBoxNum, gradeList, memberGrade, false);
-        }
-        return memberGrade;
-    }
-
-    /**
-     * 新等级计算处理（当天累计升级，次日一次性）
-     *
-     * @param cuMember        会员信息
-     * @param memberGrade     会员等级
-     * @param gradeList       等级列表
-     * @param saOrderExt      订单信息
-     * @param createLevelList 添加等级列表
-     * @param deleteLevelList 删除等级列表
-     * @return
-     */
-    private BdGrade handleNewGrade(CuMember cuMember, BdGrade memberGrade, List<BdGrade> gradeList, SaOrderExt saOrderExt,
-                                   List<CuMemberLevel> createLevelList, List<CuMemberLevel> deleteLevelList) {
-        // 会员升级记录
-        List<CuMemberLevel> memberLevelList = iMemberLevelServiceApi.listMemberLevel(cuMember.getPkId(), null).getData();
-
-        if (CollectionUtil.isNotEmpty(memberLevelList)) {
-            // 存在升级记录
-            // 2025.03.18 调整需求，升级走当天累计，当天买的所有都进行积累，24点之后则重新累积（手动升级前后的盒数都算累计）
-            // 查询开始时间
-            Date queryStartTime = DateUtils.getStartTime(saOrderExt.getPayTime());
-            // 查询结束时间
-            Date queryEndTime = DateUtils.getEndTime(queryStartTime);
-
-            // 订单购买当天所有升级记录
-            List<CuMemberLevel> todayLevelList = memberLevelList.stream()
-                    .filter(tmp -> (tmp.getUpgradeTime().compareTo(queryStartTime) >= 0 && tmp.getUpgradeTime().compareTo(queryEndTime) <= 0))
-                    .collect(Collectors.toList());
-            if (CollectionUtil.isNotEmpty(todayLevelList)) {
-                if (todayLevelList.stream().noneMatch(tmp -> tmp.getUpgradeTime().compareTo(saOrderExt.getPayTime()) >= 0)) {
-                    // 订单购买时间之后没有升级记录，直接返回当前会员等级
-                    return memberGrade;
-                } else {
-                    // 订单购买时间之后有升级记录，需要重新计算
-                    // 处理当日等级
-                    Integer oldLevel = todayLevelList.get(0).getOldLevel();
-                    Integer lastLevel = todayLevelList.get(todayLevelList.size() - 1).getNewLevel();
-                    // 手动升级记录
-                    Integer manualUpgradeLevel = null;
-
-                    // 当天最后一条手动升级记录
-                    Optional<CuMemberLevel> manualUpgradeOptional = todayLevelList.stream()
-                            .filter(tmp -> EUpgradeType.MANUAL_UPGRADE.getValue() == tmp.getUpType())
-                            .max(Comparator.comparing(CuMemberLevel::getUpgradeTime));
-                    if (manualUpgradeOptional.isPresent()) {
-                        // 存在手动升级记录（计算等级为手动升级盒数为基数 + 当天购买的订单盒数）
-                        // 删除升级记录时，只删除非手动升级的
-                        deleteLevelList.addAll(todayLevelList.stream()
-                                .filter(tmp -> EUpgradeType.MANUAL_UPGRADE.getValue() != tmp.getUpType())
-                                .collect(Collectors.toList()));
-                        // 重算订单当天升级记录（存在手动升级）
-                        manualUpgradeLevel = manualUpgradeOptional.get().getNewLevel();
-                    } else {
-                        // 不存在手动升级记录（当天购买的订单盒数）
-                        deleteLevelList.addAll(todayLevelList);
-                    }
-
-                    // 今天重算等级
-                    BdGrade todayGrade = this.handleTodayGrade(cuMember, oldLevel, lastLevel, manualUpgradeLevel,
-                            queryStartTime, queryEndTime, gradeList, createLevelList);
-                    if (lastLevel.equals(todayGrade.getPkId())) {
-                        // 重算之后和重算之前等级一致，直接返回当前会员等级
-                        return todayGrade;
-                    } else {
-                        // 重算之后和重算之前等级不一致，需要重算后面所有等级
-                        return this.handleTodayNextNew(cuMember, todayGrade, DateUtils.addDays(queryStartTime, 1), DateUtils.addDays(queryEndTime, 1),
-                                memberLevelList, gradeList, createLevelList, deleteLevelList);
-                    }
-                }
-            } else {
-                // 当天没有升级记录，直接返回当前会员等级
-                return memberGrade;
-            }
-        } else {
-            // 没有升级记录，返回当前会员等级
-            return memberGrade;
-        }
-    }
-
     /**
      * 处理日升级新
      *
@@ -3617,4 +3498,32 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
         return cuMemberLevel;
     }
 
+    /**
+     * new 2025.06.25 V1-V3升级多送两级处理
+     *
+     * @param gradeList
+     * @param bdGrade
+     * @return
+     */
+    private BdGrade handleGradeEnd(List<BdGrade> gradeList, BdGrade bdGrade) {
+        // new 2025.06.14 添加新需求，V1-V3，购买多给两级
+        // new 2025.06.25 V1-V3升级多送两级，可以继续购买升级
+        Integer pkGrade = bdGrade.getPkId();
+        // 临时处理等级
+        BdGrade tmpGrade = gradeList.stream().filter(tmpData -> tmpData.getPkId().equals(pkGrade)).findFirst().get();
+
+        if (EGrade.HAI_FAN.getValue() == tmpGrade.getGradeValue()) {
+            // V1 给 V3
+            tmpGrade = gradeList.stream().filter(tmpData -> EGrade.MAKER.getValue() == tmpData.getGradeValue()).findFirst().get();
+        } else if (EGrade.YOU_KE.getValue() == tmpGrade.getGradeValue()) {
+            // V2 给 V4
+            tmpGrade = gradeList.stream().filter(tmpData -> EGrade.VIP.getValue() == tmpData.getGradeValue()).findFirst().get();
+        } else if (EGrade.MAKER.getValue() == tmpGrade.getGradeValue()) {
+            // V3 给 V5
+            tmpGrade = gradeList.stream().filter(tmpData -> EGrade.S_VIP.getValue() == tmpData.getGradeValue()).findFirst().get();
+        }
+
+        return tmpGrade;
+    }
+
 }