更新回传策略

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/controller/BackPolicyController.java

@@ -3,6 +3,7 @@ package com.zanxiang.game.back.serve.controller;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.zanxiang.erp.security.annotation.PreAuthorize;
 import com.zanxiang.game.back.serve.pojo.dto.*;
+import com.zanxiang.game.back.serve.pojo.enums.BackUnitEnum;
 import com.zanxiang.game.back.serve.pojo.vo.*;
 import com.zanxiang.game.back.serve.service.*;
 import com.zanxiang.module.util.exception.BaseException;
@@ -13,7 +14,6 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import java.math.BigDecimal;
 import java.util.List;
 
 @RestController
@@ -62,6 +62,10 @@ public class BackPolicyController {
     }
 
     private void checkDTO(GameBackPolicyDTO dto) {
+        BackUnitEnum backUnit = BackUnitEnum.getByValue(dto.getBackUnit());
+        if (backUnit == null) {
+            dto.setBackUnit(BackUnitEnum.UNIT_ONCE.getValue());
+        }
         if (dto.getFirstMinMoney().compareTo(dto.getFirstMaxMoney()) >= 0) {
             throw new BaseException("首充的大额金额必须大于小额金额");
         }
@@ -71,5 +75,16 @@ public class BackPolicyController {
         if (dto.getRegPayIntervalTime() != null && dto.getRegPayIntervalTime() <= 0) {
             throw new BaseException("注册充值回传的最大间隔时间不能小于 1");
         }
+        if (dto.getMarkUpOrder() == null) {
+            dto.setMarkUpOrder(false);
+        }
+        if (dto.getMarkUpOrder()) {
+            if (dto.getRegPayIntervalTime() == null) {
+                throw new BaseException("开启补单后必需填充值注册回传最大间隔时间");
+            }
+            if (dto.getMarkUpOrderMinMoney().compareTo(dto.getMarkUpOrderMaxMoney()) >= 0) {
+                throw new BaseException("首充的大额金额必须大于小额金额");
+            }
+        }
     }
 }

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/pojo/dto/GameBackPolicyDTO.java

