big-model-java/slibra-admin/src/main/java/com/slibra/web/controller/business/FrontController.java

package com.slibra.web.controller.business;

import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.JSONWriter;
import com.github.pagehelper.PageInfo;
import com.slibra.business.domain.*;
import com.slibra.business.mapper.*;
import com.slibra.business.req.ChatReq;
import com.slibra.business.req.WorkOrderReq;
import com.slibra.business.res.*;
import com.slibra.business.service.IFrontService;
import com.slibra.business.service.ITXinyiCarbonMajorService;
import com.slibra.business.service.impl.TXinyiMedicineParamServiceImpl;
import com.slibra.common.DecimalUtils;
import com.slibra.common.annotation.Log;
import com.slibra.common.constant.HttpStatus;
import com.slibra.common.constant.MyConstants;
import com.slibra.common.core.controller.BaseController;
import com.slibra.common.core.domain.AjaxResult;
import com.slibra.common.core.domain.R;
import com.slibra.common.core.page.TableDataInfo;
import com.slibra.common.enums.BusinessEnum;
import com.slibra.common.enums.BusinessType;
import com.slibra.common.exception.ServiceException;
import com.slibra.common.utils.DateUtils;
import com.slibra.common.utils.SecurityUtils;
import com.slibra.common.utils.StringUtils;
import com.slibra.common.utils.poi.ExcelUtil;
import com.slibra.common.utils.uuid.IdUtils;
import com.sun.glass.ui.ClipboardAssistance;
import lombok.extern.slf4j.Slf4j;
import org.checkerframework.checker.units.qual.A;
import org.checkerframework.checker.units.qual.C;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

import static com.slibra.common.constant.MyConstants.*;

/**
 * 前端用户相关接口
 */
@RestController
@RequestMapping("/front")
@Slf4j
public class FrontController extends BaseController {


    @Autowired
    private IFrontService frontService;


    @Autowired
    private TXinyiChatRecordMapper xinyiChatRecordMapper;

    @Autowired
    private TXinyiWarningRecordMapper xinyiWarningRecordMapper;

    @Autowired
    private TXinyiAgentAssistantMapper xinyiAgentAssistantMapper;

    @Autowired
    private TXinyiIndustryMapper xinyiIndustryMapper;

    @Autowired
    private TXinyiCarbonMajorMapper xinyiCarbonMajorMapper;

    @Autowired
    private ITXinyiCarbonMajorService tXinyiCarbonMajorService;

    @Autowired
    private TXinyiMedicineConfMapper xinyiMedicineConfMapper;

    @Autowired
    private TXinyiRobotMapper xinyiRobotMapper;

    @Autowired
    private TXinyiMedicineParamMapper xinyiMedicineParamMapper;

    @Autowired
    private TXinyiMedicineParamServiceImpl xinyiMedicineParamServiceImpl;



    /**
     * 获取大屏的实时数据 + 统计数据
     * @return
     */
    @GetMapping(value = "/realTimeData")
    public AjaxResult realTimeData()
    {
        log.info("进入了 获取大屏的实时数据 + 统计数据 接口");
        return AjaxResult.success(frontService.countInfo());
    }


    //2024年12月18日13:39:38 新增2个列表数据，用于展示工业库的数据和化验室的N天的数据，生成报表
    /**
     * 获取大屏的最近N天的工业库的数据
     * @return
     */
    @GetMapping(value = "/getIndustryDataByDays")
    public AjaxResult getIndustryDataByDays(@RequestParam(required = true) int days)
    {
        log.info("进入了 获取大屏的最近N天的工业库的数据 接口，请求参数为{}", days);
        List<IndustrySimpleBean> resultList = new ArrayList<>();
        //获取N天之前的日期
        List<TXinyiIndustry> tXinyiIndustries = this.xinyiIndustryMapper.selectTXinyiIndustryList(TXinyiIndustry.builder().timeBegin(DateUtils.parseDateToStr(DateUtils.YYYYMMDD_TS, DateUtils.plusDate(-days, DateUtils.getNowDate()))).build());
        if(!CollectionUtils.isEmpty(tXinyiIndustries)){
            for (TXinyiIndustry tXinyiIndustry : tXinyiIndustries) {
                IndustrySimpleBean industrySimpleBean = new IndustrySimpleBean();
                BeanUtils.copyProperties(tXinyiIndustry, industrySimpleBean);
                resultList.add(industrySimpleBean);
            }
        }
        //新增ID 按照ID升序排列
        resultList.sort((u1, u2) -> Math.toIntExact(u1.getID() - u2.getID()));
        return AjaxResult.success(resultList);
    }


