hongze_cygx/services/elastic.go

package services

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/olivere/elastic/v7"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/utils"
	"sort"
	"strconv"
	"strings"
)

func NewClient() (client *elastic.Client, err error) {
	//errorlog := log.New(os.Stdout, "APP", log.LstdFlags)
	//file := ""
	//if utils.RunMode == "release" {
	//	//file = `/data/rdlucklog/hongze_cygx/eslog.log`
	//	file = `./rdlucklog/eslog.log`
	//} else {
	//	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))
	client, err = elastic.NewClient(
		elastic.SetURL(ES_URL),
		elastic.SetBasicAuth(ES_USERNAME, ES_PASSWORD),
		elastic.SetSniff(false))
	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 EsAddOrEditData(indexName, docId string, item *ElasticTestArticleDetail) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client, err := NewClient()
	if err != nil {
		return
	}
	searchById, err := client.Get().Index(indexName).Id(docId).Do(context.Background())
	if err != nil && !strings.Contains(err.Error(), "404") {
		fmt.Println("Get Err" + err.Error())
		return
	}
	if searchById != nil && searchById.Found {
		resp, err := client.Update().Index(indexName).Id(docId).Doc(map[string]interface{}{
			"BodyText":    item.BodyText,
			"Title":       item.Title,
			"PublishDate": item.PublishDate,
		}).Do(context.Background())
		if err != nil {
			return err
		}
		fmt.Println(resp.Status, resp.Result)
		if resp.Status == 0 {
			fmt.Println("修改成功")
		} else {
			fmt.Println("EditData", resp.Status, resp.Result)
		}
		client.CloseIndex(indexName)
	} else {
		resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
		if err != nil {
			fmt.Println("新增失败:", err.Error())
			return err
		}
		if resp.Status == 0 && resp.Result == "created" {
			fmt.Println("新增成功")
			err = nil
		} else {
			fmt.Println("AddData", resp.Status, resp.Result)
		}
	}
	return
}

//新增和修改数据
func EsAddOrEditDataV4(indexName, docId string, item *ElasticTestArticleDetailV4) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client, err := NewClient()
	if err != nil {
		return
	}
	searchById, err := client.Get().Index(indexName).Id(docId).Do(context.Background())
	if err != nil && !strings.Contains(err.Error(), "404") {
		fmt.Println("Get Err" + err.Error())
		return
	}
	if searchById != nil && searchById.Found {
		resp, err := client.Update().Index(indexName).Id(docId).Doc(map[string]interface{}{
			"BodyText":    item.BodyText,
			"Title":       item.Title,
			"PublishDate": item.PublishDate,
			"IsSummary":   item.IsSummary,
			"IsReport":    item.IsReport,
		}).Do(context.Background())
		if err != nil {
			return err
		}
		fmt.Println(resp.Status, resp.Result)
		if resp.Status == 0 {
			fmt.Println("修改成功")
		} else {
			fmt.Println("EditData", resp.Status, resp.Result)
		}
	} else {
		resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
		if err != nil {
			fmt.Println("新增失败:", err.Error())
			return err
		}
		if resp.Status == 0 && resp.Result == "created" {
			fmt.Println("新增成功")
			err = nil
		} 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 := 5.0 * 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 = n - 5
	}
	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
}

func EsMatchFunctionScoreQuery(indexName, keyWord string, startSize, pageSize int) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV2(keyWord)
	fmt.Println(keyWordArr)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	fmt.Println("-------------------------------")
	fmt.Println(keyWordArr)

	searchMap := make(map[int]int)
	boolquery := elastic.NewBoolQuery()
	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)
	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	keyWordWeight := GetWeight(keyWordLen)

	fmt.Println(keyWordArr)
	fmt.Println(keyWordWeight)
	for k, v := range keyWordArr {
		if v != "" {
			weight := float64(keyWordWeight[k])
			titleMatchq := elastic.NewMatchQuery("Title", v).Analyzer("ik_smart")

			bodyMatchq := elastic.NewMatchQuery("BodyText", v).Analyzer("ik_smart")

			titleFunctionQuery := elastic.NewFunctionScoreQuery()
			titleFunctionQuery.Query(titleMatchq)
			titleFunctions := elastic.NewWeightFactorFunction(weight)
			titleFunctionQuery.AddScoreFunc(titleFunctions)
			titleFunctionQuery.BoostMode("replace")

			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery.Query(bodyMatchq)
			bodyFunctions := elastic.NewWeightFactorFunction(weight)
			bodyFunctionQuery.AddScoreFunc(bodyFunctions)
			bodyFunctionQuery.BoostMode("replace")

			matchArr = append(matchArr, titleFunctionQuery)
			matchArr = append(matchArr, bodyFunctionQuery)
		}
		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).From(startSize).Size(pageSize).Query(boolquery)
	searchByMatch, err := request.Do(context.Background())
	//searchJson, err := json.Marshal(searchByMatch)
	if searchByMatch != nil {
		if searchByMatch.Hits != nil {
			for _, v := range searchByMatch.Hits.Hits {
				articleJson, err := v.Source.MarshalJSON()
				if err != nil {
					return nil, 0, err
				}
				article := new(models.CygxArticle)
				err = json.Unmarshal(articleJson, &article)
				if err != nil {
					return nil, 0, 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
				}
			}
		}
	}
	total = searchByMatch.Hits.TotalHits.Value
	return
}

