Merge remote-tracking branch 'origin/eta/2.3' into debug

controllers/data_manage/chart_info.go

@@ -4245,13 +4245,3 @@ func (this *ChartInfoController) ChartInfoImgSetBySvg() {
 	br.Data = resp
 	return
 }
-
-// 修复ES中的指标和图表数据
-//func init() {
-//	// 更新ES中的指标数据
-//	data.AddOrEditAllEdbInfoToEs()
-//	// 更新es中的图表数据
-//	data.AddAllChartInfo()
-//
-//	fmt.Println("全部es数据修复完成")
-//}

controllers/data_manage/edb_classify.go

@@ -41,14 +41,14 @@ func (this *EdbClassifyController) ListV2() {
 		edbType = utils.EdbTypeCalculate
 	}
 
-	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType))
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
 		return
 	}
 	//classifyAll, err := data_manage.GetEdbClassifyAll()
-	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType)
+	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType, this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -177,7 +177,7 @@ func (this *EdbClassifyController) Items() {
 	//	edbType = utils.EdbTypeCalculate
 	//}
 
-	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType))
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), this.SysUser.AdminId)
 	if err != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -185,7 +185,7 @@ func (this *EdbClassifyController) Items() {
 	}
 
 	//classifyAll, err := data_manage.GetEdbClassifyAll()
-	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType)
+	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType, this.SysUser.AdminId)
 	if err != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -709,14 +709,14 @@ func (this *EdbClassifyController) ItemsV2() {
 	//	edbType = utils.EdbTypeCalculate
 	//}
 
-	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType))
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
 		return
 	}
 	//classifyAll, err := data_manage.GetEdbClassifyAll()
-	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType)
+	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType, this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -926,7 +926,7 @@ func (this *EdbClassifyController) ItemsV3() {
 	//}
 
 	// TODO:9级改造
-	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType))
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -1076,7 +1076,7 @@ func (this *EdbClassifyController) SimpleList() {
 	if isOnlyMe {
 		sysUserId = this.SysUser.AdminId
 	}
-	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, int8(classifyType))
+	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, int8(classifyType), this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -1380,47 +1380,3 @@ func (this *EdbClassifyController) ClassifyTree() {
 //	br.Success = true
 //	br.Msg = "移动成功"
 //}
-
-// initFixClassify
-// @Description: 修复分类完整路径
-// @author: Roc
-// @datetime 2024-11-26 15:40:57
-func initFixClassify() {
-	allList := make([]*data_manage.EdbClassifyItems, 0)
-	allList, e := data_manage.GetEdbClassifyByClassifyTypes([]int{utils.EdbClassifyTypeBase, utils.EdbClassifyTypePredict, utils.EdbClassifyTypeCalculate})
-	if e != nil {
-		fmt.Println("获取分类失败", e)
-		return
-	}
-
-	var sortList data_manage.EdbClassifyItemList
-
-	allList = data.GetClassifyTreeRecursive(allList, 0)
-	//根据sort值排序
-	sortList = allList
-	sort.Sort(sortList)
-
-	for _, v := range sortList {
-		updatePath(v, "", "")
-	}
-	fmt.Println("修复分类路径完成")
-}
-
-func updatePath(item *data_manage.EdbClassifyItems, classifyNamePath, classifyIdPath string) {
-	if classifyNamePath == `` {
-		classifyNamePath = item.ClassifyName
-		classifyIdPath = fmt.Sprint(item.ClassifyId)
-	} else {
-		classifyNamePath = fmt.Sprint(classifyNamePath, "|", item.ClassifyName)
-		classifyIdPath = fmt.Sprint(classifyIdPath, ",", item.ClassifyId)
-	}
-	err := data_manage.UpdateEdbClassify(item.ClassifyId, classifyNamePath, classifyIdPath)
-	if err != nil {
-		fmt.Println(item.ClassifyId, ";更新失败", err)
-	}
-	if item.Children != nil {
-		for _, v := range item.Children {
-			updatePath(v, classifyNamePath, classifyIdPath)
-		}
-	}
-}

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,83 @@ 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)
+	edbInfoType := -1                            // 指标范围
+	edbTypeStr := this.GetString("EdbType", "0") // 指标类型：0-基础和计算；1-基础指标；2-计算指标；3-预测指标
+	{
+		if edbTypeStr == `` || edbTypeStr == `0` {
+			edbTypeList = []int{1, 2}
+			edbInfoType = 0
+		} else {
+			var hasEdb, hasPredictEdb bool
+			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
+				}
+
+				// 指标类型
+				switch edbType {
+				case 1, 2:
+					hasEdb = true
+					edbTypeList = append(edbTypeList, edbType)
+				case 3:
+					hasPredictEdb = true
+					edbTypeList = []int{1, 2}
+				}
+			}
+
+			// 只有数据查看和指标加工
+			if hasEdb && !hasPredictEdb {
+				edbInfoType = 0
+			} else if !hasEdb && hasPredictEdb {
+				// 只有预测指标
+				edbInfoType = 1
+			}
+		}
+	}
+
+	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, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList, edbInfoType, edbAuth, this.SysUser.AdminId)
 
-		total, edbInfoList, err = data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
-	}
 	if err != nil {
 		edbInfoList = make([]*data_manage.EdbInfoList, 0)
 	}
@@ -1903,8 +1893,8 @@ func (this *EdbInfoController) EdbInfoFilterByEs() {
 			return
 		}
 
