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.domain.entity.User;
import com.example.demo.domain.entity.UserGoldRecord;
import com.example.demo.domain.vo.coin.Gold;
import com.example.demo.domain.vo.coin.GoldUser;
import com.example.demo.domain.vo.coin.RechargeAudit;
import com.example.demo.domain.vo.coin.RefundAudit;
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 AdminService adminService;
    @Autowired
    private GeneralService generalService;
    @Autowired
    private MarketMapper marketMapper;
    @Autowired
    private RedService redService;
    /*
    审核订单并修改用户余额等
     */
    @Transactional
    @Override
    public boolean auditOrder(String token, String orderCode, Integer auditId, Integer action,String rejectReason) {
                        UserGoldRecord order=auditMapper.selectOrderByOrderCode(orderCode);
                        Date date =new Date();
                        if (order == null || order.getAuditStatus() != 0) {
                            throw new IllegalArgumentException("订单不存在或已被审核");
                        }
                        //更新订单的审核状态和审核人
                        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());
                    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.getRemark(),(double) (order.getPermanentGold() ) /100, auditName, "金币充值");
                    GoldTistV2.addCoinNew(order.getJwcode().toString(), 63, //充值免费
                            (double) (order.getFreeDecember()+order.getFreeJune() ) /100,
                            order.getRemark(),0, auditName, "金币充值");

            }else if (order.getType()==2) {  //退款
                //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){ //消费
                          GoldTistV2.addCoinNew(order.getJwcode().toString(), 55, //退款免费-商品
                            (double) (order.getFreeDecember()+order.getFreeJune()) /100,
                            order.getRemark(),0, auditName, "退款商品"+order.getGoodsName());
                          GoldTistV2.addCoinNew(order.getJwcode().toString(), 56, //退款永久-商品
                            (double) (order.getPermanentGold()) /100,
                            order.getRemark(),order.getPermanentGold(), auditName, "退款商品"+order.getGoodsName());
                          GoldTistV2.addCoinNew(order.getJwcode().toString(), 57, //退款任务-商品
                            (double) (order.getTaskGold() ) /100,
                            order.getRemark(),0, auditName, "退款商品"+order.getGoodsName());
                } else if (oldOrder.getType()==0){//充值金币
                    if(order.getTaskGold()==0){ //无任务金币统一走免费+永久
                    GoldTistV2.addCoinNew(order.getJwcode().toString(), 58, //退款免费+永久金币-充值
                        (double) (order.getFreeDecember()+order.getFreeJune()+order.getPermanentGold() ) /100,
                        order.getRemark(),(double) order.getPermanentGold() / 100, auditName, "退款金币充值");}
                    if (order.getTaskGold()!=0)
                    GoldTistV2.addCoinNew(order.getJwcode().toString(), 59, //退款任务+永久金币-充值
                        (double) (order.getTaskGold()+order.getPermanentGold() ) /100,
                        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;
    }
}