Merge remote-tracking branch 'origin/package-data' into package-data

game-back/game-back-base/src/main/java/com/zanxiang/game/back/base/oceanengine/rpc/IWechatMiniGameDataReportRpc.java → game-back/game-back-base/src/main/java/com/zanxiang/game/back/base/oceanengine/rpc/IOceanEngineDataReportRpc.java

@@ -8,7 +8,7 @@ import com.zanxiang.module.util.pojo.ResultVO;
  * 微信小游戏头条上报
  * 参考文档：https://bytedance.feishu.cn/docx/doxcnsCqXkvxoAg36GDzkRRRuAq
  */
-public interface IWechatMiniGameDataReportRpc {
+public interface IOceanEngineDataReportRpc {
 
     /**
      * 用户激活、注册等上报

game-back/game-back-base/src/main/java/com/zanxiang/game/back/base/pojo/vo/GameBackPolicyRpcVO.java

@@ -3,7 +3,7 @@ package com.zanxiang.game.back.base.pojo.vo;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.math.BigDecimal;
+import java.time.LocalDateTime;
 
 @Data
 public class GameBackPolicyRpcVO implements Serializable {
@@ -11,38 +11,94 @@ public class GameBackPolicyRpcVO implements Serializable {
 
     private Long id;
 
+    private String backPolicyName;
+
     /**
-     * 回传策略名
+     * 首充-小额判定金额（小于等于）
      */
-    private String backPolicyName;
+    private Long firstMinMoney;
+
+    /**
+     * 首充-小额回传方式（概率/比例）
+     */
+    private Integer firstMinMoneyType;
+
+    /**
+     * 首充-小额回传概率/比例
+     */
+    private String firstMinMoneyRate;
+
+    /**
+     * 首充-大额判定金额（大于等于）
+     */
+    private Long firstMaxMoney;
+
+    /**
+     * 首充-大额回传方式（概率/比例）
+     */
+    private Integer firstMaxMoneyType;
+
+    /**
+     * 首充-大额回传概率/比例
+     */
+    private String firstMaxMoneyRate;
 
     /**
-     * 首充金额（小于等于指定金额）
+     * 首充-其它金额回传方式（概率/比例）
      */
-    private Long firstRechargeMoney;
+    private Integer firstOtherMoneyType;
 
     /**
-     * 首充回传比例（例如：50%-->0.5)
+     * 首充-其它金额回传概率/比例
      */
-    private BigDecimal firstRechargeBackPercentage;
+    private String firstOtherMoneyRate;
 
     /**
-     * 大单金额（大于等于指定金额）
+     * 次单-小额判定金额（小于等于）
      */
-    private Long bigRechargeMoney;
+    private Long rechargeMinMoney;
 
     /**
-     * 大单回传比例（例如：50%-->0.5)
+     * 次单-小额回传方式（概率/比例）
      */
-    private BigDecimal bigRechargeBackPercentage;
+    private Integer rechargeMinMoneyType;
 
     /**
-     * 其他回传比例（例如：50%-->0.5)
+     * 次单-小额回传概率/比例
      */
-    private BigDecimal otherRechargeBackPercentage;
+    private String rechargeMinMoneyRate;
+
+    /**
+     * 次单-大额判定金额（大于等于）
+     */
+    private Long rechargeMaxMoney;
+
+    /**
+     * 次单-大额回传方式（概率/比例）
+     */
+    private Integer rechargeMaxMoneyType;
+
+    /**
+     * 次单-大额回传概率/比例
+     */
+    private String rechargeMaxMoneyRate;
+
+    /**
+     * 次单-其它金额回传方式（概率/比例）
+     */
+    private Integer rechargeOtherMoneyType;
+
+    /**
+     * 次单-其它金额回传概率/比例
+     */
+    private String rechargeOtherMoneyRate;
 
     /**
      * 降档级别
      */
     private Integer levelDown;
+
+    private LocalDateTime createTime;
+
+    private Long createBy;
 }

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

@@ -9,6 +9,7 @@ import com.zanxiang.module.util.pojo.ResultVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -30,26 +31,26 @@ public class BackPolicyController {
     @PreAuthorize(permissionKey = "gameBack:policy:list")
     @PostMapping("/list")
     @ApiOperation(value = "回传策略列表")
-    public ResultVO<IPage<GameBackPolicyVO>> policyList(@RequestBody GameBackPolicyListDTO dto) {
+    public ResultVO<IPage<GameBackPolicyVO>> policyList(@Validated @RequestBody GameBackPolicyListDTO dto) {
         return ResultVO.ok(gameBackPolicyService.policyList(dto));
     }
 
     @PreAuthorize(permissionKey = "gameBack:policy:create")
-    @PostMapping("/create")
+    @PostMapping("/add")
     @ApiOperation(value = "创建回传策略")
-    public ResultVO<Boolean> createPolicy(@RequestBody GameBackPolicyDTO dto) {
+    public ResultVO<Boolean> createPolicy(@Validated @RequestBody GameBackPolicyDTO dto) {
         return ResultVO.ok(gameBackPolicyService.createPolicy(dto));
     }
 
     @PreAuthorize(permissionKey = "gameBack:policy:update")
-    @PostMapping("/update")
+    @PostMapping("/modify/{policyId}")
     @ApiOperation(value = "修改回传策略")
-    public ResultVO<Boolean> updatePolicy(@RequestBody GameBackPolicyDTO dto) {
-        return ResultVO.ok(gameBackPolicyService.updatePolicy(dto));
+    public ResultVO<Boolean> updatePolicy(@PathVariable("policyId") Long policyId, @Validated @RequestBody GameBackPolicyDTO dto) {
+        return ResultVO.ok(gameBackPolicyService.updatePolicy(policyId, dto));
     }
 
     @PreAuthorize(permissionKey = "gameBack:policy:delete")
-    @PostMapping("/delete/{ids}")
+    @DeleteMapping("/del/{ids}")
     @ApiOperation(value = "删除回传策略")
     public ResultVO<Boolean> deletePolicy(@PathVariable("ids") List<Long> ids) {
         return ResultVO.ok(gameBackPolicyService.deletePolicy(ids));

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

@@ -29,45 +29,109 @@ public class GameBackPolicyDTO implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
-    private Long id;
-
     @ApiModelProperty("回传策略名")
     private String backPolicyName;
 
     /**
-     * 首充金额（小于等于指定金额）
+     * 首充-小额判定金额（小于等于）
+     */
+    @ApiModelProperty("首充-小额判定金额（小于等于）")
+    private BigDecimal firstMinMoney;
+
+    /**
+     * 首充-小额回传方式（概率/比例）
+     */
+    @ApiModelProperty("首充-小额回传方式（概率/比例）")
+    private Integer firstMinMoneyType;
+
+    /**
+     * 首充-小额回传概率/比例
+     */
+    @ApiModelProperty("首充-小额回传概率/比例")
+    private String firstMinMoneyRate;
+
+    /**
+     * 首充-大额判定金额（大于等于）
+     */
+    @ApiModelProperty("首充-大额判定金额（大于等于）")
+    private BigDecimal firstMaxMoney;
+
+    /**
+     * 首充-大额回传方式（概率/比例）
+     */
+    @ApiModelProperty("首充-大额回传方式（概率/比例）")
+    private Integer firstMaxMoneyType;
+
+    /**
+     * 首充-大额回传概率/比例
+     */
+    @ApiModelProperty("首充-大额回传概率/比例")
+    private String firstMaxMoneyRate;
+
+    /**
+     * 首充-其它金额回传方式（概率/比例）
+     */
+    @ApiModelProperty("首充-其它金额回传方式（概率/比例）")
+    private Integer firstOtherMoneyType;
+
+    /**
+     * 首充-其它金额回传概率/比例
+     */
+    @ApiModelProperty("首充-其它金额回传概率/比例")
+    private String firstOtherMoneyRate;
+
+    /**
+     * 次单-小额判定金额（小于等于）
+     */
+    @ApiModelProperty("次单-小额判定金额（小于等于）")
+    private BigDecimal rechargeMinMoney;
+
+    /**
+     * 次单-小额回传方式（概率/比例）
+     */
+    @ApiModelProperty("次单-小额回传方式（概率/比例）")
+    private Integer rechargeMinMoneyType;
+
+    /**
+     * 次单-小额回传概率/比例
+     */
+    @ApiModelProperty("次单-小额回传概率/比例")
+    private String rechargeMinMoneyRate;
+
+    /**
+     * 次单-大额判定金额（大于等于）
      */
-    @ApiModelProperty("首充金额（小于等于指定金额）")
-    private Long firstRechargeMoney;
+    @ApiModelProperty("次单-大额判定金额（大于等于）")
+    private BigDecimal rechargeMaxMoney;
 
     /**
-     * 首充回传比例（例如：50%-->0.5)
+     * 次单-大额回传方式（概率/比例）
      */
-    @ApiModelProperty("首充回传比例（例如：50%,传参0.5)")
-    private BigDecimal firstRechargeBackPercentage;
+    @ApiModelProperty("次单-大额回传方式（概率/比例）")
+    private Integer rechargeMaxMoneyType;
 
     /**
-     * 大单金额（大于等于指定金额）
+     * 次单-大额回传概率/比例
      */
-    @ApiModelProperty("大单金额（大于等于指定金额）")
-    private Long bigRechargeMoney;
+    @ApiModelProperty("次单-大额回传概率/比例")
+    private String rechargeMaxMoneyRate;
 
     /**
-     * 大单回传比例（例如：50%-->0.5)
+     * 次单-其它金额回传方式（概率/比例）
      */
-    @ApiModelProperty("大单回传比例（例如：50%传参0.5)")
-    private BigDecimal bigRechargeBackPercentage;
+    @ApiModelProperty("次单-其它金额回传方式（概率/比例）")
+    private Integer rechargeOtherMoneyType;
 
     /**
-     * 其他回传比例（例如：50%-->0.5)
+     * 次单-其它金额回传概率/比例
      */
-    @ApiModelProperty("其他回传比例（例如：50%传参0.5)")
-    private BigDecimal otherRechargeBackPercentage;
+    @ApiModelProperty("次单-其它金额回传概率/比例")
+    private String rechargeOtherMoneyRate;
 
     /**
      * 降档级别
      */
-    @ApiModelProperty("降档级别（降1档传参：1，降二档传参2）")
+    @ApiModelProperty("降档级别")
     private Integer levelDown;
 
 

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

@@ -3,6 +3,7 @@ package com.zanxiang.game.back.serve.pojo.entity;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
+
 import java.io.Serializable;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
@@ -24,38 +25,97 @@ import lombok.experimental.Accessors;
 @Builder
 @TableName("t_game_back_policy")
 public class GameBackPolicy implements Serializable {
-
     private static final long serialVersionUID = 1L;
 
+    // 固定比例
+    public static final Integer POLICY_TYPE_FIXED_RATE = 0;
+    // 随机概率
+    public static final Integer POLICY_TYPE_RANDOM_RATE = 1;
+
     @TableId(value = "id", type = IdType.AUTO)
     private Long id;
 
     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 firstRechargeMoney;
+    private Long rechargeMaxMoney;
 
     /**
-     * 首充回传比例（例如：50%-->0.5)
+     * 次单-大额回传方式（概率/比例）
      */
-    private BigDecimal firstRechargeBackPercentage;
+    private Integer rechargeMaxMoneyType;
 
     /**
-     * 大单金额（大于等于指定金额）
+     * 次单-大额回传概率/比例
      */
-    private Long bigRechargeMoney;
+    private String rechargeMaxMoneyRate;
 
     /**
-     * 大单回传比例（例如：50%-->0.5)
+     * 次单-其它金额回传方式（概率/比例）
      */
-    private BigDecimal bigRechargeBackPercentage;
+    private Integer rechargeOtherMoneyType;
 
     /**
-     * 其他回传比例（例如：50%-->0.5)
+     * 次单-其它金额回传概率/比例
      */
-    private BigDecimal otherRechargeBackPercentage;
+    private String rechargeOtherMoneyRate;
 
     /**
      * 降档级别

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

@@ -32,39 +32,105 @@ public class GameBackPolicyVO implements Serializable {
     private String backPolicyName;
 
     /**
-     * 首充金额（小于等于指定金额）
+     * 首充-小额判定金额（小于等于）
      */
-    @ApiModelProperty("首充金额（小于等于指定金额）")
-    private Long firstRechargeMoney;
+    @ApiModelProperty("首充-小额判定金额（小于等于）")
+    private BigDecimal firstMinMoney;
 
     /**
-     * 首充回传比例（例如：50%-->0.5)
+     * 首充-小额回传方式（概率/比例）
      */
-    @ApiModelProperty("首充回传比例（例如：50%,传参0.5)")
-    private BigDecimal firstRechargeBackPercentage;
+    @ApiModelProperty("首充-小额回传方式（概率/比例）")
+    private Integer firstMinMoneyType;
 
     /**
-     * 大单金额（大于等于指定金额）
+     * 首充-小额回传概率/比例
      */
-    @ApiModelProperty("大单金额（大于等于指定金额）")
-    private Long bigRechargeMoney;
+    @ApiModelProperty("首充-小额回传概率/比例")
+    private String firstMinMoneyRate;
 
     /**
-     * 大单回传比例（例如：50%-->0.5)
+     * 首充-大额判定金额（大于等于）
      */
-    @ApiModelProperty("大单回传比例（例如：50%传参0.5)")
-    private BigDecimal bigRechargeBackPercentage;
+    @ApiModelProperty("首充-大额判定金额（大于等于）")
+    private BigDecimal firstMaxMoney;
 
     /**
-     * 其他回传比例（例如：50%-->0.5)
+     * 首充-大额回传方式（概率/比例）
      */
-    @ApiModelProperty("其他回传比例（例如：50%传参0.5)")
-    private BigDecimal otherRechargeBackPercentage;
+    @ApiModelProperty("首充-大额回传方式（概率/比例）")
+    private Integer firstMaxMoneyType;
+
+    /**
+     * 首充-大额回传概率/比例
+     */
+    @ApiModelProperty("首充-大额回传概率/比例")
+    private String firstMaxMoneyRate;
+
+    /**
+     * 首充-其它金额回传方式（概率/比例）
+     */
+    @ApiModelProperty("首充-其它金额回传方式（概率/比例）")
+    private Integer firstOtherMoneyType;
+
+    /**
+     * 首充-其它金额回传概率/比例
+     */
+    @ApiModelProperty("首充-其它金额回传概率/比例")
+    private String firstOtherMoneyRate;
+
+    /**
+     * 次单-小额判定金额（小于等于）
+     */
+    @ApiModelProperty("次单-小额判定金额（小于等于）")
+    private BigDecimal rechargeMinMoney;
+
+    /**
+     * 次单-小额回传方式（概率/比例）
+     */
+    @ApiModelProperty("次单-小额回传方式（概率/比例）")
+    private Integer rechargeMinMoneyType;
+
+    /**
+     * 次单-小额回传概率/比例
+     */
+    @ApiModelProperty("次单-小额回传概率/比例")
+    private String rechargeMinMoneyRate;
+
+    /**
+     * 次单-大额判定金额（大于等于）
+     */
+    @ApiModelProperty("次单-大额判定金额（大于等于）")
+    private BigDecimal rechargeMaxMoney;
+
+    /**
+     * 次单-大额回传方式（概率/比例）
+     */
+    @ApiModelProperty("次单-大额回传方式（概率/比例）")
+    private Integer rechargeMaxMoneyType;
+
+    /**
+     * 次单-大额回传概率/比例
+     */
+    @ApiModelProperty("次单-大额回传概率/比例")
+    private String rechargeMaxMoneyRate;
+
+    /**
+     * 次单-其它金额回传方式（概率/比例）
+     */
+    @ApiModelProperty("次单-其它金额回传方式（概率/比例）")
+    private Integer rechargeOtherMoneyType;
+
+    /**
+     * 次单-其它金额回传概率/比例
+     */
+    @ApiModelProperty("次单-其它金额回传概率/比例")
+    private String rechargeOtherMoneyRate;
 
     /**
      * 降档级别
      */
-    @ApiModelProperty("降档级别（降1档传参：1，降二档传参2）")
+    @ApiModelProperty("降档级别")
     private Integer levelDown;
 
     private LocalDateTime createTime;
@@ -73,9 +139,5 @@ public class GameBackPolicyVO implements Serializable {
 
     private String createName;
 
-    private LocalDateTime updateTime;
-
-    private Long updateBy;
-
 
 }

game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/rpc/impl/WechatMiniGameDataReportRpcImpl.java → game-back/game-back-serve/src/main/java/com/zanxiang/game/back/serve/rpc/impl/OceanEngineDataReportRpcImpl.java

@@ -2,7 +2,7 @@ package com.zanxiang.game.back.serve.rpc.impl;
 
 import com.zanxiang.game.back.base.oceanengine.pojo.dto.OrderReportRpcDTO;
 import com.zanxiang.game.back.base.oceanengine.pojo.dto.UserActiveReportRpcDTO;
-import com.zanxiang.game.back.base.oceanengine.rpc.IWechatMiniGameDataReportRpc;
+import com.zanxiang.game.back.base.oceanengine.rpc.IOceanEngineDataReportRpc;
 import com.zanxiang.game.back.serve.pojo.entity.GameOceanengineOrderLog;
 import com.zanxiang.game.back.serve.pojo.entity.GameOceanengineUserLog;
 import com.zanxiang.game.back.serve.pojo.enums.BackStatusEnum;
@@ -16,7 +16,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 @Slf4j
 @DubboService
-public class WechatMiniGameDataReportRpcImpl implements IWechatMiniGameDataReportRpc {
+public class OceanEngineDataReportRpcImpl implements IOceanEngineDataReportRpc {
     @Autowired
     private IGameOceanengineUserLogService gameOceanengineUserLogService;
     @Autowired

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

@@ -28,7 +28,7 @@ public interface IGameBackPolicyService extends IService<GameBackPolicy> {
 
     boolean createPolicy(GameBackPolicyDTO dto);
 
-    boolean updatePolicy(GameBackPolicyDTO dto);
+    boolean updatePolicy(Long policyId, GameBackPolicyDTO dto);
 
     boolean deletePolicy(List<Long> id);
 

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

@@ -25,6 +25,7 @@ import com.zanxiang.game.back.serve.service.IGameTencentOrderService;
 import com.zanxiang.game.back.serve.service.IGameTencentUserService;
 import com.zanxiang.game.back.serve.utils.BackPolicyUtil;
 import com.zanxiang.module.util.JsonUtil;
+import com.zanxiang.module.util.NumberUtil;
 import com.zanxiang.module.util.bean.BeanUtil;
 import com.zanxiang.module.util.exception.BaseException;
 import lombok.extern.slf4j.Slf4j;
@@ -34,6 +35,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -122,16 +124,22 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
         } else {
             GameBackPolicy gameBackPolicy = gameBackPolicyService.getById(dto.getBackPolicyId());
 
-            doBack = BackPolicyUtil.backOrder(gameBackPolicy, dto.getRechargeMoney(), backUnit -> Long.valueOf(
-                    gameTencentOrderService.list(new LambdaQueryWrapper<GameTencentOrder>()
+            doBack = BackPolicyUtil.backOrder(gameBackPolicy, dto.getRechargeMoney(),
+                    () -> gameTencentOrderService.count(new LambdaQueryWrapper<GameTencentOrder>()
+                            .eq(GameTencentOrder::getGameId, dto.getGameId())
+                            .eq(GameTencentOrder::getWechatAppId, dto.getWechatAppId())
+                            .eq(GameTencentOrder::getAdAccountId, dto.getAdAccountId())
+                            .eq(GameTencentOrder::getOrderStatus, 2)
+                            .eq(GameTencentOrder::getWechatOpenid, dto.getWechatOpenid())
+                            .last("limit 1")
+                    ) < 1, backUnit -> Long.valueOf(gameTencentOrderService.count(new LambdaQueryWrapper<GameTencentOrder>()
                             .eq(GameTencentOrder::getGameId, dto.getGameId())
                             .eq(GameTencentOrder::getWechatAppId, dto.getWechatAppId())
                             .eq(GameTencentOrder::getAdAccountId, dto.getAdAccountId())
                             .eq(GameTencentOrder::getOrderStatus, 2)
                             .last("limit " + backUnit)
                             .orderByDesc(GameTencentOrder::getCreateTime)
-                    ).stream().filter(order -> order.getIsBack().equals(BackStatusEnum.SUCCESS.getBackStatus())).count()
-            ).intValue());
+                    )).intValue());
         }
 
         try {
@@ -223,46 +231,79 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
     }
 
     @Override
-    public boolean createPolicy(GameBackPolicyDTO dto) {
-        GameBackPolicy gameBackPolicy = gameBackPolicyService.getOne(new LambdaQueryWrapper<GameBackPolicy>()
+    public IPage<GameBackPolicyVO> policyList(GameBackPolicyListDTO dto) {
+        return gameBackPolicyService.page(dto.toPage(), new LambdaQueryWrapper<GameBackPolicy>()
+                        .like(StringUtils.isNotBlank(dto.getBackPolicyName()), GameBackPolicy::getBackPolicyName, dto.getBackPolicyName())
+                        .eq(GameBackPolicy::getCreateBy, SecurityUtil.getUserId())
+                        .orderByDesc(GameBackPolicy::getCreateTime))
+                .convert(this::toVO);
+    }
+
+    @Override
+    public List<GameBackPolicyVO> allOfUser() {
+        return list(new LambdaQueryWrapper<GameBackPolicy>()
                 .eq(GameBackPolicy::getCreateBy, SecurityUtil.getUserId())
-                .eq(GameBackPolicy::getBackPolicyName, dto.getBackPolicyName()));
-        if (null != gameBackPolicy) {
+                .orderByDesc(GameBackPolicy::getCreateTime)
+        ).stream().map(this::toVOSimple).collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean createPolicy(GameBackPolicyDTO dto) {
+        if (nameExist(null, SecurityUtil.getUserId(), dto.getBackPolicyName())) {
             throw new BaseException("回传策略名重复");
         }
         GameBackPolicy backPolicy = GameBackPolicy.builder()
                 .backPolicyName(dto.getBackPolicyName())
-                .firstRechargeMoney(dto.getFirstRechargeMoney())
-                .firstRechargeBackPercentage(dto.getFirstRechargeBackPercentage())
-                .bigRechargeBackPercentage(dto.getBigRechargeBackPercentage())
-                .bigRechargeMoney(dto.getBigRechargeMoney())
-                .otherRechargeBackPercentage(dto.getOtherRechargeBackPercentage())
+                .firstMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .firstMinMoneyType(dto.getFirstMinMoneyType())
+                .firstMinMoneyRate(dto.getFirstMinMoneyRate())
+                .firstMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .firstMaxMoneyType(dto.getFirstMaxMoneyType())
+                .firstMaxMoneyRate(dto.getFirstMaxMoneyRate())
+                .firstOtherMoneyType(dto.getFirstOtherMoneyType())
+                .firstOtherMoneyRate(dto.getFirstOtherMoneyRate())
+                .rechargeMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .rechargeMinMoneyType(dto.getFirstMinMoneyType())
+                .rechargeMinMoneyRate(dto.getFirstMinMoneyRate())
+                .rechargeMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .rechargeMaxMoneyType(dto.getFirstMaxMoneyType())
+                .rechargeMaxMoneyRate(dto.getFirstMaxMoneyRate())
+                .rechargeOtherMoneyType(dto.getFirstOtherMoneyType())
+                .rechargeOtherMoneyRate(dto.getFirstOtherMoneyRate())
                 .levelDown(dto.getLevelDown())
                 .createBy(SecurityUtil.getUserId())
                 .createTime(LocalDateTime.now())
                 .build();
-
         return gameBackPolicyService.save(backPolicy);
     }
 
     @Override
-    public boolean updatePolicy(GameBackPolicyDTO dto) {
-        long count = gameBackPolicyService.count(new LambdaQueryWrapper<GameBackPolicy>()
-                .eq(GameBackPolicy::getCreateBy, SecurityUtil.getUserId())
-                .eq(GameBackPolicy::getBackPolicyName, dto.getBackPolicyName())
-                .ne(GameBackPolicy::getId, dto.getId()));
-        if (count > 0) {
+    public boolean updatePolicy(Long policyId, GameBackPolicyDTO dto) {
+        if (nameExist(policyId, SecurityUtil.getUserId(), dto.getBackPolicyName())) {
             throw new BaseException("回传策略名重复");
         }
+        GameBackPolicy old = getById(policyId);
         GameBackPolicy backPolicy = GameBackPolicy.builder()
-                .id(dto.getId())
                 .backPolicyName(dto.getBackPolicyName())
-                .firstRechargeMoney(dto.getFirstRechargeMoney())
-                .firstRechargeBackPercentage(dto.getFirstRechargeBackPercentage())
-                .bigRechargeBackPercentage(dto.getBigRechargeBackPercentage())
-                .bigRechargeMoney(dto.getBigRechargeMoney())
-                .otherRechargeBackPercentage(dto.getOtherRechargeBackPercentage())
+                .firstMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .firstMinMoneyType(dto.getFirstMinMoneyType())
+                .firstMinMoneyRate(dto.getFirstMinMoneyRate())
+                .firstMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .firstMaxMoneyType(dto.getFirstMaxMoneyType())
+                .firstMaxMoneyRate(dto.getFirstMaxMoneyRate())
+                .firstOtherMoneyType(dto.getFirstOtherMoneyType())
+                .firstOtherMoneyRate(dto.getFirstOtherMoneyRate())
+                .rechargeMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .rechargeMinMoneyType(dto.getFirstMinMoneyType())
+                .rechargeMinMoneyRate(dto.getFirstMinMoneyRate())
+                .rechargeMaxMoney(NumberUtil.multiply100(dto.getFirstMaxMoney()).longValue())
+                .rechargeMaxMoneyType(dto.getFirstMaxMoneyType())
+                .rechargeMaxMoneyRate(dto.getFirstMaxMoneyRate())
+                .rechargeOtherMoneyType(dto.getFirstOtherMoneyType())
+                .rechargeOtherMoneyRate(dto.getFirstOtherMoneyRate())
                 .levelDown(dto.getLevelDown())
+                .createBy(old.getCreateBy())
+                .createTime(old.getCreateTime())
                 .updateBy(SecurityUtil.getUserId())
                 .updateTime(LocalDateTime.now())
                 .build();
@@ -275,28 +316,24 @@ public class GameBackPolicyServiceImpl extends ServiceImpl<GameBackPolicyMapper,
         return gameBackPolicyService.removeByIds(ids);
     }
 
-    @Override
-    public IPage<GameBackPolicyVO> policyList(GameBackPolicyListDTO dto) {
-        return gameBackPolicyService.page(dto.toPage(), new LambdaQueryWrapper<GameBackPolicy>()
-                        .like(StringUtils.isNotBlank(dto.getBackPolicyName()), GameBackPolicy::getBackPolicyName, dto.getBackPolicyName())
-                        .eq(GameBackPolicy::getCreateBy, SecurityUtil.getUserId())
-                        .orderByDesc(GameBackPolicy::getCreateTime))
-                .convert(this::toVO);
-    }
-
-    @Override
-    public List<GameBackPolicyVO> allOfUser() {
-        return list(new LambdaQueryWrapper<GameBackPolicy>()
-                .eq(GameBackPolicy::getCreateBy, SecurityUtil.getUserId())
-                .orderByDesc(GameBackPolicy::getCreateTime)
-        ).stream().map(this::toVOSimple).collect(Collectors.toList());
+    private boolean nameExist(Long policyId, Long userId, String policyName) {
+        return count(new LambdaQueryWrapper<GameBackPolicy>()
+                .ne(policyId != null, GameBackPolicy::getId, policyId)
+                .eq(GameBackPolicy::getBackPolicyName, policyName)
+                .eq(GameBackPolicy::getCreateBy, userId)
+        ) > 0;
     }
 
     private GameBackPolicyVO toVOSimple(GameBackPolicy gameBackPolicy) {
         if (gameBackPolicy == null) {
             return null;
         }
-        return BeanUtil.copy(gameBackPolicy, GameBackPolicyVO.class);
+        GameBackPolicyVO vo = BeanUtil.copy(gameBackPolicy, GameBackPolicyVO.class);
+        vo.setFirstMinMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getFirstMinMoney())));
+        vo.setFirstMaxMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getFirstMaxMoney())));
+        vo.setRechargeMinMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getRechargeMinMoney())));
+        vo.setRechargeMaxMoney(NumberUtil.divide100(new BigDecimal(gameBackPolicy.getRechargeMaxMoney())));
+        return vo;
     }
 
     private GameBackPolicyVO toVO(GameBackPolicy gameBackPolicy) {

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

@@ -60,17 +60,28 @@ public class GameOceanengineOrderLogServiceImpl extends ServiceImpl<GameOceaneng
                 doBack = true;
             } else {
                 GameBackPolicy gameBackPolicy = gameBackPolicyService.getById(orderLog.getBackPolicyId());
-                doBack = BackPolicyUtil.backOrder(gameBackPolicy, orderLog.getAmount(), backUnit -> {
-                    return Long.valueOf(list(new LambdaQueryWrapper<GameOceanengineOrderLog>()
+                doBack = BackPolicyUtil.backOrder(gameBackPolicy, orderLog.getAmount(),
+                        () -> {
+                            return count(new LambdaQueryWrapper<GameOceanengineOrderLog>()
                                     .eq(GameOceanengineOrderLog::getGameId, orderLog.getGameId())
                                     .eq(GameOceanengineOrderLog::getAppId, orderLog.getAppId())
                                     .eq(GameOceanengineOrderLog::getAccountId, orderLog.getAccountId())
                                     .eq(GameOceanengineOrderLog::getOrderStatus, 2)
-                                    .last("limit " + backUnit)
-                                    .orderByDesc(GameOceanengineOrderLog::getCreateTime)
-                            ).stream().filter(log -> log.getOrderStatus().equals(BackStatusEnum.SUCCESS.getBackStatus())).count()
-                    ).intValue();
-                });
+                                    .eq(GameOceanengineOrderLog::getOpenId, orderLog.getOpenId())
+                                    .last("limit 1")
+                            ) < 1;
+                        },
+                        backUnit -> {
+                            return Long.valueOf(list(new LambdaQueryWrapper<GameOceanengineOrderLog>()
+                                            .eq(GameOceanengineOrderLog::getGameId, orderLog.getGameId())
+                                            .eq(GameOceanengineOrderLog::getAppId, orderLog.getAppId())
+                                            .eq(GameOceanengineOrderLog::getAccountId, orderLog.getAccountId())
+                                            .eq(GameOceanengineOrderLog::getOrderStatus, 2)
+                                            .orderByDesc(GameOceanengineOrderLog::getCreateTime)
+                                            .last("limit " + backUnit)
+                                    ).stream().filter(log -> log.getOrderStatus().equals(BackStatusEnum.SUCCESS.getBackStatus())).count()
+                            ).intValue();
+                        });
                 orderLog.setAmount(BackPolicyUtil.lowRechargeLevel(orderLog.getAmount(), gameBackPolicy.getLevelDown()));
             }
         }

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

@@ -3,10 +3,10 @@ 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 org.apache.commons.lang3.RandomUtils;
 
-import java.math.BigDecimal;
 import java.util.Arrays;
-import java.util.Random;
+import java.util.Objects;
 import java.util.function.Function;
 
 public class BackPolicyUtil {
@@ -16,28 +16,6 @@ public class BackPolicyUtil {
         Arrays.sort(RECHARGE_LEVEL);
     }
 
-    public static boolean isBackOrder(GameBackPolicy gameBackPolicy, Long rechargeMoney) {
-        if (null == gameBackPolicy) {
-            return true;
-        } else {
-            if (rechargeMoney <= gameBackPolicy.getFirstRechargeMoney() && shouldDoTask(gameBackPolicy.getFirstRechargeBackPercentage())) {
-                return true;
-            } else if (rechargeMoney >= gameBackPolicy.getFirstRechargeMoney() && shouldDoTask(gameBackPolicy.getBigRechargeBackPercentage())) {
-                return true;
-            } else {
-                return shouldDoTask(gameBackPolicy.getOtherRechargeBackPercentage());
-            }
-        }
-    }
-
-    private static boolean shouldDoTask(BigDecimal successProbability) {
-        Random random = new Random();
-        // 生成一个0到1之间的随机数
-        double randomValue = random.nextDouble();
-        // 如果随机数小于成功概率，则返回true，否则返回false
-        return successProbability.compareTo(BigDecimal.valueOf(randomValue)) >= 0;
-    }
-
     /**
      * 订单回传
      *
@@ -46,32 +24,62 @@ public class BackPolicyUtil {
      * @param lastBackFunction 在指定最近订单数量内是否有订单回传过
      * @return <是否回传, 回传金额>
      */
-    public static boolean backOrder(GameBackPolicy gameBackPolicy, long rechargeMoney, Function<Integer, Integer> lastBackFunction) {
+    public static boolean backOrder(GameBackPolicy gameBackPolicy, long rechargeMoney, FirstOrder firstOrder, Function<Integer, Integer> lastBackFunction) {
         if (null == gameBackPolicy) {
             return true;
         }
-        BigDecimal percentage;
-        if (rechargeMoney <= gameBackPolicy.getFirstRechargeMoney()) {
+        Integer firstType;
+        String firstRate;
+        Integer rechargeType;
+        String rechargeRate;
+        if (rechargeMoney <= gameBackPolicy.getFirstMinMoney()) {
             // 小于首充金额
-            percentage = gameBackPolicy.getFirstRechargeBackPercentage();
-        } else if (rechargeMoney >= gameBackPolicy.getBigRechargeMoney()) {
-            percentage = gameBackPolicy.getBigRechargeBackPercentage();
+            firstType = gameBackPolicy.getFirstMinMoneyType();
+            firstRate = gameBackPolicy.getFirstMinMoneyRate();
+        } else if (rechargeMoney >= gameBackPolicy.getFirstMaxMoney()) {
+            firstType = gameBackPolicy.getFirstMaxMoneyType();
+            firstRate = gameBackPolicy.getFirstMaxMoneyRate();
         } else {
-            percentage = gameBackPolicy.getOtherRechargeBackPercentage();
+            firstType = gameBackPolicy.getFirstOtherMoneyType();
+            firstRate = gameBackPolicy.getFirstOtherMoneyRate();
         }
-        if (percentage == null || percentage.compareTo(BigDecimal.ONE) >= 0) {
-            return true;
+        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();
         }
-        int backRate = percentage.multiply(BigDecimal.TEN).intValue();
-        Tuple2<Integer, Integer> temp = approximate(backRate, 10);
-        backRate = temp.first;
-        int backUnit = temp.second;
-        int backCount = lastBackFunction.apply(backUnit);
-        if (backCount >= backRate) {
-            // 之前有订单上报过，这笔订单不上报了
-            return false;
+        Integer backType;
+        String backRate;
+        if (firstType.equals(rechargeType) && firstRate.equalsIgnoreCase(rechargeRate)) {
+            // 回传内容相同，不需要区分是不是首单
+            backType = firstType;
+            backRate = firstRate;
         } else {
-            return true;
+            if (firstOrder.isFirstOrder()) {
+                backType = firstType;
+                backRate = firstRate;
+            } else {
+                backType = rechargeType;
+                backRate = rechargeRate;
+            }
+        }
+        if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_FIXED_RATE)) {
+            // 固定比例回传
+            String[] temp = backRate.split(":");
+            int backCount = Integer.parseInt(temp[0]);
+            int ignoreCount = Integer.parseInt(temp[1]);
+            int isBackCount = lastBackFunction.apply(backCount + ignoreCount - 1);
+            return isBackCount >= backCount;
+        } else if (Objects.equals(backType, GameBackPolicy.POLICY_TYPE_RANDOM_RATE)) {
+            // 随机概率回传
+            return RandomUtils.nextInt(0, 100) <= Integer.parseInt(backRate);
+        } else {
+            throw new RuntimeException("回传策略[" + gameBackPolicy.getId() + "]配置错误，未知的回传类型：" + backType);
         }
     }
 
@@ -110,4 +118,8 @@ public class BackPolicyUtil {
         level = level < 0 ? 0 : Math.min(level, RECHARGE_LEVEL.length - 1);
         return RECHARGE_LEVEL[level];
     }
+
+    public interface FirstOrder {
+        boolean isFirstOrder();
+    }
 }

game-module/game-module-sdk/src/main/java/com/zanxiang/game/module/sdk/service/impl/CallBackServiceImpl.java

@@ -6,7 +6,7 @@ import com.zanxiang.game.back.base.ServerInfo;
 import com.zanxiang.game.back.base.oceanengine.pojo.dto.AccountReportRpcDTO;
 import com.zanxiang.game.back.base.oceanengine.pojo.dto.OrderReportRpcDTO;
 import com.zanxiang.game.back.base.oceanengine.pojo.dto.UserActiveReportRpcDTO;
-import com.zanxiang.game.back.base.oceanengine.rpc.IWechatMiniGameDataReportRpc;
+import com.zanxiang.game.back.base.oceanengine.rpc.IOceanEngineDataReportRpc;
 import com.zanxiang.game.back.base.tencent.pojo.dto.TencentOrderDTO;
 import com.zanxiang.game.back.base.tencent.pojo.dto.TencentUserDTO;
 import com.zanxiang.game.back.base.tencent.rpc.IGameBackTencentRpc;
@@ -36,7 +36,7 @@ public class CallBackServiceImpl implements ICallBackService {
     private IGameBackTencentRpc gameBackTencentRpc;
 
     @DubboReference(providedBy = ServerInfo.SERVER_DUBBO_NAME)
-    private IWechatMiniGameDataReportRpc wechatMiniGameDataReportRpc;
+    private IOceanEngineDataReportRpc wechatMiniGameDataReportRpc;
 
     @Autowired
     private IAgentService agentService;