-		// 如果是ES的话，需要重新查一下指标的信息，主要是为了把是否授权字段找出来
-		if isEs {
+		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		{
 			edbInfoIdList := make([]int, 0)
 			for i := 0; i < edbInfoListLen; i++ {
 				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
@@ -3217,7 +3207,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, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, -1, 0, this.SysUser.AdminId)
 		isEs = true
 	} else {
 		var condition string

controllers/data_manage/edb_info_calculate.go

@@ -1068,76 +1068,6 @@ func (this *ChartInfoController) CalculateBatchReset() {
 	br.IsAddLog = true
 }
 
-//累计值转月值
-//func init() {
-//	fmt.Println("start CalculateBatchSave")
-//	req := new(data_manage.EdbInfoCalculateBatchSaveReq)
-//	req.EdbInfoId = 100282
-//
-//	randStr := utils.GetRandDigit(4)
-//	edbCode := `C` + time.Now().Format("060102") + randStr
-//	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-//	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-//	fromEdbInfo, _ := data_manage.GetEdbInfoById(req.EdbInfoId)
-//	data_manage.AddCalculateLjzzy(req, fromEdbInfo, edbCode, uniqueCode, 1, "rdluck")
-//	fmt.Println("end CalculateBatchSave")
-//	return
-//}
-
-////同比值
-//func init() {
-//	fmt.Println("start AddCalculateTbz")
-//	req := new(data_manage.EdbInfoCalculateBatchSaveReq)
-//	req.EdbInfoId = 100092
-//
-//	randStr := utils.GetRandDigit(4)
-//	edbCode := `C` + time.Now().Format("060102") + randStr
-//	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-//	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-//	fromEdbInfo, _ := data_manage.GetEdbInfoById(req.EdbInfoId)
-//
-//	data_manage.AddCalculateTbz(req, fromEdbInfo, edbCode, uniqueCode, 1, "rdluck")
-//	fmt.Println("end AddCalculateTbz")
-//	return
-//}
-//同差值
-
-//func init() {
-//	fmt.Println("start AddCalculateTbz")
-//	req := new(data_manage.EdbInfoCalculateBatchSaveReq)
-//	req.EdbInfoId = 100092
-//
-//	randStr := utils.GetRandDigit(4)
-//	edbCode := `C` + time.Now().Format("060102") + randStr
-//	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-//	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-//	fromEdbInfo, _ := data_manage.GetEdbInfoById(req.EdbInfoId)
-//
-//	data_manage.AddCalculateTcz(req, fromEdbInfo, edbCode, uniqueCode, 1, "rdluck")
-//
-//	fmt.Println("end AddCalculateTbz")
-//	return
-//}
-
-//N数值移动平均计算
-//func init() {
-//	fmt.Println("start AddCalculateTbz")
-//	req := new(data_manage.EdbInfoCalculateBatchSaveReq)
-//	req.FromEdbInfoId = 100081
-//
-//	randStr := utils.GetRandDigit(4)
-//	edbCode := `C` + time.Now().Format("060102") + randStr
-//	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-//	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-//	fromEdbInfo, _ := data_manage.GetEdbInfoById(req.FromEdbInfoId)
-//	formulaInt := 3
-//	fmt.Println("edbCode:", edbCode)
-//	data_manage.AddCalculateNszydpjjs(req, fromEdbInfo, edbCode, uniqueCode, 1, "rdluck", formulaInt)
-//
-//	fmt.Println("end AddCalculateTbz")
-//	return
-//}
-
 // ExecPythonCode
 // @Title 执行python代码
 // @Description 执行python代码接口

controllers/data_manage/edb_info_share.go

@@ -0,0 +1,130 @@
+package data_manage
+
+import (
+	"encoding/json"
+	"eta_gn/eta_api/controllers"
+	"eta_gn/eta_api/models"
+	"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"
+)
+
+// EdbInfoShareController 数据管理
+type EdbInfoShareController struct {
+	controllers.BaseAuthController
+}
+
+// UserList
+// @Title 获取指标设置共享的详情
+// @Description 获取指标详情接口
+// @Param   EdbInfoId   query   int  true       "指标id"
+// @Success 200 {object} response.EdbInfoShareUserResp
+// @router /edb_info/share/user_list [get]
+func (c *EdbInfoShareController) UserList() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	edbInfoId, _ := c.GetInt("EdbInfoId")
+	if edbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "参数错误"
+		return
+	}
+	_, err := data_manage.GetEdbInfoById(edbInfoId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
+		return
+	}
+
+	//// TODO 权限校验
+	//{
+	//	classifyMap := make(map[int]*data_manage.EdbClassifyIdItems)
+	//	for _, v := range classifyList {
+	//		classifyMap[v.ClassifyId] = v
+	//	}
+	//	if currClassify, ok := classifyMap[edbInfo.ClassifyId]; ok {
+	//		haveOperaAuth, err := data_manage_permission.CheckEdbPermission(edbInfo.IsJoinPermission, currClassify.IsJoinPermission, c.SysUser.AdminId, edbInfo.EdbInfoId, edbInfo.ClassifyId)
+	//		if err != nil {
+	//			br.Msg = err.Error()
+	//			br.ErrMsg = "校验指标权限失败，err:" + err.Error()
+	//			return
+	//		}
+	//		resp.HaveOperaAuth = haveOperaAuth
+	//	}
+	//}
+
+	resp := response.EdbInfoShareUserResp{}
+
+	obj := data_manage.EdbInfoShare{}
+	list, err := obj.GetListByEdbInfoId(edbInfoId)
+	if err != nil {
+		br.Msg = `获取失败`
+		br.ErrMsg = `获取失败：` + err.Error()
+		return
+	}
+	resp.List = list
+	if len(list) > 0 {
+		resp.ShareType = list[0].ShareType
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// Save
+// @Title 保存指标指标设置共享的详情
+// @Description 获取指标详情接口
+// @Param	request	body request.SetEdbInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.EdbInfo
+// @router /edb_info/share/save [post]
+func (c *EdbInfoShareController) Save() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	var req request.SetEdbInfoShareReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	obj := data_manage.EdbInfoShare{}
+	err = obj.SaveEdbInfoShare([]int{req.EdbInfoId}, req.UserIdList, req.ShareType)
+	if err != nil {
+		br.Msg = `保存失败`
+		br.ErrMsg = `保存失败：` + err.Error()
+		return
+	}
+
+	// 更新es
+	go data.AddOrEditEdbInfoToEs(req.EdbInfoId)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}

controllers/data_manage/excel/custom_analysis_edb.go

@@ -461,16 +461,3 @@ func (c *CustomAnalysisController) EdbRefresh() {
 	br.Success = true
 	br.Msg = "刷新成功"
 }
-
-//func init() {
-//	excelInfo, err := excelModel.GetExcelInfoById(160)
-//	if err != nil {
-//		fmt.Println("查找excel失败：", err)
-//		return
-//	}
-//	_, err, _ = excel.GenerateExcelCustomAnalysisExcel(excelInfo)
-//	if err != nil {
-//		fmt.Println("生成excel失败：", err)
-//		return
-//	}
-//}

controllers/data_manage/future_good/future_good_edb_info.go

@@ -334,407 +334,3 @@ func (this *FutureGoodEdbInfoController) FutureGoodEdbExchangeList() {
 	br.Msg = "获取成功"
 	br.Data = list
 }
-
-//func init() {
-//	var condition string
-//	var pars []interface{}
-//
-//	condition += ` AND parent_id = ? `
-//	pars = append(pars, 0)
-//
-//	list, err := future_good2.GetFutureGoodEdbInfoList(condition, pars)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//
-//	monthMap := map[string]string{
-//		`(1月`:  "(Jan",
-//		`(2月`:  "(Feb",
-//		`(3月`:  "(Mar",
-//		`(4月`:  "(Apr",
-//		`(5月`:  "(May",
-//		`(6月`:  "(Jun",
-//		`(7月`:  "(Jul",
-//		`(8月`:  "(Aug",
-//		`(9月`:  "(Sep",
-//		`(10月`: "(Oct",
-//		`(11月`: "(Nov",
-//		`(12月`: "(Dec",
-//	}
-//	for _, v := range list {
-//		fmt.Println(v)
-//		var tmpCondition string
-//		var tmpPars []interface{}
-//
-//		tmpCondition += ` AND parent_id = ? `
-//		tmpPars = append(tmpPars, v.FutureGoodEdbInfoId)
-//		tmpList, tmpErr := future_good2.GetFutureGoodEdbInfoList(tmpCondition, tmpPars)
-//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-//			fmt.Println("err:", tmpErr)
-//			return
-//		}
-//
-//		for _, child := range tmpList {
-//			child.FutureGoodEdbNameEn = strings.Replace(child.FutureGoodEdbNameEn, v.FutureGoodEdbName, v.FutureGoodEdbNameEn, -1)
-//
-//			for k, month := range monthMap {
-//				if strings.Contains(child.FutureGoodEdbNameEn, k) {
-//					child.FutureGoodEdbNameEn = strings.Replace(child.FutureGoodEdbNameEn, k, month, -1)
-//					fmt.Println(child.FutureGoodEdbNameEn)
-//					//os.Exit(-1)
-//					child.Update([]string{"FutureGoodEdbNameEn"})
-//				}
-//			}
-//		}
-//	}
-//
-//	fmt.Println("end")
-//}
-
-//func init() {
-//
-//	edbCodeMap := map[string]string{
-//		//"沪深300指数期货": "IF",
-//		//"上证50指数期货": "IH",
-//		//"中证500指数期货": "IC",
-//		//"中证1000指数期货": "IM",
-//		//"2年期国债期货": "TS",
-//		//"5年期国债期货": "TF",
-//		"10年期国债期货": "T",
-//	}
-//	//T03
-//	suffix := "M.CFE"
-//	monthList := []string{"01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"}
-//	monthStrList := []string{"(1月)", "(2月)", "(3月)", "(4月)", "(5月)", "(6月)", "(7月)", "(8月)", "(9月)", "(10月)", "(11月)", "(12月)"}
-//
-//	for k, v := range edbCodeMap {
-//		code := v + "CFE"
-//		tmpFutureGoodEdbInfo := &future_good2.FutureGoodEdbInfo{
-//			//FutureGoodEdbInfoId: 0,
-//			FutureGoodEdbCode:   code,
-//			FutureGoodEdbName:   k,
-//			FutureGoodEdbNameEn: k,
-//			ParentId:            0,
-//			Exchange:            "中金所",
-//			Month:               0,
-//			StartDate:           "",
-//			EndDate:             "",
-//			MinValue:            0,
-//			MaxValue:            0,
-//			LatestValue:         0,
-//			//LatestDate:          time.Time{},
-//			ServerUrl:  "",
-//			CreateTime: time.Now(),
-//			ModifyTime: time.Now(),
-//		}
-//		err := future_good2.AddFutureGoodEdbInfo(tmpFutureGoodEdbInfo)
-//		if err != nil {
-//			fmt.Println("添加指标:", k, "失败,err:", err)
-//			continue
-//		}
-//
-//		for index, month := range monthList {
-//			code2 := v + month + suffix
-//			name := tmpFutureGoodEdbInfo.FutureGoodEdbName + monthStrList[index]
-//			tmpFutureGoodEdbInfo2 := &future_good2.FutureGoodEdbInfo{
-//				//FutureGoodEdbInfoId: 0,
-//				FutureGoodEdbCode:   code2,
-//				FutureGoodEdbName:   name,
-//				FutureGoodEdbNameEn: name,
-//				ParentId:            tmpFutureGoodEdbInfo.FutureGoodEdbInfoId,
-//				Exchange:            "中金所",
-//				Month:               0,
-//				StartDate:           "",
-//				EndDate:             "",
-//				MinValue:            0,
-//				MaxValue:            0,
-//				LatestValue:         0,
-//				//LatestDate:          time.Time{},
-//				ServerUrl:  "",
-//				CreateTime: time.Now(),
-//				ModifyTime: time.Now(),
-//			}
-//			err = future_good2.AddFutureGoodEdbInfo(tmpFutureGoodEdbInfo2)
-//			if err != nil {
-//				fmt.Println("添加子指标:", name, "失败,err:", err)
-//				continue
-//			}
-//		}
-//	}
-//
-//	fmt.Println("end")
-//}
-
-//func init() {
-//	var condition string
-//	var pars []interface{}
-//
-//	condition += ` AND parent_id > ? AND start_date= ? `
-//	pars = append(pars, 0, "0000-00-00")
-//
-//	list, err := future_good2.GetFutureGoodEdbInfoList(condition, pars)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//
-//	for _, v := range list {
-//		fmt.Println(v)
-//		resp, err := future_good.AddEdbData(v.FutureGoodEdbCode)
-//		if err != nil {
-//			fmt.Println(v.FutureGoodEdbName, "添加 异常 ,err:", err)
-//			continue
-//		}
-//		if resp.Ret != 200 {
-//			fmt.Println(v.FutureGoodEdbName, "添加 失败 ,msg:", resp.Msg, ";errMsg:", resp.ErrMsg)
-//		}
-//	}
-//
-//	fmt.Println("end")
-//}
-
-//func init() {
-//	var condition string
-//	var pars []interface{}
-//
-//	condition += ` AND parent_id = ? AND start_date= ? `
-//	pars = append(pars, 0, "0000-00-00")
-//
-//	list, err := future_good2.GetFutureGoodEdbInfoList(condition, pars)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//
-//	for _, v := range list {
-//		fmt.Println(v)
-//		//v.FutureGoodEdbCode = strings.Replace(v.FutureGoodEdbCode, ".", "ZL.", -1)
-//		//v.Update([]string{"FutureGoodEdbCode"})
-//		resp, err := future_good.AddEdbData(v.FutureGoodEdbCode)
-//		if err != nil {
-//			fmt.Println(v.FutureGoodEdbName, "添加 异常 ,err:", err)
-//			continue
-//		}
-//		if resp.Ret != 200 {
-//			fmt.Println(v.FutureGoodEdbName, "添加 失败 ,msg:", resp.Msg, ";errMsg:", resp.ErrMsg)
-//		}
-//	}
-//
-//	fmt.Println("end")
-//}
-
-// 添加海外交易所
-//func init() {
-//	exchangeName := `新加坡证券（SGX）`
-//	suffix := ".SGX"
-//	type TmpStruct struct {
-//		Name  string
-//		Code  string
-//		Year  int
-//		Month int
-//	}
-//	str := `TSI铁矿石指数	FEF	SGX	2612`
-//	list := make([]TmpStruct, 0)
-//
-//	strList := strings.Split(str, `
-//`)
-//	//fmt.Println(strList)
-//	for _, v := range strList {
-//		v = strings.TrimPrefix(v, "\t")
-//		tmp := strings.Split(v, `	`)
-//		fmt.Println(tmp)
-//
-//		year, err := strconv.Atoi(tmp[3][0:2])
-//		if err != nil {
-//			fmt.Println(err)
-//			return
-//		}
-//		//fmt.Println(year)
-//		month, err := strconv.Atoi(tmp[3][2:4])
-//		if err != nil {
-//			fmt.Println(err)
-//			return
-//		}
-//		//fmt.Println(month)
-//
-//		tmpStruct := TmpStruct{
-//			Name:  tmp[0],
-//			Code:  tmp[1],
-//			Year:  year,
-//			Month: month,
-//		}
-//		list = append(list, tmpStruct)
-//	}
-//
-//	//T03
-//	//suffix := ".CMX"
-//	//1、@CL0W.NMX[NYMEX美原油电子盘主力（持仓量）合约]
-//	//2、@CL23J.NMX[NYMEX美原油电子盘2304]
-//	//yearList := []int{2023, 2024, 2025, 2026, 2027, 2028}
-//	monthList := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
-//	startMonth := 3
-//	//endMonth := 5
-//
-//	monthCodeStrList := []string{"F", "G", "H", "J", "K", "M", "N", "Q", "U", "V", "X", "Z"}
-//	//monthStrList := []string{"(1月)", "(2月)", "(3月)", "(4月)", "(5月)", "(6月)", "(7月)", "(8月)", "(9月)", "(10月)", "(11月)", "(12月)"}
-//
-//	for k, v := range list {
-//		yearList := make([]int, 0)
-//		for i := 23; i <= v.Year; i++ {
-//			yearList = append(yearList, i+2000)
-//		}
-//		//fmt.Println(yearList)
-//		//return
-//		endMonth := v.Month
-//
-//		code := v.Code + `0W` + suffix
-//		tmpFutureGoodEdbInfo := &future_good2.FutureGoodEdbInfo{
-//			//FutureGoodEdbInfoId: 0,
-//			FutureGoodEdbCode:   code,
-//			FutureGoodEdbName:   v.Name,
-//			FutureGoodEdbNameEn: v.Name,
-//			ParentId:            0,
-//			RegionType:          `海外`,
-//			Exchange:            exchangeName,
-//			Year:                0,
-//			Month:               0,
-//			StartDate:           "",
-//			EndDate:             "",
-//			MinValue:            0,
-//			MaxValue:            0,
-//			LatestValue:         0,
-//			//LatestDate:          time.Time{},
-//			ServerUrl:  "",
-//			CreateTime: time.Now(),
-//			ModifyTime: time.Now(),
-//		}
-//		err := future_good2.AddFutureGoodEdbInfo(tmpFutureGoodEdbInfo)
-//		if err != nil {
-//			fmt.Println("添加指标:", k, "失败,err:", err)
-//			continue
-//		}
-//
-//		lastYearIndex := len(yearList) - 1
-//		for yearIndex, year := range yearList {
-//			for index, month := range monthList {
-//				// 如果第一年的开始月份早于约定的开始月份，那么就退出这个循环，进入下一个循环
-//				if yearIndex == 0 && month < startMonth {
-//					continue
-//				}
-//				// 如果最一年的结束月份晚于约定的开始月份，那么就退出这个循环，进入下一个循环
-//				if lastYearIndex == yearIndex && month > endMonth {
-//					break
-//				}
-//				monthStr := strconv.Itoa(month)
-//				if month < 10 {
-//					monthStr = `0` + monthStr
-//				}
-//				yearStr := strconv.Itoa(year - 2000)
-//				yearMonthStr := yearStr + monthStr
-//
-//				code2 := v.Code + yearStr + monthCodeStrList[index] + suffix
-//				name := tmpFutureGoodEdbInfo.FutureGoodEdbName + `(` + yearMonthStr + `)`
-//				tmpFutureGoodEdbInfo2 := &future_good2.FutureGoodEdbInfo{
-//					//FutureGoodEdbInfoId: 0,
-//					FutureGoodEdbCode:   code2,
-//					FutureGoodEdbName:   name,
-//					FutureGoodEdbNameEn: name,
-//					ParentId:            tmpFutureGoodEdbInfo.FutureGoodEdbInfoId,
-//					RegionType:          `海外`,
-//					Exchange:            exchangeName,
-//					Year:                year,
-//					Month:               month,
-//					StartDate:           "",
-//					EndDate:             "",
-//					MinValue:            0,
-//					MaxValue:            0,
-//					LatestValue:         0,
-//					//LatestDate:          time.Time{},
-//					ServerUrl:  "",
-//					CreateTime: time.Now(),
-//					ModifyTime: time.Now(),
-//				}
-//				err = future_good2.AddFutureGoodEdbInfo(tmpFutureGoodEdbInfo2)
-//				if err != nil {
-//					fmt.Println("添加子指标:", name, "失败,err:", err)
-//					continue
-//				}
-//			}
-//		}
-//
-//	}
-//
-//	fmt.Println("end")
-//}
-
-// 刷新海外交易所数据
-//func init() {
-//	var condition string
-//	var pars []interface{}
-//
-//	//condition += ` AND parent_id > ? AND start_date= ? `
-//	condition += ` AND region_type = ? AND start_date= ?  AND exchange = ? `
-//	pars = append(pars, "海外", "0000-00-00", "伦敦金属（LME）")
-//	//condition += ` AND region_type = ? AND start_date= ?  `
-//	//pars = append(pars, "海外", "0000-00-00")
-//
-//	list, err := future_good2.GetFutureGoodEdbInfoList(condition, pars)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//
-//	errIdList := make([]string, 0)
-//	for _, v := range list {
-//		fmt.Println(v)
-//		resp, err := future_good.AddEdbData(v.FutureGoodEdbCode)
-//		if err != nil {
-//			fmt.Println(v.FutureGoodEdbName, "添加 异常 ,err:", err)
-//			continue
-//		}
-//		if resp.Ret != 200 {
-//			errIdList = append(errIdList, fmt.Sprint(v.FutureGoodEdbInfoId))
-//			fmt.Println(v.FutureGoodEdbName, "添加 失败 ,msg:", resp.Msg, ";errMsg:", resp.ErrMsg)
-//		}
-//	}
-//
-//	fmt.Println("end")
-//	fmt.Println(strings.Join(errIdList, ","))
-//}
-
-// 刷新海外交易所数据
-//func init() {
-//	var condition string
-//	var pars []interface{}
-//
-//	//condition += ` AND parent_id > ? AND start_date= ? `
-//	condition += ` AND region_type = ? AND parent_id != 0 and future_good_edb_type = 1`
-//	pars = append(pars, "海外")
-//	//condition += ` AND region_type = ? AND start_date= ?  `
-//	//pars = append(pars, "海外", "0000-00-00")
-//
-//	list, err := future_good2.GetFutureGoodEdbInfoList(condition, pars)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//	for _, v := range list {
-//		//fmt.Println(v.FutureGoodEdbName)
-//		tmpList := strings.Split(v.FutureGoodEdbName, "(")
-//		//fmt.Println(tmpList)
-//		//fmt.Println(tmpList[1])
-//		year, err := strconv.Atoi(tmpList[1][0:2])
-//		if err != nil {
-//			fmt.Println(err)
-//			return
-//		}
-//		v.Year = year + 2000
-//		err = v.Update([]string{"Year"})
-//		if err != nil {
-//			fmt.Println(err)
-//			return
-//		}
-//	}
-//	fmt.Println("end")
-//}

controllers/data_manage/manual.go

@@ -627,30 +627,3 @@ func (this *ManualController) AllClassifyList() {
 	br.Msg = "获取成功"
 	br.Data = list
 }
-
-//func init() {
-//	fmt.Println("start")
-//	adminId:=137
-//	setList, err := data_manage.GetManualUserSetClassify(adminId)
-//	if err != nil {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//	listLen := len(setList)
-//	classifyArr := make([]string, 0)
-//	for i := 0; i < listLen; i++ {
-//		classifyArr = append(classifyArr, strconv.Itoa(setList[i].ClassifyId))
-//	}
-//	classifyIdStr := strings.Join(classifyArr, ",")
-//	condition := ""
-//	if classifyIdStr != "" {
-//		condition += ` AND classify_id IN(` + classifyIdStr + `)`
-//	}
-//	items, err := data_manage.GetManualClassifyAllByCondition(condition)
-//	if err != nil {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//	fmt.Println(items)
-//	fmt.Println("end")
-//}

controllers/data_manage/multiple_graph_config.go

@@ -1598,247 +1598,3 @@ func (this *ChartInfoController) GetMultipleGraphConfig() {
 	br.Data = resp
 	br.IsAddLog = true
 }
-
-//	func init() {
-//		//correlationChart := new(data_manage.ChartInfoCorrelation)
-//
-//		condition := ` AND source = 3 `
-//		list, err := data_manage.GetChartListByCondition(condition, []interface{}{}, 0, 1000)
-//		if err != nil {
-//			fmt.Println("err:", err)
-//			return
-//		}
-//		timeNowFormat := time.Now().Format(utils.FormatDate)
-//		for _, v := range list {
-//			item, tmpErr := data_manage.GetMultipleGraphConfigChartMappingByChartIdAndSource(v.ChartInfoId)
-//			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-//				fmt.Println("tmpErr:", tmpErr)
-//				continue
-//			}
-//			if item == nil {
-//				correlationChart := new(data_manage.ChartInfoCorrelation)
-//				e := correlationChart.GetItemById(v.ChartInfoId)
-//				if e != nil {
-//					fmt.Println("获取历史配置失败:", e)
-//					continue
-//				}
-//				day, _ := utils.GetDaysBetween2Date(utils.FormatDate, timeNowFormat, correlationChart.StartDate.Format(utils.FormatDate))
-//				req := request.SaveMultipleGraphConfigReq{
-//					MultipleGraphConfigId: 0,
-//					EdbInfoIdA:            correlationChart.EdbInfoIdFirst,
-//					EdbInfoIdB:            correlationChart.EdbInfoIdSecond,
-//					Curve:                 data_manage.CurveConfig{},
-//					Correlation: data_manage.CorrelationConfig{
-//						LeadValue:      correlationChart.LeadValue,
-//						LeadUnit:       correlationChart.LeadUnit,
-//						CalculateValue: day,
-//						CalculateUnit:  "天",
-//					},
-//					RollingCorrelation: []data_manage.RollingCorrelationConfig{
-//						{}, {},
-//					},
-//				}
-//				curveStrByte, _ := json.Marshal(req.Curve)
-//				correlationStrByte, _ := json.Marshal(req.Correlation)
-//				rollingCorrelationStrByte, _ := json.Marshal(req.RollingCorrelation)
-//
-//				multipleGraphConfig := &data_manage.MultipleGraphConfig{
-//					//MultipleGraphConfigId: 0,
-//					EdbInfoIdA:         req.EdbInfoIdA,
-//					EdbInfoIdB:         req.EdbInfoIdB,
-//					Curve:              string(curveStrByte),
-//					Correlation:        string(correlationStrByte),
-//					RollingCorrelation: string(rollingCorrelationStrByte),
-//					SysUserId:          v.SysUserId,
-//					SysUserRealName:    v.SysUserRealName,
-//					ModifyTime:         v.ModifyTime,
-//					CreateTime:         v.CreateTime,
-//				}
-//				err = data_manage.AddMultipleGraphConfig(multipleGraphConfig)
-//
-//				if err != nil {
-//					fmt.Println(v.ChartInfoId, "创建配置失败：", err)
-//					continue
-//				}
-//
-//				multipleGraphConfigChartMapping := &data_manage.MultipleGraphConfigChartMapping{
-//					//Id:                    0,
-//					MultipleGraphConfigId: multipleGraphConfig.MultipleGraphConfigId,
-//					ChartInfoId:           v.ChartInfoId,
-//					Source:                2,
-//					ModifyTime:            time.Now(),
-//					CreateTime:            time.Now(),
-//				}
-//				err = data_manage.AddMultipleGraphConfigChartMapping(multipleGraphConfigChartMapping)
-//				if err != nil {
-//					fmt.Println(v.ChartInfoId, "保存配置与图表的关联关系失败：", err)
-//				}
-//
-//				correlationChart.CalculateUnit = "天"
-//				correlationChart.CalculateValue = day
-//				err = correlationChart.Update([]string{"CalculateUnit", "CalculateValue"})
-//				if err != nil {
-//					fmt.Println(v.ChartInfoId, "修复历史数据失败：", err)
-//				}
-//			}
-//		}
-//	}
-
-// 修复相关性图表与滚动相关性图表的强关联关系
-//func init() {
-//	condition := ` AND source =  ? `
-//	pars := []interface{}{utils.CHART_SOURCE_ROLLING_CORRELATION}
-//	list, err := data_manage.GetChartListByCondition(condition, pars, 0, 1000)
-//	if err != nil {
-//		fmt.Println("err:", err)
-//		return
-//	}
-//	for _, chartInfo := range list {
-//		multipleGraphConfigChartMapping, e := data_manage.GetMultipleGraphConfigChartMappingByChartId(chartInfo.ChartInfoId)
-//		if e != nil {
-//			fmt.Println(chartInfo.ChartInfoId, ";获取滚动相关性图表的配置信息失败, Err:"+e.Error())
-//			continue
-//		}
-//		baseChartMultipleGraphConfigChartMapping, e := data_manage.GetMultipleGraphConfigChartMappingByIdAndSource(multipleGraphConfigChartMapping.MultipleGraphConfigId, 2)
-//		if e != nil {
-//			fmt.Println(chartInfo.ChartInfoId, ";获取相关性图表的配置信息失败, Err:"+e.Error())
-//			continue
-//		}
-//		baseChartCorrelationChart := new(data_manage.ChartInfoCorrelation)
-//		if e := baseChartCorrelationChart.GetItemById(baseChartMultipleGraphConfigChartMapping.ChartInfoId); e != nil {
-//			fmt.Println(chartInfo.ChartInfoId, ";获取基础相关性图表信息失败, Err:"+e.Error())
-//			continue
-//		}
-//
-//		// 自己的配置
-//		selfChartCorrelationChart := new(data_manage.ChartInfoCorrelation)
-//		if e := selfChartCorrelationChart.GetItemById(chartInfo.ChartInfoId); e != nil {
-//			fmt.Println(chartInfo.ChartInfoId, ";获取自己的相关性图表信息失败, Err:"+e.Error())
-//			continue
-//		}
-//
-//		selfChartCorrelationChart.BaseCalculateUnit = baseChartCorrelationChart.CalculateUnit
-//		selfChartCorrelationChart.BaseCalculateValue = baseChartCorrelationChart.CalculateValue
-//		err = selfChartCorrelationChart.Update([]string{"BaseCalculateUnit", "BaseCalculateValue"})
-//		if err != nil {
-//			fmt.Println(chartInfo.ChartInfoId, ";更新相关性图表信息失败, Err:"+err.Error())
-//			continue
-//		}
-//	}
-//
-//}
-
-// 修复相关性图表与滚动相关性图表的强关联关系
-//func init() {
-//	{
-//		condition := ` AND source =  ? `
-//		pars := []interface{}{utils.CHART_SOURCE_ROLLING_CORRELATION}
-//		list, err := data_manage.GetChartListByCondition(condition, pars, 0, 1000)
-//		if err != nil {
-//			fmt.Println("err:", err)
-//			return
-//		}
-//		for _, chartInfo := range list {
-//			multipleGraphConfigChartMapping, e := data_manage.GetMultipleGraphConfigChartMappingByChartId(chartInfo.ChartInfoId)
-//			if e != nil {
-//				fmt.Println(chartInfo.ChartInfoId, ";获取滚动相关性图表的配置信息失败, Err:"+e.Error())
-//				continue
-//			}
-//			multipleGraphConfig, e := data_manage.GetMultipleGraphConfigById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
-//			if e != nil {
-//				fmt.Println(chartInfo.ChartInfoId, ";获取相关性图表的配置信息失败, Err:"+e.Error())
-//				continue
-//			}
-//			var curveConf data_manage.CurveConfig
-//			e = json.Unmarshal([]byte(multipleGraphConfig.Curve), &curveConf)
-//			if e != nil {
-//				fmt.Println(chartInfo.ChartInfoId, ";格式化曲线图数据失败, Err:"+e.Error())
-//				continue
-//			}
-//
-//			// 自己的配置
-//			selfChartCorrelationChart := new(data_manage.ChartInfoCorrelation)
-//			if e := selfChartCorrelationChart.GetItemById(chartInfo.ChartInfoId); e != nil {
-//				fmt.Println(chartInfo.ChartInfoId, ";获取自己的相关性图表信息失败, Err:"+e.Error())
-//				continue
-//			}
-//
-//			selfChartCorrelationChart.DateType = curveConf.DateType
-//
-//			startDate, endDate := utils.GetDateByDateType(curveConf.DateType, curveConf.StartDate, curveConf.EndDate)
-//			if startDate != `` {
-//				startDateTime, e := time.ParseInLocation(utils.FormatDate, startDate, time.Local)
-//				if e != nil {
-//					fmt.Println(chartInfo.ChartInfoId, ";开始日期格式化失败，开始日期：", startDate, ", Err:"+e.Error())
-//					continue
-//				}
-//				selfChartCorrelationChart.StartDate = startDateTime
-//			}
-//			if endDate != `` {
-//				endDateTime, e := time.ParseInLocation(utils.FormatDate, endDate, time.Local)
-//				if e != nil {
-//					fmt.Println(chartInfo.ChartInfoId, ";开始日期格式化失败，开始日期：", startDate, ", Err:"+e.Error())
-//					continue
-//				}
-//				selfChartCorrelationChart.EndDate = endDateTime
-//			}
-//			err = selfChartCorrelationChart.Update([]string{"DateType", "StartDate", "EndDate"})
-//			if err != nil {
-//				fmt.Println(chartInfo.ChartInfoId, ";更新相关性图表信息失败, Err:"+err.Error())
-//				continue
-//			}
-//		}
-//
-//		fmt.Println("图表更新完成")
-//	}
-//
-//	{
-//		// 更新指标
-//		condition := ` AND source =  ? `
-//		pars := []interface{}{utils.DATA_SOURCE_CALCULATE_CORRELATION}
-//		list, err := data_manage.GetEdbInfoListV2ByCondition(condition, pars, 0, 10000)
-//		if err != nil {
-//			fmt.Println("err:", err)
-//			return
-//		}
-//		for _, edbInfo := range list {
-//			multipleGraphConfigEdbMappingInfo, e := data_manage.GetMultipleGraphConfigEdbMappingByEdbInfoId(edbInfo.EdbInfoId)
-//			if e != nil {
-//				fmt.Println(edbInfo.EdbInfoId, ";获取滚动相关性指标的配置信息失败, Err:"+e.Error())
-//				continue
-//			}
-//			multipleGraphConfig, e := data_manage.GetMultipleGraphConfigById(multipleGraphConfigEdbMappingInfo.MultipleGraphConfigId)
-//			if e != nil {
-//				fmt.Println(edbInfo.EdbInfoId, ";获取相关性图表的配置信息失败, Err:"+e.Error())
-//				continue
-//			}
-//
-//			// 曲线图配置
-//			var curveConf data_manage.CurveConfig
-//			e = json.Unmarshal([]byte(multipleGraphConfig.Curve), &curveConf)
-//			if e != nil {
-//				fmt.Println(edbInfo.EdbInfoId, ";格式化曲线图数据失败, Err:"+e.Error())
-//				continue
-//			}
-//
-//			var formulaConf request.EdbCalculateFormula
-//			e = json.Unmarshal([]byte(edbInfo.CalculateFormula), &formulaConf)
-//			if e != nil {
-//				fmt.Println(edbInfo.EdbInfoId, ";格式化指标计算配置数据失败, Err:"+e.Error())
-//				continue
-//			}
-//			formulaConf.DateType = curveConf.DateType
-//			formulaConf.StartDate = curveConf.StartDate
-//			formulaConf.EndDate = curveConf.EndDate
-//			calculateFormulaByte, err := json.Marshal(formulaConf)
-//			edbInfo.CalculateFormula = string(calculateFormulaByte)
-//			err = edbInfo.Update([]string{"CalculateFormula"})
-//			if err != nil {
-//				fmt.Println(edbInfo.EdbInfoId, ";更新指标信息失败, Err:"+err.Error())
-//				continue
-//			}
-//		}
-//
-//		fmt.Println("指标更新完成")
-//	}
-//}

controllers/data_manage/my_chart.go

@@ -2250,10 +2250,6 @@ func (this *MyChartController) CompanyPublicClassifyList() {
 	br.Data = resp
 }
 
-//func init() {
-//	data.AddAllMyChartInfo()
-//}
-
 // ClassifyFrameworkNodeList
 // @Title 我的图表分类-关联的框架节点列表
 // @Description 我的图表分类-关联的框架节点列表

controllers/data_manage/predict_edb_classify.go

@@ -138,7 +138,7 @@ func (this *PredictEdbClassifyController) Items() {
 		this.Data["json"] = br
 		this.ServeJSON()
 	}()
-	rootList, err := data_manage.GetEdbClassifyByParentId(0, 1)
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, utils.EdbClassifyTypePredict, this.SysUser.AdminId)
 	if err != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()
