eta_api/services/elastic/elastic.go

package elastic

import (
	"context"
	"encoding/json"
	"errors"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/excel"
	dataSourceModel "eta/eta_api/models/data_source"
	"eta/eta_api/utils"
	"fmt"
	"io"
	"strconv"
	"strings"

	"github.com/olivere/elastic/v7"
)

// indexName:索引名称
// mappingJson:表结构
func EsCreateIndex(indexName, mappingJson string) (err error) {
	client := utils.EsClient

	//定义表结构
	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 EsDeleteData(indexName, docId string) (err error) {
	client := utils.EsClient

	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
	fmt.Println(resp)
	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 := utils.EsClient
	result, err := client.PutMapping().Index(indexName).BodyString(mappingJson).Do(context.Background())
	fmt.Println(err)
	fmt.Println(result)
	return
}

// EsAddOrEditEdbInfoData 新增/修改es中的指标数据
func EsAddOrEditEdbInfoData(indexName, docId string, item *data_manage.EdbInfoList) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Refresh("true").Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// SearchEdbInfoData 查询es中的指标数据
func SearchEdbInfoData(indexName, keywordStr string, from, size, filterSource, source int, edbInfoType int8, frequency string, noPermissionEdbInfoIdList []int) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	//var source map[string]interface{}
	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"match_all": map[string]interface{}{},
	//	},
	//}
	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"bool": map[string]interface{}{
	//			"must": map[string]interface{}{
	//				"query_string": map[string]interface{}{
	//					"query":  keywordStr,
	//					"fields": []string{"EdbCode", "EdbName"},
	//				},
	//			},
	//		},
	//	},
	//}

	switch filterSource {
	case 2:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"Frequency.keyword": "月度",
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Frequency.keyword": "月度",
					//"Frequency.keyword": "月度",
				},
			},
		}
	case 3:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"must_not": []interface{}{
		//				map[string]interface{}{
		//					"match": map[string]interface{}{
		//						"Frequency.keyword": "日度",
		//					},
		//				}},
		//		},
		//	},
		//}

		////注释掉，所有频度都可以变频 2022-08-31 14:31:28
		//mustNotMap = []interface{}{
		//	map[string]interface{}{
		//		"match": map[string]interface{}{
		//			"Frequency.keyword": "日度",
		//			//"Frequency.keyword": "月度",
		//		},
		//	},
		//}
	case 4:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"EdbType": 1,
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"EdbType": 1,
				},
			},
		}
	case 5:
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Source": 6,
				},
			},
		}
	case 6:
		mustNotMap = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"Frequency.keyword": "年度",
				},
			},
		}
	}

	//指标来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
				//"Frequency.keyword": "月度",
			},
		})
	}

	if frequency != "" {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Frequency.keyword": frequency,
				//"Frequency.keyword": "月度",
			},
		})
	}

	// noPermissionEdbInfoIdList 无权限指标id
	if len(noPermissionEdbInfoIdList) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"EdbInfoId": noPermissionEdbInfoIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}

	// 指标类型：普通指标、预测指标（小于0 代表不区分指标是普通还是预测）
	if edbInfoType >= 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"EdbInfoType": edbInfoType,
			},
		})
	}

	//普通指标
	//mustMap = append(mustMap, map[string]interface{}{
	//	"term": map[string]interface{}{
	//		"EdbInfoType": 0,
	//		//"Frequency.keyword": "月度",
	//	},
	//})

	//关键字匹配
	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbCode": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbNameEn": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `EdbName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `EdbNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	//mustMap = append(mustMap, map[string]interface{}{
	//	"bool": shouldMap,
	//})

	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
}

// SearchEdbInfoData 查询es中的指标数据
func SearchEdbInfoDataByfrequency(indexName, keywordStr string, from, size int, edbInfoType int8, frequency []string, noPermissionEdbInfoIdList []int) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	if len(frequency) != 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"Frequency.keyword": frequency,
				//"Frequency.keyword": "月度",
			},
		})
	}

	// noPermissionEdbInfoIdList 无权限指标id
	if len(noPermissionEdbInfoIdList) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"EdbInfoId": noPermissionEdbInfoIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}

	// 指标类型：普通指标、预测指标（小于0 代表不区分指标是普通还是预测）
	if edbInfoType >= 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"EdbInfoType": edbInfoType,
			},
		})
	}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `EdbName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `EdbNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
}

