hongze_cygx/services/elastic.go

package services

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/olivere/elastic/v7"
	"hongze/hongze_cygx/models"
	"log"
	"os"
	"strconv"
)

func NewClient() (client *elastic.Client, err error) {
	errorlog := log.New(os.Stdout, "APP", log.LstdFlags)
	file := "./rdlucklog/eslog.log"
	logFile, _ := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
	client, err = elastic.NewClient(
		elastic.SetURL(ES_URL),
		elastic.SetBasicAuth(ES_USERNAME, ES_PASSWORD),
		elastic.SetTraceLog(log.New(logFile, "ES-TRACE: ", 0)),
		elastic.SetSniff(false), elastic.SetErrorLog(errorlog))
	return
}

//indexName:索引名称
//mappingJson:表结构
func EsCreateIndex(indexName, mappingJson string) (err error) {
	client, err := NewClient()
	if err != nil {
		return
	}
	//定义表结构
	exists, err := client.IndexExists(indexName).Do(context.Background()) //<5>
	if err != nil {
		return
	}
	if !exists {
		resp, err := client.CreateIndex(indexName).BodyJson(mappingJson).Do(context.Background())
		//BodyJson(bodyJson).Do(context.Background())
		if err != nil {
			fmt.Println("CreateIndex Err:" + err.Error())
			return err
		}
		fmt.Println(resp.Index, resp.ShardsAcknowledged, resp.Acknowledged)
	} else {
		fmt.Println(indexName + " 已存在")
	}
	return
}

