gold-java/src/main/java/com/example/demo/serviceImpl/coin/AuditServiceImpl.java

package com.example.demo.serviceImpl.coin;

import com.example.demo.Util.GoldTistV2;
import com.example.demo.Util.SimpleIdGenerator;
import com.example.demo.config.GlobalExceptionHandler;
import com.example.demo.config.RabbitMQConfig;
import com.example.demo.domain.entity.User;
import com.example.demo.domain.entity.UserGoldRecord;
import com.example.demo.domain.entity.UserRegionWallet;
import com.example.demo.domain.entity.UserWalletRecord;
import com.example.demo.domain.vo.coin.*;
import com.example.demo.exception.RedCheckException;
import com.example.demo.mapper.Temporary.RedMapper;
import com.example.demo.mapper.coin.AuditMapper;
import com.example.demo.mapper.coin.MarketMapper;
import com.example.demo.mapper.coin.UserMapper;
import com.example.demo.mapper.coin.WalletMapper;
import com.example.demo.service.Temporary.RedService;
import com.example.demo.service.Wallet.WalletService;
import com.example.demo.service.coin.AdminService;
import com.example.demo.service.coin.AuditService;
import com.example.demo.service.coin.GeneralService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @program: gold-java
 * @ClassName AuditServiceImpl
 * @description: 审核模块
 * @author: Ethan
 * @create: 2025−06-19 17:38
 * @Version 1.0
 **/

@Service
@Slf4j
public class AuditServiceImpl implements AuditService {
    @Autowired
    private AuditMapper auditMapper;
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RedMapper redMapper;
    @Autowired
    private AdminService adminService;
    @Autowired
    private GeneralService generalService;
    @Autowired
    private MarketMapper marketMapper;
    @Autowired
    private RedService redService;
    @Autowired
    private WalletMapper walletMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private WalletService walletService;

