fix:共享

controllers/data_manage/edb_info.go

@@ -1853,8 +1853,14 @@ func (this *EdbInfoController) EdbInfoFilterByEs() {
 	newKeyWord := strings.Split(keyWord, " ")
 	keyWordArr = append(keyWordArr, newKeyWord...)
 
+	sortMap := make(map[string]string)
+	// 如果没有搜索关键词，则默认根据指标编码倒序排序
+	if keyWord == `` {
+		sortMap["EdbInfoId"] = `desc`
+	}
+
 	// 普通的搜索
-	total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList, edbInfoType, edbAuth, this.SysUser.AdminId)
+	total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList, edbInfoType, edbAuth, this.SysUser.AdminId, sortMap)
 
 	if err != nil {
 		edbInfoList = make([]*data_manage.EdbInfoList, 0)
@@ -3207,7 +3213,7 @@ func (this *EdbInfoController) AllEdbInfoByEs() {
 		keyWordArr = append(keyWordArr, newKeyWord...)
 
 		// 普通的搜索
-		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, -1, 0, this.SysUser.AdminId)
+		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, -1, 0, this.SysUser.AdminId, map[string]string{})
 		isEs = true
 	} else {
 		var condition string
@@ -3797,11 +3803,19 @@ func (this *EdbInfoController) EdbChartList() {
 	pars = append(pars, 0)
 
 	// 指标类型
-	edbType, _ := this.GetInt("EdbType", 0)
+	edbType, _ := this.GetInt("EdbType", 1)
 	if edbType > 0 {
 		condition += ` AND edb_type = ? `
 		pars = append(pars, edbType)
 	}
+	switch edbType {
+	case utils.EdbTypeBase:
+		condition += ` AND edb_type = ? `
+		pars = append(pars, edbType)
+	case utils.EdbTypeCalculate:
+		condition += ` AND edb_type = ? AND sys_user_id = ? `
+		pars = append(pars, edbType, sysUser.AdminId)
+	}
 
 	// 分类筛选
 	classifyId, _ := this.GetInt("ClassifyId")
@@ -3827,13 +3841,6 @@ func (this *EdbInfoController) EdbChartList() {
 		pars = append(pars, adminId)
 	}
 
-	// 只看我的
-	isOnlyMe, _ := this.GetBool("IsOnlyMe")
-	if isOnlyMe {
-		condition += ` AND sys_user_id = ? `
-		pars = append(pars, sysUser.AdminId)
-	}
-
 	// 无权限指标 和 无权限指标分类id
 	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionList(this.SysUser.AdminId, utils.EDB_INFO_TYPE, edbType)
 	if err != nil {

controllers/data_manage/edb_info_share.go

@@ -8,6 +8,11 @@ import (
 	"eta_gn/eta_api/models/data_manage/request"
 	"eta_gn/eta_api/models/data_manage/response"
 	"eta_gn/eta_api/services/data"
+	"eta_gn/eta_api/services/elastic"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"github.com/rdlucklib/rdluck_tools/paging"
+	"strings"
 )
 
 // EdbInfoShareController 数据管理
@@ -86,8 +91,8 @@ func (c *EdbInfoShareController) UserList() {
 }
 
 // Save
-// @Title 保存指标指标设置共享的详情
-// @Description 获取指标详情接口
+// @Title 单个指标设置共享
+// @Description 单个指标设置共享
 // @Param	request	body request.SetEdbInfoShareReq true "type json string"
 // @Success 200 {object} data_manage.EdbInfo
 // @router /edb_info/share/save [post]
@@ -128,3 +133,517 @@ func (c *EdbInfoShareController) Save() {
 	br.Success = true
 	br.Msg = "保存成功"
 }
+
+// Tree
+// @Title 获取共享指标的分类/指标树
+// @Description 获取共享指标的分类/指标树
+// @Success 200 {object} response.EdbShareListResp
+// @router /edb_info/share/tree [get]
+func (c *EdbInfoShareController) Tree() {
+	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
+	}
+
+	resp := response.EdbShareListResp{}
+
+	// 我共享的
+	{
+		sendList, err := data.GetAllShareEdbListByFromUserId(sysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的指标列表信息失败，Err:" + err.Error()
+			return
+		}
+		nodeList, err := data.GetEdbClassifyItemListByShareEdbInfoQueryList(sendList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的指标列表分类结构信息失败，Err:" + err.Error()
+			return
+		}
+		resp.Send = nodeList
+	}
+
+	// TODO 不确定加了用户这个顶级，会不会对前端造成一定影响
+	// 我收到的
+	{
+		sendList, err := data.GetAllShareEdbListByReceivedUserId(sysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的指标列表信息失败，Err:" + err.Error()
+			return
+		}
+		nodeList, err := data.GetEdbClassifyItemListByShareEdbInfoQueryList(sendList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的指标列表分类结构信息失败，Err:" + err.Error()
+			return
+		}
+
+		receivedMap := make(map[int]int)
+		var receivedList data_manage.EdbClassifyItemList
+		for _, v := range nodeList {
+			index, ok := receivedMap[v.SysUserId]
+			if !ok {
+				index = len(receivedMap)
+				item := &data_manage.EdbClassifyItems{
+					ClassifyId:       v.SysUserId,
+					EdbInfoId:        0,
+					ClassifyType:     0,
+					ClassifyName:     v.SysUserRealName,
+					ClassifyNameEn:   "",
+					ParentId:         0,
+					RootId:           0,
+					Level:            0,
+					Sort:             0,
+					UniqueCode:       "",
+					Source:           0,
+					SourceName:       "",
+					SysUserId:        v.SysUserId,
+					SysUserRealName:  v.SysUserRealName,
+					StartDate:        "",
+					EdbCode:          "",
+					EdbType:          0,
+					Children:         []*data_manage.EdbClassifyItems{},
+					Button:           data_manage.EdbClassifyItemsButton{},
+					IsJoinPermission: 0,
+					HaveOperaAuth:    false,
+					ClassifyIdPath:   "",
+				}
+				receivedList = append(receivedList, item)
+			}
+			receivedList[index].Children = append(receivedList[index].Children, v)
+		}
+
+		resp.Received = receivedList
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// List
+// @Title 指标列表接口
+// @Description 指标列表接口
+// @Param   PageSize   query   int  true       "每页数据条数"
+// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
+// @Param   ClassifyId   query   int  true       "分类id"
+// @Param   FilterSource   query   int  false       "共享指标的列表数据来源，0：我共享的；1：别人共享给我的"
+// @Success 200 {object} response.EdbInfoChartListResp
+// @router /edb_info/share/list [get]
+func (c *EdbInfoShareController) List() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	// 分页
+	pageSize, _ := c.GetInt("PageSize")
+	currentIndex, _ := c.GetInt("CurrentIndex")
+	filterSource, _ := c.GetInt("FilterSource")
+
+	var total int
+	page := paging.GetPaging(currentIndex, pageSize, total)
+	var startSize int
+	if pageSize <= 0 {
+		pageSize = utils.PageSize20
+	}
+	if currentIndex <= 0 {
+		currentIndex = 1
+	}
+	startSize = paging.StartIndex(currentIndex, pageSize)
+
+	// 基础指标
+	var condition string
+	var pars []interface{}
+	condition += ` AND edb_info_type = ? `
+	pars = append(pars, 0)
+
+	// 指标类型
+	edbType, _ := c.GetInt("EdbType", 0)
+	if edbType > 0 {
+		condition += ` AND edb_type = ? `
+		pars = append(pars, edbType)
+	}
+
+	// 分类筛选
+	classifyId, _ := c.GetInt("ClassifyId")
+	if classifyId > 0 {
+		childClassify, e, _ := data.GetChildClassifyByClassifyId(classifyId)
+		if e != nil && !utils.IsErrNoRow(e) {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取分类信息失败, GetEdbClassify,Err:" + e.Error()
+			return
+		}
+		var classifyIds []int
+		for _, v := range childClassify {
+			classifyIds = append(classifyIds, v.ClassifyId)
+		}
+		condition += fmt.Sprintf(` AND b.classify_id IN (%s) `, utils.GetOrmInReplace(len(classifyIds)))
+		pars = append(pars, classifyIds)
+	}
+
+	switch filterSource {
+	case 1: // 别人共享给我的
+		condition += ` AND a.sys_user_id = ? AND b.sys_user_id != ?  `
+		pars = append(pars, sysUser.AdminId, sysUser.AdminId)
+	default: // 我共享的
+		condition += ` AND b.sys_user_id = ? `
+		pars = append(pars, sysUser.AdminId)
+	}
+
+	obj := data_manage.EdbInfoShare{}
+
+	dataCount, respList, err := obj.GetShareEdbInfoListPageList(condition, pars, startSize, pageSize)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = fmt.Sprintf("获取分享指标列表失败, %v", err)
+		return
+	}
+
+	page = paging.GetPaging(currentIndex, pageSize, int(dataCount))
+
+	resp := response.EdbInfoChartListResp{
+		Paging: page,
+		List:   respList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// EdbInfoFilterByEs
+// @Title 指标筛选接口
+// @Description 指标筛选接口
+// @Success 200 {object} data_manage.EdbInfoList
+// @Param	request	body request.SearchEdbInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.EdbInfoFilterDataResp
+// @router /edb_info/share/list_by_es [post]
+func (c *EdbInfoShareController) EdbInfoFilterByEs() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.SearchEdbInfoShareReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	pageSize := req.PageSize
+	currentIndex := req.CurrentIndex
+
+	var total int64
+
+	var startSize int
+	if pageSize <= 0 {
+		pageSize = utils.PageSize20
+	}
+	if currentIndex <= 0 {
+		currentIndex = 1
+	}
+	startSize = paging.StartIndex(currentIndex, pageSize)
+
+	keyword := req.Keyword
+	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
+
+	//指标来源
+	sourceList := req.SourceList
+
+	edbInfoType := 0        // 普通指标
+	edbTypeList := []int{2} // 普通指标中的计算指标
+
+	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	edbShareList := req.EdbShareList
+	if len(edbShareList) <= 0 {
+		edbShareList = []int{1}
+	}
+	edbShare := 1 // 0：全部，1：未共享，2：已共享
+	lenEdbShareList := len(edbShareList)
+	if len(edbShareList) > 0 {
+		if lenEdbShareList > 1 {
+			edbShare = 0
+		} else {
+			edbShare = edbShareList[0]
+		}
+	}
+
+	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	edbClassifyIdList := req.ClassifyIdList
+
+	edbAuth := 1 // 选择范围是：只有我的指标
+
+	var edbInfoList []*data_manage.EdbInfoList
+
+	sortMap := make(map[string]string)
+	// 如果没有搜索关键词，则默认根据指标编码倒序排序
+	if keyword == `` {
+		sortMap["EdbInfoId"] = `desc`
+	}
+	total, edbInfoList, err = elastic.SearchEdbInfoDataByShared(keyword, startSize, pageSize, edbShare, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, c.SysUser.AdminId, sortMap)
+	if err != nil {
+		edbInfoList = make([]*data_manage.EdbInfoList, 0)
+	}
+
+	page := paging.GetPaging(currentIndex, pageSize, int(total))
+
+	edbInfoListLen := len(edbInfoList)
+
+	// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+	if len(edbInfoList) > 0 {
+		edbInfoIdList := make([]int, 0)
+		for _, v := range edbInfoList {
+			v.ConvertToResp()
+			v.EdbNameAlias = v.EdbName
+			v.HaveOperaAuth = true
+			edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
+		}
+
+		tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+			return
+		}
+		edbInfoMap := make(map[int]*data_manage.EdbInfo)
+		for _, v := range tmpEdbList {
+			edbInfoMap[v.EdbInfoId] = v
+		}
+
+		for _, v := range edbInfoList {
+			tmpEdbInfo, ok := edbInfoMap[v.EdbInfoId]
+			if !ok {
+				continue
+			}
+			v.IsJoinPermission = tmpEdbInfo.IsJoinPermission
+		}
+	}
+
+	for i := 0; i < edbInfoListLen; i++ {
+		for j := 0; j < edbInfoListLen; j++ {
+			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
+				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
+				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
+				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
+			}
+		}
+	}
+
+	resp := data_manage.EdbInfoFilterDataResp{
+		Paging: page,
+		List:   edbInfoList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// BatchSave
+// @Title 批量指标设置共享
+// @Description 批量指标设置共享
+// @Param	request	body request.SetEdbInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.EdbInfo
+// @router /edb_info/share/batch_save [post]
+func (c *EdbInfoShareController) BatchSave() {
+	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.SetEdbChartPermissionReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	// 选中的指标id列表
+	selectEdbInfoIdList := make([]int, 0)
+
+	// 选择所有指标，所以需要通过es获取数据
+	if req.IsSelectAll {
+		allEsEdbInfoIdList, err := getAllEdbInfoIdListByShared(req, c.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "设置失败！"
+			br.ErrMsg = "设置失败，Err:" + err.Error()
+			return
+		}
+
+		if len(req.NoEdbIdList) <= 0 {
+			selectEdbInfoIdList = allEsEdbInfoIdList
+		} else {
+			noEdbIdMap := make(map[int]bool)
+			for _, v := range req.NoEdbIdList {
+				noEdbIdMap[v] = true
+			}
+
+			for _, v := range allEsEdbInfoIdList {
+				if _, ok := noEdbIdMap[v]; !ok {
+					// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
+					selectEdbInfoIdList = append(selectEdbInfoIdList, v)
+				}
+			}
+		}
+	} else {
+		selectEdbInfoIdList = req.EdbIdList
+	}
+
+	// 设置
+	{
+
+		obj := data_manage.EdbInfoShare{}
+		err = obj.SaveEdbInfoShare(selectEdbInfoIdList, req.UserIdList, req.ShareType)
+		if err != nil {
+			br.Msg = `保存失败`
+			br.ErrMsg = `保存失败：` + err.Error()
+			return
+		}
+
+		// 更新es
+		for _, edbInfoId := range selectEdbInfoIdList {
+			data.AddOrEditEdbInfoToEs(edbInfoId)
+		}
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}
+
+// getAllEdbInfoIdListByShared
+// @Description: 获取所有的指标id列表
+// @author: Roc
+// @datetime 2024-12-04 15:43:14
+// @param req request.SetEdbChartPermissionReq
+// @param userId int
+// @return edbInfoIdList []int
+// @return err error
+func getAllEdbInfoIdListByShared(req request.SetEdbChartPermissionReq, userId int) (edbInfoIdList []int, err error) {
+	keyword := req.Keyword
+	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
+
+	//指标来源
+	sourceList := req.SourceList
+
+	edbInfoType := 0        // 普通指标
+	edbTypeList := []int{2} // 普通指标中的计算指标
+
+	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	edbShareList := req.EdbShareList
+	if len(edbShareList) <= 0 {
+		edbShareList = []int{1}
+	}
+	edbShare := 1 // 0：全部，1：未共享，2：已共享
+	lenEdbShareList := len(edbShareList)
+	if len(edbShareList) > 0 {
+		if lenEdbShareList > 1 {
+			edbShare = 0
+		} else {
+			edbShare = edbShareList[0]
+		}
+	}
+
+	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	edbClassifyIdList := req.ClassifyIdList
+
+	edbAuth := 1 // 选择范围是：只有我的指标
+
+	sortMap := make(map[string]string)
+	// 如果没有搜索关键词，则默认根据指标编码倒序排序
+	if keyword == `` {
+		sortMap["EdbInfoId"] = `desc`
+	}
+	_, edbInfoList, err := getAllEdbInfoDataByShared(keyword, 1, edbShare, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, userId, sortMap)
+	if err != nil {
+		return
+	}
+
+	// 返回指标id列表
+	for _, v := range edbInfoList {
+		edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
+	}
+
+	return
+}
+
+// getAllEdbInfoDataByShared
+// @Description: 获取所有的指标列表（设置共享的时候）
+// @author: Roc
+// @datetime 2024-12-04 15:27:53
+// @param keyword string
+// @param currPage int
+// @param edbShare int
+// @param sourceList []int
+// @param classifyIdList []int
+// @param edbTypeList []int
+// @param edbInfoType int
+// @param edbAuth int
+// @param sysUserId int
+// @param sortMap map[string]string
+// @return total int64
+// @return list []*data_manage.EdbInfoList
+// @return err error
+func getAllEdbInfoDataByShared(keyword string, currPage, edbShare int, sourceList, classifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.EdbInfoList, err error) {
+	// 每页获取数据的数量
+	pageSize := 2
+	var startSize int
+	if currPage <= 0 {
+		currPage = 1
+	}
+	startSize = paging.StartIndex(currPage, pageSize)
+
+	total, list, err = elastic.SearchEdbInfoDataByShared(keyword, startSize, pageSize, edbShare, sourceList, classifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
+	if err != nil {
+		return
+	}
+
+	page := paging.GetPaging(currPage, pageSize, int(total))
+	if !page.IsEnd {
+		_, nextList, tmpErr := getAllEdbInfoDataByShared(keyword, page.NextIndex, edbShare, sourceList, classifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		list = append(list, nextList...)
+	}
+
+	return
+}

controllers/data_manage/edb_public_classify.go

@@ -0,0 +1,1221 @@
+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/system"
+	"eta_gn/eta_api/services/data"
+	"eta_gn/eta_api/services/data/data_manage_permission"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"sort"
+)
+
+// EdbPublicClassifyController 数据管理-公共分类模块
+type EdbPublicClassifyController struct {
+	controllers.BaseAuthController
+}
+
+// SimpleList
+// @Title 单层公共分类列表
+// @Description 单层公共分类列表
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/simple [get]
+func (this *EdbPublicClassifyController) SimpleList() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	// 目前只有数据加工会涉及到公共分类
+	classifyType := utils.EdbClassifyTypeCalculate
+
+	// 默认查一级公共分类和一级公共分类下的指标信息，
+	// 如果是 子级公共分类，查询该子级公共分类的下一级公共分类和指标信息
+	// 增加标识判断是文件夹还是指标列表
+	parentId, _ := this.GetInt("ParentId")
+
+	edbPublicClassifyObj := data_manage.EdbPublicClassify{}
+	rootList, err := edbPublicClassifyObj.GetEdbClassifyItemsByParentId(parentId, int8(classifyType))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+
+	var sortList data_manage.EdbClassifyItemList
+	if parentId > 0 {
+		// 指标类型（基础指标，预测指标）
+		edbType := 0
+		switch classifyType {
+		case utils.EdbClassifyTypeBase:
+			edbType = 1
+		case utils.EdbClassifyTypeCalculate:
+			edbType = 2
+		}
+
+		allEdbInfo, err := data_manage.GetEdbInfoByPublicClassifyId(parentId, 0, edbType)
+		if err != nil {
+			br.Msg = "获取指标数据失败"
+			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
+			return
+		}
+
+		if len(allEdbInfo) > 0 {
+			// 查询当前公共分类信息
+			for _, v := range allEdbInfo {
+				v.HaveOperaAuth = true
+				button := data.GetEdbOpButton(this.SysUser, v.SysUserId, v.EdbType, utils.EDB_INFO_TYPE, v.HaveOperaAuth)
+				button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+				v.Button = button
+				v.Children = make([]*data_manage.EdbClassifyItems, 0)
+				v.ParentId = parentId
+				nodeAll = append(nodeAll, v)
+			}
+		}
+
+	}
+	if len(rootList) > 0 {
+		// 已授权公共分类id
+		permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(this.SysUser.AdminId, 0)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取已授权公共分类id数据失败，Err:" + err.Error()
+			return
+		}
+
+		for _, v := range rootList {
+			// 公共分类设定了权限且无权限, 那么忽略掉该节点
+			if v.IsJoinPermission == 1 && !utils.InArrayByInt(permissionClassifyIdList, v.ClassifyId) {
+				continue
+			}
+
+			// 数据权限
+			v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+			// 按钮权限
+			button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+			v.Button = button
+			v.Children = make([]*data_manage.EdbClassifyItems, 0)
+			nodeAll = append(nodeAll, v)
+		}
+	}
+	if len(nodeAll) > 0 {
+		//根据sort值排序
+		sortList = nodeAll
+		sort.Sort(sortList)
+	}
+
+	language := `CN`
+	// 指标显示的语言
+	{
+		configDetail, _ := system.GetConfigDetailByCode(this.SysUser.AdminId, system.EdbLanguageVar)
+		if configDetail != nil {
+			language = configDetail.ConfigValue
+		} else {
+			configDetail, _ = system.GetDefaultConfigDetailByCode(system.EdbLanguageVar)
+			if configDetail != nil {
+				language = configDetail.ConfigValue
+			}
+		}
+	}
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	button := data.GetEdbClassifyOpButton(this.SysUser, 0, true)
+	if !button.AddButton {
+		canOpClassify = false
+	}
+
+	resp := new(data_manage.EdbClassifyListResp)
+	resp.AllNodes = sortList
+	resp.Language = language
+	resp.CanOpClassify = canOpClassify
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// ClassifyTree
+// @Title 多层公共分类列表树
+// @Description 多层公共分类列表树
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/tree [get]
+func (this *EdbPublicClassifyController) ClassifyTree() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType := utils.EdbClassifyTypeCalculate
+
+	edbPublicClassifyObj := data_manage.EdbPublicClassify{}
+	allList, err := edbPublicClassifyObj.GetAllEdbClassifyByType(int8(classifyType))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+
+	var sortList data_manage.EdbClassifyItemList
+	if len(allList) > 0 {
+		for k, v := range allList {
+			// 数据权限
+			v.HaveOperaAuth = true
+			// 按钮权限
+			button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+			allList[k].Button = button
+		}
+		allList = data.GetClassifyTreeRecursive(allList, 0)
+		//根据sort值排序
+		sortList = allList
+		sort.Sort(sortList)
+	}
+	language := `CN`
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	button := data.GetEdbClassifyOpButton(this.SysUser, 0, true)
+	if !button.AddButton {
+		canOpClassify = false
+	}
+
+	resp := new(data_manage.EdbClassifyListResp)
+	resp.AllNodes = sortList
+	resp.Language = language
+	resp.CanOpClassify = canOpClassify
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// ListV2
+// @Title 公共分类列表
+// @Description 公共分类列表接口
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/list [get]
+func (this *EdbPublicClassifyController) ListV2() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType, _ := this.GetInt("ClassifyType", utils.EdbClassifyTypeBase) // 默认指标库的
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+	edbType := utils.EdbTypeBase
+	if classifyType == utils.EdbClassifyTypeCalculate {
+		edbType = utils.EdbTypeCalculate
+	}
+
+	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, this.SysUser.AdminId)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	// 公共分类map
+	classifyMap := make(map[int]*data_manage.EdbClassifyItems)
+	for _, v := range classifyAll {
+		classifyMap[v.ClassifyId] = v
+	}
+
+	// 已授权公共分类id
+	permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(this.SysUser.AdminId, 0)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取已授权公共分类id数据失败，Err:" + err.Error()
+		return
+	}
+
+	// 获取当前账号的不可见指标
+	obj := data_manage.EdbInfoNoPermissionAdmin{}
+	confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+		return
+	}
+	noPermissionEdbInfoIdMap := make(map[int]bool)
+	for _, v := range confList {
+		noPermissionEdbInfoIdMap[v.EdbInfoId] = true
+	}
+	//allEdbInfo, err := data_manage.GetEdbInfoAll(utils.EDB_INFO_TYPE)
+	allEdbInfo, err := data_manage.GetEdbInfoByTypes(utils.EDB_INFO_TYPE, edbType)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	edbInfoMap := make(map[int][]*data_manage.EdbClassifyItems)
+	if len(allEdbInfo) > 0 {
+		// 获取所有有权限的指标和公共分类
+		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的指标和公共分类失败，Err:" + err.Error()
+			return
+		}
+		for _, v := range allEdbInfo {
+			// 如果指标不可见，那么就不返回该指标
+			if _, ok := noPermissionEdbInfoIdMap[v.EdbInfoId]; ok {
+				continue
+			}
+			// 数据权限
+			if classifyInfo, ok := classifyMap[v.ClassifyId]; ok {
+				v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(v.IsJoinPermission, classifyInfo.IsJoinPermission, v.EdbInfoId, v.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
+			}
+
+			button := data.GetEdbOpButton(this.SysUser, v.SysUserId, v.EdbType, utils.EDB_INFO_TYPE, v.HaveOperaAuth)
+			button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+			v.Button = button
+			edbInfoMap[v.ClassifyId] = append(edbInfoMap[v.ClassifyId], v)
+		}
+	}
+	rootChildMap := make(map[int][]*data_manage.EdbClassifyItems)
+	for _, v := range classifyAll {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+		v.Button = button
+
+		rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v)
+		if existItems, ok := edbInfoMap[v.ClassifyId]; ok {
+			v.Children = existItems
+		} else {
+			items := make([]*data_manage.EdbClassifyItems, 0)
+			v.Children = items
+		}
+	}
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+	for _, v := range rootList {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		v.Button = button
+
+		if existItems, ok := rootChildMap[v.ClassifyId]; ok {
+			v.Children = existItems
+		} else {
+			items := make([]*data_manage.EdbClassifyItems, 0)
+			v.Children = items
+		}
+		nodeAll = append(nodeAll, v)
+	}
+	resp := new(data_manage.EdbClassifyListResp)
+	resp.AllNodes = nodeAll
+	resp.CanOpClassify = true
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// Items
+// @Title 获取所有公共分类接口-不包含指标
+// @Description 获取所有公共分类接口-不包含指标
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/items [get]
+func (this *EdbPublicClassifyController) Items() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType, _ := this.GetInt("ClassifyType", utils.EdbClassifyTypeBase) // 默认指标库的
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+	//edbType := utils.EdbTypeBase
+	//if classifyType == utils.EdbClassifyTypeCalculate {
+	//	edbType = utils.EdbTypeCalculate
+	//}
+
+	rootList, err := data_manage.GetEdbClassifyByParentId(0, int8(classifyType), this.SysUser.AdminId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+
+	//classifyAll, err := data_manage.GetEdbClassifyAll()
+	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType, this.SysUser.AdminId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+	for k := range rootList {
+		rootNode := rootList[k]
+		data.EdbClassifyItemsMakeTree(classifyAll, rootNode)
+		nodeAll = append(nodeAll, rootNode)
+	}
+	resp := new(data_manage.EdbClassifyListResp)
+	resp.AllNodes = nodeAll
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// AddEdbClassify
+// @Title 新增公共分类
+// @Description 新增公共分类接口
+// @Param	request	body data_manage.AddEdbClassifyReq true "type json string"
+// @Success 200 Ret=200 保存成功
+// @router /edb_public/classify/add [post]
+func (this *EdbPublicClassifyController) AddEdbClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.AddEdbClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ClassifyName == "" {
+		br.Msg = "请输入公共分类名称"
+		br.IsSendEmail = false
+		return
+	}
+	if req.ParentId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+	// 公共分类来源筛选
+	classifyType := req.ClassifyType
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+
+	//添加指标
+	_, err, errMsg := data.AddEdbClassify(req.ClassifyName, req.ParentId, req.Level, classifyType, this.SysUser.AdminId, this.SysUser.RealName, this.Lang)
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = errMsg + ";Err:" + err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	//count, err := data_manage.GetEdbClassifyCount(req.ClassifyName, req.ParentId)
+	//if err != nil {
+	//	br.Msg = "判断名称是否已存在失败"
+	//	br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+	//	return
+	//}
+	//if count > 0 {
+	//	br.Msg = "公共分类名称已存在，请重新输入"
+	//	br.IsSendEmail = false
+	//	return
+	//}
+	////获取该层级下最大的排序数
+	//maxSort, err := data_manage.GetEdbClassifyMaxSort(req.ParentId, req.ClassifyType)
+	//
+	//classify := new(data_manage.EdbClassify)
+	//classify.ClassifyType = req.ClassifyType
+	//classify.ParentId = req.ParentId
+	//classify.ClassifyName = req.ClassifyName
+	//classify.HasData = 0
+	//classify.CreateTime = time.Now()
+	//classify.ModifyTime = time.Now()
+	//classify.SysUserId = this.SysUser.AdminId
+	//classify.SysUserRealName = this.SysUser.RealName
+	//classify.Level = req.Level + 1
+	//timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	//classify.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
+	//classify.Sort = maxSort
+	//
+	//_, err = data_manage.AddEdbClassify(classify)
+	//if err != nil {
+	//	br.Msg = "保存公共分类失败"
+	//	br.ErrMsg = "保存公共分类失败,Err:" + err.Error()
+	//	return
+	//}
+	br.Ret = 200
+	br.Msg = "保存成功"
+	br.Success = true
+	br.IsAddLog = true
+}
+
+// EditEdbClassify
+// @Title 修改公共分类
+// @Description 修改公共分类接口
+// @Param	request	body data_manage.EditEdbClassifyReq true "type json string"
+// @Success 200 Ret=200 修改成功
+// @router /edb_public/classify/edit [post]
+func (this *EdbPublicClassifyController) EditEdbClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.EditEdbClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ClassifyName == "" {
+		br.Msg = "请输入公共分类名称"
+		br.IsSendEmail = false
+		return
+	}
+
+	if req.ClassifyId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	err, errMsg := data.EditEdbClassify(req.ClassifyId, req.ClassifyName, this.Lang, this.SysUser)
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = errMsg + ";Err:" + err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	//item, err := data_manage.GetEdbClassifyById(req.ClassifyId)
+	//if err != nil {
+	//	br.Msg = "保存失败"
+	//	br.Msg = "获取公共分类信息失败,Err:" + err.Error()
+	//	return
+	//}
+	//
+	//if item.ClassifyName != req.ClassifyName {
+	//	count, err := data_manage.GetEdbClassifyCount(req.ClassifyName, item.ParentId)
+	//	if err != nil {
+	//		br.Msg = "判断名称是否已存在失败"
+	//		br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+	//		return
+	//	}
+	//	if count > 0 {
+	//		br.Msg = "公共分类名称已存在，请重新输入"
+	//		br.IsSendEmail = false
+	//		return
+	//	}
+	//
+	//	err = data_manage.EditEdbClassify(req.ClassifyId, req.ClassifyName)
+	//	if err != nil {
+	//		br.Msg = "保存失败"
+	//		br.ErrMsg = "保存失败,Err:" + err.Error()
+	//		return
+	//	}
+	//}
+	br.Ret = 200
+	br.Msg = "保存成功"
+	br.Success = true
+	br.IsAddLog = true
+}
+
+// DeleteEdbClassifyCheck
+// @Title 删除检测接口
+// @Description 删除检测接口
+// @Param	request	body data_manage.ClassifyDeleteCheckReq true "type json string"
+// @Success 200 Ret=200 检测成功
+// @router /edb_public/classify/delete/check [post]
+func (this *EdbPublicClassifyController) DeleteEdbClassifyCheck() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.ClassifyDeleteCheckReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId < 0 && req.EdbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+	deleteStatus, tipsMsg, tableList, err, errMsg := data.DeleteCheck(req.ClassifyId, req.EdbInfoId, this.SysUser)
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	if this.Lang == "en" {
+		if utils.ViperConfig.InConfig(tipsMsg) {
+			tipsMsg = utils.ViperConfig.GetString(tipsMsg)
+		}
+	}
+
+	//var deleteStatus int
+	//var tipsMsg string
+	////删除公共分类
+	//if req.ClassifyId > 0 && req.EdbInfoId == 0 {
+	//	//判断公共分类下，是否含有指标
+	//	count, err := data_manage.GetEdbInfoCountByClassifyId(req.ClassifyId)
+	//	if err != nil {
+	//		br.Msg = "删除失败"
+	//		br.ErrMsg = "公共分类下是否含有指标失败，Err:" + err.Error()
+	//		return
+	//	}
+	//
+	//	if count > 0 {
+	//		deleteStatus = 1
+	//		tipsMsg = "若目录关联指标不可删除"
+	//	}
+	//}
+	//
+	//if deleteStatus != 1 && req.EdbInfoId == 0 {
+	//	classifyCount, err := data_manage.GetClassifyCountByClassifyId(req.ClassifyId)
+	//	if err != nil && !utils.IsErrNoRow(err) {
+	//		br.Msg = "删除失败"
+	//		br.ErrMsg = "公共分类下是否含有指标失败，Err:" + err.Error()
+	//		return
+	//	}
+	//	if classifyCount > 0 {
+	//		deleteStatus = 2
+	//		tipsMsg = "确认删除当前目录及包含的子目录吗"
+	//	}
+	//}
+	//
+	////删除指标
+	//if req.EdbInfoId > 0 {
+	//	//判断指标是否用于作图，如果用于作图，则不可删除
+	//	chartCount, err := data_manage.GetChartEdbMappingCount(req.EdbInfoId)
+	//	if err != nil && !utils.IsErrNoRow(err) {
+	//		br.Msg = "删除失败"
+	//		br.ErrMsg = "判断指标是否被用于作图失败，Err:" + err.Error()
+	//		return
+	//	}
+	//	if chartCount > 0 {
+	//		deleteStatus = 3
+	//		tipsMsg = "当前指标已用作画图，不可删除"
+	//	}
+	//	//判断指标是否用于计算
+	//	{
+	//		calculateCount, err := data_manage.GetEdbInfoCalculateMappingCount(req.EdbInfoId)
+	//		if err != nil && !utils.IsErrNoRow(err) {
+	//			br.Msg = "删除失败"
+	//			br.ErrMsg = "判断指标是否被用于计算失败，GetEdbInfoCalculateCount Err:" + err.Error()
+	//			return
+	//		}
+	//		if calculateCount > 0 {
+	//			deleteStatus = 4
+	//			tipsMsg = "当前指标已用作，指标运算，不可删除"
+	//		}
+	//	}
+	//}
+
+	resp := new(data_manage.ClassifyDeleteCheckResp)
+	resp.DeleteStatus = deleteStatus
+	resp.TipsMsg = tipsMsg
+	resp.TableList = tableList
+	br.Ret = 200
+	br.Msg = "检测成功"
+	br.Success = true
+	br.Data = resp
+}
+
+// DeleteEdbClassify
+// @Title 删除公共分类/指标
+// @Description 删除公共分类/指标接口
+// @Param	request	body data_manage.DeleteEdbClassifyReq true "type json string"
+// @Success 200 Ret=200 新增成功
+// @router /edb_public/classify/delete [post]
+func (this *EdbPublicClassifyController) DeleteEdbClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	var req data_manage.DeleteEdbClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId < 0 && req.EdbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	nextItem, _, err, errMsg := data.Delete(req.ClassifyId, req.EdbInfoId, sysUser, string(this.Ctx.Input.RequestBody), this.Ctx.Input.URI())
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+
+	resp := data_manage.AddEdbInfoResp{}
+	if nextItem != nil {
+		resp = data_manage.AddEdbInfoResp{
+			EdbInfoId:  nextItem.EdbInfoId,
+			UniqueCode: nextItem.UniqueCode,
+		}
+	}
+
+	br.Ret = 200
+	br.Msg = "删除成功"
+	br.Success = true
+	br.IsAddLog = true
+	br.Data = resp
+}
+
+// EdbClassifyMove
+// @Title 公共分类移动接口
+// @Description 公共分类移动接口
+// @Success 200 {object} data_manage.MoveEdbClassifyReq
+// @router /edb_classify/move [post]
+func (this *EdbPublicClassifyController) EdbClassifyMove() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.MoveEdbClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId <= 0 && req.EdbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "请选择拖动目标，公共分类目录或者指标"
+		return
+	}
+
+	// 公共分类来源筛选
+	classifyType := req.ClassifyType // 默认指标库的
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+
+	err, errMsg := data.MoveEdbClassify(req, sysUser, uint8(classifyType))
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	////判断公共分类是否存在
+	//edbClassifyInfo, err := data_manage.GetEdbClassifyById(req.ClassifyId)
+	//if err != nil {
+	//	br.Msg = "移动失败"
+	//	br.ErrMsg = "获取公共分类信息失败,Err:" + err.Error()
+	//	return
+	//}
+	//updateCol := make([]string, 0)
+	//
+	////判断上级id是否一致，如果不一致的话，那么需要移动该公共分类层级
+	//if edbClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
+	//	parentEdbClassifyInfo, err := data_manage.GetEdbClassifyById(req.ParentClassifyId)
+	//	if err != nil {
+	//		br.Msg = "移动失败"
+	//		br.ErrMsg = "获取上级公共分类信息失败,Err:" + err.Error()
+	//		return
+	//	}
+	//	edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
+	//	edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
+	//	edbClassifyInfo.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+	//}
+	//
+	////如果有传入 上一个兄弟节点公共分类id
+	//if req.PrevClassifyId > 0 {
+	//	prevClassify, err := data_manage.GetEdbClassifyById(req.PrevClassifyId)
+	//	if err != nil {
+	//		br.Msg = "移动失败"
+	//		br.ErrMsg = "获取上一个兄弟节点公共分类信息失败,Err:" + err.Error()
+	//		return
+	//	}
+	//
+	//	//如果是移动在两个兄弟节点之间
+	//	if req.NextClassifyId > 0 {
+	//		//下一个兄弟节点
+	//		nextClassify, err := data_manage.GetEdbClassifyById(req.NextClassifyId)
+	//		if err != nil {
+	//			br.Msg = "移动失败"
+	//			br.ErrMsg = "获取下一个兄弟节点公共分类信息失败,Err:" + err.Error()
+	//			return
+	//		}
+	//		//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+	//		if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == edbClassifyInfo.Sort {
+	//			//变更兄弟节点的排序
+	//			updateSortStr := `sort + 2`
+	//			_ = data_manage.UpdateEdbClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
+	//		} else {
+	//			//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+	//			if nextClassify.Sort-prevClassify.Sort == 1 {
+	//				//变更兄弟节点的排序
+	//				updateSortStr := `sort + 1`
+	//				_ = data_manage.UpdateEdbClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+	//			}
+	//		}
+	//	}
+	//
+	//	edbClassifyInfo.Sort = prevClassify.Sort + 1
+	//	edbClassifyInfo.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "Sort", "ModifyTime")
+	//} else {
+	//	firstClassify, err := data_manage.GetFirstEdbClassifyByParentId(edbClassifyInfo.ParentId)
+	//	if err != nil && !utils.IsErrNoRow(err) {
+	//		br.Msg = "移动失败"
+	//		br.ErrMsg = "获取获取当前父级公共分类下的排序第一条的公共分类信息失败,Err:" + err.Error()
+	//		return
+	//	}
+	//
+	//	//如果该公共分类下存在其他公共分类，且第一个其他公共分类的排序等于0，那么需要调整排序
+	//	if firstClassify != nil && firstClassify.ChartClassifyId > 0 && firstClassify.Sort == 0 {
+	//		updateSortStr := ` sort + 1 `
+	//		_ = data_manage.UpdateEdbClassifySortByParentId(firstClassify.ParentId, firstClassify.ClassifyId-1, 0, updateSortStr)
+	//	}
+	//
+	//	edbClassifyInfo.Sort = 0 //那就是排在第一位
+	//	edbClassifyInfo.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "Sort", "ModifyTime")
+	//}
+	//
+	////更新
+	//if len(updateCol) > 0 {
+	//	err = edbClassifyInfo.Update(updateCol)
+	//	if err != nil {
+	//		br.Msg = "移动失败"
+	//		br.ErrMsg = "修改失败,Err:" + err.Error()
+	//		return
+	//	}
+	//}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "移动成功"
+}
+
+// ItemsV2
+// @Title 公共分类列表
+// @Description 公共分类列表接口
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/items/v2 [get]
+func (this *EdbPublicClassifyController) ItemsV2() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType, _ := this.GetInt("ClassifyType", utils.EdbClassifyTypeBase) // 默认指标库的
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+	//edbType := utils.EdbTypeBase
+	//if classifyType == utils.EdbClassifyTypeCalculate {
+	//	edbType = utils.EdbTypeCalculate
+	//}
+
+	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, this.SysUser.AdminId)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	// 已授权公共分类id
+	permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(this.SysUser.AdminId, 0)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取已授权公共分类id数据失败，Err:" + err.Error()
+		return
+	}
+	//allEdbInfo, err := data_manage.GetEdbInfoAll(0)
+	//if err != nil && !utils.IsErrNoRow(err) {
+	//	br.Msg = "获取失败"
+	//	br.ErrMsg = "获取数据失败，Err:" + err.Error()
+	//	return
+	//}
+	//edbInfoMap := make(map[int][]*data_manage.EdbClassifyItems)
+	//for _, v := range allEdbInfo {
+	//	button := data.GetEdbOpButton(this.SysUser, v.SysUserId)
+	//	button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+	//	v.Button = button
+	//	edbInfoMap[v.ClassifyId] = append(edbInfoMap[v.ClassifyId], v)
+	//}
+	rootChildMap := make(map[int][]*data_manage.EdbClassifyItems)
+	for _, v := range classifyAll {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+		v.Button = button
+
+		rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v)
+		//if existItems, ok := edbInfoMap[v.ClassifyId]; ok {
+		//	v.Children = existItems
+		//} else {
+		//	items := make([]*data_manage.EdbClassifyItems, 0)
+		//	v.Children = items
+		//}
+	}
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+	for _, v := range rootList {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		v.Button = button
+
+		if existItems, ok := rootChildMap[v.ClassifyId]; ok {
+			v.Children = existItems
+		} else {
+			items := make([]*data_manage.EdbClassifyItems, 0)
+			v.Children = items
+		}
+		nodeAll = append(nodeAll, v)
+	}
+	language := `CN`
+	// 指标显示的语言
+	{
+		configDetail, _ := system.GetConfigDetailByCode(this.SysUser.AdminId, system.EdbLanguageVar)
+		if configDetail != nil {
+			language = configDetail.ConfigValue
+		} else {
+			configDetail, _ = system.GetDefaultConfigDetailByCode(system.EdbLanguageVar)
+			if configDetail != nil {
+				language = configDetail.ConfigValue
+			}
+		}
+	}
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	//button := data.GetEdbClassifyOpButton(this.SysUser, 0)
+	//if !button.AddButton {
+	//	canOpClassify = false
+	//}
+
+	resp := data_manage.EdbClassifyListResp{
+		AllNodes:      nodeAll,
+		CanOpClassify: canOpClassify,
+		Language:      language,
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// ClassifyEdbInfoList
+// @Title 获取公共分类下指标接口
+// @Description 获取公共分类下指标接口
+// @Param   ClassifyId   query   int  true       "公共分类id"
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/edb_info/list [get]
+func (this *EdbPublicClassifyController) ClassifyEdbInfoList() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	classifyId, _ := this.GetInt("ClassifyId")
+	if classifyId <= 0 {
+		br.Msg = "参数错误,请刷新页面"
+		return
+	}
+
+	classifyInfo, err := data_manage.GetEdbClassifyById(classifyId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取公共分类信息失败，Err:" + err.Error()
+		return
+	}
+
+	// 获取当前账号的不可见指标
+	obj := data_manage.EdbInfoNoPermissionAdmin{}
+	confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+		return
+	}
+	noPermissionEdbInfoIdMap := make(map[int]bool)
+	for _, v := range confList {
+		noPermissionEdbInfoIdMap[v.EdbInfoId] = true
+	}
+
+	// 指标类型（基础指标，预测指标）
+	edbType := 0
+	switch classifyInfo.ClassifyType {
+	case utils.EdbClassifyTypeBase:
+		edbType = 1
+	case utils.EdbClassifyTypeCalculate:
+		edbType = 2
+	}
+	// 无权限指标 和 无权限指标公共分类id
+	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionList(this.SysUser.AdminId, utils.EDB_INFO_TYPE, edbType)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+		return
+	}
+
+	allEdbInfo, err := data_manage.GetEdbInfoByClassifyId(classifyId, utils.EDB_INFO_TYPE, edbType, 0, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList)
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+
+	list := make([]*data_manage.EdbClassifyItems, 0)
+
+	if len(allEdbInfo) > 0 {
+		// 获取所有有权限的指标和公共分类
+		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的指标和公共分类失败，Err:" + err.Error()
+			return
+		}
+		for _, v := range allEdbInfo {
+			// 如果指标不可见，那么就不返回该指标
+			if _, ok := noPermissionEdbInfoIdMap[v.EdbInfoId]; ok {
+				continue
+			}
+			v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(v.IsJoinPermission, classifyInfo.IsJoinPermission, v.EdbInfoId, v.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
+			button := data.GetEdbOpButton(this.SysUser, v.SysUserId, v.EdbType, utils.EDB_INFO_TYPE, v.HaveOperaAuth)
+			button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+			v.Button = button
+
+			list = append(list, v)
+		}
+	}
+
+	resp := new(data_manage.ClassifyEdbInfoListResp)
+	resp.EdbInfoList = list
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// ItemsV3
+// @Title 公共分类列表
+// @Description 公共分类列表接口
+// @Success 200 {object} data_manage.EdbClassifyListResp
+// @router /edb_public/classify/items/v3 [get]
+func (this *EdbPublicClassifyController) ItemsV3() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType, _ := this.GetInt("ClassifyType", utils.EdbClassifyTypeBase) // 默认指标库的
+	if classifyType != utils.EdbClassifyTypeBase && classifyType != utils.EdbClassifyTypeCalculate {
+		br.Msg = "参数有误"
+		br.ErrMsg = fmt.Sprintf("指标公共分类类型有误, ClassifyType: %d", classifyType)
+		return
+	}
+	//edbType := utils.EdbTypeBase
+	//if classifyType == utils.EdbClassifyTypeCalculate {
+	//	edbType = utils.EdbTypeCalculate
+	//}
+
+	// TODO:9级改造
+	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
+	}
+	rootTwoList, err := data_manage.GetEdbClassifyByParentIdTwo(int8(classifyType))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	classifyAll, err := data_manage.GetEdbClassifyAllV2(int8(classifyType))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	// 已授权公共分类id
+	permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(this.SysUser.AdminId, 0)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取已授权公共分类id数据失败，Err:" + err.Error()
+		return
+	}
+
+	rootTwoMap := make(map[int][]*data_manage.EdbClassifyItems)
+	for _, v := range rootTwoList {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		v.Button = button
+
+		rootTwoMap[v.ParentId] = append(rootTwoMap[v.ParentId], v)
+	}
+	rootTwoChildMap := make(map[int][]*data_manage.EdbClassifyItems)
+	for _, v := range classifyAll {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		v.Button = button
+		if v.Level == 3 {
+			rootTwoChildMap[v.ParentId] = append(rootTwoChildMap[v.ParentId], v)
+		}
+	}
+
+	nodeAll := make([]*data_manage.EdbClassifyItems, 0)
+	for _, v := range rootList {
+		// 数据权限
+		v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+		// 按钮权限
+		button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+		v.Button = button
+
+		if existItems, ok := rootTwoMap[v.ClassifyId]; ok {
+			v.Children = existItems
+			for _, item := range existItems {
+				// 数据权限
+				v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+				// 按钮权限
+				button := data.GetEdbClassifyOpButton(this.SysUser, item.SysUserId, v.HaveOperaAuth)
+				item.Button = button
+
+				if existItems, ok := rootTwoChildMap[item.ClassifyId]; ok {
+					for _, existItem := range existItems {
+						// 数据权限
+						v.HaveOperaAuth = data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(v.IsJoinPermission, v.ClassifyId, permissionClassifyIdList)
+						// 按钮权限
+						button := data.GetEdbClassifyOpButton(this.SysUser, v.SysUserId, v.HaveOperaAuth)
+						button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+						existItem.Button = button
+					}
+					item.Children = existItems
+				} else {
+					items := make([]*data_manage.EdbClassifyItems, 0)
+					item.Children = items
+				}
+			}
+		} else {
+			items := make([]*data_manage.EdbClassifyItems, 0)
+			v.Children = items
+		}
+		nodeAll = append(nodeAll, v)
+	}
+	language := `CN`
+	// 指标显示的语言
+	{
+		configDetail, _ := system.GetConfigDetailByCode(this.SysUser.AdminId, system.EdbLanguageVar)
+		if configDetail != nil {
+			language = configDetail.ConfigValue
+		} else {
+			configDetail, _ = system.GetDefaultConfigDetailByCode(system.EdbLanguageVar)
+			if configDetail != nil {
+				language = configDetail.ConfigValue
+			}
+		}
+	}
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	button := data.GetEdbClassifyOpButton(this.SysUser, 0, true)
+	if !button.AddButton {
+		canOpClassify = false
+	}
+
+	resp := new(data_manage.EdbClassifyListResp)
+	resp.AllNodes = nodeAll
+	resp.Language = language
+	resp.CanOpClassify = canOpClassify
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}

