gold-java/src/main/java/com/example/demo/serviceImpl/cash/CashAuditServiceImpl.java

package com.example.demo.serviceImpl.cash;

import com.example.demo.Util.GoldTistV2;
import com.example.demo.Util.SimpleIdGenerator;
import com.example.demo.config.RabbitMQConfig;
import com.example.demo.domain.entity.*;
import com.example.demo.domain.vo.cash.CashCollectionMessage;
import com.example.demo.domain.vo.coin.Messages;
import com.example.demo.mapper.cash.CashAuditMapper;
import com.example.demo.mapper.cash.CashCollectionMapper;
import com.example.demo.mapper.coin.AuditMapper;
import com.example.demo.mapper.coin.MarketMapper;
import com.example.demo.mapper.coin.RateMapper;
import com.example.demo.mapper.coin.RechargeMapper;
import com.example.demo.service.cash.CashAuditService;
import lombok.extern.slf4j.Slf4j;
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.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Date;

import static net.sf.jsqlparser.parser.feature.Feature.update;

/**
 * @program: gold-java
 * @ClassName CashAuditServiceImpl
 * @description: 处理收款订单的审核业务逻辑
 * @author: Ethan
 * @create: 2025−10-08 10:09
 * @Version 1.0
 **/
@Service
@Slf4j
public class CashAuditServiceImpl implements CashAuditService {
    @Autowired
    private AuditMapper auditMapper;
    @Autowired
    private RechargeMapper rechargeMapper;
    @Autowired
    private CashCollectionMapper cashCollectionMapper;
    @Autowired
    private CashAuditMapper cashAuditMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private MarketMapper marketMapper;
    @Autowired
    private RateMapper rateMapper;


