gold-java/src/main/java/com/example/demo/controller/bean/BeanConsumeController.java

package com.example.demo.controller.bean;

import com.example.demo.config.interfac.Log;
import com.example.demo.domain.vo.bean.BeanConsume;
import com.example.demo.domain.vo.bean.BeanConsumeGold;
import com.example.demo.domain.vo.bean.BeanRecharge;
import com.example.demo.domain.vo.coin.Page;
import com.example.demo.domain.vo.coin.Result;
import com.example.demo.service.bean.BeanConsumeService;
import com.example.demo.Util.LanguageTranslationUtil;
import com.example.demo.service.coin.TranslationService;
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 java.util.List;

/**
 * @program: gold-java
 * @ClassName BeanConsumeController
 * @description: 金豆消耗
 * @author: Ethan
 * @create: 2025−07-30 11:30
 * @Version 1.0
 **/
@RestController
@RequestMapping("/beanConsume")
@RequiredArgsConstructor
@Slf4j
@CrossOrigin
public class BeanConsumeController {
    @Autowired
    private BeanConsumeService beanConsumeService;

    @Autowired
    private LanguageTranslationUtil languageTranslationUtil;

    @Autowired
    private TranslationService translationService;

    //获取角色的权限
    @PostMapping("/getRoleChannel")
    public Result getRoleChannel(@RequestBody Integer roleId){
       return Result.success(beanConsumeService.getRoleChannel(roleId));
    }
    //获取消费用户分部信息
    @PostMapping("/getDept")
    public Result getDept(@RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            List<String> deptList = beanConsumeService.getDept();

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

            // 如果不是中文环境，先将翻译后的分部名称转换为中文简体进行处理
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedDeptNamesToChinese(deptList, languageCode);
            }

            // 对分部名称进行多语言转换
            translateDeptNames(deptList, lang);

