fix：指标es搜索调整

controllers/data_manage/edb_info.go

@@ -1742,7 +1742,9 @@ func (this *EdbInfoController) EdbInfoFilter() {
 // @Param   IsAddPredictEdb   query   bool  false       "是否查询添加预测指标"
 // @Param   PageSize   query   int  true       "每页数据条数"
 // @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
-// @Param   EdbType   query   int  false       "指标类型：0-基础和计算；1-基础指标；2-计算指标"
+// @Param   EdbType   query   int  false       "指标类型：0-基础和计算；1-基础指标；2-计算指标；3-衍生指标"
+// @Param   EdbAuth   query   int  false       "指标权限：0-全部；1-我的；2-公共"
+// @Param   EdbCollect   query   int  false       "指标收藏状态：0-全部；1-已收藏"
 // @Success 200 {object} data_manage.EdbInfoList
 // @router /edb_info/filter_by_es [get]
 func (this *EdbInfoController) EdbInfoFilterByEs() {
@@ -1777,95 +1779,63 @@ func (this *EdbInfoController) EdbInfoFilterByEs() {
 
 	frequency := this.GetString("Frequency") //频度
 
-	isAddPredictEdb, _ := this.GetBool("IsAddPredictEdb") //是否查询添加预测指标
+	//isAddPredictEdb, _ := this.GetBool("IsAddPredictEdb") //是否查询添加预测指标
 
-	edbType, _ := this.GetInt("EdbType", 0) // 指标类型：0-基础和计算；1-基础指标；2-计算指标
+	// 指标类型数组：1-基础指标；2-计算指标;3-预测指标
+	edbTypeList := make([]int, 0)
+	edbTypeStr := this.GetString("EdbType", "0") // 指标类型：0-基础和计算；1-基础指标；2-计算指标；3-预测指标
+	{
+		if edbTypeStr == `` || edbTypeStr == `0` {
+			edbTypeStr = `1,2`
+		}
+		tmpEdbTypeList := strings.Split(edbTypeStr, `,`)
+		for _, v := range tmpEdbTypeList {
+			edbType, err := strconv.Atoi(v)
+			if err != nil {
+				br.Msg = "EdbType异常"
+				br.ErrMsg = "EdbType异常，Err:" + err.Error()
+				return
+			}
+			edbTypeList = append(edbTypeList, edbType)
+		}
+	}
+
+	edbAuth, _ := this.GetInt("EdbAuth", 0) // 指标权限范围，0-全部；1-我的；2-公共
+
+	edbCollect, _ := this.GetInt("EdbCollect", 0) // 指标收藏状态：0-全部；1-已收藏
 
 	var edbInfoList []*data_manage.EdbInfoList
 	var err error
 
-	// 无权限指标 和 无权限指标分类id
-	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionList(this.SysUser.AdminId, utils.EDB_INFO_TYPE, edbType)
+	// 无权限指标 和 无权限指标分类id（只考虑）
+	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionListV2(this.SysUser.AdminId)
 	if err != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
 		return
 	}
 
-	// 是否走ES
-	isEs := false
-	if keyWord != "" {
-		var keyWordArr []string
-		keyWordArr = append(keyWordArr, keyWord)
-
-		newKeyWord := strings.Split(keyWord, " ")
-		keyWordArr = append(keyWordArr, newKeyWord...)
-
-		// 普通的搜索
-		if !isAddPredictEdb {
-			total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 0, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, edbType)
-		} else {
-			// 允许添加预测指标的搜索
-			total, edbInfoList, err = elastic.SearchAddPredictEdbInfoData(utils.DATA_INDEX_NAME, keyWord, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, startSize, pageSize, edbType)
-		}
-		isEs = true
-	} else {
-		var condition string
-		var pars []interface{}
-		// 普通指标
-		condition += ` AND edb_info_type = ? `
-		pars = append(pars, 0)
-
-		// 无权限指标id
-		lenNoPermissionEdbInfoIdList := len(noPermissionEdbInfoIdList)
-		if lenNoPermissionEdbInfoIdList > 0 {
-			condition += ` AND edb_info_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbInfoIdList) + `) `
-			pars = append(pars, noPermissionEdbInfoIdList)
-		}
-		// 无权限指标分类id
-		lenNoPermissionEdbClassifyIdList := len(noPermissionEdbClassifyIdList)
-		if lenNoPermissionEdbClassifyIdList > 0 {
-			condition += ` AND classify_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbClassifyIdList) + `) `
-			pars = append(pars, noPermissionEdbClassifyIdList)
-		}
-
-		switch filterSource {
-		case 2:
-			condition += ` AND frequency='月度' `
-		case 3:
-			condition += ` AND frequency <> '日度' `
-		case 4:
-			condition += ` AND edb_type = 1 `
-		case 5:
-			condition += ` AND source = 6 ` //来源（同比值）
-		case 6:
-			condition += ` AND frequency != ? `
-			pars = append(pars, "年度")
+	// 收藏的指标id
+	collectEdbInfoIdList := make([]int, 0)
+	if edbCollect == 1 {
+		collectEdbInfoIdList, err = data_manage.GetUserAllCollectEdbInfoIdList(this.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取收藏指标配置数据失败，Err:" + err.Error()
+			return
 		}
+	}
 
-		//频度
-		if frequency != "" {
-			condition += ` AND frequency = ? `
-			pars = append(pars, frequency)
-		}
+	var keyWordArr []string
+	keyWordArr = append(keyWordArr, keyWord)
 
-		if source > 0 && filterSource != 5 {
-			condition += ` AND source = ? `
-			pars = append(pars, source)
-		}
-		// 查询只允许添加预测指标的搜索
-		if isAddPredictEdb {
-			condition += ` AND frequency in ("日度","周度","月度") `
-		}
+	newKeyWord := strings.Split(keyWord, " ")
+	keyWordArr = append(keyWordArr, newKeyWord...)
 
-		// 基础指标/计算指标
-		if edbType > 0 {
-			condition += ` AND edb_type = ? `
-			pars = append(pars, edbType)
-		}
+	// 普通的搜索
+	total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, 0, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList, edbAuth, this.SysUser.AdminId)
+	isEs := true
 