    @Transactional
    @Override
    public boolean auditCollection(String token, Integer auditId, String orderCode, Integer action, String rejectReason) {
        CashRecord order = cashCollectionMapper.selectAuditByOrderCode(orderCode);
        if (order == null || order.getStatus() != 0
        ) {
            throw new IllegalArgumentException("订单不存在或已被审核");
        }
        //带版本更新
        int updated=cashCollectionMapper.updateOrderWithVersion(orderCode, 0, auditId, order.getVersion());
        if (updated==0){
            throw new IllegalArgumentException("订单已被其他审核员审核");
        }
        CashRecord updateOrder = new CashRecord();
        //设置审核人
        updateOrder.setAuditId(auditId);
        //判断是通过还是驳回，更新审核状态
        updateOrder.setOrderCode(orderCode);
        String auditName = cashAuditMapper.getAuditName(auditId);
        if (action == 1) { //通过
            updateOrder.setStatus(1);
            if (order.getGoodsName().equals("金币充值")) {
                //往金币订单表加一条充值记录
                UserGoldRecord rechargeOrder = new UserGoldRecord();
                rechargeOrder.setOrderCode(orderCode.replaceFirst("^XJ_", "XJCZ_"));
                rechargeOrder.setJwcode(order.getJwcode());
                rechargeOrder.setActivity(order.getActivity());
                rechargeOrder.setPermanentGold(order.getPermanentGold());
                // 获取当前月份（1-12）
                int currentMonth = LocalDate.now().getMonthValue();
                // 根据当前月份设置对应字段
                if (currentMonth >= 1 && currentMonth <= 6) {
                    // 1-6 月：设置 6 月额度，12 月保持默认值
                    rechargeOrder.setFreeJune(order.getFreeGold());
                    rechargeOrder.setFreeDecember(0);
                } else {
                    // 7-12 月：设置 12 月额度，6 月保持默认值
                    rechargeOrder.setFreeJune(0);
                    rechargeOrder.setFreeDecember(order.getFreeGold());
                }
                rechargeOrder.setSumGold(order.getPermanentGold() + order.getFreeGold());
                Integer rateId = rateMapper.getIdByName(order.getPaymentCurrency());
                if (rateId == null) {
                    log.warn("未找到币种 '{}' 对应的ID，使用默认值0", order.getPaymentCurrency());
                    rateId = 0;
                }
                rechargeOrder.setRateId(rateId);
                rechargeOrder.setMoney(order.getPaymentAmount().intValue());
                rechargeOrder.setRemark(order.getRemark());
                rechargeOrder.setVoucher(order.getVoucher());
                rechargeOrder.setPayPlatform("金币系统");
                rechargeOrder.setPayModel(order.getPayType());
                //把时间转换成 Date
                Date date = Date.from(order.getPayTime().toInstant(ZoneOffset.ofHours(8)));
                rechargeOrder.setPayTime(date);
                rechargeOrder.setAdminId(order.getSubmitterId());
                rechargeOrder.setAuditId(auditId);
                rechargeOrder.setType((byte) 0);
                rechargeOrder.setAuditStatus(1);
                rechargeOrder.setCreateTime(new Date());
                order.setLinkId(SimpleIdGenerator.generateId());
                rechargeOrder.setLinkId(order.getLinkId());
                rechargeMapper.add(rechargeOrder);

                // 先从数据库中获取订单的 walletId
                CashRecord dbRecord = cashCollectionMapper.selectByOrderCode(orderCode);
                Integer walletId = dbRecord != null ? dbRecord.getWalletId() : null;

                // 充值到指定钱包
                if (walletId != null && order.getPermanentGold() > 0) {
                    try {
                        // 尝试更新用户钱包余额
                        int updateRows = cashCollectionMapper.addUserWalletPermanentGold(
                                order.getJwcode(),
                                walletId,
                                order.getPermanentGold()
                        );

                        // 如果没有更新任何行，说明记录不存在，需要插入新记录
                        if (updateRows == 0) {
                            UserRegionWallet wallet = new UserRegionWallet();
                            wallet.setJwcode(order.getJwcode());
                            wallet.setWalletId(walletId);
                            wallet.setCurrentPermanentGold(new BigDecimal(order.getPermanentGold()));
                            cashCollectionMapper.insertUserWallet(wallet);
                            log.info("创建新的钱包记录：jwcode={}, walletId={}, permanentGold={}",
                                    order.getJwcode(), walletId, order.getPermanentGold());
                        } else {
                            log.info("充值成功：jwcode={}, walletId={}, 增加金币={}",
                                    order.getJwcode(), walletId, order.getPermanentGold());
                        }

                        // 创建钱包明细记录
                        UserWalletRecord walletRecord = new UserWalletRecord();
                        walletRecord.setJwcode(order.getJwcode());
                        walletRecord.setWalletId(walletId);
                        walletRecord.setType(0); // 0=充值
                        walletRecord.setTransactionCurrency("金币");
                        walletRecord.setAmount(order.getPermanentGold());
                        walletRecord.setOrderCode(orderCode);
                        walletRecord.setDescription(order.getPayType());
                        walletRecord.setStatus(0); // 0=正常
                        cashCollectionMapper.insertUserWalletRecord(walletRecord);
                        log.info("创建钱包明细记录：jwcode={}, walletId={}, orderCode={}, amount={}",
                                order.getJwcode(), walletId, orderCode, order.getPermanentGold());

                    } catch (Exception e) {
                        log.error("充值钱包失败：jwcode={}, walletId={}, error={}",
                                order.getJwcode(), walletId, e.getMessage(), 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.getFreeGold()) / 100,order.getLinkId(),
                        order.getRemark(), 0, auditName, "金币充值");
                //修改用户余额，添加金币
                User user = new User();
                user.setJwcode(order.getJwcode());
                user.setSumConsumePermanent(BigDecimal.valueOf(order.getPermanentGold()));
                // 根据当前月份设置对应字段
                if (currentMonth >= 1 && currentMonth <= 6) {
                    // 1-6 月：设置 12 月额度，6 月保持默认值
                    user.setSumFreeJune(BigDecimal.valueOf(0));
                    user.setSumFreeDecember(BigDecimal.valueOf(order.getFreeGold()));
                    user.setCurrentFreeDecember(BigDecimal.valueOf(order.getFreeGold()));
                } else {
                    // 7-12 月：设置 6 月额度，12 月保持默认值
                    user.setSumFreeJune(BigDecimal.valueOf(order.getFreeGold()));
                    user.setCurrentFreeJune(BigDecimal.valueOf(order.getFreeGold()));
                    user.setSumFreeDecember(BigDecimal.valueOf(0));
                }
                user.setCurrentPermanentGold(BigDecimal.valueOf(order.getPermanentGold()));
                user.setRechargeNum(1); //充值次数加一
                auditMapper.updateUserGold(user);
            }
            if (order.getGoodsName().equals("免费金币赠送")) {
                //往金币订单表加一条充值记录
                UserGoldRecord rechargeOrder = new UserGoldRecord();
                rechargeOrder.setOrderCode(orderCode.replaceFirst("^XJ_", "XJCZ_"));
                rechargeOrder.setJwcode(order.getJwcode());
                rechargeOrder.setActivity(order.getActivity());
                rechargeOrder.setPermanentGold(0);
                // 获取当前月份（1-12）
                int currentMonth = LocalDate.now().getMonthValue();
                // 根据当前月份设置对应字段
                if (currentMonth >= 1 && currentMonth <= 6) {
                    // 1-6 月：设置 6 月额度，12 月保持默认值
                    rechargeOrder.setFreeJune(order.getFreeGold());
                    rechargeOrder.setFreeDecember(0);
                } else {
                    // 7-12 月：设置 12 月额度，6 月保持默认值
                    rechargeOrder.setFreeJune(0);
                    rechargeOrder.setFreeDecember(order.getFreeGold());
                }
                rechargeOrder.setSumGold(order.getFreeGold());
                rechargeOrder.setRemark(order.getRemark());
                rechargeOrder.setPayPlatform("金币系统");
                rechargeOrder.setAdminId(order.getSubmitterId());
                rechargeOrder.setAuditId(auditId);
                rechargeOrder.setType((byte) 0);
                rechargeOrder.setAuditStatus(1);
                rechargeOrder.setCreateTime(new Date());
                rechargeMapper.add(rechargeOrder);
                //往 ERP 加一条充值数据
                GoldTistV2.addCoinNew(order.getJwcode().toString(), 63, //充值免费
                        (double) (order.getFreeGold()) / 100,
                        order.getRemark(), SimpleIdGenerator.generateId(),0, auditName, "金币充值");
                //修改用户余额，添加金币
                User user = new User();
                user.setJwcode(order.getJwcode());
                user.setSumConsumePermanent(BigDecimal.valueOf(0));
                // 根据当前月份设置对应字段
                if (currentMonth >= 1 && currentMonth <= 6) {
                    // 1-6 月：设置 6 月额度，12 月保持默认值
                    user.setSumFreeJune(BigDecimal.valueOf(order.getFreeGold()));
                    user.setSumFreeJune(BigDecimal.valueOf(order.getFreeGold()));
                    user.setCurrentFreeDecember(BigDecimal.valueOf(0));
                } else {
                    // 7-12 月：设置 12 月额度，6 月保持默认值
                    user.setSumFreeJune(BigDecimal.valueOf(0));
                    user.setSumFreeDecember(BigDecimal.valueOf(order.getFreeGold()));
                    user.setSumFreeDecember(BigDecimal.valueOf(order.getFreeGold()));
                }
                user.setCurrentPermanentGold(BigDecimal.valueOf(0));
                user.setRechargeNum(1); //充值次数加一
                auditMapper.updateUserGold(user);
            }
            else {
                // 先从数据库中获取订单的 walletId
                CashRecord dbRecord = cashCollectionMapper.selectByOrderCode(orderCode);
                Integer walletId = dbRecord != null ? dbRecord.getWalletId() : null;
                // 创建钱包明细记录
                UserWalletRecord walletRecord = new UserWalletRecord();
                walletRecord.setJwcode(order.getJwcode());
                walletRecord.setWalletId(walletId);
                walletRecord.setType(3); // 3=软件购买
                walletRecord.setTransactionCurrency(order.getPaymentCurrency());
                walletRecord.setAmount(order.getPaymentAmount().intValue());
                walletRecord.setOrderCode(orderCode);
                walletRecord.setDescription(order.getGoodsName()+order.getGoodNum()+order.getNumUnit());
                walletRecord.setStatus(0); // 0=正常
                cashCollectionMapper.insertUserWalletRecord(walletRecord);
                log.info("创建钱包明细记录：jwcode={}, walletId={}, orderCode={}, amount={}",
                        order.getJwcode(), walletId, orderCode, order.getPermanentGold());
            }
        } else if (action == 2) { //驳回
            updateOrder.setStatus(2);
            updateOrder.setRejectReason(rejectReason);
        }
        //更新订单
        cashAuditMapper.updateOrder(updateOrder);
        if (action == 1){
            // 创建消息队列1，用于发送审核结果通知
            Messages message1 = new Messages();
            message1.setJwcode(order.getJwcode());
            message1.setName(order.getName());
            message1.setStatus(7);
            message1.setDesc("的收款记录需补充手续费，前往填写");
            message1.setTitle("现金管理--收款处理（负责人）");
            message1.setType(0);
            message1.setTypeId(order.getId());
            message1.setMarket(Integer.valueOf(order.getReceivedMarket()));
            String marketName1 = marketMapper.getMarketNameById(String.valueOf(message1.getMarket()));
            message1.setMarketName(marketName1);
            message1.setQueryId(86);
            rabbitTemplate.convertAndSend(RabbitMQConfig.CASH_COLLECTION_EXCHANGE, "cash.collection.save", message1);
            // 创建消息队列2，用于发送审核结果通知
            Messages message2 = new Messages();
            message2.setJwcode(order.getJwcode());
            message2.setName(order.getName());
            message2.setStatus(updateOrder.getStatus());
            message2.setDesc("的收款记录需补充手续费，前往填写");
            message2.setTitle("现金管理--收款处理");
            message2.setType(0);
            message2.setTypeId(order.getId());
            message2.setMarket(Integer.valueOf(order.getReceivedMarket()));
            String marketName2 = marketMapper.getMarketNameById(String.valueOf(message2.getMarket()));
            message2.setMarketName(marketName2);
            message2.setQueryId(74);
            rabbitTemplate.convertAndSend(RabbitMQConfig.CASH_COLLECTION_EXCHANGE, "cash.collection.save", message2);
        } else {
            // 创建消息队列，用于发送审核结果通知
            Messages message = new Messages();
            message.setJwcode(order.getJwcode());
            message.setName(order.getName());
            message.setStatus(updateOrder.getStatus());
            message.setDesc("的现金收款申请已被驳回，前往查看驳回理由");
            message.setTitle("现金管理--收款提交");
            message.setType(0);
            message.setTypeId(order.getId());
            message.setMarket(Integer.valueOf(order.getMarket()));
            String marketName = marketMapper.getMarketNameById(String.valueOf(message.getMarket()));
            message.setMarketName(marketName);
            message.setQueryId(60);
            rabbitTemplate.convertAndSend(RabbitMQConfig.CASH_COLLECTION_EXCHANGE, "cash.collection.save", message);
        }
        return true;
    }
}