510 lines
20 KiB
Java
510 lines
20 KiB
Java
package com.tailbet.service.impl;
|
||
|
||
import com.fasterxml.jackson.core.JsonProcessingException;
|
||
import com.fasterxml.jackson.core.type.TypeReference;
|
||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||
import com.tailbet.event.RedPacketFinishedEvent;
|
||
import com.tailbet.model.entity.GameRound;
|
||
import com.tailbet.model.entity.RedPacket;
|
||
import com.tailbet.model.entity.RedPacketRecv;
|
||
import com.tailbet.model.entity.User;
|
||
import com.tailbet.mapper.GameRoundMapper;
|
||
import com.tailbet.mapper.RedPacketMapper;
|
||
import com.tailbet.mapper.RedPacketRecvMapper;
|
||
import com.tailbet.mapper.UserMapper;
|
||
import com.tailbet.service.IAuditService;
|
||
import com.tailbet.service.IPointsService;
|
||
import com.tailbet.service.IRedPacketService;
|
||
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
||
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
||
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
||
import lombok.RequiredArgsConstructor;
|
||
import lombok.extern.slf4j.Slf4j;
|
||
import org.springframework.context.ApplicationEventPublisher;
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.transaction.annotation.Transactional;
|
||
|
||
import java.math.BigDecimal;
|
||
import java.math.RoundingMode;
|
||
import java.time.LocalDateTime;
|
||
import java.util.ArrayList;
|
||
import java.util.Collections;
|
||
import java.util.List;
|
||
import java.util.Random;
|
||
|
||
/**
|
||
* 红包Service实现
|
||
*/
|
||
@Slf4j
|
||
@RequiredArgsConstructor
|
||
@Service
|
||
public class RedPacketServiceImpl implements IRedPacketService {
|
||
|
||
private final RedPacketMapper redPacketMapper;
|
||
private final RedPacketRecvMapper redPacketRecvMapper;
|
||
private final UserMapper userMapper;
|
||
private final GameRoundMapper gameRoundMapper;
|
||
private final IPointsService pointsService;
|
||
private final IAuditService auditService;
|
||
private final ApplicationEventPublisher eventPublisher;
|
||
private final ObjectMapper objectMapper = new ObjectMapper();
|
||
|
||
/**
|
||
* 发红包
|
||
*/
|
||
@Override
|
||
@Transactional
|
||
public RedPacket sendRp(Long userId, Long groupId, BigDecimal totalAmount,
|
||
Integer totalCount, Long roundId) {
|
||
User user = userMapper.selectById(userId);
|
||
if (user == null) {
|
||
throw new RuntimeException("用户不存在");
|
||
}
|
||
|
||
// 前置校验：总金额必须够每个包至少 1 分，避免产生 0 元红包
|
||
BigDecimal minRequired = BigDecimal.valueOf(totalCount == null ? 0 : totalCount)
|
||
.multiply(new BigDecimal("0.01"));
|
||
if (totalAmount == null || totalAmount.compareTo(minRequired) < 0) {
|
||
throw new RuntimeException("红包总金额不能低于 " + minRequired.toPlainString() + " 元");
|
||
}
|
||
|
||
// 扣积分
|
||
pointsService.subPoints(userId, totalAmount,
|
||
IPointsService.TYPE_RP_SEND, null, null, "发送红包");
|
||
|
||
|
||
// 创建红包
|
||
RedPacket rp = new RedPacket();
|
||
rp.setUserId(userId);
|
||
rp.setGroupId(groupId);
|
||
rp.setRoundId(roundId);
|
||
rp.setTotalAmount(totalAmount);
|
||
rp.setTotalCount(totalCount);
|
||
rp.setRemainAmount(totalAmount);
|
||
rp.setRemainCount(totalCount);
|
||
rp.setStatus(STATUS_ONGOING);
|
||
rp.setCreateTime(LocalDateTime.now());
|
||
|
||
// 判断红包类型
|
||
Integer targetDigit = null;
|
||
if (roundId != null) {
|
||
rp.setType(TYPE_GAME);
|
||
} else {
|
||
rp.setType(TYPE_RANDOM);
|
||
}
|
||
|
||
redPacketMapper.insert(rp);
|
||
|
||
// 如果是游戏红包，检查并绑定第一个红包
|
||
if (roundId != null) {
|
||
GameRound round = gameRoundMapper.selectById(roundId);
|
||
if (round == null) {
|
||
throw new RuntimeException("局不存在");
|
||
}
|
||
|
||
if (round.getFirstRpId() == null) {
|
||
// 第一个红包，绑定到局
|
||
round.setFirstRpId(rp.getId());
|
||
gameRoundMapper.updateById(round);
|
||
|
||
// 获取局的目标尾数（可能为null）
|
||
targetDigit = round.getTargetDigit();
|
||
} else {
|
||
// 已有红包，不再绑定本局，作为普通游戏红包发放（不计算尾数）
|
||
log.info("本局已有红包，当前红包不绑定: rpId={}, roundId={}", rp.getId(), roundId);
|
||
}
|
||
}
|
||
|
||
// 无论红包类型(TYPE_GAME/TYPE_RANDOM),都预先生成份额金额
|
||
// 游戏红包有targetDigit时控制手气王尾数,无targetDigit或非游戏红包按纯随机份额
|
||
List<BigDecimal> shareAmounts = preCalculateShareAmounts(rp, targetDigit);
|
||
try {
|
||
rp.setShareAmounts(objectMapper.writeValueAsString(shareAmounts));
|
||
} catch (JsonProcessingException e) {
|
||
log.error("序列化shareAmounts失败: {}", shareAmounts, e);
|
||
throw new RuntimeException("系统错误");
|
||
}
|
||
rp.setShareTakenIndex(0);
|
||
redPacketMapper.updateById(rp);
|
||
log.info("预分配红包份额: rpId={}, type={}, targetDigit={}, amounts={}",
|
||
rp.getId(), rp.getType(), targetDigit, shareAmounts);
|
||
|
||
// 审计日志
|
||
auditService.log(groupId, roundId, userId, "RP_SEND",
|
||
String.format("{\"rpId\":%d,\"amount\":%s,\"count\":%d}",
|
||
rp.getId(), totalAmount, totalCount));
|
||
|
||
return rp;
|
||
}
|
||
|
||
/**
|
||
* 领红包
|
||
*/
|
||
@Override
|
||
@Transactional
|
||
public RedPacketRecv receiveRp(Long rpId, Long userId) {
|
||
RedPacket rp = redPacketMapper.selectById(rpId);
|
||
if (rp == null) {
|
||
throw new RuntimeException("红包不存在");
|
||
}
|
||
if (rp.getStatus() != STATUS_ONGOING) {
|
||
throw new RuntimeException("红包已领完");
|
||
}
|
||
|
||
// 检查是否已领取
|
||
RedPacketRecv existing = redPacketRecvMapper.selectOne(new LambdaQueryWrapper<RedPacketRecv>()
|
||
.eq(RedPacketRecv::getRpId, rpId)
|
||
.eq(RedPacketRecv::getUserId, userId));
|
||
if (existing != null) {
|
||
throw new RuntimeException("已领取过该红包");
|
||
}
|
||
|
||
// 计算领取金额（从预分配中取或随机）
|
||
BigDecimal amount = drawFromPreAllocatedAmounts(rp);
|
||
|
||
// 更新红包
|
||
rp.setRemainAmount(rp.getRemainAmount().subtract(amount));
|
||
rp.setRemainCount(rp.getRemainCount() - 1);
|
||
boolean isFinished = rp.getRemainCount() <= 0;
|
||
if (isFinished) {
|
||
rp.setStatus(STATUS_FINISHED);
|
||
}
|
||
|
||
// 更新手气王信息（领取金额最大的用户为手气王）
|
||
Integer takenIndex = rp.getShareTakenIndex();
|
||
BigDecimal currentLucky = rp.getLuckyAmount();
|
||
if (currentLucky == null || amount.compareTo(currentLucky) > 0) {
|
||
rp.setLuckyAmount(amount);
|
||
rp.setLuckyUserId(userId);
|
||
rp.setLuckyDigit(digitOf(amount));
|
||
}
|
||
rp.setShareTakenIndex(takenIndex != null ? takenIndex + 1 : 1);
|
||
|
||
redPacketMapper.updateById(rp);
|
||
|
||
// 如果是游戏红包且已领完，标记手气王并发布开奖事件
|
||
if (isFinished && TYPE_GAME.equals(rp.getType()) && rp.getRoundId() != null) {
|
||
// 标记手气王的领取记录 is_lucky=1
|
||
if (rp.getLuckyUserId() != null) {
|
||
redPacketRecvMapper.update(null, new LambdaUpdateWrapper<RedPacketRecv>()
|
||
.eq(RedPacketRecv::getRpId, rpId)
|
||
.eq(RedPacketRecv::getUserId, rp.getLuckyUserId())
|
||
.set(RedPacketRecv::getIsLucky, 1));
|
||
}
|
||
eventPublisher.publishEvent(new RedPacketFinishedEvent(
|
||
this, rp.getRoundId(), rp.getGroupId(), rp.getId(), rp.getLuckyDigit()));
|
||
log.info("游戏红包领完，标记手气王并发布开奖事件: roundId={}, luckyDigit={}, luckyUserId={}",
|
||
rp.getRoundId(), rp.getLuckyDigit(), rp.getLuckyUserId());
|
||
}
|
||
|
||
// 加积分
|
||
pointsService.addPoints(userId, amount,
|
||
IPointsService.TYPE_RP_RECV, String.valueOf(rpId), null, "领取红包");
|
||
|
||
// 记录领取
|
||
RedPacketRecv recv = new RedPacketRecv();
|
||
recv.setRpId(rpId);
|
||
recv.setUserId(userId);
|
||
recv.setAmount(amount);
|
||
recv.setCreateTime(LocalDateTime.now());
|
||
redPacketRecvMapper.insert(recv);
|
||
|
||
// 审计日志
|
||
auditService.log(rp.getGroupId(), rp.getRoundId(), userId, "RP_RECV",
|
||
String.format("{\"rpId\":%d,\"amount\":%s}", rpId, amount));
|
||
|
||
return recv;
|
||
}
|
||
|
||
/**
|
||
* 计算领取金额
|
||
*/
|
||
@Override
|
||
public BigDecimal calculateReceiveAmount(RedPacket rp) {
|
||
if (rp.getRemainCount() <= 0) {
|
||
return BigDecimal.ZERO;
|
||
}
|
||
|
||
// 如果是游戏红包且有目标尾数,则需要控制手气王
|
||
// 简化实现:随机分配
|
||
Random random = new Random();
|
||
if (rp.getRemainCount() == 1) {
|
||
// 最后一个,拿剩余全部
|
||
return rp.getRemainAmount();
|
||
}
|
||
|
||
// 随机金额,最小0.01
|
||
double min = 0.01;
|
||
double max = rp.getRemainAmount().divide(BigDecimal.valueOf(rp.getRemainCount()), 2, RoundingMode.HALF_UP).doubleValue() * 2;
|
||
double amount = min + (max - min) * random.nextDouble();
|
||
return BigDecimal.valueOf(amount).setScale(2, RoundingMode.HALF_UP);
|
||
}
|
||
|
||
/**
|
||
* 获取红包详情
|
||
*/
|
||
@Override
|
||
public RedPacket getById(Long rpId) {
|
||
return redPacketMapper.selectById(rpId);
|
||
}
|
||
|
||
/**
|
||
* 获取红包领取列表
|
||
*/
|
||
@Override
|
||
public List<RedPacketRecv> getReceives(Long rpId) {
|
||
return redPacketRecvMapper.selectList(new LambdaQueryWrapper<RedPacketRecv>()
|
||
.eq(RedPacketRecv::getRpId, rpId)
|
||
.orderByAsc(RedPacketRecv::getCreateTime));
|
||
}
|
||
|
||
/**
|
||
* 查询红包记录
|
||
*/
|
||
@Override
|
||
public Page<RedPacket> getRecords(Long userId, Integer pageNum, Integer pageSize) {
|
||
Page<RedPacket> page = new Page<>(pageNum, pageSize);
|
||
LambdaQueryWrapper<RedPacket> wrapper = new LambdaQueryWrapper<>();
|
||
wrapper.eq(RedPacket::getUserId, userId)
|
||
.orderByDesc(RedPacket::getCreateTime);
|
||
return redPacketMapper.selectPage(page, wrapper);
|
||
}
|
||
|
||
/**
|
||
* 查询已收红包记录
|
||
*/
|
||
@Override
|
||
public Page<RedPacketRecv> getReceivedRecords(Long userId, Integer pageNum, Integer pageSize) {
|
||
Page<RedPacketRecv> page = new Page<>(pageNum, pageSize);
|
||
LambdaQueryWrapper<RedPacketRecv> wrapper = new LambdaQueryWrapper<>();
|
||
wrapper.eq(RedPacketRecv::getUserId, userId)
|
||
.orderByDesc(RedPacketRecv::getCreateTime);
|
||
return redPacketRecvMapper.selectPage(page, wrapper);
|
||
}
|
||
|
||
/**
|
||
* 查找进行中的游戏红包
|
||
*/
|
||
@Override
|
||
public RedPacket getOngoingGameRp(Long groupId) {
|
||
return redPacketMapper.selectOne(new LambdaQueryWrapper<RedPacket>()
|
||
.eq(RedPacket::getGroupId, groupId)
|
||
.eq(RedPacket::getType, TYPE_GAME)
|
||
.eq(RedPacket::getStatus, STATUS_ONGOING)
|
||
.isNotNull(RedPacket::getRoundId));
|
||
}
|
||
|
||
/**
|
||
* 从预分配金额中按索引顺序取值（不再修改 shareAmounts JSON）
|
||
* 兼容旧数据：如果没有预分配金额，则走随机算法
|
||
*/
|
||
private BigDecimal drawFromPreAllocatedAmounts(RedPacket rp) {
|
||
if (rp.getShareAmounts() == null || rp.getShareAmounts().isEmpty()) {
|
||
// 兼容旧数据fallback到随机
|
||
return calculateReceiveAmount(rp);
|
||
}
|
||
|
||
try {
|
||
List<BigDecimal> amounts = objectMapper.readValue(rp.getShareAmounts(),
|
||
new TypeReference<List<BigDecimal>>() {
|
||
});
|
||
if (amounts.isEmpty()) {
|
||
return calculateReceiveAmount(rp);
|
||
}
|
||
// 按 shareTakenIndex 索引取值，shareAmounts 不再被修改
|
||
Integer index = rp.getShareTakenIndex();
|
||
if (index == null || index >= amounts.size()) {
|
||
// 越界：兼容旧数据或异常情况，走随机
|
||
return calculateReceiveAmount(rp);
|
||
}
|
||
return amounts.get(index);
|
||
} catch (Exception e) {
|
||
log.error("解析shareAmounts失败: {}, error={}", rp.getShareAmounts(), e.getMessage());
|
||
return calculateReceiveAmount(rp);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 预计算红包份额金额
|
||
* targetDigit 非空时确保手气王金额尾数=targetDigit
|
||
* targetDigit 为空时按纯随机份额处理
|
||
*/
|
||
private List<BigDecimal> preCalculateShareAmounts(RedPacket rp, Integer targetDigit) {
|
||
List<BigDecimal> amounts = new ArrayList<>();
|
||
int count = rp.getTotalCount();
|
||
BigDecimal total = rp.getTotalAmount();
|
||
BigDecimal minUnit = new BigDecimal("0.01"); // 最小份额：1 分
|
||
|
||
if (count <= 1) {
|
||
amounts.add(total);
|
||
return amounts;
|
||
}
|
||
|
||
Random random = new Random();
|
||
|
||
// 1. 计算手气王金额（已保证不超过 luckyMax 且尾数=targetDigit）
|
||
BigDecimal luckyAmount = calculateLuckyAmount(total, targetDigit, count, random);
|
||
|
||
// 2. 计算其他人总额（保证每人至少 minUnit）
|
||
BigDecimal minForOthers = minUnit.multiply(BigDecimal.valueOf(count - 1));
|
||
BigDecimal remaining = total.subtract(luckyAmount);
|
||
if (remaining.compareTo(minForOthers) < 0) {
|
||
// 手气王挤占了他人最小份额，回收
|
||
luckyAmount = total.subtract(minForOthers);
|
||
if (targetDigit != null) {
|
||
luckyAmount = adjustToTargetDigit(luckyAmount, luckyAmount.add(minUnit), targetDigit);
|
||
}
|
||
remaining = minForOthers;
|
||
}
|
||
|
||
// 3. 其他人金额（带小随机波动）
|
||
// 计算 avgAmount 后，确保 luckyAmount ≥ avgAmount × 1.2（maxFactor）
|
||
// 这样循环里的 amount 自然 ≤ luckyAmount，无需钳制，金额严格守恒
|
||
double maxFactor = 1.2;
|
||
BigDecimal avgAmount = remaining.divide(BigDecimal.valueOf(count - 1), 2, RoundingMode.HALF_UP);
|
||
BigDecimal needed = avgAmount.multiply(BigDecimal.valueOf(maxFactor))
|
||
.setScale(2, RoundingMode.HALF_UP);
|
||
if (luckyAmount.compareTo(needed) < 0) {
|
||
// 手气王不够大，抬高到 needed（满足"分位尾数"=targetDigit 优先）
|
||
BigDecimal lifted = needed;
|
||
if (targetDigit != null) {
|
||
lifted = adjustToTargetDigit(lifted, total, targetDigit);
|
||
}
|
||
// 若抬高后超过 luckyMax（total - minForOthers），回退取 luckyMax 并再调尾数
|
||
BigDecimal cap = total.subtract(minForOthers);
|
||
if (lifted.compareTo(cap) > 0) {
|
||
lifted = cap;
|
||
if (targetDigit != null) {
|
||
lifted = adjustToTargetDigit(lifted, cap, targetDigit);
|
||
}
|
||
}
|
||
luckyAmount = lifted;
|
||
remaining = total.subtract(luckyAmount);
|
||
// 重新计算 avgAmount，确保循环里的金额仍 ≥ minUnit
|
||
avgAmount = remaining.divide(BigDecimal.valueOf(count - 1), 2, RoundingMode.HALF_UP);
|
||
}
|
||
amounts.add(luckyAmount);
|
||
|
||
BigDecimal remainingForOthers = remaining;
|
||
for (int i = 1; i < count - 1; i++) {
|
||
double factor = 0.8 + random.nextDouble() * 0.4;
|
||
BigDecimal amount = avgAmount.multiply(BigDecimal.valueOf(factor))
|
||
.setScale(2, RoundingMode.HALF_UP);
|
||
// 下限保护：每个份额至少 minUnit
|
||
if (amount.compareTo(minUnit) < 0) {
|
||
amount = minUnit;
|
||
}
|
||
// 累加上限：不超过 remainingForOthers
|
||
if (amount.compareTo(remainingForOthers) > 0) {
|
||
amount = remainingForOthers;
|
||
}
|
||
amounts.add(amount);
|
||
remainingForOthers = remainingForOthers.subtract(amount);
|
||
}
|
||
// 最后一个拿剩余
|
||
BigDecimal last = remainingForOthers;
|
||
// 下限保护：累减后可能 < minUnit
|
||
if (last.compareTo(minUnit) < 0) {
|
||
last = minUnit;
|
||
}
|
||
amounts.add(last.setScale(2, RoundingMode.HALF_UP));
|
||
|
||
// 打乱顺序（让领取顺序随机）
|
||
Collections.shuffle(amounts);
|
||
|
||
// 如果指定了目标尾数,确保列表中至少有1个金额的尾数=targetDigit
|
||
if (targetDigit != null) {
|
||
ensureLuckyDigit(amounts, targetDigit);
|
||
}
|
||
|
||
return amounts;
|
||
}
|
||
|
||
/**
|
||
* 计算手气王金额
|
||
* - 比例为总额的 [1/count, 50%]，下限定为 1/count 以保证 luckyAmount ≥ avgAmount
|
||
* （手气王必须 ≥ 其他人的平均金额，否则随机波动后有人会比手气王还大）
|
||
* - 有目标尾数时确保"分位尾数"=targetDigit
|
||
* - 不超过 luckyMax（total - minUnit * (count-1)），留出最小份额给其他人
|
||
*/
|
||
private BigDecimal calculateLuckyAmount(BigDecimal total, Integer targetDigit, int totalCount, Random random) {
|
||
BigDecimal minUnit = new BigDecimal("0.01");
|
||
BigDecimal minForOthers = minUnit.multiply(BigDecimal.valueOf(totalCount - 1));
|
||
BigDecimal luckyMax = total.subtract(minForOthers);
|
||
|
||
// 比例下限 1/count（保证 luckyAmount ≥ avgAmount），上限 50%
|
||
double minRatio = 1.0 / totalCount;
|
||
double ratio = minRatio + random.nextDouble() * (0.5 - minRatio);
|
||
BigDecimal luckyAmount = total.multiply(BigDecimal.valueOf(ratio))
|
||
.setScale(2, RoundingMode.HALF_UP);
|
||
|
||
// 调整尾数（如果指定）
|
||
if (targetDigit != null) {
|
||
luckyAmount = adjustToTargetDigit(luckyAmount, luckyMax, targetDigit);
|
||
}
|
||
|
||
// 上限保护：不超过 luckyMax
|
||
if (luckyAmount.compareTo(luckyMax) > 0) {
|
||
luckyAmount = luckyMax;
|
||
if (targetDigit != null) {
|
||
luckyAmount = adjustToTargetDigit(luckyAmount, luckyMax, targetDigit);
|
||
}
|
||
}
|
||
|
||
return luckyAmount;
|
||
}
|
||
|
||
/**
|
||
* 调整金额让"分位尾数"=targetDigit，且不超过 maxAllowed
|
||
* 优先向上调整（保持金额更大），如会超出则向下调整
|
||
*/
|
||
private BigDecimal adjustToTargetDigit(BigDecimal amount, BigDecimal maxAllowed, int targetDigit) {
|
||
BigDecimal minUnit = new BigDecimal("0.01");
|
||
int lastDigit = digitOf(amount);
|
||
if (lastDigit == targetDigit) {
|
||
return amount;
|
||
}
|
||
int upDiff = (targetDigit - lastDigit + 10) % 10; // 向上调（单位：分）
|
||
int downDiff = (lastDigit - targetDigit + 10) % 10; // 向下调
|
||
BigDecimal up = amount.add(BigDecimal.valueOf(upDiff).movePointLeft(2))
|
||
.setScale(2, RoundingMode.HALF_UP);
|
||
if (up.compareTo(maxAllowed) <= 0 && up.compareTo(minUnit) >= 0) {
|
||
return up;
|
||
}
|
||
BigDecimal down = amount.subtract(BigDecimal.valueOf(downDiff).movePointLeft(2))
|
||
.setScale(2, RoundingMode.HALF_UP);
|
||
if (down.compareTo(minUnit) >= 0) {
|
||
return down;
|
||
}
|
||
return amount; // 实在调不动，保持原值（兜底）
|
||
}
|
||
|
||
/**
|
||
* 取金额的"分位尾数"：金额×100 后取个位（如 0.45→5，1.05→5，0.40→0）
|
||
* BigDecimal.remainder(BigDecimal.TEN) 对小数返回自身+intValue 截断会丢精度，
|
||
* 这里按国内红包/微信红包标准按"分位"算尾数
|
||
*/
|
||
private static int digitOf(BigDecimal amount) {
|
||
if (amount == null) return 0;
|
||
return amount.movePointRight(2).remainder(BigDecimal.TEN).intValue();
|
||
}
|
||
|
||
/**
|
||
* 确保 amounts[0] 的"分位尾数"=targetDigit（手气王必须在首位）
|
||
* 如果首位已经命中则不操作；否则找一个命中项 swap 到首位；都没有则兜底不动
|
||
*/
|
||
private void ensureLuckyDigit(List<BigDecimal> amounts, int targetDigit) {
|
||
if (digitOf(amounts.get(0)) == targetDigit) {
|
||
return;
|
||
}
|
||
// 首位不命中，找一个命中项 swap 到首位
|
||
for (int i = 1; i < amounts.size(); i++) {
|
||
if (digitOf(amounts.get(i)) == targetDigit) {
|
||
Collections.swap(amounts, 0, i);
|
||
return;
|
||
}
|
||
}
|
||
// 没有任何命中项，无法保证（这种情况很罕见：total/count 太小无空间调整）
|
||
}
|
||
}
|