-		total, edbInfoList, err = data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
-	}
 	if err != nil {
 		edbInfoList = make([]*data_manage.EdbInfoList, 0)
 	}
@@ -1903,8 +1873,8 @@ func (this *EdbInfoController) EdbInfoFilterByEs() {
 			return
 		}
 
-		// 如果是ES的话，需要重新查一下指标的信息，主要是为了把是否授权字段找出来
-		if isEs {
+		// 需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		{
 			edbInfoIdList := make([]int, 0)
 			for i := 0; i < edbInfoListLen; i++ {
 				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
@@ -3217,7 +3187,7 @@ func (this *EdbInfoController) AllEdbInfoByEs() {
 		keyWordArr = append(keyWordArr, newKeyWord...)
 
 		// 普通的搜索
-		total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, -1, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, edbType)
+		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, -1, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2, 3}, 0, this.SysUser.AdminId)
 		isEs = true
 	} else {
 		var condition string

controllers/data_manage/edb_info_share.go

@@ -7,12 +7,7 @@ import (
 	"eta_gn/eta_api/models/data_manage"
 	"eta_gn/eta_api/models/data_manage/request"
 	"eta_gn/eta_api/models/data_manage/response"
-	"eta_gn/eta_api/services/data/data_manage_permission"
-	"eta_gn/eta_api/services/elastic"
-	"eta_gn/eta_api/utils"
-	"github.com/rdlucklib/rdluck_tools/paging"
-	"strings"
-	"time"
+	"eta_gn/eta_api/services/data"
 )
 
 // EdbInfoShareController 数据管理
@@ -24,7 +19,7 @@ type EdbInfoShareController struct {
 // @Title 获取指标设置共享的详情
 // @Description 获取指标详情接口
 // @Param   EdbInfoId   query   int  true       "指标id"
-// @Success 200 {object} data_manage.EdbInfo
+// @Success 200 {object} response.EdbInfoShareUserResp
 // @router /edb_info/share/user_list [get]
 func (c *EdbInfoShareController) UserList() {
 	br := new(models.BaseResponse).Init()
@@ -118,8 +113,6 @@ func (c *EdbInfoShareController) Save() {
 		return
 	}
 
-	resp := response.EdbInfoShareUserResp{}
-
 	obj := data_manage.EdbInfoShare{}
 	err = obj.SaveEdbInfoShare([]int{req.EdbInfoId}, req.UserIdList, req.ShareType)
 	if err != nil {
@@ -128,253 +121,10 @@ func (c *EdbInfoShareController) Save() {
 		return
 	}
 
-	br.Ret = 200
-	br.Success = true
-	br.Msg = "保存成功"
-	br.Data = resp
-}
-
-// EdbInfoFilterByEs
-// @Title 指标筛选接口
-// @Description 指标筛选接口
-// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
-// @Param   FilterSource   query   int  false       "搜索来源:1:其他搜索,2:累计值转月值搜索,3:变频，4：基础指标，5：同比"
-// @Param   Frequency   query   string  false       "频度"
-// @Param   IsAddPredictEdb   query   bool  false       "是否查询添加预测指标"
-// @Param   PageSize   query   int  true       "每页数据条数"
-// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
-// @Param   EdbType   query   int  false       "指标类型：0-基础和计算；1-基础指标；2-计算指标"
-// @Success 200 {object} data_manage.EdbInfoList
-// @router /edb_info/share [get]
-func (c *EdbInfoShareController) EdbInfoFilterByEs() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		c.Data["json"] = br
-		c.ServeJSON()
-	}()
-
-	pageSize, _ := c.GetInt("PageSize")
-	currentIndex, _ := c.GetInt("CurrentIndex")
-
-	var total int64
-
-	var startSize int
-	if pageSize <= 0 {
-		pageSize = utils.PageSize20
-	}
-	if currentIndex <= 0 {
-		currentIndex = 1
-	}
-	startSize = paging.StartIndex(currentIndex, pageSize)
-
-	keyWord := c.GetString("KeyWord")
-	keyWord = strings.TrimSpace(keyWord) //移除字符串首尾空格
-	filterSource, _ := c.GetInt("FilterSource")
-	if filterSource <= 0 {
-		filterSource = 1
-	}
-	//指标来源
-	source, _ := c.GetInt("Source")
-
-	frequency := c.GetString("Frequency") //频度
-
-	isAddPredictEdb, _ := c.GetBool("IsAddPredictEdb") //是否查询添加预测指标
-
-	edbType, _ := c.GetInt("EdbType", 0) // 指标类型：0-基础和计算；1-基础指标；2-计算指标
-
-	var edbInfoList []*data_manage.EdbInfoList
-	var err error
-
-	// 无权限指标 和 无权限指标分类id
-	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionList(c.SysUser.AdminId, utils.EDB_INFO_TYPE, edbType)
-	if err != nil {
-		br.Msg = "获取失败"
-		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
-		return
-	}
-
-	// 是否走ES
-	isEs := false
-	if keyWord != "" {
-		var keyWordArr []string
-		keyWordArr = append(keyWordArr, keyWord)
-
-		newKeyWord := strings.Split(keyWord, " ")
-		keyWordArr = append(keyWordArr, newKeyWord...)
+	// 更新es
+	go data.AddOrEditEdbInfoToEs(req.EdbInfoId)
 
-		// 普通的搜索
-		if !isAddPredictEdb {
-			total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 0, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, edbType)
-		} else {
-			// 允许添加预测指标的搜索
-			total, edbInfoList, err = elastic.SearchAddPredictEdbInfoData(utils.DATA_INDEX_NAME, keyWord, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, startSize, pageSize, edbType)
-		}
-		isEs = true
-	} else {
-		var condition string
-		var pars []interface{}
-		// 普通指标
-		condition += ` AND edb_info_type = ? `
-		pars = append(pars, 0)
-
-		// 无权限指标id
-		lenNoPermissionEdbInfoIdList := len(noPermissionEdbInfoIdList)
-		if lenNoPermissionEdbInfoIdList > 0 {
-			condition += ` AND edb_info_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbInfoIdList) + `) `
-			pars = append(pars, noPermissionEdbInfoIdList)
-		}
-		// 无权限指标分类id
-		lenNoPermissionEdbClassifyIdList := len(noPermissionEdbClassifyIdList)
-		if lenNoPermissionEdbClassifyIdList > 0 {
-			condition += ` AND classify_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbClassifyIdList) + `) `
-			pars = append(pars, noPermissionEdbClassifyIdList)
-		}
-
-		switch filterSource {
-		case 2:
-			condition += ` AND frequency='月度' `
-		case 3:
-			condition += ` AND frequency <> '日度' `
-		case 4:
-			condition += ` AND edb_type = 1 `
-		case 5:
-			condition += ` AND source = 6 ` //来源（同比值）
-		case 6:
-			condition += ` AND frequency != ? `
-			pars = append(pars, "年度")
-		}
-
-		//频度
-		if frequency != "" {
-			condition += ` AND frequency = ? `
-			pars = append(pars, frequency)
-		}
-
-		if source > 0 && filterSource != 5 {
-			condition += ` AND source = ? `
-			pars = append(pars, source)
-		}
-		// 查询只允许添加预测指标的搜索
-		if isAddPredictEdb {
-			condition += ` AND frequency in ("日度","周度","月度") `
-		}
-
-		// 基础指标/计算指标
-		if edbType > 0 {
-			condition += ` AND edb_type = ? `
-			pars = append(pars, edbType)
-		}
-
-		total, edbInfoList, err = data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
-	}
-	if err != nil {
-		edbInfoList = make([]*data_manage.EdbInfoList, 0)
-	}
-
-	page := paging.GetPaging(currentIndex, pageSize, int(total))
-
-	edbInfoListLen := len(edbInfoList)
-
-	classifyIdList := make([]int, 0)
-	for i := 0; i < edbInfoListLen; i++ {
-		edbInfoList[i].ConvertToResp()
-		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
-		classifyIdList = append(classifyIdList, edbInfoList[i].ClassifyId)
-	}
-
-	// 当前列表中的分类map
-	classifyMap := make(map[int]*data_manage.EdbClassify)
-	if edbInfoListLen > 0 {
-		classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
-			return
-		}
-
-		for _, v := range classifyList {
-			classifyMap[v.ClassifyId] = v
-		}
-
-		// 获取所有有权限的指标和分类
-		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(c.SysUser.AdminId, 0, 0)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
-			return
-		}
-
-		// 如果是ES的话，需要重新查一下指标的信息，主要是为了把是否授权字段找出来
-		if isEs {
-			edbInfoIdList := make([]int, 0)
-			for i := 0; i < edbInfoListLen; i++ {
-				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
-				tmpEdbInfo := edbInfoList[i]
-				if currClassify, ok := classifyMap[tmpEdbInfo.ClassifyId]; ok {
-					edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfo.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfo.EdbInfoId, tmpEdbInfo.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
-				}
-			}
-
-			tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
-			if err != nil {
-				br.Msg = "获取失败"
-				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
-				return
-			}
-			edbInfoMap := make(map[int]*data_manage.EdbInfo)
-			for _, v := range tmpEdbList {
-				edbInfoMap[v.EdbInfoId] = v
-			}
-
-			for i := 0; i < edbInfoListLen; i++ {
-				tmpEdbInfo, ok := edbInfoMap[edbInfoList[i].EdbInfoId]
-				if !ok {
-					continue
-				}
-				edbInfoList[i].IsJoinPermission = tmpEdbInfo.IsJoinPermission
-			}
-		}
-
-		// 权限校验
-		for i := 0; i < edbInfoListLen; i++ {
-			tmpEdbInfoItem := edbInfoList[i]
-			if currClassify, ok := classifyMap[tmpEdbInfoItem.ClassifyId]; ok {
-				edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfoItem.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfoItem.EdbInfoId, tmpEdbInfoItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
-			}
-		}
-	}
-
-	for i := 0; i < edbInfoListLen; i++ {
-		for j := 0; j < edbInfoListLen; j++ {
-			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
-				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
-				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
-				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
-			}
-		}
-	}
-	//新增搜索词记录
-	{
-		searchKeyword := new(data_manage.SearchKeyword)
-		searchKeyword.KeyWord = keyWord
-		searchKeyword.CreateTime = time.Now()
-		go data_manage.AddSearchKeyword(searchKeyword)
-	}
-
-	// 不返回无权限的指标
-	respList := make([]*data_manage.EdbInfoList, 0)
-	for _, v := range edbInfoList {
-		if v.HaveOperaAuth {
-			respList = append(respList, v)
-		}
-	}
-
-	resp := data_manage.EdbInfoFilterDataResp{
-		Paging: page,
-		List:   respList,
-	}
 	br.Ret = 200
 	br.Success = true
