Merge branch 'eta/2.3' into debug

# Conflicts:
#	routers/commentsRouter.go

controllers/data_manage/public_chart_classify.go

@@ -473,3 +473,146 @@ func (c *ChartPublicClassifyController) DeleteClassify() {
 	br.IsAddLog = true
 	br.Data = resp
 }
+
+// ChartClassifyMove
+// @Title 分类移动接口
+// @Description 分类移动接口
+// @Success 200 {object} data_manage.MoveChartClassifyReq
+// @router /chart_public/chart_classify/move [post]
+func (c *ChartPublicClassifyController) ChartClassifyMove() {
+	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.MoveChartClassifyReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId <= 0 && req.ChartInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "请选择拖动目标，分类目录或者指标"
+		return
+	}
+
+	//if chartClassifyInfo.Source != utils.CHART_SOURCE_DEFAULT {
+	//	br.Msg = "分类异常"
+	//	br.ErrMsg = "分类异常,不是ETA图库的分类"
+	//	return
+	//}
+
+	err, errMsg := data.MoveChartPublicClassify(req, sysUser)
+	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 = "移动成功"
+}

controllers/data_manage/public_edb_classify.go

@@ -635,3 +635,148 @@ func (c *EdbPublicClassifyController) ListV2() {
 	br.Msg = "获取成功"
 	br.Data = resp
 }
+
+// EdbClassifyMove
+// @Title 分类移动接口
+// @Description 分类移动接口
+// @Success 200 {object} data_manage.MoveEdbClassifyReq
+// @router /edb_public/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.MoveEdbPublicClassify(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 = "移动成功"
+}

models/data_manage/chart_classify.go

@@ -561,6 +561,18 @@ func GetChildChartClassifyListByParentId(classifyIdPath, orderStr string) (items
 	return
 }
 
