fix:共享人显示名称

controllers/data_manage/data_approve/data_approve_flow.go

@@ -6,6 +6,8 @@ import (
 	"eta_gn/eta_api/models"
 	"eta_gn/eta_api/models/data_manage/data_approve/request"
 	DataApprove "eta_gn/eta_api/services/data/data_approve"
+	"eta_gn/eta_api/utils"
+	"fmt"
 )
 
 type DataApproveFlowController struct {
@@ -71,6 +73,27 @@ func (c *DataApproveFlowController) Save() {
 		return
 	}
 
+	// 设置审批忽略人
+	{
+		ignoreApproveUserIdStr := ``
+		if len(req.IgnoreApproveUserIdList) > 0 {
+			ignoreApproveUserIdStr = utils.Implode(req.IgnoreApproveUserIdList)
+		}
+		switch req.DataType {
+		case DataApprove.DataTypeEdb:
+			err = models.UpdateBusinessConfMulti([]models.BusinessConfUpdate{
+				{ConfKey: models.IgnoreEdbApproveUserId, ConfVal: ignoreApproveUserIdStr},
+			})
+		case DataApprove.DataTypeChart:
+			err = models.UpdateBusinessConfMulti([]models.BusinessConfUpdate{
+				{ConfKey: models.IgnoreChartApproveUserId, ConfVal: ignoreApproveUserIdStr},
+			})
+		}
+		if err != nil {
+			utils.FileLog.Error(fmt.Sprintf("更新审批忽略人配置失败，审批类型：%d，忽略人信息：%s, err:%s", req.DataType, ignoreApproveUserIdStr, err.Error()))
+		}
+	}
+
 	br.Msg = "编辑审批流成功"
 	br.Success = true
 	br.Ret = 200

controllers/data_manage/edb_info.go

@@ -4595,250 +4595,84 @@ func (this *EdbInfoController) ChartImageSetBySvg() {
 	br.Msg = "保存成功"
 }
 
-// EdbInfoFilterByEs
-// @Title 指标筛选接口
-// @Description 指标筛选接口
-// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
-// @Param   FilterSource   query   int  false       "搜索来源:1:其他搜索,2:累计值转月值搜索,3:变频，4：基础指标，5：同比"
-// @Param   Frequency   query   string  false       "频度"
-// @Param   IsAddPredictEdb   query   bool  false       "是否查询添加预测指标"
-// @Param   PageSize   query   int  true       "每页数据条数"
-// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
-// @Param   EdbType   query   int  false       "指标类型：0-基础和计算；1-基础指标；2-计算指标；3-衍生指标"
-// @Param   EdbAuth   query   int  false       "指标权限：0-全部；1-我的；2-公共"
-// @Param   EdbCollect   query   int  false       "指标收藏状态：0-全部；1-已收藏"
-// @Success 200 {object} data_manage.EdbInfoList
-// @router /edb_info/batch_move [get]
+// BatchMoveEdb
+// @Title 指标批量移动接口
+// @Description 指标批量移动接口
+// @Param	request	body request.MoveEdbClassifyReq true "type json string"
+// @Success Ret=200 移动成功
+// @router /edb_info/batch_move [post]
 func (this *EdbInfoController) BatchMoveEdb() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
 		this.ServeJSON()
 	}()
-	pageSize, _ := this.GetInt("PageSize")
-	currentIndex, _ := this.GetInt("CurrentIndex")
 
-	// TODO 移动指标
-	var err error
-	req := data_manage.EsEdbReq{}
-	err = this.ParseForm(&req)
+	var req request.MoveEdbClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
-		br.Msg = "参数错误"
-		br.ErrMsg = "参数错误"
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
 		return
 	}
-	var total int64
-
-	var startSize int
-	if pageSize <= 0 {
-		pageSize = utils.PageSize20
-	}
-	if currentIndex <= 0 {
-		currentIndex = 1
-	}
-	startSize = paging.StartIndex(currentIndex, pageSize)
-
-	keyWord := this.GetString("KeyWord")
-	keyWord = strings.TrimSpace(keyWord) //移除字符串首尾空格
-	filterSource, _ := this.GetInt("FilterSource")
-	if filterSource <= 0 {
-		filterSource = 1
-	}
-	//指标来源
-	source, _ := this.GetInt("Source")
-
-	frequency := this.GetString("Frequency") //频度
 
