回传策略更新

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/utils/BackPolicyUtil.java

@@ -5,16 +5,19 @@ import com.github.sd4324530.jtuple.Tuple3;
 import com.github.sd4324530.jtuple.Tuples;
 import com.zanxiang.game.back.serve.pojo.entity.GameBackPolicy;
 import com.zanxiang.game.back.serve.pojo.enums.BackUnitEnum;
+import com.zanxiang.game.back.serve.pojo.vo.GameBackPolicyVO;
 import com.zanxiang.module.util.DateUtil;
 import com.zanxiang.module.util.JsonUtil;
 import com.zanxiang.module.util.NumberUtil;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.RandomUtils;
 import org.apache.commons.lang3.StringUtils;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
 
@@ -47,8 +50,8 @@ public class BackPolicyUtil {
         String backRate;
         if (gameBackPolicy.getRegPayIntervalTime() != null
                 && ((DateUtil.localDateTimeToSecond(payTime) - DateUtil.localDateTimeToSecond(regTime)) / 60) > gameBackPolicy.getRegPayIntervalTime()) {
-            log.error("订单 id[{}]通过回传策略[{}]判断后，超过注册充值间隔时间，走补单逻辑 {}.", orderId, gameBackPolicy.getId(), gameBackPolicy.getRegPayIntervalTime());
             // 补单
+            log.error("订单 id[{}]通过回传策略[{}]判断后，超过注册充值间隔时间，走补单逻辑 {}.", orderId, gameBackPolicy.getId(), gameBackPolicy.getRegPayIntervalTime());
             if (gameBackPolicy.getMarkUpOrder() != null && gameBackPolicy.getMarkUpOrder()) {
                 markUpTime = gameBackPolicy.getRegPayIntervalTime();
                 if (rechargeMoney <= gameBackPolicy.getMarkUpOrderMinMoney()) {
@@ -71,17 +74,17 @@ public class BackPolicyUtil {
                     int ignoreCount = Integer.parseInt(temp[1]);
                     if (backCount == 0) {
                         log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：回传比例 {}", orderId, gameBackPolicy.getId(), backRate);
-                        return Tuples.tuple(Boolean.FALSE, rechargeMoney, "补单-按比例回传，回传比例为 0，全部不回传");
+                        return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), "补单-按比例回传，回传比例为 0，全部不回传");
                     }
                     if (ignoreCount == 0) {
                         log.error("订单 id[{}]通过回传策略[{}]判断后，回传，原因：回传比例 {}", orderId, gameBackPolicy.getId(), backRate);
-                        return Tuples.tuple(Boolean.TRUE, rechargeMoney, "补单-按比例回传，忽略比例为 0，全部回传");
+                        return Tuples.tuple(Boolean.TRUE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), "补单-按比例回传，忽略比例为 0，全部回传");
                     }
                     long isBackCount = backPolicyCheck.markUpOfFixedRate(backCount + ignoreCount, markUpTime);
                     backMsg = "补单-按比例回传，每 " + (backCount + ignoreCount) + "笔回传 " + backCount + "笔，当前第 " + (isBackCount + 1) + "笔";
                     if (isBackCount >= backCount) {
                         log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                        return Tuples.tuple(Boolean.FALSE, rechargeMoney, backMsg);
+                        return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), backMsg);
                     }
                 } else if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_RANDOM_RATE)) {
                     // 随机概率回传
@@ -89,7 +92,7 @@ public class BackPolicyUtil {
                     backMsg = "补单-随机概率回传(" + backRate + ")";
                     if (!isBack) {
                         log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                        return Tuples.tuple(Boolean.FALSE, rechargeMoney, backMsg);
+                        return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), backMsg);
                     }
                 } else {
                     throw new RuntimeException("回传策略[" + gameBackPolicy.getId() + "]配置错误，未知的回传类型：" + backType);
@@ -97,64 +100,65 @@ public class BackPolicyUtil {
                 if (gameBackPolicy.getMarkUpBackCountOfUser() == null) {
                     backMsg = backMsg + "，未配置单用户最大回传笔数";
                     log.error("订单 id[{}]通过回传策略[{}]判断后，回传，原因：回传概率 {}", orderId, gameBackPolicy.getId(), backMsg);
-                    return Tuples.tuple(Boolean.TRUE, rechargeMoney, backMsg);
+                    return Tuples.tuple(Boolean.TRUE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), backMsg);
                 }
                 long userBackCount = backPolicyCheck.markUpForUser(userId, markUpTime);
                 backMsg = backMsg + "，单用户最大回传 " + gameBackPolicy.getMarkUpBackCountOfUser() + "笔，当前已回传 " + userBackCount + "笔";
                 log.error("订单 id[{}]通过回传策略[{}]判断后，是否回传：{}，原因：{}", orderId, gameBackPolicy.getId(), userBackCount < gameBackPolicy.getMarkUpBackCountOfUser(), backMsg);
-                return Tuples.tuple(userBackCount < gameBackPolicy.getMarkUpBackCountOfUser(), rechargeMoney, backMsg);
+                return Tuples.tuple(userBackCount < gameBackPolicy.getMarkUpBackCountOfUser(), downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), backMsg);
             } else {
                 log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：超过注册充值间隔时间但是未开启补单", orderId, gameBackPolicy.getId());
-                return Tuples.tuple(Boolean.FALSE, rechargeMoney, "回传策略未开启补单");
+                return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, gameBackPolicy.getMarkUpDownLevel()), "回传策略未开启补单");
             }
