Merge branch 'rag/4.0' into debug

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())
 		}
@@ -61,7 +72,7 @@ func AddWechatArticleLlmOpToCache(wechatPlatformId int, source string) bool {
 	return false
 }
 
-type RagEtaReportOpOp struct {
+type RagEtaReportOp struct {
 	Source          string
 	ReportId        int
 	ReportChapterId int
@@ -76,7 +87,7 @@ type RagEtaReportOpOp struct {
 // @param source string
 // @return bool
 func RagEtaReportOpToCache(reportId, reportChapterId int, source string) bool {
-	record := new(RagEtaReportOpOp)
+	record := new(RagEtaReportOp)
 	record.Source = source
 	record.ReportId = reportId
 	record.ReportChapterId = reportChapterId
@@ -91,3 +102,68 @@ func RagEtaReportOpToCache(reportId, reportChapterId int, source string) bool {
 	}
 	return false
 }
+
+// RagEtaReportLlmOp
+// @Description:
+type RagEtaReportLlmOp struct {
+	RagEtaReportId int
+	QuestionId     int
+	ForceGenerate  bool
+}
+
+// AddRagEtaReportLlmOpToCache
+// @Description: 将ETA报告llm操作加入缓存
+// @author: Roc
+// @datetime 2025-04-24 13:59:16
+// @param ragEtaReportId int
+// @param questionId int
+// @return 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_AI_ARTICLE_ABSTRACT_LLM_TASK, record)
+
+		utils.FileLog.Info(fmt.Sprintf("将AI任务操作调度入队列 加入缓存 AddAiTaskRecordOpToCache LPush: 记录id：%d", aiTaskRecordId))
+		if err != nil {
+			fmt.Println("AddAiTaskRecordOpToCache LPush Err:" + err.Error())
+		}
+		return true
+	}
+	return false
+}

controllers/llm/abstract.go

@@ -206,102 +206,14 @@ func (c *AbstractController) Del() {
 		return
 	}
 
-	vectorKeyList := make([]string, 0)
-	wechatArticleAbstractIdList := make([]int, 0)
-
-	obj := rag.WechatArticleAbstract{}
-
-	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 {
-			// 有加入到向量库，那么就加入到待删除的向量库list中
-			if v.VectorKey != `` {
-				vectorKeyList = append(vectorKeyList, v.VectorKey)
-			}
-			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 {
-	//			// 有加入到向量库，那么就加入到待删除的向量库list中
-	//			if v.VectorKey != `` {
-	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
-	//			}
-	//			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
-	//			}
-	//			// 有加入到向量库，那么就加入到待删除的向量库list中
-	//			if v.VectorKey != `` {
-	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
-	//			}
-	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.WechatArticleAbstractId)
-	//		}
-	//	}
-	//}
-
-	// 删除向量库
-	err = services.DelLlmDoc(vectorKeyList, wechatArticleAbstractIdList)
-	if err != nil {
-		br.Msg = "删除失败"
-		br.ErrMsg = "删除向量库失败，Err:" + err.Error()
-		return
-	}
-
 	// 删除摘要
-	err = obj.DelByIdList(wechatArticleAbstractIdList)
+	err = services.DelWechatArticleAbstract(req.WechatArticleAbstractIdList)
 	if err != nil {
 		br.Msg = "删除失败"
 		br.ErrMsg = "删除失败，Err:" + err.Error()
 		return
 	}
 
-	// 删除es数据
-	for _, wechatArticleAbstractId := range wechatArticleAbstractIdList {
-		go services.DelEsWechatArticleAbstract(wechatArticleAbstractId)
-	}
-
 	br.Ret = 200
 	br.Success = true
 	br.Msg = `删除成功`
@@ -449,8 +361,6 @@ func (c *AbstractController) AddVector() {
 		return
 	}
 
-	wechatArticleAbstractIdList := make([]int, 0)
-
 	obj := rag.WechatArticleAbstract{}
 	list, err := obj.GetByIdList(req.WechatArticleAbstractIdList)
 	if err != nil {
@@ -462,56 +372,8 @@ func (c *AbstractController) AddVector() {
 		}
 		return
 	}
-	if len(list) > 0 {
-		for _, v := range list {
-			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, ``)
+	for _, v := range list {
+		cache.AddWechatArticleLlmOpToCache(v.WechatArticleId, v.QuestionId, ``)
 	}
 
 	br.Ret = 200

controllers/llm/question.go

@@ -492,6 +492,16 @@ func (c *QuestionController) SetDefault() {
 		return
 	}
 
+	// 判断是否正在取消默认提示词（删除历史摘要）
+	{
+		cacheKey := services.GetDelAbstractByQuestionIdCacheKey(item.QuestionId)
+		if utils.Rc.IsExist(cacheKey) {
+			br.Msg = "取消设置默认提示词后，删除历史摘要中，请稍后再试！"
+			br.IsSendEmail = false
+			return
+		}
+	}
+
 	if item.IsDefault == 1 {
 		br.Msg = "该提示词已经是默认提示词，无需设置"
 		br.IsSendEmail = false
@@ -551,11 +561,11 @@ func (c *QuestionController) UnSetDefault() {
 		return
 	}
 
-	if item.IsDefault == 0 {
-		br.Msg = "该提示词不是默认提示词，无需取消"
-		br.IsSendEmail = false
-		return
-	}
+	//if item.IsDefault == 0 {
+	//	br.Msg = "该提示词不是默认提示词，无需取消"
+	//	br.IsSendEmail = false
+	//	return
+	//}
 
 	// 如果是取消已经设置成默认的提示词，那么需要判断是否有正在生成摘要的提示词任务，如果存在的话，那么就不允许取消
 	auth, err := services.CheckOpQuestionAuth()
@@ -581,7 +591,8 @@ func (c *QuestionController) UnSetDefault() {
 	// 新增/编辑ES数据
 	go services.AddOrEditEsRagQuestion(item.QuestionId)
 
-	// todo 对应的提示词生成的摘要库和向量库内容也取消，同时需要加锁，不允许重复操作
+	// 对应的提示词生成的摘要库和向量库内容也取消，同时需要加锁，不允许重复操作
+	go services.DelAbstractByQuestionId(item.QuestionId)
 
 	br.Ret = 200
 	br.Success = true
@@ -663,8 +674,6 @@ func (c *QuestionController) GenerateAbstract() {
 	// 添加任务
 	services.AddGenerateAbstractTask(item, c.SysUser)
 
-	// todo 开始任务
-
 	br.Ret = 200
 	br.Success = true
 	br.Msg = `摘要生成中`

controllers/llm/rag_eta_report_abstract.go

@@ -196,102 +196,14 @@ func (c *RagEtaReportAbstractController) Del() {
 		return
 	}
 
-	vectorKeyList := make([]string, 0)
-	wechatArticleAbstractIdList := make([]int, 0)
-
-	obj := rag.RagEtaReportAbstract{}
-
-	list, err := obj.GetByIdList(req.RagEtaReportAbstractIdList)
-	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 {
-			// 有加入到向量库，那么就加入到待删除的向量库list中
-			if v.VectorKey != `` {
-				vectorKeyList = append(vectorKeyList, v.VectorKey)
-			}
-			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
-		}
-	}
-
-	//if !req.IsSelectAll {
-	//	list, err := obj.GetByIdList(req.RagEtaReportAbstractIdList)
-	//	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 {
-	//			// 有加入到向量库，那么就加入到待删除的向量库list中
-	//			if v.VectorKey != `` {
-	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
-	//			}
-	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
-	//		}
-	//	}
-	//} else {
-	//	notIdMap := make(map[int]bool)
-	//	for _, v := range req.NotRagEtaReportAbstractIdList {
-	//		notIdMap[v] = true
-	//	}
-	//
-	//	_, list, err := getRagEtaReportAbstractList(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.RagEtaReportAbstractId] {
-	//				continue
-	//			}
-	//			// 有加入到向量库，那么就加入到待删除的向量库list中
-	//			if v.VectorKey != `` {
-	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
-	//			}
-	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
-	//		}
-	//	}
-	//}
-
-	// 删除向量库
-	err = services.DelRagReportLlmDoc(vectorKeyList, wechatArticleAbstractIdList)
-	if err != nil {
-		br.Msg = "删除失败"
-		br.ErrMsg = "删除向量库失败，Err:" + err.Error()
-		return
-	}
-
 	// 删除摘要
-	err = obj.DelByIdList(wechatArticleAbstractIdList)
+	err = services.DelRagEtaReportAbstract(req.RagEtaReportAbstractIdList)
 	if err != nil {
 		br.Msg = "删除失败"
 		br.ErrMsg = "删除失败，Err:" + err.Error()
 		return
 	}
 
-	// 删除es数据
-	for _, wechatArticleAbstractId := range wechatArticleAbstractIdList {
-		go services.DelEsRagEtaReportAbstract(wechatArticleAbstractId)
-	}
-
 	br.Ret = 200
 	br.Success = true
 	br.Msg = `删除成功`
@@ -439,8 +351,6 @@ func (c *RagEtaReportAbstractController) AddVector() {
 		return
 	}
 
-	wechatArticleAbstractIdList := make([]int, 0)
-
 	obj := rag.RagEtaReportAbstract{}
 	list, err := obj.GetByIdList(req.RagEtaReportAbstractIdList)
 	if err != nil {
@@ -454,7 +364,7 @@ func (c *RagEtaReportAbstractController) AddVector() {
 	}
 	if len(list) > 0 {
 		for _, v := range list {
-			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
+			cache.AddRagEtaReportLlmOpToCache(v.RagEtaReportId, v.QuestionId, false)
 		}
 	}
 
@@ -500,10 +410,6 @@ func (c *RagEtaReportAbstractController) AddVector() {
 	//	}
 	//}
 
-	for _, wechatArticleAbstractId := range wechatArticleAbstractIdList {
-		cache.AddWechatArticleLlmOpToCache(wechatArticleAbstractId, ``)
-	}
-
 	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"
@@ -73,6 +74,16 @@ func (m *AiTaskRecord) GetByCondition(condition string, pars []interface{}) (ite
 	return
 }
 
+func (m *AiTaskRecord) GetAllListByCondition(field, condition string, pars []interface{}) (items []*AiTaskRecord, err error) {
+	if field == "" {
+		field = "*"
+	}
+	sqlStr := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s order by AiTaskRecord_id desc `, field, m.TableName(), condition)
+	err = global.DbMap[utils.DbNameAI].Raw(sqlStr, pars...).Find(&items).Error
+
+	return
+}
+
 func (m *AiTaskRecord) GetListByCondition(field, condition string, pars []interface{}, startSize, pageSize int) (items []*AiTaskRecord, err error) {
 	if field == "" {
 		field = "*"
@@ -84,6 +95,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 {

models/rag/rag_eta_report_abstract.go

@@ -85,6 +85,12 @@ func (m *RagEtaReportAbstract) GetByIdList(idList []int) (items []*RagEtaReportA
 	return
 }
 
+func (m *RagEtaReportAbstract) GetListByQuestionId(questionId int) (items []*RagEtaReportAbstract, err error) {
+	err = global.DbMap[utils.DbNameAI].Where(fmt.Sprintf("%s = ? ", RagEtaReportAbstractColumns.QuestionId), questionId).Find(&items).Error
+
+	return
+}
+
 func (m *RagEtaReportAbstract) GetListByCondition(field, condition string, pars []interface{}, startSize, pageSize int) (items []*RagEtaReportAbstract, err error) {
 	if field == "" {
 		field = "*"

models/rag/wechat_article_abstract.go

@@ -81,6 +81,12 @@ func (m *WechatArticleAbstract) GetByIdList(idList []int) (items []*WechatArticl
 	return
 }
 
+func (m *WechatArticleAbstract) GetListByQuestionId(questionId int) (items []*WechatArticleAbstract, err error) {
+	err = global.DbMap[utils.DbNameAI].Where(fmt.Sprintf("%s = ? ", WechatArticleAbstractColumns.QuestionId), questionId).Find(&items).Error
+
+	return
+}
+
 func (m *WechatArticleAbstract) GetListByCondition(field, condition string, pars []interface{}, startSize, pageSize int) (items []*WechatArticleAbstract, err error) {
 	if field == "" {
 		field = "*"

services/llm.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"encoding/json"
+	"eta/eta_api/cache"
 	"eta/eta_api/models/rag"
 	"eta/eta_api/models/system"
 	"eta/eta_api/utils"
@@ -104,9 +105,29 @@ func AddGenerateAbstractTask(question *rag.Question, sysUser *system.Admin) {
 		return
 	}
 
+	// 添加到缓存队列中
+	go addTaskToCache(aiTask.AiTaskID)
+
 	return
 }
 
+func addTaskToCache(aiTaskId int) {
+	var err error
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("addTaskToCache error: %v", err)
+		}
+	}()
+	obj := rag.AiTaskRecord{}
+	list, err := obj.GetAllListByCondition("*", ` ai_task_id = ? `, []interface{}{aiTaskId})
+	if err != nil {
+		return
+	}
+	for _, item := range list {
+		cache.AddAiTaskRecordOpToCache(item.AiTaskRecordID)
+	}
+}
+
 // getAllWechatArticleIdList
 // @Description: 获取所有的微信文章Id列表
 // @author: Roc
@@ -162,7 +183,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

@@ -2,6 +2,8 @@ package services
 
 import (
 	"encoding/json"
+	"errors"
+	"eta/eta_api/cache"
 	"eta/eta_api/models"
 	"eta/eta_api/models/rag"
 	"eta/eta_api/services/elastic"
@@ -184,6 +186,8 @@ func handleReportAddOrModifyKnowledge(reportId, reportChapterId int, title, auth
 		err = item.Create()
 	}
 
+	cache.AddRagEtaReportLlmOpToCache(item.RagEtaReportId, 0, true)
+
 	return
 }
 
@@ -249,6 +253,9 @@ func ReportUnPublishedKnowledgeByReportId(reportId int) {
 			errList = append(errList, fmt.Sprintf("第%d章：%s，异常：\n%s", item.ReportChapterId, item.Title, err.Error()))
 			continue
 		}
+
+		// 删除摘要
+		err = DelRagEtaReportAbstract([]int{item.RagEtaReportId})
 	}
 
 	return
@@ -276,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)
-			fmt.Println("文章转临时文件失败，err:", err)
+			utils.FileLog.Error("文章摘要生成（默认提示词批量生成）失败，err:%v", err)
 		}
 	}()
-
 	// 内容为空，那就不需要生成摘要
 	if item.TextContent == `` {
 		return
@@ -315,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) {
-	var err error
+// @param question *rag.Question
+// @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)
-			fmt.Println("文章转临时文件失败，err:", err)
+			utils.FileLog.Error("文章摘要生成（根据提示词生成）失败，err:%v", err)
 		}
 	}()
 
@@ -342,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)
@@ -364,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
@@ -464,6 +478,8 @@ func GenerateRagEtaReportAbstractByQuestion(item *rag.RagEtaReport, question *ra
 	go AddOrEditEsRagEtaReportAbstract(abstractItem.RagEtaReportAbstractId)
 
 	ReportAbstractToKnowledge(item, abstractItem, false)
+
+	return
 }
 
 // AddOrEditEsRagEtaReportAbstract
@@ -639,3 +655,137 @@ func DelRagReportLlmDoc(vectorKeyList []string, abstractIdList []int) (err error
 
 	return
 }
+
+// DelRagEtaReportAbstract
+// @Description: 删除ETA报告摘要
+// @author: Roc
+// @datetime 2025-04-23 17:36:22
+// @param abstractIdList []int
+// @return err error
+func DelRagEtaReportAbstract(abstractIdList []int) (err error) {
+	obj := rag.RagEtaReportAbstract{}
+
+	list, err := obj.GetByIdList(abstractIdList)
+	if err != nil {
+		if !utils.IsErrNoRow(err) {
+			err = errors.New("删除向量库失败，Err:" + err.Error())
+		} else {
+			err = nil
+		}
+		return
+	}
+
+	err = delRagEtaReportAbstract(list)
+
+	return
+}
+
+// DelRagEtaReportAbstractByQuestionId
+// @Description: 根据提示词ID删除ETA报告摘要
+// @author: Roc
+// @datetime 2025-04-23 17:36:22
+// @param abstractIdList []int
+// @return err error
+func DelRagEtaReportAbstractByQuestionId(questionId int) (err error) {
+	obj := rag.RagEtaReportAbstract{}
+
+	list, err := obj.GetListByQuestionId(questionId)
+	if err != nil {
+		if !utils.IsErrNoRow(err) {
+			err = errors.New("删除向量库失败，Err:" + err.Error())
+		} else {
+			err = nil
+		}
+		return
+	}
+
+	err = delRagEtaReportAbstract(list)
+
+	return
+}
+
+// delRagEtaReportAbstract
+// @Description: 删除摘要
+// @author: Roc
+// @datetime 2025-04-24 15:19:19
+// @param list []*rag.RagEtaReportAbstract
+// @return err error
+func delRagEtaReportAbstract(list []*rag.RagEtaReportAbstract) (err error) {
+	obj := rag.RagEtaReportAbstract{}
+
+	vectorKeyList := make([]string, 0)
+	newAbstractIdList := make([]int, 0)
+
+	if len(list) > 0 {
+		for _, v := range list {
+			// 有加入到向量库，那么就加入到待删除的向量库list中
+			if v.VectorKey != `` {
+				vectorKeyList = append(vectorKeyList, v.VectorKey)
+			}
+			newAbstractIdList = append(newAbstractIdList, v.RagEtaReportAbstractId)
+		}
+	}
+	// 删除向量库
+	err = DelRagReportLlmDoc(vectorKeyList, newAbstractIdList)
+	if err != nil {
+		err = errors.New("删除向量库失败，Err:" + err.Error())
+		return
+	}
+
+	// 删除摘要
+	err = obj.DelByIdList(newAbstractIdList)
+	if err != nil {
+		err = errors.New("删除失败，Err:" + err.Error())
+		return
+	}
+
+	// 删除es数据
+	for _, wechatArticleAbstractId := range newAbstractIdList {
+		go DelEsRagEtaReportAbstract(wechatArticleAbstractId)
+	}
+
+	return
+}
+
+// GetDelAbstractByQuestionIdCacheKey
+// @Description: 获取删除微信文章/ETA报告摘要的缓存key
+// @author: Roc
+// @datetime 2025-04-24 15:44:41
+// @param questionId int
+// @return string
+func GetDelAbstractByQuestionIdCacheKey(questionId int) string {
+	return fmt.Sprintf("%s%d", utils.CACHE_AI_ARTICLE_ABSTRACT_DEL, questionId)
+}
+
+// DelAbstractByQuestionId
+// @Description: 根据提示词ID删除微信文章/报告摘要
+// @author: Roc
+// @datetime 2025-04-24 15:37:28
+// @param questionId int
+func DelAbstractByQuestionId(questionId int) {
+	cacheKey := GetDelAbstractByQuestionIdCacheKey(questionId)
+	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Minute) {
+		utils.FileLog.Error("根据提示词删除摘要失败，提示词ID：%d,系统处理中，请稍后重试！", questionId)
+		return
+	}
+
+	defer func() {
+		utils.Rc.Delete(cacheKey)
+	}()
+
+	// 删除微信文章摘要
+	err := DelWechatArticleAbstractByQuestionId(questionId)
+	if err != nil {
+		utils.FileLog.Error("根据提示词摘要删除微信文章摘要失败，提示词ID：%d；原因：%s", questionId, err.Error())
+	}
+
+	// 删除ETA报告摘要
+	err = DelRagEtaReportAbstractByQuestionId(questionId)
+	if err != nil {
+		utils.FileLog.Error("根据提示词删除ETA报告摘要失败，提示词ID：%d；原因：%s", questionId, err.Error())
+	}
+
+	//time.Sleep(30 * time.Second)
+
+	return
+}

services/task.go

@@ -75,8 +75,14 @@ func Task() {
 	go HandleWechatArticleLLmOp()
 
 	// 队列任务将eta报告同步到知识库操作
+	go HandleEtaReportUpdateOp()
+
+	// 定时任务进行eta报告进行LLM操作
 	go HandleEtaReportKnowledgeLLmOp()
 
+	// 定时任务进行进行AI报告/文章的摘要任务LLM操作
+	go HandleAiArticleAbstractLlmOp()
+
 	// 权益报告监听入库
 	go AutoInsertRaiReport()
 
@@ -589,8 +595,8 @@ func ModifyEsEnglishReport() {
 //	return rnd.Float64()*11000 - 1000
 //}
 
-// HandleSearchByWechatOp
-// @Description: 处理微信爬虫
+// HandleWechatArticleOp
+// @Description: 处理ETA报告加入到知识库
 func HandleWechatArticleOp() {
 	defer func() {
 		if err := recover(); err != nil {
@@ -600,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
@@ -630,39 +636,66 @@ func HandleWechatArticleLLmOp() {
 			fmt.Println("[HandleWechatArticleLLmOp]", err)
 		}
 	}()
-	obj := rag.WechatArticle{}
 	for {
-		utils.Rc.Brpop(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, func(b []byte) {
-			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
-			}
+		utils.Rc.Brpop(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, handleWechatArticleLLmOp)
+	}
+}
 
-			// 文章加入到知识库
-			ArticleToKnowledge(item)
-			// 生成摘要
-			GenerateWechatArticleAbstract(item, false)
-		})
+// handleWechatArticleLLmOp
+// @Description: 处理微信文章加入知识库
+// @author: Roc
+// @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)
 	}
 }
 
-// HandleEtaReportKnowledgeLLmOp
+// HandleEtaReportUpdateOp
 // @Description: 处理eta报告加入知识库操作
-func HandleEtaReportKnowledgeLLmOp() {
+func HandleEtaReportUpdateOp() {
 	defer func() {
 		if err := recover(); err != nil {
-			fmt.Println("[HandleEtaReportKnowledgeLLmOp]", err)
+			fmt.Println("[HandleEtaReportUpdateOp]", err)
 		}
 	}()
 	for {
 		utils.Rc.Brpop(utils.CACHE_ETA_REPORT_KNOWLEDGE, func(b []byte) {
-			ragEtaReportOpOp := new(cache.RagEtaReportOpOp)
+			ragEtaReportOpOp := new(cache.RagEtaReportOp)
 			if err := json.Unmarshal(b, &ragEtaReportOpOp); err != nil {
 				fmt.Println("json unmarshal wrong!")
 				return
@@ -677,3 +710,213 @@ func HandleEtaReportKnowledgeLLmOp() {
 		})
 	}
 }
+
+// HandleEtaReportKnowledgeLLmOp
+// @Description: 处理微信文章加入知识库
+func HandleEtaReportKnowledgeLLmOp() {
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Println("[HandleEtaReportKnowledgeLLmOp]", err)
+		}
+	}()
+
+	for {
+		utils.Rc.Brpop(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, handleEtaReportKnowledgeLLmOp)
+	}
+}
+
+// handleEtaReportKnowledgeLLmOp
+// @Description: 处理微信文章加入知识库操作
+// @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{}
+	wechatArticleOp := new(cache.RagEtaReportLlmOp)
+	if err = json.Unmarshal(b, &wechatArticleOp); err != nil {
+		fmt.Println("json unmarshal wrong!")
+		return
+	}
+	item, err := obj.GetById(wechatArticleOp.RagEtaReportId)
+	if err != nil {
+		// 找不到就处理失败
+		return
+	}
+
+	// 已经删除的就不做操作了
+	if item.IsDeleted == 1 {
+		return
+	}
+
+	// 未发布的就不操作了
+	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)
+	}
+}
+
+// HandleAiArticleAbstractLlmOp
+// @Description: 处理AI库的报告摘要生成（批量任务）
+// @author: Roc
+// @datetime 2025-04-24 10:25:51
+func HandleAiArticleAbstractLlmOp() {
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Println("[HandleAiArticleAbstractLlmOp]", err)
+		}
+	}()
+	for {
+		utils.Rc.Brpop(utils.CACHE_AI_ARTICLE_ABSTRACT_LLM_TASK, handleAiArticleAbstractLlmOp)
+	}
+}
+
+// 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
+			}
+			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.Status != `待处理` {
+		return
+	}
+
+	// 处理完成后标记记录状态
+	defer func() {
+		status := `处理成功`
+		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)
+
+	}
+}

services/wechat_platform.go

@@ -3,6 +3,7 @@ package services
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"eta/eta_api/cache"
 	"eta/eta_api/models"
 	"eta/eta_api/models/rag"
@@ -179,7 +180,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 +361,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) {
-	var err error
+// @param question *rag.Question
+// @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)
-			fmt.Println("摘要生成失败，err:", err)
+			utils.FileLog.Error("文章摘要生成（根据提示词生成）失败，err:%v", err)
 		}
 	}()
 
@@ -389,6 +391,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 +409,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 +469,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 +509,8 @@ func GenerateWechatArticleAbstractByQuestion(item *rag.WechatArticle, question *
 	go AddOrEditEsWechatArticleAbstract(abstractItem.WechatArticleAbstractId)
 
 	WechatArticleAbstractToKnowledge(item, abstractItem, false)
+
+	return
 }
 
 // DelDoc
@@ -1121,6 +1131,148 @@ func AddOrEditEsWechatArticleAbstract(articleAbstractId int) {
 	err = elastic.WechatArticleAbstractEsAddOrEdit(strconv.Itoa(articleAbstractId), esItem)
 }
 
+// DelWechatArticleAbstract
+// @Description: 删除微信文章摘要
+// @author: Roc
+// @datetime 2025-04-23 17:36:22
+// @param abstractIdList []int
+// @return err error
+func DelWechatArticleAbstract(abstractIdList []int) (err error) {
+	obj := rag.WechatArticleAbstract{}
+
+	list, err := obj.GetByIdList(abstractIdList)
+	if err != nil {
+		if !utils.IsErrNoRow(err) {
+			err = errors.New("删除向量库失败，Err:" + err.Error())
+		} else {
+			err = nil
+		}
+		return
+	}
+
+	err = delWechatArticleAbstract(list)
+
+	return
+}
+
+// DelWechatArticleAbstract
+// @Description: 删除微信文章摘要
+// @author: Roc
+// @datetime 2025-04-23 17:36:22
+// @param abstractIdList []int
+// @return err error
+func DelWechatArticleAbstractByQuestionId(questionId int) (err error) {
+	obj := rag.WechatArticleAbstract{}
+
+	list, err := obj.GetListByQuestionId(questionId)
+	if err != nil {
+		if !utils.IsErrNoRow(err) {
+			err = errors.New("删除向量库失败，Err:" + err.Error())
+		} else {
+			err = nil
+		}
+		return
+	}
+
+	err = delWechatArticleAbstract(list)
+
+	return
+}
+
+// delRagEtaReportAbstract
+// @Description: 删除摘要
+// @author: Roc
+// @datetime 2025-04-24 15:19:19
+// @param list []*rag.RagEtaReportAbstract
+// @return err error
+func delWechatArticleAbstract(list []*rag.WechatArticleAbstract) (err error) {
+	obj := rag.RagEtaReportAbstract{}
+
+	vectorKeyList := make([]string, 0)
+	newAbstractIdList := make([]int, 0)
+
+	if len(list) > 0 {
+		for _, v := range list {
+			// 有加入到向量库，那么就加入到待删除的向量库list中
+			if v.VectorKey != `` {
+				vectorKeyList = append(vectorKeyList, v.VectorKey)
+			}
+			newAbstractIdList = append(newAbstractIdList, v.WechatArticleAbstractId)
+		}
+	}
+
+	//if !req.IsSelectAll {
+	//	list, err := obj.GetByIdList(req.RagEtaReportAbstractIdList)
+	//	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 {
+	//			// 有加入到向量库，那么就加入到待删除的向量库list中
+	//			if v.VectorKey != `` {
+	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
+	//			}
+	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
+	//		}
+	//	}
+	//} else {
+	//	notIdMap := make(map[int]bool)
+	//	for _, v := range req.NotRagEtaReportAbstractIdList {
+	//		notIdMap[v] = true
+	//	}
+	//
+	//	_, list, err := getRagEtaReportAbstractList(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.RagEtaReportAbstractId] {
+	//				continue
+	//			}
+	//			// 有加入到向量库，那么就加入到待删除的向量库list中
+	//			if v.VectorKey != `` {
+	//				vectorKeyList = append(vectorKeyList, v.VectorKey)
+	//			}
+	//			wechatArticleAbstractIdList = append(wechatArticleAbstractIdList, v.RagEtaReportAbstractId)
+	//		}
+	//	}
+	//}
+
+	// 删除向量库
+	err = DelLlmDoc(vectorKeyList, newAbstractIdList)
+	if err != nil {
+		err = errors.New("删除向量库失败，Err:" + err.Error())
+		return
+	}
+
+	// 删除摘要
+	err = obj.DelByIdList(newAbstractIdList)
+	if err != nil {
+		err = errors.New("删除失败，Err:" + err.Error())
+		return
+	}
+
+	// 删除es数据
+	for _, wechatArticleAbstractId := range newAbstractIdList {
+		go DelEsWechatArticleAbstract(wechatArticleAbstractId)
+	}
+
+	return
+}
+
 // DelEsWechatArticleAbstract
 // @Description: 删除ES中的微信文章摘要
 // @author: Roc

utils/constants.go

@@ -271,7 +271,10 @@ const (
 	CACHE_DATA_SOURCE_ES_HANDLE             = "eta:data_source_es:handle"             // 数据源es处理队列
 	CACHE_WECHAT_PLATFORM_ARTICLE           = "wechat_platform:article:op:"           //微信文章处理
 	CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE = "wechat_platform:article:knowledge:op:" //微信文章入知识库处理
-	CACHE_ETA_REPORT_KNOWLEDGE              = "eta:report:knowledge:op:"              //eta报告入知识库处理
+	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_AI_ARTICLE_ABSTRACT_DEL           = "eta:ai:article:abstract:del:op:"       //微信文章/eta报告的摘要删删除缓存，避免有人在删除的过程中，又将该提示词做摘要生成
 	CACHE_CHART_AUTH                        = "eta:chart:auth:"                       //图表数据授权
 	CACHE_REPORT_SHARE_AUTH                 = "eta:report:auth:share:"                //报告短链与报告图表授权映射key
 	CACHE_REPORT_AUTH                       = "eta:report:auth:"                      //报告图表数据授权