eta_api/services/feCalendar_ai.go

package services

import (
	"errors"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/fe_calendar"
	"eta/eta_api/models/system"
	"eta/eta_api/services/data"
	"eta/eta_api/utils"
	"eta/eta_api/utils/llm"
	"eta/eta_api/utils/llm/eta_llm"
	"fmt"
	"net/http"
	"strings"
	"time"
)

func GetFeCalendarAiArticle(req *fe_calendar.FeCalendarAiArticleGenerateReq, matterDateTime time.Time, edbInfo *data_manage.EdbInfo, sysUser *system.Admin) (ret *fe_calendar.FeCalendarAiArticleGenerateResp, err error) {
	defer func() {
		if err != nil {
			utils.FileLog.Error(fmt.Sprintf("获取AI文章失败: %s", err.Error()))
		}
	}()
	
	
	var endDate string
	if edbInfo.EndDate <= req.MatterDate {
		endDate = edbInfo.EndDate
	}else{
		month := matterDateTime.Month()
		year := matterDateTime.Year()
		endDate = time.Date(year, month+1, 1, 0, 0, 0, 0, matterDateTime.Location()).AddDate(0, 0, -1).Format(utils.FormatDate)
	}
	
	classifyList, err, errMsg := data.GetFullClassifyByClassifyId(edbInfo.ClassifyId)
	if err != nil {
		err = errors.New(errMsg)
		return
	}

	classifyName := ""
	for _, v := range classifyList {
		classifyName += v.ClassifyName + "/"
	}
	edbData := make([]*data_manage.EdbDataList, 0)
	switch edbInfo.EdbInfoType {
		case 0: //普通源指标
			//dataList, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfoId, startDateReal, endDate)
			// 获取指标数据
	        edbData, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, "", endDate)
			if err != nil {
				err = errors.New("获取指标数据失败, Err: " + err.Error())
				return
			}
			
		case 1: //预测指标
			edbData, _, _, err, _ = data.GetPredictDataListByPredictEdbInfo(edbInfo, "", endDate, true)
			if err != nil {
				err = errors.New("获取预测指标数据失败, Err: " + err.Error())
				return
			}
			
	}
	if len(edbData) == 0 {
		err = errors.New("指标数据为空")
		return
	}

	dataStr := "日期 值\n"
	for _, v := range edbData {
		dataStr += fmt.Sprintf("%s %f.8\n", v.DataTime, v.Value)
	}

	endDate = edbData[len(edbData) - 1].DataTime

	// 获取提示词内容
	promote := models.BusinessConfMap[models.BusinessConfFeCalendarAiArticlePromote]
	
    // 调用大模型的接口
	edbName := edbInfo.EdbName
	frequency := edbInfo.Frequency
	startDate := edbInfo.StartDate
	sourceName := edbInfo.SourceName
	
	
	llmService, _ := llm.GetInstance(llm.ETA_LLM_CLIENT)
	promote = fmt.Sprintf(promote, edbName, frequency, startDate, endDate, sourceName, dataStr, classifyName)
	resp, err := llmService.CompletionChat(promote, nil)
	if err != nil {
		err = errors.New("获取AI文章失败, Err: " + err.Error())
		return
	}

	defer func() {
		if resp != nil && resp.Body != nil && err == nil {
			_ = resp.Body.Close()
		}
	}()
	if resp == nil {
		err = errors.New("知识库问答失败: 无应答")
		return
	}
	if err != nil {
		err = errors.New(fmt.Sprintf("知识库问答失败: httpCode:%d,错误信息:%s", resp.StatusCode, http.StatusText(resp.StatusCode)))
		return
	}

	if resp.StatusCode != http.StatusOK {
		utils.FileLog.Error(fmt.Sprintf("知识库问答失败: httpCode:%d,错误信息:%s", resp.StatusCode, http.StatusText(resp.StatusCode)))
		err = errors.New(fmt.Sprintf("知识库问答失败: httpCode:%d,错误信息:%s", resp.StatusCode, http.StatusText(resp.StatusCode)))
		return
	}

	text := ""

	// 解析流式响应
	contentChan, errChan, closeChan, _ := eta_llm.ParseStreamResponse(resp)
	for {
		select {
		case content, ok := <-contentChan:
			if !ok {
				err = errors.New("未知的内容错误异常")
				// 标记llm提问状态：未提问
				return nil, err
			}
			text += content
		case chanErr, ok := <-errChan:
			if !ok {
				err = errors.New("未知的错误异常")
			} else if chanErr != nil {
				err = errors.New(chanErr.Error())
			}
			// 标记llm提问状态：未提问
			return nil, err
		case <-closeChan:
			goto LOOP_END
		}
	}
LOOP_END:

	// 过滤掉<think>块内容
	if thinkStart := strings.Index(text, "<think>"); thinkStart != -1 {
		if thinkEnd := strings.Index(text, "</think>"); thinkEnd != -1 {
			// 提取<think>之前和</think>之后的内容
			text = text[:thinkStart] + text[thinkEnd+len("</think>"):]
		}
	}

	// 去除可能存在的多余空行
	text = strings.TrimSpace(text)

	// 获取品种信息
	// permissionItem, err := models.GetChartPermissionById(req.ChartPermissionId)
	// if err != nil {
	// 	err = errors.New("获取品种信息失败, Err: " + err.Error())
	// 	return
	// }

	// article := new(fe_calendar.FeCalendarAiArticle)
	// article.Title = edbInfo.EdbName
	// article.Content = text
	// article.Prompt = promote
	// article.ChartPermissionId = req.ChartPermissionId
	// article.ChartPermissionName = permissionItem.PermissionName
	// article.EdbCode = edbInfo.EdbCode
	// article.EdbInfoId = edbInfo.EdbInfoId
	// article.MatterDate = req.MatterDate
	// article.MatterMonth = req.MatterDate
	// article.SysUserId = sysUser.AdminId
	// article.SysUserName = sysUser.RealName

	// // 设置月份
	// article.MatterMonth = matterDateTime.Format("2006-01")

	// err = article.Create()
	// if err != nil {
	// 	err = errors.New("保存AI文章失败, Err: " + err.Error())
	// 	return
	// }
	ret = &fe_calendar.FeCalendarAiArticleGenerateResp{
		Content:               text,
		ModifyTime:            time.Now().Format(utils.FormatDateTime),
	}
	return ret, nil
}