gold-java/src/main/java/com/example/demo/controller/cash/CashCollectionController.java

package com.example.demo.controller.cash;

import com.example.demo.Util.JWTUtil;
import com.example.demo.Util.LanguageTranslationUtil;
import com.example.demo.config.interfac.Log;
import com.example.demo.domain.DTO.AddFundsDTO;
import com.example.demo.domain.DTO.PerformanceDTO;
import com.example.demo.domain.entity.*;
import com.example.demo.domain.vo.cash.*;
import com.example.demo.domain.vo.coin.Page;
import com.example.demo.domain.vo.coin.Result;
import com.example.demo.service.Wallet.WalletService;
import com.example.demo.service.cash.CashCollectionService;
import com.example.demo.service.coin.TranslationService;
import com.github.pagehelper.PageInfo;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @program: gold-java
 * @ClassName CashCollectionController
 * @description:
 * @author: Ethan
 * @create: 2025−09-26 10:22
 * @Version 1.0
 **/
@RestController
@RequestMapping("/cashCollection")
@RequiredArgsConstructor
@Slf4j
@CrossOrigin
public class CashCollectionController {
    @Autowired
    private CashCollectionService cashCollectionService;

    @Autowired
    private LanguageTranslationUtil languageTranslationUtil;

    @Autowired
    private TranslationService translationService;

    @Autowired
    private WalletService walletService;