+        }
+
+        // 正常判断
+        if (backUnit == BackUnitEnum.UNIT_ONCE) {
+            firstPolicy = isFirstOrder;
+        } else if (backUnit == BackUnitEnum.UNIT_DAY) {
+            long intervalDays = DateUtil.intervalOfDays(regTime.toLocalDate(), payTime.toLocalDate());
+            firstPolicy = intervalDays == 0;
+        } else if (backUnit == BackUnitEnum.UNIT_TIME_DAY) {
+            long intervalHours = DateUtil.intervalOfHour(regTime, payTime);
+            firstPolicy = intervalHours < 24;
+        } else if (backUnit == BackUnitEnum.UNIT_TIME_2DAY) {
+            long intervalHours = DateUtil.intervalOfHour(regTime, payTime);
+            firstPolicy = intervalHours < 48;
         } else {
-            // 正常判断
-            if (backUnit == BackUnitEnum.UNIT_ONCE) {
-                firstPolicy = isFirstOrder;
-            } else if (backUnit == BackUnitEnum.UNIT_DAY) {
-                long intervalDays = DateUtil.intervalOfDays(regTime.toLocalDate(), payTime.toLocalDate());
-                firstPolicy = intervalDays == 0;
-            } else if (backUnit == BackUnitEnum.UNIT_TIME_DAY) {
-                long intervalHours = DateUtil.intervalOfHour(regTime, payTime);
-                firstPolicy = intervalHours < 24;
-            } else if (backUnit == BackUnitEnum.UNIT_TIME_2DAY) {
-                long intervalHours = DateUtil.intervalOfHour(regTime, payTime);
-                firstPolicy = intervalHours < 48;
+            throw new RuntimeException("未知的回传单位：" + backUnit);
+        }
+        if (firstPolicy) {
+            if (rechargeMoney <= gameBackPolicy.getFirstMinMoney()) {
+                // 小额
+                backType = gameBackPolicy.getFirstMinMoneyType();
+                backRate = gameBackPolicy.getFirstMinMoneyRate();
+            } else if (rechargeMoney >= gameBackPolicy.getFirstMaxMoney()) {
+                // 大额
+                backType = gameBackPolicy.getFirstMaxMoneyType();
+                backRate = gameBackPolicy.getFirstMaxMoneyRate();
             } else {
-                throw new RuntimeException("未知的回传单位：" + backUnit);
+                backType = gameBackPolicy.getFirstOtherMoneyType();
+                backRate = gameBackPolicy.getFirstOtherMoneyRate();
             }
-            if (firstPolicy) {
-                if (rechargeMoney <= gameBackPolicy.getFirstMinMoney()) {
-                    // 小额
-                    backType = gameBackPolicy.getFirstMinMoneyType();
-                    backRate = gameBackPolicy.getFirstMinMoneyRate();
-                } else if (rechargeMoney >= gameBackPolicy.getFirstMaxMoney()) {
-                    // 大额
-                    backType = gameBackPolicy.getFirstMaxMoneyType();
-                    backRate = gameBackPolicy.getFirstMaxMoneyRate();
-                } else {
-                    backType = gameBackPolicy.getFirstOtherMoneyType();
-                    backRate = gameBackPolicy.getFirstOtherMoneyRate();
-                }
-                log.error("订单 id[{}]通过回传策略[{}]判断后走首日逻辑：backType: {}, backRate: {}", orderId, gameBackPolicy.getId(), backType, backRate);
+            log.error("订单 id[{}]通过回传策略[{}]判断后走首日逻辑：backType: {}, backRate: {}", orderId, gameBackPolicy.getId(), backType, backRate);
+        } else {
+            if (rechargeMoney <= gameBackPolicy.getRechargeMinMoney()) {
+                // 小额
+                backType = gameBackPolicy.getRechargeMinMoneyType();
+                backRate = gameBackPolicy.getRechargeMinMoneyRate();
+            } else if (rechargeMoney >= gameBackPolicy.getRechargeMaxMoney()) {
+                // 大额
+                backType = gameBackPolicy.getRechargeMaxMoneyType();
+                backRate = gameBackPolicy.getRechargeMaxMoneyRate();
             } else {
-                if (rechargeMoney <= gameBackPolicy.getRechargeMinMoney()) {
-                    // 小额
-                    backType = gameBackPolicy.getRechargeMinMoneyType();
-                    backRate = gameBackPolicy.getRechargeMinMoneyRate();
-                } else if (rechargeMoney >= gameBackPolicy.getRechargeMaxMoney()) {
-                    // 大额
-                    backType = gameBackPolicy.getRechargeMaxMoneyType();
-                    backRate = gameBackPolicy.getRechargeMaxMoneyRate();
-                } else {
-                    backType = gameBackPolicy.getRechargeOtherMoneyType();
-                    backRate = gameBackPolicy.getRechargeOtherMoneyRate();
-                }
-                log.error("订单 id[{}]通过回传策略[{}]判断后走次日逻辑, backType: {}, backRate: {}", orderId, gameBackPolicy.getId(), backType, backRate);
+                backType = gameBackPolicy.getRechargeOtherMoneyType();
+                backRate = gameBackPolicy.getRechargeOtherMoneyRate();
             }
+            log.error("订单 id[{}]通过回传策略[{}]判断后走次日逻辑, backType: {}, backRate: {}", orderId, gameBackPolicy.getId(), backType, backRate);
         }
         Integer maxBackCountOfUser = firstPolicy ? gameBackPolicy.getFirstBackCountOfUser() : gameBackPolicy.getRechargeBackCountOfUser();
         String backMsg = firstPolicy ? "首-" : "次-";
+        String downLevelString = firstPolicy ? gameBackPolicy.getFirstDownLevel() : gameBackPolicy.getRechargeDownLevel();
         if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_FIXED_RATE)) {
             // 固定比例回传
             String[] temp = backRate.split(":");
@@ -163,18 +167,18 @@ public class BackPolicyUtil {
             if (backCount == 0) {
                 backMsg = backMsg + "按比例回传，回传比例为 0，全部不回传";
                 log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                return Tuples.tuple(Boolean.FALSE, rechargeMoney, backMsg);
+                return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, downLevelString), backMsg);
             }
             if (ignoreCount == 0) {
                 backMsg = backMsg + "按比例回传，忽略比例为 0，全部回传";
                 log.error("订单 id[{}]通过回传策略[{}]判断后，回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                return Tuples.tuple(Boolean.TRUE, rechargeMoney, backMsg);
+                return Tuples.tuple(Boolean.TRUE, downLevel(rechargeMoney, downLevelString), backMsg);
             }
             long isBackCount = backPolicyCheck.backCountForFixedRate(backCount + ignoreCount, backUnit, firstPolicy);
             backMsg = backMsg + "按比例回传，每 " + (backCount + ignoreCount) + "笔回传 " + backCount + "笔，当前第 " + (isBackCount + 1) + "笔";
             if (isBackCount >= backCount) {
                 log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                return Tuples.tuple(Boolean.FALSE, rechargeMoney, backMsg);
+                return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, downLevelString), backMsg);
             }
         } else if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_RANDOM_RATE)) {
             // 随机概率回传
@@ -182,7 +186,7 @@ public class BackPolicyUtil {
             backMsg = backMsg + "补单-随机概率回传(" + backRate + ")";
             if (!isBack) {
                 log.error("订单 id[{}]通过回传策略[{}]判断后，不回传，原因：{}", orderId, gameBackPolicy.getId(), backMsg);
-                return Tuples.tuple(Boolean.FALSE, rechargeMoney, backMsg);
+                return Tuples.tuple(Boolean.FALSE, downLevel(rechargeMoney, downLevelString), backMsg);
             }
         } else {
             throw new RuntimeException("回传策略[" + gameBackPolicy.getId() + "]配置错误，未知的回传类型：" + backType);
@@ -191,12 +195,12 @@ public class BackPolicyUtil {
         if (maxBackCountOfUser == null) {
             backMsg = backMsg + "，未配置单用户最大回传笔数";
             log.error("订单 id[{}]通过回传策略[{}]判断后，回传，原因：回传概率 {}", orderId, gameBackPolicy.getId(), backMsg);
-            return Tuples.tuple(Boolean.TRUE, rechargeMoney, backMsg);
+            return Tuples.tuple(Boolean.TRUE, downLevel(rechargeMoney, downLevelString), backMsg);
         }
         long userBackCount = backPolicyCheck.backCountForUser(backUnit, userId, firstPolicy);
         backMsg = backMsg + "，单用户最大回传 " + maxBackCountOfUser + "笔，当前已回传 " + userBackCount + "笔";
         log.error("订单 id[{}]通过回传策略[{}]判断后，是否回传：{}，原因：{}", orderId, gameBackPolicy.getId(), userBackCount < maxBackCountOfUser, backMsg);
-        return Tuples.tuple(userBackCount < maxBackCountOfUser, rechargeMoney, backMsg);
+        return Tuples.tuple(userBackCount < maxBackCountOfUser, downLevel(rechargeMoney, downLevelString), backMsg);
         /*if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_FIXED_RATE)) {
             // 固定比例回传
             String[] temp = backRate.split(":");
@@ -223,6 +227,23 @@ public class BackPolicyUtil {
         }*/
     }
 
+    private static Long downLevel(Long rechargeMoney, String downLevelStr) {
+        if (StringUtils.isBlank(downLevelStr)) {
+            return rechargeMoney;
+        }
+        String[] downLevelList = downLevelStr.split(",");
+        for (String downLevel : downLevelList) {
+            String[] tmp = downLevel.split("_");
+            long minMoney = Long.parseLong(tmp[0]);
+            long maxMoney = Long.parseLong(tmp[1]);
+            Long backMoney = Long.parseLong(tmp[2]);
+            if (rechargeMoney >= minMoney && rechargeMoney <= maxMoney) {
+                return backMoney;
+            }
+        }
+        return rechargeMoney;
+    }
+
     private static Tuple2<Integer, Integer> approximate(int molecular, int denominator) {
         if (molecular % denominator == 0) {
             int temp = molecular / denominator;