//新增数据
func EsAddData(indexName, docId string, item interface{}) (err error) {
	client, err := NewClient()
	if err != nil {
		return
	}
	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
	if err != nil {
		return
	}
	if resp.Status == 0 && resp.Result == "created" {
		fmt.Println("新增成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

//删除数据
func EsDeleteData(indexName, docId string) (err error) {
	client, err := NewClient()
	if err != nil {
		return
	}
	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
	if err != nil {
		return
	}
	if resp.Status == 0 {
		fmt.Println("删除成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

func MappingModify(indexName, mappingJson string) {
	client, err := NewClient()
	if err != nil {
		return
	}
	result, err := client.PutMapping().Index(indexName).BodyString(mappingJson).Do(context.Background())
	fmt.Println(err)
	fmt.Println(result)
	return
}

func EsMatchQuery(indexName, keyWord string) (result []*models.SearchItem, err error) {
	client, err := NewClient()
	pageSize := 20
	keyWordArr, err := GetIndustryMapNameSliceV2(keyWord)
	fmt.Println(keyWordArr)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	fmt.Println("-------------------------------")
	fmt.Println(keyWordArr)
	searchMap := make(map[int]int)
	boolquery := elastic.NewBoolQuery()
	keyLen := len(keyWordArr)
	n := float64(keyLen)
	matchArr := make([]elastic.Query, 0)

	matchq1 := elastic.NewMatchQuery("Title", keyWord).Boost(n + 1).Analyzer("ik_smart")
	matchq2 := elastic.NewMatchQuery("BodyText", keyWord).Boost(n + 1).Analyzer("ik_smart")

	matchArr = append(matchArr, matchq1)
	matchArr = append(matchArr, matchq2)
	for _, v := range keyWordArr {
		if v != "" {
			matchq1 := elastic.NewMatchQuery("Title", v).Boost(n).Analyzer("ik_smart")
			matchq2 := elastic.NewMatchQuery("BodyText", v).Boost(n).Analyzer("ik_smart")
			matchArr = append(matchArr, matchq1)
			matchArr = append(matchArr, matchq2)
		}
		n--
	}
	boolquery.Should(matchArr...)
	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("Title"), elastic.NewHighlighterField("BodyText"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
	request := client.Search(indexName).Highlight(highlight).Size(pageSize).Query(boolquery)
	searchByMatch, err := request.Do(context.Background())
	if searchByMatch.Hits != nil {
		for _, v := range searchByMatch.Hits.Hits {
			articleJson, err := v.Source.MarshalJSON()
			if err != nil {
				return nil, err
			}
			article := new(models.CygxArticle)
			err = json.Unmarshal(articleJson, &article)
			if err != nil {
				return nil, err
			}
			if _, ok := searchMap[article.ArticleId]; !ok {
				searchItem := new(models.SearchItem)
				searchItem.ArticleId, _ = strconv.Atoi(v.Id)
				if len(v.Highlight["BodyText"]) > 0 {
					searchItem.Body = v.Highlight["BodyText"]
				} else {
					bodyRune := []rune(article.BodyText)
					bodyRuneLen:=len(bodyRune)
					if bodyRuneLen>100 {
						bodyRuneLen=100
					}
					body:= string(bodyRune[:bodyRuneLen])
					fmt.Println(body)
					searchItem.Body = []string{body}
				}
				var title string
				if len(v.Highlight["Title"]) > 0 {
					title = v.Highlight["Title"][0]
				} else {
					title = article.Title
				}
				searchItem.Title = title
				searchItem.PublishDate = article.PublishDate
				result = append(result, searchItem)
				searchMap[article.ArticleId] = article.ArticleId
			}
		}
	}
	return
}

func EsMatchPhraseQuery(indexName, keyWord string) (result []*models.SearchItem, err error) {
	client, err := NewClient()
	pageSize := 20
	keyWordArr, err := GetIndustryMapNameSliceV2(keyWord)
	fmt.Println(keyWordArr)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	fmt.Println("-------------------------------")
	fmt.Println(keyWordArr)
	searchMap := make(map[int]int)
	boolquery := elastic.NewBoolQuery()
	//keyLen := len(keyWordArr)
	//n := float64(keyLen)
	matchArr := make([]elastic.Query, 0)
	//matchq1 := elastic.NewMatchQuery("Title", keyWord).Boost(n + 1).Analyzer("ik_smart")
	//matchq2 := elastic.NewMatchQuery("BodyText", keyWord).Boost(n + 1).Analyzer("ik_smart")
	matchq1 := elastic.NewMatchPhraseQuery("Title", keyWord) //.Analyzer("ik_smart")
	matchq2 := elastic.NewMatchPhraseQuery("BodyText", keyWord)
	matchArr = append(matchArr, matchq1)
	matchArr = append(matchArr, matchq2)
	//matchArr = append(matchArr, matchq2)
	//for _, v := range keyWordArr {
	//	if v != "" {
	//		matchq1 := elastic.NewMatchQuery("Title", v).Boost(n).Analyzer("ik_smart")
	//		matchq2 := elastic.NewMatchQuery("BodyText", v).Boost(n).Analyzer("ik_smart")
	//		matchArr = append(matchArr, matchq1)
	//		matchArr = append(matchArr, matchq2)
	//	}
	//	n--
	//}
	//boolquery.Should(matchArr...)

	boolquery.Should(matchArr...)

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("Title"), elastic.NewHighlighterField("BodyText"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
	request := client.Search(indexName).Highlight(highlight).Size(pageSize).Query(boolquery)
	searchByMatch, err := request.Do(context.Background())
	fmt.Println("err:", err, searchByMatch)
	return
	if searchByMatch.Hits != nil {
		for _, v := range searchByMatch.Hits.Hits {
			articleJson, err := v.Source.MarshalJSON()
			if err != nil {
				return nil, err
			}
			article := new(models.CygxArticle)
			err = json.Unmarshal(articleJson, &article)
			if err != nil {
				return nil, err
			}
			if _, ok := searchMap[article.ArticleId]; !ok {
				searchItem := new(models.SearchItem)
				searchItem.ArticleId, _ = strconv.Atoi(v.Id)
				searchItem.Body = v.Highlight["BodyText"]
				var title string
				if len(v.Highlight["Title"]) > 0 {
					title = v.Highlight["Title"][0]
				} else {
					title = article.Title
				}
				searchItem.Title = title
				searchItem.PublishDate = article.PublishDate
				result = append(result, searchItem)
				searchMap[article.ArticleId] = article.ArticleId
			}
		}
	}
	return
}