controllers/data_manage/predict_edb_info.go

@@ -1104,7 +1104,7 @@ func (this *PredictEdbInfoController) FilterByEs() {
 		newKeyWord := strings.Split(keyWord, " ")
 		keyWordArr = append(keyWordArr, newKeyWord...)
 
-		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, 1, 0, this.SysUser.AdminId)
+		total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, []int{}, []int{1, 2}, 1, 0, this.SysUser.AdminId, map[string]string{})
 
 		isEs = true
 	} else {

models/data_manage/edb_classify.go

@@ -675,3 +675,21 @@ func GetChildEdbClassifyListByParentId(classifyIdPath, orderStr string) (items [
 
 	return
 }
+
+// GetEdbClassifyItemsByIdList
+// @Description: 根据分类id列表获取分类列表
+// @author: Roc
+// @datetime 2024-03-29 10:30:21
+// @param classifyId int
+// @return item *EdbClassify
+// @return err error
+func GetEdbClassifyItemsByIdList(classifyIdList []int) (item []*EdbClassifyItems, err error) {
+	num := len(classifyIdList)
+	if num <= 0 {
+		return
+	}
+	sql := `SELECT * FROM edb_classify WHERE classify_id in (` + utils.GetOrmInReplace(num) + `) `
+	err = global.DmSQL["data"].Raw(sql, classifyIdList).Scan(&item).Error
+
+	return
+}

models/data_manage/edb_info.go

@@ -20,54 +20,56 @@ import (
 )
 
 type EdbInfo struct {
-	EdbInfoId        int       `gorm:"primaryKey" `
-	EdbInfoType      int       `description:"指标类型，0：普通指标，1：预测指标"`
-	SourceName       string    `description:"来源名称"`
-	Source           int       `description:"来源id"`
-	EdbCode          string    `description:"指标编码"`
-	EdbName          string    `description:"指标名称"`
-	EdbNameEn        string    `description:"英文指标名称"`
-	EdbNameSource    string    `description:"指标名称来源"`
-	Frequency        string    `description:"频率"`
-	Unit             string    `description:"单位"`
-	UnitEn           string    `description:"英文单位"`
-	StartDate        time.Time `description:"起始日期"`
-	EndDate          time.Time `description:"终止日期"`
-	ClassifyId       int       `description:"分类id"`
-	SysUserId        int
-	SysUserRealName  string
-	UniqueCode       string `description:"指标唯一编码"`
-	CreateTime       time.Time
-	ModifyTime       time.Time
-	BaseModifyTime   time.Time
-	MinValue         float64 `description:"指标最小值"`
-	MaxValue         float64 `description:"指标最大值"`
-	CalculateFormula string  `description:"计算公式"`
-	EdbType          int     `description:"指标类型:1:基础指标,2:计算指标"`
-	Sort             int     `description:"排序字段"`
-	LatestDate       string  `description:"数据最新日期（实际日期）"`
-	LatestValue      float64 `description:"数据最新值（实际值）"`
-	EndValue         float64 `description:"数据的最新值（预测日期的最新值）"`
-	MoveType         int     `description:"移动方式:1:领先(默认),2:滞后"`
-	MoveFrequency    string  `description:"移动频度"`
-	NoUpdate         int8    `description:"是否停止更新，0：继续更新；1：停止更新"`
-	ServerUrl        string  `description:"服务器地址"`
-	ChartImage       string  `description:"图表图片"`
-	Calendar         string  `description:"公历/农历" orm:"default(公历);"`
-	DataDateType     string  `orm:"column(data_date_type);size(255);null;default(交易日)"`
-	ManualSave       int     `description:"是否有手动保存过上下限: 0-否; 1-是"`
-	EmptyType        int     `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
-	MaxEmptyType     int     `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
-	TerminalCode     string  `description:"终端编码，用于配置在机器上"`
-	DataUpdateTime   string  `description:"最近一次数据发生变化的时间"`
-	ErDataUpdateDate string  `description:"本次更新，数据发生变化的最早日期"`
-	SourceIndexName  string  `description:"数据源中的指标名称"`
-	SubSource        int     `description:"子数据来源:0:经济数据库,1:日期序列"`
-	SubSourceName    string  `description:"子数据来源名称"`
-	IndicatorCode    string  `description:"指标代码"`
-	StockCode        string  `description:"证券代码"`
-	Extra            string  `description:"指标额外配置"`
-	IsJoinPermission int     `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	EdbInfoId           int       `gorm:"primaryKey" `
+	EdbInfoType         int       `description:"指标类型，0：普通指标，1：预测指标"`
+	SourceName          string    `description:"来源名称"`
+	Source              int       `description:"来源id"`
+	EdbCode             string    `description:"指标编码"`
+	EdbName             string    `description:"指标名称"`
+	EdbNameEn           string    `description:"英文指标名称"`
+	EdbNameSource       string    `description:"指标名称来源"`
+	Frequency           string    `description:"频率"`
+	Unit                string    `description:"单位"`
+	UnitEn              string    `description:"英文单位"`
+	StartDate           time.Time `description:"起始日期"`
+	EndDate             time.Time `description:"终止日期"`
+	ClassifyId          int       `description:"分类id"`
+	SysUserId           int
+	SysUserRealName     string
+	UniqueCode          string `description:"指标唯一编码"`
+	CreateTime          time.Time
+	ModifyTime          time.Time
+	BaseModifyTime      time.Time
+	MinValue            float64 `description:"指标最小值"`
+	MaxValue            float64 `description:"指标最大值"`
+	CalculateFormula    string  `description:"计算公式"`
+	EdbType             int     `description:"指标类型:1:基础指标,2:计算指标"`
+	Sort                int     `description:"排序字段"`
+	LatestDate          string  `description:"数据最新日期（实际日期）"`
+	LatestValue         float64 `description:"数据最新值（实际值）"`
+	EndValue            float64 `description:"数据的最新值（预测日期的最新值）"`
+	MoveType            int     `description:"移动方式:1:领先(默认),2:滞后"`
+	MoveFrequency       string  `description:"移动频度"`
+	NoUpdate            int8    `description:"是否停止更新，0：继续更新；1：停止更新"`
+	ServerUrl           string  `description:"服务器地址"`
+	ChartImage          string  `description:"图表图片"`
+	Calendar            string  `description:"公历/农历" orm:"default(公历);"`
+	DataDateType        string  `orm:"column(data_date_type);size(255);null;default(交易日)"`
+	ManualSave          int     `description:"是否有手动保存过上下限: 0-否; 1-是"`
+	EmptyType           int     `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
+	MaxEmptyType        int     `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
+	TerminalCode        string  `description:"终端编码，用于配置在机器上"`
+	DataUpdateTime      string  `description:"最近一次数据发生变化的时间"`
+	ErDataUpdateDate    string  `description:"本次更新，数据发生变化的最早日期"`
+	SourceIndexName     string  `description:"数据源中的指标名称"`
+	SubSource           int     `description:"子数据来源:0:经济数据库,1:日期序列"`
+	SubSourceName       string  `description:"子数据来源名称"`
+	IndicatorCode       string  `description:"指标代码"`
+	StockCode           string  `description:"证券代码"`
+	Extra               string  `description:"指标额外配置"`
+	IsJoinPermission    int     `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	PublicStatus        int     `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
+	EdbPublicClassifyId int     `description:"指标公开分类id"`
 }
 
 type EdbInfoFullClassify struct {
@@ -411,6 +413,7 @@ type EdbInfoList struct {
 	CollectClassifyIdList []int                   `description:"所属收藏分类id列表" gorm:"-"`
 	SharedUserIdList      []int                   `description:"共享用户id列表" gorm:"-"`
 	PublicStatus          int                     `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
+	EdbPublicClassifyId   int                     `description:"指标公开分类id"`
 }
 
 type EdbDataInsertConfigItem struct {

models/data_manage/edb_info_share.go

@@ -1,6 +1,7 @@
 package data_manage
 
 import (
+	sql2 "database/sql"
 	"eta_gn/eta_api/global"
 	"eta_gn/eta_api/utils"
 	"fmt"
@@ -91,3 +92,135 @@ func (m EdbInfoShare) SaveEdbInfoShare(edbInfoIdList, userIdList []int, shareTyp
 
 	return
 }
+
+// ShareEdbInfoQuery
+// @Description: 共享指标
+type ShareEdbInfoQuery struct {
+	EdbInfo
+	ShareType string    `gorm:"column:share_type" description:"共享类型"`
+	ShareTime time.Time `gorm:"column:share_time" description:"设置共享时间"`
+}
+
+// GetAllSharedEdbInfoListByFromUserId
+// @Description: 获取所有我共享出去的指标列表
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 09:56:41
+// @param sysUserId int
+// @return list []*ShareEdbInfoQuery
+// @return err error
+func (m EdbInfoShare) GetAllSharedEdbInfoListByFromUserId(sysUserId int) (list []*ShareEdbInfoQuery, err error) {
+	sql := `SELECT b."edb_info_id",
+       MAX(a.share_type) AS share_type,
+MAX(a.create_time) as share_time,
+MAX(b."edb_code") AS "edb_code",
+MAX(b."edb_name") "edb_name",
+MAX(b."edb_info_type") "edb_info_type",
+MAX(b."edb_type") "edb_type",
+MAX(b."source") "source",
+MAX(b."source_name") "source_name",
+MAX(b."frequency") "frequency",
+MAX(b."unit") "unit",
+MAX(b."classify_id") "classify_id",
+MAX(b."create_time") "create_time",
+MAX(b."unique_code") "unique_code",
+MAX(b."chart_image") "chart_image",
+MAX(b."modify_time") "modify_time",
+MAX(b."start_date") "start_date",
+MAX(b."sort") AS "sort"
+ FROM edb_info_share AS a 
+     JOIN edb_info AS b ON a.edb_info_id = b.edb_info_id
+	  WHERE 1=1 AND b.sys_user_id = ?
+	  GROUP BY b.edb_info_id
+ORDER BY share_time DESC`
+	err = global.DmSQL["data"].Raw(sql, sysUserId).Scan(&list).Error
+	return
+}
+
+// GetAllSharedEdbInfoListByReceivedUserId
+// @Description: 获取所有我收到的共享的指标列表
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 09:56:41
+// @param sysUserId int
+// @return list []*ShareEdbInfoQuery
+// @return err error
+func (m EdbInfoShare) GetAllSharedEdbInfoListByReceivedUserId(sysUserId int) (list []*ShareEdbInfoQuery, err error) {
+	sql := `SELECT b."edb_info_id",
+       MAX(a.share_type) AS share_type,
+MAX(a.create_time) as share_time,
+MAX(b."edb_code") AS "edb_code",
+MAX(b."edb_name") "edb_name",
+MAX(b."edb_info_type") "edb_info_type",
+MAX(b."edb_type") "edb_type",
+MAX(b."source") "source",
+MAX(b."source_name") "source_name",
+MAX(b."frequency") "frequency",
+MAX(b."unit") "unit",
+MAX(b."classify_id") "classify_id",
+MAX(b."create_time") "create_time",
+MAX(b."unique_code") "unique_code",
+MAX(b."chart_image") "chart_image",
+MAX(b."modify_time") "modify_time",
+MAX(b."start_date") "start_date",
+MAX(b."sort") AS "sort"
+ FROM edb_info_share AS a 
+     JOIN edb_info AS b ON a.edb_info_id = b.edb_info_id
+	  WHERE 1=1 AND a.sys_user_id = ? AND b.sys_user_id != ?
+	  GROUP BY b.edb_info_id
+ORDER BY share_time DESC`
+	err = global.DmSQL["data"].Raw(sql, sysUserId, sysUserId).Scan(&list).Error
+	return
+}
+
+// GetShareEdbInfoListPageList
+// @Description: 获取分享的指标列表（分页）
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 14:42:12
+// @param condition string
+// @param pars []interface{}
+// @param startSize int
+// @param pageSize int
+// @return total int32
+// @return list []*EdbInfoList
+// @return err error
+func (m EdbInfoShare) GetShareEdbInfoListPageList(condition string, pars []interface{}, startSize, pageSize int) (total int32, list []*EdbInfoList, err error) {
+	baseSql := `SELECT b."edb_info_id",
+       MAX(a.share_type) AS share_type,
+MAX(a.create_time) as share_time,
+MAX(b."edb_code") AS "edb_code",
+MAX(b."edb_name") "edb_name",
+MAX(b."edb_info_type") "edb_info_type",
+MAX(b."edb_type") "edb_type",
+MAX(b."source") "source",
+MAX(b."source_name") "source_name",
+MAX(b."frequency") "frequency",
+MAX(b."unit") "unit",
+MAX(b."classify_id") "classify_id",
+MAX(b."create_time") "create_time",
+MAX(b."unique_code") "unique_code",
+MAX(b."chart_image") "chart_image",
+MAX(b."modify_time") "modify_time",
+MAX(b."start_date") "start_date",
+MAX(b."sort") AS "sort"
+  FROM edb_info_share AS a 
+     JOIN edb_info AS b ON a.edb_info_id = b.edb_info_id
+	  WHERE 1=1 `
+
+	baseSql += condition
+	baseSql += ` GROUP BY b.edb_info_id `
+
+	totalSql := `SELECT COUNT(1) AS total FROM (` + baseSql + `) AS d`
+	var totalNull sql2.NullInt32
+	err = global.DmSQL["data"].Raw(totalSql, pars...).Scan(&totalNull).Error
+	if err != nil {
+		return
+	}
+	total = totalNull.Int32
+
+	sql := baseSql + ` ORDER BY share_time DESC LIMIT ?,? `
+	pars = append(pars, startSize, pageSize)
+	err = global.DmSQL["data"].Raw(sql, pars...).Scan(&list).Error
+	return
+}

models/data_manage/public_edb_classify.go

@@ -0,0 +1,125 @@
+package data_manage
+
+import (
+	"eta_gn/eta_api/global"
+	"time"
+)
+
+// EdbPublicClassify
+// @Description: 公共分类
+type EdbPublicClassify struct {
+	EdbPublicClassifyId       int       `gorm:"primaryKey" `
+	ClassifyType              uint8     `description:"分类类型，0：普通指标分类，1：预测指标分类，2：指标加工的分类（普通指标的计算指标）"`
+	EdbPublicClassifyName     string    `description:"分类名称"`
+	ParentId                  int       `description:"父级id"`
+	HasData                   int       `description:"是否含有指标数据"`
+	RootId                    int       `description:"顶级id"`
+	CreateTime                time.Time `description:"创建时间"`
+	ModifyTime                time.Time `description:"修改时间"`
+	SysUserId                 int       `description:"创建人id"`
+	SysUserRealName           string    `description:"创建人姓名"`
+	Level                     int       `description:"层级"`
+	UniqueCode                string    `description:"唯一编码"`
+	Sort                      int       `description:"排序字段，越小越靠前，默认值：10"`
+	LastModifyUserId          int       `description:"最后修改人ID"`
+	LastModifyUserRealName    string    `description:"最后修改人姓名"`
+	EdbPublicClassifyNamePath string    `description:"分类名称的完整路径，格式为：父级分类名称|当前分类名称"`
+	EdbPublicClassifyIdPath   string    `description:"分类的完整路径，格式为：父级ID,当前ID"`
+}
+
+// GetEdbClassifyListByParentId
+// @Description: 根据父级id获取下级分类列表
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 13:57:48
+// @param parentId int
+// @param classifyType int8
+// @return items []*EdbPublicClassify
+// @return err error
+func (m EdbPublicClassify) GetEdbClassifyListByParentId(parentId int, classifyType int8) (items []*EdbPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := `SELECT * FROM edb_public_classify WHERE parent_id=? AND classify_type = ? order by sort asc,classify_id asc `
+	err = o.Raw(sql, parentId, classifyType).Find(&items).Error
+
+	return
+}
+
+// GetEdbClassifyItemsByParentId
+// @Description: 根据父级id获取下级分类列表（结构型的）
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 13:56:18
+// @param parentId int
+// @param classifyType int8
+// @return items []*EdbClassifyItems
+// @return err error
+func (m EdbPublicClassify) GetEdbClassifyItemsByParentId(parentId int, classifyType int8) (items []*EdbClassifyItems, err error) {
+	list, err := m.GetEdbClassifyListByParentId(parentId, classifyType)
+	if err != nil {
+		return
+	}
+
+	for _, v := range list {
+		items = append(items, v.ToEdbClassifyItems())
+	}
+
+	return
+}
+
+// GetEdbClassifyListByParentId
+// @Description: 根据父级id获取下级分类列表
+// @author: Roc
+// @receiver m
+// @datetime 2024-12-03 13:57:48
+// @param parentId int
+// @param classifyType int8
+// @return items []*EdbPublicClassify
+// @return err error
+func (m EdbPublicClassify) GetEdbClassifyListByType(classifyType int8) (items []*EdbPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := `SELECT * FROM edb_public_classify WHERE classify_type = ? order by sort asc,classify_id asc `
+	err = o.Raw(sql, classifyType).Find(&items).Error
+
+	return
+}
+
+// GetAllEdbClassifyByType 根据类型获取分类列表
+func (m EdbPublicClassify) GetAllEdbClassifyByType(classifyType int8) (items []*EdbClassifyItems, err error) {
+	list, err := m.GetEdbClassifyListByType(int8(classifyType))
+	if err != nil {
+		return
+	}
+
+	for _, v := range list {
+		items = append(items, v.ToEdbClassifyItems())
+	}
+
+	return
+}
+
+func (m EdbPublicClassify) ToEdbClassifyItems() *EdbClassifyItems {
+	return &EdbClassifyItems{
+		ClassifyId: m.EdbPublicClassifyId,
+		//EdbInfoId:        0,
+		ClassifyType:   m.ClassifyType,
+		ClassifyName:   m.EdbPublicClassifyName,
+		ClassifyNameEn: m.EdbPublicClassifyName,
+		ParentId:       m.ParentId,
+		RootId:         m.RootId,
+		Level:          m.Level,
+		Sort:           m.Sort,
+		UniqueCode:     m.UniqueCode,
+		//Source:           0,
+		//SourceName:       "",
+		SysUserId:       m.SysUserId,
+		SysUserRealName: m.SysUserRealName,
+		//StartDate:        "",
+		//EdbCode:          "",
+		//EdbType:          0,
+		//Children:         nil,
+		//Button:           EdbClassifyItemsButton{},
+		//IsJoinPermission: 0,
+		//HaveOperaAuth:    false,
+		ClassifyIdPath: m.EdbPublicClassifyIdPath,
+	}
+}

models/data_manage/public_edb_info.go

@@ -0,0 +1,30 @@
+package data_manage
+
+import "eta_gn/eta_api/global"
+
+// GetEdbInfoByPublicClassifyId
+// @Description: 根据公共分类id获取指标列表
+// @author: Roc
+// @datetime 2024-12-03 14:09:32
+// @param classifyId int
+// @param edbInfoType int
+// @param edbType int
+// @return items []*EdbClassifyItems
+// @return err error
+func GetEdbInfoByPublicClassifyId(classifyId, edbInfoType, edbType int) (items []*EdbClassifyItems, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT edb_info_id,classify_id,edb_name AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type, sort,is_join_permission FROM edb_info WHERE edb_public_classify_id = ? AND edb_info_type = ?`
+
+	pars := []interface{}{classifyId, edbInfoType}
+
+	// 如果筛选了指标类型，那么就根据条件来
+	if edbType > 0 {
+		sql += ` AND edb_type = ? `
+		pars = append(pars, edbType)
+	}
+
+	sql += ` order by sort asc,edb_info_id asc `
+	err = o.Raw(sql, pars...).Scan(&items).Error
+
+	return
+}

models/data_manage/request/edb_info_share.go

@@ -8,16 +8,25 @@ type SetEdbInfoShareReq struct {
 	ShareType  int8  `description:"分享类型，1：仅查看；2：可编辑"`
 }
 
+// SearchEdbInfoShareReq
+// @Description: 获取指标列表（设置共享的时候）请求结构体
+type SearchEdbInfoShareReq struct {
+	EdbShareList   []int  `description:"指标分享状态：1-未共享；2-已共享。可多选，默认是未共享"`
+	SourceList     []int  `description:"来源id"`
+	Keyword        string `description:"关键字"`
+	ClassifyIdList []int  `description:"分类选择，如果不指定分类，那么就是所有分类"`
+	CurrentIndex   int    `description:"当前页页码，从1开始"`
+	PageSize       int    `description:"每页数据条数"`
+}
+
 // 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:"关键字"`
+	SearchEdbInfoShareReq
+	EdbIdList   []int `description:"选中的指标id列表"`
+	NoEdbIdList []int `description:"未选中的指标id列表"`
+	IsSelectAll bool  `description:"是否选择所有指标"`
+
+	UserIdList []int `description:"分享用户id列表，如果为空，说明要给该指标移除分享人"`
+	ShareType  int8  `description:"分享类型，1：仅查看；2：可编辑"`
 }

models/data_manage/response/edb_info_share.go

@@ -8,3 +8,10 @@ type EdbInfoShareUserResp struct {
 	ShareType int8                        `description:"分享类型，1：仅查看；2：可编辑"`
 	List      []*data_manage.EdbInfoShare `description:"分享用户列表"`
 }
+
+// EdbShareListResp
+// @Description: 共享列表
+type EdbShareListResp struct {
+	Send     data_manage.EdbClassifyItemList
+	Received data_manage.EdbClassifyItemList `description:"收到的共享"`
+}

routers/commentsRouter.go

@@ -4183,6 +4183,33 @@ 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: "BatchSave",
+            Router: `/edb_info/share/batch_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: "List",
+            Router: `/edb_info/share/list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"],
+        beego.ControllerComments{
+            Method: "EdbInfoFilterByEs",
+            Router: `/edb_info/share/list_by_es`,
+            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: "Save",
@@ -4192,6 +4219,15 @@ 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: "Tree",
+            Router: `/edb_info/share/tree`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbInfoShareController"],
         beego.ControllerComments{
             Method: "UserList",
@@ -4201,6 +4237,114 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "EdbClassifyMove",
+            Router: `/edb_classify/move`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "AddEdbClassify",
+            Router: `/edb_public/classify/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "DeleteEdbClassify",
+            Router: `/edb_public/classify/delete`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "DeleteEdbClassifyCheck",
+            Router: `/edb_public/classify/delete/check`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ClassifyEdbInfoList",
+            Router: `/edb_public/classify/edb_info/list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "EditEdbClassify",
+            Router: `/edb_public/classify/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "Items",
+            Router: `/edb_public/classify/items`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ItemsV2",
+            Router: `/edb_public/classify/items/v2`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ItemsV3",
+            Router: `/edb_public/classify/items/v3`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ListV2",
+            Router: `/edb_public/classify/list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "SimpleList",
+            Router: `/edb_public/classify/simple`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ClassifyTree",
+            Router: `/edb_public/classify/tree`,
+            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",

services/data/edb_classify.go

@@ -32,7 +32,12 @@ func GetClassifyTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int
 	res := make([]*data_manage.EdbClassifyItems, 0)
 	for _, v := range list {
 		if v.ParentId == parentId {
-			v.Children = GetClassifyTreeRecursive(list, v.ClassifyId)
+			children := GetClassifyTreeRecursive(list, v.ClassifyId)
+			if v.Children == nil {
+				v.Children = children
+			} else {
+				v.Children = append(v.Children, children...)
+			}
 			res = append(res, v)
 		}
 	}
@@ -1024,6 +1029,11 @@ func MoveEdbClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin,
 			err = errors.New("获取分类信息失败,Err:" + err.Error())
 			return
 		}
+		if edbClassifyInfo.SysUserId != sysUser.AdminId {
+			errMsg = "不是本人目录，您没有操作权限"
+			err = errors.New(errMsg)
+			return
+		}
 		if parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 {
 			errMsg = "最高只支持添加6级分类"
 			err = errors.New(errMsg)
@@ -1082,6 +1092,13 @@ func MoveEdbClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin,
 			err = errors.New("获取分类信息失败,Err:" + err.Error())
 			return
 		}
+
+		if edbInfo.SysUserId != sysUser.AdminId {
+			errMsg = "不是本人指标，您没有操作权限"
+			err = errors.New(errMsg)
+			return
+		}
+
 		if parentClassifyId == 0 {
 			errMsg = "移动失败,指标必须挂在分类下"
 			err = errors.New(errMsg)

services/data/edb_info_share.go

@@ -0,0 +1,135 @@
+package data
+
+import (
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/utils"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// GetAllShareEdbListByFromUserId
+// @Description: 根据共享人id获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-03 10:01:49
+// @param sysUserId int
+// @return item []*data_manage.ShareEdbInfoQuery
+// @return err error
+func GetAllShareEdbListByFromUserId(sysUserId int) (item []*data_manage.ShareEdbInfoQuery, err error) {
+	obj := data_manage.EdbInfoShare{}
+	item, err = obj.GetAllSharedEdbInfoListByFromUserId(sysUserId)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetAllShareEdbListByReceivedUserId
+// @Description: 根据接收人id获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-03 10:01:49
+// @param sysUserId int
+// @return item []*data_manage.ShareEdbInfoQuery
+// @return err error
+func GetAllShareEdbListByReceivedUserId(sysUserId int) (item []*data_manage.ShareEdbInfoQuery, err error) {
+	obj := data_manage.EdbInfoShare{}
+	item, err = obj.GetAllSharedEdbInfoListByReceivedUserId(sysUserId)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetEdbClassifyItemListByShareEdbInfoQueryList
+// @Description: 根据共享的指标来获取分类和指标的树形结构
+// @author: Roc
+// @datetime 2024-12-03 11:12:26
+// @param items []*data_manage.ShareEdbInfoQuery
+// @return item data_manage.EdbClassifyItemList
+// @return err error
+func GetEdbClassifyItemListByShareEdbInfoQueryList(items []*data_manage.ShareEdbInfoQuery) (item data_manage.EdbClassifyItemList, err error) {
+	// 所有分类
+	edbClassifyItemListMap := make(map[int][]*data_manage.EdbClassifyItems)
+	classifyIdList := make([]int, 0)
+
+	for _, v := range items {
+		edbClassifyItem := &data_manage.EdbClassifyItems{
+			ClassifyId: v.ClassifyId,
+			EdbInfoId:  v.EdbInfoId,
+			//ParentId:   v.ClassifyId,
+			//ClassifyType:     v.ClassifyT,
+			ClassifyName:    v.EdbName,
+			ClassifyNameEn:  v.EdbNameEn,
+			Sort:            v.Sort,
+			UniqueCode:      v.UniqueCode,
+			Source:          v.Source,
+			SourceName:      v.SourceName,
+			SysUserId:       v.SysUserId,
+			SysUserRealName: v.SysUserRealName,
+			StartDate:       v.StartDate.Format(utils.FormatDate),
+			EdbCode:         v.EdbCode,
+			EdbType:         v.EdbType,
+			//Children:         nil,
+			Button:           data_manage.EdbClassifyItemsButton{},
+			IsJoinPermission: v.IsJoinPermission,
+			HaveOperaAuth:    false,
+			ClassifyIdPath:   "",
+		}
+		edbClassifyItemList, ok := edbClassifyItemListMap[v.ClassifyId]
+		if ok {
+			edbClassifyItemListMap[v.ClassifyId] = []*data_manage.EdbClassifyItems{edbClassifyItem}
+			continue
+		}
+		edbClassifyItemListMap[v.ClassifyId] = append(edbClassifyItemList, edbClassifyItem)
+		classifyIdList = append(classifyIdList, v.ClassifyId)
+	}
+
+	// 组成一个分类树形结构
+	{
+		// 根据分类id获取分类
+		classifyItemsList, tmpErr := data_manage.GetEdbClassifyItemsByIdList(classifyIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		allClassifyIdList := make([]int, 0)
+		// 获取分类的完整路径id集合（子级、父级、顶级）
+		allClassifyIdStrList := make([]string, 0)
+		for _, v := range classifyItemsList {
+			allClassifyIdStrList = append(allClassifyIdStrList, v.ClassifyIdPath)
+		}
+		allClassifyIdStrList = strings.Split(strings.Join(allClassifyIdStrList, ","), ",")
+		for _, v := range allClassifyIdStrList {
+			classifyId, tmpErr := strconv.Atoi(v)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			allClassifyIdList = append(allClassifyIdList, classifyId)
+		}
+
+		classifyItemsList, err = data_manage.GetEdbClassifyItemsByIdList(allClassifyIdList)
+		if err != nil {
+			return
+		}
+
+		for _, v := range classifyItemsList {
+			if edbClassifyItemList, ok := edbClassifyItemListMap[v.ClassifyId]; ok {
+				if v.Children == nil {
+					v.Children = edbClassifyItemList
+				} else {
+					v.Children = append(v.Children, edbClassifyItemList...)
+				}
+			}
+		}
+
+		item = GetClassifyTreeRecursive(classifyItemsList, 0)
+		//根据sort值排序
+		sort.Sort(item)
+	}
+
+	return
+}

services/elastic/edb_info.go

@@ -0,0 +1,608 @@
+package elastic
+
+import (
+	"context"
+	"encoding/json"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"github.com/olivere/elastic/v7"
+)
+
+// EsAddOrEditEdbInfoData 新增/修改es中的指标数据
+func EsAddOrEditEdbInfoData(indexName, docId string, item *data_manage.EdbInfoList) (err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("EsAddOrEditData Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
+	if err != nil {
+		fmt.Println("新增失败:", err.Error())
+		return err
+	}
+	fmt.Println(resp)
+	if resp.Status == 0 {
+		fmt.Println("新增成功", resp.Result)
+		err = nil
+	} else {
+		fmt.Println("AddData", resp.Status, resp.Result)
+	}
+	return
+}
+
+// searchEdbInfoData 查询es中的指标数据
+func searchEdbInfoData(indexName 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 {
+			fmt.Println("searchEdbInfoData Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	//queryString := elastic.NewQueryStringQuery(keywordStr)
+	//boolQueryJson, err := json.Marshal(queryString)
+	//if err != nil {
+	//	fmt.Println("boolQueryJson err:", err)
+	//} else {
+	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
+	//}
+
+	highlight := elastic.NewHighlight()
+	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
+	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
+
+	//query := elastic.RawStringQuery(`{"match_all":{}}`)
+
+	//关键字匹配
+	for _, shouldMap := range shouldMapList {
+		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
+
+	// 如果有指定排序，那么就按照排序来
+	if len(sortList) > 0 {
+		queryMap["sort"] = sortList
+	}
+
+	jsonBytes, _ := json.Marshal(queryMap)
+	fmt.Println(string(jsonBytes))
+
+	//queryString := elastic.NewMatchQuery("EdbCode", keywordStr)
+	//request := client.Search(indexName).Highlight(highlight).From(from).Size(size).Query(queryString)
+
+	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request
+
+	//requestJson, err := json.Marshal(request)
+	//if err != nil {
+	//	fmt.Println("requestJson err:", err)
+	//}
+	//fmt.Println("requestJson ", string(requestJson))
+	searchMap := make(map[string]string)
+
+	searchResp, err := request.Do(context.Background())
+	if err != nil {
+		return
+	}
+	fmt.Println(searchResp)
+	fmt.Println(searchResp.Status)
+	if searchResp.Status != 0 {
+		return
+	}
+	//total = searchResp.TotalHits()
+	if searchResp.Hits != nil {
+		for _, v := range searchResp.Hits.Hits {
+			if _, ok := searchMap[v.Id]; !ok {
+				itemJson, tmpErr := v.Source.MarshalJSON()
+				if tmpErr != nil {
+					err = tmpErr
+					fmt.Println("movieJson err:", err)
+					return
+				}
+				edbInfoItem := new(data_manage.EdbInfoList)
+				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
+				if tmpErr != nil {
+					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
+					err = tmpErr
+					return
+				}
+				if len(v.Highlight["EdbCode"]) > 0 {
+					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
+				}
+				if len(v.Highlight["EdbName"]) > 0 {
+					edbInfoItem.EdbCode = v.Highlight["EdbName"][0]
+				}
+				list = append(list, edbInfoItem)
+				searchMap[v.Id] = v.Id
+			}
+		}
+	}
+
+	return
+}
+
+// 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, sortMap map[string]string) (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("SearchEdbInfoData Err:", err.Error())
+		}
+	}()
+
+	highlight := elastic.NewHighlight()
+	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
+	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
+
+	mustMap := make([]interface{}, 0)
+	mustNotMap := make([]interface{}, 0)
+
+	switch filterSource {
+	case 2:
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Frequency.keyword": "月度",
+				//"Frequency.keyword": "月度",
+			},
+		})
+	case 3:
+	case 4:
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"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": "年度",
+			},
+		})
+	}
+
+	//指标来源
+	if source > 0 {
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Source": source,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+
+	if frequency != "" {
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"Frequency.keyword": frequency,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+
+	// noPermissionEdbInfoIdList 无权限指标id
+	if len(noPermissionEdbInfoIdList) > 0 {
+		mustNotMap = append(mustNotMap, map[string]interface{}{
+			"terms": map[string]interface{}{
+				"EdbInfoId": noPermissionEdbInfoIdList,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+
+	// noPermissionEdbInfoIdList 无权限指标id
+	if len(noPermissionEdbClassifyIdList) > 0 {
+		mustNotMap = append(mustNotMap, map[string]interface{}{
+			"terms": map[string]interface{}{
+				"ClassifyId": noPermissionEdbClassifyIdList,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+
+	// 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": 3,
+				},
+			})
+
+		}
+
+		shouldMap := map[string]interface{}{
+			"should": shouldTermList,
+		}
+		shouldMapList = append(shouldMapList, shouldMap)
+	}
+
+	// 排序
+	sortList := make([]interface{}, 0)
+	// 如果没有关键字，那么就走指标id倒序
+
+	for orderKey, orderType := range sortMap {
+		sortEdbInfoId := map[string]interface{}{
+			orderKey: map[string]interface{}{
+				"order": orderType,
+			},
+		}
+		sortList = append(sortList, sortEdbInfoId)
+	}
+
+	return searchEdbInfoData(indexName, mustMap, mustNotMap, shouldMapList, sortList, from, size)
+}
+
+// searchEdbInfoData 查询es中的指标数量
+func searchEdbInfoDataTotal(indexName string, query elastic.Query) (total int64, err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("searchEdbInfoDataV2 Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	//根据条件数量统计
+	requestTotalHits := client.Count(indexName).Query(query)
+	total, err = requestTotalHits.Do(context.Background())
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// searchEdbInfoData 查询es中的指标数据
+func searchEdbInfoDataList(indexName string, query elastic.Query, sortList []*elastic.FieldSort, from, size int) (list []*data_manage.EdbInfoList, err error) {
+	list = make([]*data_manage.EdbInfoList, 0)
+	defer func() {
+		if err != nil {
+			fmt.Println("searchEdbInfoDataV2 Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+	// 高亮
+	highlight := elastic.NewHighlight()
+	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
+	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
+
+	request := client.Search(indexName).Highlight(highlight).From(from).Size(size) // sets the JSON request
+
+	// 如果有指定排序，那么就按照排序来
+	if len(sortList) > 0 {
+		for _, v := range sortList {
+			request = request.SortBy(v)
+		}
+	}
+
+	searchMap := make(map[string]string)
+
+	searchResp, err := request.Query(query).Do(context.Background())
+	if err != nil {
+		return
+	}
+	//fmt.Println(searchResp)
+	//fmt.Println(searchResp.Status)
+	if searchResp.Status != 0 {
+		return
+	}
+	//total = searchResp.TotalHits()
+	if searchResp.Hits != nil {
+		for _, v := range searchResp.Hits.Hits {
+			if _, ok := searchMap[v.Id]; !ok {
+				itemJson, tmpErr := v.Source.MarshalJSON()
+				if tmpErr != nil {
+					err = tmpErr
+					fmt.Println("movieJson err:", err)
+					return
+				}
+				edbInfoItem := new(data_manage.EdbInfoList)
+				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
+				if tmpErr != nil {
+					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
+					err = tmpErr
+					return
+				}
+				if len(v.Highlight["EdbCode"]) > 0 {
+					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
+				}
+				if len(v.Highlight["EdbName"]) > 0 {
+					edbInfoItem.EdbCode = v.Highlight["EdbName"][0]
+				}
+				list = append(list, edbInfoItem)
+				searchMap[v.Id] = v.Id
+			}
+		}
+	}
+
+	return
+}
+
+// searchEdbInfoData 查询es中的指标数据
+func searchEdbInfoDataV2(indexName string, query elastic.Query, sortList []*elastic.FieldSort, from, size int) (total int64, list []*data_manage.EdbInfoList, err error) {
+	total, err = searchEdbInfoDataTotal(indexName, query)
+	if err != nil {
+		return
+	}
+
+	// 获取列表数据
+	list, err = searchEdbInfoDataList(indexName, query, sortList, from, size)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// SearchEdbInfoDataByShared
+// @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 SearchEdbInfoDataByShared(keywordStr string, from, size, edbShare int, sourceList, classifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (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("SearchEdbInfoData Err:", err.Error())
+		}
+	}()
+
+	query := elastic.NewBoolQuery()
+
+	//指标来源
+	if len(sourceList) > 0 {
+		termsList := make([]interface{}, 0)
+		for _, v := range sourceList {
+			termsList = append(termsList, v)
+		}
+		query = query.Must(elastic.NewTermsQuery("Source", termsList...))
+	}
+
+	// classifyIdList 指定分类下的指标
+	if len(classifyIdList) > 0 {
+		termsList := make([]interface{}, 0)
+		for _, v := range classifyIdList {
+			termsList = append(termsList, v)
+		}
+		query = query.Must(elastic.NewTermsQuery("ClassifyId", termsList...))
+	}
+
+	// 指标类型：0-基础+计算；1-基础指标；2-计算指标；3-预测指标
+	if len(edbTypeList) > 0 {
+		termsList := make([]interface{}, 0)
+		for _, v := range edbTypeList {
+			termsList = append(termsList, v)
+		}
+		query = query.Must(elastic.NewTermsQuery("EdbType", termsList...))
+	}
+
+	// 如果指定了分享状态，那么就添加分享状态的筛选
+	// 0：全部，1：未共享，2：已共享
+	switch edbShare {
+	case 1:
+		// 筛选 SharedUserIdList 为空的文档
+		query = query.MustNot(elastic.NewExistsQuery("SharedUserIdList"))
+	case 2:
+		// 筛选 SharedUserIdList 不为空的文档
+		query = query.Must(elastic.NewExistsQuery("SharedUserIdList"))
+	}
+
+	if edbInfoType >= 0 {
+		query = query.Must(elastic.NewTermQuery("EdbInfoType", edbInfoType))
+	}
+
+	// 指标名称、编码匹配
+	if keywordStr != `` {
+		// 默认使用中文名字字段去匹配
+		keywordNameKey := `EdbName`
+		query = query.Must(elastic.NewMultiMatchQuery(keywordStr, keywordNameKey, "EdbCode"))
+	}
+
+	// 指标与用户的权限匹配
+	{
+		//指标权限范围，0-全部；1-我的；2-公共
+		switch edbAuth {
+		case 1:
+			// 自己的指标
+			query = query.Must(elastic.NewTermQuery(`SysUserId`, sysUserId))
+		case 2:
+			// 公开的指标
+			query = query.Must(elastic.NewTermQuery(`PublicStatus`, 3))
+		default:
+			tmpShouldQuery := elastic.NewBoolQuery()
+			// 自己的指标
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`SysUserId`, sysUserId))
+			// 分享给我的指标
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermsQuery(`SharedUserIdList`, sysUserId))
+			//公开的指标
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`PublicStatus`, 3))
+			//shouldQuery = shouldQuery.Should(tmpShouldQuery)
+			query = query.Must(tmpShouldQuery)
+		}
+	}
+
+	// 排序
+	sortList := make([]*elastic.FieldSort, 0)
+	// 如果没有关键字，那么就走指标id倒序
+
+	for orderKey, orderType := range sortMap {
+		switch orderType {
+		case "asc":
+			sortList = append(sortList, elastic.NewFieldSort(orderKey).Asc())
+		case "desc":
+			sortList = append(sortList, elastic.NewFieldSort(orderKey).Desc())
+
+		}
+
+	}
+
+	return searchEdbInfoDataV2(indexName, query, sortList, from, size)
+}
+
+// EsDeleteEdbInfoData 删除es中的指标数据
+func EsDeleteEdbInfoData(indexName, docId string) (err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
+	fmt.Println(resp)
+	if err != nil {
+		return
+	}
+	if resp.Status == 0 {
+		fmt.Println("删除成功")
+	} else {
+		fmt.Println("AddData", resp.Status, resp.Result)
+	}
+	return
+}

services/elastic/elastic.go

@@ -62,387 +62,6 @@ func MappingModify(indexName, mappingJson string) {
 	return
 }
 
-// EsAddOrEditEdbInfoData 新增/修改es中的指标数据
-func EsAddOrEditEdbInfoData(indexName, docId string, item *data_manage.EdbInfoList) (err error) {
-	defer func() {
-		if err != nil {
-			fmt.Println("EsAddOrEditData Err:", err.Error())
-		}
-	}()
-	client := utils.EsClient
-
-	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
-	if err != nil {
-		fmt.Println("新增失败:", err.Error())
-		return err
-	}
-	fmt.Println(resp)
-	if resp.Status == 0 {
-		fmt.Println("新增成功", resp.Result)
-		err = nil
-	} else {
-		fmt.Println("AddData", resp.Status, resp.Result)
-	}
-	return
-}
-
-// SearchEdbInfoData
-// @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("SearchEdbInfoData Err:", err.Error())
-		}
-	}()
-
-	highlight := elastic.NewHighlight()
-	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
-	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
-
-	mustMap := make([]interface{}, 0)
-	mustNotMap := make([]interface{}, 0)
-
-	switch filterSource {
-	case 2:
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Frequency.keyword": "月度",
-				//"Frequency.keyword": "月度",
-			},
-		})
-	case 3:
-	case 4:
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"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": "年度",
-			},
-		})
-	}
-
-	//指标来源
-	if source > 0 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Source": source,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	if frequency != "" {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"Frequency.keyword": frequency,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// noPermissionEdbInfoIdList 无权限指标id
-	if len(noPermissionEdbInfoIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"EdbInfoId": noPermissionEdbInfoIdList,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// noPermissionEdbInfoIdList 无权限指标id
-	if len(noPermissionEdbClassifyIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"ClassifyId": noPermissionEdbClassifyIdList,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	// 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{}, 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 {
-			fmt.Println("EsAddOrEditData Err:", err.Error())
-		}
-	}()
-	client := utils.EsClient
-
-	//queryString := elastic.NewQueryStringQuery(keywordStr)
-	//boolQueryJson, err := json.Marshal(queryString)
-	//if err != nil {
-	//	fmt.Println("boolQueryJson err:", err)
-	//} else {
-	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
-	//}
-
-	highlight := elastic.NewHighlight()
-	highlight = highlight.Fields(elastic.NewHighlighterField("EdbCode"), elastic.NewHighlighterField("EdbName"))
-	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
-
-	//query := elastic.RawStringQuery(`{"match_all":{}}`)
-
-	//关键字匹配
-	for _, shouldMap := range shouldMapList {
-		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
-
-	// 如果有指定排序，那么就按照排序来
-	if len(sortList) > 0 {
-		queryMap["sort"] = sortList
-	}
-
-	jsonBytes, _ := json.Marshal(queryMap)
-	fmt.Println(string(jsonBytes))
-
-	//queryString := elastic.NewMatchQuery("EdbCode", keywordStr)
-	//request := client.Search(indexName).Highlight(highlight).From(from).Size(size).Query(queryString)
-
-	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request
-
-	//requestJson, err := json.Marshal(request)
-	//if err != nil {
-	//	fmt.Println("requestJson err:", err)
-	//}
-	//fmt.Println("requestJson ", string(requestJson))
-	searchMap := make(map[string]string)
-
-	searchResp, err := request.Do(context.Background())
-	if err != nil {
-		return
-	}
-	fmt.Println(searchResp)
-	fmt.Println(searchResp.Status)
-	if searchResp.Status != 0 {
-		return
-	}
-	//total = searchResp.TotalHits()
-	if searchResp.Hits != nil {
-		for _, v := range searchResp.Hits.Hits {
-			if _, ok := searchMap[v.Id]; !ok {
-				itemJson, tmpErr := v.Source.MarshalJSON()
-				if tmpErr != nil {
-					err = tmpErr
-					fmt.Println("movieJson err:", err)
-					return
-				}
-				edbInfoItem := new(data_manage.EdbInfoList)
-				tmpErr = json.Unmarshal(itemJson, &edbInfoItem)
-				if tmpErr != nil {
-					fmt.Println("json.Unmarshal movieJson err:", tmpErr)
-					err = tmpErr
-					return
-				}
-				if len(v.Highlight["EdbCode"]) > 0 {
-					edbInfoItem.EdbCode = v.Highlight["EdbCode"][0]
-				}
-				if len(v.Highlight["EdbName"]) > 0 {
-					edbInfoItem.EdbCode = v.Highlight["EdbName"][0]
-				}
-				list = append(list, edbInfoItem)
-				searchMap[v.Id] = v.Id
-			}
-		}
-	}
-
-	return
-}
-
-// EsDeleteEdbInfoData 删除es中的指标数据
-func EsDeleteEdbInfoData(indexName, docId string) (err error) {
-	defer func() {
-		if err != nil {
-			fmt.Println("EsDeleteEdbInfoData Err:", err.Error())
-		}
-	}()
-	client := utils.EsClient
-
-	resp, err := client.Delete().Index(indexName).Id(docId).Do(context.Background())
-	fmt.Println(resp)
-	if err != nil {
-		return
-	}
-	if resp.Status == 0 {
-		fmt.Println("删除成功")
-	} else {
-		fmt.Println("AddData", resp.Status, resp.Result)
-	}
-	return
-}
-
 // EsAddOrEditReport 新增编辑es报告
 func EsAddOrEditReport(indexName, docId string, item *models.ElasticReportDetail) (err error) {
 	defer func() {

utils/elastic.go

@@ -2,16 +2,31 @@ package utils
 
 import (
 	"github.com/olivere/elastic/v7"
+	"log"
+	"os"
 )
 
 // EsClient es客户端
 var EsClient *elastic.Client
 
 func initEs() {
-	client, err := elastic.NewClient(
+	var logInfo *log.Logger
+	if RunMode == `debug` {
+		logInfo = log.New(os.Stderr, "", log.LstdFlags)
+	}
+
+	clientOptionFuncList := []elastic.ClientOptionFunc{
 		elastic.SetURL(ES_URL),
 		elastic.SetBasicAuth(ES_USERNAME, ES_PASSWORD),
-		elastic.SetSniff(false))
+		elastic.SetSniff(false),
+	}
+	if logInfo != nil {
+		clientOptionFuncList = append(clientOptionFuncList, elastic.SetTraceLog(logInfo))
+	}
+
+	client, err := elastic.NewClient(
+		clientOptionFuncList...,
+	)
 	EsClient = client
 	if err != nil {
 		panic("ElasticSearch连接失败,err:" + err.Error())