func SearchEdbInfoDataBak(indexName, keywordStr string, from, size, filterSource, source int, frequency string) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	//queryString := elastic.NewQueryStringQuery(keywordStr)
	//boolQueryJson, err := json.Marshal(queryString)
	//if err != nil {
	//	fmt.Println("boolQueryJson err:", err)
	//} else {
	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
	//}

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	//query := elastic.RawStringQuery(`{"match_all":{}}`)

	//var source map[string]interface{}
	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"match_all": map[string]interface{}{},
	//	},
	//}
	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"bool": map[string]interface{}{
	//			"must": map[string]interface{}{
	//				"query_string": map[string]interface{}{
	//					"query":  keywordStr,
	//					"fields": []string{"EdbCode", "EdbName"},
	//				},
	//			},
	//		},
	//	},
	//}

	switch filterSource {
	case 2:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"Frequency.keyword": "月度",
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Frequency.keyword": "月度",
					//"Frequency.keyword": "月度",
				},
			},
		}
	case 3:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"must_not": []interface{}{
		//				map[string]interface{}{
		//					"match": map[string]interface{}{
		//						"Frequency.keyword": "日度",
		//					},
		//				}},
		//		},
		//	},
		//}

		////注释掉，所有频度都可以变频 2022-08-31 14:31:28
		//mustNotMap = []interface{}{
		//	map[string]interface{}{
		//		"match": map[string]interface{}{
		//			"Frequency.keyword": "日度",
		//			//"Frequency.keyword": "月度",
		//		},
		//	},
		//}
	case 4:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"EdbType": 1,
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"EdbType": 1,
				},
			},
		}
	case 5:
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Source": 6,
				},
			},
		}
	case 6:
		mustNotMap = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"Frequency.keyword": "年度",
				},
			},
		}
	}

	//指标来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
				//"Frequency.keyword": "月度",
			},
		})
	}

	if frequency != "" {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Frequency.keyword": frequency,
				//"Frequency.keyword": "月度",
			},
		})
	}

	//普通指标
	//mustMap = append(mustMap, map[string]interface{}{
	//	"term": map[string]interface{}{
	//		"EdbInfoType": 0,
	//		//"Frequency.keyword": "月度",
	//	},
	//})

	//关键字匹配
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbName": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},

			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": map[string]interface{}{
						"query":    keywordStr,
						"operator": "and",
					},
					//"Frequency.keyword": "月度",
				},
			},

			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbName": map[string]interface{}{
						"query":    keywordStr,
						"operator": "and",
					},
					//"Frequency.keyword": "月度",
				},
			},
		},
	}
	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	total, err = requestTotalHits.Do(context.Background())
	if err != nil {
		return
	}

	queryMap["from"] = from
	queryMap["size"] = size
	jsonBytes, _ := json.Marshal(queryMap)
	fmt.Println(string(jsonBytes))

	//queryStr := fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}}}}}`, keywordStr)
	//switch filterSource {
	//case 2:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"filter":{"term":{"Frequency.keyword":"%s"}}}}}`, keywordStr, "月度")
	//case 3:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"Frequency.keyword":"%s"}}]}}}`, keywordStr, "日度")
	//case 4:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"EdbType":1}}]}}}`, keywordStr)
	//}
	//queryString := elastic.RawStringQuery(queryStr)
	//fmt.Println("queryString：", queryString)

	//queryString := elastic.NewMatchQuery("EdbCode", keywordStr)
	//request := client.Search(indexName).Highlight(highlight).From(from).Size(size).Query(queryString)

	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request

	//requestJson, err := json.Marshal(request)
	//if err != nil {
	//	fmt.Println("requestJson err:", err)
	//}
	//fmt.Println("requestJson ", string(requestJson))
	searchMap := make(map[string]string)

	searchResp, err := request.Do(context.Background())
	if err != nil {
		return
	}
	fmt.Println(searchResp)
	fmt.Println(searchResp.Status)
	if searchResp.Status != 0 {
		return
	}
	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			if _, ok := searchMap[v.Id]; !ok {
				itemJson, tmpErr := v.Source.MarshalJSON()
				if tmpErr != nil {
					err = tmpErr
					fmt.Println("movieJson err:", err)
					return
				}
				edbInfoItem := new(data_manage.EdbInfoList)
				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
				if tmpErr != nil {
					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
					err = tmpErr
					return
				}
				if len(v.Highlight["EdbCode"]) > 0 {
					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
				}
				if len(v.Highlight["EdbName"]) > 0 {
					edbInfoItem.EdbCode = v.Highlight["EdbName"][0]
				}
				list = append(list, edbInfoItem)
				searchMap[v.Id] = v.Id
			}
		}
	}

	//for _, v := range result {
	//	fmt.Println(v)
	//}
	return
}

// SearchAddPredictEdbInfoData 查询允许添加预测指标的数据
func SearchAddPredictEdbInfoData(indexName, keywordStr string, noPermissionEdbInfoIdList []int, from, size, sysUserId int) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	mustNotMap = []interface{}{
		//map[string]interface{}{
		//	"terms": map[string]interface{}{
		//		"Frequency.keyword": []string{"日度", "周度", "月度"},
		//	},
		//	//"match": map[string]interface{}{
		//	//	"Frequency": []string{"日度", "周度", "月度"},
		//	//	//"Frequency.keyword": []string{"日度", "周度", "月度"},
		//	//},
		//},
	}

	// 指标类型：普通指标、预算指标
	mustMap = append(mustMap, map[string]interface{}{
		"term": map[string]interface{}{
			"EdbInfoType": 0,
		},
	})
	mustMap = append(mustMap, map[string]interface{}{
		"terms": map[string]interface{}{
			"Frequency.keyword": []string{"日度", "周度", "月度"},
		},
	})

	// 只看我的
	if sysUserId > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"SysUserId": sysUserId,
			},
		})
	}

	//关键字匹配
	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbCode": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbNameEn": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `EdbName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `EdbNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	// noPermissionEdbInfoIdList 无权限指标id
	if len(noPermissionEdbInfoIdList) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"EdbInfoId": noPermissionEdbInfoIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}
	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
}