    /*
    审核订单并修改用户余额等
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean auditOrder(String token, String orderCode, Integer auditId, Integer action, String rejectReason, BigDecimal price, String linkId ,Integer refundModel) throws Exception {

        if (linkId == null) {
            linkId = orderCode;
        }
        UserGoldRecord order = auditMapper.selectOrderByOrderCode(orderCode);

        if (price == null) {
            price = BigDecimal.valueOf(order.getPermanentGold());
        }
        Date date = new Date();
        //状态为0待审核或4第一次红包退款失败的订单才能审核
        if (order == null || (order.getAuditStatus() != 0 && order.getAuditStatus() != 4)) {
            throw new IllegalArgumentException("订单不存在或已被审核");
        }
        GoldUser userNow = userMapper.selectUser(order.getJwcode().toString());
        //更新订单的审核状态和审核人
        UserGoldRecord updateOrder = new UserGoldRecord();
        updateOrder.setOrderCode(orderCode);
        updateOrder.setAuditId(auditId);
        String auditName = auditMapper.getName(auditId);
        //判断是通过还是驳回
        if (action == 2) {     //驳回

            if (order.getType() == 2) {  //退款
                //2.获取对应的订单（退款订单号去掉开头"TK"即为对应原始订单）
                String oldOrderCode = order.getOrderCode().replaceFirst("TK_", "");
                //3.更新消费订单是否已退款状态为0
                UserGoldRecord oldOrder = auditMapper.selectAllOrderByOrderCode(oldOrderCode);
                if (oldOrderCode != null && (oldOrder.getType() == 1 || oldOrder.getType() == 0)) {   //确保是消费或充值订单
                    auditMapper.updateOrderRefund(oldOrderCode, (byte) 0);
                } else {
                    throw new IllegalArgumentException("找不到对应的订单或不是有效订单");
                }
            }
            updateOrder.setAuditStatus(2);
            updateOrder.setRejectReason(rejectReason);
            updateOrder.setAuditTime(new Date());

            // 执行审核更新
            auditMapper.updateOrder(updateOrder);

        } else if (action == 1) {    //通过

            //判断是充值还是退款
            if (order.getType() == 0) {    //充值
                //更新用户余额
                User update = new User();
                Date oldFirstRecharge = userMapper.getFirstRecharge(order.getJwcode().toString());

                update.setJwcode(order.getJwcode());   //精网号
                update.setSumPermanentGold(BigDecimal.valueOf(order.getPermanentGold()));   //历史永久金币
                update.setSumFreeJune(BigDecimal.valueOf(order.getFreeJune())); //历史六月免费金币
                update.setSumFreeDecember(BigDecimal.valueOf(order.getFreeDecember())); //历史十二月免费金币
                update.setSumTaskGold(BigDecimal.valueOf(order.getTaskGold())); //历史任务金币
                update.setCurrentPermanentGold(BigDecimal.valueOf(order.getPermanentGold())); //当前永久金币
                update.setCurrentFreeJune(BigDecimal.valueOf(order.getFreeJune())); //当前六月免费金币
                update.setCurrentFreeDecember(BigDecimal.valueOf(order.getFreeDecember())); //当前十二月免费金币
                update.setCurrentTaskGold(BigDecimal.valueOf(order.getTaskGold())); //当前任务金币
                update.setRechargeNum(1);   //充值次数加一
                /*
                判断是否更新首充时间
                    1.用户当前首充时间为空
                    2.用户当前首充时间小于当前时间
                    3.用户当前首充时间等于2020-01-01 00:00:00
                 */
                // 构造 2020-01-01 00:00:00
                Date placeholder = new GregorianCalendar(2020, Calendar.JANUARY, 1, 0, 0).getTime();
                if (oldFirstRecharge == null || oldFirstRecharge.after(date) || placeholder.equals(oldFirstRecharge)) {
                    auditMapper.updateFirstRecharge(order.getJwcode());//设置首充时间为当前时间
                }
                auditMapper.updateUserGold(update);
              /*  //累充
                try {
                    BigDecimal sum = BigDecimal.valueOf(
                                    order.getPermanentGold())
                            .divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP);

                    redService.addAmount(order.getJwcode(), sum, 1); // ← 直接调你写好的方法！
                } catch (Exception e) {
                    log.warn("红包累加失败，主流程继续 | jwcode={}", order.getJwcode(), e);
                }
                try {
                    redService.sendJwcode(order.getJwcode(), order.getLinkId());
                    log.info("精网号发送成功 | jwcode={}", order.getJwcode());
                } catch (Exception e) {
                    log.warn("精网号发送失败，主流程继续 | jwcode={}", order.getJwcode(), e);
                }*/

                //erp增加充值数据