    /**
     * 获取大屏的最近N天的化验室的数据
     * @return
     */
    @GetMapping(value = "/getRobotDataByDays")
    public AjaxResult getRobotDataByDays(@RequestParam(required = true) int days)
    {
        log.info("进入了 获取大屏的最近N天的化验室的数据 接口，请求参数为{}", days);
        List<RobotSimpleBean> resultList = new ArrayList<>();
        //获取N天之前的日期
        List<TXinyiRobot> tXinyiRobots = this.xinyiRobotMapper.selectTXinyiRobotList(TXinyiRobot.builder().timeBegin(DateUtils.parseDateToStr(DateUtils.YYYYMMDD_TS, DateUtils.plusDate(-days, DateUtils.getNowDate()))).build());
        if(!CollectionUtils.isEmpty(tXinyiRobots)){
            for (TXinyiRobot tXinyiRobot : tXinyiRobots) {
                RobotSimpleBean robotSimpleBean = new RobotSimpleBean();
                BeanUtils.copyProperties(tXinyiRobot, robotSimpleBean);
                resultList.add(robotSimpleBean);
            }
        }
        //新增ID 按照ID升序排列
        resultList.sort((u1, u2) -> Math.toIntExact(u1.getID() - u2.getID()));
        return AjaxResult.success(resultList);
    }



    /**
     * 分页获取大模型的问答记录
     * @param tXinyiChatRecord
     * @return
     */
    @GetMapping("/bigModel/qa/pageList")
    public TableDataInfo qaPageList(TXinyiChatRecord tXinyiChatRecord)
    {
        log.info("进入了 分页获取大模型的问答记录 接口");
        //获取登录用户信息
        Long userId = SecurityUtils.getUserId();
        tXinyiChatRecord.setUserId(String.valueOf(userId));
        startPage();
        return getDataTable(xinyiChatRecordMapper.selectTXinyiChatRecordFirstList(tXinyiChatRecord));
    }