func EsMultiMatchFunctionScoreQuery(indexName, keyWord string, startSize, pageSize, userId int) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV3(keyWord)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	//artidArr := make([]elastic.Query, 0)
	//matchArr := make([]elastic.Query, 0)
	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	utils.FileLog.Info("SearchKeyWord:%s, userId:%s", keyWordArr, strconv.Itoa(userId))
	//keyWordWeight := GetWeight(keyWordLen)
	for _, v := range keyWordArr {
		if v != "" {
			matchArr := make([]elastic.Query, 0)
			boolquery := elastic.NewBoolQuery()
			//weight := float64(keyWordWeight[k])
			//multiMatch := elastic.NewMultiMatchQuery(v, "Title", "BodyText").Analyzer("ik_smart")
			//bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			//bodyFunctionQuery.Query(multiMatch)
			//bodyFunctions := elastic.NewWeightFactorFunction(weight)
			//bodyFunctionQuery.AddScoreFunc(bodyFunctions)
			//bodyFunctionQuery.BoostMode("replace")
			//matchArr = append(matchArr, bodyFunctionQuery)
			//weight := float64(keyWordWeight[k])
			multiMatch := elastic.NewMultiMatchQuery(v, "Title", "BodyText").Analyzer("ik_smart")
			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery.Query(multiMatch)
			//bodyFunctions := elastic.NewWeightFactorFunction(weight)
			//bodyFunctionQuery.AddScoreFunc(bodyFunctions)
			//bodyFunctionQuery.BoostMode("replace")
			matchArr = append(matchArr, bodyFunctionQuery)
			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).From(startSize).Size(pageSize).Query(boolquery)
			searchByMatch, err := request.Do(context.Background())
			if err != nil {
				return nil, 0, err
			}
			if searchByMatch != nil {
				if searchByMatch.Hits != nil {
					for _, v := range searchByMatch.Hits.Hits {
						var isAppend bool
						articleJson, err := v.Source.MarshalJSON()
						if err != nil {
							return nil, 0, err
						}
						article := new(models.CygxArticle)
						err = json.Unmarshal(articleJson, &article)
						if err != nil {
							return nil, 0, err
						}
						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])
							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
						for _, v_result := range result {
							if v_result.ArticleId == searchItem.ArticleId {
								isAppend = true
							}
						}
						if !isAppend {
							result = append(result, searchItem)
						}
					}
				}
				//total += searchByMatch.Hits.TotalHits.Value
			}
		}
		n++
	}
	total = int64(len(result))
	//fmt.Println(result)
	//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).From(startSize).Size(pageSize).Query(boolquery)
	//searchByMatch, err := request.Do(context.Background())
	//if searchByMatch != nil {
	//	if searchByMatch.Hits != nil {
	//		for _, v := range searchByMatch.Hits.Hits {
	//			articleJson, err := v.Source.MarshalJSON()
	//			if err != nil {
	//				return nil, 0, err
	//			}
	//			article := new(models.CygxArticle)
	//			err = json.Unmarshal(articleJson, &article)
	//			if err != nil {
	//				return nil, 0, err
	//			}
	//			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])
	//				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)
	//		}
	//	}
	//	total = searchByMatch.Hits.TotalHits.Value
	//}
	return
}