                GoldTistV2.addCoinNew(order.getJwcode().toString(), 64, //充值永久金币
                        (double) (order.getPermanentGold()) / 100, order.getLinkId()
                        , order.getRemark(), (double) (order.getPermanentGold()) / 100, auditName, "金币充值");
                GoldTistV2.addCoinNew(order.getJwcode().toString(), 63, //充值免费
                        (double) (order.getFreeDecember() + order.getFreeJune()) / 100, order.getLinkId(),
                        order.getRemark(), 0, auditName, "金币充值");

            } else if (order.getType() == 2) {  //退款

             /*   //对非强制退款订单进行退红包校验
                if (order.getAuditStatus() != 4) {
                    try {
                        String result = redService.checkRed(price, linkId);
                        // 设置到全局上下文
                        AuditContext.setRedCheckResult(result);
                    } catch (RedCheckException e) {
                        //  业务失败（flag=false）
                        int num = e.getNum();
                        String logMsg = String.format(
                                "红包退票失败，orderId=%s，还需扣除金币数=%d",
                                linkId, num
                        );
                        log.error(logMsg);
                        updateOrder.setAuditStatus(4);
                        updateOrder.setRedDiff(BigDecimal.valueOf(num * 100L));
                        auditMapper.updateOrder(updateOrder);
                        AuditContext.setFailMsg(logMsg);
                        return false;
                    } catch (Exception e) {
                        // 网络异常 / 系统异常
                        log.error("红包接口调用异常", e);
                        throw new RuntimeException(e);
                    }
                }*/
                //2.获取对应的订单（退款订单号去掉开头"TK"即为对应原始订单）
                String oldOrderCode = order.getOrderCode().replaceFirst("TK_", "");
                UserGoldRecord oldOrder = auditMapper.selectAllOrderByOrderCode(oldOrderCode);
                //更新用户余额
                User update = new User();
                update.setJwcode(order.getJwcode());
                update.setCurrentPermanentGold(BigDecimal.valueOf(order.getPermanentGold())); //当前永久金币
                update.setCurrentFreeJune(BigDecimal.valueOf(order.getFreeJune())); //当前六月免费金币
                update.setCurrentFreeDecember(BigDecimal.valueOf(order.getFreeDecember())); //当前十二月免费金币
                update.setCurrentTaskGold(BigDecimal.valueOf(order.getTaskGold())); //当前任务金币
                auditMapper.updateUserGold(update);

                //钱包更新
//                List<UserWalletRecord> userWalletList = walletService.selectUserWalletRecord(order.getJwcode(), oldOrderCode);
//                UserRegionWallet userRegionWallet = new UserRegionWallet();
                // 钱包更新 - 按原始扣款流水 wallet_id 优先级顺序原路退回（1-10，越小优先级越高）
// 1. 查询原始扣款流水（type=1 消耗，status=0 正常）
                List<UserWalletRecord> originalRecords = walletService.selectUserWalletRecord(order.getJwcode(), oldOrderCode);
                if (!CollectionUtils.isEmpty(originalRecords)) {
                    originalRecords = originalRecords.stream()
                            .filter(r -> r.getType() == 1 && r.getStatus() == 0)
                            // 修改点：使用 comparingInt 并 reversed
                            .sorted(Comparator.comparingInt(UserWalletRecord::getWalletId).reversed())
                            .collect(Collectors.toList());

                    // 2. 本次退款总金额
                    BigDecimal totalRefundAmount = BigDecimal.valueOf(order.getPermanentGold());

                    if (totalRefundAmount.compareTo(BigDecimal.ZERO) > 0) {
                        BigDecimal remainingRefund = totalRefundAmount;

                        // 3. 按原始流水顺序退回
                        for (UserWalletRecord record : originalRecords) {
                            if (remainingRefund.compareTo(BigDecimal.ZERO) <= 0) {
                                break;
                            }

                            Integer walletId = record.getWalletId();
                            // 🔥 关键修正：取绝对值，兼容负数存储
                            BigDecimal originalAmount = BigDecimal.valueOf(record.getAmount()).abs();
                            if (originalAmount.compareTo(BigDecimal.ZERO) <= 0) {
                                continue;
                            }

                            // 4. 计算本次退回金额 = min(原扣金额，剩余待退金额)
                            BigDecimal refundAmount = originalAmount.min(remainingRefund);
                            if (refundAmount.compareTo(BigDecimal.ZERO) <= 0) {
                                continue;
                            }

                            // 5. 插入退款流水记录（type=2 退款）
                            UserWalletRecord refundRecord = new UserWalletRecord();
                            refundRecord.setJwcode(order.getJwcode());
                            refundRecord.setWalletId(walletId);
                            refundRecord.setType(2); // 退款类型
                            refundRecord.setTransactionCurrency("金币"); // 交易币种
                            refundRecord.setAmount(refundAmount.intValue()); // 🔥 退款存正数
                            refundRecord.setOrderCode(order.getOrderCode());
                            if(refundModel==0){
                                refundRecord.setDescription("全部退款");
                            }else{
                                refundRecord.setDescription("部分退款");
                            }

                            refundRecord.setStatus(0);
                            walletService.addUserWalletRecord(refundRecord);

                            // 6. 查询并更新钱包余额（覆盖更新，先查后改）
                            UserRegionWallet currentWallet = walletMapper.selectWallet(order.getJwcode(), walletId);
                            if (currentWallet == null) {
                                log.error("钱包记录不存在，无法退款 | jwcode={}, walletId={}", order.getJwcode(), walletId);
                                continue;
                            }

                            // 7. 计算新余额 + 覆盖更新
                            BigDecimal newBalance = currentWallet.getCurrentPermanentGold().add(refundAmount);
                            currentWallet.setCurrentPermanentGold(newBalance);
                            walletMapper.updateWallet(currentWallet);
                            walletService.updateUserWalletRecord(record.getId());

                            // 8. 扣减剩余待退金额
                            remainingRefund = remainingRefund.subtract(refundAmount);
                        }
                    }
                }


                //商品消费退款
                //erp增加退款数据
                if (oldOrder.getType() == 1) {
                  /*  int type = 2;
                    //额外扣金币抵扣红包
                    if (order.getAuditStatus() == 4) {


                        // 检查用户余额是否足够抵扣红包差额

                        if (price.add(order.getRedDiff()).compareTo(userNow.getNowSumGold()) > 0) {
                            log.error("用户余额不足，无法抵扣红包 - 红包差额: {}, 用户余额: {}",
                                    order.getRedDiff(), userNow.getNowSumGold());
                            throw new IllegalArgumentException("用户余额不足，无法抵扣红包");
                        }
                        ConsumeUser consumeUser = new ConsumeUser();
                        // 1. 先扣除免费金币
                        if (order.getRedDiff().compareTo(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember()))) <= 0) {
                            // 红包差额小于等于免费金币，只扣免费金币
                            consumeUser.setJwcode(order.getJwcode());
                            consumeUser.setFreeGold(order.getRedDiff());
                            consumeUser.setPermanentGold(BigDecimal.ZERO);
                            consumeUser.setTaskGold(BigDecimal.ZERO);
                        } else {
                            // 2. 免费金币不足，扣除免费+永久金币
                            BigDecimal remainingAfterFree = order.getRedDiff().subtract(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                            if (remainingAfterFree.compareTo(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold()))) <= 0) {
                                consumeUser.setJwcode(order.getJwcode());
                                consumeUser.setFreeGold(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                                consumeUser.setPermanentGold(remainingAfterFree);
                                consumeUser.setTaskGold(BigDecimal.ZERO);
                            } else {
                                // 3. 免费+永久金币仍不足，扣除全部免费+永久+部分任务金币
                                BigDecimal remainingAfterPermanent = remainingAfterFree.subtract(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold())));
                                if (remainingAfterPermanent.compareTo(userNow.getNowTaskGold().add(BigDecimal.valueOf(order.getTaskGold()))) <= 0) {
                                    consumeUser.setJwcode(order.getJwcode());
                                    consumeUser.setFreeGold(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                                    consumeUser.setPermanentGold(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold())));
                                    consumeUser.setTaskGold(remainingAfterPermanent);
                                } else {
                                    throw new IllegalArgumentException("用户金币不足，无法抵扣红包");
                                }
                            }
                        }
                        consumeUser.setSumGold(order.getRedDiff());
                        consumeUser.setAdminId(order.getAdminId());
                        consumeUser.setRemark(order.getRemark());
                        consumeUser.setPrice(price);
                        // 执行金币抵扣红包
                        redService.updateRed(consumeUser);
                        //link扣除已有红包
                        redService.consumeRed(linkId);
                    }
                    //link扣除已有红包
                    else if (AuditContext.getRedCheckResult() != null && !AuditContext.getRedCheckResult().equals("old")) {
                        redService.consumeRed(linkId);
                    } else {
                        Exception e = new Exception("旧订单退款");
                        String title = "旧订单退款";
                        String detail = ("精网号:" + order.getJwcode()) + "\n金币订单号:" + orderCode + "\n永久金币:" + Math.abs(order.getPermanentGold()) / 100 +
                                "\n免费金币:" + Math.abs((order.getFreeJune() + order.getFreeDecember())) / 100 + "\n任务金币:" + Math.abs(order.getTaskGold()) / 100 +
                                "\n退款类型:" + order.getRefundType() + "\n商品名:" + order.getGoodsName() + "\n备注:" + order.getRemark();
                        GlobalExceptionHandler.sendFeishuAlert(e, title, detail);
                    }
                    // 执行审核更新
                    redMapper.update(order.getJwcode(), type, price.divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
*/
                    if (order.getPermanentGold() != 0 || order.getFreeJune() != 0 || order.getFreeDecember() != 0 || order.getTaskGold() != 0) {
                        GoldTistV2.addCoinNew(order.getJwcode().toString(), 55, //退款免费-商品
                                (double) (order.getFreeDecember() + order.getFreeJune()) / 100, SimpleIdGenerator.generateId(),
                                order.getRemark(), 0, auditName, "退款商品" + order.getGoodsName());
                        GoldTistV2.addCoinNew(order.getJwcode().toString(), 56, //退款永久-商品
                                (double) (order.getPermanentGold()) / 100, SimpleIdGenerator.generateId(),
                                order.getRemark(), order.getPermanentGold(), auditName, "退款商品" + order.getGoodsName());
                        GoldTistV2.addCoinNew(order.getJwcode().toString(), 57, //退款任务-商品
                                (double) (order.getTaskGold()) / 100, SimpleIdGenerator.generateId(),
                                order.getRemark(), 0, auditName, "退款商品" + order.getGoodsName());
                    } else {
                        //0金币消耗，往erp传一条金币为空的记录
                        GoldTistV2.addCoinRecordNew(String.valueOf(order.getJwcode()), order.getRemark(), auditName, order.getGoodsName());

                    }

                }//金币充值退款
                else if (oldOrder.getType() == 0) {
                    //判断够不够扣
                    if (userNow.getNowPermanentGold().compareTo(BigDecimal.valueOf(Math.abs(order.getPermanentGold()))) < 0
                            || userNow.getNowFreeGold().compareTo(BigDecimal.valueOf(Math.abs(order.getFreeDecember() + order.getFreeJune()))) < 0
                            || userNow.getNowTaskGold().compareTo(BigDecimal.valueOf(Math.abs(order.getTaskGold()))) < 0) {
                        log.error("用户余额不足，无法退款");
                        throw new IllegalArgumentException("用户余额不足，无法退款");

                    }
                /*    int type = 1;  //红包充值累计
                    //额外扣金币抵扣红包
                    if (order.getAuditStatus() == 4) {


                        // 检查用户余额是否足够抵扣红包差额

                        if (price.add(order.getRedDiff()).compareTo(userNow.getNowSumGold()) > 0) {
                            log.error("用户余额不足，无法抵扣红包 - 红包差额: {}, 用户余额: {}",
                                    order.getRedDiff(), userNow.getNowSumGold());
                            throw new IllegalArgumentException("用户余额不足，无法抵扣红包");
                        }
                        ConsumeUser consumeUser = new ConsumeUser();
                        // 1. 先扣除免费金币
                        if (order.getRedDiff().compareTo(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember()))) <= 0) {
                            // 红包差额小于等于免费金币，只扣免费金币
                            consumeUser.setJwcode(order.getJwcode());
                            consumeUser.setFreeGold(order.getRedDiff());
                            consumeUser.setPermanentGold(BigDecimal.ZERO);
                            consumeUser.setTaskGold(BigDecimal.ZERO);
                        } else {
                            // 2. 免费金币不足，扣除免费+永久金币
                            BigDecimal remainingAfterFree = order.getRedDiff().subtract(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                            if (remainingAfterFree.compareTo(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold()))) <= 0) {
                                consumeUser.setJwcode(order.getJwcode());
                                consumeUser.setFreeGold(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                                consumeUser.setPermanentGold(remainingAfterFree);
                                consumeUser.setTaskGold(BigDecimal.ZERO);
                            } else {
                                // 3. 免费+永久金币仍不足，扣除全部免费+永久+部分任务金币
                                BigDecimal remainingAfterPermanent = remainingAfterFree.subtract(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold())));
                                if (remainingAfterPermanent.compareTo(userNow.getNowTaskGold().add(BigDecimal.valueOf(order.getTaskGold()))) <= 0) {
                                    consumeUser.setJwcode(order.getJwcode());
                                    consumeUser.setFreeGold(userNow.getNowFreeGold().add(BigDecimal.valueOf(order.getFreeJune() + order.getFreeDecember())));
                                    consumeUser.setPermanentGold(userNow.getNowPermanentGold().add(BigDecimal.valueOf(order.getPermanentGold())));
                                    consumeUser.setTaskGold(remainingAfterPermanent);
                                } else {
                                    throw new IllegalArgumentException("用户金币不足，无法抵扣红包");
                                }
                            }
                        }
                        consumeUser.setSumGold(order.getRedDiff());
                        consumeUser.setAdminId(order.getAdminId());
                        consumeUser.setRemark(order.getRemark());
                        consumeUser.setPrice(price);
                        // 执行金币抵扣红包
                        redService.updateRed(consumeUser);
                        //link扣除已有红包
                        redService.consumeRed(linkId);
                    }
                    //link扣除已有红包
                    else if (AuditContext.getRedCheckResult() != null && !AuditContext.getRedCheckResult().equals("old")) {
                        redService.consumeRed(linkId);
                    } else {
                        Exception e = new Exception("旧订单退款");
                        String title = "旧订单退款";
                        String detail = ("精网号:" + order.getJwcode()) + "\n金币订单号:" + orderCode + "\n永久金币:" + Math.abs(order.getPermanentGold()) / 100 +
                                "\n免费金币:" + Math.abs((order.getFreeJune() + order.getFreeDecember())) / 100 + "\n任务金币:" + Math.abs(order.getTaskGold()) / 100 +
                                "\n退款类型:" + order.getRefundType() + "\n商品名:" + order.getGoodsName() + "\n备注:" + order.getRemark();
                        GlobalExceptionHandler.sendFeishuAlert(e, title, detail);
                    }
                    // 执行审核更新
                    redMapper.update(order.getJwcode(), type, price.divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
*/
                    if (order.getTaskGold() == 0) { //无任务金币统一走免费+永久
                        GoldTistV2.addCoinNew(order.getJwcode().toString(), 58, //退款免费+永久金币-充值
                                (double) (order.getFreeDecember() + order.getFreeJune() + order.getPermanentGold()) / 100, SimpleIdGenerator.generateId(),
                                order.getRemark(), (double) order.getPermanentGold() / 100, auditName, "退款金币充值");
                    }
                    if (order.getTaskGold() != 0) {
                        GoldTistV2.addCoinNew(order.getJwcode().toString(), 59, //退款任务+永久金币-充值
                                (double) (order.getTaskGold() + order.getPermanentGold()) / 100, SimpleIdGenerator.generateId(),
                                order.getRemark(), (double) order.getPermanentGold() / 100, auditName, "退款金币充值");
                    }

                }

            }

            updateOrder.setAuditStatus(1);
            updateOrder.setAuditTime(new Date());


            auditMapper.updateOrder(updateOrder);
        }

        return true;
    }

    /*
     * 多条件查询充值订单列表
     */
    @Override
    public PageInfo<RechargeAudit> selectRechargeBy(Integer pageNum, Integer pageSize, RechargeAudit rechargeAudit) {

        List<String> markets = marketMapper.getMarketIds(rechargeAudit.getMarkets());
        if (markets.contains("9") || markets.contains("9999")) {
            markets = null;
        }
        rechargeAudit.setMarkets(markets);
        PageHelper.startPage(pageNum, pageSize);     //必须要直接跟mapper
        List<RechargeAudit> rechargeAudits = auditMapper.selectRechargeBy(pageNum, pageSize, rechargeAudit);
        // rechargeAudit.setFreeGold(rechargeAudit.getFreeJune()+rechargeAudit.getFreeDecember());
        return new PageInfo<>(rechargeAudits);
    }

    /*
    多条件查询退款订单
    */
    @Override
    public PageInfo<RefundAudit> selectRefundBy(Integer pageNum, Integer pageSize, RefundAudit refundAudit) {


        List<String> markets = marketMapper.getMarketIds(refundAudit.getMarkets());
        if (markets.contains("9") || markets.contains("9999")) {
            markets = null;
        }
        refundAudit.setMarkets(markets);
        PageHelper.startPage(pageNum, pageSize);     //必须要直接跟mapper

        List<RefundAudit> refundAudits = auditMapper.selectRefundBy(pageNum, pageSize, refundAudit);
        //refundAudit.setFreeGold(refundAudit.getFreeJune()+refundAudit.getFreeDecember());
        return new PageInfo<>(refundAudits);
    }

    /*
    充值审核金币合计数
     */
    @Override
    public Gold sumRechargeGold(Integer pageNum, Integer pageSize, RechargeAudit rechargeAudit) {

        Gold gold = new Gold();
        //获取充值审核订单列表

        List<String> markets = marketMapper.getMarketIds(rechargeAudit.getMarkets());
        if (markets.contains("9") || markets.contains("9999")) {
            markets = null;
        }
        rechargeAudit.setMarkets(markets);
        List<RechargeAudit> rechargeAudits = auditMapper.selectRechargeBy(1, 500000, rechargeAudit);
        // 初始化累加器
        int totalNum = 0;
        int permanentGoldSum = 0;
        int freeGoldSum = 0;
// 遍历消费记录并累加金币
        for (RechargeAudit recharge : rechargeAudits) {
            // 累加永久金币
            if (recharge.getPermanentGold() != null) {
                permanentGoldSum += recharge.getPermanentGold();
            }
            // 累加免费金币
            if (recharge.getFreeJune() != null || recharge.getFreeDecember() != null) {
                freeGoldSum = freeGoldSum + recharge.getFreeJune() + recharge.getFreeDecember();
            }

            // 每遍历一条记录，总条数加1
            totalNum++;
        }
        // 将累加结果设置到Gold对象
        gold.setPermanentGolds(BigDecimal.valueOf(permanentGoldSum));
        gold.setFreeGolds(BigDecimal.valueOf(freeGoldSum));
        gold.setTotalNum(totalNum);
        return gold;
    }

    /*
    退款审核合计数
     */
    @Override
    public Gold sumRefundGold(Integer pageNum, Integer pageSize, RefundAudit refundAudit) {
        Gold gold = new Gold();
        //获取充值审核订单列表

        List<String> markets = marketMapper.getMarketIds(refundAudit.getMarkets());
        if (markets.contains("9") || markets.contains("9999")) {
            markets = null;
        }
        refundAudit.setMarkets(markets);
        List<RefundAudit> refundAudits = auditMapper.selectRefundBy(1, 500000, refundAudit);
        // 初始化累加器
        int totalNum = 0;
        int permanentGoldSum = 0;
        int freeGoldSum = 0;
        int taskGoldSum = 0;
// 遍历消费记录并累加金币
        for (RefundAudit refund : refundAudits) {
            // 累加永久金币
            if (refund.getPermanentGold() != null) {
                permanentGoldSum += refund.getPermanentGold();
            }
            // 累加免费金币
            if (refund.getFreeJune() != null || refund.getFreeDecember() != null) {
                freeGoldSum += refund.getFreeJune() + refund.getFreeDecember();
            }
            //累加任务金币
            if (refund.getTaskGold() != null)
                taskGoldSum += refund.getTaskGold();

            // 每遍历一条记录，总条数加1
            totalNum++;
        }
        // 将累加结果设置到Gold对象
        gold.setPermanentGolds(BigDecimal.valueOf(permanentGoldSum));
        gold.setFreeGolds(BigDecimal.valueOf(freeGoldSum));
        gold.setTotalNum(totalNum);
        gold.setTaskGolds(BigDecimal.valueOf(taskGoldSum));
        return gold;
    }

    public class AuditContext {

        private static final ThreadLocal<String> FAIL_MSG = new ThreadLocal<>();
        private static final ThreadLocal<String> RED_CHECK_RESULT = new ThreadLocal<>();

        public static void setFailMsg(String msg) {
            FAIL_MSG.set(msg);
        }

        public static String getFailMsg() {
            return FAIL_MSG.get();
        }

        public static void setRedCheckResult(String result) {
            RED_CHECK_RESULT.set(result);
        }

        public static String getRedCheckResult() {
            return RED_CHECK_RESULT.get();
        }

        public static void clear() {
            FAIL_MSG.remove();
            RED_CHECK_RESULT.remove();
        }
    }

}