egg_admin/app/svc/egg_energy/svc_egg_energy.go

package egg_energy

import (
	md2 "applet/app/md/institutional_management/egg_energy"
	"applet/app/utils"
	"code.fnuoos.com/EggPlanet/egg_system_rules.git/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_es.git/es"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/olivere/elastic/v7"
	"strconv"
	"strings"
)

// 查询Elasticsearch并返回结果
func QueryElasticsearch(req md2.UserEggFlowReq, indexName string) (resp []md2.UserEggFlowReqRespList, total int64, err error) {
	// 构建查询条件
	boolQuery := elastic.NewBoolQuery()

	if req.ScoreValueStart != "" && req.ScoreValueEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("score_value").Gte(req.ScoreValueStart).Lte(req.ScoreValueEnd))
	}
	if req.EcpmStart != "" && req.EcpmEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("ecpm").Gte(req.EcpmStart).Lte(req.EcpmEnd))
	}
	if req.InviteUserNumsStart != "" && req.InviteUserNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("invite_user_nums").Gte(req.InviteUserNumsStart).Lte(req.InviteUserNumsEnd))
	}
	if req.TeamActivityNumsStart != "" && req.TeamActivityNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("team_activity_nums").Gte(req.TeamActivityNumsStart).Lte(req.TeamActivityNumsEnd))
	}
	if req.SignInNumsStart != "" && req.SignInNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("sign_in_nums").Gte(req.SignInNumsStart).Lte(req.SignInNumsEnd))
	}
	if req.ImActivityNumsStart != "" && req.ImActivityNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("im_activity_nums").Gte(req.ImActivityNumsStart).Lte(req.ImActivityNumsEnd))
	}
	if req.SendRedPackageNumsStart != "" && req.SendRedPackageNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("send_red_package_nums").Gte(req.SendRedPackageNumsStart).Lte(req.SendRedPackageNumsEnd))
	}
	if req.EggEnergyExchangeAccountBalanceStart != "" && req.EggEnergyExchangeAccountBalanceEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("egg_energy_exchange_account_balance").Gte(req.EggEnergyExchangeAccountBalanceStart).Lte(req.EggEnergyExchangeAccountBalanceEnd))
	}
	if req.AccountBalanceExchangeEggEnergyNumsStart != "" && req.AccountBalanceExchangeEggEnergyNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("account_balance_exchange_egg_energy_nums").Gte(req.AccountBalanceExchangeEggEnergyNumsStart).Lte(req.AccountBalanceExchangeEggEnergyNumsEnd))
	}
	if req.SendCircleOfFriendNumsStart != "" && req.SendCircleOfFriendNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("send_circle_of_friend_nums").Gte(req.SendCircleOfFriendNumsStart).Lte(req.SendCircleOfFriendNumsEnd))
	}
	if req.ForumCommentsNumsStart != "" && req.ForumCommentsNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("forum_comments_nums").Gte(req.ForumCommentsNumsStart).Lte(req.ForumCommentsNumsEnd))
	}
	if req.CollegeLearningNumsStart != "" && req.CollegeLearningNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("college_learning_nums").Gte(req.CollegeLearningNumsStart).Lte(req.CollegeLearningNumsEnd))
	}
	if req.ViolateNumsStart != "" && req.ViolateNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("violate_nums").Gte(req.ViolateNumsStart).Lte(req.ViolateNumsEnd))
	}
	if req.BrowseInterfaceNumsStart != "" && req.BrowseInterfaceNumsEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("browse_interface_nums").Gte(req.BrowseInterfaceNumsStart).Lte(req.BrowseInterfaceNumsEnd))
	}
	if req.PersonAddActivityValueStart != "" && req.PersonAddActivityValueEnd != "" {
		boolQuery = boolQuery.Filter(elastic.NewRangeQuery("person_add_activity_value").Gte(req.PersonAddActivityValueStart).Lte(req.PersonAddActivityValueEnd))
	}

	// 执行查询
	searchResult, err := es.EsClient.Search().
		Index(indexName).
		Query(boolQuery).
		From((req.Page - 1) * req.PageSize).Size(req.PageSize).
		Pretty(true).
		Do(context.Background())

	if err != nil {
		return
	}

	// 检查是否有结果
	if searchResult.Hits.TotalHits.Value == 0 {
		return
	}

	// 解析结果
	for _, hit := range searchResult.Hits.Hits {
		var doc md2.UserEggFlowReqRespList
		err = json.Unmarshal(hit.Source, &doc)
		if err != nil {
			return
		}
		resp = append(resp, doc)
	}
	total = searchResult.Hits.TotalHits.Value
	return
}