+// GetChartInfoMaxPublicSortByClassifyId
+// @Description: 获取分类下公共图库的最大的排序数
+// @param classifyId
+// @return sort
+// @return err
+func GetChartInfoMaxPublicSortByClassifyId(classifyId int) (sort int, err error) {
+	sql := `SELECT COALESCE(Max(public_sort), 0) AS sort FROM chart_info WHERE public_status = 3 AND chart_public_classify_id = ? `
+	err = global.DmSQL["data"].Raw(sql, classifyId).Scan(&sort).Error
+
+	return
+}
+
 type ChartClassifyItemList []*ChartClassifyItems
 
 func (m ChartClassifyItemList) Len() int {

models/data_manage/chart_info.go

@@ -64,6 +64,7 @@ type ChartInfo struct {
 	PublicStatus          int       `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
 	ChartPublicClassifyId int       `description:"图表公开分类id"`
 	PublicTime            time.Time `description:"设置公开的时间"`
+	PublicSort            int       `description:"公开分类下的排序字段"`
 }
 
 type ChartInfoMore struct {
@@ -2969,3 +2970,35 @@ func UpdateClassifyIdByChartInfoIdList(chartInfoIdList []int, chartClassifyId in
 
 	return
 }
+
+// UpdateChartInfoPublicSortByClassifyId
+// @Description: 根据公共分类id更新图表公共排序
+// @param classifyId
+// @param nowSort
+// @param prevChartInfoId
+// @param updateSort
+// @param source
+// @return err
+func UpdateChartInfoPublicSortByClassifyId(classifyId, nowSort int, prevChartInfoId int, updateSort string, source int) (err error) {
+	sql := ` update chart_info set sort = ` + updateSort + ` WHERE chart_public_classify_id=? AND public_status = 3 AND source = ? `
+	if prevChartInfoId > 0 {
+		sql += ` AND ( public_sort > ? or ( chart_info_id > ` + fmt.Sprint(prevChartInfoId) + ` and public_sort=` + fmt.Sprint(nowSort) + ` )) `
+	} else {
+		sql += ` AND ( public_sort > ? )`
+	}
+	err = global.DmSQL["data"].Exec(sql, classifyId, nowSort, source).Error
+
+	return
+}
+
+// GetFirstChartInfoByPublicClassifyId
+// @Description: 获取当前公共分类下，且排序数相同 的排序第一条的图表数据
+// @param classifyId
+// @return item
+// @return err
+func GetFirstChartInfoByPublicClassifyId(classifyId int) (item *ChartInfo, err error) {
+	sql := ` SELECT * FROM chart_info WHERE chart_public_classify_id=? AND public_status = 3 order by public_sort asc,chart_info_id asc limit 1`
+	err = global.DmSQL["data"].Raw(sql, classifyId).First(&item).Error
+
+	return
+}

models/data_manage/edb_classify.go

@@ -408,6 +408,14 @@ func GetEdbInfoMaxSortByClassifyId(classifyId int) (sort int, err error) {
 	return
 }
 
+// GetEdbInfoMaxPublicSortByClassifyId 获取分类下公共指标的最大的排序数
+func GetEdbInfoMaxPublicSortByClassifyId(classifyId int) (sort int, err error) {
+	sql := `SELECT COALESCE(Max(public_sort), 0) AS sort FROM edb_info WHERE public_status = 3 AND edb_public_classify_id=? `
+	err = global.DmSQL["data"].Raw(sql, classifyId).Scan(&sort).Error
+
+	return
+}
+
 type ClassifyEdbInfoListResp struct {
 	EdbInfoList []*EdbClassifyItems
 }

models/data_manage/edb_info.go

@@ -70,6 +70,7 @@ type EdbInfo struct {
 	IsJoinPermission    int     `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
 	PublicStatus        int     `description:"公开状态；0：未公开；1：审批中；2：已驳回；3：已公开"`
 	EdbPublicClassifyId int     `description:"指标公开分类id"`
+	PublicSort          int     `description:"公开分类下的排序字段"`
 }
 
 type EdbInfoFullClassify struct {
@@ -847,6 +848,18 @@ func GetFirstEdbInfoByClassifyId(classifyId int) (item *EdbInfo, err error) {
 	return
 }
 
+// GetFirstEdbInfoByPublicClassifyId
+// @Description: 获取当前公共分类下，且排序数相同 的排序第一条的数据
+// @param classifyId
+// @return item
+// @return err
+func GetFirstEdbInfoByPublicClassifyId(classifyId int) (item *EdbInfo, err error) {
+	sql := ` SELECT * FROM edb_info WHERE edb_public_classify_id=? AND public_status = 3 order by public_sort asc,edb_info_id asc limit 1`
+	err = global.DmSQL["data"].Raw(sql, classifyId).First(&item).Error
+
+	return
+}
+
 // UpdateEdbInfoSortByClassifyId 根据分类id更新排序
 func UpdateEdbInfoSortByClassifyId(classifyId, nowSort int, prevEdbInfoId int, updateSort string) (err error) {
 	sql := ` update edb_info set sort = ` + updateSort + ` WHERE classify_id=?`
@@ -860,6 +873,19 @@ func UpdateEdbInfoSortByClassifyId(classifyId, nowSort int, prevEdbInfoId int, u
 	return
 }
 
+// UpdateEdbInfoPublicSortByClassifyId 根据公共分类id更新公共排序
+func UpdateEdbInfoPublicSortByClassifyId(classifyId, nowSort int, prevEdbInfoId int, updateSort string) (err error) {
+	sql := ` update edb_info set sort = ` + updateSort + ` WHERE edb_public_classify_id=? AND public_status = 3 `
+	if prevEdbInfoId > 0 {
+		sql += ` AND ( public_sort > ? or ( edb_info_id > ` + fmt.Sprint(prevEdbInfoId) + ` and public_sort=` + fmt.Sprint(nowSort) + ` )) `
+	} else {
+		sql += ` AND ( public_sort > ? )`
+	}
+	err = global.DmSQL["data"].Exec(sql, classifyId, nowSort).Error
+
+	return
+}
+
 // Update 更新指标基础信息
 func (edbInfo *EdbInfo) Update(cols []string) (err error) {
 	err = global.DmSQL["data"].Select(cols).Updates(edbInfo).Error

models/data_manage/public_chart_classify.go

@@ -321,10 +321,80 @@ func (m *ChartPublicClassify) GetAllChildClassifyByParentId(parentId int) (targe
 }
 
 // GetChartPublicClassifyByParentIdAndName 根据父级ID和名称获取分类
-func GetChartPublicClassifyByParentIdAndName(source, parentId int, classifyName string, classifyId int) (item *ChartClassify, err error) {
+func (m *ChartPublicClassify) GetChartPublicClassifyByParentIdAndName(source, parentId int, classifyName string, classifyId int) (item *ChartPublicClassify, 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
 }
+
+// UpdateChartClassifySortByParentId 根据父类id更新排序
+func (m *ChartPublicClassify) UpdateChartClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string, source int) (err error) {
+	sql := ` update chart_public_classify set sort = ` + updateSort + ` WHERE parent_id=? AND sort > ? AND source = ? `
+	if classifyId > 0 {
+		sql += ` or ( chart_public_classify_id > ` + fmt.Sprint(classifyId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
+	}
+	err = global.DmSQL["data"].Exec(sql, parentId, nowSort, source).Error
+
+	return
+}
+
+// GetFirstChartClassifyByParentId 获取当前父级分类下，且排序数相同 的排序第一条的数据
+func (m *ChartPublicClassify) GetFirstChartClassifyByParentId(parentId int) (item *ChartPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT * FROM chart_public_classify WHERE parent_id=? order by sort asc,chart_public_classify_id asc limit 1`
+	err = o.Raw(sql, parentId).First(&item).Error
+
+	return
+}
+func (m *ChartPublicClassify) GetChartClassifyByRootIdLevel(rootId int, source int, orderStr string) (items []*ChartPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT * FROM chart_public_classify WHERE root_id=? AND source = ? `
+	if orderStr != "" {
+		sql += orderStr
+	} else {
+		sql += ` order by level desc, sort asc, chart_public_classify_id asc`
+	}
+
+	err = o.Raw(sql, rootId, source).Scan(&items).Error
+
+	return
+}
+func (m *ChartPublicClassify) UpdateChartClassifyChildByParentClassifyId(classifyIds []int, rootId int, levelStep int) (err error) {
+	var pars []interface{}
+	pars = append(pars, rootId, levelStep)
+	pars = append(pars, classifyIds)
+	// 更新相关联的二级分类的parentId,和classify_name_second
+	sql := `update chart_public_classify 
+SET root_id = ?, level = level+?
+where chart_public_classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `)`
+	err = global.DmSQL["data"].Exec(sql, pars...).Error
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// UpdateChartClassifyNameAndNamePathByOldClassifyIdPath
+// @Description: 根据源分类id全路径更新分类名称和子分类的全路径
+// @author: Roc
+// @receiver chartClassify
+// @datetime 2024-11-26 14:39:09
+// @param cols []string
+// @param oldClassifyNamePath string
+// @param newClassifyNamePath string
+// @return err error
+func (m *ChartPublicClassify) UpdateChartClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath string) (err error) {
+	// 更改子分类的完整的路径
+	if oldClassifyIdPath != `` && newClassifyNamePath != `` && newClassifyIdPath != `` {
+		sql := `UPDATE chart_public_classify SET chart_public_classify_id_path = REPLACE(chart_public_classify_id_path,?,?) ,chart_public_classify_name_path = REPLACE(chart_public_classify_name_path,?,?)  WHERE chart_public_classify_id_path LIKE ?`
+		err = global.DmSQL["data"].Exec(sql, oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath, fmt.Sprint(oldClassifyIdPath+`,%`)).Error
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}

models/data_manage/public_chart_info.go

@@ -16,9 +16,9 @@ import (
 // @return err error
 func GetChartInfoByPublicClassifyId(classifyId, source int) (items []*ChartClassifyItems, err error) {
 	o := global.DmSQL["data"]
-	sql := ` SELECT chart_info_id,chart_classify_id,chart_public_classify_id,chart_name AS chart_classify_name,chart_name_en AS chart_classify_name_en,unique_code,source,sys_user_id,sys_user_real_name,start_date,chart_type, sort,is_join_permission FROM chart_info WHERE chart_public_classify_id = ? AND source = ?`
+	sql := ` SELECT chart_info_id,chart_classify_id,chart_public_classify_id,chart_name AS chart_classify_name,chart_name_en AS chart_classify_name_en,unique_code,source,sys_user_id,sys_user_real_name,start_date,chart_type, public_sort as sort,is_join_permission FROM chart_info WHERE chart_public_classify_id = ? AND source = ?`
 
-	sql += ` order by sort asc,chart_info_id asc `
+	sql += ` order by public_sort asc,chart_info_id asc `
 	err = o.Raw(sql, classifyId, source).Scan(&items).Error
 
 	return

models/data_manage/public_edb_classify.go

@@ -319,9 +319,79 @@ func (m *EdbPublicClassify) GetAllChildClassifyByParentId(parentId int) (targetL
 }
 
 // GetEdbPublicClassifyByParentIdAndName 根据父级ID和名称获取分类
-func GetEdbPublicClassifyByParentIdAndName(parentId int, classifyName string, classifyId int, classifyType uint8) (item *EdbClassify, err error) {
+func (m *EdbPublicClassify) GetEdbPublicClassifyByParentIdAndName(parentId int, classifyName string, classifyId int, classifyType uint8) (item *EdbPublicClassify, 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
 }
+
+// UpdateEdbClassifySortByParentId 根据父类id更新排序
+func (m *EdbPublicClassify) UpdateEdbClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string, classifyType uint8) (err error) {
+	sql := ` update edb_public_classify set sort = ` + updateSort + ` WHERE parent_id=? AND sort > ? AND classify_type = ? `
+	if classifyId > 0 {
+		sql += ` or ( edb_public_classify_id > ` + fmt.Sprint(classifyId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
+	}
+	err = global.DmSQL["data"].Exec(sql, parentId, nowSort, classifyType).Error
+
+	return
+}
+
+// GetFirstEdbClassifyByParentId 获取当前父级分类下，且排序数相同 的排序第一条的数据
+func (m *EdbPublicClassify) GetFirstEdbClassifyByParentId(parentId int) (item *EdbPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT * FROM edb_public_classify WHERE parent_id=? order by sort asc,edb_public_classify_id asc limit 1`
+	err = o.Raw(sql, parentId).First(&item).Error
+
+	return
+}
+func (m *EdbPublicClassify) GetEdbClassifyByRootIdLevel(rootId int, classifyType uint8, orderStr string) (items []*EdbPublicClassify, err error) {
+	o := global.DmSQL["data"]
+	sql := ` SELECT * FROM edb_public_classify WHERE root_id=? AND classify_type = ? `
+	if orderStr != "" {
+		sql += orderStr
+	} else {
+		sql += ` order by level desc, sort asc, edb_public_classify_id asc`
+	}
+
+	err = o.Raw(sql, rootId, classifyType).Scan(&items).Error
+
+	return
+}
+func (m *EdbPublicClassify) UpdateEdbClassifyChildByParentClassifyId(classifyIds []int, rootId int, levelStep int) (err error) {
+	var pars []interface{}
+	pars = append(pars, rootId, levelStep)
+	pars = append(pars, classifyIds)
+	// 更新相关联的二级分类的parentId,和classify_name_second
+	sql := `update edb_public_classify 
+SET root_id = ?, level = level+?
+where edb_public_classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `)`
+	err = global.DmSQL["data"].Exec(sql, pars...).Error
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath
+// @Description: 根据源分类id全路径更新分类名称和子分类的全路径
+// @author: Roc
+// @receiver edbClassify
+// @datetime 2024-11-26 14:39:09
+// @param cols []string
+// @param oldClassifyNamePath string
+// @param newClassifyNamePath string
+// @return err error
+func (m *EdbPublicClassify) UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath string) (err error) {
+	// 更改子分类的完整的路径
+	if oldClassifyIdPath != `` && newClassifyNamePath != `` && newClassifyIdPath != `` {
+		sql := `UPDATE edb_public_classify SET edb_public_classify_id_path = REPLACE(edb_public_classify_id_path,?,?) ,edb_public_classify_name_path = REPLACE(edb_public_classify_name_path,?,?)  WHERE edb_public_classify_id_path LIKE ?`
+		err = global.DmSQL["data"].Exec(sql, oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath, fmt.Sprint(oldClassifyIdPath+`,%`)).Error
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}

models/data_manage/public_edb_info.go

@@ -16,7 +16,7 @@ import (
 // @return err error
 func GetEdbInfoByPublicClassifyId(classifyId, edbInfoType, edbType int) (items []*EdbClassifyItems, err error) {
 	o := global.DmSQL["data"]
-	sql := ` SELECT edb_info_id,classify_id,edb_public_classify_id,edb_name AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type, sort,is_join_permission FROM edb_info WHERE edb_public_classify_id = ? AND edb_info_type = ?`
+	sql := ` SELECT edb_info_id,classify_id,edb_public_classify_id,edb_name AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type, public_sort sort,is_join_permission FROM edb_info WHERE edb_public_classify_id = ? AND edb_info_type = ?`
 
 	pars := []interface{}{classifyId, edbInfoType}
 
@@ -26,7 +26,7 @@ func GetEdbInfoByPublicClassifyId(classifyId, edbInfoType, edbType int) (items [
 		pars = append(pars, edbType)
 	}
 
-	sql += ` order by sort asc,edb_info_id asc `
+	sql += ` order by public_sort asc,edb_info_id asc `
 	err = o.Raw(sql, pars...).Scan(&items).Error
 
 	return

routers/commentsRouter.go

@@ -5551,24 +5551,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"],
-        beego.ControllerComments{
-            Method: "BiDashboardCacheResourceList",
-            Router: `/resource/bi_dashboard/list`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"],
-        beego.ControllerComments{
-            Method: "BiDashboardResourceSave",
-            Router: `/resource/bi_dashboard/save`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"],
         beego.ControllerComments{
             Method: "Delete",
@@ -5641,15 +5623,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"],
-        beego.ControllerComments{
-            Method: "Search",
-            Router: `/resource/search_by_es`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers/knowledge:ResourceController"],
         beego.ControllerComments{
             Method: "GetSourceFrom",
@@ -7018,15 +6991,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ClassifyController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ClassifyController"],
-        beego.ControllerComments{
-            Method: "AdminList",
-            Router: `/user/list`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers:CompanyPermissionController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:CompanyPermissionController"],
         beego.ControllerComments{
             Method: "List",
@@ -7054,42 +7018,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"],
-        beego.ControllerComments{
-            Method: "AddImageMaterial",
-            Router: `/add/image/material`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"],
-        beego.ControllerComments{
-            Method: "DeleteImageMaterial",
-            Router: `/delete/image/material`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"],
-        beego.ControllerComments{
-            Method: "EditImageMaterial",
-            Router: `/edit/image/material`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ImageConfController"],
-        beego.ControllerComments{
-            Method: "GetImageMaterial",
-            Router: `/get/image/material`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers:MeetingProbabilitiesController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:MeetingProbabilitiesController"],
         beego.ControllerComments{
             Method: "Detail",
@@ -7477,42 +7405,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"],
-        beego.ControllerComments{
-            Method: "Delete",
-            Router: `/del`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"],
-        beego.ControllerComments{
-            Method: "Detail",
-            Router: `/detail`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"],
-        beego.ControllerComments{
-            Method: "List",
-            Router: `/list`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:PptV2HistoryController"],
-        beego.ControllerComments{
-            Method: "Revert",
-            Router: `/revert`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportAuthorController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportAuthorController"],
         beego.ControllerComments{
             Method: "Author",
@@ -8062,42 +7954,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"],
-        beego.ControllerComments{
-            Method: "Delete",
-            Router: `/del`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"],
-        beego.ControllerComments{
-            Method: "Detail",
-            Router: `/detail`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"],
-        beego.ControllerComments{
-            Method: "List",
-            Router: `/list`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportHistoryController"],
-        beego.ControllerComments{
-            Method: "Revert",
-            Router: `/revert`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportUploadCommonController"] = append(beego.GlobalControllerRouter["eta_gn/eta_api/controllers:ReportUploadCommonController"],
         beego.ControllerComments{
             Method: "UploadImg",

services/data/public_chart_classify.go

@@ -10,7 +10,7 @@ import (
 	"time"
 )
 
-// TODO 移动的时候，获取上下级的分裂
+// TODO 分类名称允许在不同人的名下重复
 
 // AddChartPublicClassify
 // @Description: 添加公共指标分类
@@ -306,215 +306,183 @@ func DeleteChartPublicClassify(classifyId int, sysUser *system.Admin, requestBod
 	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
+// MoveChartClassify 移动指标分类
+func MoveChartPublicClassify(req data_manage.MoveChartClassifyReq, sysUser *system.Admin) (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
+
+	obj := data_manage.ChartPublicClassify{}
+	source := utils.CHART_SOURCE_DEFAULT
+
+	//首先确定移动的对象是分类还是指标
+	//判断上一个节点是分类还是指标
+	//判断下一个节点是分类还是指标
+	//同时更新分类目录下的分类sort和指标sort
+	//更新当前移动的分类或者指标sort
+
+	var parentChartClassifyInfo *data_manage.ChartPublicClassify
+	if parentClassifyId > 0 {
+		parentChartClassifyInfo, err = obj.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
+	)
+
+	// 移动对象为分类， 判断权限
+	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.Source != source {
+			errMsg = "分类异常,不是ETA图库的分类"
+			err = errors.New(errMsg)
+			return
+		}
+		if parentClassifyId > 0 && parentChartClassifyInfo.Level == 6 {
+			errMsg = "最高只支持添加6级分类"
+			err = errors.New(errMsg)
+			return
+		}
+		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
+		exists, e := obj.GetChartPublicClassifyByParentIdAndName(source, parentClassifyId, chartClassifyInfo.ChartPublicClassifyName, classifyId)
+		if e != nil && !utils.IsErrNoRow(e) {
+			errMsg = "移动失败"
+			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
+			return
+		}
+		if exists != nil && exists.ChartPublicClassifyId > 0 {
+			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.Source != source {
+			errMsg = "分类异常,不是ETA图库的分类"
+			err = errors.New(errMsg)
+			return
+		}
+
+		if parentClassifyId == 0 {
+			errMsg = "移动失败,指标必须挂在分类下"
+			err = errors.New(errMsg)
+			return
+		}
+
+		// TODO 移动权限校验
+	}
+
+	if prevClassifyId > 0 {
+		prevClassify, err = obj.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.PublicSort
+	}
+
+	if nextClassifyId > 0 {
+		//下一个兄弟节点
+		nextClassify, err = obj.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.PublicSort
+	}
+
+	err, errMsg = movePublicChartOrClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+	return
+}
+
+// movePublicChartOrClassify
+// @Description: 移动公共指标/分类
+// @param parentChartClassifyInfo
+// @param chartClassifyInfo
+// @param prevClassify
+// @param nextClassify
+// @param chartInfo
+// @param prevChartInfo
+// @param nextChartInfo
+// @param parentClassifyId
+// @param prevSort
+// @param nextSort
+// @param source
+// @return err
+// @return errMsg
+func movePublicChartOrClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartPublicClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort, source int) (err error, errMsg string) {
+
+	if chartClassifyInfo != nil {
+		// 移动分类
+		return movePublicChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+	} else {
+		// 移动指标
+		return moveChartPublic(prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+	}
+
+	return
+}
+
+// moveChartPublic
 // @Description: 移动指标
 // @author: Roc
 // @datetime 2024-11-26 16:07:37
@@ -526,135 +494,148 @@ func DeleteChartPublicClassify(classifyId int, sysUser *system.Admin, requestBod
 // @param parentClassifyId int
 // @param prevSort int
 // @param nextSort int
-// @param source int
+// @param source uint8
 // @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
+func moveChartPublic(prevClassify, nextClassify *data_manage.ChartPublicClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort, source int) (err error, errMsg string) {
+	updateCol := make([]string, 0)
+	obj := data_manage.ChartPublicClassify{}
+
+	fmt.Println("prevSort:", prevSort)
+	fmt.Println("prevChartInfo:", prevChartInfo)
+	fmt.Println("parentClassifyId:", parentClassifyId)
+	if chartInfo == nil {
+		errMsg = "当前指标不存在"
+		err = errors.New(errMsg)
+		return
+	}
+	//如果改变了分类，那么移动该指标数据
+	if chartInfo.ChartClassifyId != parentClassifyId {
+		chartInfo.ChartPublicClassifyId = parentClassifyId
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "ChartPublicClassifyId", "ModifyTime")
+	}
+	if prevChartInfo != nil && prevChartInfo.ChartInfoId > 0 {
+		//如果是移动在两个兄弟节点之间
+		if nextSort > 0 {
+			//下一个兄弟节点
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevSort == nextSort || prevSort == chartInfo.PublicSort {
+				//变更兄弟节点的排序
+				updateSortStr := ` sort + 2`
+				updateChartSortStr := ` public_sort + 2`
+
+				//变更分类
+				if prevClassify != nil {
+					_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ChartPublicClassifyId, prevClassify.Sort, updateSortStr, source)
+				} else {
+					_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+				}
+
+				//变更指标
+				if prevChartInfo != nil {
+					//变更兄弟节点的排序
+					_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateChartSortStr, source)
+				} else {
+					_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateChartSortStr, source)
+				}
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextSort-prevSort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := ` sort + 1`
+					updateChartSortStr := ` public_sort + 1`
+					//变更分类
+					if prevClassify != nil {
+						_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ChartPublicClassifyId, prevSort, updateSortStr, source)
+					} else {
+						_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+					}
+
+					//变更指标
+					if prevChartInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr, source)
+					} else {
+						_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateChartSortStr, source)
+					}
+				}
+			}
+		}
+
+		chartInfo.PublicSort = prevChartInfo.PublicSort + 1
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	} else if prevClassify == nil && nextClassify == nil && prevChartInfo == nil && nextChartInfo == nil && parentClassifyId > 0 {
+		//处理只拖动到目录里，默认放到目录底部的情况
+		var maxSort int
+		maxSort, err = GetPublicChartClassifyMaxSort(parentClassifyId, source)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+			return
+		}
+		fmt.Println("maxSort:", maxSort)
+		chartInfo.PublicSort = maxSort + 1 //那就是排在组内最后一位
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	} else {
+		fmt.Println("进来:")
+		// 拖动到父级分类的第一位
+		firstClassify, tmpErr := obj.GetFirstChartClassifyByParentId(parentClassifyId)
+		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.ChartPublicClassifyId > 0 && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ChartPublicClassifyId-1, 0, updateSortStr, source)
+			//该分类下的所有指标也需要+1
+
+			updateChartSortStr := ` public_sort + 1 `
+			_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, 0, 0, updateChartSortStr, source)
+		} else {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstChart, tErr := data_manage.GetFirstChartInfoByPublicClassifyId(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 `
+				_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
+
+				// 指标
+				updateChartSortStr := ` public_sort + 1 `
+				_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateChartSortStr, source)
+			}
+		}
+
+		chartInfo.PublicSort = 0 //那就是排在第一位
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	}
+
+	//更新
+	if len(updateCol) > 0 {
+		err = chartInfo.Update(updateCol)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("修改失败,Err:" + err.Error())
+			return
+		}
+	}
+
+	return
+}
+
+// movePublicChartClassify
 // @Description: 移动指标分类
 // @author: Roc
 // @datetime 2024-11-26 16:07:44