func EsMultiMatchFunctionScoreQueryFix(indexName, keyWord string, startSize, pageSize int) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV2(keyWord)

	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	boolquery := elastic.NewBoolQuery()
	matchArr := make([]elastic.Query, 0)

	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	fmt.Println(keyWordArr)

	keyWordWeight := GetWeight(keyWordLen)
	for k, v := range keyWordArr {
		if v != "" {
			weight := float64(keyWordWeight[k])
			multiMatch := elastic.NewMultiMatchQuery(v, "Title", "BodyText").Analyzer("ik_smart")
			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery.Query(multiMatch)
			bodyFunctions := elastic.NewWeightFactorFunction(weight)
			bodyFunctionQuery.AddScoreFunc(bodyFunctions)
			bodyFunctionQuery.BoostMode("replace")
			matchArr = append(matchArr, bodyFunctionQuery)
		}
		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).From(startSize).Size(pageSize).Query(boolquery)
	searchByMatch, err := request.Do(context.Background())
	if searchByMatch != nil {

		matchResult, _ := json.Marshal(searchByMatch)
		utils.FileLog.Info("%s", string(matchResult))

		if searchByMatch.Hits != nil {
			for _, v := range searchByMatch.Hits.Hits {
				articleJson, err := v.Source.MarshalJSON()
				utils.FileLog.Info("%s", string(articleJson))
				if err != nil {
					return nil, 0, err
				}
				article := new(models.CygxArticle)
				err = json.Unmarshal(articleJson, &article)
				if err != nil {
					return nil, 0, err
				}
				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])
					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)
			}
		}
		total = searchByMatch.Hits.TotalHits.Value
	}
	return
}

func GetWeight(length int) []int {
	steep := 10
	intArr := make([]int, 0)
	for i := 1; i <= length; i++ {
		if i == 1 {
			intArr = append(intArr, 1)
		} else {
			min := GetArrSum(intArr)
			maxVal := utils.GetRandInt(min, min+steep)
			intArr = append(intArr, maxVal)
		}
	}
	//数组排序
	sort.Slice(intArr, func(i, j int) bool {
		return intArr[i] > intArr[j]
	})
	return intArr
}

func GetArrSum(intArr []int) (sum int) {
	for _, val := range intArr {
		//累计求和
		sum += val
	}
	return
}

//func init() {
//	fmt.Println("start")
//	keyWord:="阿里巴巴"
//	keyWordArr, _ := GetIndustryMapNameSliceV2(keyWord)
//	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
//	fmt.Println(keyWordArr)
//	fmt.Println("end")
//}

func EsMultiMatchFunctionScoreQuerySort(indexName, keyWord string, startSize, pageSize, userId int, orderColumn string) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV3(keyWord)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	//artidArr := make([]elastic.Query, 0)
	//matchArr := make([]elastic.Query, 0)
	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	for _, v := range keyWordArr {
		fmt.Println(v)
	}

	// @Param   OrderColumn   query   int  true       "排序字段 ，Comprehensive综合 ，Matching匹配度 ，PublishDate 发布时间 "
	utils.FileLog.Info("SearchKeyWord:%s, userId:%s", keyWordArr, strconv.Itoa(userId))
	//keyWordWeight := GetWeight(keyWordLen)
	for _, v := range keyWordArr {
		if v != "" {
			matchArr := make([]elastic.Query, 0)
			boolquery := elastic.NewBoolQuery()
			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery2 := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery3 := elastic.NewFunctionScoreQuery()

			//multiMatch := elastic.NewMultiMatchQuery(v, "Title", "BodyText").Analyzer("ik_smart")
			multiMatch := elastic.NewMultiMatchQuery(v, "Title").Analyzer("ik_smart").Boost(100)
			bodyFunctionQuery.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery)

			multiMatch = elastic.NewMultiMatchQuery(v, "BodyText").Analyzer("ik_smart").Boost(1)
			bodyFunctionQuery2.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery2)

			//multiMatch = elastic.NewMultiMatchQuery(1, "IsSummary")
			bodyFunctionQuery3.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery3)

			boolquery.Should(matchArr...)

			//multiMatch = elastic.NewMultiMatchQuery(v, "BodyText").Analyzer("ik_smart")
			//bodyFunctionQuery.Query(multiMatch)
			//matchArr = append(matchArr, bodyFunctionQuery)
			//boolquery.Should(matchArr...)

			highlight := elastic.NewHighlight()
			highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
			highlight = highlight.Fields(elastic.NewHighlighterField("Title"), elastic.NewHighlighterField("BodyText"))
			request := client.Search(indexName).Highlight(highlight).Sort("PublishDate", false).From(0).Size(pageSize).Query(boolquery)
			if orderColumn == "Matching" {
				request = client.Search(indexName).Highlight(highlight).From(0).Size(pageSize).Query(boolquery)
			}
			searchByMatch, err := request.Do(context.Background())
			if err != nil {
				return nil, 0, err
			}
			if searchByMatch != nil {
				if searchByMatch.Hits != nil {
					for _, v := range searchByMatch.Hits.Hits {
						var isAppend bool
						articleJson, err := v.Source.MarshalJSON()
						if err != nil {
							return nil, 0, err
						}
						article := new(models.CygxArticle)
						err = json.Unmarshal(articleJson, &article)
						if err != nil {
							return nil, 0, err
						}
						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])
							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
						for _, v_result := range result {
							if v_result.ArticleId == searchItem.ArticleId {
								isAppend = true
							}
						}
						if !isAppend {
							result = append(result, searchItem)
						}
					}
				}
				//total += searchByMatch.Hits.TotalHits.Value
			}
		}
		n++
	}
	total = int64(len(result))
	return
}

