图库

controllers/data_manage/chart_info_share.go

@@ -0,0 +1,678 @@
+package data_manage
+
+import (
+	"encoding/json"
+	"eta_gn/eta_api/controllers"
+	"eta_gn/eta_api/models"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/models/data_manage/request"
+	"eta_gn/eta_api/models/data_manage/response"
+	"eta_gn/eta_api/models/system"
+	"eta_gn/eta_api/services/data"
+	"eta_gn/eta_api/services/elastic"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"github.com/rdlucklib/rdluck_tools/paging"
+	"sort"
+	"strings"
+)
+
+// ChartInfoShareController 数据管理
+type ChartInfoShareController struct {
+	controllers.BaseAuthController
+}
+
+// UserList
+// @Title 获取图表设置共享的详情
+// @Description 获取图表详情接口
+// @Param   ChartInfoId   query   int  true       "图表id"
+// @Success 200 {object} response.ChartInfoShareUserResp
+// @router /chart_info/share/user_list [get]
+func (c *ChartInfoShareController) UserList() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	chartInfoId, _ := c.GetInt("ChartInfoId")
+	if chartInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "参数错误"
+		return
+	}
+	_, err := data_manage.GetChartInfoById(chartInfoId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+		return
+	}
+
+	//// TODO 权限校验
+	//{
+	//	classifyMap := make(map[int]*data_manage.ChartClassifyIdItems)
+	//	for _, v := range classifyList {
+	//		classifyMap[v.ClassifyId] = v
+	//	}
+	//	if currClassify, ok := classifyMap[chartInfo.ClassifyId]; ok {
+	//		haveOperaAuth, err := data_manage_permission.CheckChartPermission(chartInfo.IsJoinPermission, currClassify.IsJoinPermission, c.SysUser.AdminId, chartInfo.ChartInfoId, chartInfo.ClassifyId)
+	//		if err != nil {
+	//			br.Msg = err.Error()
+	//			br.ErrMsg = "校验图表权限失败，err:" + err.Error()
+	//			return
+	//		}
+	//		resp.HaveOperaAuth = haveOperaAuth
+	//	}
+	//}
+
+	resp := response.ChartInfoShareUserResp{}
+
+	obj := data_manage.ChartInfoShare{}
+	list, err := obj.GetListByChartInfoId(chartInfoId)
+	if err != nil {
+		br.Msg = `获取失败`
+		br.ErrMsg = `获取失败：` + err.Error()
+		return
+	}
+	resp.List = list
+	if len(list) > 0 {
+		resp.ShareType = list[0].ShareType
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// Save
+// @Title 单个图表设置共享
+// @Description 单个图表设置共享
+// @Param	request	body request.SetChartInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfo
+// @router /chart_info/share/save [post]
+func (c *ChartInfoShareController) Save() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	var req request.SetChartInfoShareReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	obj := data_manage.ChartInfoShare{}
+	err = obj.SaveChartInfoShare([]int{req.ChartInfoId}, req.UserIdList, req.ShareType)
+	if err != nil {
+		br.Msg = `保存失败`
+		br.ErrMsg = `保存失败：` + err.Error()
+		return
+	}
+
+	// 更新es
+	go data.EsAddOrEditChartInfo(req.ChartInfoId)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}
+
+// Tree
+// @Title 获取共享图表的分类/图表树
+// @Description 获取共享图表的分类/图表树
+// @Success 200 {object} response.ChartShareListResp
+// @router /chart_info/share/tree [get]
+func (c *ChartInfoShareController) 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.ChartShareListResp{}
+
+	// 我共享的
+	{
+		sendList, err := data.GetAllShareChartListByFromUserId(sysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的图表列表信息失败，Err:" + err.Error()
+			return
+		}
+		nodeList, err := data.GetChartClassifyItemListByShareChartInfoQueryList(sendList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享出去的图表列表分类结构信息失败，Err:" + err.Error()
+			return
+		}
+
+		var sortList data_manage.ChartClassifyItemList
+		sortList = nodeList
+
+		sort.Sort(sortList)
+		resp.Send = sortList
+	}
+
+	// TODO 不确定加了用户这个顶级，会不会对前端造成一定影响
+	// 我收到的
+	{
+		sendList, err := data.GetAllShareChartListByReceivedUserId(sysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我共享的图表列表信息失败，Err:" + err.Error()
+			return
+		}
+		nodeList, err := data.GetChartClassifyItemListByShareChartInfoQueryList(sendList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取我收到共享的图表列表分类结构信息失败，Err:" + err.Error()
+			return
+		}
+
+		receivedMap := make(map[int]int)
+		var receivedList data_manage.ChartClassifyItemList
+		for _, v := range nodeList {
+			index, ok := receivedMap[v.SysUserId]
+			if !ok {
+				index = len(receivedMap)
+				item := &data_manage.ChartClassifyItems{
+					ChartClassifyId:     v.SysUserId,
+					ChartInfoId:         0,
+					ChartClassifyName:   v.SysUserRealName,
+					ChartClassifyNameEn: v.SysUserRealName,
+					ParentId:            0,
+					Level:               0,
+					Sort:                0,
+					UniqueCode:          utils.MD5(fmt.Sprint(v.SysUserId, "_", v.SysUserRealName)),
+					Source:              0,
+					SourceName:          "",
+					SysUserId:           v.SysUserId,
+					SysUserRealName:     v.SysUserRealName,
+					DateType:            0,
+					StartDate:           "",
+					EndDate:             "",
+					ChartType:           0,
+					Calendar:            "",
+					SeasonStartDate:     "",
+					SeasonEndDate:       "",
+					Children:            []*data_manage.ChartClassifyItems{},
+					Button:              data_manage.ChartClassifyItemsButton{},
+					IsJoinPermission:    0,
+					HaveOperaAuth:       false,
+					ChartClassifyIdPath: "",
+				}
+				receivedList = append(receivedList, item)
+			}
+			receivedList[index].Children = append(receivedList[index].Children, v)
+		}
+		sort.Sort(receivedList)
+		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.ChartInfoChartListResp
+// @router /chart_info/share/list [get]
+func (c *ChartInfoShareController) 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 chart_info_type = ? `
+	pars = append(pars, 0)
+
+	// 图表类型
+	chartType, _ := c.GetInt("ChartType", 0)
+	if chartType > 0 {
+		condition += ` AND chart_type = ? `
+		pars = append(pars, chartType)
+	}
+
+	// 分类筛选
+	classifyId, _ := c.GetInt("ClassifyId")
+	if classifyId > 0 {
+		childClassify, e, _ := data.GetChildClassifyByClassifyId(classifyId)
+		if e != nil && !utils.IsErrNoRow(e) {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取分类信息失败, GetChartClassify,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.ChartInfoShare{}
+
+	dataCount, respList, err := obj.GetShareChartInfoListPageList(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.ChartInfoChartListResp{
+		Paging: page,
+		List:   respList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// ListByEs
+// @Title 图表筛选接口
+// @Description 图表筛选接口
+// @Success 200 {object} data_manage.ChartInfoList
+// @Param	request	body request.SearchChartInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfoFilterDataResp
+// @router /chart_info/share/list/es [post]
+func (c *ChartInfoShareController) ListByEs() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.SearchChartInfoShareReq
+	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 := []int{utils.CHART_TYPE_CURVE}
+	// 图表分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未全部
+	chartShareList := req.ChartShareList
+	if len(chartShareList) <= 0 {
+		chartShareList = []int{}
+	}
+	chartShare := 0 // 0：全部，1：未共享，2：已共享
+	lenChartShareList := len(chartShareList)
+	if len(chartShareList) > 0 {
+		if lenChartShareList > 1 {
+			chartShare = 0
+		} else {
+			chartShare = chartShareList[0]
+		}
+	}
+
+	// 直图表所属分类id
+	chartClassifyIdList := req.ClassifyIdList
+
+	chartAuth := 1 // 选择范围是：只有我的图表
+
+	var chartInfoList []*data_manage.ChartInfoView
+
+	sortMap := make(map[string]string)
+	// 如果没有搜索关键词，则默认根据图表编码倒序排序
+	if keyword == `` {
+		sortMap["ChartInfoId"] = `desc`
+	}
+	total, chartInfoList, err = elastic.SearchChartInfoDataByShared(keyword, startSize, pageSize, chartShare, sourceList, chartClassifyIdList, chartAuth, c.SysUser.AdminId, sortMap)
+	if err != nil {
+		chartInfoList = make([]*data_manage.ChartInfoView, 0)
+	}
+
+	page := paging.GetPaging(currentIndex, pageSize, int(total))
+
+	// 因为是ES查找的，所以需要重新查一下图表的信息，主要是为了把是否授权字段找出来
+	if len(chartInfoList) > 0 {
+		sysUserIdList := make([]int, 0)
+		chartInfoIdList := make([]int, 0)
+		for _, v := range chartInfoList {
+			v.ConvertToResp()
+			v.HaveOperaAuth = true
+			chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
+
+			if v.SharedUserIdList != nil && len(v.SharedUserIdList) > 0 {
+				sysUserIdList = append(sysUserIdList, v.SharedUserIdList...)
+			}
+		}
+
+		// 获取图表数据
+		tmpChartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的图表失败，Err:" + err.Error()
+			return
+		}
+		chartInfoMap := make(map[int]*data_manage.ChartInfo)
+		for _, v := range tmpChartList {
+			chartInfoMap[v.ChartInfoId] = v
+		}
+
+		// 获取用户数据
+		sysUserMap := make(map[int]string)
+		if len(sysUserIdList) > 0 {
+			sysUserList, err := system.GetAdminListByIdList(sysUserIdList)
+			if err != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取分享用户列表失败，Err:" + err.Error()
+				return
+			}
+
+			for _, v := range sysUserList {
+				sysUserMap[v.AdminId] = v.RealName
+			}
+		}
+
+		for _, v := range chartInfoList {
+			tmpChartInfo, ok := chartInfoMap[v.ChartInfoId]
+			if !ok {
+				continue
+			}
+			v.IsJoinPermission = tmpChartInfo.IsJoinPermission
+
+			// 分享人
+			shareUserName := ``
+			shareUserNameList := make([]string, 0)
+			for _, userId := range v.SharedUserIdList {
+				userName, ok := sysUserMap[userId]
+				if !ok {
+					continue
+				}
+				shareUserNameList = append(shareUserNameList, userName)
+			}
+			if len(shareUserNameList) > 0 {
+				shareUserName = strings.Join(shareUserNameList, `,`)
+			}
+			v.SharedUserName = shareUserName
+
+		}
+	}
+
+	resp := data_manage.ChartInfoFilterDataResp{
+		Paging: page,
+		List:   chartInfoList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// BatchSave
+// @Title 批量图表设置共享
+// @Description 批量图表设置共享
+// @Param	request	body request.SetChartSharePermissionReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfo
+// @router /chart_info/share/batch_save [post]
+func (c *ChartInfoShareController) 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.SetChartSharePermissionReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	// 选中的图表id列表
+	selectChartInfoIdList := make([]int, 0)
+
+	// 选择所有图表，所以需要通过es获取数据
+	if req.IsSelectAll {
+		allEsChartInfoIdList, err := getAllChartInfoIdListByShared(req, c.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "设置失败！"
+			br.ErrMsg = "设置失败，Err:" + err.Error()
+			return
+		}
+
+		if len(req.NoChartIdList) <= 0 {
+			selectChartInfoIdList = allEsChartInfoIdList
+		} else {
+			noChartIdMap := make(map[int]bool)
+			for _, v := range req.NoChartIdList {
+				noChartIdMap[v] = true
+			}
+
+			for _, v := range allEsChartInfoIdList {
+				if _, ok := noChartIdMap[v]; !ok {
+					// 如果不在未选中的图表id列表中，那么就加入到选中的图表id列表
+					selectChartInfoIdList = append(selectChartInfoIdList, v)
+				}
+			}
+		}
+	} else {
+		selectChartInfoIdList = req.ChartIdList
+	}
+
+	if len(selectChartInfoIdList) > 30 {
+		br.Msg = `图表数量不能超过30个`
+		br.IsSendEmail = false
+		return
+	}
+
+	// 设置
+	{
+
+		obj := data_manage.ChartInfoShare{}
+		err = obj.SaveChartInfoShare(selectChartInfoIdList, req.UserIdList, req.ShareType)
+		if err != nil {
+			br.Msg = `保存失败`
+			br.ErrMsg = `保存失败：` + err.Error()
+			return
+		}
+
+		// 更新es
+		for _, chartInfoId := range selectChartInfoIdList {
+			data.EsAddOrEditChartInfo(chartInfoId)
+		}
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}
+
+// getAllChartInfoIdListByShared
+// @Description: 获取所有的图表id列表
+// @author: Roc
+// @datetime 2024-12-10 17:51:35
+// @param req request.SetChartSharePermissionReq
+// @param userId int
+// @return chartInfoIdList []int
+// @return err error
+func getAllChartInfoIdListByShared(req request.SetChartSharePermissionReq, userId int) (chartInfoIdList []int, err error) {
+	keyword := req.Keyword
+	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
+
+	//图表来源
+	sourceList := []int{utils.CHART_TYPE_CURVE}
+
+	// 图表分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	chartShareList := req.ChartShareList
+	if len(chartShareList) <= 0 {
+		chartShareList = []int{1}
+	}
+	chartShare := 1 // 0：全部，1：未共享，2：已共享
+	lenChartShareList := len(chartShareList)
+	if len(chartShareList) > 0 {
+		if lenChartShareList > 1 {
+			chartShare = 0
+		} else {
+			chartShare = chartShareList[0]
+		}
+	}
+
+	// 图表分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
+	chartClassifyIdList := req.ClassifyIdList
+
+	chartAuth := 1 // 选择范围是：只有我的图表
+
+	sortMap := make(map[string]string)
+	// 如果没有搜索关键词，则默认根据图表编码倒序排序
+	if keyword == `` {
+		sortMap["ChartInfoId"] = `desc`
+	}
+	_, chartInfoList, err := getAllChartInfoDataByShared(keyword, 1, chartShare, sourceList, chartClassifyIdList, chartAuth, userId, sortMap)
+	if err != nil {
+		return
+	}
+
+	// 返回图表id列表
+	for _, v := range chartInfoList {
+		chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
+	}
+
+	return
+}
+
+// getAllChartInfoDataByShared
+// @Description: 获取所有的图表列表（设置共享的时候）
+// @author: Roc
+// @datetime 2024-12-10 17:51:18
+// @param keyword string
+// @param currPage int
+// @param chartShare int
+// @param sourceList []int
+// @param classifyIdList []int
+// @param chartAuth int
+// @param sysUserId int
+// @param sortMap map[string]string
+// @return total int64
+// @return list []*data_manage.ChartInfoView
+// @return err error
+func getAllChartInfoDataByShared(keyword string, currPage, chartShare int, sourceList, classifyIdList []int, chartAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.ChartInfoView, err error) {
+	// 每页获取数据的数量
+	pageSize := 5000
+	var startSize int
+	if currPage <= 0 {
+		currPage = 1
+	}
+	startSize = paging.StartIndex(currPage, pageSize)
+
+	total, list, err = elastic.SearchChartInfoDataByShared(keyword, startSize, pageSize, chartShare, sourceList, classifyIdList, chartAuth, sysUserId, sortMap)
+	if err != nil {
+		return
+	}
+
+	page := paging.GetPaging(currPage, pageSize, int(total))
+	if !page.IsEnd {
+		_, nextList, tmpErr := getAllChartInfoDataByShared(keyword, page.NextIndex, chartShare, sourceList, classifyIdList, chartAuth, sysUserId, sortMap)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		list = append(list, nextList...)
+	}
+
+	return
+}

controllers/data_manage/chart_public.go

@@ -0,0 +1,518 @@
+package data_manage
+
+import (
+	"encoding/json"
+	"eta_gn/eta_api/controllers"
+	"eta_gn/eta_api/models"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/models/data_manage/request"
+	"eta_gn/eta_api/services/data"
+	dataApproveSerice "eta_gn/eta_api/services/data/data_approve"
+	"eta_gn/eta_api/services/elastic"
+	"eta_gn/eta_api/utils"
+	"github.com/rdlucklib/rdluck_tools/paging"
+	"strconv"
+	"strings"
+)
+
+// ChartPublicController 公共指标
+type ChartPublicController struct {
+	controllers.BaseAuthController
+}
+
+// Save
+// @Title 单个指标设置公开
+// @Description 单个指标设置公开
+// @Param	request	body request.SetChartInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfo
+// @router /chart_info/public/save [post]
+func (c *ChartPublicController) Save() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	var req request.SetChartPublicReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if len(req.ChartInfoList) <= 0 {
+		br.Msg = `请选择指标`
+		br.IsSendEmail = false
+	}
+
+	// 待处理的资产
+	dataPublicItemList := make([]dataApproveSerice.SetDataPublicItem, 0)
+
+	// 校验是否重复存在已公开、已提交的指标
+	{
+		chartInfoIdList := make([]int, 0)
+		for _, item := range req.ChartInfoList {
+			chartInfoIdList = append(chartInfoIdList, item.ChartInfoId)
+
+			dataPublicItemList = append(dataPublicItemList, dataApproveSerice.SetDataPublicItem{
+				DataId:     item.ChartInfoId,
+				ClassifyId: item.ClassifyId,
+			})
+		}
+
+		list, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+		if err != nil {
+			br.Msg = "保存失败！"
+			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
+			return
+		}
+		for _, v := range list {
+			if v.PublicStatus != utils.DataPublicDefault {
+				br.Msg = `选择指标中存在已经公开/提交审批的指标，请仅选择未公开指标！`
+				br.IsSendEmail = false
+				return
+			}
+		}
+	}
+
+	// 校验是否开启了审批流
+	opening, e := dataApproveSerice.CheckOpenApprove(utils.DataApproveTypeChart)
+	if e != nil {
+		br.Msg = "操作失败"
+		br.ErrMsg = "校验指标公开是否开启审批流失败, Err: " + e.Error()
+		return
+	}
+
+	// 是否忽略审批
+	var isIgnoreApprove bool
+	{
+		businessConf, e := models.GetBusinessConfByKey(models.IgnoreChartApproveUserId)
+		if e != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取商家配置失败, Err: " + e.Error()
+			return
+		}
+		ignoreChartApproveUserIdList := strings.Split(businessConf.ConfVal, `,`)
+		if utils.InArrayByStr(ignoreChartApproveUserIdList, strconv.Itoa(c.SysUser.AdminId)) {
+			isIgnoreApprove = true
+		}
+	}
+
+	chartInfo, err := data_manage.GetChartInfoById(req.ChartInfoList[0].ChartInfoId)
+	if err != nil {
+		br.Msg = "获取指标失败"
+		br.ErrMsg = "获取指标失败：" + err.Error()
+		return
+	}
+	title := chartInfo.ChartName
+	if len(req.ChartInfoList) > 1 {
+		title += `等指标`
+	}
+	title += `公开审批`
+
+	// 没开启审批流、或者无需审批
+	if !opening || isIgnoreApprove {
+		err = dataApproveSerice.UpdatePublicByDataList(utils.DataApproveTypeChart, dataApproveSerice.DataApproveStatePass, dataPublicItemList)
+	} else {
+		_, err = dataApproveSerice.SubmitDataApprove(utils.DataApproveTypeChart, dataPublicItemList, title, strings.TrimSpace(req.Description), c.SysUser.AdminId, c.SysUser.RealName)
+		if err != nil {
+			br.Msg = "提交审批失败"
+			br.ErrMsg = "提交审批失败, Err: " + err.Error()
+			return
+		}
+
+		// 更新ES
+		for _, dataPublicItem := range dataPublicItemList {
+			data.EsAddOrEditChartInfo(dataPublicItem.DataId)
+		}
+	}
+
+	if err != nil {
+		br.Msg = "编辑失败"
+		br.ErrMsg = "编辑失败,Err:" + err.Error()
+		return
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}
+
+// Cancel
+// @Title 撤销指标公开
+// @Description 撤销指标公开
+// @Param   ChartInfoId   query   int  true       "指标id"
+// @Success 200 {object} data_manage.ChartInfo
+// @router /chart_info/public/cancel [post]
+func (c *ChartPublicController) Cancel() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	// TODO 单个指标撤销的时候，需要校验状态，然后撤销
+	sysUser := c.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	chartInfoId, _ := c.GetInt("ChartInfoId")
+	if chartInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "参数错误"
+		return
+	}
+
+	var req request.SetChartPublicReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if len(req.ChartInfoList) <= 0 {
+		br.Msg = `请选择指标`
+		br.IsSendEmail = false
+	}
+
+	// 待处理的资产
+	dataPublicItemList := make([]dataApproveSerice.SetDataPublicItem, 0)
+
+	// 校验是否重复存在已公开、已提交的指标
+	{
+		chartInfoIdList := make([]int, 0)
+		for _, item := range req.ChartInfoList {
+			chartInfoIdList = append(chartInfoIdList, item.ChartInfoId)
+
+			dataPublicItemList = append(dataPublicItemList, dataApproveSerice.SetDataPublicItem{
+				DataId:     item.ChartInfoId,
+				ClassifyId: item.ClassifyId,
+			})
+		}
+
+		list, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+		if err != nil {
+			br.Msg = "保存失败！"
+			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
+			return
+		}
+		for _, v := range list {
+			if v.PublicStatus != utils.DataPublicDefault {
+				br.Msg = `选择指标中存在已经公开/提交审批的指标，请仅选择未公开指标！`
+				br.IsSendEmail = false
+				return
+			}
+		}
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+}
+
+// ListByEs
+// @Title 指标筛选接口
+// @Description 指标筛选接口
+// @Success 200 {object} data_manage.ChartInfoList
+// @Param	request	body request.SearchPublicChartReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfoFilterDataResp
+// @router /chart_info/public/list/es [post]
+func (c *ChartPublicController) ListByEs() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.SearchPublicChartReq
+	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, searchChartPublicList, sourceList, chartClassifyIdList, publicClassifyIdList, chartAuth, sortMap := data.GetChartSearchPar(req)
+
+	total, chartInfoList, err := elastic.SearchChartInfoDataByPublic(keyword, startSize, pageSize, searchChartPublicList, sourceList, chartClassifyIdList, publicClassifyIdList, chartAuth, c.SysUser.AdminId, sortMap)
+	if err != nil {
+		chartInfoList = make([]*data_manage.ChartInfoView, 0)
+	}
+
+	page := paging.GetPaging(currentIndex, pageSize, int(total))
+
+	// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+	if len(chartInfoList) > 0 {
+		chartInfoIdList := make([]int, 0)
+		for _, v := range chartInfoList {
+			v.ConvertToResp()
+			v.HaveOperaAuth = true
+			chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
+		}
+
+		tmpChartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+			return
+		}
+		chartInfoMap := make(map[int]*data_manage.ChartInfo)
+		for _, v := range tmpChartList {
+			chartInfoMap[v.ChartInfoId] = v
+		}
+
+		for _, v := range chartInfoList {
+			tmpChartInfo, ok := chartInfoMap[v.ChartInfoId]
+			if !ok {
+				continue
+			}
+			v.IsJoinPermission = tmpChartInfo.IsJoinPermission
+		}
+	}
+
+	resp := data_manage.ChartInfoFilterDataResp{
+		Paging: page,
+		List:   chartInfoList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// AllListByEs
+// @Title 指标筛选接口
+// @Description 指标筛选接口
+// @Success 200 {object} data_manage.ChartInfoList
+// @Param	request	body request.SearchChartInfoShareReq true "type json string"
+// @Success 200 {object} data_manage.ChartInfoFilterDataResp
+// @router /chart_info/public/list/es/all [post]
+func (c *ChartPublicController) AllListByEs() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.AllSearchPublicChartReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	// 选择所有指标，所以需要通过es获取数据
+
+	// 选中的指标id列表
+	chartInfoList := make([]*data_manage.ChartInfoView, 0)
+
+	// 选择所有指标，所以需要通过es获取数据
+	if req.IsSelectAll {
+		tmpChartInfoList, err := data.GetAllChartInfoListBySearchPublicChartReq(req.SearchPublicChartReq, c.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取指标列表失败！"
+			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
+			return
+		}
+
+		// 如果有过滤指标，那么就过滤吧
+		if len(req.NoChartIdList) > 0 {
+			noChartIdMap := make(map[int]bool)
+			for _, v := range req.NoChartIdList {
+				noChartIdMap[v] = true
+			}
+
+			for _, v := range tmpChartInfoList {
+				if _, ok := noChartIdMap[v.ChartInfoId]; !ok {
+					// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
+					chartInfoList = append(chartInfoList, v)
+				}
+			}
+		} else {
+			chartInfoList = tmpChartInfoList
+		}
+
+		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		if len(chartInfoList) > 0 {
+
+			chartInfoIdList := make([]int, 0)
+			for _, v := range chartInfoList {
+				v.ConvertToResp()
+				v.HaveOperaAuth = true
+				chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
+			}
+
+			tmpChartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+			if err != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+				return
+			}
+			chartInfoMap := make(map[int]*data_manage.ChartInfo)
+			for _, v := range tmpChartList {
+				chartInfoMap[v.ChartInfoId] = v
+			}
+
+			for _, v := range chartInfoList {
+				tmpChartInfo, ok := chartInfoMap[v.ChartInfoId]
+				if !ok {
+					continue
+				}
+				v.IsJoinPermission = tmpChartInfo.IsJoinPermission
+			}
+		}
+	} else {
+		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		if len(req.ChartIdList) > 0 {
+			chartInfoList, err = data_manage.GetChartInfoViewByIdList(req.ChartIdList)
+			if err != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+				return
+			}
+		}
+	}
+
+	resp := data_manage.ChartInfoFilterDataResp{
+		List: chartInfoList,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// BatchMoveChart
+// @Title 指标批量移动接口
+// @Description 指标批量移动接口
+// @Param	request	body request.MoveChartClassifyReq true "type json string"
+// @Success Ret=200 移动成功
+// @router /chart_info/public/batch_move [post]
+func (c *ChartPublicController) BatchMoveChart() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.MoveChartClassifyReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.NewClassifyId <= 0 {
+		br.Msg = `请选择要转移的新分类`
+		br.IsSendEmail = false
+		return
+	}
+
+	chartInfoIdList := make([]int, 0)
+	if req.IsSelectAll {
+		// 获取指标
+		chartInfoList, err := data.GetAllChartInfoListBySearchPublicChartReq(req.SearchPublicChartReq, c.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取指标列表失败！"
+			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
+			return
+		}
+		// 如果有过滤指标，那么就过滤吧
+		if len(req.NoChartIdList) > 0 {
+			noChartIdMap := make(map[int]bool)
+			for _, v := range req.NoChartIdList {
+				noChartIdMap[v] = true
+			}
+
+			for _, chartInfo := range chartInfoList {
+				if _, ok := noChartIdMap[chartInfo.ChartInfoId]; !ok {
+					if chartInfo.PublicStatus != utils.DataPublicSuccess {
+						br.Msg = `存在未公开的指标：` + chartInfo.ChartName
+						br.IsSendEmail = false
+						return
+					}
+
+					// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
+					chartInfoIdList = append(chartInfoIdList, chartInfo.ChartInfoId)
+				}
+			}
+		} else {
+			for _, chartInfo := range chartInfoList {
+				if chartInfo.PublicStatus != utils.DataPublicSuccess {
+					br.Msg = `存在未公开的指标：` + chartInfo.ChartName
+					br.IsSendEmail = false
+					return
+				}
+				chartInfoIdList = append(chartInfoIdList, chartInfo.ChartInfoId)
+			}
+		}
+	} else {
+		chartInfoList, err := data_manage.GetChartInfoViewByIdList(req.ChartIdList)
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+			return
+		}
+		for _, v := range chartInfoList {
+			if v.PublicStatus != utils.DataPublicSuccess {
+				br.Msg = `存在未公开的指标：` + v.ChartName
+				br.IsSendEmail = false
+				return
+			}
+		}
+		chartInfoIdList = req.ChartIdList
+	}
+
+	num := len(chartInfoIdList)
+	if num <= 0 {
+		br.Msg = `请选择要移动的指标！`
+		br.IsSendEmail = false
+		return
+	}
+	if num > 100 {
+		br.Msg = `最多只能选择100条指标！`
+		br.IsSendEmail = false
+		return
+	}
+
+	// 开始批量修改指标分类
+	if len(chartInfoIdList) > 0 {
+		err = data_manage.UpdatePublicClassifyIdByChartInfoIdList(chartInfoIdList, req.NewClassifyId)
+		if err != nil {
+			br.Msg = `指标移动失败！`
+			br.ErrMsg = `指标移动失败，ERR：` + err.Error()
+			return
+		}
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+}

controllers/data_manage/chart_public_classify.go

@@ -0,0 +1,479 @@
+package data_manage
+
+import (
+	"encoding/json"
+	"eta_gn/eta_api/controllers"
+	"eta_gn/eta_api/models"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/models/data_manage/request"
+	"eta_gn/eta_api/models/system"
+	"eta_gn/eta_api/services/data"
+	"eta_gn/eta_api/utils"
+	"sort"
+)
+
+// ChartPublicClassifyController 数据管理-公共分类模块
+type ChartPublicClassifyController struct {
+	controllers.BaseAuthController
+}
+
+// SimpleList
+// @Title 单层公共分类列表
+// @Description 单层公共分类列表
+// @Success 200 {object} data_manage.ChartClassifyListResp
+// @router /chart_public/classify/simple [get]
+func (c *ChartPublicClassifyController) SimpleList() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	// 目前只有图库会涉及到公共分类
+	source := utils.CHART_TYPE_CURVE
+
+	// 默认查一级公共分类和一级公共分类下的指标信息，
+	// 如果是 子级公共分类，查询该子级公共分类的下一级公共分类和指标信息
+	// 增加标识判断是文件夹还是指标列表
+	parentId, _ := c.GetInt("ParentId")
+
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	rootList, err := chartPublicClassifyObj.GetChartClassifyItemsByParentId(parentId, int8(source))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+	nodeAll := make([]*data_manage.ChartClassifyItems, 0)
+
+	var sortList data_manage.ChartClassifyItemList
+	if parentId > 0 {
+
+		allChartInfo, err := data_manage.GetChartInfoByPublicClassifyId(parentId, 0, source)
+		if err != nil {
+			br.Msg = "获取指标数据失败"
+			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
+			return
+		}
+
+		if len(allChartInfo) > 0 {
+			// 查询当前公共分类信息
+			for _, v := range allChartInfo {
+				v.HaveOperaAuth = true
+				button := data.GetChartOpButton(c.SysUser, v.SysUserId, v.HaveOperaAuth)
+				button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
+				v.Button = button
+				v.Children = make([]*data_manage.ChartClassifyItems, 0)
+				v.ParentId = parentId
+				nodeAll = append(nodeAll, v)
+			}
+		}
+
+	}
+	if len(rootList) > 0 {
+
+		for _, v := range rootList {
+			// 数据权限
+			v.HaveOperaAuth = true
+			// 按钮权限
+			button := data.GetChartClassifyOpButton(c.SysUser, v.SysUserId, v.HaveOperaAuth)
+			v.Button = button
+			v.Children = make([]*data_manage.ChartClassifyItems, 0)
+			nodeAll = append(nodeAll, v)
+		}
+	}
+	if len(nodeAll) > 0 {
+		//根据sort值排序
+		sortList = nodeAll
+		sort.Sort(sortList)
+	}
+
+	language := `CN`
+	// 指标显示的语言
+	{
+		configDetail, _ := system.GetConfigDetailByCode(c.SysUser.AdminId, system.ChartLanguageVar)
+		if configDetail != nil {
+			language = configDetail.ConfigValue
+		} else {
+			configDetail, _ = system.GetDefaultConfigDetailByCode(system.ChartLanguageVar)
+			if configDetail != nil {
+				language = configDetail.ConfigValue
+			}
+		}
+	}
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	button := data.GetChartClassifyOpButton(c.SysUser, 0, true)
+	if !button.AddButton {
+		canOpClassify = false
+	}
+
+	resp := new(data_manage.ChartClassifyListResp)
+	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.ChartClassifyListResp
+// @router /chart_public/classify/tree [get]
+func (c *ChartPublicClassifyController) ClassifyTree() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	// 公共分类来源筛选
+	classifyType := utils.CHART_TYPE_CURVE
+
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	allList, err := chartPublicClassifyObj.GetAllChartClassifyByType(int8(classifyType))
+	if err != nil && !utils.IsErrNoRow(err) {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取数据失败，Err:" + err.Error()
+		return
+	}
+
+	var sortList data_manage.ChartClassifyItemList
+	if len(allList) > 0 {
+		for k, v := range allList {
+			// 数据权限
+			v.HaveOperaAuth = true
+			// 按钮权限
+			button := data.GetChartClassifyOpButton(c.SysUser, v.SysUserId, v.HaveOperaAuth)
+			allList[k].Button = button
+		}
+		allList = data.GetChartClassifyTreeRecursive(allList, 0)
+		//根据sort值排序
+		sortList = allList
+		sort.Sort(sortList)
+	}
+	language := `CN`
+
+	// 是否允许添加一级公共分类
+	canOpClassify := true
+	button := data.GetChartClassifyOpButton(c.SysUser, 0, true)
+	if !button.AddButton {
+		canOpClassify = false
+	}
+
+	resp := new(data_manage.ChartClassifyListResp)
+	resp.AllNodes = sortList
+	resp.Language = language
+	resp.CanOpClassify = canOpClassify
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = resp
+}
+
+// AddChartClassify
+// @Title 新增公共分类
+// @Description 新增公共分类接口
+// @Param	request	body data_manage.AddChartClassifyReq true "type json string"
+// @Success 200 Ret=200 保存成功
+// @router /chart_public/classify/add [post]
+func (c *ChartPublicClassifyController) AddClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	var req data_manage.AddChartClassifyReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ChartClassifyName == "" {
+		br.Msg = "请输入公共分类名称"
+		br.IsSendEmail = false
+		return
+	}
+	if req.ParentId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+	// 公共分类来源筛选
+	source := utils.CHART_TYPE_CURVE
+
+	//添加指标
+	_, err, errMsg := data.AddChartPublicClassify(req.ChartClassifyName, req.ParentId, req.Level, source, c.SysUser.AdminId, c.SysUser.RealName)
+	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.GetChartClassifyCount(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.GetChartClassifyMaxSort(req.ParentId, req.ClassifyType)
+	//
+	//classify := new(data_manage.ChartClassify)
+	//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 = c.SysUser.AdminId
+	//classify.SysUserRealName = c.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.AddChartClassify(classify)
+	//if err != nil {
+	//	br.Msg = "保存公共分类失败"
+	//	br.ErrMsg = "保存公共分类失败,Err:" + err.Error()
+	//	return
+	//}
+	br.Ret = 200
+	br.Msg = "新增成功"
+	br.Success = true
+	br.IsAddLog = true
+}
+
+// EditChartClassify
+// @Title 修改公共分类
+// @Description 修改公共分类接口
+// @Param	request	body data_manage.EditChartClassifyReq true "type json string"
+// @Success 200 Ret=200 修改成功
+// @router /chart_public/classify/edit [post]
+func (c *ChartPublicClassifyController) EditChartClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	var req data_manage.EditChartClassifyReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ChartClassifyName == "" {
+		br.Msg = "请输入公共分类名称"
+		br.IsSendEmail = false
+		return
+	}
+
+	if req.ChartClassifyId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	err, errMsg := data.EditChartPublicClassify(req.ChartClassifyId, req.ChartClassifyName, c.SysUser)
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = errMsg + ";Err:" + err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	br.Ret = 200
+	br.Msg = "修改成功"
+	br.Success = true
+	br.IsAddLog = true
+}
+
+// DeleteChartClassifyCheck
+// @Title 删除检测接口
+// @Description 删除检测接口
+// @Param	request	body request.PublicClassifyDeleteCheckReq true "type json string"
+// @Success 200 Ret=200 检测成功
+// @router /chart_public/classify/delete/check [post]
+func (c *ChartPublicClassifyController) DeleteClassifyCheck() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req request.PublicClassifyDeleteCheckReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+	deleteStatus, tipsMsg, _, tableList, err, errMsg := data.DeleteChartPublicClassifyCheck(req.ClassifyId, c.SysUser)
+	if errMsg != `` {
+		br.Msg = errMsg
+		br.ErrMsg = errMsg
+		if err != nil {
+			br.ErrMsg = err.Error()
+		} else {
+			br.IsSendEmail = false
+		}
+		return
+	}
+	if c.Lang == "en" {
+		if utils.ViperConfig.InConfig(tipsMsg) {
+			tipsMsg = utils.ViperConfig.GetString(tipsMsg)
+		}
+	}
+
+	//var deleteStatus int
+	//var tipsMsg string
+	////删除公共分类
+	//if req.ClassifyId > 0 && req.ChartInfoId == 0 {
+	//	//判断公共分类下，是否含有指标
+	//	count, err := data_manage.GetChartInfoCountByClassifyId(req.ClassifyId)
+	//	if err != nil {
+	//		br.Msg = "删除失败"
+	//		br.ErrMsg = "公共分类下是否含有指标失败，Err:" + err.Error()
+	//		return
+	//	}
+	//
+	//	if count > 0 {
+	//		deleteStatus = 1
+	//		tipsMsg = "若目录关联指标不可删除"
+	//	}
+	//}
+	//
+	//if deleteStatus != 1 && req.ChartInfoId == 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.ChartInfoId > 0 {
+	//	//判断指标是否用于作图，如果用于作图，则不可删除
+	//	chartCount, err := data_manage.GetChartChartMappingCount(req.ChartInfoId)
+	//	if err != nil && !utils.IsErrNoRow(err) {
+	//		br.Msg = "删除失败"
+	//		br.ErrMsg = "判断指标是否被用于作图失败，Err:" + err.Error()
+	//		return
+	//	}
+	//	if chartCount > 0 {
+	//		deleteStatus = 3
+	//		tipsMsg = "当前指标已用作画图，不可删除"
+	//	}
+	//	//判断指标是否用于计算
+	//	{
+	//		calculateCount, err := data_manage.GetChartInfoCalculateMappingCount(req.ChartInfoId)
+	//		if err != nil && !utils.IsErrNoRow(err) {
+	//			br.Msg = "删除失败"
+	//			br.ErrMsg = "判断指标是否被用于计算失败，GetChartInfoCalculateCount 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
+}
+
+// DeleteChartClassify
+// @Title 删除公共分类/指标
+// @Description 删除公共分类/指标接口
+// @Param	request	body request.PublicClassifyDeleteCheckReq true "type json string"
+// @Success 200 Ret=200 删除成功
+// @router /chart_public/classify/delete [post]
+func (c *ChartPublicClassifyController) DeleteClassify() {
+	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.PublicClassifyDeleteCheckReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	nextItem, _, err, errMsg := data.DeleteChartPublicClassify(req.ClassifyId, sysUser, string(c.Ctx.Input.RequestBody), c.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.AddChartInfoResp{}
+	if nextItem != nil {
+		resp = data_manage.AddChartInfoResp{
+			ChartInfoId: nextItem.ChartInfoId,
+			UniqueCode:  nextItem.UniqueCode,
+		}
+	}
+
+	br.Ret = 200
+	br.Msg = "删除成功"
+	br.Success = true
+	br.IsAddLog = true
+	br.Data = resp
+}

controllers/data_manage/edb_info_share.go

@@ -378,8 +378,8 @@ func (c *EdbInfoShareController) ListByEs() {
 	//指标来源
 	sourceList := req.SourceList
 
-	edbInfoType := 0        // 普通指标
-	edbTypeList := []int{2} // 普通指标中的计算指标
+	edbInfoType := 0                             // 普通指标
+	edbTypeList := []int{utils.EdbTypeCalculate} // 普通指标中的计算指标
 
 	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未全部
 	edbShareList := req.EdbShareList
@@ -606,8 +606,8 @@ func getAllEdbInfoIdListByShared(req request.SetEdbSharePermissionReq, userId in
 	//指标来源
 	sourceList := req.SourceList
 
-	edbInfoType := 0        // 普通指标
-	edbTypeList := []int{2} // 普通指标中的计算指标
+	edbInfoType := 0                             // 普通指标
+	edbTypeList := []int{utils.EdbTypeCalculate} // 普通指标中的计算指标
 
 	// 指标分享状态：1-未共享；2-已共享。可多选，多选用英文,隔开；默认是未共享
 	edbShareList := req.EdbShareList

controllers/data_manage/edb_public_classify.go

@@ -635,557 +635,3 @@ func (c *EdbPublicClassifyController) ListV2() {
 	br.Msg = "获取成功"
 	br.Data = resp
 }
-
-// Items
-// @Title 获取所有公共分类接口-不包含指标
-// @Description 获取所有公共分类接口-不包含指标
-// @Success 200 {object} data_manage.EdbClassifyListResp
-// @router /edb_public/classify/items [get]
-func (c *EdbPublicClassifyController) Items() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		c.Data["json"] = br
-		c.ServeJSON()
-	}()
-	// 公共分类来源筛选
-	classifyType, _ := c.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), c.SysUser.AdminId)
-	if err != nil {
-		br.Msg = "获取失败"
-		br.ErrMsg = "获取数据失败，Err:" + err.Error()
-		return
-	}
-
-	//classifyAll, err := data_manage.GetEdbClassifyAll()
-	classifyAll, err := data_manage.GetChildEdbClassifyByClassifyType(classifyType, c.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
-}
-
-// EdbClassifyMove
-// @Title 公共分类移动接口
-// @Description 公共分类移动接口
-// @Success 200 {object} data_manage.MoveEdbClassifyReq
-// @router /edb_classify/move [post]
-func (c *EdbPublicClassifyController) EdbClassifyMove() {
-	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 data_manage.MoveEdbClassifyReq
-	err := json.Unmarshal(c.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 (c *EdbPublicClassifyController) ItemsV2() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		c.Data["json"] = br
-		c.ServeJSON()
-	}()
-	// 公共分类来源筛选
-	classifyType, _ := c.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), c.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, c.SysUser.AdminId)
-	if err != nil && !utils.IsErrNoRow(err) {
-		br.Msg = "获取失败"
-		br.ErrMsg = "获取数据失败，Err:" + err.Error()
-		return
-	}
-	// 已授权公共分类id
-	permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(c.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(c.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(c.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(c.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(c.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(c.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 (c *EdbPublicClassifyController) ClassifyEdbInfoList() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		c.Data["json"] = br
-		c.ServeJSON()
-	}()
-
-	classifyId, _ := c.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(c.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(c.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(c.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(c.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 (c *EdbPublicClassifyController) ItemsV3() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		c.Data["json"] = br
-		c.ServeJSON()
-	}()
-	// 公共分类来源筛选
-	classifyType, _ := c.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), c.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(c.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(c.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(c.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(c.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(c.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(c.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(c.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(c.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/fix.go

@@ -698,7 +698,7 @@ func initEs() {
 	// 更新ES中的指标数据
 	data.AddOrEditAllEdbInfoToEs()
 	// 更新es中的图表数据
-	//data.AddAllChartInfo()
+	data.AddAllChartInfo()
 
 	fmt.Println("全部es数据修复完成")
 }

models/data_manage/chart_classify.go

@@ -353,6 +353,25 @@ func GetChartClassifyByIdList(classifyIdList []int) (items []*ChartClassify, err
 	return
 }
 
+// GetChartClassifyItemsByIdList
+// @Description:  根据分类ID列表获取分类
+// @author: Roc
+// @datetime 2024-04-01 13:21:48
+// @param classifyId []int
+// @return items []*ChartClassify
+// @return err error
+func GetChartClassifyItemsByIdList(classifyIdList []int) (items []*ChartClassifyItems, err error) {
+	num := len(classifyIdList)
+	if num <= 0 {
+		return
+	}
+	o := global.DmSQL["data"]
+	sql := `SELECT * FROM chart_classify WHERE chart_classify_id in (` + utils.GetOrmInReplace(num) + `) `
+	err = o.Raw(sql, classifyIdList).Scan(&items).Error
+
+	return
+}
+
 // GetChartClassifyBySourceAndIsJoinPermission
 // @Description: 根据分类类型和是否涉密获取分类列表
 // @author: Roc
@@ -527,3 +546,17 @@ func UpdateChartClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, ne
 
 	return
 }
+
+type ChartClassifyItemList []*ChartClassifyItems
+
+func (m ChartClassifyItemList) Len() int {
+	return len(m)
+}
+
+func (m ChartClassifyItemList) Less(i, j int) bool {
+	return m[i].Sort < m[j].Sort
+}
+
+func (m ChartClassifyItemList) Swap(i, j int) {
+	m[i], m[j] = m[j], m[i]
+}

models/data_manage/chart_info.go

@@ -16,51 +16,54 @@ import (
 )
 
 type ChartInfo struct {
-	ChartInfoId       int    `orm:"column(chart_info_id);pk" gorm:"primaryKey" `
-	ChartName         string `description:"图表名称"`
-	ChartNameEn       string `description:"英文图表名称"`
-	ChartClassifyId   int    `description:"图表分类id"`
-	SysUserId         int
-	SysUserRealName   string
-	UniqueCode        string `description:"图表唯一编码"`
-	CreateTime        time.Time
-	ModifyTime        time.Time
-	DateType          int    `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
-	StartDate         string `description:"自定义开始日期"`
-	EndDate           string `description:"自定义结束日期"`
-	IsSetName         int    `description:"设置名称"`
-	EdbInfoIds        string `description:"指标id"`
-	ChartType         int    `description:"生成样式:1:曲线图,2:季节性图,3:面积图，4：柱状图，5：散点图，6：组合图，7：柱方图，8：商品价格曲线图，9：相关性图，10:截面散点图, 11：雷达图"`
-	Calendar          string `description:"公历/农历"`
-	SeasonStartDate   string `description:"季节性图开始日期"`
-	SeasonEndDate     string `description:"季节性图开始日期"`
-	ChartImage        string `description:"图表图片"`
-	Sort              int    `description:"排序字段，数字越小越排前面"`
-	XMin              string `description:"图表X轴最小值"`
-	XMax              string `description:"图表X轴最大值"`
-	LeftMin           string `description:"图表左侧最小值"`
-	LeftMax           string `description:"图表左侧最大值"`
-	RightMin          string `description:"图表右侧最小值"`
-	RightMax          string `description:"图表右侧最大值"`
-	Right2Min         string `description:"图表右侧2最小值"`
-	Right2Max         string `description:"图表右侧2最大值"`
-	MinMaxSave        int    `description:"是否手动保存过上下限：0-否；1-是"`
-	Disabled          int    `description:"是否禁用，0：启用，1：禁用，默认：0"`
-	BarConfig         string `description:"柱方图的配置，json数据"`
-	Source            int    `description:"1：ETA图库；2：商品价格曲线"`
-	ExtraConfig       string `description:"图表额外配置,json数据"`
-	SeasonExtraConfig string `description:"季节性图表中的配置,json数据"`
-	StartYear         int    `description:"当选择的日期类型为最近N年类型时，即date_type=20, 用start_year表示N"`
-	ChartThemeId      int    `description:"图表应用主题ID"`
-	SourcesFrom       string `description:"图表来源"`
-	Instructions      string `description:"图表说明"`
-	MarkersLines      string `description:"标识线"`
-	MarkersAreas      string `description:"标识区"`
-	Unit              string `description:"中文单位名称"`
-	UnitEn            string `description:"英文单位名称"`
-	IsJoinPermission  int    `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
-	ForumChartInfoId  int    `description:"社区的图表ID"`
-	ChartAlias        string `description:"图表别名"`
+	ChartInfoId         int    `orm:"column(chart_info_id);pk" gorm:"primaryKey" `
+	ChartName           string `description:"图表名称"`
+	ChartNameEn         string `description:"英文图表名称"`
+	ChartClassifyId     int    `description:"图表分类id"`
+	SysUserId           int
+	SysUserRealName     string
+	UniqueCode          string `description:"图表唯一编码"`
+	CreateTime          time.Time
+	ModifyTime          time.Time
+	DateType            int       `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
+	StartDate           string    `description:"自定义开始日期"`
+	EndDate             string    `description:"自定义结束日期"`
+	IsSetName           int       `description:"设置名称"`
+	EdbInfoIds          string    `description:"指标id"`
+	ChartType           int       `description:"生成样式:1:曲线图,2:季节性图,3:面积图，4：柱状图，5：散点图，6：组合图，7：柱方图，8：商品价格曲线图，9：相关性图，10:截面散点图, 11：雷达图"`
+	Calendar            string    `description:"公历/农历"`
+	SeasonStartDate     string    `description:"季节性图开始日期"`
+	SeasonEndDate       string    `description:"季节性图开始日期"`
+	ChartImage          string    `description:"图表图片"`
+	Sort                int       `description:"排序字段，数字越小越排前面"`
+	XMin                string    `description:"图表X轴最小值"`
+	XMax                string    `description:"图表X轴最大值"`
+	LeftMin             string    `description:"图表左侧最小值"`
+	LeftMax             string    `description:"图表左侧最大值"`
+	RightMin            string    `description:"图表右侧最小值"`
+	RightMax            string    `description:"图表右侧最大值"`
+	Right2Min           string    `description:"图表右侧2最小值"`
+	Right2Max           string    `description:"图表右侧2最大值"`
+	MinMaxSave          int       `description:"是否手动保存过上下限：0-否；1-是"`
+	Disabled            int       `description:"是否禁用，0：启用，1：禁用，默认：0"`
+	BarConfig           string    `description:"柱方图的配置，json数据"`
+	Source              int       `description:"1：ETA图库；2：商品价格曲线"`
+	ExtraConfig         string    `description:"图表额外配置,json数据"`
+	SeasonExtraConfig   string    `description:"季节性图表中的配置,json数据"`
+	StartYear           int       `description:"当选择的日期类型为最近N年类型时，即date_type=20, 用start_year表示N"`
+	ChartThemeId        int       `description:"图表应用主题ID"`
+	SourcesFrom         string    `description:"图表来源"`
+	Instructions        string    `description:"图表说明"`
+	MarkersLines        string    `description:"标识线"`
+	MarkersAreas        string    `description:"标识区"`
+	Unit                string    `description:"中文单位名称"`
+	UnitEn              string    `description:"英文单位名称"`
+	IsJoinPermission    int       `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	ForumChartInfoId    int       `description:"社区的图表ID"`
+	ChartAlias          string    `description:"图表别名"`
+	PublicStatus        int       `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
+	EdbPublicClassifyId int       `description:"指标公开分类id"`
+	PublicTime          time.Time `description:"设置公开的时间"`
 }
 
 type ChartInfoMore struct {
@@ -152,6 +155,68 @@ type ChartInfoSearchResp struct {
 	Status     int            `description:"1:数据已存在于国能数据库，2:新数据"`
 }
 
+// ChartEsInfo
+// @Description: Es中的数据
+type ChartEsInfo struct {
+	ChartInfoId         int    `orm:"column(chart_info_id);pk" gorm:"primaryKey" `
+	ChartName           string `description:"图表名称"`
+	ChartNameEn         string `description:"英文图表名称"`
+	ChartClassifyId     int    `description:"图表分类id"`
+	SysUserId           int
+	SysUserRealName     string
+	UniqueCode          string `description:"图表唯一编码"`
+	CreateTime          time.Time
+	ModifyTime          time.Time
+	DateType            int       `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
+	StartDate           string    `description:"自定义开始日期"`
+	EndDate             string    `description:"自定义结束日期"`
+	IsSetName           int       `description:"设置名称"`
+	EdbInfoIds          string    `description:"指标id"`
+	ChartType           int       `description:"生成样式:1:曲线图,2:季节性图,3:面积图，4：柱状图，5：散点图，6：组合图，7：柱方图，8：商品价格曲线图，9：相关性图，10:截面散点图, 11：雷达图"`
+	Calendar            string    `description:"公历/农历"`
+	SeasonStartDate     string    `description:"季节性图开始日期"`
+	SeasonEndDate       string    `description:"季节性图开始日期"`
+	ChartImage          string    `description:"图表图片"`
+	Sort                int       `description:"排序字段，数字越小越排前面"`
+	XMin                string    `description:"图表X轴最小值"`
+	XMax                string    `description:"图表X轴最大值"`
+	LeftMin             string    `description:"图表左侧最小值"`
+	LeftMax             string    `description:"图表左侧最大值"`
+	RightMin            string    `description:"图表右侧最小值"`
+	RightMax            string    `description:"图表右侧最大值"`
+	Right2Min           string    `description:"图表右侧2最小值"`
+	Right2Max           string    `description:"图表右侧2最大值"`
+	MinMaxSave          int       `description:"是否手动保存过上下限：0-否；1-是"`
+	Disabled            int       `description:"是否禁用，0：启用，1：禁用，默认：0"`
+	BarConfig           string    `description:"柱方图的配置，json数据"`
+	Source              int       `description:"1：ETA图库；2：商品价格曲线"`
+	ExtraConfig         string    `description:"图表额外配置,json数据"`
+	SeasonExtraConfig   string    `description:"季节性图表中的配置,json数据"`
+	StartYear           int       `description:"当选择的日期类型为最近N年类型时，即date_type=20, 用start_year表示N"`
+	ChartThemeId        int       `description:"图表应用主题ID"`
+	SourcesFrom         string    `description:"图表来源"`
+	Instructions        string    `description:"图表说明"`
+	MarkersLines        string    `description:"标识线"`
+	MarkersAreas        string    `description:"标识区"`
+	Unit                string    `description:"中文单位名称"`
+	UnitEn              string    `description:"英文单位名称"`
+	IsJoinPermission    int       `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	ForumChartInfoId    int       `description:"社区的图表ID"`
+	ChartAlias          string    `description:"图表别名"`
+	SharedUserIdList    []int     `description:"共享用户id列表" gorm:"-"`
+	PublicStatus        int       `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
+	EdbPublicClassifyId int       `description:"指标公开分类id"`
+	PublicTime          time.Time `description:"设置公开的时间"`
+}
+
+func GetChartEsInfoById(chartInfoId int) (item *ChartEsInfo, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT * FROM chart_info WHERE chart_info_id=? `
+	err = o.Raw(sql, chartInfoId).First(&item).Error
+
+	return
+}
+
 func GetChartInfoById(chartInfoId int) (item *ChartInfo, err error) {
 	o := global.DmSQL["data"]
 	sql := ` SELECT * FROM chart_info WHERE chart_info_id=? `
@@ -1933,22 +1998,27 @@ type ChartInfoView struct {
 	BarConfig         string               `description:"柱方图的配置，json数据" json:"-"`
 	Source            int                  `description:"1：ETA图库；2：商品价格曲线；3：相关性图表"`
 	//CorrelationLeadUnit string `description:"相关性图表-领先单位"`
-	ExtraConfig       string          `description:"图表额外配置,json数据"`
-	ChartSource       string          `description:"图表来源str"`
-	ChartSourceEn     string          `description:"图表来源（英文）"`
-	Button            ChartViewButton `gorm:"-" description:"操作按钮"`
-	SeasonExtraConfig string          `description:"季节性图表中的配置,json数据"`
-	StartYear         int             `description:"当选择的日期类型为最近N年类型时，即date_type=20, 用start_year表示N"`
-	ChartThemeId      int             `description:"图表应用主题ID"`
-	ChartThemeStyle   string          `description:"图表应用主题样式"`
-	SourcesFrom       string          `description:"图表来源"`
-	Instructions      string          `description:"图表说明"`
-	MarkersLines      string          `description:"标识线"`
-	MarkersAreas      string          `description:"标识区"`
-	IsJoinPermission  int             `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
-	HaveOperaAuth     bool            `description:"是否有数据权限，默认：false"`
-	ForumChartInfoId  int             `description:"社区的图表ID"`
-	ChartAlias        string          `description:"图表别名"`
+	ExtraConfig         string          `description:"图表额外配置,json数据"`
+	ChartSource         string          `description:"图表来源str"`
+	ChartSourceEn       string          `description:"图表来源（英文）"`
+	Button              ChartViewButton `gorm:"-" description:"操作按钮"`
+	SeasonExtraConfig   string          `description:"季节性图表中的配置,json数据"`
+	StartYear           int             `description:"当选择的日期类型为最近N年类型时，即date_type=20, 用start_year表示N"`
+	ChartThemeId        int             `description:"图表应用主题ID"`
+	ChartThemeStyle     string          `description:"图表应用主题样式"`
+	SourcesFrom         string          `description:"图表来源"`
+	Instructions        string          `description:"图表说明"`
+	MarkersLines        string          `description:"标识线"`
+	MarkersAreas        string          `description:"标识区"`
+	IsJoinPermission    int             `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	HaveOperaAuth       bool            `description:"是否有数据权限，默认：false"`
+	ForumChartInfoId    int             `description:"社区的图表ID"`
+	ChartAlias          string          `description:"图表别名"`
+	SharedUserIdList    []int           `description:"共享用户id列表" gorm:"-"`
+	SharedUserName      string          `description:"共享用户姓名，多个用英文,隔开" gorm:"-"`
+	PublicStatus        int             `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
+	EdbPublicClassifyId int             `description:"指标公开分类id"`
+	PublicTime          time.Time       `description:"设置公开的时间"`
 }
 
 type ChartViewButton struct {

models/data_manage/chart_info_resp.go

@@ -1,6 +1,9 @@
 package data_manage
 
-import "eta_gn/eta_api/utils"
+import (
+	"eta_gn/eta_api/utils"
+	"github.com/rdlucklib/rdluck_tools/paging"
+)
 
 // ConvertToResp
 // @Description: 转成需要输出的格式
@@ -29,3 +32,9 @@ func (m *ChartInfoView) ConvertToResp() {
 
 	return
 }
+
+// ChartInfoFilterDataResp 搜索指标列表数据返回
+type ChartInfoFilterDataResp struct {
+	Paging *paging.PagingItem
+	List   []*ChartInfoView
+}

models/data_manage/edb_classify.go

@@ -300,6 +300,7 @@ type ExcelBaseInfo struct {
 	//SysUserId       int    `description:"操作人id"`
 	//SysUserRealName string `description:"操作人真实姓名"`
 }
+
 type ClassifyDeleteCheckReq struct {
 	ClassifyId int `description:"分类id"`
 	EdbInfoId  int `description:"指标id"`

models/data_manage/public_chart_classify.go

@@ -103,13 +103,13 @@ func (m ChartPublicClassify) GetChartClassifyById(classifyId int) (item *ChartPu
 // @receiver m
 // @datetime 2024-12-03 13:57:48
 // @param parentId int
-// @param classifyType int8
+// @param source int8
 // @return items []*ChartPublicClassify
 // @return err error
-func (m ChartPublicClassify) GetChartClassifyListByParentId(parentId int, classifyType int8) (items []*ChartPublicClassify, err error) {
+func (m ChartPublicClassify) GetChartClassifyListByParentId(parentId int, source int8) (items []*ChartPublicClassify, err error) {
 	o := global.DmSQL["data"]
-	sql := `SELECT * FROM chart_public_classify WHERE parent_id=? AND classify_type = ? order by sort asc,chart_public_classify_id asc `
-	err = o.Raw(sql, parentId, classifyType).Find(&items).Error
+	sql := `SELECT * FROM chart_public_classify WHERE parent_id=? AND source = ? order by sort asc,chart_public_classify_id asc `
+	err = o.Raw(sql, parentId, source).Find(&items).Error
 
 	return
 }
@@ -120,11 +120,11 @@ func (m ChartPublicClassify) GetChartClassifyListByParentId(parentId int, classi
 // @receiver m
 // @datetime 2024-12-03 13:56:18
 // @param parentId int
-// @param classifyType int8
+// @param source int8
 // @return items []*ChartClassifyItems
 // @return err error
-func (m ChartPublicClassify) GetChartClassifyItemsByParentId(parentId int, classifyType int8) (items []*ChartClassifyItems, err error) {
-	list, err := m.GetChartClassifyListByParentId(parentId, classifyType)
+func (m ChartPublicClassify) GetChartClassifyItemsByParentId(parentId int, source int8) (items []*ChartClassifyItems, err error) {
+	list, err := m.GetChartClassifyListByParentId(parentId, source)
 	if err != nil {
 		return
 	}
@@ -142,20 +142,20 @@ func (m ChartPublicClassify) GetChartClassifyItemsByParentId(parentId int, class
 // @receiver m
 // @datetime 2024-12-03 13:57:48
 // @param parentId int
-// @param classifyType int8
+// @param source int8
 // @return items []*ChartPublicClassify
 // @return err error
-func (m ChartPublicClassify) GetChartClassifyListByType(classifyType int8) (items []*ChartPublicClassify, err error) {
+func (m ChartPublicClassify) GetChartClassifyListByType(source int8) (items []*ChartPublicClassify, err error) {
 	o := global.DmSQL["data"]
-	sql := `SELECT * FROM chart_public_classify WHERE classify_type = ? order by sort asc,chart_public_classify_id asc `
-	err = o.Raw(sql, classifyType).Find(&items).Error
+	sql := `SELECT * FROM chart_public_classify WHERE source = ? order by sort asc,chart_public_classify_id asc `
+	err = o.Raw(sql, source).Find(&items).Error
 
 	return
 }
 
 // GetAllChartClassifyByType 根据类型获取分类列表
-func (m ChartPublicClassify) GetAllChartClassifyByType(classifyType int8) (items []*ChartClassifyItems, err error) {
-	list, err := m.GetChartClassifyListByType(int8(classifyType))
+func (m ChartPublicClassify) GetAllChartClassifyByType(source int8) (items []*ChartClassifyItems, err error) {
+	list, err := m.GetChartClassifyListByType(int8(source))
 	if err != nil {
 		return
 	}
@@ -167,9 +167,9 @@ func (m ChartPublicClassify) GetAllChartClassifyByType(classifyType int8) (items
 	return
 }
 
-func (m ChartPublicClassify) GetChartClassifyCount(classifyName string, parentId int, classifyType uint8) (count int, err error) {
-	sql := `SELECT COUNT(1) AS count FROM chart_public_classify WHERE parent_id=? AND chart_public_classify_name=? AND classify_type = ?  `
-	err = global.DmSQL["data"].Raw(sql, parentId, classifyName, classifyType).Scan(&count).Error
+func (m ChartPublicClassify) GetChartClassifyCount(classifyName string, parentId int, source int) (count int, err error) {
+	sql := `SELECT COUNT(1) AS count FROM chart_public_classify WHERE parent_id=? AND chart_public_classify_name=? AND source = ?  `
+	err = global.DmSQL["data"].Raw(sql, parentId, classifyName, source).Scan(&count).Error
 
 	return
 }
@@ -212,9 +212,9 @@ func (m *ChartPublicClassify) UpdateChartClassifyNameAndNamePath(cols []string,
 }
 
 // GetChartClassifyMaxSort 获取分类下最大的排序数
-func (m ChartPublicClassify) GetChartClassifyMaxSort(parentId int, classifyType uint8) (sort int, err error) {
-	sql := `SELECT COALESCE(Max(sort), 0) AS sort FROM chart_public_classify WHERE parent_id=? AND classify_type=? `
-	err = global.DmSQL["data"].Raw(sql, parentId, classifyType).Scan(&sort).Error
+func (m ChartPublicClassify) GetChartClassifyMaxSort(parentId int, source int) (sort int, err error) {
+	sql := `SELECT COALESCE(Max(sort), 0) AS sort FROM chart_public_classify WHERE parent_id=? AND source=? `
+	err = global.DmSQL["data"].Raw(sql, parentId, source).Scan(&sort).Error
 
 	return
 }
@@ -257,3 +257,12 @@ func (m *ChartPublicClassify) BatchesDel(classifyIdList []int) (err error) {
 
 	return
 }
+
+// GetChartPublicClassifyByParentIdAndName 根据父级ID和名称获取分类
+func GetChartPublicClassifyByParentIdAndName(source, parentId int, classifyName string, classifyId int) (item *ChartClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := `SELECT * FROM chart_public_classify WHERE source = ? AND parent_id = ? AND chart_public_classify_name = ? AND chart_public_classify_id <> ? LIMIT 1`
+	err = o.Raw(sql, source, parentId, classifyName, classifyId).First(&item).Error
+
+	return
+}

models/data_manage/public_chart_info.go

@@ -11,19 +11,19 @@ import (
 // @datetime 2024-12-03 14:09:32
 // @param classifyId int
 // @param chartInfoType int
-// @param chartType int
+// @param source int
 // @return items []*ChartClassifyItems
 // @return err error
-func GetChartInfoByPublicClassifyId(classifyId, chartInfoType, chartType int) (items []*ChartClassifyItems, err error) {
+func GetChartInfoByPublicClassifyId(classifyId, chartInfoType, source int) (items []*ChartClassifyItems, err error) {
 	o := global.DmSQL["data"]
 	sql := ` SELECT chart_info_id,classify_id,chart_name AS classify_name,chart_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,chart_code,chart_type, sort,is_join_permission FROM chart_info WHERE chart_public_classify_id = ? AND chart_info_type = ?`
 
 	pars := []interface{}{classifyId, chartInfoType}
 
 	// 如果筛选了指标类型，那么就根据条件来
-	if chartType > 0 {
-		sql += ` AND chart_type = ? `
-		pars = append(pars, chartType)
+	if source > 0 {
+		sql += ` AND source = ? `
+		pars = append(pars, source)
 	}
 
 	sql += ` order by sort asc,chart_info_id asc `

models/data_manage/public_edb_classify.go

@@ -255,3 +255,11 @@ func (m *EdbPublicClassify) BatchesDel(classifyIdList []int) (err error) {
 
 	return
 }
+
+// GetEdbPublicClassifyByParentIdAndName 根据父级ID和名称获取分类
+func GetEdbPublicClassifyByParentIdAndName(parentId int, classifyName string, classifyId int, classifyType uint8) (item *EdbClassify, err error) {
+	sql := `SELECT * FROM edb_public_classify WHERE parent_id = ? AND edb_public_classify_name = ? AND edb_public_classify_id <> ? and classify_type=? LIMIT 1`
+	err = global.DmSQL["data"].Raw(sql, parentId, classifyName, classifyId, classifyType).First(&item).Error
+
+	return
+}

models/data_manage/request/chart_info_share.go

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

models/data_manage/request/public_chart.go

@@ -0,0 +1,51 @@
+package request
+
+// SetChartPublicReq
+// @Description: 设置指标公开的请求
+type SetChartPublicReq struct {
+	ChartInfoList []SetChartPublicChartReq `description:"待设置的指标"`
+	Description   string                   `description:"备注"`
+}
+
+// CancelChartPublicReq
+// @Description: 撤销指标公开的请求
+type CancelChartPublicReq struct {
+	ChartInfoId int    `description:"待设置的指标"`
+	Description string `description:"备注"`
+}
+
+type SetChartPublicChartReq struct {
+	ChartInfoId int `description:"指标id列表"`
+	ClassifyId  int `description:"公共分类id"`
+}
+
+// SearchPublicChartReq
+// @Description: 获取指标列表（设置公开的时候）请求结构体
+type SearchPublicChartReq struct {
+	ChartPublicList      []int  `description:"指标公开状态：1：未公开，2：已提交；3：已公开。可多选，默认是未公开"`
+	SourceList           []int  `description:"来源id"`
+	Keyword              string `description:"关键字"`
+	ClassifyIdList       []int  `description:"指标分类选择，如果不指定分类，那么就是所有分类"`
+	PublicClassifyIdList []int  `description:"指标所属公共分类id，如果不指定分类，那么就是所有分类"`
+	CurrentIndex         int    `description:"当前页页码，从1开始"`
+	PageSize             int    `description:"每页数据条数"`
+}
+
+// AllSearchPublicChartReq
+// @Description: 获取所有指标列表（设置公开的时候）请求结构体
+type AllSearchPublicChartReq struct {
+	SearchPublicChartReq
+	ChartIdList   []int `description:"选中的指标id列表"`
+	NoChartIdList []int `description:"未选中的指标id列表"`
+	IsSelectAll   bool  `description:"是否选择所有指标"`
+}
+
+// MoveChartClassifyReq
+// @Description: 移动指标分类的请求结构体
+type MoveChartClassifyReq struct {
+	SearchPublicChartReq
+	ChartIdList   []int `description:"选中的指标id列表"`
+	NoChartIdList []int `description:"未选中的指标id列表"`
+	IsSelectAll   bool  `description:"是否选择所有指标"`
+	NewClassifyId int   `description:"新的分类id"`
+}

models/data_manage/response/chart.go

@@ -1,7 +1,18 @@
 package response
 
+import (
+	"eta_gn/eta_api/models/data_manage"
+	"github.com/rdlucklib/rdluck_tools/paging"
+)
+
 // ChartRefreshResp
 // @Description: 图表更新结果
 type ChartRefreshResp struct {
 	RefreshResult bool `description:"刷新结果"`
 }
+
+// ChartInfoChartListResp ETA图库列表返回数据
+type ChartInfoChartListResp struct {
+	Paging *paging.PagingItem
+	List   []*data_manage.ChartInfoList
+}

models/data_manage/response/chart_info_share.go

@@ -0,0 +1,17 @@
+package response
+
+import "eta_gn/eta_api/models/data_manage"
+
+// ChartInfoShareUserResp
+// @Description: 获取指标分享用户列表
+type ChartInfoShareUserResp struct {
+	ShareType int8                          `description:"分享类型，1：仅查看；2：可编辑"`
+	List      []*data_manage.ChartInfoShare `description:"分享用户列表"`
+}
+
+// ChartShareListResp
+// @Description: 共享列表
+type ChartShareListResp struct {
+	Send     []*data_manage.ChartClassifyItems
+	Received []*data_manage.ChartClassifyItems `description:"收到的共享"`
+}

routers/commentsRouter.go

@@ -3427,6 +3427,159 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "BatchSave",
+            Router: `/chart_info/share/batch_save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "List",
+            Router: `/chart_info/share/list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "ListByEs",
+            Router: `/chart_info/share/list/es`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "Save",
+            Router: `/chart_info/share/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "Tree",
+            Router: `/chart_info/share/tree`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartInfoShareController"],
+        beego.ControllerComments{
+            Method: "UserList",
+            Router: `/chart_info/share/user_list`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "AddClassify",
+            Router: `/chart_public/classify/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "DeleteClassify",
+            Router: `/chart_public/classify/delete`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "DeleteClassifyCheck",
+            Router: `/chart_public/classify/delete/check`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "EditChartClassify",
+            Router: `/chart_public/classify/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "SimpleList",
+            Router: `/chart_public/classify/simple`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicClassifyController"],
+        beego.ControllerComments{
+            Method: "ClassifyTree",
+            Router: `/chart_public/classify/tree`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"],
+        beego.ControllerComments{
+            Method: "BatchMoveChart",
+            Router: `/chart_info/public/batch_move`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"],
+        beego.ControllerComments{
+            Method: "Cancel",
+            Router: `/chart_info/public/cancel`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"],
+        beego.ControllerComments{
+            Method: "ListByEs",
+            Router: `/chart_info/public/list/es`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"],
+        beego.ControllerComments{
+            Method: "AllListByEs",
+            Router: `/chart_info/public/list/es/all`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartPublicController"],
+        beego.ControllerComments{
+            Method: "Save",
+            Router: `/chart_info/public/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartThemeController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:ChartThemeController"],
         beego.ControllerComments{
             Method: "Add",
@@ -4336,15 +4489,6 @@ 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: "AddClassify",
@@ -4372,15 +4516,6 @@ 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: "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",
@@ -4390,33 +4525,6 @@ 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: "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",
@@ -4444,6 +4552,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicController"],
+        beego.ControllerComments{
+            Method: "BatchMoveEdb",
+            Router: `/edb_info/public/batch_move`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/data_manage:EdbPublicController"],
         beego.ControllerComments{
             Method: "Cancel",

services/data/chart_info_elastic.go

@@ -34,9 +34,23 @@ func EsAddOrEditChartInfo(chartInfoId int) {
 			fmt.Println("新增和修改ES中的图表数据失败：", err.Error())
 		}
 	}()
-	itemInfo, _ := data_manage.GetChartInfoById(chartInfoId)
+	itemInfo, err := data_manage.GetChartEsInfoById(chartInfoId)
+	if err != nil {
+		return
+	}
+
+	// 获取分享人
+	obj := data_manage.ChartInfoShare{}
+	list, _ := obj.GetListByChartInfoId(itemInfo.ChartInfoId)
+	sharedList := make([]int, 0)
+	for _, v := range list {
+		sharedList = append(sharedList, v.SysUserId)
+	}
+	itemInfo.SharedUserIdList = sharedList
+
 	//添加es
 	err = elastic.EsAddOrEditChartInfoData(utils.CHART_INDEX_NAME, strconv.Itoa(itemInfo.ChartInfoId), itemInfo)
+
 	return
 }
 

services/data/chart_info_share.go

@@ -0,0 +1,139 @@
+package data
+
+import (
+	"eta_gn/eta_api/models/data_manage"
+	"strconv"
+	"strings"
+)
+
+// GetAllShareChartListByFromUserId
+// @Description: 根据共享人id获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-03 10:01:49
+// @param sysUserId int
+// @return item []*data_manage.ShareChartInfoQuery
+// @return err error
+func GetAllShareChartListByFromUserId(sysUserId int) (item []*data_manage.ShareChartInfoQuery, err error) {
+	obj := data_manage.ChartInfoShare{}
+	item, err = obj.GetAllSharedChartInfoListByFromUserId(sysUserId)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetAllShareChartListByReceivedUserId
+// @Description: 根据接收人id获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-03 10:01:49
+// @param sysUserId int
+// @return item []*data_manage.ShareChartInfoQuery
+// @return err error
+func GetAllShareChartListByReceivedUserId(sysUserId int) (item []*data_manage.ShareChartInfoQuery, err error) {
+	obj := data_manage.ChartInfoShare{}
+	item, err = obj.GetAllSharedChartInfoListByReceivedUserId(sysUserId)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetChartClassifyItemListByShareChartInfoQueryList
+// @Description: 根据共享的指标来获取分类和指标的树形结构
+// @author: Roc
+// @datetime 2024-12-03 11:12:26
+// @param items []*data_manage.ShareChartInfoQuery
+// @return item data_manage.ChartClassifyItemList
+// @return err error
+func GetChartClassifyItemListByShareChartInfoQueryList(items []*data_manage.ShareChartInfoQuery) (item []*data_manage.ChartClassifyItems, err error) {
+	// 所有分类
+	chartClassifyItemListMap := make(map[int][]*data_manage.ChartClassifyItems)
+	classifyIdList := make([]int, 0)
+
+	for _, v := range items {
+		chartClassifyItem := &data_manage.ChartClassifyItems{
+			ChartClassifyId:     v.ChartClassifyId,
+			ChartInfoId:         v.ChartInfoId,
+			ChartClassifyName:   v.ChartName,
+			ChartClassifyNameEn: v.ChartNameEn,
+			//ParentId:            0,
+			//Level:               0,
+			Sort:       v.Sort,
+			UniqueCode: v.UniqueCode,
+			Source:     v.Source,
+			//SourceName:          "",
+			SysUserId:       v.SysUserId,
+			SysUserRealName: v.SysUserRealName,
+			DateType:        v.DateType,
+			StartDate:       v.StartDate,
+			EndDate:         v.EndDate,
+			ChartType:       v.ChartType,
+			Calendar:        v.Calendar,
+			SeasonStartDate: v.SeasonStartDate,
+			SeasonEndDate:   v.SeasonEndDate,
+			//Children:            nil,
+			Button:           data_manage.ChartClassifyItemsButton{},
+			IsJoinPermission: v.IsJoinPermission,
+			//HaveOperaAuth:       false,
+			//ChartClassifyIdPath: "",
+		}
+		chartClassifyItemList, ok := chartClassifyItemListMap[v.ChartClassifyId]
+		if !ok {
+			chartClassifyItemListMap[v.ChartClassifyId] = []*data_manage.ChartClassifyItems{chartClassifyItem}
+			continue
+		}
+		chartClassifyItemListMap[v.ChartClassifyId] = append(chartClassifyItemList, chartClassifyItem)
+		classifyIdList = append(classifyIdList, v.ChartClassifyId)
+	}
+
+	// 组成一个分类树形结构
+	{
+		// 根据分类id获取分类
+		classifyItemsList, tmpErr := data_manage.GetChartClassifyItemsByIdList(classifyIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		allClassifyIdList := make([]int, 0)
+		// 获取分类的完整路径id集合（子级、父级、顶级）
+		allClassifyIdStrList := make([]string, 0)
+		for _, v := range classifyItemsList {
+			allClassifyIdStrList = append(allClassifyIdStrList, v.ChartClassifyIdPath)
+		}
+		if len(allClassifyIdStrList) > 0 {
+			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.GetChartClassifyItemsByIdList(allClassifyIdList)
+		if err != nil {
+			return
+		}
+
+		for _, v := range classifyItemsList {
+			if chartClassifyItemList, ok := chartClassifyItemListMap[v.ChartClassifyId]; ok {
+				if v.Children == nil {
+					v.Children = chartClassifyItemList
+				} else {
+					v.Children = append(v.Children, chartClassifyItemList...)
+				}
+			}
+		}
+
+		item = GetChartClassifyTreeRecursive(classifyItemsList, 0)
+		//根据sort值排序
+		//sort.Sort(item)
+	}
+
+	return
+}

services/data/chart_public.go

@@ -0,0 +1,175 @@
+package data
+
+import (
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/models/data_manage/request"
+	"eta_gn/eta_api/models/system"
+	"eta_gn/eta_api/services/elastic"
+	"eta_gn/eta_api/utils"
+	"github.com/rdlucklib/rdluck_tools/paging"
+	"strings"
+)
+
+// DeleteChartPublicCheck
+// @Description: 移除指标公共检测
+// @author: Roc
+// @datetime 2024-12-05 10:23:01
+// @param classifyId int
+// @param chartInfoId int
+// @param sysUser *system.Admin
+// @return deleteStatus int
+// @return tipsMsg string
+// @return tableList []*data_manage.ExcelBaseInfo
+// @return err error
+// @return errMsg string
+func DeleteChartPublicCheck(chartInfoId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
+	// TODO 操作权限校验
+	{
+
+	}
+
+	// 移除指标
+	if chartInfoId > 0 {
+
+		// TODO 需要判断该指标是否被其他人给收藏了
+
+		//if chartInfo == nil {
+		//	errMsg = "指标已删除，请刷新页面"
+		//	return
+		//}
+		//if chartCount > 0 {
+		//	deleteStatus = 3
+		//	tipsMsg = "当前指标已用作画图，不可删除"
+		//	return
+		//}
+		return
+	}
+
+	return
+}
+
+// GetChartSearchPar
+// @Description: 获取查询参数
+// @author: Roc
+// @datetime 2024-12-05 14:13:25
+// @param req request.SearchPublicChartReq
+// @return keyword string
+// @return searchChartPublicList []int
+// @return sourceList []int
+// @return classifyIdList []int
+// @return publicClassifyIdList []int
+// @return chartTypeList []int
+// @return chartInfoType int
+// @return chartAuth int
+// @return sortMap map[string]string
+func GetChartSearchPar(req request.SearchPublicChartReq) (keyword string, searchChartPublicList, sourceList, classifyIdList, publicClassifyIdList []int, chartAuth int, sortMap map[string]string) {
+	keyword = req.Keyword
+	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
+
+	//指标来源
+	sourceList = []int{utils.CHART_TYPE_CURVE}
+
+	// 选择的分类
+	classifyIdList = req.ClassifyIdList
+	publicClassifyIdList = req.PublicClassifyIdList
+
+	// 指标公开状态：1：未公开，2：已提交；3：已公开。可多选，默认是未公开
+	chartPublicList := req.ChartPublicList
+	if len(chartPublicList) <= 0 {
+		chartPublicList = []int{1}
+	}
+
+	chartAuth = 1 // 选择范围是：只有我的指标
+
+	searchChartPublicList = make([]int, 0) // 0：全部，1：未公开，2：已提交；3：已公开
+	if len(chartPublicList) > 0 && !utils.InArrayByInt(chartPublicList, 0) {
+		// 不含全部
+		for _, v := range chartPublicList {
+			switch v {
+			case 1: // 未公开
+				searchChartPublicList = append(searchChartPublicList, utils.DataPublicDefault)
+			case 2: // 已提交
+				searchChartPublicList = append(searchChartPublicList, utils.DataPublicCommit, utils.DataPublicReject)
+			case 3: // 已公开
+				searchChartPublicList = append(searchChartPublicList, utils.DataPublicSuccess)
+
+			}
+		}
+	} else {
+		searchChartPublicList = []int{0, 1, 2, 3}
+	}
+
+	sortMap = make(map[string]string)
+	// 如果没有搜索关键词，则默认根据指标编码倒序排序
+	if keyword == `` {
+		sortMap["ChartInfoId"] = `desc`
+	}
+
+	return
+
+}
+
+// GetAllChartInfoListBySearchPublicChartReq
+// @Description: 获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-04 15:43:14
+// @param req request.SearchPublicChartReq
+// @param userId int
+// @return chartInfoIdList []*data_manage.ChartInfoList
+// @return err error
+func GetAllChartInfoListBySearchPublicChartReq(req request.SearchPublicChartReq, userId int) (chartInfoList []*data_manage.ChartInfoView, err error) {
+	// 获取查询参数
+	keyword, searchChartPublicList, sourceList, chartClassifyIdList, publicClassifyIdList, chartAuth, sortMap := GetChartSearchPar(req)
+
+	_, chartInfoList, err = getAllChartInfoDataByPublic(keyword, 1, searchChartPublicList, sourceList, chartClassifyIdList, publicClassifyIdList, chartAuth, userId, sortMap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// getAllChartInfoDataByShared
+// @Description: 获取所有的指标列表（设置公开的时候）
+// @author: Roc
+// @datetime 2024-12-04 15:27:53
+// @param keyword string
+// @param currPage int
+// @param chartShare int
+// @param sourceList []int
+// @param classifyIdList []int
+// @param chartTypeList []int
+// @param chartInfoType int
+// @param chartAuth int
+// @param sysUserId int
+// @param sortMap map[string]string
+// @return total int64
+// @return list []*data_manage.ChartInfoList
+// @return err error
+func getAllChartInfoDataByPublic(keyword string, currPage int, searchChartPublicList, sourceList, classifyIdList, publicClassifyIdList []int, chartAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.ChartInfoView, err error) {
+	// 每页获取数据的数量
+	pageSize := 5000
+	var startSize int
+	if currPage <= 0 {
+		currPage = 1
+	}
+	startSize = paging.StartIndex(currPage, pageSize)
+
+	total, list, err = elastic.SearchChartInfoDataByPublic(keyword, startSize, pageSize, searchChartPublicList, sourceList, classifyIdList, publicClassifyIdList, chartAuth, sysUserId, sortMap)
+	if err != nil {
+		return
+	}
+
+	page := paging.GetPaging(currPage, pageSize, int(total))
+	if !page.IsEnd {
+		_, nextList, tmpErr := getAllChartInfoDataByPublic(keyword, page.NextIndex, searchChartPublicList, sourceList, classifyIdList, publicClassifyIdList, chartAuth, sysUserId, sortMap)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		list = append(list, nextList...)
+	}
+
+	return
+}

services/data/chart_public_classify.go

@@ -0,0 +1,838 @@
+package data
+
+import (
+	"errors"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/models/system"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// TODO 移动的时候，获取上下级的分裂
+
+// AddChartPublicClassify
+// @Description: 添加公共指标分类
+// @author: Roc
+// @datetime 2024-12-04 18:00:22
+// @param classifyName string
+// @param parentId int
+// @param level int
+// @param source int
+// @param sysUserId int
+// @param sysUserName string
+// @return classifyInfo *data_manage.ChartPublicClassify
+// @return err error
+// @return errMsg string
+func AddChartPublicClassify(classifyName string, parentId, level, source int, sysUserId int, sysUserName string) (classifyInfo *data_manage.ChartPublicClassify, err error, errMsg string) {
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	// 校验分类名称相同的数量
+	{
+		var count int
+		count, err = chartPublicClassifyObj.GetChartClassifyCount(classifyName, parentId, source)
+		if err != nil {
+			errMsg = `判断名称是否已存在失败`
+			return
+		}
+		if count > 0 {
+			errMsg = `分类名称已存在，请重新输入`
+			err = errors.New(errMsg)
+			return
+		}
+	}
+
+	// 层级校验
+	if level > 6 {
+		errMsg = fmt.Sprintf("最高只支持添加6级分类")
+		return
+	}
+
+	//获取该层级下最大的排序数
+	maxSort, err := GetChartPublicClassifyMaxSort(parentId, source)
+	if err != nil {
+		errMsg = "获取失败"
+		err = errors.New("查询排序信息失败，Err:" + err.Error())
+		return
+	}
+	//查询顶级rootId
+	rootId := 0
+	var classifyNamePath, classifyIdPath string
+	if parentId > 0 {
+		parentClassify, tErr := chartPublicClassifyObj.GetChartClassifyById(parentId)
+		if tErr != nil {
+			if utils.IsErrNoRow(tErr) {
+				errMsg = "父级分类不存在"
+				err = errors.New(errMsg)
+				return
+			}
+			errMsg = "获取失败"
+			err = errors.New("获取分类信息失败，Err:" + tErr.Error())
+			return
+		}
+		rootId = parentClassify.RootId
+
+		classifyNamePath = fmt.Sprint(parentClassify.ChartPublicClassifyNamePath, "|", classifyName)
+		classifyIdPath = fmt.Sprint(parentClassify.ChartPublicClassifyIdPath, ",")
+	} else {
+		classifyNamePath = classifyName
+	}
+
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	classifyInfo = &data_manage.ChartPublicClassify{
+		//ChartPublicClassifyId:       0,
+		Source:                      source,
+		ChartPublicClassifyName:     classifyName,
+		ParentId:                    parentId,
+		HasData:                     0,
+		RootId:                      rootId,
+		CreateTime:                  time.Now(),
+		ModifyTime:                  time.Now(),
+		SysUserId:                   sysUserId,
+		SysUserRealName:             sysUserName,
+		Level:                       level + 1,
+		UniqueCode:                  utils.MD5(utils.PUBLIC_CLASSIFY_PREFIX + "_" + timestamp),
+		Sort:                        maxSort + 1,
+		LastModifyUserId:            sysUserId,
+		LastModifyUserRealName:      sysUserName,
+		ChartPublicClassifyNamePath: classifyNamePath,
+		ChartPublicClassifyIdPath:   "",
+	}
+	err = classifyInfo.Add()
+	if err != nil {
+		errMsg = "保存分类失败"
+		return
+	}
+
+	// 更改分类id完整路径path
+	updateCols := []string{"ChartPublicClassifyIdPath"}
+	classifyInfo.ChartPublicClassifyIdPath = fmt.Sprint(classifyIdPath, classifyInfo.ChartPublicClassifyId)
+	if parentId == 0 { //一级目录的rootId等于自己本身
+		classifyInfo.RootId = classifyInfo.ChartPublicClassifyId
+		updateCols = append(updateCols, "RootId")
+
+	}
+	err = classifyInfo.Update(updateCols)
+	if err != nil {
+		errMsg = "更新分类失败"
+		return
+	}
+
+	return
+}
+
+// EditChartPublicClassify
+// @Description: 编辑指标分类
+// @author: Roc
+// @datetime 2024-12-05 09:29:38
+// @param classifyId int
+// @param classifyName string
+// @param sysUser *system.Admin
+// @return err error
+// @return errMsg string
+func EditChartPublicClassify(classifyId int, classifyName string, sysUser *system.Admin) (err error, errMsg string) {
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	item, err := chartPublicClassifyObj.GetChartClassifyById(classifyId)
+	if err != nil {
+		errMsg = `修改失败`
+		return
+	}
+
+	// TODO 操作权限校验
+	{
+	}
+
+	// 需要变更的字段
+	updateCols := make([]string, 0)
+
+	// 旧完整路径  ， 新的完整路径
+	var oldClassifyNamePath, newClassifyNamePath string
+
+	// 名字相同，那么就直接返回
+	if item.ChartPublicClassifyName == classifyName {
+		return
+	}
+
+	// 判断名称是否已存在
+	count, tmpErr := chartPublicClassifyObj.GetChartClassifyCount(classifyName, item.ParentId, item.Source)
+	if tmpErr != nil {
+		err = tmpErr
+		errMsg = "判断名称是否已存在失败"
+		return
+	}
+	if count > 0 {
+		errMsg = "分类名称已存在，请重新输入"
+		err = errors.New(errMsg)
+		return
+	}
+
+	// 旧完整路径
+	oldClassifyNamePath = item.ChartPublicClassifyNamePath
+
+	if item.ParentId > 0 {
+		parentItem, tmpErr := chartPublicClassifyObj.GetChartClassifyById(item.ParentId)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		newClassifyNamePath = fmt.Sprint(parentItem.ChartPublicClassifyNamePath, "|", classifyName)
+	} else {
+		newClassifyNamePath = classifyName
+	}
+
+	// 更新自己的信息
+	item.ChartPublicClassifyName = classifyName
+	item.ChartPublicClassifyNamePath = newClassifyNamePath
+	item.LastModifyUserId = sysUser.AdminId
+	item.LastModifyUserRealName = sysUser.RealName
+	updateCols = append(updateCols, "ChartPublicClassifyName", "ChartPublicClassifyNamePath", "LastModifyUserId", "LastModifyUserRealName")
+
+	// 修改数据
+	if len(updateCols) > 0 {
+		err = item.UpdateChartClassifyNameAndNamePath(updateCols, oldClassifyNamePath, newClassifyNamePath)
+		if err != nil {
+			errMsg = "保存失败"
+		}
+	}
+
+	return
+}
+
+// GetChartPublicClassifyMaxSort
+// @Description: 获取最大排序值
+// @author: Roc
+// @datetime 2024-12-04 16:54:57
+// @param parentId int
+// @param source int
+// @return maxSort int
+// @return err error
+func GetChartPublicClassifyMaxSort(parentId, source int) (maxSort int, err error) {
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	//获取该层级下最大的排序数
+	classifyMaxSort, err := chartPublicClassifyObj.GetChartClassifyMaxSort(parentId, source)
+	if err != nil {
+		return
+	}
+	maxSort = classifyMaxSort
+	chartMaxSort, err := data_manage.GetChartInfoMaxSortByClassifyId(parentId)
+	if err != nil {
+		return
+	}
+	if maxSort < chartMaxSort {
+		maxSort = chartMaxSort
+	}
+
+	return
+}
+
+// DeleteChartPublicClassifyCheck 删除检测
+func DeleteChartPublicClassifyCheck(classifyId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, allClassifyIdList []int, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
+	// TODO 操作权限校验
+	{
+
+	}
+
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	// 查找当前分类
+	item, tmpErr := chartPublicClassifyObj.GetChartClassifyById(classifyId)
+	if tmpErr != nil {
+		errMsg = `查找分类失败`
+		err = tmpErr
+		return
+	}
+
+	// 查找分类下所有子分类
+	childClassifyIdList, tmpErr := item.GetAllChildClassifyIdList()
+	if tmpErr != nil {
+		errMsg = `查找下级分类失败`
+		err = tmpErr
+		return
+	}
+	allClassifyIdList = childClassifyIdList
+	allClassifyIdList = append(allClassifyIdList, item.ChartPublicClassifyId)
+
+	// 判断分类下，是否含有指标
+	{
+		//判断分类下，是否含有指标
+		count, tmpErr := chartPublicClassifyObj.GetChartInfoCountByClassifyIdList(allClassifyIdList)
+		if tmpErr != nil {
+			errMsg = "删除失败"
+			err = errors.New("分类下是否含有指标失败，Err:" + tmpErr.Error())
+			return
+		}
+
+		if count > 0 {
+			deleteStatus = 1
+			tipsMsg = "目录关联指标不可删除"
+			return
+		}
+	}
+
+	// 子目录数量校验
+	if len(childClassifyIdList) > 0 {
+		deleteStatus = 2
+		tipsMsg = "确认删除当前目录及包含的子目录吗"
+		return
+	}
+
+	return
+}
+
+// DeleteChartPublicClassify 删除分类/指标
+func DeleteChartPublicClassify(classifyId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.ChartInfo, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
+	//删除分类校验
+	deleteStatus, tipsMsg, allClassifyIdList, _, err, errMsg := DeleteChartPublicClassifyCheck(classifyId, sysUser)
+	// 0：可以；2：删除子目录；1：不可删除（有关联指标）
+	if deleteStatus == 1 {
+		if tipsMsg != `` {
+			errMsg = tipsMsg
+		}
+		if err == nil {
+			err = errors.New(errMsg)
+		}
+		return
+	}
+
+	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
+	err = chartPublicClassifyObj.BatchesDel(allClassifyIdList)
+	if err != nil {
+		errMsg = "删除失败"
+		return
+	}
+
+	return
+}
+
+// MoveChartClassify 移动指标分类 TODO
+//func MoveChartPublicClassify(req data_manage.MoveChartClassifyReq, sysUser *system.Admin, source int) (err error, errMsg string) {
+//	// req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
+//	classifyId := req.ClassifyId
+//	parentClassifyId := req.ParentClassifyId
+//	prevClassifyId := req.PrevClassifyId
+//	nextClassifyId := req.NextClassifyId
+//
+//	chartInfoId := req.ChartInfoId
+//	prevChartInfoId := req.PrevChartInfoId
+//	nextChartInfoId := req.NextChartInfoId
+//
+//	//首先确定移动的对象是分类还是指标
+//	//判断上一个节点是分类还是指标
+//	//判断下一个节点是分类还是指标
+//	//同时更新分类目录下的分类sort和指标sort
+//	//更新当前移动的分类或者指标sort
+//
+//	var parentChartClassifyInfo *data_manage.ChartClassify
+//	if parentClassifyId > 0 {
+//		parentChartClassifyInfo, err = data_manage.GetChartClassifyById(parentClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//	}
+//
+//	//如果有传入 上一个兄弟节点分类id
+//	var (
+//		chartClassifyInfo *data_manage.ChartPublicClassify
+//		prevClassify      *data_manage.ChartPublicClassify
+//		nextClassify      *data_manage.ChartPublicClassify
+//
+//		chartInfo     *data_manage.ChartInfo
+//		prevChartInfo *data_manage.ChartInfo
+//		nextChartInfo *data_manage.ChartInfo
+//		prevSort      int
+//		nextSort      int
+//	)
+//
+//	obj:= data_manage.ChartPublicClassify{}
+//
+//	// 移动对象为分类， 判断权限
+//	if chartInfoId == 0 {
+//		chartClassifyInfo, err = obj.GetChartClassifyById(classifyId)
+//		if err != nil {
+//			if utils.IsErrNoRow(err) {
+//				errMsg = "当前分类不存在"
+//				err = errors.New("获取分类信息失败,Err:" + err.Error())
+//				return
+//			}
+//			errMsg = "移动失败"
+//			err = errors.New("获取分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		if chartClassifyInfo.SysUserId != sysUser.AdminId {
+//			errMsg = "不是本人目录，您没有操作权限"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//		if parentClassifyId > 0 && parentChartClassifyInfo.Level == 6 {
+//			errMsg = "最高只支持添加6级分类"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
+//		exists, e := data_manage.GetChartPublicClassifyByParentIdAndName(source, parentClassifyId, chartClassifyInfo.ChartClassifyName, classifyId)
+//		if e != nil && !utils.IsErrNoRow(e) {
+//			errMsg = "移动失败"
+//			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
+//			return
+//		}
+//		if exists != nil && exists.ChartClassifyId > 0 {
+//			errMsg = "移动失败，分类名称已存在"
+//			return
+//		}
+//
+//		// 权限校验
+//		{
+//			// 已授权分类id
+//			permissionClassifyIdList, tmpErr := data_manage_permission.GetUserChartClassifyPermissionList(sysUser.AdminId, classifyId)
+//			if tmpErr != nil {
+//				errMsg = "移动失败"
+//				err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error())
+//				return
+//			}
+//			// 数据权限
+//			haveOperaAuth := data_manage_permission.CheckChartClassifyPermissionByPermissionIdList(chartClassifyInfo.IsJoinPermission, chartClassifyInfo.ClassifyId, permissionClassifyIdList)
+//
+//			if chartClassifyInfo.ClassifyType == 0 { // 普通指标
+//				button := GetChartClassifyOpButton(sysUser, chartClassifyInfo.SysUserId, haveOperaAuth)
+//				if !button.MoveButton {
+//					errMsg = "无操作权限"
+//					err = errors.New(errMsg)
+//					return
+//				}
+//			} else if chartClassifyInfo.ClassifyType == 1 { // 预测指标
+//				button := GetPredictChartClassifyOpButton(sysUser, chartClassifyInfo.SysUserId, haveOperaAuth)
+//				if !button.MoveButton {
+//					errMsg = "无操作权限"
+//					err = errors.New(errMsg)
+//					return
+//				}
+//			}
+//		}
+//
+//	} else {
+//		chartInfo, err = data_manage.GetChartInfoById(req.ChartInfoId)
+//		if err != nil {
+//			if utils.IsErrNoRow(err) {
+//				errMsg = "当前指标不存在"
+//				err = errors.New("获取分类信息失败,Err:" + err.Error())
+//				return
+//			}
+//			errMsg = "移动失败"
+//			err = errors.New("获取分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//
+//		if chartInfo.SysUserId != sysUser.AdminId {
+//			errMsg = "不是本人指标，您没有操作权限"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//
+//		if parentClassifyId == 0 {
+//			errMsg = "移动失败,指标必须挂在分类下"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//
+//		var haveOperaAuth bool
+//		// 权限校验
+//		{
+//			haveOperaAuth, err = data_manage_permission.CheckChartPermissionByChartInfoId(chartInfo.ChartInfoId, chartInfo.ClassifyId, chartInfo.IsJoinPermission, sysUser.AdminId)
+//			if err != nil {
+//				errMsg = "移动失败"
+//				err = errors.New("获取指标权限信息失败,Err:" + err.Error())
+//				return
+//			}
+//		}
+//
+//		// 移动权限校验
+//		button := GetChartOpButton(sysUser, chartInfo.SysUserId, chartInfo.ChartType, chartInfo.ChartInfoType, haveOperaAuth)
+//		if !button.MoveButton {
+//			errMsg = "无操作权限"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//	}
+//
+//	if prevClassifyId > 0 {
+//		prevClassify, err = data_manage.GetChartClassifyById(prevClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		prevSort = prevClassify.Sort
+//	} else if prevChartInfoId > 0 {
+//		prevChartInfo, err = data_manage.GetChartInfoById(prevChartInfoId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		prevSort = prevChartInfo.Sort
+//	}
+//
+//	if nextClassifyId > 0 {
+//		//下一个兄弟节点
+//		nextClassify, err = data_manage.GetChartClassifyById(nextClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		nextSort = nextClassify.Sort
+//	} else if nextChartInfoId > 0 {
+//		//下一个兄弟节点
+//		nextChartInfo, err = data_manage.GetChartInfoById(nextChartInfoId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		nextSort = nextChartInfo.Sort
+//	}
+//
+//	err, errMsg = moveChartOrClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+//	return
+//}
+
+// moveChartOrClassify 移动指标分类 TODO
+//func moveChartOrPublicClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
+//
+//	if chartClassifyInfo != nil {
+//		// 移动分类
+//		return moveChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+//	} else {
+//		// 移动指标
+//		return moveChart(prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+//	}
+//
+//	return
+//}
+
+// moveChart TODO
+// @Description: 移动指标
+// @author: Roc
+// @datetime 2024-11-26 16:07:37
+// @param prevClassify *data_manage.ChartClassify
+// @param nextClassify *data_manage.ChartClassify
+// @param chartInfo *data_manage.ChartInfo
+// @param prevChartInfo *data_manage.ChartInfo
+// @param nextChartInfo *data_manage.ChartInfo
+// @param parentClassifyId int
+// @param prevSort int
+// @param nextSort int
+// @param source int
+// @return err error
+// @return errMsg string
+//func movePublicChart(prevClassify, nextClassify *data_manage.ChartClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
+//	updateCol := make([]string, 0)
+//
+//	if chartInfo == nil {
+//		errMsg = "当前指标不存在"
+//		err = errors.New(errMsg)
+//		return
+//	}
+//	//如果改变了分类，那么移动该指标数据
+//	if chartInfo.ClassifyId != parentClassifyId {
+//		chartInfo.ClassifyId = parentClassifyId
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ClassifyId", "ModifyTime")
+//	}
+//	if prevSort > 0 {
+//		//如果是移动在两个兄弟节点之间
+//		if nextSort > 0 {
+//			//下一个兄弟节点
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevSort == nextSort || prevSort == chartInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//
+//				//变更分类
+//				if prevClassify != nil {
+//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, source)
+//				} else {
+//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+//				}
+//
+//				//变更指标
+//				if prevChartInfo != nil {
+//					//变更兄弟节点的排序
+//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+//				} else {
+//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//				}
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextSort-prevSort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//					//变更分类
+//					if prevClassify != nil {
+//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, source)
+//					} else {
+//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+//					}
+//
+//					//变更指标
+//					if prevChartInfo != nil {
+//						//变更兄弟节点的排序
+//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+//					} else {
+//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//					}
+//				}
+//			}
+//		}
+//
+//		chartInfo.Sort = prevSort + 1
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else if prevClassify == nil && nextClassify == nil && prevChartInfo == nil && nextChartInfo == nil && parentClassifyId > 0 {
+//		//处理只拖动到目录里，默认放到目录底部的情况
+//		var maxSort int
+//		maxSort, err = GetChartClassifyMaxSort(parentClassifyId, source)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+//			return
+//		}
+//		chartInfo.Sort = maxSort + 1 //那就是排在组内最后一位
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else {
+//		// 拖动到父级分类的第一位
+//		firstClassify, tmpErr := data_manage.GetFirstChartClassifyByParentId(parentClassifyId)
+//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+//			errMsg = "移动失败"
+//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, source)
+//			//该分类下的所有指标也需要+1
+//			_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+//		} else {
+//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+//			firstChart, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
+//			if tErr != nil && !utils.IsErrNoRow(tErr) {
+//				errMsg = "移动失败"
+//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+//				return
+//			}
+//
+//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//			if firstChart != nil && firstChart.ClassifyId > 0 && firstChart.Sort == 0 {
+//				updateSortStr := ` sort + 1 `
+//				_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateSortStr)
+//				_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
+//			}
+//		}
+//
+//		chartInfo.Sort = 0 //那就是排在第一位
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = chartInfo.Update(updateCol)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("修改失败,Err:" + err.Error())
+//			return
+//		}
+//	}
+//
+//	return
+//}
+
+// moveChartClassify
+// @Description: 移动指标分类
+// @author: Roc
+// @datetime 2024-11-26 16:07:44
+// @param parentChartClassifyInfo *data_manage.ChartClassify
+// @param chartClassifyInfo *data_manage.ChartClassify
+// @param prevClassify *data_manage.ChartClassify
+// @param nextClassify *data_manage.ChartClassify
+// @param chartInfo *data_manage.ChartInfo
+// @param prevChartInfo *data_manage.ChartInfo
+// @param nextChartInfo *data_manage.ChartInfo
+// @param parentClassifyId int
+// @param prevSort int
+// @param nextSort int
+// @param source int
+// @return err error
+// @return errMsg string
+//func moveChartPublicClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartClassify, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
+//	updateCol := make([]string, 0)
+//
+//	// 移动对象为分类， 判断分类是否存在
+//	oldParentId := chartClassifyInfo.ParentId
+//	oldLevel := chartClassifyInfo.Level
+//	var classifyIds []int
+//	if oldParentId != parentClassifyId {
+//		//更新子分类对应的level
+//		childList, e, m := GetChildClassifyByClassifyId(chartClassifyInfo.ClassifyId)
+//		if e != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
+//			return
+//		}
+//
+//		if len(childList) > 0 {
+//			for _, v := range childList {
+//				if v.ClassifyId == chartClassifyInfo.ClassifyId {
+//					continue
+//				}
+//				classifyIds = append(classifyIds, v.ClassifyId)
+//			}
+//		}
+//	}
+//	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+//	if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+//		if chartClassifyInfo.Level != parentChartClassifyInfo.Level+1 { //禁止层级调整
+//			errMsg = "移动失败"
+//			err = errors.New("不支持目录层级变更")
+//			return
+//		}
+//		chartClassifyInfo.ParentId = parentChartClassifyInfo.ClassifyId
+//		chartClassifyInfo.RootId = parentChartClassifyInfo.RootId
+//		chartClassifyInfo.Level = parentChartClassifyInfo.Level + 1
+//		chartClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
+//	} else if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
+//		errMsg = "移动失败"
+//		err = errors.New("不支持目录层级变更")
+//		return
+//	}
+//
+//	if prevSort > 0 {
+//		//如果是移动在两个兄弟节点之间
+//		if nextSort > 0 {
+//			//下一个兄弟节点
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevSort == nextSort || prevSort == chartClassifyInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//
+//				//变更分类
+//				if prevClassify != nil {
+//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, source)
+//				} else {
+//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+//				}
+//
+//				//变更指标
+//				if prevChartInfo != nil {
+//					//变更兄弟节点的排序
+//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+//				} else {
+//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//				}
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextSort-prevSort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//
+//					//变更分类
+//					if prevClassify != nil {
+//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, source)
+//					} else {
+//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+//					}
+//
+//					//变更指标
+//					if prevChartInfo != nil {
+//						//变更兄弟节点的排序
+//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+//					} else {
+//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//					}
+//
+//				}
+//			}
+//		}
+//
+//		chartClassifyInfo.Sort = prevSort + 1
+//		chartClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else if prevClassify == nil && nextClassify == nil && prevChartInfo == nil && nextChartInfo == nil && parentClassifyId > 0 {
+//		//处理只拖动到目录里，默认放到目录底部的情况
+//		var maxSort int
+//		maxSort, err = GetChartClassifyMaxSort(parentClassifyId, source)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+//			return
+//		}
+//		chartClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
+//		chartClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else {
+//		// 拖动到父级分类的第一位
+//		firstClassify, tmpErr := data_manage.GetFirstChartClassifyByParentId(parentClassifyId)
+//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+//			errMsg = "移动失败"
+//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, source)
+//			//该分类下的所有指标也需要+1
+//			_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+//		} else {
+//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+//			firstChart, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
+//			if tErr != nil && !utils.IsErrNoRow(tErr) {
+//				errMsg = "移动失败"
+//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+//				return
+//			}
+//
+//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//			if firstChart != nil && firstChart.ChartClassifyId > 0 && firstChart.Sort == 0 {
+//				updateSortStr := ` sort + 1 `
+//				_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateSortStr)
+//				_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
+//			}
+//		}
+//
+//		chartClassifyInfo.Sort = 0 //那就是排在第一位
+//		chartClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = chartClassifyInfo.Update(updateCol)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("修改失败,Err:" + err.Error())
+//			return
+//		}
+//		//更新对应分类的root_id和层级
+//		if oldParentId != parentClassifyId {
+//			if len(classifyIds) > 0 {
+//				levelStep := chartClassifyInfo.Level - oldLevel
+//				err = data_manage.UpdateChartClassifyChildByParentClassifyId(classifyIds, chartClassifyInfo.RootId, levelStep)
+//				if err != nil {
+//					errMsg = "移动失败"
+//					err = errors.New("更新子分类失败,Err:" + err.Error())
+//					return
+//				}
+//			}
+//		}
+//
+//	}
+//
+//	return
+//}

services/data/data_approve/approve_flow.go

@@ -66,7 +66,11 @@ func SaveDataApproveFlow(flow *request.DataApproveFlowSaveReq) (ok bool, msg str
 			return
 		}
 		if !ok {
-			msg = "保存审批流失败, 存在还未审批的报告"
+			if flowInfo.DataType == utils.DataApproveTypeEdb {
+				msg = "保存审批流失败, 存在还未审批的指标"
+			} else {
+				msg = "保存审批流失败, 存在还未审批的图表"
+			}
 			return
 		}
 		var updateCols []string

services/data/edb_public.go

@@ -79,9 +79,9 @@ func GetSearchPar(req request.SearchPublicEdbReq) (keyword string, searchEdbPubl
 		edbPublicList = []int{1}
 	}
 
-	edbInfoType = 0        // 普通指标
-	edbTypeList = []int{2} // 普通指标中的计算指标
-	edbAuth = 1            // 选择范围是：只有我的指标
+	edbInfoType = 0                             // 普通指标
+	edbTypeList = []int{utils.EdbTypeCalculate} // 普通指标中的计算指标
+	edbAuth = 1                                 // 选择范围是：只有我的指标
 
 	searchEdbPublicList = make([]int, 0) // 0：全部，1：未公开，2：已提交；3：已公开
 	if len(edbPublicList) > 0 && !utils.InArrayByInt(edbPublicList, 0) {

services/data/edb_public_classify.go

@@ -4,13 +4,14 @@ import (
 	"errors"
 	"eta_gn/eta_api/models/data_manage"
 	"eta_gn/eta_api/models/system"
-	"eta_gn/eta_api/services/data/data_manage_permission"
 	"eta_gn/eta_api/utils"
 	"fmt"
 	"strconv"
 	"time"
 )
 
+// TODO 移动的时候，获取上下级的分裂
+
 // AddEdbPublicClassify
 // @Description: 添加公共指标分类
 // @author: Roc
@@ -302,213 +303,186 @@ func DeleteEdbPublicClassify(classifyId int, sysUser *system.Admin, requestBody,
 	return
 }
 
-// MoveEdbClassify 移动指标分类
-func MoveEdbPublicClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin, classifyType uint8) (err error, errMsg string) {
-	// req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
-	classifyId := req.ClassifyId
-	parentClassifyId := req.ParentClassifyId
-	prevClassifyId := req.PrevClassifyId
-	nextClassifyId := req.NextClassifyId
-
-	edbInfoId := req.EdbInfoId
-	prevEdbInfoId := req.PrevEdbInfoId
-	nextEdbInfoId := req.NextEdbInfoId
-
-	//首先确定移动的对象是分类还是指标
-	//判断上一个节点是分类还是指标
-	//判断下一个节点是分类还是指标
-	//同时更新分类目录下的分类sort和指标sort
-	//更新当前移动的分类或者指标sort
-
-	var parentEdbClassifyInfo *data_manage.EdbClassify
-	if parentClassifyId > 0 {
-		parentEdbClassifyInfo, err = data_manage.GetEdbClassifyById(parentClassifyId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
-			return
-		}
-	}
-
-	//如果有传入 上一个兄弟节点分类id
-	var (
-		edbClassifyInfo *data_manage.EdbClassify
-		prevClassify    *data_manage.EdbClassify
-		nextClassify    *data_manage.EdbClassify
-
-		edbInfo     *data_manage.EdbInfo
-		prevEdbInfo *data_manage.EdbInfo
-		nextEdbInfo *data_manage.EdbInfo
-		prevSort    int
-		nextSort    int
-	)
-
-	// 移动对象为分类， 判断权限
-	if edbInfoId == 0 {
-		edbClassifyInfo, err = data_manage.GetEdbClassifyById(classifyId)
-		if err != nil {
-			if utils.IsErrNoRow(err) {
-				errMsg = "当前分类不存在"
-				err = errors.New("获取分类信息失败,Err:" + err.Error())
-				return
-			}
-			errMsg = "移动失败"
-			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)
-			return
-		}
-		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
-		exists, e := data_manage.GetEdbClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.ClassifyName, classifyId, classifyType)
-		if e != nil && !utils.IsErrNoRow(e) {
-			errMsg = "移动失败"
-			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
-			return
-		}
-		if exists != nil && exists.ClassifyId > 0 {
-			errMsg = "移动失败，分类名称已存在"
-			return
-		}
-
-		// 权限校验
-		{
-			// 已授权分类id
-			permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId)
-			if tmpErr != nil {
-				errMsg = "移动失败"
-				err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error())
-				return
-			}
-			// 数据权限
-			haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(edbClassifyInfo.IsJoinPermission, edbClassifyInfo.ClassifyId, permissionClassifyIdList)
-
-			if edbClassifyInfo.ClassifyType == 0 { // 普通指标
-				button := GetEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth)
-				if !button.MoveButton {
-					errMsg = "无操作权限"
-					err = errors.New(errMsg)
-					return
-				}
-			} else if edbClassifyInfo.ClassifyType == 1 { // 预测指标
-				button := GetPredictEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth)
-				if !button.MoveButton {
-					errMsg = "无操作权限"
-					err = errors.New(errMsg)
-					return
-				}
-			}
-		}
-
-	} else {
-		edbInfo, err = data_manage.GetEdbInfoById(req.EdbInfoId)
-		if err != nil {
-			if utils.IsErrNoRow(err) {
-				errMsg = "当前指标不存在"
-				err = errors.New("获取分类信息失败,Err:" + err.Error())
-				return
-			}
-			errMsg = "移动失败"
-			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)
-			return
-		}
-
-		var haveOperaAuth bool
-		// 权限校验
-		{
-			haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, sysUser.AdminId)
-			if err != nil {
-				errMsg = "移动失败"
-				err = errors.New("获取指标权限信息失败,Err:" + err.Error())
-				return
-			}
-		}
-
-		// 移动权限校验
-		button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
-		if !button.MoveButton {
-			errMsg = "无操作权限"
-			err = errors.New(errMsg)
-			return
-		}
-	}
-
-	if prevClassifyId > 0 {
-		prevClassify, err = data_manage.GetEdbClassifyById(prevClassifyId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
-			return
-		}
-		prevSort = prevClassify.Sort
-	} else if prevEdbInfoId > 0 {
-		prevEdbInfo, err = data_manage.GetEdbInfoById(prevEdbInfoId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
-			return
-		}
-		prevSort = prevEdbInfo.Sort
-	}
-
-	if nextClassifyId > 0 {
-		//下一个兄弟节点
-		nextClassify, err = data_manage.GetEdbClassifyById(nextClassifyId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
-			return
-		}
-		nextSort = nextClassify.Sort
-	} else if nextEdbInfoId > 0 {
-		//下一个兄弟节点
-		nextEdbInfo, err = data_manage.GetEdbInfoById(nextEdbInfoId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
-			return
-		}
-		nextSort = nextEdbInfo.Sort
-	}
-
-	err, errMsg = moveEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
-	return
-}
-
-// moveEdbOrClassify 移动指标分类
-func moveEdbOrPublicClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
-
-	if edbClassifyInfo != nil {
-		// 移动分类
-		return moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
-	} else {
-		// 移动指标
-		return moveEdb(prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
-	}
-
-	return
-}
-
-// moveEdb
+// MoveEdbClassify 移动指标分类 TODO
+//func MoveEdbPublicClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin, classifyType uint8) (err error, errMsg string) {
+//	// req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
+//	classifyId := req.ClassifyId
+//	parentClassifyId := req.ParentClassifyId
+//	prevClassifyId := req.PrevClassifyId
+//	nextClassifyId := req.NextClassifyId
+//
+//	edbInfoId := req.EdbInfoId
+//	prevEdbInfoId := req.PrevEdbInfoId
+//	nextEdbInfoId := req.NextEdbInfoId
+//
+//	//首先确定移动的对象是分类还是指标
+//	//判断上一个节点是分类还是指标
+//	//判断下一个节点是分类还是指标
+//	//同时更新分类目录下的分类sort和指标sort
+//	//更新当前移动的分类或者指标sort
+//
+//	var parentEdbClassifyInfo *data_manage.EdbClassify
+//	if parentClassifyId > 0 {
+//		parentEdbClassifyInfo, err = data_manage.GetEdbClassifyById(parentClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//	}
+//
+//	//如果有传入 上一个兄弟节点分类id
+//	var (
+//		edbClassifyInfo *data_manage.EdbPublicClassify
+//		prevClassify    *data_manage.EdbPublicClassify
+//		nextClassify    *data_manage.EdbPublicClassify
+//
+//		edbInfo     *data_manage.EdbInfo
+//		prevEdbInfo *data_manage.EdbInfo
+//		nextEdbInfo *data_manage.EdbInfo
+//		prevSort    int
+//		nextSort    int
+//	)
+//	obj:= data_manage.EdbPublicClassify{}
+//
+//	// 移动对象为分类， 判断权限
+//	if edbInfoId == 0 {
+//		edbClassifyInfo, err = obj.GetEdbClassifyById(classifyId)
+//		if err != nil {
+//			if utils.IsErrNoRow(err) {
+//				errMsg = "当前分类不存在"
+//				err = errors.New("获取分类信息失败,Err:" + err.Error())
+//				return
+//			}
+//			errMsg = "移动失败"
+//			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)
+//			return
+//		}
+//		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
+//		exists, e := data_manage.GetEdbPublicClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.EdbPublicClassifyName, classifyId, classifyType)
+//		if e != nil && !utils.IsErrNoRow(e) {
+//			errMsg = "移动失败"
+//			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
+//			return
+//		}
+//		if exists != nil && exists.ClassifyId > 0 {
+//			errMsg = "移动失败，分类名称已存在"
+//			return
+//		}
+//
+//
+//	} else {
+//		edbInfo, err = data_manage.GetEdbInfoById(req.EdbInfoId)
+//		if err != nil {
+//			if utils.IsErrNoRow(err) {
+//				errMsg = "当前指标不存在"
+//				err = errors.New("获取分类信息失败,Err:" + err.Error())
+//				return
+//			}
+//			errMsg = "移动失败"
+//			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)
+//			return
+//		}
+//
+//		var haveOperaAuth bool
+//		// 权限校验
+//		{
+//			haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, sysUser.AdminId)
+//			if err != nil {
+//				errMsg = "移动失败"
+//				err = errors.New("获取指标权限信息失败,Err:" + err.Error())
+//				return
+//			}
+//		}
+//
+//		// 移动权限校验
+//		button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
+//		if !button.MoveButton {
+//			errMsg = "无操作权限"
+//			err = errors.New(errMsg)
+//			return
+//		}
+//	}
+//
+//	if prevClassifyId > 0 {
+//		prevClassify, err = data_manage.GetEdbClassifyById(prevClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		prevSort = prevClassify.Sort
+//	} else if prevEdbInfoId > 0 {
+//		prevEdbInfo, err = data_manage.GetEdbInfoById(prevEdbInfoId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		prevSort = prevEdbInfo.Sort
+//	}
+//
+//	if nextClassifyId > 0 {
+//		//下一个兄弟节点
+//		nextClassify, err = data_manage.GetEdbClassifyById(nextClassifyId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		nextSort = nextClassify.Sort
+//	} else if nextEdbInfoId > 0 {
+//		//下一个兄弟节点
+//		nextEdbInfo, err = data_manage.GetEdbInfoById(nextEdbInfoId)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+//			return
+//		}
+//		nextSort = nextEdbInfo.Sort
+//	}
+//
+//	err, errMsg = moveEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+//	return
+//}
+
+// moveEdbOrClassify 移动指标分类 TODO
+//func moveEdbOrPublicClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+//
+//	if edbClassifyInfo != nil {
+//		// 移动分类
+//		return moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+//	} else {
+//		// 移动指标
+//		return moveEdb(prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+//	}
+//
+//	return
+//}
+
+// moveEdb  TODO
 // @Description: 移动指标
 // @author: Roc
 // @datetime 2024-11-26 16:07:37
@@ -523,132 +497,132 @@ func moveEdbOrPublicClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassif
 // @param classifyType uint8
 // @return err error
 // @return errMsg string
-func movePublicEdb(prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
-	updateCol := make([]string, 0)
-
-	if edbInfo == nil {
-		errMsg = "当前指标不存在"
-		err = errors.New(errMsg)
-		return
-	}
-	//如果改变了分类，那么移动该指标数据
-	if edbInfo.ClassifyId != parentClassifyId {
-		edbInfo.ClassifyId = parentClassifyId
-		edbInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "ClassifyId", "ModifyTime")
-	}
-	if prevSort > 0 {
-		//如果是移动在两个兄弟节点之间
-		if nextSort > 0 {
-			//下一个兄弟节点
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevSort == nextSort || prevSort == edbInfo.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-
-				//变更分类
-				if prevClassify != nil {
-					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
-				} else {
-					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
-				}
-
-				//变更指标
-				if prevEdbInfo != nil {
-					//变更兄弟节点的排序
-					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
-				} else {
-					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
-				}
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextSort-prevSort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					//变更分类
-					if prevClassify != nil {
-						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
-					} else {
-						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
-					}
-
-					//变更指标
-					if prevEdbInfo != nil {
-						//变更兄弟节点的排序
-						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
-					} else {
-						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
-					}
-				}
-			}
-		}
-
-		edbInfo.Sort = prevSort + 1
-		edbInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
-		//处理只拖动到目录里，默认放到目录底部的情况
-		var maxSort int
-		maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
-			return
-		}
-		edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位
-		edbInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else {
-		// 拖动到父级分类的第一位
-		firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
-			//该分类下的所有指标也需要+1
-			_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
-		} else {
-			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
-			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
-			if tErr != nil && !utils.IsErrNoRow(tErr) {
-				errMsg = "移动失败"
-				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
-				return
-			}
-
-			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 {
-				updateSortStr := ` sort + 1 `
-				_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
-				_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
-			}
-		}
-
-		edbInfo.Sort = 0 //那就是排在第一位
-		edbInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = edbInfo.Update(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("修改失败,Err:" + err.Error())
-			return
-		}
-	}
-
-	return
-}
-
-// moveEdbClassify
+//func movePublicEdb(prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+//	updateCol := make([]string, 0)
+//
+//	if edbInfo == nil {
+//		errMsg = "当前指标不存在"
+//		err = errors.New(errMsg)
+//		return
+//	}
+//	//如果改变了分类，那么移动该指标数据
+//	if edbInfo.ClassifyId != parentClassifyId {
+//		edbInfo.ClassifyId = parentClassifyId
+//		edbInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ClassifyId", "ModifyTime")
+//	}
+//	if prevSort > 0 {
+//		//如果是移动在两个兄弟节点之间
+//		if nextSort > 0 {
+//			//下一个兄弟节点
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevSort == nextSort || prevSort == edbInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//
+//				//变更分类
+//				if prevClassify != nil {
+//					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
+//				} else {
+//					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+//				}
+//
+//				//变更指标
+//				if prevEdbInfo != nil {
+//					//变更兄弟节点的排序
+//					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
+//				} else {
+//					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//				}
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextSort-prevSort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//					//变更分类
+//					if prevClassify != nil {
+//						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
+//					} else {
+//						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+//					}
+//
+//					//变更指标
+//					if prevEdbInfo != nil {
+//						//变更兄弟节点的排序
+//						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
+//					} else {
+//						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//					}
+//				}
+//			}
+//		}
+//
+//		edbInfo.Sort = prevSort + 1
+//		edbInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
+//		//处理只拖动到目录里，默认放到目录底部的情况
+//		var maxSort int
+//		maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+//			return
+//		}
+//		edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位
+//		edbInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else {
+//		// 拖动到父级分类的第一位
+//		firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
+//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+//			errMsg = "移动失败"
+//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
+//			//该分类下的所有指标也需要+1
+//			_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+//		} else {
+//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+//			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
+//			if tErr != nil && !utils.IsErrNoRow(tErr) {
+//				errMsg = "移动失败"
+//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+//				return
+//			}
+//
+//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 {
+//				updateSortStr := ` sort + 1 `
+//				_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
+//				_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
+//			}
+//		}
+//
+//		edbInfo.Sort = 0 //那就是排在第一位
+//		edbInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = edbInfo.Update(updateCol)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("修改失败,Err:" + err.Error())
+//			return
+//		}
+//	}
+//
+//	return
+//}
+
+// moveEdbClassify  TODO
 // @Description: 移动指标分类
 // @author: Roc
 // @datetime 2024-11-26 16:07:44
@@ -665,171 +639,171 @@ func movePublicEdb(prevClassify, nextClassify *data_manage.EdbClassify, edbInfo,
 // @param classifyType uint8
 // @return err error
 // @return errMsg string
-func moveEdbPublicClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
-	updateCol := make([]string, 0)
-
-	// 移动对象为分类， 判断分类是否存在
-	oldParentId := edbClassifyInfo.ParentId
-	oldLevel := edbClassifyInfo.Level
-	var classifyIds []int
-	if oldParentId != parentClassifyId {
-		//更新子分类对应的level
-		childList, e, m := GetChildClassifyByClassifyId(edbClassifyInfo.ClassifyId)
-		if e != nil {
-			errMsg = "移动失败"
-			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
-			return
-		}
-
-		if len(childList) > 0 {
-			for _, v := range childList {
-				if v.ClassifyId == edbClassifyInfo.ClassifyId {
-					continue
-				}
-				classifyIds = append(classifyIds, v.ClassifyId)
-			}
-		}
-	}
-	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
-	if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
-		if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整
-			errMsg = "移动失败"
-			err = errors.New("不支持目录层级变更")
-			return
-		}
-		edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
-		edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId
-		edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
-		edbClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
-	} else if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
-		errMsg = "移动失败"
-		err = errors.New("不支持目录层级变更")
-		return
-	}
-
-	if prevSort > 0 {
-		//如果是移动在两个兄弟节点之间
-		if nextSort > 0 {
-			//下一个兄弟节点
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevSort == nextSort || prevSort == edbClassifyInfo.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-
-				//变更分类
-				if prevClassify != nil {
-					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
-				} else {
-					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
-				}
-
-				//变更指标
-				if prevEdbInfo != nil {
-					//变更兄弟节点的排序
-					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
-				} else {
-					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
-				}
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextSort-prevSort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-
-					//变更分类
-					if prevClassify != nil {
-						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
-					} else {
-						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
-					}
-
-					//变更指标
-					if prevEdbInfo != nil {
-						//变更兄弟节点的排序
-						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
-					} else {
-						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
-					}
-
-				}
-			}
-		}
-
-		edbClassifyInfo.Sort = prevSort + 1
-		edbClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
-		//处理只拖动到目录里，默认放到目录底部的情况
-		var maxSort int
-		maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
-			return
-		}
-		edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
-		edbClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else {
-		// 拖动到父级分类的第一位
-		firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
-			//该分类下的所有指标也需要+1
-			_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
-		} else {
-			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
-			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
-			if tErr != nil && !utils.IsErrNoRow(tErr) {
-				errMsg = "移动失败"
-				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
-				return
-			}
-
-			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 {
-				updateSortStr := ` sort + 1 `
-				_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
-				_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
-			}
-		}
-
-		edbClassifyInfo.Sort = 0 //那就是排在第一位
-		edbClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = edbClassifyInfo.Update(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("修改失败,Err:" + err.Error())
-			return
-		}
-		//更新对应分类的root_id和层级
-		if oldParentId != parentClassifyId {
-			if len(classifyIds) > 0 {
-				levelStep := edbClassifyInfo.Level - oldLevel
-				err = data_manage.UpdateEdbClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep)
-				if err != nil {
-					errMsg = "移动失败"
-					err = errors.New("更新子分类失败,Err:" + err.Error())
-					return
-				}
-			}
-		}
-
-	}
-
-	return
-}
+//func moveEdbPublicClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+//	updateCol := make([]string, 0)
+//
+//	// 移动对象为分类， 判断分类是否存在
+//	oldParentId := edbClassifyInfo.ParentId
+//	oldLevel := edbClassifyInfo.Level
+//	var classifyIds []int
+//	if oldParentId != parentClassifyId {
+//		//更新子分类对应的level
+//		childList, e, m := GetChildClassifyByClassifyId(edbClassifyInfo.ClassifyId)
+//		if e != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
+//			return
+//		}
+//
+//		if len(childList) > 0 {
+//			for _, v := range childList {
+//				if v.ClassifyId == edbClassifyInfo.ClassifyId {
+//					continue
+//				}
+//				classifyIds = append(classifyIds, v.ClassifyId)
+//			}
+//		}
+//	}
+//	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+//	if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+//		if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整
+//			errMsg = "移动失败"
+//			err = errors.New("不支持目录层级变更")
+//			return
+//		}
+//		edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
+//		edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId
+//		edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
+//		edbClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
+//	} else if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
+//		errMsg = "移动失败"
+//		err = errors.New("不支持目录层级变更")
+//		return
+//	}
+//
+//	if prevSort > 0 {
+//		//如果是移动在两个兄弟节点之间
+//		if nextSort > 0 {
+//			//下一个兄弟节点
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevSort == nextSort || prevSort == edbClassifyInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//
+//				//变更分类
+//				if prevClassify != nil {
+//					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
+//				} else {
+//					_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+//				}
+//
+//				//变更指标
+//				if prevEdbInfo != nil {
+//					//变更兄弟节点的排序
+//					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
+//				} else {
+//					_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//				}
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextSort-prevSort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//
+//					//变更分类
+//					if prevClassify != nil {
+//						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
+//					} else {
+//						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+//					}
+//
+//					//变更指标
+//					if prevEdbInfo != nil {
+//						//变更兄弟节点的排序
+//						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
+//					} else {
+//						_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+//					}
+//
+//				}
+//			}
+//		}
+//
+//		edbClassifyInfo.Sort = prevSort + 1
+//		edbClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
+//		//处理只拖动到目录里，默认放到目录底部的情况
+//		var maxSort int
+//		maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+//			return
+//		}
+//		edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
+//		edbClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	} else {
+//		// 拖动到父级分类的第一位
+//		firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
+//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+//			errMsg = "移动失败"
+//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
+//			//该分类下的所有指标也需要+1
+//			_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+//		} else {
+//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+//			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
+//			if tErr != nil && !utils.IsErrNoRow(tErr) {
+//				errMsg = "移动失败"
+//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+//				return
+//			}
+//
+//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 {
+//				updateSortStr := ` sort + 1 `
+//				_ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
+//				_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
+//			}
+//		}
+//
+//		edbClassifyInfo.Sort = 0 //那就是排在第一位
+//		edbClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = edbClassifyInfo.Update(updateCol)
+//		if err != nil {
+//			errMsg = "移动失败"
+//			err = errors.New("修改失败,Err:" + err.Error())
+//			return
+//		}
+//		//更新对应分类的root_id和层级
+//		if oldParentId != parentClassifyId {
+//			if len(classifyIds) > 0 {
+//				levelStep := edbClassifyInfo.Level - oldLevel
+//				err = data_manage.UpdateEdbClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep)
+//				if err != nil {
+//					errMsg = "移动失败"
+//					err = errors.New("更新子分类失败,Err:" + err.Error())
+//					return
+//				}
+//			}
+//		}
+//
+//	}
+//
+//	return
+//}

services/elastic/chart.go

@@ -0,0 +1,509 @@
+package elastic
+
+import (
+	"context"
+	"encoding/json"
+	"eta_gn/eta_api/models/data_manage"
+	"eta_gn/eta_api/utils"
+	"fmt"
+	"github.com/olivere/elastic/v7"
+)
+
+// EsAddOrEditChartInfoData 新增/修改es中的图表数据
+func EsAddOrEditChartInfoData(indexName, docId string, item *data_manage.ChartEsInfo) (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
+}
+
+// SearchChartInfoData 查询es中的图表数据
+func SearchChartInfoData(indexName, keywordStr string, showSysId int, sourceList []int, noPermissionChartIdList []int, from, size int) (list []*data_manage.ChartInfo, total int64, err error) {
+	list = make([]*data_manage.ChartInfo, 0)
+	defer func() {
+		if err != nil {
+			fmt.Println("EsAddOrEditData Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	//queryString := elastic.NewQueryStringQuery(keywordStr)
+	//boolQueryJson, err := json.Marshal(queryString)
+	//if err != nil {
+	//	fmt.Println("boolQueryJson err:", err)
+	//} else {
+	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
+	//}
+
+	highlight := elastic.NewHighlight()
+	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
+	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
+
+	mustMap := make([]interface{}, 0)
+	mustNotMap := make([]interface{}, 0)
+
+	//图表来源
+	if showSysId > 0 {
+		mustMap = append(mustMap, map[string]interface{}{
+			"term": map[string]interface{}{
+				"SysUserId": showSysId,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+	mustMap = append(mustMap, map[string]interface{}{
+		"terms": map[string]interface{}{
+			"Source": sourceList,
+		},
+	})
+
+	//关键字匹配
+	//shouldMap := map[string]interface{}{
+	//	"should": []interface{}{
+	//		map[string]interface{}{
+	//			"match": map[string]interface{}{
+	//				"ChartName": keywordStr,
+	//				//"Frequency.keyword": "月度",
+	//			},
+	//		},
+	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
+	//		map[string]interface{}{
+	//			"match": map[string]interface{}{
+	//				"ChartName": map[string]interface{}{
+	//					"query":    keywordStr,
+	//					"operator": "and",
+	//				},
+	//				//"Frequency.keyword": "月度",
+	//			},
+	//		},
+	//		map[string]interface{}{
+	//			"match": map[string]interface{}{
+	//				"ChartNameEn": keywordStr,
+	//				//"Frequency.keyword": "月度",
+	//			},
+	//		},
+	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
+	//		map[string]interface{}{
+	//			"match": map[string]interface{}{
+	//				"ChartNameEn": map[string]interface{}{
+	//					"query":    keywordStr,
+	//					"operator": "and",
+	//				},
+	//				//"Frequency.keyword": "月度",
+	//			},
+	//		},
+	//	},
+	//}
+
+	// 默认使用中文名字字段去匹配
+	keywordNameKey := `ChartName`
+	// 如果没有中文，则使用英文名称字段去匹配
+	if !utils.ContainsChinese(keywordStr) {
+		keywordNameKey = `ChartNameEn`
+	}
+	shouldMap := map[string]interface{}{
+		"should": []interface{}{
+			map[string]interface{}{
+				"match": map[string]interface{}{
+					keywordNameKey: keywordStr,
+					//"Frequency.keyword": "月度",
+				},
+			},
+			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
+			map[string]interface{}{
+				"match": map[string]interface{}{
+					keywordNameKey: map[string]interface{}{
+						"query":    keywordStr,
+						"operator": "and",
+					},
+					//"Frequency.keyword": "月度",
+				},
+			},
+		},
+	}
+
+	mustMap = append(mustMap, map[string]interface{}{
+		"bool": shouldMap,
+	})
+
+	// noPermissionChartIdList 无权限图表id
+	if len(noPermissionChartIdList) > 0 {
+		mustNotMap = append(mustNotMap, map[string]interface{}{
+			"terms": map[string]interface{}{
+				"ChartInfoId": noPermissionChartIdList,
+				//"Frequency.keyword": "月度",
+			},
+		})
+	}
+
+	queryMap := map[string]interface{}{
+		"query": map[string]interface{}{
+			"bool": map[string]interface{}{
+				"must":     mustMap,
+				"must_not": mustNotMap,
+				//"should":   shouldMap,
+			},
+		},
+	}
+
+	//根据条件数量统计
+	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
+	total, err = requestTotalHits.Do(context.Background())
+	if err != nil {
+		return
+	}
+
+	// 分页查询
+	queryMap["from"] = from
+	queryMap["size"] = size
+	jsonBytes, _ := json.Marshal(queryMap)
+	fmt.Println(string(jsonBytes))
+
+	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request
+
+	//requestJson, err := json.Marshal(request)
+	//if err != nil {
+	//	fmt.Println("requestJson err:", err)
+	//}
+	//fmt.Println("requestJson ", string(requestJson))
+	searchMap := make(map[string]string)
+
+	searchResp, err := request.Do(context.Background())
+	if err != nil {
+		return
+	}
+	fmt.Println(searchResp)
+	fmt.Println(searchResp.Status)
+	if searchResp.Status != 0 {
+		return
+	}
+
+	if searchResp.Hits != nil {
+		for _, v := range searchResp.Hits.Hits {
+			if _, ok := searchMap[v.Id]; !ok {
+				itemJson, tmpErr := v.Source.MarshalJSON()
+				if tmpErr != nil {
+					err = tmpErr
+					fmt.Println("movieJson err:", err)
+					return
+				}
+				chartInfoItem := new(data_manage.ChartInfo)
+				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
+				if err != nil {
+					fmt.Println("json.Unmarshal chartInfoJson err:", err)
+					err = tmpErr
+					return
+				}
+				if len(v.Highlight["ChartName"]) > 0 {
+					chartInfoItem.ChartName = v.Highlight["ChartName"][0]
+				}
+				list = append(list, chartInfoItem)
+				searchMap[v.Id] = v.Id
+			}
+		}
+	}
+
+	//for _, v := range result {
+	//	fmt.Println(v)
+	//}
+	return
+}
+
+func SearchChartInfoDataByShared(keywordStr string, from, size, chartShare int, sourceList, classifyIdList []int, chartAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.ChartInfoView, err error) {
+	indexName := utils.CHART_INDEX_NAME
+	list = make([]*data_manage.ChartInfoView, 0)
+	defer func() {
+		if err != nil {
+			fmt.Println("SearchChartInfoData 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("ChartClassifyId", termsList...))
+	}
+
+	// 如果指定了分享状态，那么就添加分享状态的筛选
+	// 0：全部，1：未共享，2：已共享
+	switch chartShare {
+	case 1:
+		// 筛选 SharedUserIdList 为空的文档
+		query = query.MustNot(elastic.NewExistsQuery("SharedUserIdList"))
+	case 2:
+		// 筛选 SharedUserIdList 不为空的文档
+		query = query.Must(elastic.NewExistsQuery("SharedUserIdList"))
+	}
+
+	// 图表名称、编码匹配
+	if keywordStr != `` {
+		// 默认使用中文名字字段去匹配
+		keywordNameKey := `ChartName`
+		query = query.Must(elastic.NewMatchQuery(keywordStr, keywordNameKey))
+	}
+
+	// 图表与用户的权限匹配
+	{
+		//图表权限范围，0-全部；1-我的；2-公共
+		switch chartAuth {
+		case 1:
+			// 自己的图表
+			query = query.Must(elastic.NewTermQuery(`SysUserId`, sysUserId))
+		case 2:
+			// 公开的图表
+			query = query.Must(elastic.NewTermQuery(`PublicStatus`, utils.DataPublicSuccess))
+		default:
+			tmpShouldQuery := elastic.NewBoolQuery()
+			// 自己的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`SysUserId`, sysUserId))
+			// 分享给我的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermsQuery(`SharedUserIdList`, sysUserId))
+			//公开的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`PublicStatus`, utils.DataPublicSuccess))
+			//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 searchChartInfoData(indexName, query, sortList, from, size)
+}
+
+func SearchChartInfoDataByPublic(keywordStr string, from, size int, chartPublicList, sourceList, classifyIdList, publicClassifyIdList []int, chartAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.ChartInfoView, err error) {
+	indexName := utils.CHART_INDEX_NAME
+	list = make([]*data_manage.ChartInfoView, 0)
+	defer func() {
+		if err != nil {
+			fmt.Println("SearchChartInfoData 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...))
+	}
+
+	// publicClassifyIdList 指定公共分类下的图表
+	if len(publicClassifyIdList) > 0 {
+		termsList := make([]interface{}, 0)
+		for _, v := range publicClassifyIdList {
+			termsList = append(termsList, v)
+		}
+		query = query.Must(elastic.NewTermsQuery("ChartPublicClassifyId", termsList...))
+	}
+
+	// 如果指定了图表公开状态，那么就添加图表公开状态的筛选
+	// 公开状态；0：未公开；1：审批中；2：已驳回；3：已公开
+	if len(chartPublicList) > 0 {
+		termsList := make([]interface{}, 0)
+		for _, v := range chartPublicList {
+			termsList = append(termsList, v)
+		}
+		query = query.Must(elastic.NewTermsQuery("PublicStatus", termsList...))
+	}
+
+	// 图表名称、编码匹配
+	if keywordStr != `` {
+		// 默认使用中文名字字段去匹配
+		keywordNameKey := `ChartName`
+		query = query.Must(elastic.NewMatchQuery(keywordStr, keywordNameKey))
+	}
+
+	// 图表与用户的权限匹配
+	{
+		//图表权限范围，0-全部；1-我的；2-公共
+		switch chartAuth {
+		case 1:
+			// 自己的图表
+			query = query.Must(elastic.NewTermQuery(`SysUserId`, sysUserId))
+		case 2:
+			// 公开的图表
+			query = query.Must(elastic.NewTermQuery(`PublicStatus`, utils.DataPublicSuccess))
+		default:
+			tmpShouldQuery := elastic.NewBoolQuery()
+			// 自己的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`SysUserId`, sysUserId))
+			// 分享给我的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermsQuery(`SharedUserIdList`, sysUserId))
+			//公开的图表
+			tmpShouldQuery = tmpShouldQuery.Should(elastic.NewTermQuery(`PublicStatus`, utils.DataPublicSuccess))
+			//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 searchChartInfoData(indexName, query, sortList, from, size)
+}
+
+// searchChartInfoData 查询es中的图表数据
+func searchChartInfoData(indexName string, query elastic.Query, sortList []*elastic.FieldSort, from, size int) (total int64, list []*data_manage.ChartInfoView, err error) {
+	total, err = searchChartInfoDataTotal(indexName, query)
+	if err != nil {
+		return
+	}
+
+	// 获取列表数据
+	list, err = searchChartInfoDataList(indexName, query, sortList, from, size)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// searchChartInfoDataTotal 查询es中的图表数量
+func searchChartInfoDataTotal(indexName string, query elastic.Query) (total int64, err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("searchChartInfoDataTotal Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+
+	//根据条件数量统计
+	requestTotalHits := client.Count(indexName).Query(query)
+	total, err = requestTotalHits.Do(context.Background())
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// searchChartInfoData 查询es中的图表数据
+func searchChartInfoDataList(indexName string, query elastic.Query, sortList []*elastic.FieldSort, from, size int) (list []*data_manage.ChartInfoView, err error) {
+	list = make([]*data_manage.ChartInfoView, 0)
+	defer func() {
+		if err != nil {
+			fmt.Println("searchChartInfoDataList Err:", err.Error())
+		}
+	}()
+	client := utils.EsClient
+	// 高亮
+	highlight := elastic.NewHighlight()
+	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
+	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
+				}
+				chartInfoItem := new(data_manage.ChartInfoView)
+				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
+				if err != nil {
+					fmt.Println("json.Unmarshal chartInfoJson err:", err)
+					err = tmpErr
+					return
+				}
+				if len(v.Highlight["ChartName"]) > 0 {
+					chartInfoItem.ChartName = v.Highlight["ChartName"][0]
+				}
+				list = append(list, chartInfoItem)
+				searchMap[v.Id] = v.Id
+			}
+		}
+	}
+
+	return
+}

services/elastic/elastic.go

@@ -169,30 +169,6 @@ func Analyze(content string) (contentList []string, err error) {
 	return
 }
 
-// EsAddOrEditChartInfoData 新增/修改es中的图表数据
-func EsAddOrEditChartInfoData(indexName, docId string, item *data_manage.ChartInfo) (err error) {
-	defer func() {
-		if err != nil {
-			fmt.Println("EsAddOrEditData Err:", err.Error())
-		}
-	}()
-	client := utils.EsClient
-
-	resp, err := client.Index().Index(indexName).Id(docId).BodyJson(item).Do(context.Background())
-	if err != nil {
-		fmt.Println("新增失败:", err.Error())
-		return err
-	}
-	fmt.Println(resp)
-	if resp.Status == 0 {
-		fmt.Println("新增成功", resp.Result)
-		err = nil
-	} else {
-		fmt.Println("AddData", resp.Status, resp.Result)
-	}
-	return
-}
-
 // EsDeleteDataV2 删除es中的数据
 func EsDeleteDataV2(indexName, docId string) (err error) {
 	defer func() {
@@ -215,198 +191,6 @@ func EsDeleteDataV2(indexName, docId string) (err error) {
 	return
 }
 
-// SearchChartInfoData 查询es中的图表数据
-func SearchChartInfoData(indexName, keywordStr string, showSysId int, sourceList []int, noPermissionChartIdList []int, from, size int) (list []*data_manage.ChartInfo, total int64, err error) {
-	list = make([]*data_manage.ChartInfo, 0)
-	defer func() {
-		if err != nil {
-			fmt.Println("EsAddOrEditData Err:", err.Error())
-		}
-	}()
-	client := utils.EsClient
-
-	//queryString := elastic.NewQueryStringQuery(keywordStr)
-	//boolQueryJson, err := json.Marshal(queryString)
-	//if err != nil {
-	//	fmt.Println("boolQueryJson err:", err)
-	//} else {
-	//	fmt.Println("boolQueryJson ", string(boolQueryJson))
-	//}
-
-	highlight := elastic.NewHighlight()
-	highlight = highlight.Fields(elastic.NewHighlighterField("ChartName"))
-	highlight = highlight.PreTags("<font color='red'>").PostTags("</font>")
-
-	mustMap := make([]interface{}, 0)
-	mustNotMap := make([]interface{}, 0)
-
-	//指标来源
-	if showSysId > 0 {
-		mustMap = append(mustMap, map[string]interface{}{
-			"term": map[string]interface{}{
-				"SysUserId": showSysId,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-	mustMap = append(mustMap, map[string]interface{}{
-		"terms": map[string]interface{}{
-			"Source": sourceList,
-		},
-	})
-
-	//关键字匹配
-	//shouldMap := map[string]interface{}{
-	//	"should": []interface{}{
-	//		map[string]interface{}{
-	//			"match": map[string]interface{}{
-	//				"ChartName": keywordStr,
-	//				//"Frequency.keyword": "月度",
-	//			},
-	//		},
-	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-	//		map[string]interface{}{
-	//			"match": map[string]interface{}{
-	//				"ChartName": map[string]interface{}{
-	//					"query":    keywordStr,
-	//					"operator": "and",
-	//				},
-	//				//"Frequency.keyword": "月度",
-	//			},
-	//		},
-	//		map[string]interface{}{
-	//			"match": map[string]interface{}{
-	//				"ChartNameEn": keywordStr,
-	//				//"Frequency.keyword": "月度",
-	//			},
-	//		},
-	//		// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-	//		map[string]interface{}{
-	//			"match": map[string]interface{}{
-	//				"ChartNameEn": map[string]interface{}{
-	//					"query":    keywordStr,
-	//					"operator": "and",
-	//				},
-	//				//"Frequency.keyword": "月度",
-	//			},
-	//		},
-	//	},
-	//}
-
-	// 默认使用中文名字字段去匹配
-	keywordNameKey := `ChartName`
-	// 如果没有中文，则使用英文名称字段去匹配
-	if !utils.ContainsChinese(keywordStr) {
-		keywordNameKey = `ChartNameEn`
-	}
-	shouldMap := map[string]interface{}{
-		"should": []interface{}{
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					keywordNameKey: keywordStr,
-					//"Frequency.keyword": "月度",
-				},
-			},
-			// 因为关键词被分了，所以需要用下面的语句来让他 整个词 查询，从而加重整词的权重
-			map[string]interface{}{
-				"match": map[string]interface{}{
-					keywordNameKey: map[string]interface{}{
-						"query":    keywordStr,
-						"operator": "and",
-					},
-					//"Frequency.keyword": "月度",
-				},
-			},
-		},
-	}
-
-	mustMap = append(mustMap, map[string]interface{}{
-		"bool": shouldMap,
-	})
-
-	// noPermissionEdbInfoIdList 无权限指标id
-	if len(noPermissionChartIdList) > 0 {
-		mustNotMap = append(mustNotMap, map[string]interface{}{
-			"terms": map[string]interface{}{
-				"ChartInfoId": noPermissionChartIdList,
-				//"Frequency.keyword": "月度",
-			},
-		})
-	}
-
-	queryMap := map[string]interface{}{
-		"query": map[string]interface{}{
-			"bool": map[string]interface{}{
-				"must":     mustMap,
-				"must_not": mustNotMap,
-				//"should":   shouldMap,
-			},
-		},
-	}
-
-	//根据条件数量统计
-	requestTotalHits := client.Count(indexName).BodyJson(queryMap)
-	total, err = requestTotalHits.Do(context.Background())
-	if err != nil {
-		return
-	}
-
-	// 分页查询
-	queryMap["from"] = from
-	queryMap["size"] = size
-	jsonBytes, _ := json.Marshal(queryMap)
-	fmt.Println(string(jsonBytes))
-
-	request := client.Search(indexName).Highlight(highlight).Source(queryMap) // sets the JSON request
-
-	//requestJson, err := json.Marshal(request)
-	//if err != nil {
-	//	fmt.Println("requestJson err:", err)
-	//}
-	//fmt.Println("requestJson ", string(requestJson))
-	searchMap := make(map[string]string)
-
-	searchResp, err := request.Do(context.Background())
-	if err != nil {
-		return
-	}
-	fmt.Println(searchResp)
-	fmt.Println(searchResp.Status)
-	if searchResp.Status != 0 {
-		return
-	}
-
-	if searchResp.Hits != nil {
-		for _, v := range searchResp.Hits.Hits {
-			if _, ok := searchMap[v.Id]; !ok {
-				itemJson, tmpErr := v.Source.MarshalJSON()
-				if tmpErr != nil {
-					err = tmpErr
-					fmt.Println("movieJson err:", err)
-					return
-				}
-				chartInfoItem := new(data_manage.ChartInfo)
-				tmpErr = json.Unmarshal(itemJson, &chartInfoItem)
-				if err != nil {
-					fmt.Println("json.Unmarshal chartInfoJson err:", err)
-					err = tmpErr
-					return
-				}
-				if len(v.Highlight["ChartName"]) > 0 {
-					chartInfoItem.ChartName = v.Highlight["ChartName"][0]
-				}
-				list = append(list, chartInfoItem)
-				searchMap[v.Id] = v.Id
-			}
-		}
-	}
-
-	//for _, v := range result {
-	//	fmt.Println(v)
-	//}
-	return
-}
-
 // EsAddOrEditDataInterface 新增/修改es中的数据
 func EsAddOrEditDataInterface(indexName, docId string, item interface{}) (err error) {
 	defer func() {