// searchEdbInfoData 查询es中的指标数据
func searchEdbInfoData(indexName string, mustMap, mustNotMap []interface{}, shouldMap map[string]interface{}, from, size int) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	//queryString := elastic.NewQueryStringQuery(keywordStr)
	//boolQueryJson, err := json.Marshal(queryString)
	//if err != nil {
	//	fmt.Println("boolQueryJson err:", err)
	//} else {
	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
	//}

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	//query := elastic.RawStringQuery(`{"match_all":{}}`)

	//关键字匹配
	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	total, err = requestTotalHits.Do(context.Background())
	if err != nil {
		return
	}

	queryMap["from"] = from
	queryMap["size"] = size
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			"EdbName": map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}

	jsonBytes, _ := json.Marshal(queryMap)
	fmt.Println(string(jsonBytes))

	//queryStr := fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}}}}}`, keywordStr)
	//switch filterSource {
	//case 2:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"filter":{"term":{"Frequency.keyword":"%s"}}}}}`, keywordStr, "月度")
	//case 3:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"Frequency.keyword":"%s"}}]}}}`, keywordStr, "日度")
	//case 4:
	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"EdbType":1}}]}}}`, keywordStr)
	//}
	//queryString := elastic.RawStringQuery(queryStr)
	//fmt.Println("queryString：", queryString)

	//queryString := elastic.NewMatchQuery("EdbCode", keywordStr)
	//request := client.Search(indexName).Highlight(highlight).From(from).Size(size).Query(queryString)

	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request

	//requestJson, err := json.Marshal(request)
	//if err != nil {
	//	fmt.Println("requestJson err:", err)
	//}
	//fmt.Println("requestJson ", string(requestJson))
	searchMap := make(map[string]string)

	searchResp, err := request.Do(context.Background())
	if err != nil {
		return
	}
	fmt.Println(searchResp)
	fmt.Println(searchResp.Status)
	if searchResp.Status != 0 {
		return
	}
	//total = searchResp.TotalHits()
	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			if _, ok := searchMap[v.Id]; !ok {
				itemJson, tmpErr := v.Source.MarshalJSON()
				if tmpErr != nil {
					err = tmpErr
					fmt.Println("movieJson err:", err)
					return
				}
				edbInfoItem := new(data_manage.EdbInfoList)
				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
				if tmpErr != nil {
					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
					err = tmpErr
					return
				}
				if len(v.Highlight["EdbCode"]) > 0 {
					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
				}
				if len(v.Highlight["EdbName"]) > 0 {
					// 搜索结果高亮用新字段，原EdbName直接高亮展示上会有点影响
					edbInfoItem.SearchText = v.Highlight["EdbName"][0]
					//edbInfoItem.EdbName = v.Highlight["EdbName"][0]
				} else {
					edbInfoItem.SearchText = edbInfoItem.EdbName
				}
				list = append(list, edbInfoItem)
				searchMap[v.Id] = v.Id
			}
		}
	}

	return
}

// EsDeleteEdbInfoData 删除es中的指标数据
func EsDeleteEdbInfoData(indexName, docId string) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Delete().Index(indexName).Id(docId).Refresh(`true`).Do(context.Background())
	fmt.Println(resp)
	if err != nil {
		return
	}
	if resp.Status == 0 {
		fmt.Println("删除成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// EsAddOrEditReport 新增编辑es报告
func EsAddOrEditReport(indexName, docId string, item *models.ElasticReportDetail) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditReport Err:", err.Error())
		}
	}()
	client := utils.EsClient

	// docId为报告ID+章节ID
	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{}{
			"ReportId":           item.ReportId,
			"ReportChapterId":    item.ReportChapterId,
			"Title":              item.Title,
			"Abstract":           item.Abstract,
			"BodyContent":        item.BodyContent,
			"PublishTime":        item.PublishTime,
			"PublishState":       item.PublishState,
			"Author":             item.Author,
			"ClassifyIdFirst":    item.ClassifyIdFirst,
			"ClassifyNameFirst":  item.ClassifyNameFirst,
			"ClassifyIdSecond":   item.ClassifyIdSecond,
			"ClassifyNameSecond": item.ClassifyNameSecond,
			"Categories":         item.Categories,
			"StageStr":           item.StageStr,
		}).Do(context.Background())
		if err != nil {
			return err
		}
		//fmt.Println(resp.Status, resp.Result)
		if resp.Status == 0 {
			fmt.Println("修改成功" + docId)
			err = nil
		} 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("新增成功" + docId)
			return nil
		} else {
			fmt.Println("AddData", resp.Status, resp.Result)
		}
	}
	return
}

// AnalyzeResp 分词接口返回结构体
type AnalyzeResp struct {
	Tokens []struct {
		EndOffset   int64  `json:"end_offset"`
		Position    int64  `json:"position"`
		StartOffset int64  `json:"start_offset"`
		Token       string `json:"token"`
		Type        string `json:"type"`
	} `json:"tokens"`
}

// Analyze 根据输入的文字获取分词后的文字
func Analyze(content string) (contentList []string, err error) {
	defer func() {
		if err != nil {
			fmt.Println("Analyze Err:", err.Error())
		}
	}()
	client := utils.EsClient

	queryMap := map[string]string{
		"text":     content,
		"analyzer": "ik_max_word",
	}
	res, err := client.PerformRequest(
		context.Background(),
		elastic.PerformRequestOptions{
			Method: "GET",
			Path:   "/_analyze",
			Body:   queryMap,
			Stream: false,
		},
	)
	if res.StatusCode == 200 {
		var analyzeResp AnalyzeResp
		tmpErr := json.Unmarshal(res.Body, &analyzeResp)
		if tmpErr != nil {
			err = errors.New("返回数据转结构体失败：" + tmpErr.Error())
			return
		}
		for _, v := range analyzeResp.Tokens {
			contentList = append(contentList, v.Token)
		}
	} else {
		err = errors.New("分词失败,返回code异常：" + strconv.Itoa(res.StatusCode))
	}
	return
}

// EsAddOrEditChartInfoData 新增/修改es中的图表数据
func EsAddOrEditChartInfoData(indexName, docId string, item *data_manage.ChartInfo) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Refresh("true").Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// EsDeleteDataV2 删除es中的数据
func EsDeleteDataV2(indexName, docId string) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Delete().Index(indexName).Id(docId).Refresh("true").Do(context.Background())
	fmt.Println(resp)
	if err != nil {
		return
	}
	if resp.Status == 0 {
		fmt.Println("删除成功")
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// SearchChartInfoData 查询es中的图表数据
func SearchChartInfoData(indexName, keywordStr string, showSysId int, sourceList []int, noPermissionChartIdList []int, from, size int) (list []*data_manage.ChartInfoMore, total int64, err error) {
	list = make([]*data_manage.ChartInfoMore, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	//queryString := elastic.NewQueryStringQuery(keywordStr)
	//boolQueryJson, err := json.Marshal(queryString)
	//if err != nil {
	//	fmt.Println("boolQueryJson err:", err)
	//} else {
	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
	//}

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//指标来源
	if showSysId > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SysUserId": showSysId,
				//"Frequency.keyword": "月度",
			},
		})
	}
	mustMap = append(mustMap, map[string]interface{}{
		"terms": map[string]interface{}{
			"Source": sourceList,
		},
	})

	//关键字匹配
	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `ChartName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `ChartNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: map[string]interface{}{
						"query":    keywordStr,
						"operator": "and",
					},
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	// noPermissionEdbInfoIdList 无权限指标id
	if len(noPermissionChartIdList) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"ChartInfoId": noPermissionChartIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}

	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	total, err = requestTotalHits.Do(context.Background())
	if err != nil {
		return
	}

	// 分页查询
	queryMap["from"] = from
	queryMap["size"] = size
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			keywordNameKey: map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}

	jsonBytes, _ := json.Marshal(queryMap)
	fmt.Println(string(jsonBytes))

	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request

	//requestJson, err := json.Marshal(request)
	//if err != nil {
	//	fmt.Println("requestJson err:", err)
	//}
	//fmt.Println("requestJson ", string(requestJson))
	searchMap := make(map[string]string)

	searchResp, err := request.Do(context.Background())
	if err != nil {
		return
	}
	fmt.Println(searchResp)
	fmt.Println(searchResp.Status)
	if searchResp.Status != 0 {
		return
	}

	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			if _, ok := searchMap[v.Id]; !ok {
				itemJson, tmpErr := v.Source.MarshalJSON()
				if tmpErr != nil {
					err = tmpErr
					fmt.Println("movieJson err:", err)
					return
				}
				chartInfoItem := new(data_manage.ChartInfoMore)
				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
				if err != nil {
					fmt.Println("json.Unmarshal chartInfoJson err:", err)
					err = tmpErr
					return
				}
				if len(v.Highlight[keywordNameKey]) > 0 {
					//chartInfoItem.ChartName = v.Highlight["ChartName"][0]
					chartInfoItem.SearchText = v.Highlight[keywordNameKey][0]
				} else {
					chartInfoItem.SearchText = chartInfoItem.ChartName
				}
				list = append(list, chartInfoItem)
				searchMap[v.Id] = v.Id
			}
		}
	}

	//for _, v := range result {
	//	fmt.Println(v)
	//}
	return
}

// EsAddOrEditDataInterface 新增/修改es中的数据
func EsAddOrEditDataInterface(indexName, docId string, item interface{}) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Refresh("true").Do(context.Background())
	if err != nil {
		fmt.Println("新增失败:", err.Error())
		return err
	}
	fmt.Println(resp)
	if resp.Status == 0 {
		fmt.Println("新增成功", resp.Result)
		err = nil
	} else {
		fmt.Println("AddData", resp.Status, resp.Result)
	}
	return
}

// SearchMyChartInfoData 查询es中的我的图表数据
func SearchMyChartInfoData(indexName, keywordStr string, adminId int, noPermissionChartIdList []int, from, size int) (list []*data_manage.MyChartList, total int64, err error) {
	list = make([]*data_manage.MyChartList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()
	client := utils.EsClient

	//queryString := elastic.NewQueryStringQuery(keywordStr)
	//boolQueryJson, err := json.Marshal(queryString)
	//if err != nil {
	//	fmt.Println("boolQueryJson err:", err)
	//} else {
	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
	//}

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//指标来源
	if adminId > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"AdminId": adminId,
				//"Frequency.keyword": "月度",
			},
		})
	}

	//关键字匹配

	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartName": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"ChartNameEn": map[string]interface{}{
	//					"query":    keywordStr,
	//					"operator": "and",
	//				},
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `ChartName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `ChartNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: map[string]interface{}{
						"query":    keywordStr,
						"operator": "and",
					},
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	// noPermissionEdbInfoIdList 无权限指标id
	if len(noPermissionChartIdList) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"ChartInfoId": noPermissionChartIdList,
				//"Frequency.keyword": "月度",
			},
		})
	}

	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	total, err = requestTotalHits.Do(context.Background())
	if err != nil {
		return
	}

	// 分页查询
	queryMap["from"] = from
	queryMap["size"] = size
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			keywordNameKey: map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}

	jsonBytes, _ := json.Marshal(queryMap)
	fmt.Println(string(jsonBytes))

	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request

	//requestJson, err := json.Marshal(request)
	//if err != nil {
	//	fmt.Println("requestJson err:", err)
	//}
	//fmt.Println("requestJson ", string(requestJson))
	searchMap := make(map[string]string)

	searchResp, err := request.Do(context.Background())
	if err != nil {
		return
	}
	fmt.Println(searchResp)
	fmt.Println(searchResp.Status)
	if searchResp.Status != 0 {
		return
	}

	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			if _, ok := searchMap[v.Id]; !ok {
				itemJson, tmpErr := v.Source.MarshalJSON()
				if tmpErr != nil {
					err = tmpErr
					fmt.Println("movieJson err:", err)
					return
				}
				chartInfoItem := new(data_manage.MyChartList)
				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
				if err != nil {
					fmt.Println("json.Unmarshal chartInfoJson err:", err)
					err = tmpErr
					return
				}
				if len(v.Highlight[keywordNameKey]) > 0 {
					//chartInfoItem.ChartName = v.Highlight["ChartName"][0]
					chartInfoItem.SearchText = v.Highlight[keywordNameKey][0]
				} else {
					chartInfoItem.SearchText = chartInfoItem.ChartName
				}
				list = append(list, chartInfoItem)
				searchMap[v.Id] = v.Id
			}
		}
	}

	//for _, v := range result {
	//	fmt.Println(v)
	//}
	return
}

// SearchEdbInfoDataByAdminId 查询es中的指标数据
func SearchEdbInfoDataByAdminId(indexName, keywordStr string, from, size, filterSource, source int, edbInfoType uint8, frequency string, adminId int) (total int64, list []*data_manage.EdbInfoList, err error) {
	list = make([]*data_manage.EdbInfoList, 0)
	defer func() {
		if err != nil {
			fmt.Println("EsAddOrEditData Err:", err.Error())
		}
	}()

	highlight := elastic.NewHighlight()
	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")

	//var source map[string]interface{}
	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"match_all": map[string]interface{}{},
	//	},
	//}
	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)

	//source := map[string]interface{}{
	//	"query": map[string]interface{}{
	//		"bool": map[string]interface{}{
	//			"must": map[string]interface{}{
	//				"query_string": map[string]interface{}{
	//					"query":  keywordStr,
	//					"fields": []string{"EdbCode", "EdbName"},
	//				},
	//			},
	//		},
	//	},
	//}

	switch filterSource {
	case 2:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"Frequency.keyword": "月度",
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Frequency.keyword": "月度",
					//"Frequency.keyword": "月度",
				},
			},
		}
	case 3:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"must_not": []interface{}{
		//				map[string]interface{}{
		//					"match": map[string]interface{}{
		//						"Frequency.keyword": "日度",
		//					},
		//				}},
		//		},
		//	},
		//}

		////注释掉，所有频度都可以变频 2022-08-31 14:31:28
		//mustNotMap = []interface{}{
		//	map[string]interface{}{
		//		"match": map[string]interface{}{
		//			"Frequency.keyword": "日度",
		//			//"Frequency.keyword": "月度",
		//		},
		//	},
		//}
	case 4:
		//source = map[string]interface{}{
		//	"query": map[string]interface{}{
		//		"bool": map[string]interface{}{
		//			"must": map[string]interface{}{
		//				"query_string": map[string]interface{}{
		//					"query": keywordStr,
		//				},
		//			},
		//			"filter": []interface{}{
		//				map[string]interface{}{
		//					"term": map[string]interface{}{
		//						"EdbType": 1,
		//					},
		//				}},
		//		},
		//	},
		//}
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"EdbType": 1,
				},
			},
		}
	case 5:
		mustMap = []interface{}{
			map[string]interface{}{
				"term": map[string]interface{}{
					"Source": 6,
				},
			},
		}
	case 6:
		mustNotMap = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"Frequency.keyword": "年度",
				},
			},
		}
	}

	//指标来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
				//"Frequency.keyword": "月度",
			},
		})
	}

	if frequency != "" {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Frequency.keyword": frequency,
				//"Frequency.keyword": "月度",
			},
		})
	}

	// 指标类型：普通指标、预算指标
	mustMap = append(mustMap, map[string]interface{}{
		"term": map[string]interface{}{
			"EdbInfoType": edbInfoType,
		},
	})

	//普通指标
	//mustMap = append(mustMap, map[string]interface{}{
	//	"term": map[string]interface{}{
	//		"EdbInfoType": 0,
	//		//"Frequency.keyword": "月度",
	//	},
	//})

	//关键字匹配
	//shouldMap := map[string]interface{}{
	//	"should": []interface{}{
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbCode": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//		map[string]interface{}{
	//			"match": map[string]interface{}{
	//				"EdbName": keywordStr,
	//				//"Frequency.keyword": "月度",
	//			},
	//		},
	//	},
	//}

	// 默认使用中文名字字段去匹配
	keywordNameKey := `EdbName`
	// 如果没有中文，则使用英文名称字段去匹配
	if !utils.ContainsChinese(keywordStr) {
		keywordNameKey = `EdbNameEn`
	}
	shouldMap := map[string]interface{}{
		"should": []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"EdbCode": keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					keywordNameKey: keywordStr,
					//"Frequency.keyword": "月度",
				},
			},
		},
	}

	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})

	//创建人
	if adminId > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SysUserId": adminId,
			},
		})
	}

	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
}

// EsAddOrEditExcelInfoData 新增/修改es中的表格数据
func EsAddOrEditExcelInfoData(indexName, docId string, item *excel.ExcelInfo) (err error) {
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("EsAddOrEditExcelInfoData err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	resp, e := client.Index().Index(indexName).Id(docId).BodyJson(item).Refresh("true").Do(context.Background())
	if e != nil {
		err = fmt.Errorf("resp err, %v", e)
		return
	}
	if resp.Status != 0 {
		err = fmt.Errorf("result err, status: %d, result: %s", resp.Status, resp.Result)
		return
	}
	err = nil
	fmt.Println("excel write to es success", resp.Result)
	return
}

// SearchExcelInfoData 查询es中的表格
func SearchExcelInfoData(indexName, keyword string, source, adminId int, queryIds, exceptIds []int, from, size int) (total int64, list []*excel.SearchExcelInfo, err error) {
	list = make([]*excel.SearchExcelInfo, 0)
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("SearchExcelInfoData err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)
	mustMap = append(mustMap, map[string]interface{}{
		"term": map[string]interface{}{
			"IsDelete": 0,
		},
	})

	// 表格名称
	shouldMap := make(map[string]interface{}, 0)
	if keyword != "" {
		shouldMap["should"] = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"ExcelName": keyword,
				},
			},
		}

		//shouldMap := map[string]interface{}{
		//	"should": []interface{}{
		//		map[string]interface{}{
		//			"match": map[string]interface{}{
		//				"ExcelName": keyword,
		//			},
		//		},
		//	},
		//}
	}

	// 表格来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
			},
		})
	}

	// 创建人
	if adminId > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SysUserId": adminId,
			},
		})
	}

	// 查询和排除的表格IDs
	if len(queryIds) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"ExcelInfoId": queryIds,
			},
		})
	}
	if len(exceptIds) > 0 {
		mustNotMap = append(mustNotMap, map[string]interface{}{
			"terms": map[string]interface{}{
				"ExcelInfoId": exceptIds,
			},
		})
	}

	// 关键字匹配
	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})
	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//jsonBytes, _ := json.Marshal(queryMap)
	//fmt.Println(string(jsonBytes))

	// 根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	t, e := requestTotalHits.Do(context.Background())
	if e != nil {
		err = fmt.Errorf("total hits err: %v", e)
		return
	}
	total = t

	// 表格名称高亮，分页
	highlightKeyName := "ExcelName"
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			highlightKeyName: map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}
	queryMap["from"] = from
	queryMap["size"] = size

	//jsonBytes, _ := json.Marshal(queryMap)
	//fmt.Println(string(jsonBytes))

	request := client.Search(indexName).Source(queryMap)
	searchResp, e := request.Do(context.Background())
	if e != nil {
		err = fmt.Errorf("search do err: %v", e)
		return
	}
	//fmt.Println(searchResp)
	if searchResp.Status != 0 {
		return
	}
	if searchResp.Hits == nil {
		return
	}
	searchMap := make(map[string]string)
	for _, v := range searchResp.Hits.Hits {
		if _, ok := searchMap[v.Id]; ok {
			continue
		}
		j, e := v.Source.MarshalJSON()
		if e != nil {
			err = fmt.Errorf("hits json err: %v", e)
			return
		}
		item := new(excel.SearchExcelInfo)
		if e = json.Unmarshal(j, &item); e != nil {
			err = fmt.Errorf("hits json unmarshal err: %v", e)
			return
		}
		if len(v.Highlight[highlightKeyName]) > 0 {
			item.SearchText = v.Highlight[highlightKeyName][0]
		} else {
			item.SearchText = item.ExcelName
		}
		list = append(list, item)
		searchMap[v.Id] = v.Id
	}
	return
}

// EsAddOrEditDataSourceIndex 新增/修改es中的数据源指标
func EsAddOrEditDataSourceIndex(indexName, docId string, item *dataSourceModel.SearchDataSource) (err error) {
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("EsAddOrEditDataSourceIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	resp, e := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
	if e != nil {
		err = fmt.Errorf("resp err, %v", e)
		return
	}
	if resp.Status != 0 {
		err = fmt.Errorf("result err, status: %d, result: %s", resp.Status, resp.Result)
		return
	}
	err = nil
	fmt.Println("data source write to es success", resp.Result)
	return
}

// SearchDataSourceIndex 查询es中的数据源
func SearchDataSourceIndex(indexName, keyword string, source, subSource int, classifyIds, adminIds []int, frequency []string, from, size int) (total int64, list []*dataSourceModel.SearchDataSourceItem, err error) {
	list = make([]*dataSourceModel.SearchDataSourceItem, 0)
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("SearchDataSourceIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)
	mustMap = append(mustMap, map[string]interface{}{
		"term": map[string]interface{}{
			"IsDeleted": 0,
		},
	})

	// 指标编码/名称
	shouldMap := make(map[string]interface{}, 0)
	if keyword != "" {
		shouldMap["should"] = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"IndexCode": map[string]interface{}{
						"query":  keyword,
						"operator": "and",
					},
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					"IndexName": map[string]interface{}{
						"query":    keyword,
						"operator": "and",
					},
				},
			},
			map[string]interface{}{
				"match_phrase": map[string]interface{}{
					"IndexCode": map[string]interface{}{
						"query":  keyword,
						"boost":  5,
					},
				},
			},
			map[string]interface{}{
				"match_phrase": map[string]interface{}{
					"IndexName": map[string]interface{}{
						"query":  keyword,
						"boost":  5,
					},
				},
			},
		}
		//queryFields := []string{"IndexName.keyword", "IndexName.ik", "IndexName.ngram", "IndexCode.keyword", "IndexCode.ngram"}
		//mustMap = append(mustMap, map[string]interface{}{
		//	"multi_match": map[string]interface{}{
		//		"query":  keyword,
		//		"fields": queryFields,
		//	},
		//})
	}

	// 来源/子来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
			},
		})
	}
	if subSource > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SubSource": subSource,
			},
		})
	}

	// 分类
	if len(classifyIds) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"ClassifyId": classifyIds,
			},
		})
	}

	// 创建人
	if len(adminIds) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SysUserId": adminIds,
			},
		})
	}

	// 频度
	if len(frequency) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Frequency": frequency,
			},
		})
	}

	// 关键字匹配
	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})
	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
				//"should":   shouldMap,
			},
		},
	}

	//tj, _ := json.Marshal(queryMap)
	//utils.FileLog.Info(string(tj))

	// 根据条件数量统计
	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
	t, e := requestTotalHits.Do(context.Background())
	if e != nil {
		err = fmt.Errorf("total hits err: %v", e)
		return
	}
	total = t

	// 表格名称高亮，分页
	highlightKeyName := "IndexName"
	//highlightIk := "IndexName.ik"
	//highlightKeyword := "IndexName.keyword"
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			highlightKeyName: map[string]interface{}{},
			//highlightIk:      map[string]interface{}{},
			//highlightKeyword: map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}
	queryMap["from"] = from
	queryMap["size"] = size

	qj, _ := json.Marshal(queryMap)
	utils.FileLog.Info(string(qj))

	request := client.Search(indexName).Source(queryMap)
	searchResp, e := request.Do(context.Background())
	if e != nil {
		err = fmt.Errorf("search do err: %v", e)
		return
	}

	rj, _ := json.Marshal(searchResp)
	utils.FileLog.Info(string(rj))

	if searchResp.Status != 0 {
		return
	}
	if searchResp.Hits == nil {
		return
	}
	searchMap := make(map[string]string)
	for _, v := range searchResp.Hits.Hits {
		if _, ok := searchMap[v.Id]; ok {
			continue
		}
		j, e := v.Source.MarshalJSON()
		if e != nil {
			err = fmt.Errorf("hits json err: %v", e)
			return
		}
		item := new(dataSourceModel.SearchDataSourceItem)
		if e = json.Unmarshal(j, &item); e != nil {
			err = fmt.Errorf("hits json unmarshal err: %v", e)
			return
		}
		if len(v.Highlight[highlightKeyName]) > 0 {
			item.SearchText = v.Highlight[highlightKeyName][0]
		}

		// 优先取keyword的高亮，其次是ik分词之后的高亮
		//if len(v.Highlight) > 0 {
		//	if len(v.Highlight[highlightKeyword]) > 0 {
		//		item.SearchText = v.Highlight[highlightKeyword][0]
		//	}
		//	if len(v.Highlight[highlightKeyword]) == 0 && len(v.Highlight[highlightIk]) > 0 {
		//		item.SearchText = v.Highlight[highlightIk][0]
		//	}
		//}
		if item.SearchText == "" {
			item.SearchText = item.IndexName
		}
		list = append(list, item)
		searchMap[v.Id] = v.Id
	}
	return
}

// CreateEsIndex 创建ES索引
func CreateEsIndex(indexName, jsonMapping string) (exists bool, err error) {
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("CreateEsIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	// 校验是否存在
	exist, e := client.IndexExists(indexName).Do(context.Background())
	if e != nil {
		err = fmt.Errorf("check exists err: %v", e)
		return
	}
	exists = exist
	if exists {
		fmt.Printf("索引已存在: %s, 跳过\n", indexName)
		return
	}

	// 创建索引及映射
	createIndex, e := client.CreateIndex(indexName).BodyJson(jsonMapping).Do(context.Background())
	if e != nil {
		err = fmt.Errorf("create index err: %v", e)
		return
	}
	fmt.Printf("create index success: %s\n", createIndex.Index)
	return
}

// ClearEsIndex 清空指定索引的所有数据
func ClearEsIndex(indexName string) (err error) {
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("ClearEsIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()

	client := utils.EsClient

	// 校验索引是否存在
	exists, e := client.IndexExists(indexName).Do(context.Background())
	if e != nil {
		err = fmt.Errorf("check index exists err: %v", e)
		return
	}
	if !exists {
		err = fmt.Errorf("index does not exist: %s", indexName)
		return
	}

	query := elastic.NewMatchAllQuery()
	res, e := client.DeleteByQuery().
		Index(indexName).
		Query(query).
		ProceedOnVersionConflict(). // 忽略版本冲突
		Do(context.Background())
	if e != nil {
		err = fmt.Errorf("delete by query err: %v", e)
		return
	}

	fmt.Printf("Cleared index: %s, Deleted documents count: %d\n", indexName, res.Deleted)
	return
}

// SearchDataSourceIndexWithScroll 使用scroll API查询es中的数据源
func SearchDataSourceIndexWithScroll(indexName, keyword string, source, subSource int, classifyIds, adminIds []int, frequency []string, size int) (scrollId string, list []*dataSourceModel.SearchDataSourceItem, err error) {
	list = make([]*dataSourceModel.SearchDataSourceItem, 0)
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("SearchDataSourceIndexWithScroll err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	mustMap := make([]interface{}, 0)
	mustNotMap := make([]interface{}, 0)
	mustMap = append(mustMap, map[string]interface{}{
		"term": map[string]interface{}{
			"IsDeleted": 0,
		},
	})

	// 指标编码/名称
	shouldMap := make(map[string]interface{}, 0)
	if keyword != "" {
		shouldMap["should"] = []interface{}{
			map[string]interface{}{
				"match": map[string]interface{}{
					"IndexCode": keyword,
				},
			},
			map[string]interface{}{
				"match": map[string]interface{}{
					"IndexName": keyword,
				},
			},
		}
	}

	// 来源/子来源
	if source > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Source": source,
			},
		})
	}
	if subSource > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SubSource": subSource,
			},
		})
	}

	// 分类
	if len(classifyIds) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"ClassifyId": classifyIds,
			},
		})
	}

	// 创建人
	if len(adminIds) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"SysUserId": adminIds,
			},
		})
	}

	// 频度
	if len(frequency) > 0 {
		mustMap = append(mustMap, map[string]interface{}{
			"term": map[string]interface{}{
				"Frequency": frequency,
			},
		})
	}

	// 关键字匹配
	mustMap = append(mustMap, map[string]interface{}{
		"bool": shouldMap,
	})
	queryMap := map[string]interface{}{
		"query": map[string]interface{}{
			"bool": map[string]interface{}{
				"must":     mustMap,
				"must_not": mustNotMap,
			},
		},
	}

	// 表格名称高亮
	highlightKeyName := "IndexName"
	queryMap["highlight"] = map[string]interface{}{
		"fields": map[string]interface{}{
			highlightKeyName: map[string]interface{}{},
		},
		"pre_tags":  "<span style=\"color:#0052D9\">",
		"post_tags": "</span>",
	}
	queryMap["size"] = size

	// 使用scroll API
	request := client.Scroll(indexName).Body(queryMap).Scroll("5m")
	searchResp, e := request.Do(context.Background())
	if e != nil {
		err = fmt.Errorf("search do err: %v", e)
		return
	}

	if searchResp.Status != 0 {
		return
	}
	if searchResp.Hits == nil {
		return
	}

	scrollId = searchResp.ScrollId
	searchMap := make(map[string]string)
	for _, v := range searchResp.Hits.Hits {
		if _, ok := searchMap[v.Id]; ok {
			continue
		}
		j, e := v.Source.MarshalJSON()
		if e != nil {
			err = fmt.Errorf("hits json err: %v", e)
			return
		}
		item := new(dataSourceModel.SearchDataSourceItem)
		if e = json.Unmarshal(j, &item); e != nil {
			err = fmt.Errorf("hits json unmarshal err: %v", e)
			return
		}
		if len(v.Highlight[highlightKeyName]) > 0 {
			item.SearchText = v.Highlight[highlightKeyName][0]
		}
		if item.SearchText == "" {
			item.SearchText = item.IndexName
		}
		list = append(list, item)
		searchMap[v.Id] = v.Id
	}
	return
}

// ScrollDataSourceIndex 使用scroll API获取下一页数据
func ScrollDataSourceIndex(scrollId string) (nextScrollId string, list []*dataSourceModel.SearchDataSourceItem, err error) {
	list = make([]*dataSourceModel.SearchDataSourceItem, 0)
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("ScrollDataSourceIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	// 使用scroll API获取下一页
	request := client.Scroll().ScrollId(scrollId).Scroll("5m")
	searchResp, e := request.Do(context.Background())
	if e != nil {
		if errors.Is(e, io.EOF) {
			// 结束了，没有更多的数据了
			return
		}
		err = fmt.Errorf("scroll do err: %v", e)
		return
	}

	if searchResp.Status != 0 {
		return
	}
	if searchResp.Hits == nil {
		return
	}

	//理论上 scrollId 在整个 Scroll 生命周期中是固定不变的。
	//不过为了代码可读性和未来可能的扩展性，仍保留 nextScrollId = searchResp.ScrollId 这一行代码，这样即使逻辑迁移或改动，也不会出错。
	nextScrollId = searchResp.ScrollId
	searchMap := make(map[string]string)
	for _, v := range searchResp.Hits.Hits {
		if _, ok := searchMap[v.Id]; ok {
			continue
		}
		j, e := v.Source.MarshalJSON()
		if e != nil {
			err = fmt.Errorf("hits json err: %v", e)
			return
		}
		item := new(dataSourceModel.SearchDataSourceItem)
		if e = json.Unmarshal(j, &item); e != nil {
			err = fmt.Errorf("hits json unmarshal err: %v", e)
			return
		}
		if len(v.Highlight["IndexName"]) > 0 {
			item.SearchText = v.Highlight["IndexName"][0]
		}
		if item.SearchText == "" {
			item.SearchText = item.IndexName
		}
		list = append(list, item)
		searchMap[v.Id] = v.Id
	}
	return
}

// ClearScrollDataSourceIndex
// @Description: 清除scroll查询
// @author: Roc
// @datetime 2025-05-08 10:17:01
// @param scrollId string
// @return nextScrollId string
// @return list []*dataSourceModel.SearchDataSourceItem
// @return err error
func ClearScrollDataSourceIndex(scrollId string) (nextScrollId string, list []*dataSourceModel.SearchDataSourceItem, err error) {
	list = make([]*dataSourceModel.SearchDataSourceItem, 0)
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("ScrollDataSourceIndex err: %v", err)
			utils.FileLog.Info(tips)
		}
	}()
	client := utils.EsClient

	// 使用scroll API获取下一页
	request := client.ClearScroll().ScrollId(scrollId)
	_, err = request.Do(context.Background())

	return
}