@@ -701,7 +701,7 @@ func (this *PredictEdbClassifyController) SimpleList() {
 		sysUserId = this.SysUser.AdminId
 	}
 
-	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, 1)
+	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, utils.EdbClassifyTypePredict, this.SysUser.AdminId)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()

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, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, 1, 0, this.SysUser.AdminId)
+
 		isEs = true
 	} else {
 		var condition string

controllers/data_manage/wind_data.go

@@ -28,7 +28,7 @@ func (this *EdbInfoController) WindClassify() {
 	// 增加标识判断是文件夹还是指标列表
 	parentId, _ := this.GetInt("ParentId")
 	// 特殊处理顶级分类
-	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, 0)
+	rootList, err := data_manage.GetEdbClassifyByParentId(parentId, 0, 0)
 	if err != nil && !utils.IsErrNoRow(err) {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取数据失败，Err:" + err.Error()

controllers/fix.go

@@ -0,0 +1,351 @@
+package controllers
+
+import (
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/services/data"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// init
+// @Description: 数据修复
+// @author: Roc
+// @datetime 2024-12-02 09:29:56
+func init() {
+	// ### 1、先修复分类完整路径
+	//initFixClassifyPath()
+
+	// ### 2、再修复个人分类、删除不存在指标的分类
+	// ### 2.1 数据加工
+	//initFixSelfClassify(utils.EdbClassifyTypeCalculate)
+
+	// ### 2.2 衍生指标
+	//initFixSelfClassify(utils.EdbClassifyTypePredict)
+}
+
+// initFixClassifyPath
+// @Description: 修复分类完整路径
+// @author: Roc
+// @datetime 2024-11-26 15:40:57
+func initFixClassifyPath() {
+	allList := make([]*data_manage.EdbClassifyItems, 0)
+	allList, e := data_manage.GetEdbClassifyByClassifyTypes([]int{utils.EdbClassifyTypeBase, utils.EdbClassifyTypePredict, utils.EdbClassifyTypeCalculate})
+	if e != nil {
+		fmt.Println("获取分类失败", e)
+		return
+	}
+
+	var sortList data_manage.EdbClassifyItemList
+
+	allList = data.GetClassifyTreeRecursive(allList, 0)
+	//根据sort值排序
+	sortList = allList
+	sort.Sort(sortList)
+
+	for _, v := range sortList {
+		updatePath(v, "", "")
+	}
+	fmt.Println("修复分类路径完成")
+}
+
+func updatePath(item *data_manage.EdbClassifyItems, classifyNamePath, classifyIdPath string) {
+	if classifyNamePath == `` {
+		classifyNamePath = item.ClassifyName
+		classifyIdPath = fmt.Sprint(item.ClassifyId)
+	} else {
+		classifyNamePath = fmt.Sprint(classifyNamePath, "|", item.ClassifyName)
+		classifyIdPath = fmt.Sprint(classifyIdPath, ",", item.ClassifyId)
+	}
+	err := data_manage.UpdateEdbClassify(item.ClassifyId, classifyNamePath, classifyIdPath)
+	if err != nil {
+		fmt.Println(item.ClassifyId, ";更新失败", err)
+	}
+	if item.Children != nil {
+		for _, v := range item.Children {
+			updatePath(v, classifyNamePath, classifyIdPath)
+		}
+	}
+}
+
+// initFixUserClassify
+// @Description: initFixUserClassify
+// @author: Roc
+// @datetime 2024-11-29 16:57:54
+func initFixSelfClassify(classifyType int) {
+	// 指标数据明细
+	condition := ` AND edb_info_type = 0 and edb_type = 2 `
+	if classifyType == utils.EdbClassifyTypePredict {
+		condition = ` AND edb_info_type = 1 `
+	}
+
+	pars := make([]interface{}, 0)
+	edbList, err := data_manage.GetEdbInfoListByCond(condition, pars)
+	if err != nil {
+		fmt.Println("查找指标加工数据失败", err.Error())
+		return
+	}
+
+	edbClassifyIdMap := make(map[int]bool)
+	classifyIdList := make([]int, 0)
+
+	edbUserMap := make(map[int]string)
+
+	for _, v := range edbList {
+		if _, ok := edbClassifyIdMap[v.ClassifyId]; !ok {
+			classifyIdList = append(classifyIdList, v.ClassifyId)
+			edbClassifyIdMap[v.ClassifyId] = true
+		}
+
+		edbUserMap[v.SysUserId] = v.SysUserRealName
+	}
+
+	// 获取所有数据加工的分类
+	classifyList, err := data_manage.GetAllEdbClassifyByType(classifyType)
+	if err != nil {
+		fmt.Println("获取数据加工分类失败", err.Error())
+		return
+	}
+
+	hasClassifyIdStrList := make([]string, 0)
+	for _, v := range classifyList {
+		// 判断当前分类id是否加到指标中，如果加进去了，那么才处理
+		_, ok := edbClassifyIdMap[v.ClassifyId]
+		if !ok {
+			continue
+		}
+		hasClassifyIdStrList = append(hasClassifyIdStrList, v.ClassifyIdPath)
+	}
+	classifyIdStrList := strings.Split(strings.Join(hasClassifyIdStrList, ","), ",")
+	classifyIdMap := make(map[string]bool)
+	for _, v := range classifyIdStrList {
+		classifyIdMap[v] = true
+	}
+	newClassifyList := make([]*data_manage.EdbClassifyItems, 0)
+	newClassifyMap := make(map[string]bool)
+	for _, v := range classifyList {
+		classifyIdStr := fmt.Sprint(v.ClassifyId)
+
+		// 是否在关联指标的map里面，如果不在的话，那么就过滤
+		_, ok := classifyIdMap[classifyIdStr]
+		if !ok {
+			continue
+		}
+
+		// 是否已经加到需要关联指标分类的map里面，如果已经在了，那么也过滤
+		_, ok = newClassifyMap[classifyIdStr]
+		if ok {
+			continue
+		}
+
+		newClassifyMap[classifyIdStr] = true
+		newClassifyList = append(newClassifyList, v)
+	}
+
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), 0)
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+	for k := range rootList {
+		rootNode := rootList[k]
+		data.EdbClassifyItemsMakeTree(newClassifyList, rootNode)
+		nodeAll = append(nodeAll, rootNode)
+	}
+
+	// 创建新的分类
+	// [用户id][原分类id][新分类id]
+	userClassifyIdMap := make(map[int]map[int]int)
+	for userId, sysUserName := range edbUserMap {
+		classifyRelationMap := make(map[int]int)
+		for _, v := range nodeAll {
+			createNewClassify(userId, 0, 0, 0, sysUserName, ``, ``, v, classifyRelationMap)
+		}
+		userClassifyIdMap[userId] = classifyRelationMap
+	}
+
+	// ##### 第二步，指标数据迁移
+
+	// 指标数据迁移
+	for _, v := range edbList {
+		userClassifyMap, ok := userClassifyIdMap[v.SysUserId]
+		if !ok {
+			fmt.Println("找不到该用户所属的分类，userId:", v.SysUserId)
+			continue
+		}
+
+		newClassifyId, ok := userClassifyMap[v.ClassifyId]
+		if !ok {
+			fmt.Println("找不到该用户所属的分类，classifyId:", v.ClassifyId)
+			continue
+		}
+		// 开始迁移指标数据
+		err = data_manage.UpdateClassifyIdByEdbInfoId(v.EdbInfoId, newClassifyId)
+		if err != nil {
+			fmt.Println("指标数据迁移失败", err.Error())
+		}
+	}
+
+	// ##### 3、开始删除没有指标的分类
+	deleteNullClassify(classifyType)
+	return
+}
+
+func deleteNullClassify(classifyType int) {
+	// 指标列表数据
+	condition := ` AND edb_info_type = 0 and edb_type = 2 `
+	if classifyType == utils.EdbClassifyTypePredict {
+		condition = ` AND edb_info_type = 1 `
+	}
+
+	pars := make([]interface{}, 0)
+	edbList, err := data_manage.GetEdbInfoListByCond(condition, pars)
+	if err != nil {
+		fmt.Println("查找指标加工数据失败", err.Error())
+		return
+	}
+
+	edbClassifyIdMap := make(map[int]bool)
+	classifyIdList := make([]int, 0)
+
+	for _, v := range edbList {
+		if _, ok := edbClassifyIdMap[v.ClassifyId]; !ok {
+			classifyIdList = append(classifyIdList, v.ClassifyId)
+			edbClassifyIdMap[v.ClassifyId] = true
+		}
+	}
+
+	// 获取所有数据加工的分类
+	classifyList, err := data_manage.GetAllEdbClassifyByType(classifyType)
+	if err != nil {
+		fmt.Println("获取数据加工分类失败", err.Error())
+		return
+	}
+
+	// 存在指标的分类
+	hasEdbClassifyList := make([]*data_manage.EdbClassifyItems, 0)
+	for _, v := range classifyList {
+		if _, ok := edbClassifyIdMap[v.ClassifyId]; ok {
+			hasEdbClassifyList = append(hasEdbClassifyList, v)
+		}
+	}
+
+	// 待删除的分类id集合
+	deleteClassifyIdMap := make(map[int]int)
+	// 全部的分类id集合
+	for _, v := range classifyList {
+		deleteClassifyIdMap[v.ClassifyId] = v.ClassifyId
+	}
+
+	// 存在指标的的分类id集合
+	hasClassifyIdStrList := make([]string, 0)
+	for _, v := range hasEdbClassifyList {
+		hasClassifyIdStrList = append(hasClassifyIdStrList, v.ClassifyIdPath)
+	}
+	classifyIdStrList := strings.Split(strings.Join(hasClassifyIdStrList, ","), ",")
+	for _, v := range classifyIdStrList {
+		classifyId, err := strconv.Atoi(v)
+		if err != nil {
+			fmt.Println("分类字符串转int失败，", err.Error())
+			return
+		}
+		delete(deleteClassifyIdMap, classifyId)
+	}
+
+	// 删除空分类
+	if len(deleteClassifyIdMap) > 0 {
+		deleteClassifyIdList := make([]int, 0)
+		for _, v := range deleteClassifyIdMap {
+			deleteClassifyIdList = append(deleteClassifyIdList, v)
+		}
+
+		err = data_manage.DelEdbClassifyByIdList(deleteClassifyIdList)
+		if err != nil {
+			fmt.Println("删除空分类失败", err.Error())
+			return
+		}
+	}
+}
+
+// createNewClassify
+// @Description: 创建分类
+// @author: Roc
+// @datetime 2024-11-29 17:57:47
+// @param userId int
+// @param parentId int
+// @param rootId int
+// @param level int
+// @param sysUserName string
+// @param parentClassifyNamePath string
+// @param parentClassifyIdPath string
+// @param node *data_manage.EdbClassifyItems
+// @param classifyRelationMap map[int]int
+func createNewClassify(userId, parentId, rootId, level int, sysUserName, parentClassifyNamePath, parentClassifyIdPath string, node *data_manage.EdbClassifyItems, classifyRelationMap map[int]int) {
+	var classifyNamePath, classifyIdPath string
+
+	if parentId > 0 {
+		classifyNamePath = fmt.Sprint(parentClassifyNamePath, "|", node.ClassifyName)
+		classifyIdPath = fmt.Sprint(parentClassifyIdPath, ",")
+	} else {
+		classifyNamePath = node.ClassifyName
+	}
+
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	classifyInfo := &data_manage.EdbClassify{
+		//ClassifyId:      0,
+		ClassifyType:     node.ClassifyType,
+		ClassifyName:     node.ClassifyName,
+		ClassifyNameEn:   node.ClassifyNameEn,
+		ParentId:         parentId,
+		RootId:           rootId,
+		HasData:          1,
+		CreateTime:       time.Now(),
+		ModifyTime:       time.Now(),
+		SysUserId:        userId,
+		SysUserRealName:  sysUserName,
+		Level:            level + 1,
+		UniqueCode:       utils.MD5(utils.DATA_PREFIX + "_" + timestamp),
+		Sort:             node.Sort,
+		ClassifyNamePath: classifyNamePath,
+	}
+	err := data_manage.AddEdbClassify(classifyInfo)
+	if err != nil {
+		fmt.Println("创建分类失败：", err.Error())
+		return
+	}
+	// 更改分类id完整路径path
+	classifyInfo.ClassifyIdPath = fmt.Sprint(classifyIdPath, classifyInfo.ClassifyId)
+	_ = classifyInfo.Update([]string{"ClassifyIdPath"})
+
+	classifyRelationMap[node.ClassifyId] = classifyInfo.ClassifyId
+
+	if rootId <= 0 {
+		rootId = classifyInfo.ClassifyId
+	}
+	level = classifyInfo.Level
+
+	if node.Children == nil {
+		return
+	}
+	if len(node.Children) <= 0 {
+		return
+	}
+	for _, child := range node.Children {
+		createNewClassify(userId, parentId, rootId, level, sysUserName, classifyNamePath, classifyIdPath, child, classifyRelationMap)
+	}
+
+	return
+}
+
+// initEs
+// @Description: 修复ES中的指标和图表数据
+// @author: Roc
+// @datetime 2024-11-29 16:18:02
+func initEs() {
+	// 更新ES中的指标数据
+	data.AddOrEditAllEdbInfoToEs()
+	// 更新es中的图表数据
+	data.AddAllChartInfo()
+
+	fmt.Println("全部es数据修复完成")
+}

controllers/sys_admin.go

@@ -890,20 +890,6 @@ func (this *SysAdminController) Delete() {
 	br.Msg = "删除成功"
 }
 
-/*
-func init() {
-	fmt.Println("start")
-	pwdStr:=`11111`
-	//compile := `(\d+.*[^a-zA-Z]+){6,12}|([^a-zA-Z]+.*\d+){6,12}`
-	compile := `([0-9a-z]+){6,12}|(a-z0-9]+){6,12}`
-	///^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,12}$/
-	///^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,12}$/
-	reg := regexp.MustCompile(compile)
-	flag := reg.MatchString(pwdStr)
-	fmt.Println(flag)
-	fmt.Println("end")
-}*/
-
 // SetConfig
 // @Title 用户信息配置接口
 // @Description 用户信息配置接口

models/data_manage/edb_classify.go

@@ -159,9 +159,14 @@ DELETE
 	return
 }
 
