knowledgeBase/rpc/knowledge/internal/service/knowledgeService.go

package service

import (
	cm "app.yhyue.com/moapp/jybase/common"
	. "app.yhyue.com/moapp/jybase/encrypt"
	elastic "app.yhyue.com/moapp/jybase/esv1"
	"bp.jydev.jianyu360.cn/BaseService/userCenter/rpc/usercenter"
	. "bp.jydev.jianyu360.cn/SocialPlatform/knowledgeBase/entity"
	"bp.jydev.jianyu360.cn/SocialPlatform/knowledgeBase/rpc/knowledge/internal/config"

	//. "bp.jydev.jianyu360.cn/SocialPlatform/knowledgeBase/rpc/knowledge/init"
	"bp.jydev.jianyu360.cn/SocialPlatform/knowledgeBase/rpc/knowledge/knowledgeclient"
	"bp.jydev.jianyu360.cn/SocialPlatform/knowledgeBase/rpc/knowledge/util"
	"context"
	"database/sql"
	"errors"
	"github.com/zeromicro/go-zero/core/logx"
	"log"
	"strconv"
	"time"
)

type KnowledgeService struct{}

var (
	Index = "smart_new"
	Type  = "smart"
)

func (k *KnowledgeService) KnowledgeAdd(param *knowledgeclient.AddRequest) (bool, string, error) {
	//先查找知识库Id
	query := map[string]interface{}{"status": 1, "appid": param.AppId, "ent_id": param.EntId}
	datalist := Mysql.Find(util.KNOWLEDGE, query, "id", "", -1, -1)
	if datalist != nil && *datalist != nil && len(*datalist) > 0 {
		//问题进行分词
		keywords := util.HanlpGetNormalWords(param.Question, config.C.Segment)
		if len(keywords) == 0 {
			keywords = append(keywords, param.Question)
		}
		//通过entUserId获取创建人名称,调用用户中心
		req := &usercenter.EntUserReq{
			EntId:     param.EntId,
			EntUserId: param.EntUserId,
			AppId:     param.AppId,
		}
		resp, err := UserCenterLib.GetEntUserInfo(context.Background(), req)
		if err != nil {
			logx.Info("查询用户中台创建人信息失败", param.EntId, param.EntUserId, "err:", err)
			return false, "查询用户中台创建人信息失败", err
		}
		createPerson := resp.Data.Name
		var answerId int64
		nowTime := time.Now().Local().Format(util.Date_Full_Layout)
		fool := Mysql.ExecTx("添加知识", func(tx *sql.Tx) bool {
			//插入答案
			answerData := map[string]interface{}{
				"knowledge_id":  (*datalist)[0]["id"],
				"status":        1,
				"create_time":   nowTime,
				"update_time":   nowTime,
				"create_person": createPerson,
				"content":       param.Answer,
			}
			answerId = Mysql.Insert(util.ANSWER, answerData)
			//插入问题
			questionData := map[string]interface{}{
				"answer_id": answerId,
				"content":   param.Question,
				"keywords":  keywords,
			}
			questionId := Mysql.Insert(util.QUESTION, questionData)
			return answerId > 0 && questionId > 0
		})
		if fool {
			//插入es
			knowledge := map[string]interface{}{
				"knowledgeId":  (*datalist)[0]["id"],
				"status":       1,
				"createTime":   time.Now().Unix(),
				"createPerson": createPerson,
				"answer":       param.Answer,
				"question":     param.Question,
				"keywords":     keywords,
				"answerId":     answerId,
				"entId":        param.EntId,
			}
			b := elastic.Save(Index, Type, knowledge)
			if b {
				return true, "插入es成功", nil
			} else {
				return false, "插入es出错", errors.New("插入es出错")
			}
		} else {
			return false, "插入mysql出错", errors.New("插入mysql出错")
		}
	} else {
		return false, "租户不存在", errors.New("租户不存在")
	}
}