// StatisticsUserEggScoreValueRange 统计用户蛋蛋分范围
func StatisticsUserEggScoreValueRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("score_value")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		newAggs := elastic.NewHistogramAggregation().Field("score_value").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		var tempTotalDocCount int64
		var endStart, endEnd string
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			if bucket.Key <= stdDeviation {
				bucketValue := bucket.Key
				keys = append(keys, utils.Float64ToStr(bucketValue))
				values = append(values, bucket.DocCount)
			} else {
				bucketValue := bucket.Key
				if tempTotalDocCount == 0 {
					endStart = utils.Float64ToStr(bucketValue)
				}
				tempTotalDocCount += bucket.DocCount
				endEnd = utils.Float64ToStr(bucketValue)
			}
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.AnyToString(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
		if tempTotalDocCount > 0 {
			temp, _ := Operate(tempTotalDocCount, totalCount)
			resp = append(resp, map[string]string{
				"key":   endStart + " ~ " + endEnd + " 元",
				"value": utils.Float64ToStrPrec10(temp),
			})
		}
	}
	return resp, nil
}

// StatisticsUserEggKindProportion 统计用户蛋蛋分"评比类型"占比
func StatisticsUserEggKindProportion(esIndexName string) (result []map[string]interface{}, err error) {
	var res *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	aggs := elastic.NewTermsAggregation().Field("score_value_kind")
	res, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).           // 设置查询条件
		Aggregation("terms", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                    // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).               // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return result, err
	}
	// 使用Terms函数和前面定义的聚合条件名称，查询结果
	agg, _ := res.Aggregations.Terms("terms")
	var total float64
	for _, bucket := range agg.Buckets {
		var tmp = map[string]interface{}{}
		bucketValue := bucket.Key
		tmp["key"] = bucketValue
		tmp["count"] = bucket.DocCount
		switch bucketValue {
		case 1:
			tmp["name"] = "人工"
			break
		case 2:
			tmp["name"] = "自动"
			break
		default:
			tmp["name"] = "未知"
		}
		result = append(result, tmp)
		total += utils.AnyToFloat64(bucket.DocCount)
	}
	for _, value := range result {
		value["proportion"] = utils.AnyToString(utils.AnyToFloat64(value["count"]) / total)
	}
	return result, nil
}

