fix:分类移动时，也要变更完整路径

models/data_manage/edb_classify.go

@@ -590,6 +590,28 @@ func (edbClassify *EdbClassify) UpdateEdbClassifyNameAndNamePath(cols []string,
 	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 UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyNamePath, newClassifyIdPath string) (err error) {
+	// 更改子分类的完整的路径
+	if oldClassifyIdPath != `` && newClassifyNamePath != `` && newClassifyIdPath != `` {
+		sql := `UPDATE edb_classify SET classify_name_path = ?,classify_id_path = ?  WHERE classify_id_path LIKE ?`
+		err = global.DmSQL["data"].Exec(sql, newClassifyNamePath, newClassifyIdPath, fmt.Sprint(oldClassifyIdPath+`,%`)).Error
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
 // UpdateEdbClassify 更新分类基础信息
 func UpdateEdbClassify(classifyId int, classifyNamePath, classifyIdPath string) (err error) {
 	sql := `UPDATE edb_classify SET classify_name_path = ?,classify_id_path = ? WHERE classify_id = ?`

services/data/edb_classify.go

@@ -1146,67 +1146,84 @@ func MoveEdbClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin,
 		nextSort = nextEdbInfo.Sort
 	}
 
-	err, errMsg = moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	err, errMsg = moveEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
 	return
 }
 
-// moveEdbClassify 移动指标分类
-func moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, 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)
+// moveEdbOrClassify 移动指标分类
+func moveEdbOrClassify(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 {
-		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
-			}
+		// 移动分类
+		return moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	} else {
+		// 移动指标
+		return moveEdb(prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
+	}
 
-			if len(childList) > 0 {
-				for _, v := range childList {
-					if v.ClassifyId == edbClassifyInfo.ClassifyId {
-						continue
-					}
-					classifyIds = append(classifyIds, v.ClassifyId)
+	return
+}
+
+// moveEdb
+// @Description: 移动指标
+// @author: Roc
+// @datetime 2024-11-26 16:07:37
+// @param prevClassify *data_manage.EdbClassify
+// @param nextClassify *data_manage.EdbClassify
+// @param edbInfo *data_manage.EdbInfo
+// @param prevEdbInfo *data_manage.EdbInfo
+// @param nextEdbInfo *data_manage.EdbInfo
+// @param parentClassifyId int
+// @param prevSort int
+// @param nextSort int
+// @param classifyType uint8
+// @return err error
+// @return errMsg string
+func moveEdb(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)
 				}
-			}
-		}
-		//判断上级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 {
+				//变更指标
+				if prevEdbInfo != nil {
 					//变更兄弟节点的排序
-					updateSortStr := `sort + 2`
-
+					_ = 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, prevClassify.Sort, updateSortStr, classifyType)
+						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
 					} else {
 						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
 					}
@@ -1218,128 +1235,167 @@ func moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextC
 					} 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")
+		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 {
-			// 拖动到父级分类的第一位
-			firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
-			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
+			if tErr != nil && !utils.IsErrNoRow(tErr) {
 				errMsg = "移动失败"
-				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
 				return
 			}
 
 			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-			if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.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)
-				}
+				_ = 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")
+	}
 
-			edbClassifyInfo.Sort = 0 //那就是排在第一位
-			edbClassifyInfo.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
 		}
+	}
 
-		//更新
-		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
+}
+
+// moveEdbClassify
+// @Description: 移动指标分类
+// @author: Roc
+// @datetime 2024-11-26 16:07:44
+// @param parentEdbClassifyInfo *data_manage.EdbClassify
+// @param edbClassifyInfo *data_manage.EdbClassify
+// @param prevClassify *data_manage.EdbClassify
+// @param nextClassify *data_manage.EdbClassify
+// @param edbInfo *data_manage.EdbInfo
+// @param prevEdbInfo *data_manage.EdbInfo
+// @param nextEdbInfo *data_manage.EdbInfo
+// @param parentClassifyId int
+// @param prevSort int
+// @param nextSort int
+// @param classifyType uint8
+// @return err error
+// @return errMsg string
+func moveEdbClassify(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)
 			}
 		}
-	} else {
-		if edbInfo == nil {
-			errMsg = "当前指标不存在"
-			err = errors.New(errMsg)
+	}
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+		if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整
+			errMsg = "移动失败"
+			err = errors.New("不支持目录层级变更")
 			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 {
+		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 + 2`
+					updateSortStr := `sort + 1`
 
 					//变更分类
 					if prevClassify != nil {
-						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
+						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
 					} else {
 						_ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
 					}
@@ -1351,91 +1407,100 @@ func moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextC
 					} 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")
+		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 {
-			// 拖动到父级分类的第一位
-			firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
-			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
+			firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
+			if tErr != nil && !utils.IsErrNoRow(tErr) {
 				errMsg = "移动失败"
-				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
 				return
 			}
 
 			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-			if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
+			if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.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) {
+				_ = 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")
+	}
+
+	oldClassifyIdPath := edbClassifyInfo.ClassifyIdPath
+	newClassifyNamePath := fmt.Sprint(parentEdbClassifyInfo.ClassifyNamePath, `|`, edbClassifyInfo.ClassifyName)
+	newClassifyIdPath := fmt.Sprint(parentEdbClassifyInfo.ClassifyIdPath, `,`, edbClassifyInfo.ClassifyId)
+
+	//更新
+	if len(updateCol) > 0 {
+		edbClassifyInfo.ClassifyNamePath = newClassifyNamePath
+		edbClassifyInfo.ClassifyIdPath = newClassifyIdPath
+		updateCol = append(updateCol, "ClassifyNamePath", "ClassifyIdPath")
+
+		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:" + tErr.Error())
+					err = errors.New("更新子分类失败,Err:" + err.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
+			// 更改了上级分类，那么需要同步去更改自己的分类全路径
+			tmpErr := data_manage.UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyNamePath, newClassifyIdPath)
+			if tmpErr != nil {
+				utils.FileLog.Error(fmt.Sprintf("更新分类全路径失败，分类id：%d；失败原因Err:%s", edbClassifyInfo.ClassifyId, tmpErr.Error()))
 			}
 		}
+
 	}
+
 	return
 }