-func GetEdbClassifyByParentId(parentId int, classifyType int8) (items []*EdbClassifyItems, err error) {
+func GetEdbClassifyByParentId(parentId int, classifyType int8, sysUserId int) (items []*EdbClassifyItems, err error) {
 	o := global.DmSQL["data"]
-	sql := ` SELECT * FROM edb_classify WHERE parent_id=? AND classify_type = ?  order by sort asc,classify_id asc`
+	sql := ` SELECT * FROM edb_classify WHERE parent_id=? AND classify_type = ? `
+
+	if sysUserId > 0 {
+		sql += fmt.Sprintf(` AND sys_user_id = %d `, sysUserId)
+	}
+	sql += ` order by sort asc,classify_id asc `
 	err = o.Raw(sql, parentId, classifyType).Scan(&items).Error
 
 	return
@@ -209,8 +214,9 @@ func GetAllEdbClassifyByType(classifyType int) (items []*EdbClassifyItems, err e
 }
 
 type EdbClassifyItems struct {
-	ClassifyId       int `description:"分类id"`
-	EdbInfoId        int `description:"指标id"`
+	ClassifyId       int   `description:"分类id"`
+	EdbInfoId        int   `description:"指标id"`
+	ClassifyType     uint8 `description:"分类类型，0：普通指标分类，1：预测指标分类"`
 	ClassifyName     string
 	ClassifyNameEn   string
 	ParentId         int
@@ -229,6 +235,7 @@ type EdbClassifyItems struct {
 	Button           EdbClassifyItemsButton `gorm:"-" description:"操作权限"`
 	IsJoinPermission int                    `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
 	HaveOperaAuth    bool                   `description:"是否有数据权限"`
+	ClassifyIdPath   string                 `description:"分类的完整路径，格式为：父级ID,当前ID"`
 }
 
 type EdbClassifyIdItems struct {
@@ -518,9 +525,16 @@ func GetEdbClassifyRootIdsByClassifyIds(classifyIds []int) (items []int, err err
 }
 
 // GetChildEdbClassifyByClassifyType 根据类型获取非顶级分类
-func GetChildEdbClassifyByClassifyType(classifyType int) (items []*EdbClassifyItems, err error) {
+func GetChildEdbClassifyByClassifyType(classifyType, sysUserId int) (items []*EdbClassifyItems, err error) {
 	o := global.DmSQL["data"]
-	sql := `SELECT * FROM edb_classify WHERE parent_id <> 0 AND classify_type = ? ORDER BY sort ASC,classify_id ASC`
+	sql := `SELECT * FROM edb_classify WHERE parent_id <> 0 AND classify_type = ?`
+
+	if sysUserId > 0 {
+		sql += fmt.Sprintf(` AND sys_user_id = %d `, sysUserId)
+	}
+
+	sql += ` ORDER BY sort ASC,classify_id ASC `
+
 	err = o.Raw(sql, classifyType).Find(&items).Error
 	return
 }
@@ -620,3 +634,20 @@ func UpdateEdbClassify(classifyId int, classifyNamePath, classifyIdPath string)
 
 	return
 }
+
+// DelEdbClassifyByIdList
+// @Description: 根据id删除分类
+// @author: Roc
+// @datetime 2024-12-02 09:27:26
+// @param idList []int
+// @return err error
+func DelEdbClassifyByIdList(idList []int) (err error) {
+	num := len(idList)
+	if num <= 0 {
+		return
+	}
+	sql := `DELETE  FROM edb_classify  WHERE classify_id IN (?) `
+	err = global.DmSQL["data"].Exec(sql, idList).Error
+
+	return
+}

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,8 @@ type EdbInfoList struct {
 	HaveOperaAuth         bool                    `description:"是否有数据权限，默认：false"`
 	IsSupplierStop        int                     `description:"是否供应商停更:1:停更,0:未停更"`
 	CollectClassifyIdList []int                   `description:"所属收藏分类id列表" gorm:"-"`
+	SharedUserIdList      []int                   `description:"共享用户id列表" gorm:"-"`
+	PublicStatus          int                     `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
 }
 
 type EdbDataInsertConfigItem struct {
@@ -2037,3 +2039,16 @@ func GetIsJoinPermissionEdbInfoIdList(edbInfoType, edbType int) (list []int, err
 
 	return
 }
+
+// UpdateClassifyIdByEdbInfoId
+// @Description: 根据指标id更新所属分类id
+// @author: Roc
+// @datetime 2024-11-29 17:54:44
+// @param edbInfoId int
+// @param edbClassifyId int
+// @return err error
+func UpdateClassifyIdByEdbInfoId(edbInfoId, edbClassifyId int) (err error) {
+	sql := ` UPDATE edb_info SET classify_id = ? WHERE  edb_info_id=? `
+	err = global.DmSQL["data"].Exec(sql, edbClassifyId, edbInfoId).Error
+	return
+}

models/data_manage/edb_info_share.go

@@ -0,0 +1,93 @@
+package data_manage
+
+import (
+	"eta_gn/eta_api/global"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"time"
+)
+
+// EdbInfoShare
+// @Description: 指标分享表
+type EdbInfoShare struct {
+	EdbInfoShareId int       `gorm:"primaryKey" `
+	EdbInfoId      int       `description:"指标id"`
+	SysUserId      int       `description:"sys_user_id"`
+	ShareType      int8      `description:"分享类型，1：仅查看；2：可编辑"`
+	CreateTime     time.Time `description:"创建时间"`
+}
+
+// TableName
+// @Description: 表名
+// @author: Roc
+// @receiver m
+// @datetime 2024-11-27 14:04:14
+// @return string
+func (m EdbInfoShare) TableName() string {
+	return `edb_info_share`
+}
+
+// GetListByEdbInfoId
+// @Description: 根据指标id获取分享用户列表
+// @author: Roc
+// @receiver m
+// @datetime 2024-11-27 15:39:17
+// @param edbInfoId int
+// @return items []*EdbInfoShare
+// @return err error
+func (m EdbInfoShare) GetListByEdbInfoId(edbInfoId int) (items []*EdbInfoShare, err error) {
+	sql := ` SELECT * FROM edb_info_share WHERE edb_info_id = ? ORDER BY edb_info_share_id ASC `
+	err = global.DmSQL["data"].Raw(sql, edbInfoId).Find(&items).Error
+
+	return
+}
+
+// SaveEdbInfoShare
+// @Description: 保存配置
+// @author: Roc
+// @receiver m
+// @datetime 2024-11-27 15:54:07
+// @param edbInfoIdList []int
+// @param userIdList []int
+// @param shareType int8
+// @return err error
+func (m EdbInfoShare) SaveEdbInfoShare(edbInfoIdList, userIdList []int, shareType int8) (err error) {
+	addList := make([]*EdbInfoShare, 0)
+	for _, edbInfoId := range edbInfoIdList {
+		for _, userId := range userIdList {
+			addList = append(addList, &EdbInfoShare{
+				EdbInfoShareId: 0,
+				EdbInfoId:      edbInfoId,
+				SysUserId:      userId,
+				ShareType:      shareType,
+				CreateTime:     time.Now(),
+			})
+		}
+	}
+
+	tx := global.DmSQL["data"].Begin()
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+			return
+		}
+		_ = tx.Commit()
+	}()
+
+	// 先删除原来的配置，新增最新的配置
+	sql := fmt.Sprintf("DELETE FROM %s WHERE edb_info_id IN (?) ", m.TableName())
+	err = tx.Exec(sql, edbInfoIdList).Error
+	if err != nil {
+		return
+	}
+
+	// 批量添加新的配置
+	if len(addList) > 0 {
+		err = tx.CreateInBatches(addList, utils.MultiAddNum).Error
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}

models/data_manage/request/edb_info_share.go

@@ -0,0 +1,23 @@
+package request
+
+// SetEdbInfoShareReq
+// @Description: 设置指标分享人请求
+type SetEdbInfoShareReq struct {
+	EdbInfoId  int   `description:"指标id"`
+	UserIdList []int `description:"分享用户id列表，如果为空，说明要给该指标移除分享人"`
+	ShareType  int8  `description:"分享类型，1：仅查看；2：可编辑"`
+}
+
+// SetEdbChartPermissionReq
+// @Description: 设置数据权限请求
+type SetEdbChartPermissionReq struct {
+	Source       int      `description:"来源id"`
+	SubSource    int      `description:"子来源id"`
+	UserId       int      `description:"用户筛选"`
+	DataIdList   []string `description:"指标/图表/表格唯一id列表"`
+	NoDataIdList []string `description:"指标/图表/表格唯一id列表"`
+	UserList     []int    `description:"赋权用户id列表，如果为空，说明要给这些指标移除权限管控"`
+	IsSelectAll  bool     `description:"是否选择所有指标"`
+	Classify     string   `description:"分类id，支持多选，用英文,隔开"`
+	Keyword      string   `description:"关键字"`
+}

models/data_manage/response/edb_info_share.go

@@ -0,0 +1,10 @@
+package response
+
+import "eta_gn/eta_api/models/data_manage"
+
+// EdbInfoShareUserResp
+// @Description: 获取指标分享用户列表
+type EdbInfoShareUserResp struct {
+	ShareType int8                        `description:"分享类型，1：仅查看；2：可编辑"`
+	List      []*data_manage.EdbInfoShare `description:"分享用户列表"`
+}

routers/commentsRouter.go

@@ -4183,6 +4183,24 @@ 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: "Save",
+            Router: `/edb_info/share/save`,
+            AllowHTTPMethods: []string{"post"},
+            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: "UserList",
+            Router: `/edb_info/share/user_list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:FactorEdbSeriesController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:FactorEdbSeriesController"],
         beego.ControllerComments{
             Method: "Add",

routers/router.go

@@ -160,6 +160,7 @@ func init() {
 				&data_manage.FactorEdbSeriesController{},
 				&data_manage.EdbCollectController{},
 				&data_manage.EdbCollectClassifyController{},
+				&data_manage.EdbInfoShareController{},
 			),
 		),
 		web.NSNamespace("/my_chart",

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)
 }
 
@@ -710,7 +718,15 @@ func AddOrEditEdbInfoToEs(edbInfoId int) {
 func AddOrEditAllEdbInfoToEs() {
 	//添加es
 	total, itemInfoList, _ := data_manage.GetEdbInfoFilterList("", []interface{}{}, 0, 100000)
+	obj := data_manage.EdbInfoShare{}
 	for k, itemInfo := range itemInfoList {
+		list, _ := obj.GetListByEdbInfoId(itemInfo.EdbInfoId)
+		sharedList := make([]int, 0)
+		for _, v := range list {
+			sharedList = append(sharedList, v.SysUserId)
+		}
+		itemInfo.SharedUserIdList = sharedList
+
 		elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
 		fmt.Println("剩余", int(total)-k-1, "条指标数据")
 	}

services/elastic/elastic.go

@@ -109,12 +109,32 @@ func EsAddOrEditEdbInfoData(indexName, docId string, item *data_manage.EdbInfoLi
 	return
 }
 
-// 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) {
+// SearchEdbInfoData
+// @Description: 查询es中的指标数据
+// @author: Roc
+// @datetime 2024-11-29 10:22:25
+// @param keywordStr string
+// @param from int
+// @param size int
+// @param filterSource int
+// @param source int
+// @param frequency string
+// @param noPermissionEdbInfoIdList []int
+// @param noPermissionEdbClassifyIdList []int
+// @param collectEdbInfoIdList []int
+// @param edbTypeList []int
+// @param edbInfoType int 指标类型，0：ETA指标库（基础指标+计算指标）；1：预测指标
+// @param edbAuth int 指标权限范围，0-全部；1-我的；2-公共
+// @param sysUserId int
+// @return total int64
+// @return list []*data_manage.EdbInfoList
+// @return err error
+func SearchEdbInfoData(keywordStr string, from, size, filterSource, source int, frequency string, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList []int, edbInfoType, 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())
 		}
 	}()
 
@@ -122,649 +142,55 @@ 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": "月度",
-				},
-			},
-		}
-	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": "月度",
 				//"Frequency.keyword": "月度",
 			},
 		})
-	}
-
-	if frequency != "" {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Frequency.keyword": frequency,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// noPermissionEdbInfoIdList 无权限指标id
-	if len(noPermissionEdbInfoIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"EdbInfoId": noPermissionEdbInfoIdList,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// noPermissionEdbInfoIdList 无权限指标id
-	if len(noPermissionEdbClassifyIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"ClassifyId": noPermissionEdbClassifyIdList,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// 指标类型：普通指标、预测指标（小于0 代表不区分指标是普通还是预测）
-	if edbInfoType >= 0 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"EdbInfoType": edbInfoType,
-			},
-		})
-	}
-
-	// 指标类型：0-基础+计算；1-基础指标；2-计算指标
-	if edbType > 0 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"EdbType": edbType,
-			},
-		})
-	}
-
-	//普通指标
-	//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 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Source": source,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	if frequency != "" {
 		mustMap = append(mustMap, map[string]interface{}{
 			"term": map[string]interface{}{
-				"Frequency.keyword": frequency,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	//普通指标
-	//mustMap = append(mustMap, map[string]interface{}{
-	//	"term": map[string]interface{}{
-	//		"EdbInfoType": 0,
-	//		//"Frequency.keyword": "月度",
-	//	},
-	//})
-
-	//关键字匹配
-	shouldMap := map[string]interface{}{
-		"should": []interface{}{
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbCode": keywordStr,
-					//"Frequency.keyword": "月度",
-				},
-			},
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbName": keywordStr,
-					//"Frequency.keyword": "月度",
-				},
-			},
-
-			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbCode": map[string]interface{}{
-						"query":    keywordStr,
-						"operator": "and",
-					},
-					//"Frequency.keyword": "月度",
-				},
-			},
-
-			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					"EdbName": map[string]interface{}{
-						"query":    keywordStr,
-						"operator": "and",
-					},
-					//"Frequency.keyword": "月度",
-				},
-			},
-		},
-	}
-	mustMap = append(mustMap, map[string]interface{}{
-		"bool": shouldMap,
-	})
-
-	queryMap := map[string]interface{}{
-		"query": map[string]interface{}{
-			"bool": map[string]interface{}{
-				"must":     mustMap,
-				"must_not": mustNotMap,
-				//"should":   shouldMap,
-			},
-		},
-	}
-
-	//根据条件数量统计
-	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
-	total, err = requestTotalHits.Do(context.Background())
-	if err != nil {
-		return
-	}
-
-	queryMap["from"] = from
-	queryMap["size"] = size
-	jsonBytes, _ := json.Marshal(queryMap)
-	fmt.Println(string(jsonBytes))
-
-	//queryStr := fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}}}}}`, keywordStr)
-	//switch filterSource {
-	//case 2:
-	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"filter":{"term":{"Frequency.keyword":"%s"}}}}}`, keywordStr, "月度")
-	//case 3:
-	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"Frequency.keyword":"%s"}}]}}}`, keywordStr, "日度")
-	//case 4:
-	//	queryStr = fmt.Sprintf(`{"query":{"bool":{"must":{"query_string":{"query":"%s","fields":["EdbCode","EdbName"]}},"must_not":[{"match":{"EdbType":1}}]}}}`, keywordStr)
-	//}
-	//queryString := elastic.RawStringQuery(queryStr)
-	//fmt.Println("queryString：", queryString)
-
-	//queryString := elastic.NewMatchQuery("EdbCode", keywordStr)
-	//request := client.Search(indexName).Highlight(highlight).From(from).Size(size).Query(queryString)
-
-	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request
-
-	//requestJson, err := json.Marshal(request)
-	//if err != nil {
-	//	fmt.Println("requestJson err:", err)
-	//}
-	//fmt.Println("requestJson ", string(requestJson))
-	searchMap := make(map[string]string)
-
-	searchResp, err := request.Do(context.Background())
-	if err != nil {
-		return
-	}
-	fmt.Println(searchResp)
-	fmt.Println(searchResp.Status)
-	if searchResp.Status != 0 {
-		return
-	}
-	if searchResp.Hits != nil {
-		for _, v := range searchResp.Hits.Hits {
-			if _, ok := searchMap[v.Id]; !ok {
-				itemJson, tmpErr := v.Source.MarshalJSON()
-				if tmpErr != nil {
-					err = tmpErr
-					fmt.Println("movieJson err:", err)
-					return
-				}
-				edbInfoItem := new(data_manage.EdbInfoList)
-				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
-				if tmpErr != nil {
-					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
-					err = tmpErr
-					return
-				}
-				if len(v.Highlight["EdbCode"]) > 0 {
-					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
-				}
-				if len(v.Highlight["EdbName"]) > 0 {
-					edbInfoItem.EdbCode = v.Highlight["EdbName"][0]
-				}
-				list = append(list, edbInfoItem)
-				searchMap[v.Id] = v.Id
-			}
-		}
-	}
-
-	//for _, v := range result {
-	//	fmt.Println(v)
-	//}
-	return
-}
-
-// SearchAddPredictEdbInfoData 查询允许添加预测指标的数据
-func SearchAddPredictEdbInfoData(indexName, keywordStr string, noPermissionEdbInfoIdList, 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{"日度", "周度", "月度"},
-		//	//},
-		//},
+				"EdbType": 1,
+			},
+		})
+	case 5:
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Source": 6,
+			},
+		})
+	case 6:
+		mustMap = append(mustMap, map[string]interface{}{
+			"match": map[string]interface{}{
+				"Frequency.keyword": "年度",
+			},
+		})
 	}
 
