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.domain.entity.User;
import com.example.demo.domain.entity.UserGoldRecord;
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.service.Temporary.RedService;
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.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.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

/**
 * @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;
    /*
    审核订单并修改用户余额等
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean auditOrder(String token, String orderCode, Integer auditId, Integer action,String rejectReason,BigDecimal price,String linkId) 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);

                //商品消费退款
                //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();
        }
    }

}