    //根据精网号获取姓名和地区
    @PostMapping("/getNameAndMarket")
    public Result getNameAndMarket(@RequestBody Integer jwcode, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            Result result = cashCollectionService.getNameAndMarket(jwcode, lang);

            // 对返回结果进行多语言转换
            if (result.getCode() == 200 && result.getData() instanceof User) {
                User user = (User) result.getData();
                // 如果服务层未处理市场名称翻译，在这里进行处理
                if (user.getMarketName() != null) {
                    user.setMarketName(languageTranslationUtil.translate(user.getMarketName(), lang));
                }
            }

            return result;
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("查询失败", lang);
            return Result.error(errorMsg + ": " + e.getMessage());
        }
    }



    //获取收款活动列表
    @PostMapping("/getActivityList")
    public Result getActivityList()
    {
        List<RechargeActivity> list = cashCollectionService.getActivityList();
        return Result.success(list);
    }
    //新增收款订单
    @PostMapping("/add")
    public Result add(@RequestBody CashCollection cashCollection, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedFieldsToChinese(cashCollection, languageCode);
            }

            String result = cashCollectionService.add(cashCollection,lang);
            String successMsg = languageTranslationUtil.translate(result, lang);
            return Result.success(successMsg);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }
    //新增赠送免费金币
    @PostMapping("/addFreeCoin")
    public Result addFreeCoin(@RequestBody CashCollection cashCollection, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            return Result.success(cashCollectionService.addFreeCoin(cashCollection, lang));
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    //撤回未审核的收款订单
    @PostMapping("/cancel")
    public Result cancel(@RequestBody CashCollection cashRecord, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            String result = cashCollectionService.cancel(cashRecord.getOrderCode());
            String successMsg = languageTranslationUtil.translate(result, lang);
            return Result.success(successMsg);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //重新提交审核的收款订单
    @PostMapping("/reSubmit")
    public Result reSubmit(@RequestBody CashRecord cashRecord, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedRecordFieldsToChinese(cashRecord, languageCode);
            }

            String result = cashCollectionService.reSubmit(cashRecord, lang);
            String successMsg = languageTranslationUtil.translate(result, lang);
            return Result.success(successMsg);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //多条件查询收款订单列表
    @PostMapping("/selectCollection")
    public Result selectAll(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            if (ObjectUtils.isEmpty(page.getPageNum())) {
                String errorMsg = languageTranslationUtil.translate("页码数为空！", lang);
                return Result.error(errorMsg);
            }
            if (ObjectUtils.isEmpty(page.getPageSize())) {
                String errorMsg = languageTranslationUtil.translate("页大小为空！", lang);
                return Result.error(errorMsg);
            } else {
                //解token权限
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                String token = request.getHeader("token");
                Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
                if (admin != null) {
                    List<String> list = Arrays.asList(admin.getMarkets().split(","));
                    page.getCashCollection().setMarkets(list);

                    // 解析语言代码
                    String languageCode = parseLanguageCode(lang);

                    // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
                    if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                        convertTranslatedCollectionFieldsToChinese(page.getCashCollection(), languageCode);
                    }
                } else {
                    String errorMsg = languageTranslationUtil.translate("角色为空", lang);
                    return Result.error(errorMsg);
                }

                Result result = Result.success(cashCollectionService.selectCollection(page.getPageNum(), page.getPageSize(), page.getCashCollection()));

                // 对返回结果进行多语言转换
                if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
                    PageInfo<CashCollection> pageInfo = (PageInfo<CashCollection>) result.getData();
                    translateCashCollections(pageInfo, lang);
                }

                return result;
            }
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    @PostMapping("/export")
    public Result export(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        try {
            if (ObjectUtils.isEmpty(page.getPageNum())) {
                String errorMsg = languageTranslationUtil.translate("页码数为空！", lang);
                return Result.error(errorMsg);
            }
            if (ObjectUtils.isEmpty(page.getPageSize())) {
                String errorMsg = languageTranslationUtil.translate("页大小为空！", lang);
                return Result.error(errorMsg);
            }

            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedCollectionFieldsToChinese(page.getCashCollection(), languageCode);
            }

            Result result = Result.success(cashCollectionService.selectCollection(page.getPageNum(), page.getPageSize(), page.getCashCollection()));

            // 对返回结果进行多语言转换
            if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
                PageInfo<CashCollection> pageInfo = (PageInfo<CashCollection>) result.getData();
                translateCashCollections(pageInfo, lang);
            }

            return result;
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //补全手续费等
    @PostMapping("/complete")
    public Result complete(@RequestBody CashRecord cashRecord, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedRecordFieldsToChinese(cashRecord, languageCode);
            }

            String result = cashCollectionService.complete(cashRecord);
            String successMsg = languageTranslationUtil.translate(result, lang);
            return Result.success(successMsg);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //同步g_order订单到cash_record表
    @PostMapping("/syncToCashRecord")
    public Result syncToCashRecord(@RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            Object result = cashCollectionService.syncToCashRecord();
            return Result.success(result);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //根据id查询收款订单
    @PostMapping("/selectById")
    public Result selectById(@RequestBody CashCollection cashCollection, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            CashCollection result = cashCollectionService.selectById(cashCollection);

            // 对返回结果进行多语言转换
            if (result != null) {
                translateSingleCashCollection(result, lang);
            }

            return Result.success(result);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //根据gold coin订单号查询收款订单
    @PostMapping("/selectByGoldCoinOrderCode")
    public Result selectByGoldCoinOrderCode(@RequestBody String orderNo, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            CashCollection result = cashCollectionService.selectByGoldCoinOrderCode(orderNo);

            // 对返回结果进行多语言转换
            if (result != null) {
                translateSingleCashCollection(result, lang);
            }

            return Result.success(result);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    //根据id查询收款订单
    @PostMapping("/performanceSelect")
    public Result performanceSelect(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedPerformanceFieldsToChinese(page.getPerformanceVO(), languageCode);
            }

            Result result = Result.success(cashCollectionService.performanceSelect(page.getPageNum(), page.getPageSize(), page.getPerformanceDTO()));

            // 对返回结果进行多语言转换
            if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
                PageInfo<PerformanceVO> pageInfo = (PageInfo<PerformanceVO>) result.getData();
                translatePerformanceVOs(pageInfo, lang);
            }

            return result;
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    // 根据精网号和钱包 ID 查询用户钱包明细列表
    @PostMapping("/selectWalletRecords")
    public Result selectWalletRecords(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            if (ObjectUtils.isEmpty(page.getPageNum())) {
                return Result.error("页码数为空！");
            }
            if (ObjectUtils.isEmpty(page.getPageSize())) {
                return Result.error("页大小为空！");
            }

            UserWalletRecord queryCondition = page.getUserWalletRecord();
            if (queryCondition == null ||
                    (queryCondition.getJwcode() == null && queryCondition.getWalletId() == null)) {
                return Result.error("精网号和钱包 ID 不能同时为空");
            }

            Result result = Result.success(cashCollectionService.selectWalletRecordsByJwcodeAndWalletId(
                    page.getPageNum(),
                    page.getPageSize(),
                    queryCondition.getJwcode(),
                    queryCondition.getWalletId()
            ));

            // 对返回结果进行多语言转换
            if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
                PageInfo<UserWalletRecordVO> pageInfo = (PageInfo<UserWalletRecordVO>) result.getData();
                translateWalletRecordVOs(pageInfo, lang);
            }

            return result;
        } catch (Exception e) {
            return Result.error("查询失败" + ": " + e.getMessage());
        }
    }

    // 根据精网号和地区查询用户的所有钱包 ID 和金币数量
    @PostMapping("/selectUserWallets")
    public Result selectUserWallets(@RequestBody Map<String, Object> params, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            Integer jwcode = null;
            String market = null;
            Integer pageNum = null;
            Integer pageSize = null;

            if (params.containsKey("jwcode")) {
                Object jwcodeObj = params.get("jwcode");
                if (jwcodeObj != null) {
                    String jwcodeStr = jwcodeObj.toString();
                    if (!jwcodeStr.isEmpty()) {
                        try {
                            jwcode = ((Number) jwcodeObj).intValue();
                        } catch (Exception e) {
                            // 如果转换失败，保持为 null
                        }
                    }
                }
            }

            if (params.containsKey("market")) {
                Object marketObj = params.get("market");
                if (marketObj != null && !marketObj.toString().isEmpty()) {
                    market = marketObj.toString();
                }
            }

            if (params.containsKey("pageNum")) {
                Object pageNumObj = params.get("pageNum");
                if (pageNumObj != null && !pageNumObj.toString().isEmpty()) {
                    try {
                        pageNum = ((Number) pageNumObj).intValue();
                    } catch (Exception e) {
                        pageNum = 1;
                    }
                }
            }

            if (params.containsKey("pageSize")) {
                Object pageSizeObj = params.get("pageSize");
                if (pageSizeObj != null && !pageSizeObj.toString().isEmpty()) {
                    try {
                        pageSize = ((Number) pageSizeObj).intValue();
                    } catch (Exception e) {
                        pageSize = 10;
                    }
                }
            }

            if (pageNum == null) {
                pageNum = 1;
            }
            if (pageSize == null) {
                pageSize = 10;
            }

            PageInfo<UserWalletVO> result = cashCollectionService.selectUserWallets(jwcode, market, pageNum, pageSize);

            // 对返回结果进行多语言转换
            if (result != null && result.getList() != null) {
                for (UserWalletVO vo : result.getList()) {
                    translateUserWalletVO(vo, lang);
                }
            }
            return Result.success(result);
        } catch (Exception e) {
            return Result.error("查询失败" + ": " + e.getMessage());
        }
    }
    /**
     *新增流水-其他收入
     */

    @PostMapping("/addExFund")
    public Result addExFund(@RequestBody CashCollection addFundsDTO, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            String result = cashCollectionService.addExFund(addFundsDTO);
            return Result.success(result);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate(e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 查询所有钱包类型
     */
    @Log("查询所有钱包类型")
    @PostMapping("/selectAllWallets")
    public Result selectAllWallets(@RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            List<Wallet> wallets = walletService.selectAllWallets();

            // 对钱包名称进行多语言转换
            if (wallets != null && !"zh".equalsIgnoreCase(parseLanguageCode(lang))
                    && !"zh_cn".equalsIgnoreCase(parseLanguageCode(lang))) {
                for (Wallet wallet : wallets) {
                    if (wallet.getWalletName() != null) {
                        wallet.setWalletName(
                                languageTranslationUtil.translate(wallet.getWalletName().toString(), lang)
                        );
                    }
                }
            }

            return Result.success(wallets);
        } catch (Exception e) {
            log.error("查询所有钱包类型失败", e);
            return Result.error("查询失败");
        }
    }
    /**
     * 转换用户钱包 VO 的多语言字段
     */
    private void translateUserWalletVO(UserWalletVO vo, String lang) {
        if (vo != null) {
            // 翻译地区名称
            if (vo.getMarketName() != null) {
                vo.setMarketName(languageTranslationUtil.translate(vo.getMarketName(), lang));
            }

            // 翻译钱包名称
            if (vo.getWalletList() != null) {
                for (WalletItem wallet : vo.getWalletList()) {
                    if (wallet.getWalletName() != null) {
                        wallet.setWalletName(languageTranslationUtil.translate(wallet.getWalletName(), lang));
                    }
                }
            }
        }
    }

    /**
     * 转换现金收款订单的多语言字段
     */
    private void translateCashCollections(PageInfo<CashCollection> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (CashCollection collection : pageInfo.getList()) {
                translateSingleCashCollection(collection, lang);
            }
        }
    }

    /**
     * 转换单个现金收款订单的多语言字段
     */
    private void translateSingleCashCollection(CashCollection collection, String lang) {
        if (collection != null) {
            // 翻译市场名称
            if (collection.getMarketName() != null) {
                collection.setMarketName(languageTranslationUtil.translate(collection.getMarketName(), lang));
            }
            // 翻译商品名称
            if (collection.getGoodsName() != null) {
                collection.setGoodsName(languageTranslationUtil.translate(collection.getGoodsName(), lang));
            }
            // 翻译支付方式
            if (collection.getPayType() != null) {
                collection.setPayType(languageTranslationUtil.translate(collection.getPayType(), lang));
            }
            // 翻译到账地区
            if (collection.getReceivedMarket() != null) {
                collection.setReceivedMarket(languageTranslationUtil.translate(collection.getReceivedMarket(), lang));
            }
            // 翻译支付币种
            if (collection.getPaymentCurrency() != null) {
                collection.setPaymentCurrency(languageTranslationUtil.translate(collection.getPaymentCurrency(), lang));
            }
            // 翻译到账币种
            if (collection.getReceivedCurrency() != null) {
                collection.setReceivedCurrency(languageTranslationUtil.translate(collection.getReceivedCurrency(), lang));
            }
            // 翻译数量单位
            if (collection.getNumUnit() != null) {
                collection.setNumUnit(languageTranslationUtil.translate(collection.getNumUnit(), lang));
            }
        }
    }

    /**
     * 转换绩效数据的多语言字段
     */
    private void translatePerformanceVOs(PageInfo<PerformanceVO> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (PerformanceVO performance : pageInfo.getList()) {
                translateSinglePerformanceVO(performance, lang);
            }
        }
    }

    /**
     * 转换单个绩效数据的多语言字段
     */
    private void translateSinglePerformanceVO(PerformanceVO performance, String lang) {
        if (performance != null) {
            // 翻译市场名称
            if (performance.getMarketName() != null) {
                performance.setMarketName(languageTranslationUtil.translate(performance.getMarketName(), lang));
            }
            // 翻译支付币种
            if (performance.getPaymentCurrency() != null) {
                performance.setPaymentCurrency(languageTranslationUtil.translate(performance.getPaymentCurrency(), lang));
            }
            // 翻译到账币种
            if (performance.getReceivedCurrency() != null) {
                performance.setReceivedCurrency(languageTranslationUtil.translate(performance.getReceivedCurrency(), lang));
            }
        }
    }

    /**
     * 解析语言代码
     */
    private String parseLanguageCode(String langHeader) {
        if (langHeader == null || langHeader.isEmpty()) {
            return "zh";
        }
        // 处理类似 "en-US" 或 "zh-TW" 的情况
        if (langHeader.contains("-")) {
            String[] parts = langHeader.split("-");
            // 特殊处理中文繁体
            if ("zh".equalsIgnoreCase(parts[0]) && "TW".equalsIgnoreCase(parts[1])) {
                return "zh_TW";
            }
            return parts[0].toLowerCase();
        }
        return langHeader.toLowerCase();
    }

    /**
     * 将收款订单查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedFieldsToChinese(CashCollection cashCollection, String languageCode) {
        if (cashCollection != null) {
            // 转换商品名称
            if (cashCollection.getGoodsName() != null && !cashCollection.getGoodsName().isEmpty()) {
                String chineseGoodsName = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getGoodsName(), languageCode);
                cashCollection.setGoodsName(chineseGoodsName);
            }

            // 转换支付方式
            if (cashCollection.getPayType() != null && !cashCollection.getPayType().isEmpty()) {
                String chinesePayType = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getPayType(), languageCode);
                cashCollection.setPayType(chinesePayType);
            }

            // 转换到账地区
            if (cashCollection.getReceivedMarket() != null && !cashCollection.getReceivedMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getReceivedMarket(), languageCode);
                cashCollection.setReceivedMarket(chineseMarket);
            }

            // 转换所属地区名称
            if (cashCollection.getMarketName() != null && !cashCollection.getMarketName().isEmpty()) {
                String chineseMarketName = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getMarketName(), languageCode);
                cashCollection.setMarketName(chineseMarketName);
            }

            // 转换数量单位
            if (cashCollection.getNumUnit() != null && !cashCollection.getNumUnit().isEmpty()) {
                String chineseNumUnit = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getNumUnit(), languageCode);
                cashCollection.setNumUnit(chineseNumUnit);
            }
        }
    }

    /**
     * 将现金记录查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedRecordFieldsToChinese(CashRecord cashRecord, String languageCode) {
        if (cashRecord != null) {
            // 转换商品名称
            if (cashRecord.getGoodsName() != null && !cashRecord.getGoodsName().isEmpty()) {
                String chineseGoodsName = translationService.findChineseSimplifiedByTranslation(
                        cashRecord.getGoodsName(), languageCode);
                cashRecord.setGoodsName(chineseGoodsName);
            }

            // 转换支付方式
            if (cashRecord.getPayType() != null && !cashRecord.getPayType().isEmpty()) {
                String chinesePayType = translationService.findChineseSimplifiedByTranslation(
                        cashRecord.getPayType(), languageCode);
                cashRecord.setPayType(chinesePayType);
            }

            // 转换到账地区
            if (cashRecord.getReceivedMarket() != null && !cashRecord.getReceivedMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        cashRecord.getReceivedMarket(), languageCode);
                cashRecord.setReceivedMarket(chineseMarket);
            }

            // 转换原始付款币种
            if (cashRecord.getPaymentCurrencyOrig() != null && !cashRecord.getPaymentCurrencyOrig().isEmpty()) {
                String chinesePaymentCurrencyOrig = translationService.findChineseSimplifiedByTranslation(
                        cashRecord.getPaymentCurrencyOrig(), languageCode);
                cashRecord.setPaymentCurrencyOrig(chinesePaymentCurrencyOrig);
            }
        }
    }

    /**
     * 将收款订单列表查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedCollectionFieldsToChinese(CashCollection cashCollection, String languageCode) {
        if (cashCollection != null) {
            // 转换商品名称
            if (cashCollection.getGoodsName() != null && !cashCollection.getGoodsName().isEmpty()) {
                String chineseGoodsName = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getGoodsName(), languageCode);
                cashCollection.setGoodsName(chineseGoodsName);
            }

            // 转换支付方式
            if (cashCollection.getPayType() != null && !cashCollection.getPayType().isEmpty()) {
                String chinesePayType = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getPayType(), languageCode);
                cashCollection.setPayType(chinesePayType);
            }

            // 转换到账地区
            if (cashCollection.getReceivedMarket() != null && !cashCollection.getReceivedMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getReceivedMarket(), languageCode);
                cashCollection.setReceivedMarket(chineseMarket);
            }

            // 转换支付币种
            if (cashCollection.getPaymentCurrency() != null && !cashCollection.getPaymentCurrency().isEmpty()) {
                String chineseCurrency = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getPaymentCurrency(), languageCode);
                cashCollection.setPaymentCurrency(chineseCurrency);
            }

            // 转换到账币种
            if (cashCollection.getReceivedCurrency() != null && !cashCollection.getReceivedCurrency().isEmpty()) {
                String chineseCurrency = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getReceivedCurrency(), languageCode);
                cashCollection.setReceivedCurrency(chineseCurrency);
            }

            // 转换提交人地区
            if (cashCollection.getSubmitterMarket() != null && !cashCollection.getSubmitterMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getSubmitterMarket(), languageCode);
                cashCollection.setSubmitterMarket(chineseMarket);
            }

            // 转换所属地区名称
            if (cashCollection.getMarketName() != null && !cashCollection.getMarketName().isEmpty()) {
                String chineseMarketName = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getMarketName(), languageCode);
                cashCollection.setMarketName(chineseMarketName);
            }

            // 转换数量单位
            if (cashCollection.getNumUnit() != null && !cashCollection.getNumUnit().isEmpty()) {
                String chineseNumUnit = translationService.findChineseSimplifiedByTranslation(
                        cashCollection.getNumUnit(), languageCode);
                cashCollection.setNumUnit(chineseNumUnit);
            }
        }
    }

    /**
     * 将绩效查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedPerformanceFieldsToChinese(PerformanceVO performanceVO, String languageCode) {
        if (performanceVO != null) {
            // 转换市场名称
            if (performanceVO.getMarketName() != null && !performanceVO.getMarketName().isEmpty()) {
                String chineseMarketName = translationService.findChineseSimplifiedByTranslation(
                        performanceVO.getMarketName(), languageCode);
                performanceVO.setMarketName(chineseMarketName);
            }

            // 转换支付币种
            if (performanceVO.getPaymentCurrency() != null && !performanceVO.getPaymentCurrency().isEmpty()) {
                String chinesePaymentCurrency = translationService.findChineseSimplifiedByTranslation(
                        performanceVO.getPaymentCurrency(), languageCode);
                performanceVO.setPaymentCurrency(chinesePaymentCurrency);
            }

            // 转换到账币种
            if (performanceVO.getReceivedCurrency() != null && !performanceVO.getReceivedCurrency().isEmpty()) {
                String chineseReceivedCurrency = translationService.findChineseSimplifiedByTranslation(
                        performanceVO.getReceivedCurrency(), languageCode);
                performanceVO.setReceivedCurrency(chineseReceivedCurrency);
            }
        }
    }

    /**
     * 转换用户钱包明细 VO 列表的多语言字段
     */
    private void translateWalletRecordVOs(PageInfo<UserWalletRecordVO> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (UserWalletRecordVO vo : pageInfo.getList()) {
                translateWalletRecordVO(vo, lang);
            }
        }
    }

    /**
     * 转换用户钱包明细 VO 的多语言字段
     */
    private void translateWalletRecordVO(UserWalletRecordVO vo, String lang) {
        if (vo != null) {
            // 翻译地区名称
            if (vo.getMarketName() != null) {
                vo.setMarketName(languageTranslationUtil.translate(vo.getMarketName(), lang));
            }
            // 翻译钱包名称
            if (vo.getWalletName() != null) {
                vo.setWalletName(languageTranslationUtil.translate(vo.getWalletName(), lang));
            }
            // 翻译交易说明
            if (vo.getDescription() != null) {
                vo.setDescription(languageTranslationUtil.translate(vo.getDescription(), lang));
            }
            // 翻译交易类型
            if (vo.getType() != null) {
                String typeText = vo.getType() == 0 ? "充值" : (vo.getType() == 1 ? "消耗" : "退款");
                vo.setTypeText(languageTranslationUtil.translate(typeText, lang));
            }
            // 翻译状态
            if (vo.getStatus() != null) {
                String statusText = vo.getStatus() == 0 ? "正常" : "已退款";
                vo.setStatusText(languageTranslationUtil.translate(statusText, lang));
            }
            // 翻译交易币种
            if (vo.getTransactionCurrency() != null) {
                vo.setTransactionCurrency(languageTranslationUtil.translate(vo.getTransactionCurrency(), lang));
            }
        }
    }
}