func (k *KnowledgeService) KnowledgeEdit(param *knowledgeclient.KnowledgeEditReq) (ok bool, msg string, err error) {
	//获取问题分词
	keywords := util.HttpDo(param.Question)
	if keywords == "" {
		keywords = param.Question
	}
	//通过entUserId获取创建人名称
	req := &usercenter.EntUserReq{
		EntId:     param.EntId,
		EntUserId: param.EntUserId,
		AppId:     param.AppId,
	}
	resp := &usercenter.EntUserResp{}
	resp, err = UserCenterLib.GetEntUserInfo(context.Background(), req)
	if err != nil {
		logx.Info("查询用户中台创建人信息失败", param.EntId, param.EntUserId, "err:", err)
		return false, "查询用户中台创建人信息失败", err
	}
	createPerson := resp.Data.Name
	fool := Mysql.ExecTx("编辑问题、答案", func(tx *sql.Tx) bool {
		//修改答案
		answerUpdate := map[string]interface{}{
			"update_time": time.Now().Local().Format(util.Date_Full_Layout),
			"content":     param.Answer,
		}
		ok1 := Mysql.UpdateByTx(tx, util.ANSWER, map[string]interface{}{"id": param.AnswerId}, answerUpdate)
		//修改问题
		questionUpdate := map[string]interface{}{
			"content":  param.Question,
			"keywords": keywords,
		}
		ok2 := Mysql.UpdateByTx(tx, util.QUESTION, map[string]interface{}{"answer_id": param.AnswerId}, questionUpdate)
		return ok1 && ok2
	})

	if fool {
		query := `{"query":{"bool":{"must":[{"term":{"answerId":"` + strconv.Itoa(int(param.AnswerId)) + `"}}],"must_not":[],"should":[]}},"from":0,"size":10,"sort":[],"facets":{}}`
		//修改es数据
		newKnowledge := map[string]interface{}{
			"knowledgeId":  param.KnowledgeId,
			"status":       1,
			"createTime":   time.Now().Unix(),
			"createPerson": createPerson,
			"answer":       param.Answer,
			"question":     param.Question,
			"keywords":     keywords,
			"answerId":     param.AnswerId,
			"entId":        param.EntId,
		}
		ok1 := elastic.Del(Index, Type, query)
		ok := elastic.Save(Index, Type, newKnowledge)
		if ok && ok1 {
			ok = true
			msg = "修改问题成功"
		} else {
			ok = false
			err = errors.New("删除es问题失败")
			msg = "删除es问题失败"
		}
	} else {
		ok = false
		err = errors.New("修改mysql问题失败")
		msg = "修改mysql问题失败"
	}
	return
}

func (k *KnowledgeService) KnowledgeList(param *knowledgeclient.ListRequest) *knowledgeclient.ListData {
	var knowledgeList knowledgeclient.ListData
	var data []*knowledgeclient.KnowledgeEntity
	countSql := "SELECT COUNT(b.id)  FROM " + util.KNOWLEDGE +
		" a LEFT JOIN " + util.ANSWER + " b ON a.id = b.knowledge_id LEFT JOIN " + util.QUESTION +
		" c ON b.id = c.answer_id WHERE b.`status` =1 and a.ent_id=?"
	count := Mysql.CountBySql(countSql, param.EntId)
	log.Println("总数：", count)
	if count > 0 {
		//列表数据
		sql1 := "SELECT b.content as answer,c.content as question,b.id,b.knowledge_id  FROM " + util.KNOWLEDGE +
			" a LEFT JOIN " + util.ANSWER + " b ON a.id = b.knowledge_id LEFT JOIN " + util.QUESTION +
			" c ON b.id = c.answer_id WHERE b.`status` =1 and a.ent_id=? order by b.update_time desc limit ?,?"
		//log.Println(sql, param.EntId, (param.PageIndex-1)*param.PageSize, param.PageSize)
		datalist := Mysql.SelectBySql(sql1, param.EntId, (param.PageIndex-1)*param.PageSize, param.PageSize)
		if datalist != nil && *datalist != nil && len(*datalist) > 0 {
			for _, value := range *datalist {
				knowledge := knowledgeclient.KnowledgeEntity{}
				knowledge.Answer = cm.ObjToString(value["answer"])
				knowledge.Question = cm.ObjToString(value["question"])
				knowledge.AnswerId = cm.Int64All(value["id"])
				knowledge.KnowledgeId = cm.Int64All(value["knowledge_id"])
				data = append(data, &knowledge)
			}
		}
		//log.Println("数据：", data)
		knowledgeList.Total = count
		knowledgeList.Data = data
	}
	return &knowledgeList
}