func EsMultiMatchFunctionScoreQueryTimeSort(indexName, keyWord string, startSize, pageSize, userId int) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV2(keyWord)

	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	boolquery := elastic.NewBoolQuery()
	matchArr := make([]elastic.Query, 0)
	//matchArr2 := make([]elastic.Query, 0)

	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	fmt.Println(keyWordArr)
	utils.FileLog.Info("SearchKeyWord:%s, userId:%s", keyWordArr, strconv.Itoa(userId))
	for _, v := range keyWordArr {
		if v != "" {
			multiMatch := elastic.NewMultiMatchQuery(v, "Title", "BodyText")
			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery)
		}
		n++
	}
	boolquery.Should(matchArr...)

	//multiMatch2 := elastic.NewMultiMatchQuery(1, "IsSummary")
	//bodyFunctionQuery2 := elastic.NewFunctionScoreQuery()
	//bodyFunctionQuery2.Query(multiMatch2)
	//matchArr2 = append(matchArr2, bodyFunctionQuery2)
	//boolquery.Must(matchArr2...).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).Sort("PublishDate", false).Size(pageSize).Query(boolquery)
	searchByMatch, err := request.Do(context.Background())

	if searchByMatch != nil {
		matchResult, _ := json.Marshal(searchByMatch)
		utils.FileLog.Info("%s", string(matchResult))
		fmt.Println(len(searchByMatch.Hits.Hits))
		if searchByMatch.Hits != nil {
			for _, v := range searchByMatch.Hits.Hits {
				articleJson, err := v.Source.MarshalJSON()
				utils.FileLog.Info("%s", string(articleJson))
				if err != nil {
					return nil, 0, err
				}
				article := new(models.CygxArticle)
				err = json.Unmarshal(articleJson, &article)
				if err != nil {
					return nil, 0, err
				}
				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])
					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)
			}
		}
		total = searchByMatch.Hits.TotalHits.Value
	}
	return
}

func EsSearchReport(indexName, keyWord string, startSize, pageSize, userId int) (result []*models.SearchItem, total int64, err error) {
	client, err := NewClient()
	keyWordArr, err := GetIndustryMapNameSliceV3(keyWord)
	keyWordArr = RemoveDuplicatesAndEmpty(keyWordArr)
	n := 0
	keyWordLen := len(keyWordArr)
	if keyWordLen <= 0 {
		keyWordArr = append(keyWordArr, keyWord)
		keyWordLen = len(keyWordArr)
	}
	for _, v := range keyWordArr {
		fmt.Println(v)
	}

	utils.FileLog.Info("SearchKeyWord:%s, userId:%s", keyWordArr, strconv.Itoa(userId))
	for _, v := range keyWordArr {
		if v != "" {
			matchArr := make([]elastic.Query, 0)
			boolquery := elastic.NewBoolQuery()
			bodyFunctionQuery := elastic.NewFunctionScoreQuery()
			bodyFunctionQuery2 := elastic.NewFunctionScoreQuery()

			multiMatch := elastic.NewMultiMatchQuery(v, "Title").Analyzer("ik_smart")
			bodyFunctionQuery.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery)

			multiMatch = elastic.NewMultiMatchQuery(1, "IsReport")
			bodyFunctionQuery2.Query(multiMatch)
			matchArr = append(matchArr, bodyFunctionQuery2)
			boolquery.Must(matchArr...)

			highlight := elastic.NewHighlight()
			highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
			highlight = highlight.Fields(elastic.NewHighlighterField("Title"))
			request := client.Search(indexName).Highlight(highlight).Sort("PublishDate", false).From(0).Size(pageSize).Query(boolquery)

			searchByMatch, err := request.Do(context.Background())
			if err != nil {
				return nil, 0, err
			}
			if searchByMatch != nil {
				if searchByMatch.Hits != nil {
					for _, v := range searchByMatch.Hits.Hits {
						var isAppend bool
						articleJson, err := v.Source.MarshalJSON()
						if err != nil {
							return nil, 0, err
						}
						article := new(models.CygxArticle)
						err = json.Unmarshal(articleJson, &article)
						if err != nil {
							return nil, 0, err
						}
						searchItem := new(models.SearchItem)
						searchItem.ArticleId, _ = strconv.Atoi(v.Id)

						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
						for _, v_result := range result {
							if v_result.ArticleId == searchItem.ArticleId {
								isAppend = true
							}
						}
						if !isAppend {
							result = append(result, searchItem)
						}
					}
				}
			}
		}
		n++
	}
	total = int64(len(result))
	return
}