    /**
     * 分页获取大模型的问答记录
     * @param tXinyiChatRecord
     * @return
     */
    @GetMapping("/bigModel/qa/wx/list")
    public R<Map<String, List<TXinyiChatRecord>>> wxList(TXinyiChatRecord tXinyiChatRecord)
    {
        log.info("进入了 小程序获取问答记录并按日期分组 接口");
        //获取登录用户信息
        Long userId = SecurityUtils.getUserId();
        tXinyiChatRecord.setUserId(String.valueOf(userId));
        List<TXinyiChatRecord> tXinyiChatRecords = xinyiChatRecordMapper.selectTXinyiChatRecordFirstList(tXinyiChatRecord);
        if(CollectionUtils.isEmpty(tXinyiChatRecords))
            return null;
        //处理日期数据 在程序处理，不在SQL中处理了
        for (TXinyiChatRecord xinyiChatRecord : tXinyiChatRecords) {
            Date createTime = xinyiChatRecord.getCreateTime();
            if(!Objects.isNull(createTime))
                xinyiChatRecord.setDateStr(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, createTime));
        }
        return R.ok(tXinyiChatRecords.stream().collect(Collectors.groupingBy(TXinyiChatRecord::getDateStr)));
    }

    /**
     * 不分页获取大模型的问答记录
     * @param tXinyiChatRecord
     * @return
     */
    @GetMapping("/bigModel/qa/noPageList")
    public AjaxResult noPageList(TXinyiChatRecord tXinyiChatRecord)
    {
        log.info("进入了 不分页获取大模型的问答记录 接口");
        //获取登录用户信息
        Long userId = SecurityUtils.getUserId();
        tXinyiChatRecord.setUserId(String.valueOf(userId));
        return AjaxResult.success(xinyiChatRecordMapper.selectTXinyiChatRecordFirstList(tXinyiChatRecord));
    }






    /**
     * 通过sessionId获取某个用户的问答列表
     * @param tXinyiChatRecord
     * @return
     */
    @GetMapping("/bigModel/qa/qaListBySessionId")
    public AjaxResult qaListBySessionId(TXinyiChatRecord tXinyiChatRecord)
    {
        log.info("进入了 通过sessionId获取某个用户的问答列表 接口");
        String sessionId = tXinyiChatRecord.getSessionId();
        if(StringUtils.isBlank(sessionId))
            throw new ServiceException("必须传入sessionId");
        //获取登录用户信息
        Long userId = SecurityUtils.getUserId();
        tXinyiChatRecord.setUserId(String.valueOf(userId));
        //2024年08月16日13:50:30  拿到数据以后，按照counts字段排序，目的是让SQL通过ID排序，走主键索引
        return AjaxResult.success(xinyiChatRecordMapper.selectTXinyiChatRecordList(tXinyiChatRecord).stream().sorted(Comparator.comparing(TXinyiChatRecord::getCounts)).collect(Collectors.toList()));
    }


    /**
     *
     * 获取报警统计信息接口
     * @return
     */
    @GetMapping("/bigModel/warningCount")
    public AjaxResult warningCount()
    {
        log.info("进入了获取报警统计信息接口");
        return AjaxResult.success(frontService.warningCount());
    }


    /**
     * 首页报警记录（按时间倒叙  取十条）
     * @return
     */
    @GetMapping("/bigModel/home/warningList")
    public AjaxResult homeWarningList()
    {
        log.info("进入了 首页报警记录（按时间倒叙  取十条） 接口");
        return AjaxResult.success(frontService.homeWarningList());
    }




    /**
     * 获取 信义推荐问答列表
     * type: 0专家问答 1水质报警  2生化报警 3预测预警
     * @return
     */
    @GetMapping("/bigModel/home/recommendQAList/{type}")
    public AjaxResult recommendQAList(@PathVariable Integer type)
    {
        log.info("进入了 获取 信义推荐问答列表  接口");
        return AjaxResult.success(frontService.recommendQAList(type));
    }




    //报警+预警记录列表分页 【水质报警  1生化报警 2预测报警】
    /**
     * 报警+预警记录列表分页
     * @param tXinyiWarningRecord
     * @return
     */
    @GetMapping("/bigModel/warning/pageList")
    public TableDataInfo warningPageList(TXinyiWarningRecord tXinyiWarningRecord)
    {
        log.info("进入了 报警+预警记录列表分页 接口");
        startPage();
        List<TXinyiWarningRecord> tXinyiWarningRecords = xinyiWarningRecordMapper.selectTXinyiWarningRecordList(tXinyiWarningRecord);
        this.addWarningRecordExtra(tXinyiWarningRecords);
        return getDataTable(tXinyiWarningRecords);
    }



    //报警+预警记录列表不分页 【水质报警  1生化报警 2预测报警】
    /**
     * 报警+预警记录列表不分页
     * @param tXinyiWarningRecord
     * @return
     */
    @GetMapping("/bigModel/warning/noPageList")
    public AjaxResult noPageList(TXinyiWarningRecord tXinyiWarningRecord)
    {
        log.info("进入了 报警+预警记录列表不分页 接口");
        List<TXinyiWarningRecord> tXinyiWarningRecords = xinyiWarningRecordMapper.selectTXinyiWarningRecordList(tXinyiWarningRecord);
        this.addWarningRecordExtra(tXinyiWarningRecords);
        return AjaxResult.success(tXinyiWarningRecords);
    }


    private void addWarningRecordExtra(List<TXinyiWarningRecord> tXinyiWarningRecords) {
        if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
            for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningRecords) {
                Date endDate = null;
                //判断类型 如果结束了 截止时间就是告警截止时间；  如果正在报警 截止时间就是当前时间
                if(0 == tXinyiWarningRecord.getStatus() || 3 == tXinyiWarningRecord.getStatus())
                    endDate = DateUtils.getNowDate();
                else
                    endDate = tXinyiWarningRecord.getOffTime();
                //防止 之前程序处理错误  理论上不再报警了，一定有截止时间的
                if(Objects.isNull(endDate)){
                    log.error("xxxxxxxxx：之前处理告警结束的逻辑异常，没有更新截止时间");
                    endDate = DateUtils.getNowDate();
                }
                long counts = DateUtils.differentHoursByLocalDateTime(tXinyiWarningRecord.getCreateTime(), endDate) + 1;
                tXinyiWarningRecord.setCounts(counts > MAX_COUNT ? MAX_COUNT_STR : String.valueOf(counts));

                //2024年7月11日13:36:41 新增处理，返回带单位的报警值（目前只处理生化报警的）
                if(1 == tXinyiWarningRecord.getType())
                    tXinyiWarningRecord.setWarningValStr(this.getWarningValStr(tXinyiWarningRecord.getWarningVal(), tXinyiWarningRecord.getCategory()));
                //2024年7月13日17:41:06 小数点保留两位小数
                this.handleDecimalPoint(tXinyiWarningRecord);
            }
        }
    }

    private void handleDecimalPoint(TXinyiWarningRecord xinyiWarningRecord) {
        BigDecimal warningVal = xinyiWarningRecord.getWarningVal();
        BigDecimal designVal = xinyiWarningRecord.getDesignVal();
        BigDecimal controlVal = xinyiWarningRecord.getControlVal();
        BigDecimal forecastVal = xinyiWarningRecord.getForecastVal();
        if(!Objects.isNull(warningVal))
            xinyiWarningRecord.setWarningVal(DecimalUtils.getAbsAndScale(warningVal, INT_2));
        if(!Objects.isNull(designVal))
            xinyiWarningRecord.setDesignVal(DecimalUtils.getAbsAndScale(designVal, INT_2));
        if(!Objects.isNull(controlVal))
            xinyiWarningRecord.setControlVal(DecimalUtils.getAbsAndScale(controlVal, INT_2));
        if(!Objects.isNull(forecastVal))
            xinyiWarningRecord.setForecastVal(DecimalUtils.getAbsAndScale(forecastVal, INT_2));
    }

    private String getWarningValStr(BigDecimal warningVal, String category) {
        BigDecimal absAndScale = DecimalUtils.getAbsAndScale(warningVal, MyConstants.INT_2);
        if(BusinessEnum.WarningCategoryEnum.NHLB.getCode().equals(category))
            return absAndScale + SPACE_STR + BusinessEnum.BigModelUnitEnum.PERCENT.getCode();
        if(BusinessEnum.WarningCategoryEnum.WHLB.getCode().equals(category))
            return absAndScale + SPACE_STR + BusinessEnum.BigModelUnitEnum.PERCENT.getCode();
        if(BusinessEnum.WarningCategoryEnum.WNND_MLSS_1.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.MG_L.getCode();
        if(BusinessEnum.WarningCategoryEnum.WNND_MLSS_2.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.MG_L.getCode();
        if(BusinessEnum.WarningCategoryEnum.WNFH.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.KGBOD_KGMLSS_D.getCode();
        if(BusinessEnum.WarningCategoryEnum.HFXWNNDZB.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.NULL.getCode();
        if(BusinessEnum.WarningCategoryEnum.TDB.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.NULL.getCode();
        if(BusinessEnum.WarningCategoryEnum.TLB.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.NULL.getCode();
        if(BusinessEnum.WarningCategoryEnum.BODCODB.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.NULL.getCode();
        if(BusinessEnum.WarningCategoryEnum.HYQDO_ONE.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.MG_L.getCode();
        if(BusinessEnum.WarningCategoryEnum.HYQDO_TWO.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.MG_L.getCode();
        if(BusinessEnum.WarningCategoryEnum.QSB.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.M3_M3.getCode();
        if(BusinessEnum.WarningCategoryEnum.ECC_BMFH.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.M3_M2_H.getCode();
        if(BusinessEnum.WarningCategoryEnum.ECC_GTFH.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.KG_M2_D.getCode();
        if(BusinessEnum.WarningCategoryEnum.FCXSL.getCode().equals(category))
            return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.PERCENT.getCode();
        return absAndScale + SPACE_STR  + BusinessEnum.BigModelUnitEnum.NULL.getCode();
    }

    /**
     * 获取 后台配置的智能助手列表
     * @return
     */
    @GetMapping("/bigModel/agentAssistant/list")
    public AjaxResult agentAssistantList()
    {
        log.info("进入了 获取 后台配置的智能助手列表  接口");
        return AjaxResult.success(xinyiAgentAssistantMapper.selectTXinyiAgentAssistantList(null));
    }




    /**
     * 获取 告警id获取决策列表的最后一条数据
     * 2024年6月23日17:30:07  因为只展示一条数据，所以判断是不是最后一条数据是report类型的，如果是就返回； 如果不是，获取是定时任务生成的最近的一条数据
     * @return
     */
    @GetMapping("/bigModel/warning/qaDetailByWarningId/{warningId}")
    public AjaxResult qaDetailByWarningId(@PathVariable String warningId)
    {
        log.info("进入了 获取 告警id获取决策列表的最后一条数据  接口");
        return AjaxResult.success(frontService.qaDetailByWarningId(warningId));
    }


    /**
     * 删除问答记录（单条）
     * @return
     */
    @DeleteMapping("/bigModel/chat/deleteOneChtById/{id}")
    public AjaxResult deleteOneChtById(@PathVariable Long id)
    {
        log.info("进入了 删除问答记录（单条）  接口");
        return AjaxResult.success(xinyiChatRecordMapper.deleteTXinyiChatRecordById(id));
    }


    /**
     * 生成sessionId给聊天接口使用
     * @return
     */
    @GetMapping("/bigModel/chat/generateSessionId")
    public AjaxResult generateSessionId()
    {
        log.info("进入了 生成sessionId给聊天接口使用  接口");
        return AjaxResult.success(SUCCESS, IdUtils.simpleUUID());
    }


    /**
     * 标记问题是否满意
     * @return
     */
    @PutMapping("/bigModel/chat/isSatisfiedAnswer")
    public AjaxResult isSatisfiedAnswer(@RequestBody ChatReq chatReq)
    {
        log.info("进入了 标记问题是否满意  接口");
        return AjaxResult.success(frontService.isSatisfiedAnswer(chatReq));
    }



    /**
     * 人工处理告警接口(是否采用大模型问答  是否转应急  归档/上传地址)
     * @return
     */
    @PutMapping("/bigModel/warning/handleWarningByMan")
    public AjaxResult handleWarningByMan(@RequestBody TXinyiWarningRecord warningRecord)
    {
        log.info("进入了 人工处理告警接口  接口");
        return AjaxResult.success(frontService.handleWarningByMan(warningRecord));
    }



    /**
     * 获取 首页简报的问答数据
     * @return
     */
    @GetMapping("/bigModel/home/getLeastShortReport")
    public AjaxResult getLeastShortReport()
    {
        log.info("进入了 首页简报的问答数据获取  接口");
        return AjaxResult.success(frontService.getLeastShortReport());
    }



    /**
     * 获取 告警id获取所有的仿真预测列表
     * @return
     */
    @GetMapping("/bigModel/warning/forecastList/{warningId}")
    public AjaxResult forecastList(@PathVariable String warningId)
    {
        log.info("进入了 获取 告警id获取所有的仿真预测列表  接口");
        return AjaxResult.success(frontService.forecastList(warningId));
    }


    /**
     * 获取 最新的一条日报相关的费用信息
     * @return
     */
    @GetMapping("/bigModel/daily/recentlyOneFeeInfo")
    public String recentlyOneFeeInfo()
    {
        log.info("进入了 获取 最新的一条日报相关的费用信息  接口");
        return JSON.toJSONString(success(frontService.recentlyOneFeeInfo()), JSONWriter.Feature.WriteNulls);
    }





    /**
     * 自定义工单接口 获取数据接口
     * @return
     * 2024年6月19日14:45:51 返回结构再处理下，方便前端解析
     */
    @PostMapping("/bigModel/custom/workOrder")
    public AjaxResult customWorkOrder(@RequestBody WorkOrderReq workOrderReq)
    {
        log.info("进入了 自定义工单接口 获取数据接口 接口");
        return AjaxResult.success(frontService.customWorkOrderHandle(workOrderReq));
    }


    /**
     *
     * 大模型停止生成
     * @param sessionId
     * @return
     */
    @GetMapping("/bigModel/warning/stopChat/{sessionId}")
    public AjaxResult stopChat(@PathVariable String sessionId)
    {
        log.info("进入了 大模型停止生成  接口");
        return AjaxResult.success(frontService.stopChat(sessionId));
    }


    /**
     *
     * 智能投药系统获取实时需要数据接口
     * @return
     */
    @GetMapping("/bigModel/smartAdd/dataInfo")
    public AjaxResult smartAddDataInfo()
    {
        log.info("进入了 智能投药系统获取实时需要数据 接口");
        return AjaxResult.success(frontService.smartAddDataInfo());
    }


    /**
     * type说明：
     * 0：进水流量
     * 1：#1好氧池硝酸盐
     * 2：#2好氧池硝酸盐
     * 3：#1缺氧池氨氮
     * 4：#2缺氧池氨氮
     * 5：进水COD
     * 6：进水总氮
     * 7：碳源投加量
     *
     *
     * @param type
     * @return
     */
    @GetMapping("/bigModel/smartAdd/charList/{type}")
    public AjaxResult smartAddCharList(@PathVariable int type, @RequestParam(required = false, name = "timeBegin") String timeBegin, @RequestParam(required = false, name = "timeEnd") String timeEnd)
    {
        log.info("进入了 智能投药系统获取对应指标最近3天的数据情况 接口");
        return AjaxResult.success(frontService.smartAddCharList(type, timeBegin, timeEnd));
    }

    /**
     *
     * 2025年04月24日13:36:45 获取起止范围内的图表数据 不再按照以前多个维度展示，改成列表数据
     * @param timeBegin
     * @param timeEnd
     * @return
     */
    @GetMapping("/bigModel/smartAdd/charListNew")
    public AjaxResult smartAddCharListNew(@RequestParam(required = false, name = "timeBegin") String timeBegin, @RequestParam(required = false, name = "timeEnd") String timeEnd)
    {
        log.info("进入了 智能投药系统获取对应指标最近3天的数据情况-新逻辑 接口");
        return AjaxResult.success(frontService.smartAddCharListNew(timeBegin, timeEnd));
    }



    /**
     *
     * 获取当前投药采用的是创哥对应的哪个参数；计算值是多少；反馈值是多少
     * @return
     */
    @GetMapping("/bigModel/smartAdd/homeValues")
    public AjaxResult homeValues()
    {
        log.info("进入了 获取当前投药采用的是创哥对应的哪个参数；计算值是多少；反馈值是多少 接口");
        MedicineRemote medicineRemote = new MedicineRemote();
        TXinyiMedicineParam latestRecord = this.xinyiMedicineParamMapper.getLatestRecord();
        if(!Objects.isNull(latestRecord)){
            //2025年04月27日11:26:43 返回结构做了调整
            medicineRemote = this.xinyiMedicineParamServiceImpl.calculateMedicineByLastRecord(latestRecord);
        }
        MedicineHome medicineHome = new MedicineHome();
        //该时刻对应的真实碳源投加值
        List<TXinyiIndustry> tXinyiIndustries = this.xinyiIndustryMapper.selectTXinyiIndustryList(TXinyiIndustry.builder().testHour(DateUtils.parseDateToStr(DateUtils.YYYYMMDDHH_TS, DateUtils.getNowDate())).build());
        if(!CollectionUtils.isEmpty(tXinyiIndustries))
            medicineHome.setRealVal(tXinyiIndustries.get(0).getSJTYJLY());
        medicineHome.setCalculateVal(medicineRemote.getCalculateVal());
        medicineHome.setKzxs(medicineRemote.getKzxs());
        medicineHome.setHtfksd(medicineRemote.getHtfksd());
        return AjaxResult.success(medicineHome);
    }


    /**
     *
     * 获取某个时间的内的记录的碳源投加情况
     * @param timeBegin
     * @param timeEnd
     * @return
     */
    @GetMapping("/bigModel/smartAdd/addMedicineRecordList")
    public AjaxResult addMedicineRecordList(@RequestParam(required = false, name = "timeBegin") String timeBegin, @RequestParam(required = false, name = "timeEnd") String timeEnd)
    {
        log.info("进入了 获取某个时间的内的记录的碳源投加情况 接口");
        return AjaxResult.success(frontService.addMedicineRecordList(timeBegin, timeEnd));
    }



    /**
     *获取碳源投加 是否在本系统中允许投放（用于部分场景：计算异常 或者 想手动中断等）
     * @return
     */
    @GetMapping("/bigModel/smartAdd/getSwitchStatus")
    public R<Integer> getSwitchStatus()
    {
        log.info("进入了 获取碳源投加 是否在本系统中允许投放（用于部分场景：计算异常 或者 想手动中断等） 接口");
        TXinyiMedicineConf tXinyiMedicineConf = xinyiMedicineConfMapper.selectTXinyiMedicineConfById(LONG_1);
        if(Objects.isNull(tXinyiMedicineConf))
            throw new ServiceException("未查询到碳源投放配置开关");
        return R.ok(tXinyiMedicineConf.getAddStatus());
    }


    /**
     *修改碳源投加 是否在本系统中允许投放（用于部分场景：计算异常 或者 想手动中断等）
     * @return
     */
    @PutMapping("/bigModel/smartAdd/updateSwitchStatus")
    public R<String> updateSwitchStatus(@RequestBody TXinyiMedicineConf tXinyiMedicineConf)
    {
        log.info("进入了 修改碳源投加 是否在本系统中允许投放（用于部分场景：计算异常 或者 想手动中断等） 接口");
        if(Objects.isNull(tXinyiMedicineConf.getAddStatus()))
            throw new ServiceException("请输入要更改的状态");
        tXinyiMedicineConf.setId(LONG_1);
        this.xinyiMedicineConfMapper.updateTXinyiMedicineConf(tXinyiMedicineConf);
        return R.ok("修改成功");
    }


    //--------------------下面是碳排放智能体相关的方法--------------------begin

    /**
     * 碳排放智能体-获取所有的填写的月份
     * @return
     */
    @GetMapping("/bigModel/carbonSmart/allMonths")
    public R<List<String>> allMonths()
    {
        log.info("进入了 碳排放智能体-获取所有的填写的月份 接口");
        return R.ok(xinyiCarbonMajorMapper.allMonths());
    }



    /**
     * 获取某个月份的部分数据（水量是总值 tn和cod是平均值）
     */
    @GetMapping(value = "/bigModel/carbonSmart/getDBDatas/{month}")
    public R<CarbonSmartQueryDB> getDBDatasByMonth(@PathVariable("month") String month)
    {
        return R.ok(tXinyiCarbonMajorService.getDBDatasByMonth(month));
    }


    /**
     * 通过月份获取碳排放主详细信息
     */
    @GetMapping(value = "/bigModel/carbonSmart/getCarbonDetailsByMonth/{month}")
    public R<TXinyiCarbonMajor> getCarbonDetailsByMonth(@PathVariable("month") String month)
    {
        return R.ok(tXinyiCarbonMajorService.getCarbonDetailsByMonth(month));
    }


    /**
     * 通过ID获取碳排放主详细信息
     */
    @GetMapping(value = "/bigModel/carbonSmart/getCarbonDetailsById/{id}")
    public R<TXinyiCarbonMajor> getCarbonDetailsById(@PathVariable("id") Long id)
    {
        return R.ok(tXinyiCarbonMajorService.getCarbonDetailsById(id));
    }


    /**
     * 查询碳排放主列表数据-部分展示字段（分页）
     */
    @GetMapping("/bigModel/carbonSmart/pageList")
    public TableDataInfo carbonSmartPageList(TXinyiCarbonMajor tXinyiCarbonMajor)
    {
        startPage();
        List<TXinyiCarbonMajor> list = tXinyiCarbonMajorService.selectTXinyiCarbonMajorList(tXinyiCarbonMajor);
        List<CarbonMajorSimple> resultList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(list)) {
            for (TXinyiCarbonMajor xinyiCarbonMajor : list) {
                CarbonMajorSimple carbonMajorSimple = new CarbonMajorSimple();
                BeanUtils.copyProperties(xinyiCarbonMajor, carbonMajorSimple);
                resultList.add(carbonMajorSimple);
            }
        }
        TableDataInfo rspData = new TableDataInfo();
        rspData.setCode(HttpStatus.SUCCESS);
        rspData.setMsg("查询成功");
        rspData.setRows(resultList);
        rspData.setTotal(new PageInfo(list).getTotal());
        return rspData;
    }


    /**
     * 导出碳排放主列表部分字段
     */
    @PostMapping("/bigModel/carbonSmart/export")
    public void carbonSmartExport(HttpServletResponse response, TXinyiCarbonMajor tXinyiCarbonMajor)
    {
        List<TXinyiCarbonMajor> list = tXinyiCarbonMajorService.selectTXinyiCarbonMajorList(tXinyiCarbonMajor);
        if(CollectionUtils.isEmpty(list))
            log.info("导出的数据为空，无法导出");
        else{
            List<CarbonMajorSimple> resultList = new ArrayList<>();
            for (TXinyiCarbonMajor xinyiCarbonMajor : list) {
                CarbonMajorSimple carbonMajorSimple = new CarbonMajorSimple();
                BeanUtils.copyProperties(xinyiCarbonMajor, carbonMajorSimple);
                resultList.add(carbonMajorSimple);
            }
            ExcelUtil<CarbonMajorSimple> util = new ExcelUtil<>(CarbonMajorSimple.class);
            util.exportExcel(response, resultList, "碳排放主数据");
        }
    }



    /**
     * 新增碳排放主
     */
    @PostMapping("/bigModel/carbonSmart/addCarbonSmart")
    public AjaxResult addCarbonSmart(@RequestBody TXinyiCarbonMajor tXinyiCarbonMajor)
    {
//        tXinyiCarbonMajor.setCreateBy(getUsername());
        return toAjax(tXinyiCarbonMajorService.insertTXinyiCarbonMajor(tXinyiCarbonMajor));
    }




    /**
     * 配置预测参数，获取碳源投加计算得到的相关参数
     * @return
     */
    @PostMapping("/configPredict")
    public AjaxResult configPredict(@RequestBody List<TJlPredict> tJlPredicts)
    {
        log.info("进入了 配置预测参数，获取碳源投加计算得到的相关参数 接口");
        return AjaxResult.success(frontService.configPredict(tJlPredicts));
    }


    /**
     * 配置预测参数，获取碳源投加计算得到的相关参数-直接调用创哥接口返回前端-做个终转
     * @return
     */
    @PostMapping("/configPredictRemote")
    public String configPredictRemote(@RequestBody String json)
    {
        log.info("进入了 配置预测参数，获取碳源投加计算得到的相关参数-直接调用 接口，收到的请求参数为{}", json);
        return HttpUtil.post("http://localhost:30076/setfeedback", json);
    }


    //2025年05月09日14:41:13  新增新的请求接口

    /**
     * 中转接口，点击“查看参数数据”，获取结果
     * @return
     */
    @PostMapping("/queryParamsRemote")
    public String queryParamsRemote(@RequestBody String json)
    {
        log.info("进入了 中转接口，点击“查看参数数据”，获取结果 接口，收到的请求参数为{}", json);
        return HttpUtil.post("http://localhost:30076/feedbackconf", json);
    }



    //--------------------上面是碳排放智能体相关的方法--------------------end

    //--------------------下面是测试的方法--------------------
    /*@GetMapping("/test/data")
    public void testData(){
        List<DecisionReq> decisionReqs = this.xinyiIndustryMapper.selectLast10RecordsForDecisionOnlyIndustry();
        System.out.println(JSON.toJSONString(decisionReqs,  JSONWriter.Feature.WriteNulls));
    }*/



}