@@ -35,6 +35,9 @@ public class GameBackPolicyDTO implements Serializable {
     @ApiModelProperty("回传策略名")
     private String backPolicyName;
 
+    @ApiModelProperty("回传类型（1：首单、次单、2：首日、次日）")
+    private Integer backUnit;
+
     /**
      * 首充-小额判定金额（小于等于）
      */
@@ -157,5 +160,59 @@ public class GameBackPolicyDTO implements Serializable {
     @ApiModelProperty("注册充值回传的最大间隔时间（超时不回传）")
     private Long regPayIntervalTime;
 
+    /**
+     * 是否补单
+     */
+    @ApiModelProperty("是否补单")
+    private Boolean markUpOrder;
+
+    /**
+     * 补单-小额判定金额（小于等于）
+     */
+    @ApiModelProperty("补单-小额判定金额（小于等于）")
+    private BigDecimal markUpOrderMinMoney;
+
+    /**
+     * 补单-小额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-小额回传方式（概率/比例）")
+    private Integer markUpOrderMinMoneyType;
+
+    /**
+     * 补单-小额回传概率/比例
+     */
+    @ApiModelProperty("补单-小额回传概率/比例")
+    private String markUpOrderMinMoneyRate;
+
+    /**
+     * 补单-大额判定金额（大于等于）
+     */
+    @ApiModelProperty("补单-大额判定金额（大于等于）")
+    private BigDecimal markUpOrderMaxMoney;
+
+    /**
+     * 补单-大额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-大额回传方式（概率/比例）")
+    private Integer markUpOrderMaxMoneyType;
+
+    /**
+     * 补单-大额回传概率/比例
+     */
+    @ApiModelProperty("补单-大额回传概率/比例")
+    private String markUpOrderMaxMoneyRate;
+
+    /**
+     * 补单-其它金额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-其它金额回传方式（概率/比例）")
+    private Integer markUpOrderOtherMoneyType;
+
+    /**
+     * 补单-其它金额回传概率/比例
+     */
+    @ApiModelProperty("补单-其它金额回传概率/比例")
+    private String markUpOrderOtherMoneyRate;
+
 
 }

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/pojo/entity/GameBackPolicy.java

@@ -38,82 +38,82 @@ public class GameBackPolicy implements Serializable {
     private String backPolicyName;
 
     /**
-     * 首充-小额判定金额（小于等于）
+     * 首充/日-小额判定金额（小于等于）
      */
     private Long firstMinMoney;
 
     /**
-     * 首充-小额回传方式（概率/比例）
+     * 首充/日-小额回传方式（概率/比例）
      */
     private Integer firstMinMoneyType;
 
     /**
-     * 首充-小额回传概率/比例
+     * 首充/日-小额回传概率/比例
      */
     private String firstMinMoneyRate;
 
     /**
-     * 首充-大额判定金额（大于等于）
+     * 首充/日-大额判定金额（大于等于）
      */
     private Long firstMaxMoney;
 
     /**
-     * 首充-大额回传方式（概率/比例）
+     * 首充/日-大额回传方式（概率/比例）
      */
     private Integer firstMaxMoneyType;
 
     /**
-     * 首充-大额回传概率/比例
+     * 首充/日-大额回传概率/比例
      */
     private String firstMaxMoneyRate;
 
     /**
-     * 首充-其它金额回传方式（概率/比例）
+     * 首充/日-其它金额回传方式（概率/比例）
      */
     private Integer firstOtherMoneyType;
 
     /**
-     * 首充-其它金额回传概率/比例
+     * 首充/日-其它金额回传概率/比例
      */
     private String firstOtherMoneyRate;
 
     /**
-     * 次单-小额判定金额（小于等于）
+     * 次单/日-小额判定金额（小于等于）
      */
     private Long rechargeMinMoney;
 
     /**
-     * 次单-小额回传方式（概率/比例）
+     * 次单/日-小额回传方式（概率/比例）
      */
     private Integer rechargeMinMoneyType;
 
     /**
-     * 次单-小额回传概率/比例
+     * 次单/日-小额回传概率/比例
      */
     private String rechargeMinMoneyRate;
 
     /**
-     * 次单-大额判定金额（大于等于）
+     * 次单/日-大额判定金额（大于等于）
      */
     private Long rechargeMaxMoney;
 
     /**
-     * 次单-大额回传方式（概率/比例）
+     * 次单/日-大额回传方式（概率/比例）
      */
     private Integer rechargeMaxMoneyType;
 
     /**
-     * 次单-大额回传概率/比例
+     * 次单/日-大额回传概率/比例
      */
     private String rechargeMaxMoneyRate;
 
     /**
-     * 次单-其它金额回传方式（概率/比例）
+     * 次单/日-其它金额回传方式（概率/比例）
      */
     private Integer rechargeOtherMoneyType;
 
     /**
-     * 次单-其它金额回传概率/比例
+     * 次单/日-其它金额回传概率/比例
      */
     private String rechargeOtherMoneyRate;
 
@@ -132,5 +132,54 @@ public class GameBackPolicy implements Serializable {
 
     private Long regPayIntervalTime;
 
+    /**
+     * 回传类型（1：首单、次单、2：首日、次日）
+     */
+    private Integer backUnit;
+
+    /**
+     * 是否补单
+     */
+    private Boolean markUpOrder;
+    /**
+     * 补单-小额判定金额（小于等于）
+     */
+    private Long markUpOrderMinMoney;
+
+    /**
+     * 补单-小额回传方式（概率/比例）
+     */
+    private Integer markUpOrderMinMoneyType;
+
+    /**
+     * 补单-小额回传概率/比例
+     */
+    private String markUpOrderMinMoneyRate;
+
+    /**
+     * 补单-大额判定金额（大于等于）
+     */
+    private Long markUpOrderMaxMoney;
+
+    /**
+     * 补单-大额回传方式（概率/比例）
+     */
+    private Integer markUpOrderMaxMoneyType;
+
+    /**
+     * 补单-大额回传概率/比例
+     */
+    private String markUpOrderMaxMoneyRate;
+
+    /**
+     * 补单-其它金额回传方式（概率/比例）
+     */
+    private Integer markUpOrderOtherMoneyType;
+
+    /**
+     * 补单-其它金额回传概率/比例
+     */
+    private String markUpOrderOtherMoneyRate;
+
 
 }

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/pojo/enums/BackUnitEnum.java

@@ -0,0 +1,35 @@
+package com.zanxiang.game.back.serve.pojo.enums;
+
+import lombok.Getter;
+
+import java.util.Objects;
+
+@Getter
+public enum BackUnitEnum {
+    /**
+     * 未回传
+     */
+    UNIT_ONCE(1),
+    /**
+     * 回传成功
+     */
+    UNIT_DAY(2);
+
+    private final Integer value;
+
+    BackUnitEnum(Integer value) {
+        this.value = value;
+    }
+
+    public static BackUnitEnum getByValue(Integer value) {
+        if (value == null) {
+            return null;
+        }
+        for (BackUnitEnum backUnit : BackUnitEnum.values()) {
+            if (Objects.equals(backUnit.getValue(), value)) {
+                return backUnit;
+            }
+        }
+        return null;
+    }
+}

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/pojo/vo/GameBackPolicyVO.java

@@ -31,6 +31,9 @@ public class GameBackPolicyVO implements Serializable {
     @ApiModelProperty("回传策略名")
     private String backPolicyName;
 
+    @ApiModelProperty("回传类型（1：首单、次单、2：首日、次日）")
+    private Integer backUnit;
+
     /**
      * 首充-小额判定金额（小于等于）
      */
@@ -138,7 +141,63 @@ public class GameBackPolicyVO implements Serializable {
     private Long createBy;
 
     private String createName;
+
+    @ApiModelProperty("充值注册最大间隔时间（超时不回传）")
     private Long regPayIntervalTime;
 
+    /**
+     * 是否补单
+     */
+    @ApiModelProperty("是否补单")
+    private Boolean markUpOrder;
+
+    /**
+     * 补单-小额判定金额（小于等于）
+     */
+    @ApiModelProperty("补单-小额判定金额（小于等于）")
+    private BigDecimal markUpOrderMinMoney;
+
+    /**
+     * 补单-小额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-小额回传方式（概率/比例）")
+    private Integer markUpOrderMinMoneyType;
+
+    /**
+     * 补单-小额回传概率/比例
+     */
+    @ApiModelProperty("补单-小额回传概率/比例")
+    private String markUpOrderMinMoneyRate;
+
+    /**
+     * 补单-大额判定金额（大于等于）
+     */
+    @ApiModelProperty("补单-大额判定金额（大于等于）")
+    private BigDecimal markUpOrderMaxMoney;
+
+    /**
+     * 补单-大额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-大额回传方式（概率/比例）")
+    private Integer markUpOrderMaxMoneyType;
+
+    /**
+     * 补单-大额回传概率/比例
+     */
+    @ApiModelProperty("补单-大额回传概率/比例")
+    private String markUpOrderMaxMoneyRate;
+
+    /**
+     * 补单-其它金额回传方式（概率/比例）
+     */
+    @ApiModelProperty("补单-其它金额回传方式（概率/比例）")
+    private Integer markUpOrderOtherMoneyType;
+
+    /**
+     * 补单-其它金额回传概率/比例
+     */
+    @ApiModelProperty("补单-其它金额回传概率/比例")
+    private String markUpOrderOtherMoneyRate;
+
 
 }

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/service/impl/GameBackPolicyServiceImpl.java

@@ -99,6 +99,16 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
                 .createBy(SecurityUtil.getUserId())
                 .createTime(LocalDateTime.now())
                 .regPayIntervalTime(dto.getRegPayIntervalTime())
+                .backUnit(dto.getBackUnit())
+                .markUpOrder(dto.getMarkUpOrder())
+                .markUpOrderMinMoney(dto.getMarkUpOrderMinMoney() == null ? null : NumberUtil.multiply100(dto.getMarkUpOrderMinMoney()).longValue())
+                .markUpOrderMinMoneyType(dto.getMarkUpOrderMinMoneyType())
+                .markUpOrderMinMoneyRate(dto.getMarkUpOrderMinMoneyRate())
+                .markUpOrderMaxMoney(dto.getMarkUpOrderMaxMoney() == null ? null : NumberUtil.multiply100(dto.getMarkUpOrderMaxMoney()).longValue())
+                .markUpOrderMaxMoneyType(dto.getFirstMaxMoneyType())
+                .markUpOrderMaxMoneyRate(dto.getMarkUpOrderMaxMoneyRate())
+                .markUpOrderOtherMoneyType(dto.getFirstOtherMoneyType())
+                .markUpOrderOtherMoneyRate(dto.getMarkUpOrderMaxMoneyRate())
                 .build();
         return gameBackPolicyService.save(backPolicy);
     }
@@ -134,6 +144,16 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
                 .createTime(old.getCreateTime())
                 .updateBy(SecurityUtil.getUserId())
                 .updateTime(LocalDateTime.now())
+                .backUnit(dto.getBackUnit())
+                .markUpOrder(dto.getMarkUpOrder())
+                .markUpOrderMinMoney(dto.getMarkUpOrderMinMoney() == null ? null : NumberUtil.multiply100(dto.getMarkUpOrderMinMoney()).longValue())
+                .markUpOrderMinMoneyType(dto.getMarkUpOrderMinMoneyType())
+                .markUpOrderMinMoneyRate(dto.getMarkUpOrderMinMoneyRate())
+                .markUpOrderMaxMoney(dto.getMarkUpOrderMaxMoney() == null ? null : NumberUtil.multiply100(dto.getMarkUpOrderMaxMoney()).longValue())
+                .markUpOrderMaxMoneyType(dto.getFirstMaxMoneyType())
+                .markUpOrderMaxMoneyRate(dto.getMarkUpOrderMaxMoneyRate())
+                .markUpOrderOtherMoneyType(dto.getFirstOtherMoneyType())
+                .markUpOrderOtherMoneyRate(dto.getMarkUpOrderMaxMoneyRate())
                 .build();
 
         return gameBackPolicyService.updateById(backPolicy);
@@ -161,6 +181,12 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
         vo.setFirstMaxMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getFirstMaxMoney())));
         vo.setRechargeMinMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getRechargeMinMoney())));
         vo.setRechargeMaxMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getRechargeMaxMoney())));
