fix

cache/llm.go

@@ -5,13 +5,15 @@ import (
 	"fmt"
 )
 
-type WechatArticleOp struct {
+// WechatPlatformOp
+// @Description: 微信公众号操作请求
+type WechatPlatformOp struct {
 	Source           string
 	WechatPlatformId int
 }
 
 // AddWechatArticleOpToCache
-// @Description: 将公众号文章操作加入缓存
+// @Description: 将公众号操作加入缓存
 // @param wechatPlatformId
 // @param source
 // @return bool
@@ -21,7 +23,7 @@ func AddWechatArticleOpToCache(wechatPlatformId int, source string) bool {
 		return true
 	}
 
-	record := new(WechatArticleOp)
+	record := new(WechatPlatformOp)
 	record.Source = source
 	record.WechatPlatformId = wechatPlatformId
 	if utils.Re == nil {
@@ -36,23 +38,32 @@ func AddWechatArticleOpToCache(wechatPlatformId int, source string) bool {
 	return false
 }
 
+// WechatArticleOp
+// @Description: 微信公众号文章操作
+type WechatArticleOp struct {
+	Source          string
+	WechatArticleId int
+	QuestionId      int
+}
+
 // AddWechatArticleLlmOpToCache
 // @Description: 将公众号文章llm操作加入缓存
 // @param wechatPlatformId
 // @param source
 // @return bool
-func AddWechatArticleLlmOpToCache(wechatPlatformId int, source string) bool {
+func AddWechatArticleLlmOpToCache(wechatArticleId, questionId int, source string) bool {
 	// 如果不在发布和调试模式，那么就不加入缓存
 	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
 		return true
 	}
 	record := new(WechatArticleOp)
 	record.Source = source
-	record.WechatPlatformId = wechatPlatformId
+	record.WechatArticleId = wechatArticleId
+	record.QuestionId = questionId
 	if utils.Re == nil {
 		err := utils.Rc.LPush(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, record)
 
-		utils.FileLog.Info(fmt.Sprintf("将公众号文章llm操作加入缓存 加入缓存 AddWechatArticleLlmOpToCache LPush: 操作类型：%s，公众号id：%d", source, wechatPlatformId))
+		utils.FileLog.Info(fmt.Sprintf("将公众号文章llm操作加入缓存 加入缓存 AddWechatArticleLlmOpToCache LPush: 操作类型：%s，公众号稳扎id：%d", source, wechatArticleId))
 		if err != nil {
 			fmt.Println("AddWechatArticleOpToCache LPush Err:" + err.Error())
 		}
@@ -96,26 +107,61 @@ func RagEtaReportOpToCache(reportId, reportChapterId int, source string) bool {
 // @Description:
 type RagEtaReportLlmOp struct {
 	RagEtaReportId int
+	QuestionId     int
+	ForceGenerate  bool
 }
 
 // AddRagEtaReportLlmOpToCache
 // @Description: 将ETA报告llm操作加入缓存
-// @param wechatPlatformId
+// @author: Roc
-// @param source
+// @datetime 2025-04-24 13:59:16
+// @param ragEtaReportId int
+// @param questionId int
 // @return bool
-func AddRagEtaReportLlmOpToCache(ragEtaReportId int) bool {
+func AddRagEtaReportLlmOpToCache(ragEtaReportId, questionId int, forceGenerate bool) bool {
 	// 如果不在发布和调试模式，那么就不加入缓存
 	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
 		return true
 	}
 	record := new(RagEtaReportLlmOp)
 	record.RagEtaReportId = ragEtaReportId
+	record.QuestionId = questionId
+	record.ForceGenerate = forceGenerate
+	if utils.Re != nil {
+		return false
+	}
+
+	err := utils.Rc.LPush(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, record)
+	utils.FileLog.Info(fmt.Sprintf("将eta报告llm操作加入缓存 加入缓存 RagEtaReportLlmOpToCache LPush: ETA报告id：%d", ragEtaReportId))
+	if err != nil {
+		fmt.Println("RagEtaReportLlmOpToCache LPush Err:" + err.Error())
+	}
+	return true
+}
+
+type AiTaskRecordOp struct {
+	AiTaskRecordId int
+}
+
+// AddAiTaskRecordOpToCache
+// @Description: AI任务操作调度入队列
+// @author: Roc
+// @datetime 2025-04-24 09:41:11
+// @param aiTaskRecordId int
+// @return bool
+func AddAiTaskRecordOpToCache(aiTaskRecordId int) bool {
+	// 如果不在发布和调试模式，那么就不加入缓存
+	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
+		return true
+	}
+	record := new(AiTaskRecordOp)
+	record.AiTaskRecordId = aiTaskRecordId
 	if utils.Re == nil {
-		err := utils.Rc.LPush(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, record)
+		err := utils.Rc.LPush(utils.CACHE_AI_ARTICLE_ABSTRACT_LLM_TASK, record)
 
-		utils.FileLog.Info(fmt.Sprintf("将eta报告llm操作加入缓存 加入缓存 RagEtaReportLlmOpToCache LPush: ETA报告id：%d", ragEtaReportId))
+		utils.FileLog.Info(fmt.Sprintf("将AI任务操作调度入队列 加入缓存 AddAiTaskRecordOpToCache LPush: 记录id：%d", aiTaskRecordId))
 		if err != nil {
-			fmt.Println("RagEtaReportLlmOpToCache LPush Err:" + err.Error())
+			fmt.Println("AddAiTaskRecordOpToCache LPush Err:" + err.Error())
 		}
 		return true
 	}

controllers/llm/abstract.go

@@ -449,8 +449,6 @@ func (c *AbstractController) AddVector() {
 		return
 	}
 
-	wechatArticleAbstractIdList := make([]int, 0)
-
 	obj := rag.WechatArticleAbstract{}
 	list, err := obj.GetByIdList(req.WechatArticleAbstractIdList)
 	if err != nil {
@@ -462,56 +460,8 @@ func (c *AbstractController) AddVector() {
 		}
 		return
 	}
-	if len(list) > 0 {
+	for _, v := range list {
-		for _, v := range list {
+		cache.AddWechatArticleLlmOpToCache(v.WechatArticleId, v.QuestionId, ``)
-			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.WechatArticleAbstractId)
-		}
-	}
-
-	//if !req.IsSelectAll {
-	//	list, err := obj.GetByIdList(req.WechatArticleAbstractIdList)
-	//	if err != nil {
-	//		br.Msg = "修改失败"
-	//		br.ErrMsg = "修改失败，查找问题失败，Err:" + err.Error()
-	//		if utils.IsErrNoRow(err) {
-	//			br.Msg = "问题不存在"
-	//			br.IsSendEmail = false
-	//		}
-	//		return
-	//	}
-	//	if len(list) > 0 {
-	//		for _, v := range list {
-	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.WechatArticleAbstractId)
-	//		}
-	//	}
-	//} else {
-	//	notIdMap := make(map[int]bool)
-	//	for _, v := range req.NotWechatArticleAbstractIdList {
-	//		notIdMap[v] = true
-	//	}
-	//
-	//	_, list, err := getAbstractList(req.KeyWord, req.TagId, 0, 100000)
-	//	if err != nil {
-	//		br.Msg = "修改失败"
-	//		br.ErrMsg = "修改失败，查找问题失败，Err:" + err.Error()
-	//		if utils.IsErrNoRow(err) {
-	//			br.Msg = "问题不存在"
-	//			br.IsSendEmail = false
-	//		}
-	//		return
-	//	}
-	//	if len(list) > 0 {
-	//		for _, v := range list {
-	//			if notIdMap[v.WechatArticleAbstractId] {
-	//				continue
-	//			}
-	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.WechatArticleAbstractId)
-	//		}
-	//	}
-	//}
-
-	for _, wechatArticleAbstractId := range wechatArticleAbstractIdList {
-		cache.AddWechatArticleLlmOpToCache(wechatArticleAbstractId, ``)
 	}
 
 	br.Ret = 200

controllers/llm/rag_eta_report_abstract.go

@@ -351,8 +351,6 @@ func (c *RagEtaReportAbstractController) AddVector() {
 		return
 	}
 
-	ragEtaReportAbstractIdList := make([]int, 0)
-
 	obj := rag.RagEtaReportAbstract{}
 	list, err := obj.GetByIdList(req.RagEtaReportAbstractIdList)
 	if err != nil {
@@ -366,7 +364,7 @@ func (c *RagEtaReportAbstractController) AddVector() {
 	}
 	if len(list) > 0 {
 		for _, v := range list {
-			ragEtaReportAbstractIdList = append(ragEtaReportAbstractIdList, v.RagEtaReportAbstractId)
+			cache.AddRagEtaReportLlmOpToCache(v.RagEtaReportId, v.QuestionId, false)
 		}
 	}
 
@@ -412,10 +410,6 @@ func (c *RagEtaReportAbstractController) AddVector() {
 	//	}
 	//}
 
-	for _, ragEtaReportAbstractId := range ragEtaReportAbstractIdList {
-		cache.AddRagEtaReportLlmOpToCache(ragEtaReportAbstractId)
-	}
-
 	br.Ret = 200
 	br.Success = true
 	br.Msg = `添加向量库中，请稍后查看`

models/rag/ai_task_record.go

@@ -1,6 +1,7 @@
 package rag
 
 import (
+	"database/sql"
 	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
@@ -84,6 +85,17 @@ func (m *AiTaskRecord) GetListByCondition(field, condition string, pars []interf
 	return
 }
 
+func (m *AiTaskRecord) GetCountByCondition(condition string, pars []interface{}) (total int, err error) {
+	var intNull sql.NullInt64
+	sqlStr := fmt.Sprintf(`SELECT COUNT(1) total FROM %s WHERE 1=1 %s`, m.TableName(), condition)
+	err = global.DbMap[utils.DbNameAI].Raw(sqlStr, pars...).Scan(&intNull).Error
+	if err == nil && intNull.Valid {
+		total = int(intNull.Int64)
+	}
+
+	return
+}
+
 // QuestionGenerateAbstractParam
 // @Description:
 type QuestionGenerateAbstractParam struct {

services/llm.go

@@ -162,7 +162,7 @@ func getWechatArticleIdList(currentIndex, pageSize int) (wechatArticleIdList []i
 	startSize = utils.StartIndex(currentIndex, pageSize)
 
 	condition += fmt.Sprintf(` AND %s = ? `, rag.WechatArticleColumns.IsDeleted)
-	pars = append(pars, 0, 1)
+	pars = append(pars, 0)
 
 	obj := new(rag.WechatArticle)
 	list, err := obj.GetListByCondition(` wechat_article_id `, condition, pars, startSize, pageSize)

services/llm_report.go

@@ -186,7 +186,7 @@ func handleReportAddOrModifyKnowledge(reportId, reportChapterId int, title, auth
 		err = item.Create()
 	}
 
-	cache.AddRagEtaReportLlmOpToCache(item.RagEtaReportId)
+	cache.AddRagEtaReportLlmOpToCache(item.RagEtaReportId, 0, true)
 
 	return
 }
@@ -283,20 +283,19 @@ func getArticleContent(content *strings.Builder, htmlContentNode *html.Node) {
 	}
 }
 
-// GenerateArticleAbstract
+// GenerateRagEtaReportAbstract
 // @Description: 文章摘要生成（默认提示词批量生成）
 // @author: Roc
-// @datetime 2025-03-10 16:17:53
+// @datetime 2025-04-24 11:24:53
 // @param item *rag.RagEtaReport
+// @param forceGenerate bool
 func GenerateRagEtaReportAbstract(item *rag.RagEtaReport, forceGenerate bool) {
 	var err error
 	defer func() {
 		if err != nil {
-			utils.FileLog.Error("文章转临时文件失败，err:%v", err)
+			utils.FileLog.Error("文章摘要生成（默认提示词批量生成）失败，err:%v", err)
-			fmt.Println("文章转临时文件失败，err:", err)
 		}
 	}()
-
 	// 内容为空，那就不需要生成摘要
 	if item.TextContent == `` {
 		return
@@ -322,16 +321,17 @@ func GenerateRagEtaReportAbstract(item *rag.RagEtaReport, forceGenerate bool) {
 }
 
 // GenerateRagEtaReportAbstractByQuestion
-// @Description: 文章摘要生成（根据提示词生成）
+// @Description: ETA报告摘要生成（根据提示词生成）
 // @author: Roc
-// @datetime 2025-03-10 16:17:53
+// @datetime 2025-04-24 11:23:49
 // @param item *rag.RagEtaReport
-func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *rag.Question, forceGenerate bool) {
+// @param question *rag.Question
-	var err error
+// @param forceGenerate bool
+// @return err error
+func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *rag.Question, forceGenerate bool) (err error) {
 	defer func() {
 		if err != nil {
-			utils.FileLog.Error("文章转临时文件失败，err:%v", err)
+			utils.FileLog.Error("文章摘要生成（根据提示词生成）失败，err:%v", err)
-			fmt.Println("文章转临时文件失败，err:", err)
 		}
 	}()
 
@@ -349,6 +349,10 @@ func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *ra
 
 		return
 	}
+	// 如果是没找到数据，那么就将报错置空
+	if err != nil && utils.IsErrNoRow(err) {
+		err = nil
+	}
 
 	//你现在是一名资深的期货行业分析师，请基于以下的问题进行汇总总结，如果不能正常总结出来，那么就只需要回复我：sorry
 	questionStr := fmt.Sprintf(`%s\n%s`, `你现在是一名资深的期货行业分析师，请基于以下的问题进行汇总总结，如果不能正常总结出来，那么就只需要回复我：sorry。以下是问题：`, question.QuestionContent)
@@ -371,6 +375,9 @@ func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *ra
 	if abstract == `` {
 		return
 	}
+	if abstract == `sorry` || strings.Index(abstract, `根据已知信息无法回答该问题`) == 0 {
+		return
+	}
 
 	//if abstract == `sorry` || strings.Index(abstract, `根据已知信息无法回答该问题`) == 0 {
 	//	item.AbstractStatus = 2
@@ -471,6 +478,8 @@ func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *ra
 	go AddOrEditEsRagEtaReportAbstract(abstractItem.RagEtaReportAbstractId)
 
 	ReportAbstractToKnowledge(item, abstractItem, false)
+
+	return
 }
 
 // AddOrEditEsRagEtaReportAbstract

services/task.go

@@ -80,6 +80,9 @@ func Task() {
 	// 定时任务进行eta报告进行LLM操作
 	go HandleEtaReportKnowledgeLLmOp()
 
+	// 定时任务进行进行AI报告/文章的摘要任务LLM操作
+	go HandleAiArticleAbstractLlmOp()
+
 	// 权益报告监听入库
 	go AutoInsertRaiReport()
 
@@ -603,7 +606,7 @@ func HandleWechatArticleOp() {
 	obj := rag.WechatPlatform{}
 	for {
 		utils.Rc.Brpop(utils.CACHE_WECHAT_PLATFORM_ARTICLE, func(b []byte) {
-			wechatArticleOp := new(cache.WechatArticleOp)
+			wechatArticleOp := new(cache.WechatPlatformOp)
 			if err := json.Unmarshal(b, &wechatArticleOp); err != nil {
 				fmt.Println("json unmarshal wrong!")
 				return
@@ -633,25 +636,52 @@ func HandleWechatArticleLLmOp() {
 			fmt.Println("[HandleWechatArticleLLmOp]", err)
 		}
 	}()
-	obj := rag.WechatArticle{}
 	for {
-		utils.Rc.Brpop(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, func(b []byte) {
+		utils.Rc.Brpop(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, handleWechatArticleLLmOp)
-			wechatArticleOp := new(cache.WechatArticleOp)
+	}
-			if err := json.Unmarshal(b, &wechatArticleOp); err != nil {
+}
-				fmt.Println("json unmarshal wrong!")
-				return
-			}
-			item, tmpErr := obj.GetById(wechatArticleOp.WechatPlatformId)
-			if tmpErr != nil {
-				// 找不到就处理失败
-				return
-			}
 
-			// 文章加入到知识库
+// handleWechatArticleLLmOp
-			ArticleToKnowledge(item)
+// @Description: 处理微信文章加入知识库
-			// 生成摘要
+// @author: Roc
-			GenerateWechatArticleAbstract(item, false)
+// @datetime 2025-04-24 13:33:08
-		})
+// @param b []byte
+func handleWechatArticleLLmOp(b []byte) {
+	var err error
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("[handleWechatArticleLLmOp] params：%s；err：%s", string(b), err.Error())
+		}
+	}()
+	obj := rag.WechatArticle{}
+	wechatArticleOp := new(cache.WechatArticleOp)
+	if err = json.Unmarshal(b, &wechatArticleOp); err != nil {
+		fmt.Println("json unmarshal wrong!")
+		return
+	}
+	item, err := obj.GetById(wechatArticleOp.WechatArticleId)
+	if err != nil {
+		// 找不到就处理失败
+		return
+	}
+
+	// 文章加入到知识库
+	ArticleToKnowledge(item)
+
+	// 生成摘要
+	if wechatArticleOp.QuestionId <= 0 {
+		// 全部摘要生成
+		GenerateWechatArticleAbstract(item, false)
+	} else {
+		questionObj := rag.Question{}
+		questionInfo, tmpErr := questionObj.GetByID(wechatArticleOp.QuestionId)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		// 指定指定摘要生成
+		err = GenerateWechatArticleAbstractByQuestion(item, questionInfo, false)
 	}
 }
 
@@ -660,7 +690,7 @@ func HandleWechatArticleLLmOp() {
 func HandleEtaReportUpdateOp() {
 	defer func() {
 		if err := recover(); err != nil {
-			fmt.Println("[HandleEtaReportKnowledgeLLmOp]", err)
+			fmt.Println("[HandleEtaReportUpdateOp]", err)
 		}
 	}()
 	for {
@@ -686,77 +716,210 @@ func HandleEtaReportUpdateOp() {
 func HandleEtaReportKnowledgeLLmOp() {
 	defer func() {
 		if err := recover(); err != nil {
-			fmt.Println("[HandleWechatArticleLLmOp]", err)
+			fmt.Println("[HandleEtaReportKnowledgeLLmOp]", err)
 		}
 	}()
-	obj := rag.RagEtaReport{}
+
 	for {
-		utils.Rc.Brpop(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, func(b []byte) {
+		utils.Rc.Brpop(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, handleEtaReportKnowledgeLLmOp)
-			wechatArticleOp := new(cache.RagEtaReportLlmOp)
+	}
-			if err := json.Unmarshal(b, &wechatArticleOp); err != nil {
+}
-				fmt.Println("json unmarshal wrong!")
-				return
-			}
-			item, tmpErr := obj.GetById(wechatArticleOp.RagEtaReportId)
-			if tmpErr != nil {
-				// 找不到就处理失败
-				return
-			}
 
-			// 已经删除的就不做操作了
+// handleEtaReportKnowledgeLLmOp
-			if item.IsDeleted == 1 {
+// @Description: 处理微信文章加入知识库操作
-				return
+// @author: Roc
-			}
+// @datetime 2025-04-24 14:04:10
+// @param b []byte
+func handleEtaReportKnowledgeLLmOp(b []byte) {
+	var err error
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("[handleEtaReportKnowledgeLLmOp] params：%s；err：%s", string(b), err.Error())
+		}
+	}()
 
-			// 未发布的就不操作了
+	obj := rag.RagEtaReport{}
-			if item.IsPublished != 1 {
+	wechatArticleOp := new(cache.RagEtaReportLlmOp)
-				return
+	if err = json.Unmarshal(b, &wechatArticleOp); err != nil {
-			}
+		fmt.Println("json unmarshal wrong!")
+		return
+	}
+	item, err := obj.GetById(wechatArticleOp.RagEtaReportId)
+	if err != nil {
+		// 找不到就处理失败
+		return
+	}
 
-			// 文章加入到知识库
+	// 已经删除的就不做操作了
-			//ArticleToKnowledge(item)
+	if item.IsDeleted == 1 {
-			// 生成摘要
+		return
-			GenerateRagEtaReportAbstract(item, true)
+	}
-		})
+
+	// 未发布的就不操作了
+	if item.IsPublished != 1 {
+		return
+	}
+
+	// 文章加入到知识库
+	//ArticleToKnowledge(item)
+
+	// 生成摘要
+
+	if wechatArticleOp.QuestionId <= 0 {
+		// 全部提示词摘要生成
+		GenerateRagEtaReportAbstract(item, wechatArticleOp.ForceGenerate)
+	} else {
+		questionObj := rag.Question{}
+		questionInfo, tmpErr := questionObj.GetByID(wechatArticleOp.QuestionId)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		// 全部提示词摘要生成
+		err = GenerateRagEtaReportAbstractByQuestion(item, questionInfo, wechatArticleOp.ForceGenerate)
 	}
 }
 
-// HandleEtaReportKnowledgeLLmOp
+// HandleAiArticleAbstractLlmOp
-// @Description: 处理微信文章加入知识库
+// @Description: 处理AI库的报告摘要生成（批量任务）
-func Handle() {
+// @author: Roc
+// @datetime 2025-04-24 10:25:51
+func HandleAiArticleAbstractLlmOp() {
 	defer func() {
 		if err := recover(); err != nil {
-			fmt.Println("[HandleWechatArticleLLmOp]", err)
+			fmt.Println("[HandleAiArticleAbstractLlmOp]", err)
 		}
 	}()
-	obj := rag.RagEtaReport{}
 	for {
-		utils.Rc.Brpop(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, func(b []byte) {
+		utils.Rc.Brpop(utils.CACHE_AI_ARTICLE_ABSTRACT_LLM_TASK, handleAiArticleAbstractLlmOp)
-			wechatArticleOp := new(cache.RagEtaReportLlmOp)
+	}
-			if err := json.Unmarshal(b, &wechatArticleOp); err != nil {
+}
-				fmt.Println("json unmarshal wrong!")
+
+// handleAiArticleAbstractLlmOp
+// @Description: 处理AI库的报告摘要生成（批量任务）
+// @author: Roc
+// @datetime 2025-04-24 11:26:05
+// @param b []byte
+func handleAiArticleAbstractLlmOp(b []byte) {
+	var err error
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("[handleAiArticleAbstractLlmOp] params：%s；err：%s", string(b), err.Error())
+		}
+	}()
+	obj := rag.AiTaskRecord{}
+	aiTaskRecordOp := new(cache.AiTaskRecordOp)
+	if err = json.Unmarshal(b, &aiTaskRecordOp); err != nil {
+		fmt.Println("json unmarshal wrong!")
+		return
+	}
+	item, err := obj.GetByID(aiTaskRecordOp.AiTaskRecordId)
+	if err != nil {
+		err = fmt.Errorf("查找任务记录状态失败, err: %s", err.Error())
+		return
+	}
+
+	// 处理完成后标记任务状态
+	defer func() {
+		// 修改任务状态
+		todoCount, tmpErr := obj.GetCountByCondition(fmt.Sprintf(` AND %s = ? AND %s = ? `, rag.AiTaskColumns.AiTaskID, rag.AiTaskColumns.Status), []interface{}{item.AiTaskID, `待处理`})
+		if tmpErr != nil {
+			err = fmt.Errorf("查找剩余任务数量失败, err: %s", tmpErr.Error())
+			return
+		}
+		if todoCount <= 0 {
+			aiTaskObj := rag.AiTask{}
+			aiTaskInfo, tmpErr := aiTaskObj.GetByID(item.AiTaskID)
+			if tmpErr != nil {
+				err = fmt.Errorf("查找任务失败, err: %s", tmpErr.Error())
 				return
 			}
-			item, tmpErr := obj.GetById(wechatArticleOp.RagEtaReportId)
+			aiTaskInfo.Status = `done`
+			aiTaskInfo.UpdateTime = time.Now()
+			tmpErr = aiTaskInfo.Update([]string{"status", "update_time"})
 			if tmpErr != nil {
-				// 找不到就处理失败
+				err = fmt.Errorf("标记任务状态失败, err: %s", tmpErr.Error())
 				return
 			}
+		}
 
-			// 已经删除的就不做操作了
+		return
-			if item.IsDeleted == 1 {
+	}()
-				return
-			}
 
-			// 未发布的就不操作了
+	// 不是待处理就不处理
-			if item.IsPublished != 1 {
+	if item.Status != `待处理` {
-				return
+		return
-			}
+	}
 
-			// 文章加入到知识库
+	// 处理完成后标记记录状态
-			//ArticleToKnowledge(item)
+	defer func() {
-			// 生成摘要
+		status := `处理成功`
-			GenerateRagEtaReportAbstract(item, true)
+		remark := ``
-		})
+		if err != nil {
+			status = `处理失败`
+			remark = err.Error()
+		}
+		item.Status = status
+		item.Remark = remark
+		item.ModifyTime = time.Now()
+		tmpErr := item.Update([]string{"status", "remark", "modify_time"})
+		if tmpErr != nil {
+			err = fmt.Errorf("标记任务记录状态失败, err: %s", tmpErr.Error())
+			return
+		}
+	}()
+
+	var params rag.QuestionGenerateAbstractParam
+	if err = json.Unmarshal([]byte(item.Parameters), &params); err != nil {
+		fmt.Println("json unmarshal wrong!")
+		return
 	}
+
+	// 查找提示词
+	questionObj := rag.Question{}
+	questionInfo, tmpErr := questionObj.GetByID(params.QuestionId)
+	if tmpErr != nil {
+		// 找不到就处理失败
+		err = fmt.Errorf("查找提示词失败, err: %s", err.Error())
+		return
+	}
+
+	switch params.ArticleType {
+	case `wechat_article`:
+		articleObj := rag.WechatArticle{}
+		articleInfo, tmpErr := articleObj.GetById(params.ArticleId)
+		if tmpErr != nil {
+			err = tmpErr
+			// 找不到就处理失败
+			return
+		}
+		// 生成摘要
+		err = GenerateWechatArticleAbstractByQuestion(articleInfo, questionInfo, true)
+	case `rag_eta_report`:
+		articleObj := rag.RagEtaReport{}
+		articleInfo, tmpErr := articleObj.GetById(params.ArticleId)
+		if tmpErr != nil {
+			err = tmpErr
+			// 找不到就处理失败
+			return
+		}
+
+		// 已经删除的就不做操作了
+		if articleInfo.IsDeleted == 1 {
+			return
+		}
+
+		// 未发布的就不操作了
+		if articleInfo.IsPublished != 1 {
+			return
+		}
+
+		// 生成摘要
+		err = GenerateRagEtaReportAbstractByQuestion(articleInfo, questionInfo, true)
+
+	}
+}
+func init() {
+	cache.AddAiTaskRecordOpToCache(12208)
 }

services/wechat_platform.go

@@ -179,7 +179,7 @@ func AddWechatArticle(item *rag.WechatPlatform, articleLink string, articleDetai
 	go replaceWechatArticleCoverPic(obj)
 
 	// 文章入库成功后，需要将相关信息入摘要库
-	go cache.AddWechatArticleLlmOpToCache(obj.WechatArticleId, ``)
+	go cache.AddWechatArticleLlmOpToCache(obj.WechatArticleId, 0, ``)
 
 }
 
@@ -360,17 +360,18 @@ func GenerateWechatArticleAbstract(item *rag.WechatArticle, forceGenerate bool)
 	return
 }
 
-// GenerateArticleAbstractByQuestion
+// GenerateWechatArticleAbstractByQuestion
 // @Description: 文章摘要生成（根据提示词生成）
 // @author: Roc
-// @datetime 2025-03-10 16:17:53
+// @datetime 2025-04-24 11:23:27
 // @param item *rag.WechatArticle
-func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *rag.Question, forceGenerate bool) {
+// @param question *rag.Question
-	var err error
+// @param forceGenerate bool
+// @return err error
+func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *rag.Question, forceGenerate bool) (err error) {
 	defer func() {
 		if err != nil {
-			utils.FileLog.Error("摘要生成失败，err:%v", err)
+			utils.FileLog.Error("文章摘要生成（根据提示词生成）失败，err:%v", err)
-			fmt.Println("摘要生成失败，err:", err)
 		}
 	}()
 
@@ -389,6 +390,11 @@ func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *
 		return
 	}
 
+	// 如果是没找到数据，那么就将报错置空
+	if err != nil && utils.IsErrNoRow(err) {
+		err = nil
+	}
+
 	//你现在是一名资深的期货行业分析师，请基于以下的问题进行汇总总结，如果不能正常总结出来，那么就只需要回复我：sorry
 	questionStr := fmt.Sprintf(`%s\n%s`, `你现在是一名资深的期货行业分析师，请基于以下的问题进行汇总总结，如果不能正常总结出来，那么就只需要回复我：sorry。以下是问题：`, question.QuestionContent)
 	//开始对话
@@ -402,6 +408,13 @@ func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *
 		return
 	}
 
+	if abstract == `sorry` || strings.Index(abstract, `根据已知信息无法回答该问题`) == 0 {
+		item.AbstractStatus = 2
+		item.ModifyTime = time.Now()
+		err = item.Update([]string{"AbstractStatus", "ModifyTime"})
+		return
+	}
+
 	var tagIdJsonStr string
 	var tagNameJsonStr string
 	// 标签ID
@@ -455,12 +468,6 @@ func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *
 		tagNameJsonStr = strings.Join(tagNameList, `,`)
 	}
 
-	if abstract == `sorry` || strings.Index(abstract, `根据已知信息无法回答该问题`) == 0 {
-		item.AbstractStatus = 2
-		item.ModifyTime = time.Now()
-		err = item.Update([]string{"AbstractStatus", "ModifyTime"})
-		return
-	}
 	item.AbstractStatus = 1
 	item.ModifyTime = time.Now()
 	err = item.Update([]string{"AbstractStatus", "ModifyTime"})
@@ -501,6 +508,8 @@ func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *
 	go AddOrEditEsWechatArticleAbstract(abstractItem.WechatArticleAbstractId)
 
 	WechatArticleAbstractToKnowledge(item, abstractItem, false)
+
+	return
 }
 
 // DelDoc

utils/constants.go

@@ -269,6 +269,7 @@ const (
 	CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE = "wechat_platform:article:knowledge:op:" //微信文章入知识库处理
 	CACHE_ETA_REPORT_KNOWLEDGE              = "eta:report:knowledge:op:"              //eta报告入AI库处理
 	CACHE_ETA_REPORT_KNOWLEDGE_LLM          = "eta:report:knowledge:llm:op:"          //eta报告入知识库处理
+	CACHE_AI_ARTICLE_ABSTRACT_LLM_TASK      = "eta:ai:article:abstract:llm:task:op:"  //微信文章/eta报告的摘要重新生成处理（任务调度）
 	CACHE_CHART_AUTH                        = "eta:chart:auth:"                       //图表数据授权
 	CACHE_REPORT_SHARE_AUTH                 = "eta:report:auth:share:"                //报告短链与报告图表授权映射key
 	CACHE_REPORT_AUTH                       = "eta:report:auth:"                      //报告图表数据授权