// StatisticsUserEggEcpmRange 统计用户"ecpm"范围
func StatisticsUserEggEcpmRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("ecpm")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("ecpm").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggInviteUserNumsRange 统计用户"拉新人数"范围
func StatisticsUserEggInviteUserNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("invite_user_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("invite_user_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggTeamActivityNumsRange 统计用户"团队活跃次数"范围
func StatisticsUserEggTeamActivityNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("team_activity_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("team_activity_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggSignInNumsRange 统计用户"签到次数"范围
func StatisticsUserEggSignInNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("sign_in_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("sign_in_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggSendRedPackageNumsRange 统计用户"发红包次数"范围
func StatisticsUserEggSendRedPackageNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("send_red_package_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("send_red_package_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggEggEnergyExchangeAccountBalanceRange 统计用户"蛋蛋能量兑换余额数量"范围
func StatisticsUserEggEggEnergyExchangeAccountBalanceRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("account_balance_exchange_egg_energy_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("account_balance_exchange_egg_energy_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggAccountBalanceExchangeEggEnergyNumsRange 统计用户"余额兑换蛋蛋能量数量"范围
func StatisticsUserEggAccountBalanceExchangeEggEnergyNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("egg_energy_exchange_account_balance")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("egg_energy_exchange_account_balance").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggSendCircleOfFriendNumsRange 统计用户"发朋友圈次数"范围
func StatisticsUserEggSendCircleOfFriendNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("send_circle_of_friend_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("send_circle_of_friend_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggForumCommentsNumsRange 统计用户"论坛评论次数"范围
func StatisticsUserEggForumCommentsNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("forum_comments_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("forum_comments_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggCollegeLearningNumsRange 统计用户"学院学习次数"范围
func StatisticsUserEggCollegeLearningNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("college_learning_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("college_learning_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggViolateNumsRange 统计用户"违规次数"范围
func StatisticsUserEggViolateNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("violate_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("violate_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggBrowseInterfaceNumsRange 统计用户"浏览界面次数"范围
func StatisticsUserEggBrowseInterfaceNumsRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("browse_interface_nums")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("browse_interface_nums").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

// StatisticsUserEggPersonAddActivityValueRange 统计用户"个人活跃积分增量值"范围
func StatisticsUserEggPersonAddActivityValueRange(esIndexName string) (resp []map[string]string, err error) {
	resp = []map[string]string{}
	var result *elastic.SearchResult
	boolQuery := elastic.NewBoolQuery().Must() // 创建bool查询

	// 1、 创建 extended_stats 高级统计
	aggs := elastic.NewExtendedStatsAggregation().Field("person_add_activity_value")
	result, err = es.EsClient.Search().
		Index(esIndexName).
		TrackTotalHits(true).
		Query(boolQuery).            // 设置查询条件
		Aggregation("result", aggs). // 设置聚合条件，并为聚合条件设置一个名字
		Size(0).                     // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
		Pretty(true).                // 返回可读的json格式
		Do(context.Background())
	if err != nil {
		return resp, err
	}

	// 使用Cardinality函数和前面定义的聚合条件名称，查询结果
	agg, found := result.Aggregations.ExtendedStats("result")
	if !found {
		// 打印结果，注意：这里使用的是取值运算符
		return resp, errors.New("未聚合出数据")
	}

	if agg.StdDeviation != nil && *agg.StdDeviation != 0 {
		//2、histogram 直方图聚合
		stdDeviation := *agg.StdDeviation         //标准平方差
		min := *agg.Min                           //最小值
		max := *agg.Max                           //最大值
		avg := *agg.Avg                           //平均数
		totalCount := agg.Count                   //总数
		discreteCoefficient := stdDeviation / avg //离散系数
		if stdDeviation < avg {
			//TODO::如果标准差相对较小，而平均值较大，离散系数可能会导致较大的间隔,直接使用标准差或其他更合适的值作为间隔。
			discreteCoefficient = stdDeviation
		}
		newAggs := elastic.NewHistogramAggregation().Field("person_add_activity_value").Interval(discreteCoefficient).ExtendedBounds(min, max)
		searchResult, err := es.EsClient.Search().
			Index(esIndexName).
			TrackTotalHits(true).
			Query(boolQuery).               // 设置查询条件
			Aggregation("result", newAggs). // 设置聚合条件，并为聚合条件设置一个名字
			Size(0).                        // 设置分页参数 - 每页大小,设置为0,代表不返回搜索结果，仅返回聚合分析结果
			Pretty(true).                   // 返回可读的json格式
			Do(context.Background())
		if err != nil {
			return resp, err
		}
		// 使用Terms函数和前面定义的聚合条件名称，查询结果
		newAgg, found := searchResult.Aggregations.Histogram("result")
		if !found {
			return resp, errors.New("未聚合出数据")
		}

		// 3、组装数据
		var keys []string
		var values []int64
		for _, bucket := range newAgg.Buckets {
			// 每一个桶都有一个key值，其实就是分组的值，可以理解为SQL的group by值
			bucketValue := bucket.Key
			keys = append(keys, utils.Float64ToStr(bucketValue))
			values = append(values, bucket.DocCount)
		}

		for k, v := range keys {
			value, _ := Operate(values[k], totalCount)
			if k+1 == len(keys) {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + utils.Float64ToStr(max) + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			} else {
				resp = append(resp, map[string]string{
					"key":   v + " ~ " + keys[k+1] + " 元",
					"value": utils.Float64ToStrPrec10(value),
				})
			}
		}
	}
	return resp, nil
}

func GetYearsAndWeeks() (resp map[string][]string, err error) {
	// 1、 获取到所有的索引
	indices, err := es.GetIndexFromAlias(md.EggEnergyUserEggScoreEsAlias)
	if err != nil {
		return nil, err
	}

	//2、组装数据
	resp = map[string][]string{}
	for _, index := range indices {
		// 分割字符串
		parts := strings.Split(index, "_")

		// 提取 2024 和 46
		resp[parts[len(parts)-1][:4]] = append(resp[parts[len(parts)-1][:4]], parts[len(parts)-1][4:])
	}
	return
}

func GetYearsAndWeekStr(esIndexName string) (string, string) {
	parts := strings.Split(esIndexName, "_")
	return parts[len(parts)-1][:4], parts[len(parts)-1][4:]
}

// Operate 除运算保留10位小数
func Operate(num1, num2 int64) (float64, error) {
	value, err := strconv.ParseFloat(fmt.Sprintf("%.10f", float64(num1)/float64(num2)), 64)
	if err != nil {
		return 0, err
	}
	return value, nil
}