-	//isAddPredictEdb, _ := this.GetBool("IsAddPredictEdb") //是否查询添加预测指标
-
-	// 指标类型数组：1-基础指标；2-计算指标;3-预测指标
-	edbTypeList := make([]int, 0)
-	edbInfoType := -1                            // 指标范围
-	edbTypeStr := this.GetString("EdbType", "0") // 指标类型：0-基础和计算；1-基础指标；2-计算指标；3-预测指标
-	{
-		if edbTypeStr == `` || edbTypeStr == `0` {
-			edbTypeList = []int{1, 2}
-			edbInfoType = 0
-		} else {
-			var hasEdb, hasPredictEdb bool
-			tmpEdbTypeList := strings.Split(edbTypeStr, `,`)
-			for _, v := range tmpEdbTypeList {
-				edbType, err := strconv.Atoi(v)
-				if err != nil {
-					br.Msg = "EdbType异常"
-					br.ErrMsg = "EdbType异常，Err:" + err.Error()
-					return
-				}
-
-				// 指标类型
-				switch edbType {
-				case 1, 2:
-					hasEdb = true
-					edbTypeList = append(edbTypeList, edbType)
-				case 3:
-					hasPredictEdb = true
-					edbTypeList = []int{1, 2}
-				}
-			}
-
-			// 只有数据查看和指标加工
-			if hasEdb && !hasPredictEdb {
-				edbInfoType = 0
-			} else if !hasEdb && hasPredictEdb {
-				// 只有预测指标
-				edbInfoType = 1
-			}
-		}
-	}
-
-	edbAuth, _ := this.GetInt("EdbAuth", 0) // 指标权限范围，0-全部；1-我的；2-公共
-
-	edbCollect, _ := this.GetInt("EdbCollect", 0) // 指标收藏状态：0-全部；1-已收藏
-
-	var edbInfoList []*data_manage.EdbInfoList
-
-	// 无权限指标 和 无权限指标分类id（只考虑）
-	noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, err := data_manage_permission.GetUserAllEdbAndClassifyNoPermissionListV2(this.SysUser.AdminId)
-	if err != nil {
-		br.Msg = "获取失败"
-		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+	if req.NewClassifyId <= 0 {
+		br.Msg = `请选择要转移的新分类`
+		br.IsSendEmail = false
 		return
 	}
 
-	// 收藏的指标id
-	collectEdbInfoIdList := make([]int, 0)
-	if edbCollect == 1 {
-		collectEdbInfoIdList, err = data_manage.GetUserAllCollectEdbInfoIdList(this.SysUser.AdminId)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取收藏指标配置数据失败，Err:" + err.Error()
-			return
-		}
-	}
-
-	var keyWordArr []string
-	keyWordArr = append(keyWordArr, keyWord)
-
-	newKeyWord := strings.Split(keyWord, " ")
-	keyWordArr = append(keyWordArr, newKeyWord...)
-
-	sortMap := make(map[string]string)
-	// 如果没有搜索关键词，则默认根据指标编码倒序排序
-	if keyWord == `` {
-		sortMap["EdbInfoId"] = `desc`
-	}
-
-	// 普通的搜索
-	total, edbInfoList, err = elastic.SearchEdbInfoData(keyWord, startSize, pageSize, filterSource, source, frequency, noPermissionEdbInfoIdList, noPermissionEdbClassifyIdList, collectEdbInfoIdList, edbTypeList, edbInfoType, edbAuth, this.SysUser.AdminId, sortMap)
-
+	// 获取指标
+	edbInfoList, err := data.GetAllEdbInfoListBySearchPublicEdbReq(req.SearchPublicEdbReq, this.SysUser.AdminId)
 	if err != nil {
-		edbInfoList = make([]*data_manage.EdbInfoList, 0)
-	}
-
-	page := paging.GetPaging(currentIndex, pageSize, int(total))
-
-	edbInfoListLen := len(edbInfoList)
-
-	classifyIdList := make([]int, 0)
-	for i := 0; i < edbInfoListLen; i++ {
-		edbInfoList[i].ConvertToResp()
-		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
-		classifyIdList = append(classifyIdList, edbInfoList[i].ClassifyId)
+		br.Msg = "获取指标列表失败！"
+		br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
+		return
 	}
 