-	// 指标类型：普通指标、预算指标
-	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 {
+	//指标来源
+	if source > 0 {
 		mustMap = append(mustMap, map[string]interface{}{
 			"term": map[string]interface{}{
-				"EdbType": edbType,
+				"Source": source,
+				//"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": "月度",
-				},
+	if frequency != "" {
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Frequency.keyword": frequency,
+				//"Frequency.keyword": "月度",
 			},
-		},
+		})
 	}
 
 	// noPermissionEdbInfoIdList 无权限指标id
@@ -777,7 +203,7 @@ func SearchAddPredictEdbInfoData(indexName, keywordStr string, noPermissionEdbIn
 		})
 	}
 
-	// noPermissionEdbClassifyIdList 无权限指标分类id
+	// noPermissionEdbInfoIdList 无权限指标id
 	if len(noPermissionEdbClassifyIdList) > 0 {
 		mustNotMap = append(mustNotMap, map[string]interface{}{
 			"terms": map[string]interface{}{
@@ -787,11 +213,127 @@ func SearchAddPredictEdbInfoData(indexName, keywordStr string, noPermissionEdbIn
 		})
 	}
 
-	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMap, from, size)
+	// collectEdbInfoIdList 收藏的指标id
+	if len(collectEdbInfoIdList) > 0 {
+		mustMap = append(mustMap, map[string]interface{}{
+			"terms": map[string]interface{}{
+				"EdbInfoId": collectEdbInfoIdList,
+			},
+		})
+	}
+
+	// 指标类型：0-基础+计算；1-基础指标；2-计算指标；3-预测指标
+	if len(edbTypeList) > 0 {
+		mustMap = append(mustMap, map[string]interface{}{
+			"terms": map[string]interface{}{
+				"EdbType": edbTypeList,
+			},
+		})
+	}
+
+	if edbInfoType >= 0 {
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"EdbInfoType": edbInfoType,
+			},
+		})
+	}
+
+	shouldMapList := make([]map[string]interface{}, 0)
+
+	// 指标名称、编码匹配
+	if keywordStr != `` {
+		// 默认使用中文名字字段去匹配
+		keywordNameKey := `EdbName`
+		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": "月度",
+					},
+				},
+			},
+		}
+		shouldMapList = append(shouldMapList, shouldMap)
+	}
+
+	// 指标与用户的权限匹配
+	{
+		shouldTermList := make([]map[string]interface{}, 0)
+		//指标权限范围，0-全部；1-我的；2-公共
+		switch edbAuth {
+		case 1:
+			// 自己的指标
+			shouldTermList = append(shouldTermList, map[string]interface{}{
+				"term": map[string]interface{}{
+					"SysUserId": sysUserId,
+				},
+			})
+		case 2:
+			// 公开的指标
+			shouldTermList = append(shouldTermList, map[string]interface{}{
+				"term": map[string]interface{}{
+					"PublicStatus": 3,
+				},
+			})
+		default:
+			// 自己的指标
+			shouldTermList = append(shouldTermList, map[string]interface{}{
+				"term": map[string]interface{}{
+					"SysUserId": sysUserId,
+				},
+			})
+			// 分享给我的指标
+			shouldTermList = append(shouldTermList, map[string]interface{}{
+				"terms": map[string]interface{}{
+					"SharedUserIdList": []int{sysUserId},
+				},
+			})
+			// 公开的指标
+			//shouldTermList = append(shouldTermList,map[string]interface{}{
+			//	"term": map[string]interface{}{
+			//		"PublicStatus": 2,
+			//	},
+			//})
+
+		}
+		// 公开的指标
+		//shouldTermList = append(shouldTermList,map[string]interface{}{
+		//	"term": map[string]interface{}{
+		//		"PublicStatus": 2,
+		//	},
+		//})
+
+		shouldMap := map[string]interface{}{
+			"should": shouldTermList,
+		}
+		shouldMapList = append(shouldMapList, shouldMap)
+	}
+
+	// 排序
+	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, 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 {
@@ -815,9 +357,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{}{
@@ -838,21 +382,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)
 
@@ -1484,230 +1022,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)
-}