-	br.Msg = "获取成功"
-	br.Data = resp
+	br.Msg = "保存成功"
 }

controllers/data_manage/predict_edb_info.go

@@ -1082,6 +1082,7 @@ func (this *PredictEdbInfoController) FilterByEs() {
 
 	frequency := this.GetString("Frequency") //频度
 	isOnlyMe, _ := this.GetBool("IsOnlyMe")
+	isOnlyMe = true
 
 	var edbInfoList []*data_manage.EdbInfoList
 	var err error
@@ -1102,11 +1103,9 @@ func (this *PredictEdbInfoController) FilterByEs() {
 
 		newKeyWord := strings.Split(keyWord, " ")
 		keyWordArr = append(keyWordArr, newKeyWord...)
-		if isOnlyMe {
-			total, edbInfoList, err = elastic.SearchEdbInfoDataByAdminId(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 1, frequency, this.SysUser.AdminId)
-		} else {
-			total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 1, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, 0)
-		}
+
+		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, 1, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{3}, 0, this.SysUser.AdminId)
+
 		isEs = true
 	} else {
 		var condition string

models/data_manage/edb_collect.go

@@ -236,6 +236,19 @@ ORDER BY collect_time DESC LIMIT ?,?`, condition)
 	return
 }
 
+// GetUserAllCollectEdbInfoIdList
+// @Description: 获取用户所有收藏的指标id列表
+// @author: Roc
+// @datetime 2024-11-28 15:27:52
+// @param userId int
+// @return list []int
+// @return err error
+func GetUserAllCollectEdbInfoIdList(userId int) (list []int, err error) {
+	sql := `SELECT edb_info_id FROM edb_collect WHERE 1=1 AND sys_user_id = ? GROUP BY edb_info_id`
+	err = global.DmSQL["data"].Raw(sql, userId).Scan(&list).Error
+	return
+}
+
 type CollectEdbInfoQuery struct {
 	EdbInfo
 	CollectClassifyIdStr string    `gorm:"column:collect_classify_id" description:"收藏分类ID"`

models/data_manage/edb_info.go

@@ -409,6 +409,7 @@ type EdbInfoList struct {
 	HaveOperaAuth         bool                    `description:"是否有数据权限，默认：false"`
 	IsSupplierStop        int                     `description:"是否供应商停更:1:停更,0:未停更"`
 	CollectClassifyIdList []int                   `description:"所属收藏分类id列表" gorm:"-"`
+	SharedUserIdList      []int                   `description:"共享用户id列表" gorm:"-"`
 }
 
 type EdbDataInsertConfigItem struct {

routers/commentsRouter.go

@@ -4183,15 +4183,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"],
-        beego.ControllerComments{
-            Method: "EdbInfoFilterByEs",
-            Router: `/edb_info/share`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"],
         beego.ControllerComments{
             Method: "Save",

services/data/data_manage_permission/edb.go

@@ -169,6 +169,7 @@ func CheckEdbPermission(edbIsJoinPermission, edbClassifyIsJoinPermission, userId
 // @return classifyIdList
 // @return err
 func GetUserAllEdbAndClassifyNoPermissionList(userId, edbInfoType, edbType int) (edbIdList, classifyIdList []int, err error) {
+	// TODO 这块需要调整掉，只获取数据查看的
 	edbIdList = make([]int, 0)
 	classifyIdList = make([]int, 0)
 
@@ -231,3 +232,61 @@ func GetUserAllEdbAndClassifyNoPermissionList(userId, edbInfoType, edbType int)
 
 	return
 }
+
+// GetUserAllEdbAndClassifyNoPermissionListV2
+// @Description: 根据用户获取已经未授权的指标ID列表和指标分类ID列表（仅有数据查看（基础的普通指标）的指标了）
+// @param userId
+// @return edbIdList
+// @return classifyIdList
+// @return err
+func GetUserAllEdbAndClassifyNoPermissionListV2(userId int) (edbIdList, classifyIdList []int, err error) {
+	edbIdList = make([]int, 0)
+	classifyIdList = make([]int, 0)
+	// 获取所有无权限指标id列表
+	{
+		isJoinPermissionEdbIdList, tmpErr := data_manage.GetIsJoinPermissionEdbInfoIdList(utils.EDB_INFO_TYPE, utils.EdbTypeBase)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		// 获取有权限的指标ID列表
+		hasPermissionEdbIdList, tmpErr := data_manage_permission.GetPermissionEdbIdList(userId, 0)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println("获取授权指标列表失败， err:", tmpErr)
+			return
+		}
+		for _, edbId := range isJoinPermissionEdbIdList {
+			if !utils.InArrayByInt(hasPermissionEdbIdList, edbId) {
+				edbIdList = append(edbIdList, edbId)
+			}
+		}
+	}
+
+	// 获取所有无权限指标分类id列表
+	{
+		classifyType := 0
+
+		isJoinPermissionEdbClassifyIdList, tmpErr := data_manage.GetIsJoinPermissionEdbClassifyIdList(classifyType)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		// 获取有权限的指标分类ID列表
+		hasPermissionClassifyIdList, tmpErr := data_manage_permission.GetPermissionEdbClassifyIdList(userId, 0)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println("获取授权指标分类列表失败， err:", err)
+			return
+		}
+		for _, classifyId := range isJoinPermissionEdbClassifyIdList {
+			if !utils.InArrayByInt(hasPermissionClassifyIdList, classifyId) {
+				classifyIdList = append(classifyIdList, classifyId)
+			}
+		}
+	}
+
+	return
+}

services/data/edb_info.go

@@ -703,6 +703,14 @@ func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId,
 func AddOrEditEdbInfoToEs(edbInfoId int) {
 	//添加es
 	itemInfo, _ := data_manage.GetEdbInfoByCondition("AND edb_info_id=?", []interface{}{edbInfoId})
+	obj := data_manage.EdbInfoShare{}
+	list, _ := obj.GetListByEdbInfoId(edbInfoId)
+	sharedList := make([]int, 0)
+	for _, v := range list {
+		sharedList = append(sharedList, v.SysUserId)
+	}
+	itemInfo.SharedUserIdList = sharedList
+
 	go elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
 }
 

services/elastic/elastic.go

@@ -87,11 +87,12 @@ func EsAddOrEditEdbInfoData(indexName, docId string, item *data_manage.EdbInfoLi
 }
 
 // SearchEdbInfoData 查询es中的指标数据
-func SearchEdbInfoData(indexName, keywordStr string, from, size, filterSource, source int, edbInfoType int8, frequency string, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList []int, edbType int) (total int64, list []*data_manage.EdbInfoList, err error) {
+func SearchEdbInfoData(keywordStr string, from, size, filterSource, source int, edbInfoType int8, frequency string, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList []int, edbAuth, sysUserId int) (total int64, list []*data_manage.EdbInfoList, err error) {
+	indexName := utils.DATA_INDEX_NAME
 	list = make([]*data_manage.EdbInfoList, 0)
 	defer func() {
 		if err != nil {
-			fmt.Println("EsAddOrEditData Err:", err.Error())
+			fmt.Println("SearchEdbInfoData Err:", err.Error())
 		}
 	}()
 
@@ -99,124 +100,36 @@ func SearchEdbInfoData(indexName, keywordStr string, from, size, filterSource, s
 	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": "月度",
-				},
+		mustMap = append(mustMap, 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,
-				},
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"EdbType": 1,
 			},
-		}
+		})
 	case 5:
-		mustMap = []interface{}{
-			map[string]interface{}{
-				"term": map[string]interface{}{
-					"Source": 6,
-				},
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Source": 6,
 			},
-		}
+		})
 	case 6:
-		mustNotMap = []interface{}{
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"Frequency.keyword": "年度",
-				},
+		mustMap = append(mustMap, map[string]interface{}{
+			"match": map[string]interface{}{
+				"Frequency.keyword": "年度",
 			},
-		}
+		})
 	}
 
 	//指标来源
@@ -258,517 +171,103 @@ func SearchEdbInfoData(indexName, keywordStr string, from, size, filterSource, s
 		})
 	}
 
-	// 指标类型：普通指标、预测指标（小于0 代表不区分指标是普通还是预测）
-	if edbInfoType >= 0 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"EdbInfoType": edbInfoType,
-			},
-		})
-	}
-
-	// 指标类型：0-基础+计算；1-基础指标；2-计算指标
-	if edbType > 0 {
+	// collectEdbInfoIdList 收藏的指标id
+	if len(collectEdbInfoIdList) > 0 {
 		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"EdbType": edbType,
+			"terms": map[string]interface{}{
+				"EdbInfoId": collectEdbInfoIdList,
 			},
 		})
 	}
 
-	//普通指标
-	//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)
-}
-
-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())
-		}
-
-		for _, v := range list {
-			v.ConvertToResp()
-		}
-	}()
-	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 {
+	// 指标类型：普通指标、预测指标（小于0 代表不区分指标是普通还是预测）
+	if edbInfoType >= 0 {
 		mustMap = append(mustMap, map[string]interface{}{
 			"term": map[string]interface{}{
-				"Source": source,
-				//"Frequency.keyword": "月度",
+				"EdbInfoType": edbInfoType,
 			},
 		})
 	}
 
-	if frequency != "" {
+	// 指标类型：0-基础+计算；1-基础指标；2-计算指标；3-预测指标
+	if len(edbTypeList) > 0 {
 		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Frequency.keyword": frequency,
-				//"Frequency.keyword": "月度",
+			"terms": map[string]interface{}{
+				"EdbType": edbTypeList,
 			},
 		})
 	}
 
-	//普通指标
-	//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": "月度",
-				},
-			},
+	shouldMapList := make([]map[string]interface{}, 0)
 
-			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbCode": map[string]interface{}{
-						"query":    keywordStr,
-						"operator": "and",
+	// 指标名称、编码匹配
+	if keywordStr != `` {
+		// 默认使用中文名字字段去匹配
+		keywordNameKey := `EdbName`
+		shouldMap := map[string]interface{}{
+			"should": []interface{}{
+				map[string]interface{}{
+					"match": map[string]interface{}{
+						"EdbCode": keywordStr,
+						//"Frequency.keyword": "月度",
 					},
-					//"Frequency.keyword": "月度",
 				},
-			},
-
-			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbName": map[string]interface{}{
-						"query":    keywordStr,
-						"operator": "and",
+				map[string]interface{}{
+					"match": map[string]interface{}{
+						keywordNameKey: keywordStr,
+						//"Frequency.keyword": "月度",
 					},
-					//"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, noPermissionEdbClassifyIdList []int, from, size, edbType 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())
-		}
-
-		for _, v := range list {
-			v.ConvertToResp()
 		}
-	}()
-
-	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{"日度", "周度", "月度"},
-		//	//},
-		//},
+		shouldMapList = append(shouldMapList, shouldMap)
 	}
 
-	// 指标类型：普通指标、预算指标
-	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{"日度", "周度", "月度"},
-		},
-	})
-
-	// 指标类型: 1-基础指标; 2-计算指标
-	if edbType > 0 {
-		mustMap = append(mustMap, map[string]interface{}{
+	// 指标与用户的权限匹配
+	if sysUserId > 0 {
+		shouldTermList := make([]map[string]interface{}, 0)
+		// 自己的指标
+		shouldTermList = append(shouldTermList, map[string]interface{}{
 			"term": map[string]interface{}{
-				"EdbType": edbType,
+				"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{}{
+		// 分享给我的指标
+		shouldTermList = append(shouldTermList, map[string]interface{}{
 			"terms": map[string]interface{}{
-				"EdbInfoId": noPermissionEdbInfoIdList,
-				//"Frequency.keyword": "月度",
+				"SharedUserIdList": []int{sysUserId},
 			},
 		})
+		// 公开的指标
+		//shouldTermList = append(shouldTermList,map[string]interface{}{
+		//	"term": map[string]interface{}{
+		//		"PublicStatus": 2,
+		//	},
+		//})
+
+		shouldMap := map[string]interface{}{
+			"should": shouldTermList,
+		}
+		shouldMapList = append(shouldMapList, shouldMap)
 	}
 
-	// noPermissionEdbClassifyIdList 无权限指标分类id
-	if len(noPermissionEdbClassifyIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"ClassifyId": noPermissionEdbClassifyIdList,
-				//"Frequency.keyword": "月度",
+	// 排序
+	sortList := make([]interface{}, 0)
+	// 如果没有关键字，那么就走指标id倒序
+	if keywordStr == `` {
+		sortEdbInfoId := map[string]interface{}{
+			"EdbInfoId": map[string]interface{}{
+				"order": "desc",
 			},
-		})
+		}
+		sortList = append(sortList, sortEdbInfoId)
 	}
 
-	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
+	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMapList, sortList, 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) {
+func searchEdbInfoData(indexName string, mustMap, mustNotMap []interface{}, shouldMapList []map[string]interface{}, sortList []interface{}, from, size int) (total int64, list []*data_manage.EdbInfoList, err error) {
 	list = make([]*data_manage.EdbInfoList, 0)
 	defer func() {
 		if err != nil {
@@ -792,9 +291,11 @@ func searchEdbInfoData(indexName string, mustMap, mustNotMap []interface{}, shou
 	//query := elastic.RawStringQuery(`{"match_all":{}}`)
 
 	//关键字匹配
-	mustMap = append(mustMap, map[string]interface{}{
-		"bool": shouldMap,
-	})
+	for _, shouldMap := range shouldMapList {
+		mustMap = append(mustMap, map[string]interface{}{
+			"bool": shouldMap,
+		})
+	}
 
 	queryMap := map[string]interface{}{
 		"query": map[string]interface{}{
@@ -815,21 +316,15 @@ func searchEdbInfoData(indexName string, mustMap, mustNotMap []interface{}, shou
 
 	queryMap["from"] = from
 	queryMap["size"] = size
+
+	// 如果有指定排序，那么就按照排序来
+	if len(sortList) > 0 {
+		queryMap["sort"] = sortList
+	}
+
 	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)
 
@@ -1461,230 +956,3 @@ func SearchMyChartInfoData(indexName, keywordStr string, adminId int, noPermissi
 	//}
 	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())
-		}
-		for _, v := range list {
-			v.ConvertToResp()
-		}
-	}()
-
-	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)
-}