-	// 当前列表中的分类map
-	classifyMap := make(map[int]*data_manage.EdbClassify)
-	if edbInfoListLen > 0 {
-		classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
-			return
-		}
-
-		for _, v := range classifyList {
-			classifyMap[v.ClassifyId] = v
-		}
-
-		// 获取所有有权限的指标和分类
-		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
-			return
+	edbInfoIdList := make([]int, 0)
+	// 如果有过滤指标，那么就过滤吧
+	if len(req.NoEdbIdList) > 0 {
+		noEdbIdMap := make(map[int]bool)
+		for _, v := range req.NoEdbIdList {
+			noEdbIdMap[v] = true
 		}
 
-		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
-		{
-			edbInfoIdList := make([]int, 0)
-			for i := 0; i < edbInfoListLen; i++ {
-				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
-				tmpEdbInfo := edbInfoList[i]
-				if currClassify, ok := classifyMap[tmpEdbInfo.ClassifyId]; ok {
-					edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfo.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfo.EdbInfoId, tmpEdbInfo.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
-				}
-			}
-
-			tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
-			if err != nil {
-				br.Msg = "获取失败"
-				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
-				return
-			}
-			edbInfoMap := make(map[int]*data_manage.EdbInfo)
-			for _, v := range tmpEdbList {
-				edbInfoMap[v.EdbInfoId] = v
-			}
-
-			for i := 0; i < edbInfoListLen; i++ {
-				tmpEdbInfo, ok := edbInfoMap[edbInfoList[i].EdbInfoId]
-				if !ok {
-					continue
-				}
-				edbInfoList[i].IsJoinPermission = tmpEdbInfo.IsJoinPermission
+		for _, edbInfo := range edbInfoList {
+			if _, ok := noEdbIdMap[edbInfo.EdbInfoId]; !ok {
+				// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
+				edbInfoIdList = append(edbInfoIdList, edbInfo.EdbInfoId)
 			}
 		}
-
-		// 权限校验
-		for i := 0; i < edbInfoListLen; i++ {
-			tmpEdbInfoItem := edbInfoList[i]
-			if currClassify, ok := classifyMap[tmpEdbInfoItem.ClassifyId]; ok {
-				edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfoItem.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfoItem.EdbInfoId, tmpEdbInfoItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
-			}
+	} else {
+		for _, edbInfo := range edbInfoList {
+			edbInfoIdList = append(edbInfoIdList, edbInfo.EdbInfoId)
 		}
 	}
 
-	for i := 0; i < edbInfoListLen; i++ {
-		for j := 0; j < edbInfoListLen; j++ {
-			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
-				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
-				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
-				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
-			}
-		}
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		br.Msg = `请选择要移动的指标！`
+		br.IsSendEmail = false
+		return
 	}
-	//新增搜索词记录
-	{
-		searchKeyword := new(data_manage.SearchKeyword)
-		searchKeyword.KeyWord = keyWord
-		searchKeyword.CreateTime = time.Now()
-		go data_manage.AddSearchKeyword(searchKeyword)
+	if num > 100 {
+		br.Msg = `最多只能选择100条指标！`
+		br.IsSendEmail = false
+		return
 	}
 
-	// 不返回无权限的指标
-	respList := make([]*data_manage.EdbInfoList, 0)
-	for _, v := range edbInfoList {
-		if v.HaveOperaAuth {
-			respList = append(respList, v)
+	// 开始批量修改指标分类
+	if len(edbInfoIdList) > 0 {
+		err = data_manage.UpdateClassifyIdByEdbInfoIdList(edbInfoIdList, req.NewClassifyId)
+		if err != nil {
+			br.Msg = `指标移动失败！`
+			br.ErrMsg = `指标移动失败，ERR：` + err.Error()
+			return
 		}
 	}
 
-	resp := data_manage.EdbInfoFilterDataResp{
-		Paging: page,
-		List:   respList,
-	}
 	br.Ret = 200
 	br.Success = true
 	br.Msg = "获取成功"
-	br.Data = resp
 }

controllers/data_manage/edb_public.go

@@ -481,9 +481,9 @@ func (c *EdbPublicController) ListByEs() {
 	startSize = paging.StartIndex(currentIndex, pageSize)
 
 	// 获取查询参数
-	keyword, searchEdbPublicList, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, sortMap := getSearchPar(req)
+	keyword, searchEdbPublicList, sourceList, edbClassifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, sortMap := data.GetSearchPar(req)
 
-	total, edbInfoList, err := elastic.SearchEdbInfoDataByPublic(keyword, startSize, pageSize, searchEdbPublicList, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, c.SysUser.AdminId, sortMap)
+	total, edbInfoList, err := elastic.SearchEdbInfoDataByPublic(keyword, startSize, pageSize, searchEdbPublicList, sourceList, edbClassifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, c.SysUser.AdminId, sortMap)
 	if err != nil {
 		edbInfoList = make([]*data_manage.EdbInfoList, 0)
 	}
@@ -565,59 +565,79 @@ func (c *EdbPublicController) AllListByEs() {
 	}
 	// 选择所有指标，所以需要通过es获取数据
 
+	// 选中的指标id列表
 	edbInfoList := make([]*data_manage.EdbInfoList, 0)
-	tmpEdbInfoList, err := getAllEdbInfoListByPublic(req, c.SysUser.AdminId)
 
-	// 如果有过滤指标，那么就过滤吧
-	if len(req.NoEdbIdList) > 0 {
-		noEdbIdMap := make(map[int]bool)
-		for _, v := range req.NoEdbIdList {
-			noEdbIdMap[v] = true
+	// 选择所有指标，所以需要通过es获取数据
+	if req.IsSelectAll {
+		tmpEdbInfoList, err := data.GetAllEdbInfoListBySearchPublicEdbReq(req.SearchPublicEdbReq, c.SysUser.AdminId)
+		if err != nil {
+			br.Msg = "获取指标列表失败！"
+			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
+			return
 		}
 
-		for _, v := range tmpEdbInfoList {
-			if _, ok := noEdbIdMap[v.EdbInfoId]; !ok {
-				// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
-				edbInfoList = append(edbInfoList, v)
+		// 如果有过滤指标，那么就过滤吧
+		if len(req.NoEdbIdList) > 0 {
+			noEdbIdMap := make(map[int]bool)
+			for _, v := range req.NoEdbIdList {
+				noEdbIdMap[v] = true
+			}
+
+			for _, v := range tmpEdbInfoList {
+				if _, ok := noEdbIdMap[v.EdbInfoId]; !ok {
+					// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
+					edbInfoList = append(edbInfoList, v)
+				}
 			}
+		} else {
+			edbInfoList = tmpEdbInfoList
 		}
-	} else {
-		edbInfoList = tmpEdbInfoList
-	}
 
-	edbInfoListLen := len(edbInfoList)
+		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		if len(edbInfoList) > 0 {
 
-	// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
-	if len(edbInfoList) > 0 {
+			edbInfoIdList := make([]int, 0)
+			for _, v := range edbInfoList {
+				v.ConvertToResp()
+				v.EdbNameAlias = v.EdbName
+				v.HaveOperaAuth = true
+				edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
+			}
 
-		edbInfoIdList := make([]int, 0)
-		for _, v := range edbInfoList {
-			v.ConvertToResp()
-			v.EdbNameAlias = v.EdbName
-			v.HaveOperaAuth = true
-			edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
-		}
+			tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
+			if err != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+				return
+			}
+			edbInfoMap := make(map[int]*data_manage.EdbInfo)
+			for _, v := range tmpEdbList {
+				edbInfoMap[v.EdbInfoId] = v
+			}
 
-		tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
-		if err != nil {
-			br.Msg = "获取失败"
-			br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
-			return
-		}
-		edbInfoMap := make(map[int]*data_manage.EdbInfo)
-		for _, v := range tmpEdbList {
-			edbInfoMap[v.EdbInfoId] = v
+			for _, v := range edbInfoList {
+				tmpEdbInfo, ok := edbInfoMap[v.EdbInfoId]
+				if !ok {
+					continue
+				}
+				v.IsJoinPermission = tmpEdbInfo.IsJoinPermission
+			}
 		}
-
-		for _, v := range edbInfoList {
-			tmpEdbInfo, ok := edbInfoMap[v.EdbInfoId]
-			if !ok {
-				continue
+	} else {
+		// 因为是ES查找的，所以需要重新查一下指标的信息，主要是为了把是否授权字段找出来
+		if len(req.EdbIdList) > 0 {
+			edbInfoList, err = data_manage.GetEdbInfoListByCond(` AND edb_info_id in (?) `, []interface{}{req.EdbIdList})
+			if err != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
+				return
 			}
-			v.IsJoinPermission = tmpEdbInfo.IsJoinPermission
 		}
 	}
 
+	edbInfoListLen := len(edbInfoList)
+
 	for i := 0; i < edbInfoListLen; i++ {
 		for j := 0; j < edbInfoListLen; j++ {
 			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
@@ -636,129 +656,3 @@ func (c *EdbPublicController) AllListByEs() {
 	br.Msg = "获取成功"
 	br.Data = resp
 }
-
-// getSearchPar
-// @Description: 获取查询参数
-// @author: Roc
-// @datetime 2024-12-05 14:13:25
-// @param req request.SearchPublicEdbReq
-// @return keyword string
-// @return searchEdbPublicList []int
-// @return sourceList []int
-// @return classifyIdList []int
-// @return edbTypeList []int
-// @return edbInfoType int
-// @return edbAuth int
-// @return sortMap map[string]string
-func getSearchPar(req request.SearchPublicEdbReq) (keyword string, searchEdbPublicList, sourceList, classifyIdList, edbTypeList []int, edbInfoType, edbAuth int, sortMap map[string]string) {
-	keyword = req.Keyword
-	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
-
-	//指标来源
-	sourceList = req.SourceList
-
-	// 选择的分类
-	classifyIdList = req.ClassifyIdList
-
-	// 指标公开状态：1：未公开，2：已提交；3：已公开。可多选，默认是未公开
-	edbPublicList := req.EdbPublicList
-	if len(edbPublicList) <= 0 {
-		edbPublicList = []int{1}
-	}
-
-	edbInfoType = 0        // 普通指标
-	edbTypeList = []int{2} // 普通指标中的计算指标
-	edbAuth = 1            // 选择范围是：只有我的指标
-
-	searchEdbPublicList = make([]int, 0) // 0：全部，1：未公开，2：已提交；3：已公开
-	if len(edbPublicList) > 0 && !utils.InArrayByInt(edbPublicList, 0) {
-		// 不含全部
-		for _, v := range edbPublicList {
-			switch v {
-			case 1: // 未公开
-				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicDefault)
-			case 2: // 已提交
-				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicCommit, utils.EdbPublicReject)
-			case 3: // 已公开
-				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicSuccess)
-
-			}
-		}
-	} else {
-		searchEdbPublicList = []int{0, 1, 2, 3}
-	}
-
-	sortMap = make(map[string]string)
-	// 如果没有搜索关键词，则默认根据指标编码倒序排序
-	if keyword == `` {
-		sortMap["EdbInfoId"] = `desc`
-	}
-
-	return
-
-}
-
-// getAllEdbInfoListByPublic
-// @Description: 获取所有的指标列表
-// @author: Roc
-// @datetime 2024-12-04 15:43:14
-// @param req request.SetEdbChartPermissionReq
-// @param userId int
-// @return edbInfoIdList []*data_manage.EdbInfoList
-// @return err error
-func getAllEdbInfoListByPublic(req request.AllSearchPublicEdbReq, userId int) (edbInfoList []*data_manage.EdbInfoList, err error) {
-	// 获取查询参数
-	keyword, searchEdbPublicList, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, sortMap := getSearchPar(req.SearchPublicEdbReq)
-
-	_, edbInfoList, err = getAllEdbInfoDataByPublic(keyword, 1, searchEdbPublicList, sourceList, edbClassifyIdList, edbTypeList, edbInfoType, edbAuth, userId, sortMap)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// getAllEdbInfoDataByShared
-// @Description: 获取所有的指标列表（设置公开的时候）
-// @author: Roc
-// @datetime 2024-12-04 15:27:53
-// @param keyword string
-// @param currPage int
-// @param edbShare int
-// @param sourceList []int
-// @param classifyIdList []int
-// @param edbTypeList []int
-// @param edbInfoType int
-// @param edbAuth int
-// @param sysUserId int
-// @param sortMap map[string]string
-// @return total int64
-// @return list []*data_manage.EdbInfoList
-// @return err error
-func getAllEdbInfoDataByPublic(keyword string, currPage int, searchEdbPublicList, sourceList, classifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.EdbInfoList, err error) {
-	// 每页获取数据的数量
-	pageSize := 5000
-	var startSize int
-	if currPage <= 0 {
-		currPage = 1
-	}
-	startSize = paging.StartIndex(currPage, pageSize)
-
-	total, list, err = elastic.SearchEdbInfoDataByPublic(keyword, startSize, pageSize, searchEdbPublicList, sourceList, classifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
-	if err != nil {
-		return
-	}
-
-	page := paging.GetPaging(currPage, pageSize, int(total))
-	if !page.IsEnd {
-		_, nextList, tmpErr := getAllEdbInfoDataByPublic(keyword, page.NextIndex, searchEdbPublicList, sourceList, classifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-
-		list = append(list, nextList...)
-	}
-
-	return
-}

models/data_manage/data_approve/request/approve_flow.go

@@ -1,9 +1,10 @@
 package request
 
 type DataApproveFlowSaveReq struct {
-	DataType int
-	FlowName string
-	Nodes    []Node
+	DataType                int
+	FlowName                string
+	Nodes                   []Node
+	IgnoreApproveUserIdList []int `description:"忽略审批人id"`
 }
 
 type Node struct {

models/data_manage/edb_info.go

@@ -2132,8 +2132,19 @@ func UpdateClassifyIdByEdbInfoId(edbInfoId, edbClassifyId int) (err error) {
 	return
 }
 
-// SetEdbInfoImageReq 设置指标图片
-type EsEdbReq struct {
-	KeyWord  string `description:"关键字" form:"KeyWord"`
-	ImageUrl string `description:"指标图片地址" form:"ImageUrl"`
+// UpdateClassifyIdByEdbInfoIdList
+// @Description: 根据指标id列表更新所属分类id
+// @author: Roc
+// @datetime 2024-12-10 13:18:52
+// @param edbInfoId int
+// @param edbClassifyId int
+// @return err error
+func UpdateClassifyIdByEdbInfoIdList(edbInfoIdList []int, edbClassifyId int) (err error) {
+	if len(edbInfoIdList) <= 0 {
+		return
+	}
+	sql := ` UPDATE edb_info SET classify_id = ? WHERE  edb_info_id in (?) `
+	err = global.DmSQL["data"].Exec(sql, edbClassifyId, edbInfoIdList).Error
+
+	return
 }

models/data_manage/request/edb_public.go

@@ -28,12 +28,13 @@ type SetEdbPublicEdbReq struct {
 // SearchPublicEdbReq
 // @Description: 获取指标列表（设置公开的时候）请求结构体
 type SearchPublicEdbReq struct {
-	EdbPublicList  []int  `description:"指标公开状态：1：未公开，2：已提交；3：已公开。可多选，默认是未公开"`
-	SourceList     []int  `description:"来源id"`
-	Keyword        string `description:"关键字"`
-	ClassifyIdList []int  `description:"分类选择，如果不指定分类，那么就是所有分类"`
-	CurrentIndex   int    `description:"当前页页码，从1开始"`
-	PageSize       int    `description:"每页数据条数"`
+	EdbPublicList        []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:"每页数据条数"`
 }
 
 // AllSearchPublicEdbReq
@@ -45,11 +46,12 @@ type AllSearchPublicEdbReq struct {
 	IsSelectAll bool  `description:"是否选择所有指标"`
 }
 
-// SetPublicEdbPermissionReq
-// @Description: 设置数据权限请求
-type SetPublicEdbPermissionReq struct {
+// MoveEdbClassifyReq
+// @Description: 移动指标分类的请求结构体
+type MoveEdbClassifyReq struct {
 	SearchPublicEdbReq
-	EdbIdList   []int `description:"选中的指标id列表"`
-	NoEdbIdList []int `description:"未选中的指标id列表"`
-	IsSelectAll bool  `description:"是否选择所有指标"`
+	EdbIdList     []int `description:"选中的指标id列表"`
+	NoEdbIdList   []int `description:"未选中的指标id列表"`
+	IsSelectAll   bool  `description:"是否选择所有指标"`
+	NewClassifyId int   `description:"新的分类id"`
 }

routers/commentsRouter.go

@@ -3836,7 +3836,7 @@ func init() {
         beego.ControllerComments{
             Method: "BatchMoveEdb",
             Router: `/edb_info/batch_move`,
-            AllowHTTPMethods: []string{"get"},
+            AllowHTTPMethods: []string{"post"},
             MethodParams: param.Make(),
             Filters: nil,
             Params: nil})

services/data/data_approve/approve_flow.go

@@ -25,9 +25,9 @@ func SaveDataApproveFlow(flow *request.DataApproveFlowSaveReq) (ok bool, msg str
 		// 之前没有过记录，所以走新增
 		var remark string
 		switch flow.DataType {
-		case 1:
+		case DataTypeEdb:
 			remark = `指标审批`
-		case 2:
+		case DataTypeChart:
 			remark = `图表审批`
 		}
 		t := &DataApprove.DataApproveFlow{

services/data/edb_info_share.go

@@ -78,7 +78,7 @@ func GetEdbClassifyItemListByShareEdbInfoQueryList(items []*data_manage.ShareEdb
 			ClassifyIdPath:   "",
 		}
 		edbClassifyItemList, ok := edbClassifyItemListMap[v.ClassifyId]
-		if ok {
+		if !ok {
 			edbClassifyItemListMap[v.ClassifyId] = []*data_manage.EdbClassifyItems{edbClassifyItem}
 			continue
 		}

services/data/edb_public.go

@@ -2,7 +2,12 @@ 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"
 )
 
 // DeleteEdbPublicCheck
@@ -42,3 +47,131 @@ func DeleteEdbPublicCheck(edbInfoId int, sysUser *system.Admin) (deleteStatus in
 
 	return
 }
+
+// GetSearchPar
+// @Description: 获取查询参数
+// @author: Roc
+// @datetime 2024-12-05 14:13:25
+// @param req request.SearchPublicEdbReq
+// @return keyword string
+// @return searchEdbPublicList []int
+// @return sourceList []int
+// @return classifyIdList []int
+// @return publicClassifyIdList []int
+// @return edbTypeList []int
+// @return edbInfoType int
+// @return edbAuth int
+// @return sortMap map[string]string
+func GetSearchPar(req request.SearchPublicEdbReq) (keyword string, searchEdbPublicList, sourceList, classifyIdList, publicClassifyIdList, edbTypeList []int, edbInfoType, edbAuth int, sortMap map[string]string) {
+	keyword = req.Keyword
+	keyword = strings.TrimSpace(keyword) //移除字符串首尾空格
+
+	//指标来源
+	sourceList = req.SourceList
+
+	// 选择的分类
+	classifyIdList = req.ClassifyIdList
+	publicClassifyIdList = req.PublicClassifyIdList
+
+	// 指标公开状态：1：未公开，2：已提交；3：已公开。可多选，默认是未公开
+	edbPublicList := req.EdbPublicList
+	if len(edbPublicList) <= 0 {
+		edbPublicList = []int{1}
+	}
+
+	edbInfoType = 0        // 普通指标
+	edbTypeList = []int{2} // 普通指标中的计算指标
+	edbAuth = 1            // 选择范围是：只有我的指标
+
+	searchEdbPublicList = make([]int, 0) // 0：全部，1：未公开，2：已提交；3：已公开
+	if len(edbPublicList) > 0 && !utils.InArrayByInt(edbPublicList, 0) {
+		// 不含全部
+		for _, v := range edbPublicList {
+			switch v {
+			case 1: // 未公开
+				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicDefault)
+			case 2: // 已提交
+				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicCommit, utils.EdbPublicReject)
+			case 3: // 已公开
+				searchEdbPublicList = append(searchEdbPublicList, utils.EdbPublicSuccess)
+
+			}
+		}
+	} else {
+		searchEdbPublicList = []int{0, 1, 2, 3}
+	}
+
+	sortMap = make(map[string]string)
+	// 如果没有搜索关键词，则默认根据指标编码倒序排序
+	if keyword == `` {
+		sortMap["EdbInfoId"] = `desc`
+	}
+
+	return
+
+}
+
+// GetAllEdbInfoListBySearchPublicEdbReq
+// @Description: 获取所有的指标列表
+// @author: Roc
+// @datetime 2024-12-04 15:43:14
+// @param req request.SearchPublicEdbReq
+// @param userId int
+// @return edbInfoIdList []*data_manage.EdbInfoList
+// @return err error
+func GetAllEdbInfoListBySearchPublicEdbReq(req request.SearchPublicEdbReq, userId int) (edbInfoList []*data_manage.EdbInfoList, err error) {
+	// 获取查询参数
+	keyword, searchEdbPublicList, sourceList, edbClassifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, sortMap := GetSearchPar(req)
+
+	_, edbInfoList, err = getAllEdbInfoDataByPublic(keyword, 1, searchEdbPublicList, sourceList, edbClassifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, userId, sortMap)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// getAllEdbInfoDataByShared
+// @Description: 获取所有的指标列表（设置公开的时候）
+// @author: Roc
+// @datetime 2024-12-04 15:27:53
+// @param keyword string
+// @param currPage int
+// @param edbShare int
+// @param sourceList []int
+// @param classifyIdList []int
+// @param edbTypeList []int
+// @param edbInfoType int
+// @param edbAuth int
+// @param sysUserId int
+// @param sortMap map[string]string
+// @return total int64
+// @return list []*data_manage.EdbInfoList
+// @return err error
+func getAllEdbInfoDataByPublic(keyword string, currPage int, searchEdbPublicList, sourceList, classifyIdList, publicClassifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.EdbInfoList, err error) {
+	// 每页获取数据的数量
+	pageSize := 5000
+	var startSize int
+	if currPage <= 0 {
+		currPage = 1
+	}
+	startSize = paging.StartIndex(currPage, pageSize)
+
+	total, list, err = elastic.SearchEdbInfoDataByPublic(keyword, startSize, pageSize, searchEdbPublicList, sourceList, classifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
+	if err != nil {
+		return
+	}
+
+	page := paging.GetPaging(currPage, pageSize, int(total))
+	if !page.IsEnd {
+		_, nextList, tmpErr := getAllEdbInfoDataByPublic(keyword, page.NextIndex, searchEdbPublicList, sourceList, classifyIdList, publicClassifyIdList, edbTypeList, edbInfoType, edbAuth, sysUserId, sortMap)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		list = append(list, nextList...)
+	}
+
+	return
+}

services/elastic/edb_info.go

@@ -595,6 +595,7 @@ func SearchEdbInfoDataByShared(keywordStr string, from, size, edbShare int, sour
 // @param edbPublicList []int
 // @param sourceList []int
 // @param classifyIdList []int
+// @param publicClassifyIdList []int
 // @param edbTypeList []int
 // @param edbInfoType int
 // @param edbAuth int
@@ -603,7 +604,7 @@ func SearchEdbInfoDataByShared(keywordStr string, from, size, edbShare int, sour
 // @return total int64
 // @return list []*data_manage.EdbInfoList
 // @return err error
-func SearchEdbInfoDataByPublic(keywordStr string, from, size int, edbPublicList, sourceList, classifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.EdbInfoList, err error) {
+func SearchEdbInfoDataByPublic(keywordStr string, from, size int, edbPublicList, sourceList, classifyIdList, publicClassifyIdList, edbTypeList []int, edbInfoType, edbAuth, sysUserId int, sortMap map[string]string) (total int64, list []*data_manage.EdbInfoList, err error) {
 	indexName := utils.DATA_INDEX_NAME
 	list = make([]*data_manage.EdbInfoList, 0)
 	defer func() {
@@ -632,6 +633,15 @@ func SearchEdbInfoDataByPublic(keywordStr string, from, size int, edbPublicList,
 		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("EdbPublicClassifyId", termsList...))
+	}
+
 	// 指标类型：0-基础+计算；1-基础指标；2-计算指标；3-预测指标
 	if len(edbTypeList) > 0 {
 		termsList := make([]interface{}, 0)