@@ -668,174 +649,263 @@ func DeleteChartPublicClassify(classifyId int, sysUser *system.Admin, requestBod
 // @param parentClassifyId int
 // @param prevSort int
 // @param nextSort int
-// @param source int
+// @param source uint8
 // @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
-//}
+func movePublicChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartPublicClassify, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort, source int) (err error, errMsg string) {
+	updateCol := make([]string, 0)
+	obj := data_manage.ChartPublicClassify{}
+
+	// 移动对象为分类， 判断分类是否存在
+	oldParentId := chartClassifyInfo.ParentId
+	oldLevel := chartClassifyInfo.Level
+	var classifyIds []int
+	if oldParentId != parentClassifyId {
+		//更新子分类对应的level
+		childList, e, m := GetChartChildClassifyByPublicClassifyId(chartClassifyInfo.ChartPublicClassifyId)
+		if e != nil {
+			errMsg = "移动失败"
+			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
+			return
+		}
+
+		if len(childList) > 0 {
+			for _, v := range childList {
+				if v.ChartClassifyId == chartClassifyInfo.ChartPublicClassifyId {
+					continue
+				}
+				classifyIds = append(classifyIds, v.ChartClassifyId)
+			}
+		}
+	}
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+		if chartClassifyInfo.Level != parentChartClassifyInfo.Level+1 { //禁止层级调整
+			errMsg = "移动失败"
+			err = errors.New("不支持目录层级变更")
+			return
+		}
+		chartClassifyInfo.ParentId = parentChartClassifyInfo.ChartPublicClassifyId
+		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`
+				updateChartSortStr := ` public_sort + 2`
+
+				//变更分类
+				if prevClassify != nil {
+					_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ChartPublicClassifyId, prevClassify.Sort, updateSortStr, source)
+				} else {
+					_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+				}
+
+				//变更指标
+				if prevChartInfo != nil {
+					//变更兄弟节点的排序
+					_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateChartSortStr, source)
+				} else {
+					_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateChartSortStr, source)
+				}
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextSort-prevSort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					updateChartSortStr := `public_sort + 1`
+
+					//变更分类
+					if prevClassify != nil {
+						_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ChartPublicClassifyId, prevSort, updateSortStr, source)
+					} else {
+						_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
+					}
+
+					//变更指标
+					if prevChartInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateChartSortStr, source)
+					} else {
+						_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateChartSortStr, source)
+					}
+
+				}
+			}
+		}
+
+		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 = GetChartPublicClassifyMaxSort(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 := obj.GetFirstChartClassifyByParentId(parentClassifyId)
+		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.ChartPublicClassifyId > 0 && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			updateChartSortStr := ` public_sort + 1 `
+			_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ChartPublicClassifyId-1, 0, updateSortStr, source)
+			//该分类下的所有指标也需要+1
+			_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, 0, 0, updateChartSortStr, source)
+		} else {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstChart, tErr := data_manage.GetFirstChartInfoByPublicClassifyId(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 `
+				_ = obj.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
+
+				updateChartSortStr := ` public_sort + 1 `
+				_ = data_manage.UpdateChartInfoPublicSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateChartSortStr, source)
+			}
+		}
+
+		chartClassifyInfo.Sort = 0 //那就是排在第一位
+		chartClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	oldClassifyIdPath := chartClassifyInfo.ChartPublicClassifyIdPath
+	oldClassifyNamePath := chartClassifyInfo.ChartPublicClassifyNamePath
+	newClassifyNamePath := fmt.Sprint(parentChartClassifyInfo.ChartPublicClassifyNamePath, `|`, chartClassifyInfo.ChartPublicClassifyName)
+	newClassifyIdPath := fmt.Sprint(parentChartClassifyInfo.ChartPublicClassifyIdPath, `,`, chartClassifyInfo.ChartPublicClassifyId)
+
+	//更新
+	if len(updateCol) > 0 {
+		chartClassifyInfo.ChartPublicClassifyNamePath = newClassifyNamePath
+		chartClassifyInfo.ChartPublicClassifyIdPath = newClassifyIdPath
+		updateCol = append(updateCol, "ChartPublicClassifyNamePath", "ChartPublicClassifyIdPath")
+
+		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 = obj.UpdateChartClassifyChildByParentClassifyId(classifyIds, chartClassifyInfo.RootId, levelStep)
+				if err != nil {
+					errMsg = "移动失败"
+					err = errors.New("更新子分类失败,Err:" + err.Error())
+					return
+				}
+			}
+
+			// 更改了上级分类，那么需要同步去更改自己的分类全路径
+			tmpErr := obj.UpdateChartClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath)
+			if tmpErr != nil {
+				utils.FileLog.Error(fmt.Sprintf("更新分类全路径失败，分类id：%d；失败原因Err:%s", chartClassifyInfo.ChartPublicClassifyId, tmpErr.Error()))
+			}
+		}
+
+	}
+
+	return
+}
+
+func GetPublicChartClassifyMaxSort(parentId, source int) (maxSort int, err error) {
+	//获取该层级下最大的排序数
+	obj := data_manage.ChartPublicClassify{}
+	classifyMaxSort, err := obj.GetChartClassifyMaxSort(parentId, source)
+	if err != nil {
+		return
+	}
+	maxSort = classifyMaxSort
+	chartMaxSort, err := data_manage.GetChartInfoMaxPublicSortByClassifyId(parentId)
+	if err != nil {
+		return
+	}
+	if maxSort < chartMaxSort {
+		maxSort = chartMaxSort
+	}
+	return
+}
+
+func GetChartChildClassifyByPublicClassifyId(targetClassifyId int) (targetList []*data_manage.ChartClassifyIdItems, err error, errMsg string) {
+	obj := data_manage.ChartPublicClassify{}
+	//判断是否是挂在顶级目录下
+	targetClassify, err := obj.GetChartClassifyById(targetClassifyId)
+	if err != nil {
+		if utils.IsErrNoRow(err) {
+			errMsg = "当前分类不存在"
+			err = errors.New(errMsg)
+			return
+		}
+		errMsg = "获取失败"
+		err = errors.New("获取分类信息失败，Err:" + err.Error())
+		return
+	}
+	orderStr := ` order by level asc, sort asc, chart_public_classify_id asc`
+	tmpList, err := obj.GetChartClassifyByRootIdLevel(targetClassify.RootId, targetClassify.Source, orderStr)
+	if err != nil && !utils.IsErrNoRow(err) {
+		errMsg = "获取失败"
+		err = errors.New("获取数据失败，Err:" + err.Error())
+		return
+	}
+	idMap := make(map[int]struct{})
+	if len(tmpList) > 0 {
+		for _, v := range tmpList {
+			if v.ChartPublicClassifyId == targetClassify.ChartPublicClassifyId {
+				idMap[v.ChartPublicClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.ParentId]; ok {
+				idMap[v.ChartPublicClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.ChartPublicClassifyId]; ok {
+				targetItem := new(data_manage.ChartClassifyIdItems)
+				targetItem.ChartClassifyId = v.ChartPublicClassifyId
+				targetItem.ParentId = v.ParentId
+				targetItem.RootId = v.RootId
+				targetItem.UniqueCode = v.UniqueCode
+				targetItem.Level = v.Level
+				targetItem.ChartClassifyName = v.ChartPublicClassifyName
+				targetList = append(targetList, targetItem)
+			}
+		}
+	}
+
+	return
+}

services/data/public_edb_classify.go

@@ -10,8 +10,6 @@ import (
 	"time"
 )
 
-// TODO 移动的时候，获取上下级的分裂
-
 // AddEdbPublicClassify
 // @Description: 添加公共指标分类
 // @author: Roc
@@ -307,186 +305,172 @@ func DeleteEdbPublicClassify(classifyId int, sysUser *system.Admin, requestBody,
 	return
 }
 
-// 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
+// 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
+
+	obj := data_manage.EdbPublicClassify{}
+
+	//首先确定移动的对象是分类还是指标
+	//判断上一个节点是分类还是指标
+	//判断下一个节点是分类还是指标
+	//同时更新分类目录下的分类sort和指标sort
+	//更新当前移动的分类或者指标sort
+
+	var parentEdbClassifyInfo *data_manage.EdbPublicClassify
+	if parentClassifyId > 0 {
+		parentEdbClassifyInfo, err = obj.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
+	)
+
+	// 移动对象为分类， 判断权限
+	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 parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 {
+			errMsg = "最高只支持添加6级分类"
+			err = errors.New(errMsg)
+			return
+		}
+		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
+		exists, e := obj.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.EdbPublicClassifyId > 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 parentClassifyId == 0 {
+			errMsg = "移动失败,指标必须挂在分类下"
+			err = errors.New(errMsg)
+			return
+		}
+
+		// TODO 移动权限校验
+	}
+
+	if prevClassifyId > 0 {
+		prevClassify, err = obj.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.PublicSort
+	}
+
+	if nextClassifyId > 0 {
+		//下一个兄弟节点
+		nextClassify, err = obj.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.PublicSort
+	}
+
+	err, errMsg = movePublicEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	return
+}
+
+// movePublicEdbOrClassify
+// @Description: 移动公共指标/分类
+// @param parentEdbClassifyInfo
+// @param edbClassifyInfo
+// @param prevClassify
+// @param nextClassify
+// @param edbInfo
+// @param prevEdbInfo
+// @param nextEdbInfo
+// @param parentClassifyId
+// @param prevSort
+// @param nextSort
+// @param classifyType
+// @return err
+// @return errMsg
+func movePublicEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbPublicClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+
+	if edbClassifyInfo != nil {
+		// 移动分类
+		return movePublicEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	} else {
+		// 移动指标
+		return moveEdbPublic(prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	}
+
+	return
+}
+
+// moveEdbPublic
 // @Description: 移动指标
 // @author: Roc
 // @datetime 2024-11-26 16:07:37