func (k *KnowledgeService) KnowledgeInfo(answerId int64) (data *knowledgeclient.KnowledgeEntity, ok bool) {
	sql1 := "SELECT b.content as answer,c.content as question,b.id,b.knowledge_id  FROM " + util.ANSWER +
		" b LEFT JOIN " + util.QUESTION + " c ON b.id = c.answer_id WHERE b.`status` =1 AND b.id = ? "
	datalist := Mysql.SelectBySql(sql1, answerId)
	if datalist != nil && *datalist != nil && len(*datalist) > 0 {
		knowledge := knowledgeclient.KnowledgeEntity{}
		knowledge.Answer = cm.ObjToString((*datalist)[0]["answer"])
		knowledge.Question = cm.ObjToString((*datalist)[0]["question"])
		knowledge.AnswerId = cm.Int64All((*datalist)[0]["id"])
		knowledge.KnowledgeId = cm.Int64All((*datalist)[0]["knowledge_id"])
		return &knowledge, true
	}
	return nil, false
}

func (k *KnowledgeService) KnowledgeDel(answerId int64) (ok bool, msg string) {
	//修改答案
	answerUpdate := map[string]interface{}{
		"update_time": time.Now().Local().Format(util.Date_Full_Layout),
		"status":      0,
	}
	fool := Mysql.Update(util.ANSWER, map[string]interface{}{"id": answerId}, answerUpdate)

	if fool {
		//删除es数据
		query := `{"query":{"bool":{"must":[{"term":{"answerId":"` + strconv.Itoa(int(answerId)) + `"}}],"must_not":[],"should":[]}},"from":0,"size":10,"sort":[],"facets":{}}`
		ok := elastic.Del(Index, Type, query)
		if ok {
			return true, "删除成功"
		} else {
			return false, "删除es问题失败"
		}
	}
	return false, "删除mysql问题失败"
}

func (k *KnowledgeService) FindAnswer(param *knowledgeclient.FindAnswerReq) *knowledgeclient.Question {
	var question knowledgeclient.Question
	robotEntId := SE.Decode4Hex(param.RobotEntId)
	logx.Info("机器人企业id：", robotEntId)
	//组装es query
	query := util.DSL4SmartResponse(param.Question, robotEntId, int(param.Type))
	logx.Info("es查询：", query)
	res := elastic.Get(Index, Type, query)
	if res != nil && len(*res) > 0 {
		data := (*res)[0]
		question.Answer = cm.ObjToString(data["answer"])
		question.Question = cm.ObjToString(data["question"])
	}
	return &question
}

func (k *KnowledgeService) RecommendAnswer(param *knowledgeclient.FindAnswerReq) []*knowledgeclient.Question {
	var (
		keyWords    = ""
		searchField = `"answer","question"`
		answers     []*knowledgeclient.Question
	)
	//根据问题进行分词
	keyWords = util.HttpDo(param.Question)
	log.Println("问题分词关键字：", keyWords)
	var query = util.DSL4SearchByKwsOrid(keyWords, SE.Decode4Hex(param.RobotEntId))
	res := elastic.GetAllByNgram(Index, Type, query, "", "", searchField, 0, 3, 0, false)
	//log.Println("推荐3个答案：", res)
	if res != nil && len(*res) > 0 {
		for _, val := range *res {
			answers = append(answers, &knowledgeclient.Question{
				Question: cm.ObjToString(val["question"]),
				Answer:   cm.ObjToString(val["answer"]),
			})
		}
	}
	return answers
}