            return Result.success(deptList);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("获取分部信息失败", lang);
            return Result.error(errorMsg);
        }
    }

    //获取直播消费用户分部信息
    @PostMapping("/getLiveDept")
    public Result getLiveDept(@RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            List<String> deptList = beanConsumeService.getLiveDept();

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

            // 如果不是中文环境，先将翻译后的分部名称转换为中文简体进行处理
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedLiveDeptNamesToChinese(deptList, languageCode);
            }

            // 对分部名称进行多语言转换
            translateLiveDeptNames(deptList, lang);

            return Result.success(deptList);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("获取直播分部信息失败", lang);
            return Result.error(errorMsg);
        }
    }

    //减少金豆
    @PostMapping("/reduce")
    public Result reduce(@RequestBody BeanConsume consume, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            return beanConsumeService.reduce(consume);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("减少失败", lang);
            return Result.error(errorMsg);
        }
    }

    //筛选查询直播消费记录
    @Log("查询直播消费记录")
    @PostMapping("/selectLiveBy")
    public Result selectLiveBy(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            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 {
                Result result = Result.success(beanConsumeService.selectLiveBy(page.getPageNum(), page.getPageSize(), page.getBeanConsumeLive()));

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

                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorMsg = languageTranslationUtil.translate("查询直播消费记录失败", lang);
            return Result.error(errorMsg);
        }
    }

    //筛选查询铁粉消费记录
    @Log("查询铁粉消费记录")
    @PostMapping("/selectFanBy")
    public Result selectFanBy(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            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 {
                Result result = Result.success(beanConsumeService.selectFanBy(page.getPageNum(), page.getPageSize(), page.getBeanConsumeFan()));

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

                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorMsg = languageTranslationUtil.translate("查询铁粉消费记录失败", lang);
            return Result.error(errorMsg);
        }
    }

    //筛选查询文章消费记录
    @Log("查询文章消费记录")
    @PostMapping("/selectArticleBy")
    public Result selectArticleBy(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            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 {
                Result result = Result.success(beanConsumeService.selectArticleBy(page.getPageNum(), page.getPageSize(), page.getBeanConsumeArticle()));

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

                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorMsg = languageTranslationUtil.translate("查询文章消费记录失败", lang);
            return Result.error(errorMsg);
        }
    }

    //筛选查询小黄车消费记录
    @Log("查询小黄车消费记录")
    @PostMapping("/selectCartBy")
    public Result selectCartBy(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            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 {
                Result result = Result.success(beanConsumeService.selectCartBy(page.getPageNum(), page.getPageSize(), page.getBeanConsumeCartDTO()));

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

                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorMsg = languageTranslationUtil.translate("查询小黄车消费记录失败", lang);
            return Result.error(errorMsg);
        }
    }

    //消费合计数
    @PostMapping("sumConsumeGold")
    public BeanConsumeGold sumConsumeGold(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang)  {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            return beanConsumeService.sumConsumeGold(page);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("计算消费合计数失败", lang);
            throw new RuntimeException(errorMsg, e);
        }
    }

    //查询所有直播礼物
    @PostMapping("/getLiveGift")
    public Result getLiveGift(@RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            List<String> giftList = beanConsumeService.getLiveGift();

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

            // 如果不是中文环境，先将翻译后的礼物名称转换为中文简体进行处理
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedGiftNamesToChinese(giftList, languageCode);
            }

            // 对礼物名称进行多语言转换
            translateGiftNames(giftList, lang);

            return Result.success(giftList);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("获取直播礼物失败", lang);
            return Result.error(errorMsg);
        }
    }

    //查询所有直播频道
    @PostMapping("/getLiveChannel")
    public Result getLiveChannel(@RequestHeader(defaultValue = "zh_CN") String lang){
        try {
            List<String> channelList = beanConsumeService.getLiveChannel();

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

            // 如果不是中文环境，先将翻译后的频道名称转换为中文简体进行处理
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedChannelNamesToChinese(channelList, languageCode);
            }

            // 对频道名称进行多语言转换
            translateChannelNames(channelList, lang);

            return Result.success(channelList);
        } catch (Exception e) {
            String errorMsg = languageTranslationUtil.translate("获取直播频道失败", lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 将是否为背包礼物数字转换为中文描述
     */
    private String convertIsBackpackGiftToString(Integer isBackpackGift) {
        if (isBackpackGift == null) return "";
        switch (isBackpackGift) {
            case 0: return "否";
            case 1: return "是";
            default: return "未知";
        }
    }

    /**
     * 将文章消费明细类型数字转换为中文描述
     */
    private String convertTypeToString(Integer type) {
        if (type == null) return "";
        switch (type) {
            case 9, 10: return "打赏";
            case 11: return "付费";
            default: return "未知";
        }
    }

    /**
     * 转换直播消费记录的多语言字段
     */
    private void translateBeanConsumeLives(com.github.pagehelper.PageInfo<?> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (Object obj : pageInfo.getList()) {
                if (obj instanceof com.example.demo.domain.vo.bean.BeanConsumeLive) {
                    com.example.demo.domain.vo.bean.BeanConsumeLive live = (com.example.demo.domain.vo.bean.BeanConsumeLive) obj;
                    // 翻译分部名称
                    if (live.getDept() != null) {
                        live.setDept(languageTranslationUtil.translate(live.getDept(), lang));
                    }
                    // 翻译礼物名称
                    if (live.getGift() != null) {
                        live.setGift(languageTranslationUtil.translate(live.getGift(), lang));
                    }
                    // 翻译直播频道
                    if (live.getLiveChannel() != null) {
                        live.setLiveChannel(languageTranslationUtil.translate(live.getLiveChannel(), lang));
                    }
                    // 翻译直播名称
                    if (live.getLiveName() != null) {
                        live.setLiveName(languageTranslationUtil.translate(live.getLiveName(), lang));
                    }
                    // 翻译是否为背包礼物
                    if (live.getIsBackpack() != null) {
                        String isBackpackGiftDesc = convertIsBackpackGiftToString(live.getIsBackpack());
                        live.setIsBackpackDesc(languageTranslationUtil.translate(isBackpackGiftDesc, lang));
                    }
                }
            }
        }
    }

    /**
     * 转换铁粉消费记录的多语言字段
     */
    private void translateBeanConsumeFans(com.github.pagehelper.PageInfo<?> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (Object obj : pageInfo.getList()) {
                if (obj instanceof com.example.demo.domain.vo.bean.BeanConsumeFan) {
                    com.example.demo.domain.vo.bean.BeanConsumeFan fan = (com.example.demo.domain.vo.bean.BeanConsumeFan) obj;
                    // 翻译分部名称
                    if (fan.getDept() != null) {
                        fan.setDept(languageTranslationUtil.translate(fan.getDept(), lang));
                    }
                    // 翻译频道名称
                    if (fan.getChannel() != null) {
                        fan.setChannel(languageTranslationUtil.translate(fan.getChannel(), lang));
                    }
                }
            }
        }
    }

    /**
     * 转换文章消费记录的多语言字段
     */
    private void translateBeanConsumeArticles(com.github.pagehelper.PageInfo<?> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (Object obj : pageInfo.getList()) {
                if (obj instanceof com.example.demo.domain.vo.bean.BeanConsumeArticle) {
                    com.example.demo.domain.vo.bean.BeanConsumeArticle article = (com.example.demo.domain.vo.bean.BeanConsumeArticle) obj;
                    // 翻译分部名称
                    if (article.getDept() != null) {
                        article.setDept(languageTranslationUtil.translate(article.getDept(), lang));
                    }
                    // 翻译文章名称
                    if (article.getArticleName() != null) {
                        article.setArticleName(languageTranslationUtil.translate(article.getArticleName(), lang));
                    }
                    // 翻译类型
                    if (article.getType() != null) {
                        String typeDesc = convertTypeToString(article.getType());
                        article.setTypeDesc(languageTranslationUtil.translate(typeDesc, lang));
                    }
                }
            }
        }
    }

    /**
     * 转换小黄车消费记录的多语言字段
     */
    private void translateBeanConsumeCarts(com.github.pagehelper.PageInfo<?> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (Object obj : pageInfo.getList()) {
                if (obj instanceof com.example.demo.domain.vo.bean.BeanConsumeCartVo) {
                    com.example.demo.domain.vo.bean.BeanConsumeCartVo cart = (com.example.demo.domain.vo.bean.BeanConsumeCartVo) obj;
                    // 翻译分部名称
                    if (cart.getMarket() != null) {
                        cart.setMarket(languageTranslationUtil.translate(cart.getMarket(), lang));
                    }
                    // 翻译产品名称
                    if (cart.getProductName() != null) {
                        cart.setProductName(languageTranslationUtil.translate(cart.getProductName(), lang));
                    }
                }
            }
        }
    }

    /**
     * 转换分部名称为指定语言
     */
    private void translateDeptNames(List<String> deptNames, String lang) {
        if (deptNames != null && !deptNames.isEmpty()) {
            for (int i = 0; i < deptNames.size(); i++) {
                String translatedName = languageTranslationUtil.translate(deptNames.get(i), lang);
                deptNames.set(i, translatedName);
            }
        }
    }

    /**
     * 转换直播分部名称为指定语言
     */
    private void translateLiveDeptNames(List<String> deptNames, String lang) {
        if (deptNames != null && !deptNames.isEmpty()) {
            for (int i = 0; i < deptNames.size(); i++) {
                String translatedName = languageTranslationUtil.translate(deptNames.get(i), lang);
                deptNames.set(i, translatedName);
            }
        }
    }

    /**
     * 转换礼物名称为指定语言
     */
    private void translateGiftNames(List<String> giftNames, String lang) {
        if (giftNames != null && !giftNames.isEmpty()) {
            for (int i = 0; i < giftNames.size(); i++) {
                String translatedName = languageTranslationUtil.translate(giftNames.get(i), lang);
                giftNames.set(i, translatedName);
            }
        }
    }

    /**
     * 转换频道名称为指定语言
     */
    private void translateChannelNames(List<String> channelNames, String lang) {
        if (channelNames != null && !channelNames.isEmpty()) {
            for (int i = 0; i < channelNames.size(); i++) {
                String translatedName = languageTranslationUtil.translate(channelNames.get(i), lang);
                channelNames.set(i, translatedName);
            }
        }
    }

    /**
     * 解析语言代码
     */
    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 convertTranslatedConsumeFieldsToChinese(BeanConsume consume, String languageCode) {
        if (consume != null) {
            // 转换备注信息
            if (consume.getRemark() != null && !consume.getRemark().isEmpty()) {
                String chineseRemark = translationService.findChineseSimplifiedByTranslation(
                        consume.getRemark(), languageCode);
                consume.setRemark(chineseRemark);
            }
        }
    }

    /**
     * 将直播消费查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedLiveFieldsToChinese(com.example.demo.domain.vo.bean.BeanConsumeLive beanConsumeLive, String languageCode) {
        if (beanConsumeLive != null) {
            // 转换分部名称
            if (beanConsumeLive.getDept() != null && !beanConsumeLive.getDept().isEmpty()) {
                String chineseDept = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeLive.getDept(), languageCode);
                beanConsumeLive.setDept(chineseDept);
            }

            // 转换礼物名称
            if (beanConsumeLive.getGift() != null && !beanConsumeLive.getGift().isEmpty()) {
                String chineseGift = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeLive.getGift(), languageCode);
                beanConsumeLive.setGift(chineseGift);
            }

            // 转换直播频道
            if (beanConsumeLive.getLiveChannel() != null && !beanConsumeLive.getLiveChannel().isEmpty()) {
                String chineseChannel = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeLive.getLiveChannel(), languageCode);
                beanConsumeLive.setLiveChannel(chineseChannel);
            }

            // 转换直播名称
            if (beanConsumeLive.getLiveName() != null && !beanConsumeLive.getLiveName().isEmpty()) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeLive.getLiveName(), languageCode);
                beanConsumeLive.setLiveName(chineseName);
            }
        }
    }

    /**
     * 将铁粉消费查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedFanFieldsToChinese(com.example.demo.domain.vo.bean.BeanConsumeFan beanConsumeFan, String languageCode) {
        if (beanConsumeFan != null) {
            // 转换分部名称
            if (beanConsumeFan.getDept() != null && !beanConsumeFan.getDept().isEmpty()) {
                String chineseDept = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeFan.getDept(), languageCode);
                beanConsumeFan.setDept(chineseDept);
            }

            // 转换频道名称
            if (beanConsumeFan.getChannel() != null && !beanConsumeFan.getChannel().isEmpty()) {
                String chineseChannel = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeFan.getChannel(), languageCode);
                beanConsumeFan.setChannel(chineseChannel);
            }
        }
    }

    /**
     * 将文章消费查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedArticleFieldsToChinese(com.example.demo.domain.vo.bean.BeanConsumeArticle beanConsumeArticle, String languageCode) {
        if (beanConsumeArticle != null) {
            // 转换分部名称
            if (beanConsumeArticle.getDept() != null && !beanConsumeArticle.getDept().isEmpty()) {
                String chineseDept = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeArticle.getDept(), languageCode);
                beanConsumeArticle.setDept(chineseDept);
            }

            // 转换文章名称
            if (beanConsumeArticle.getArticleName() != null && !beanConsumeArticle.getArticleName().isEmpty()) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeArticle.getArticleName(), languageCode);
                beanConsumeArticle.setArticleName(chineseName);
            }
        }
    }

    /**
     * 将小黄车消费查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedCartFieldsToChinese(com.example.demo.domain.DTO.BeanConsumeCartDTO beanConsumeCartDTO, String languageCode) {
        if (beanConsumeCartDTO != null) {
            // 转换产品名称
            if (beanConsumeCartDTO.getProductName() != null && !beanConsumeCartDTO.getProductName().isEmpty()) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeCartDTO.getProductName(), languageCode);
                beanConsumeCartDTO.setProductName(chineseName);
            }

            // 转换直播名称
            if (beanConsumeCartDTO.getLiveName() != null && !beanConsumeCartDTO.getLiveName().isEmpty()) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeCartDTO.getLiveName(), languageCode);
                beanConsumeCartDTO.setLiveName(chineseName);
            }

            // 转换来源名称
            if (beanConsumeCartDTO.getSourceName() != null && !beanConsumeCartDTO.getSourceName().isEmpty()) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        beanConsumeCartDTO.getSourceName(), languageCode);
                beanConsumeCartDTO.setSourceName(chineseName);
            }
        }
    }

    /**
     * 将分部名称转换为中文简体
     */
    private void convertTranslatedDeptNamesToChinese(List<String> deptNames, String languageCode) {
        if (deptNames != null && !deptNames.isEmpty()) {
            for (int i = 0; i < deptNames.size(); i++) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        deptNames.get(i), languageCode);
                deptNames.set(i, chineseName);
            }
        }
    }

    /**
     * 将直播分部名称转换为中文简体
     */
    private void convertTranslatedLiveDeptNamesToChinese(List<String> deptNames, String languageCode) {
        if (deptNames != null && !deptNames.isEmpty()) {
            for (int i = 0; i < deptNames.size(); i++) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        deptNames.get(i), languageCode);
                deptNames.set(i, chineseName);
            }
        }
    }

    /**
     * 将礼物名称转换为中文简体
     */
    private void convertTranslatedGiftNamesToChinese(List<String> giftNames, String languageCode) {
        if (giftNames != null && !giftNames.isEmpty()) {
            for (int i = 0; i < giftNames.size(); i++) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        giftNames.get(i), languageCode);
                giftNames.set(i, chineseName);
            }
        }
    }

    /**
     * 将频道名称转换为中文简体
     */
    private void convertTranslatedChannelNamesToChinese(List<String> channelNames, String languageCode) {
        if (channelNames != null && !channelNames.isEmpty()) {
            for (int i = 0; i < channelNames.size(); i++) {
                String chineseName = translationService.findChineseSimplifiedByTranslation(
                        channelNames.get(i), languageCode);
                channelNames.set(i, chineseName);
            }
        }
    }

    /**
     * 将合计数查询条件中的翻译字段转换为中文简体
     */
    private void convertTranslatedSumFieldsToChinese(Page page, String languageCode) {
        if (page != null) {
            // 转换直播消费条件
            if (page.getBeanConsumeLive() != null) {
                convertTranslatedLiveFieldsToChinese(page.getBeanConsumeLive(), languageCode);
            }

            // 转换铁粉消费条件
            if (page.getBeanConsumeFan() != null) {
                convertTranslatedFanFieldsToChinese(page.getBeanConsumeFan(), languageCode);
            }

            // 转换文章消费条件
            if (page.getBeanConsumeArticle() != null) {
                convertTranslatedArticleFieldsToChinese(page.getBeanConsumeArticle(), languageCode);
            }
        }
    }
}