+        if (gameBackPolicy.getMarkUpOrderMinMoney() != null) {
+            vo.setMarkUpOrderMinMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getMarkUpOrderMinMoney())));
+        }
+        if (gameBackPolicy.getMarkUpOrderMaxMoney() != null) {
+            vo.setMarkUpOrderMaxMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getMarkUpOrderMaxMoney())));
+        }
         return vo;
     }
 

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/service/impl/GameOceanengineOrderLogServiceImpl.java

@@ -75,13 +75,16 @@ public class GameOceanengineOrderLogServiceImpl extends ServiceImpl<GameOceaneng
                 doBack = BackPolicyUtil.backOrder(orderLog.getOrderNo(), gameBackPolicy, orderLog.getAmount(),
                         orderLog.getIsFirstOrder(),
                         orderLog.getPayTime(), orderLog.getRegTime(),
-                        (backUnit, isFirstOrder) -> Long.valueOf(list(new LambdaQueryWrapper<GameOceanengineOrderLog>()
+                        (backUnit, isFirstOrder, firstDay, markUpTime) -> Long.valueOf(list(new LambdaQueryWrapper<GameOceanengineOrderLog>()
                                         .eq(GameOceanengineOrderLog::getGameId, orderLog.getGameId())
                                         .eq(GameOceanengineOrderLog::getAppId, orderLog.getAppId())
                                         .eq(GameOceanengineOrderLog::getAccountId, orderLog.getAccountId())
                                         .eq(GameOceanengineOrderLog::getBackPolicyId, gameBackPolicy.getId())
                                         .eq(GameOceanengineOrderLog::getOrderStatus, OrderStatusEnum.SUCCESS_PAY.getValue())
-                                        .eq(GameOceanengineOrderLog::getIsFirstOrder, isFirstOrder)
+                                        .eq(isFirstOrder != null, GameOceanengineOrderLog::getIsFirstOrder, isFirstOrder)
+                                        .apply(firstDay != null && firstDay, "date(reg_time) = date(pay_time)")
+                                        .apply(firstDay != null && !firstDay, "date(reg_time) != date(pay_time)")
+                                        .apply(markUpTime != null, "TIMESTAMPDIFF(MINUTE, reg_time, pay_time) > {0}", markUpTime)
                                         .ne(GameOceanengineOrderLog::getOrderNo, orderLog.getOrderNo())
                                         .orderByDesc(GameOceanengineOrderLog::getCreateTime)
                                         .last("limit " + backUnit)

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/service/impl/GameTencentMiniGameOrderServiceImpl.java

@@ -13,6 +13,7 @@ import com.zanxiang.game.back.base.pojo.enums.OrderStatusEnum;
 import com.zanxiang.game.back.serve.dao.mapper.GameTencentMiniGameOrderMapper;
 import com.zanxiang.game.back.serve.pojo.dto.GameTencentMiniGameOrderDTO;
 import com.zanxiang.game.back.serve.pojo.entity.GameBackPolicy;
+import com.zanxiang.game.back.serve.pojo.entity.GameOceanengineOrderLog;
 import com.zanxiang.game.back.serve.pojo.entity.GameTencentMiniGameOrder;
 import com.zanxiang.game.back.serve.pojo.enums.BackStatusEnum;
 import com.zanxiang.game.back.serve.pojo.vo.GameTencentMiniGameOrderVO;
@@ -81,13 +82,16 @@ public class GameTencentMiniGameOrderServiceImpl extends ServiceImpl<GameTencent
                 // 此处是否是首单用 limit 2。因为在执行判断之前订单已入库，所以库里只有一笔才是首单
                 doBack = BackPolicyUtil.backOrder(orderLog.getOrderId(), gameBackPolicy, orderLog.getRechargeMoney(),
                         orderLog.getIsFirstOrder(), orderLog.getPayTime(), orderLog.getRegisterTime(),
-                        (backUnit, isFirstOrder) -> Long.valueOf(list(new LambdaQueryWrapper<GameTencentMiniGameOrder>()
+                        (backUnit, isFirstOrder, firstDay, markUpTime) -> Long.valueOf(list(new LambdaQueryWrapper<GameTencentMiniGameOrder>()
                                         .eq(GameTencentMiniGameOrder::getGameId, orderLog.getGameId())
                                         .eq(GameTencentMiniGameOrder::getWechatAppId, orderLog.getWechatAppId())
                                         .eq(GameTencentMiniGameOrder::getAdAccountId, orderLog.getAdAccountId())
                                         .eq(GameTencentMiniGameOrder::getOrderStatus, OrderStatusEnum.SUCCESS_PAY.getValue())
                                         .eq(GameTencentMiniGameOrder::getBackPolicyId, gameBackPolicy.getId())
-                                        .eq(GameTencentMiniGameOrder::getIsFirstOrder, isFirstOrder)
+                                        .eq(isFirstOrder != null, GameTencentMiniGameOrder::getIsFirstOrder, isFirstOrder)
+                                        .apply(firstDay != null && firstDay, "date(register_time) = date(pay_time)")
+                                        .apply(firstDay != null && !firstDay, "date(register_time) != date(pay_time)")
+                                        .apply(markUpTime != null, "TIMESTAMPDIFF(MINUTE, register_time, pay_time) > {0}", markUpTime)
                                         .ne(GameTencentMiniGameOrder::getOrderId, orderLog.getOrderId())
                                         .orderByDesc(GameTencentMiniGameOrder::getCreateTime)
                                         .last("limit " + backUnit)

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/service/impl/GameTencentOrderServiceImpl.java

@@ -91,13 +91,16 @@ public class GameTencentOrderServiceImpl extends ServiceImpl<GameTencentOrderMap
                 GameBackPolicy gameBackPolicy = gameBackPolicyService.getById(orderLog.getBackPolicyId());
                 doBack = BackPolicyUtil.backOrder(orderLog.getOrderId(), gameBackPolicy, orderLog.getRechargeMoney(),
                         orderLog.getIsFirstOrder(), orderLog.getPayTime(), orderLog.getRegisterTime(),
-                        (backUnit, isFirstOrder) -> Long.valueOf(list(new LambdaQueryWrapper<GameTencentOrder>()
+                        (backUnit, isFirstOrder, firstDay, markUpTime) -> Long.valueOf(list(new LambdaQueryWrapper<GameTencentOrder>()
                                         .eq(GameTencentOrder::getGameId, orderLog.getGameId())
                                         .eq(GameTencentOrder::getWechatAppId, orderLog.getWechatAppId())
                                         .eq(GameTencentOrder::getAdAccountId, orderLog.getAdAccountId())
                                         .eq(GameTencentOrder::getBackPolicyId, gameBackPolicy.getId())
                                         .eq(GameTencentOrder::getOrderStatus, OrderStatusEnum.SUCCESS_PAY.getValue())
-                                        .eq(GameTencentOrder::getIsFirstOrder, isFirstOrder)
+                                        .eq(isFirstOrder != null, GameTencentOrder::getIsFirstOrder, isFirstOrder)
+                                        .apply(firstDay != null && firstDay, "date(register_time) = date(pay_time)")
+                                        .apply(firstDay != null && !firstDay, "date(register_time) != date(pay_time)")
+                                        .apply(markUpTime != null, "TIMESTAMPDIFF(MINUTE, register_time, pay_time) > {0}", markUpTime)
                                         .ne(GameTencentOrder::getOrderId, orderLog.getOrderId())
                                         .orderByDesc(GameTencentOrder::getCreateTime)
                                         .last("limit " + backUnit)

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

@@ -3,6 +3,7 @@ package com.zanxiang.game.back.serve.utils;
 import com.github.sd4324530.jtuple.Tuple2;
 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.module.util.DateUtil;
 import com.zanxiang.module.util.JsonUtil;
 import com.zanxiang.module.util.NumberUtil;
@@ -36,56 +37,101 @@ public class BackPolicyUtil {
             log.error("订单 id[{}]通过回传策略[null]判断后，是否回传：{}.", orderId, true);
             return true;
         }
-        log.error("----orderId: {}, backPolicy: {}, money: {}", orderId, JsonUtil.toString(gameBackPolicy), rechargeMoney);
-        if (payTime != null && gameBackPolicy.getRegPayIntervalTime() != null) {
-            long regPayIntervalMinute = (DateUtil.localDateTimeToSecond(payTime) - DateUtil.localDateTimeToSecond(regTime)) / 60;
-            if (regPayIntervalMinute > gameBackPolicy.getRegPayIntervalTime()) {
-                log.error("订单 id[{}]通过回传策略[{}]判断后，超过注册充值间隔时间，不回传{}.", orderId, gameBackPolicy.getId(), gameBackPolicy.getRegPayIntervalTime());
-                return false;
-            }
-        }
-        Integer firstType;
-        String firstRate;
-        Integer rechargeType;
-        String rechargeRate;
-        if (rechargeMoney <= gameBackPolicy.getFirstMinMoney()) {
-            // 小于首充金额
-            firstType = gameBackPolicy.getFirstMinMoneyType();
-            firstRate = gameBackPolicy.getFirstMinMoneyRate();
-        } else if (rechargeMoney >= gameBackPolicy.getFirstMaxMoney()) {
-            firstType = gameBackPolicy.getFirstMaxMoneyType();
-            firstRate = gameBackPolicy.getFirstMaxMoneyRate();
-        } else {
-            firstType = gameBackPolicy.getFirstOtherMoneyType();
-            firstRate = gameBackPolicy.getFirstOtherMoneyRate();
-        }
-        if (rechargeMoney <= gameBackPolicy.getRechargeMinMoney()) {
-            rechargeType = gameBackPolicy.getRechargeMinMoneyType();
-            rechargeRate = gameBackPolicy.getRechargeMinMoneyRate();
-        } else if (rechargeMoney >= gameBackPolicy.getRechargeMaxMoney()) {
-            rechargeType = gameBackPolicy.getRechargeMaxMoneyType();
-            rechargeRate = gameBackPolicy.getRechargeMaxMoneyRate();
-        } else {
-            rechargeType = gameBackPolicy.getRechargeOtherMoneyType();
-            rechargeRate = gameBackPolicy.getRechargeOtherMoneyRate();
-        }
-        boolean firstPolicy = false;
+        BackUnitEnum backUnit = gameBackPolicy.getBackUnit() == null ? BackUnitEnum.UNIT_ONCE : BackUnitEnum.getByValue(gameBackPolicy.getBackUnit());
+
+        Boolean firstPolicy = null, firstDay = null;
+        Long markUpTime = null;
         Integer backType;
         String backRate;
-        if (firstType.equals(rechargeType) && firstRate.equalsIgnoreCase(rechargeRate)) {
-            // 回传内容相同，不需要区分是不是首单
-            backType = firstType;
-            backRate = firstRate;
+        if (gameBackPolicy.getRegPayIntervalTime() != null
+                && ((DateUtil.localDateTimeToSecond(payTime) - DateUtil.localDateTimeToSecond(regTime)) / 60) > gameBackPolicy.getRegPayIntervalTime()) {
+            if (gameBackPolicy.getMarkUpOrder() != null && gameBackPolicy.getMarkUpOrder()) {
+                markUpTime = gameBackPolicy.getRegPayIntervalTime();
+                if (rechargeMoney <= gameBackPolicy.getMarkUpOrderMinMoney()) {
+                    // 小额
+                    backType = gameBackPolicy.getMarkUpOrderMinMoneyType();
+                    backRate = gameBackPolicy.getMarkUpOrderMinMoneyRate();
+                } else if (rechargeMoney >= gameBackPolicy.getMarkUpOrderMaxMoney()) {
+                    // 大额
+                    backType = gameBackPolicy.getMarkUpOrderMaxMoneyType();
+                    backRate = gameBackPolicy.getMarkUpOrderMaxMoneyRate();
+                } else {
+                    backType = gameBackPolicy.getMarkUpOrderOtherMoneyType();
+                    backRate = gameBackPolicy.getMarkUpOrderOtherMoneyRate();
+                }
+                log.error("订单 id[{}]通过回传策略[{}]判断后，超过注册充值间隔时间，走补单逻辑 {}.", orderId, gameBackPolicy.getId(), gameBackPolicy.getRegPayIntervalTime());
+            } else {
+                log.error("订单 id[{}]通过回传策略[{}]判断后，超过注册充值间隔时间，不回穿 {}.", orderId, gameBackPolicy.getId(), gameBackPolicy.getRegPayIntervalTime());
+                return false;
+            }
         } else {
-            if (isFirstOrder) {
-                log.error("订单{}是首单", orderId);
-                backType = firstType;
-                backRate = firstRate;
-                firstPolicy = true;
+            if (backUnit == BackUnitEnum.UNIT_ONCE) {
+                if (isFirstOrder) {
+                    firstPolicy = true;
+                    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(), true, backType, backRate);
+                } else {
+                    firstPolicy = false;
+                    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(), false, backType, backRate);
+                }
+            } else if (backUnit == BackUnitEnum.UNIT_DAY) {
+                long intervalDays = DateUtil.intervalOfDays(regTime.toLocalDate(), payTime.toLocalDate());
+                if (intervalDays == 0) {
+                    firstDay = true;
+                    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(), true, backType, backRate);
+                } else {
+                    firstDay = false;
+                    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(), false, backType, backRate);
+                }
             } else {
-                log.error("订单{}不是首单", orderId);
-                backType = rechargeType;
-                backRate = rechargeRate;
+                throw new RuntimeException("未知的回传单位：" + backUnit);
             }
         }
         if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_FIXED_RATE)) {
@@ -101,7 +147,7 @@ public class BackPolicyUtil {
                 log.error("订单 id[{}]通过回传策略[{}]判断后，是否回传：{}.", orderId, gameBackPolicy.getId(), true);
                 return true;
             }
-            int isBackCount = lastBackFunction.getLastBackCount(backCount + ignoreCount - 1, firstPolicy);
+            int isBackCount = lastBackFunction.getLastBackCount(backCount + ignoreCount - 1, firstPolicy, firstDay, markUpTime);
             log.error("订单 id[{}]通过回传策略[{}]判断后，是否回传：{}.", orderId, gameBackPolicy.getId(), (isBackCount < backCount));
             return isBackCount < backCount;
         } else if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_RANDOM_RATE)) {
@@ -151,6 +197,6 @@ public class BackPolicyUtil {
     }
 
     public interface LastBackFunction {
-        int getLastBackCount(int backUnit, boolean isFirstOrder);
+        int getLastBackCount(int backUnit, Boolean isFirstOrder, Boolean firstDay, Long markUpTime);
     }
 }