@@ -501,132 +485,145 @@ func DeleteEdbPublicClassify(classifyId int, sysUser *system.Admin, requestBody,
 // @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  TODO
+func moveEdbPublic(prevClassify, nextClassify *data_manage.EdbPublicClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+	updateCol := make([]string, 0)
+	obj := data_manage.EdbPublicClassify{}
+
+	fmt.Println("prevSort:", prevSort)
+	fmt.Println("prevEdbInfo:", prevEdbInfo)
+	fmt.Println("parentClassifyId:", parentClassifyId)
+	if edbInfo == nil {
+		errMsg = "当前指标不存在"
+		err = errors.New(errMsg)
+		return
+	}
+	//如果改变了分类，那么移动该指标数据
+	if edbInfo.ClassifyId != parentClassifyId {
+		edbInfo.EdbPublicClassifyId = parentClassifyId
+		edbInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "EdbPublicClassifyId", "ModifyTime")
+	}
+	if prevEdbInfo != nil && prevEdbInfo.EdbInfoId > 0 {
+		//如果是移动在两个兄弟节点之间
+		if nextSort > 0 {
+			//下一个兄弟节点
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevSort == nextSort || prevSort == edbInfo.PublicSort {
+				//变更兄弟节点的排序
+				updateSortStr := ` sort + 2`
+				updateEdbSortStr := ` public_sort + 2`
+
+				//变更分类
+				if prevClassify != nil {
+					_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.EdbPublicClassifyId, prevClassify.Sort, updateSortStr, classifyType)
+				} else {
+					_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+				}
+
+				//变更指标
+				if prevEdbInfo != nil {
+					//变更兄弟节点的排序
+					_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateEdbSortStr)
+				} else {
+					_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateEdbSortStr)
+				}
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextSort-prevSort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := ` sort + 1`
+					updateEdbSortStr := ` public_sort + 1`
+					//变更分类
+					if prevClassify != nil {
+						_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.EdbPublicClassifyId, prevSort, updateSortStr, classifyType)
+					} else {
+						_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+					}
+
+					//变更指标
+					if prevEdbInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
+					} else {
+						_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateEdbSortStr)
+					}
+				}
+			}
+		}
+
+		edbInfo.PublicSort = prevEdbInfo.PublicSort + 1
+		edbInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
+		//处理只拖动到目录里，默认放到目录底部的情况
+		var maxSort int
+		maxSort, err = GetPublicEdbClassifyMaxSort(parentClassifyId, classifyType)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+			return
+		}
+		fmt.Println("maxSort:", maxSort)
+		edbInfo.PublicSort = maxSort + 1 //那就是排在组内最后一位
+		edbInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	} else {
+		fmt.Println("进来:")
+		// 拖动到父级分类的第一位
+		firstClassify, tmpErr := obj.GetFirstEdbClassifyByParentId(parentClassifyId)
+		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.EdbPublicClassifyId > 0 && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.EdbPublicClassifyId-1, 0, updateSortStr, classifyType)
+			//该分类下的所有指标也需要+1
+
+			updateEdbSortStr := ` public_sort + 1 `
+			_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, 0, 0, updateEdbSortStr)
+		} else {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstEdb, tErr := data_manage.GetFirstEdbInfoByPublicClassifyId(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 `
+				_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
+
+				// 指标
+				updateEdbSortStr := ` public_sort + 1 `
+				_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateEdbSortStr)
+			}
+		}
+
+		edbInfo.PublicSort = 0 //那就是排在第一位
+		edbInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "PublicSort", "ModifyTime")
+	}
+
+	//更新
+	if len(updateCol) > 0 {
+		err = edbInfo.Update(updateCol)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("修改失败,Err:" + err.Error())
+			return
+		}
+	}
+
+	return
+}
+
+// movePublicEdbClassify
 // @Description: 移动指标分类
 // @author: Roc
 // @datetime 2024-11-26 16:07:44
@@ -643,171 +640,260 @@ func DeleteEdbPublicClassify(classifyId int, sysUser *system.Admin, requestBody,
 // @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 movePublicEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbPublicClassify, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) {
+	updateCol := make([]string, 0)
+	obj := data_manage.EdbPublicClassify{}
+
+	// 移动对象为分类， 判断分类是否存在
+	oldParentId := edbClassifyInfo.ParentId
+	oldLevel := edbClassifyInfo.Level
+	var classifyIds []int
+	if oldParentId != parentClassifyId {
+		//更新子分类对应的level
+		childList, e, m := GetChildClassifyByPublicClassifyId(edbClassifyInfo.EdbPublicClassifyId)
+		if e != nil {
+			errMsg = "移动失败"
+			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
+			return
+		}
+
+		if len(childList) > 0 {
+			for _, v := range childList {
+				if v.ClassifyId == edbClassifyInfo.EdbPublicClassifyId {
+					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.EdbPublicClassifyId
+		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`
+				updateEdbSortStr := ` public_sort + 2`
+
+				//变更分类
+				if prevClassify != nil {
+					_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.EdbPublicClassifyId, prevClassify.Sort, updateSortStr, classifyType)
+				} else {
+					_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+				}
+
+				//变更指标
+				if prevEdbInfo != nil {
+					//变更兄弟节点的排序
+					_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateEdbSortStr)
+				} else {
+					_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateEdbSortStr)
+				}
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextSort-prevSort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					updateEdbSortStr := `public_sort + 1`
+
+					//变更分类
+					if prevClassify != nil {
+						_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.EdbPublicClassifyId, prevSort, updateSortStr, classifyType)
+					} else {
+						_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
+					}
+
+					//变更指标
+					if prevEdbInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateEdbSortStr)
+					} else {
+						_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, prevSort, 0, updateEdbSortStr)
+					}
+
+				}
+			}
+		}
+
+		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 = GetEdbPublicClassifyMaxSort(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 := obj.GetFirstEdbClassifyByParentId(parentClassifyId)
+		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.EdbPublicClassifyId > 0 && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			updateEdbSortStr := ` public_sort + 1 `
+			_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.EdbPublicClassifyId-1, 0, updateSortStr, classifyType)
+			//该分类下的所有指标也需要+1
+			_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, 0, 0, updateEdbSortStr)
+		} else {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstEdb, tErr := data_manage.GetFirstEdbInfoByPublicClassifyId(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 `
+				_ = obj.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
+
+				updateEdbSortStr := ` public_sort + 1 `
+				_ = data_manage.UpdateEdbInfoPublicSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateEdbSortStr)
+			}
+		}
+
+		edbClassifyInfo.Sort = 0 //那就是排在第一位
+		edbClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	oldClassifyIdPath := edbClassifyInfo.EdbPublicClassifyIdPath
+	oldClassifyNamePath := edbClassifyInfo.EdbPublicClassifyNamePath
+	newClassifyNamePath := fmt.Sprint(parentEdbClassifyInfo.EdbPublicClassifyNamePath, `|`, edbClassifyInfo.EdbPublicClassifyName)
+	newClassifyIdPath := fmt.Sprint(parentEdbClassifyInfo.EdbPublicClassifyIdPath, `,`, edbClassifyInfo.EdbPublicClassifyId)
+
+	//更新
+	if len(updateCol) > 0 {
+		edbClassifyInfo.EdbPublicClassifyNamePath = newClassifyNamePath
+		edbClassifyInfo.EdbPublicClassifyIdPath = newClassifyIdPath
+		updateCol = append(updateCol, "EdbPublicClassifyNamePath", "EdbPublicClassifyIdPath")
+
+		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 = obj.UpdateEdbClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep)
+				if err != nil {
+					errMsg = "移动失败"
+					err = errors.New("更新子分类失败,Err:" + err.Error())
+					return
+				}
+			}
+
+			// 更改了上级分类，那么需要同步去更改自己的分类全路径
+			tmpErr := obj.UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath)
+			if tmpErr != nil {
+				utils.FileLog.Error(fmt.Sprintf("更新分类全路径失败，分类id：%d；失败原因Err:%s", edbClassifyInfo.EdbPublicClassifyId, tmpErr.Error()))
+			}
+		}
+
+	}
+
+	return
+}
+
+func GetPublicEdbClassifyMaxSort(parentId int, classifyType uint8) (maxSort int, err error) {
+	//获取该层级下最大的排序数
+	obj := data_manage.EdbPublicClassify{}
+	classifyMaxSort, err := obj.GetEdbClassifyMaxSort(parentId, classifyType)
+	if err != nil {
+		return
+	}
+	maxSort = classifyMaxSort
+	edbMaxSort, err := data_manage.GetEdbInfoMaxPublicSortByClassifyId(parentId)
+	if err != nil {
+		return
+	}
+	if maxSort < edbMaxSort {
+		maxSort = edbMaxSort
+	}
+	return
+}
+
+func GetChildClassifyByPublicClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) {
+	obj := data_manage.EdbPublicClassify{}
+	//判断是否是挂在顶级目录下
+	targetClassify, err := obj.GetEdbClassifyById(targetClassifyId)
+	if err != nil {
+		if utils.IsErrNoRow(err) {
+			errMsg = "当前分类不存在"
+			err = errors.New(errMsg)
+			return
+		}
+		errMsg = "获取失败"
+		err = errors.New("获取分类信息失败，Err:" + err.Error())
+		return
+	}
+	orderStr := ` order by level asc, sort asc, edb_public_classify_id asc`
+	tmpList, err := obj.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, orderStr)
+	if err != nil && !utils.IsErrNoRow(err) {
+		errMsg = "获取失败"
+		err = errors.New("获取数据失败，Err:" + err.Error())
+		return
+	}
+	idMap := make(map[int]struct{})
+	if len(tmpList) > 0 {
+		for _, v := range tmpList {
+			if v.EdbPublicClassifyId == targetClassify.EdbPublicClassifyId {
+				idMap[v.EdbPublicClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.ParentId]; ok {
+				idMap[v.EdbPublicClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.EdbPublicClassifyId]; ok {
+				targetItem := new(data_manage.EdbClassifyIdItems)
+				targetItem.ClassifyId = v.EdbPublicClassifyId
+				targetItem.ParentId = v.ParentId
+				targetItem.RootId = v.RootId
+				targetItem.UniqueCode = v.UniqueCode
+				targetItem.Level = v.Level
+				targetItem.ClassifyName = v.EdbPublicClassifyName
+				targetList = append(targetList, targetItem)
+			}
+		}
+	}
+
+	return
+}