move 修改

controllers/sandbox/sandbox.go

@@ -1225,92 +1225,403 @@ func (this *SandboxController) ChartClassifyMove() {
 
 	updateCol := make([]string, 0)
 
-	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
-	if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
-		parentChartClassifyInfo, err := sandbox.GetSandboxClassifyById(req.ParentClassifyId)
-		if err != nil {
-			br.Msg = "移动失败"
-			br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
+	// 判断移动的是分类还是沙盘
+	if req.SandboxId > 0 {
+		//判断分类是否存在
+		count, _ := sandbox.GetSandboxClassifyCountById(req.ClassifyId)
+		if count <= 0 {
+			br.Msg = "分类已被删除，不可移动，请刷新页面"
 			return
 		}
-		sandboxClassifyInfo.ParentId = parentChartClassifyInfo.SandboxClassifyId
-		sandboxClassifyInfo.Level = parentChartClassifyInfo.Level + 1
-		sandboxClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
-	} else if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId == 0 {
-		//改为一级分类
-		sandboxClassifyInfo.ParentId = req.ParentClassifyId
-		sandboxClassifyInfo.Level = 1
-		sandboxClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
-	}
-
-	//如果有传入 上一个兄弟节点分类id
-	if req.PrevClassifyId > 0 {
-		//上一个兄弟节点
-		prevClassify, err := sandbox.GetSandboxClassifyById(req.PrevClassifyId)
+
+		sandboxInfo, err := sandbox.GetSandboxById(req.SandboxId)
 		if err != nil {
 			br.Msg = "移动失败"
-			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+			br.ErrMsg = "获取沙盘信息失败,Err:" + err.Error()
 			return
 		}
 
-		//如果是移动在两个兄弟节点之间
-		if req.NextClassifyId > 0 {
-			//下一个兄弟节点
-			nextClassify, err := sandbox.GetSandboxClassifyById(req.NextClassifyId)
+		//如果改变了分类，那么移动该图表数据
+		if sandboxInfo.SandboxClassifyId != req.ParentClassifyId {
+			//查询需要修改的分类下是否存在同一个图表名称
+			tmpSandboxInfo, tmpErr := sandbox.GetSandboxByClassifyIdAndName(req.ParentClassifyId, sandboxInfo.Name)
+			if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+				br.Msg = "移动失败"
+				br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+				return
+			}
+			if tmpSandboxInfo != nil {
+				br.Msg = "移动失败，同一个分类下沙盘名称不允许重复"
+				br.ErrMsg = "移动失败，同一个分类下沙盘名称不允许重复"
+				return
+			}
+			err = sandbox.MoveSandbox(req.SandboxId, req.ParentClassifyId)
 			if err != nil {
 				br.Msg = "移动失败"
-				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+				br.ErrMsg = "移动失败,Err:" + err.Error()
 				return
 			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == sandboxClassifyInfo.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+		}
+
+		//移动排序
+		updateCol := make([]string, 0)
+		//如果有传入 上一个兄弟节点分类id
+		if req.PrevId > 0 {
+			if req.PrevType == 1 {
+				//上一个兄弟节点
+				prevClassify, err := sandbox.GetSandboxClassifyById(req.PrevId)
+				if err != nil {
+					br.Msg = "移动失败"
+					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+					return
+				}
+
+				//如果是移动在两个兄弟节点之间
+				if req.NextId > 0 {
+					if req.NextType == 1 {
+						//上一个节点是分类 下一个节点是分类的情况
+						//下一个兄弟节点
+						nextClassify, err := sandbox.GetSandboxClassifyById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+						if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+						} else {
+							//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+							if nextClassify.Sort-prevClassify.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+							}
+						}
+					} else {
+						//上一个节点是分类 下一个节点是沙盘的情况
+						//下一个兄弟节点
+						nextChartInfo, err := sandbox.GetSandboxById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(分类)与下一个兄弟(沙盘)的排序权重是一致的，那么需要将下一个兄弟(沙盘)（以及下个兄弟(沙盘)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
+						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == sandboxInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+						} else {
+							//如果下一个兄弟(沙盘)的排序权重正好是上个兄弟节点(分类)的下一层，那么需要再加一层了
+							if nextChartInfo.Sort-prevClassify.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.SandboxClassifyId, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+							}
+						}
+					}
+
+				}
+
+				sandboxInfo.Sort = prevClassify.Sort + 1
+				sandboxInfo.ModifyTime = time.Now()
+				updateCol = append(updateCol, "Sort", "ModifyTime")
+
 			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextClassify.Sort-prevClassify.Sort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+				prevSandbox, err := sandbox.GetSandboxById(req.PrevId)
+				if err != nil {
+					br.Msg = "移动失败"
+					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+					return
 				}
+
+				//如果是移动在两个兄弟节点之间
+				if req.NextId > 0 {
+					if req.NextType == 1 {
+						//上一个节点是沙盘 下一个节点是分类的情况
+						//下一个兄弟节点
+						nextClassify, err := sandbox.GetSandboxClassifyById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
+						if prevSandbox.Sort == nextClassify.Sort || prevSandbox.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+						} else {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
+							if nextClassify.Sort-prevSandbox.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+							}
+						}
+					} else {
+						//上一个节点是沙盘 下一个节点是沙盘的情况
+						//下一个兄弟节点
+						nextChartInfo, err := sandbox.GetSandboxById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
+						if prevSandbox.Sort == nextChartInfo.Sort || prevSandbox.Sort == sandboxInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+						} else {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
+							if nextChartInfo.Sort-prevSandbox.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+							}
+						}
+					}
+
+				}
+
+				sandboxInfo.Sort = prevSandbox.Sort + 1
+				sandboxInfo.ModifyTime = time.Now()
+				updateCol = append(updateCol, "Sort", "ModifyTime")
 			}
-		}
 
-		sandboxClassifyInfo.Sort = prevClassify.Sort + 1
-		sandboxClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
 
-	} else {
-		firstClassify, err := sandbox.GetFirstSandboxClassifyByParentId(sandboxClassifyInfo.ParentId)
-		if err != nil && err.Error() != utils.ErrNoRow() {
-			br.Msg = "移动失败"
-			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
-			return
+		} else {
+			// prevId为0，也就是沙盘移到最前端
+			firstClassify, err := sandbox.GetFirstSandboxByClassifyId(req.ClassifyId)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+				return
+			}
+
+			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+			if firstClassify != nil && firstClassify.Sort == 0 {
+				updateSortStr := ` sort + 1 `
+				_ = sandbox.UpdateSandboxSortByClassifyId(firstClassify.SandboxClassifyId, 0, firstClassify.SandboxId-1, updateSortStr)
+			}
+
+			sandboxInfo.Sort = 0 //那就是排在第一位
+			sandboxInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "Sort", "ModifyTime")
+
 		}
 
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = sandbox.UpdateSandboxClassifySortByParentId(firstClassify.ParentId, firstClassify.SandboxClassifyId-1, 0, updateSortStr)
+		//更新
+		if len(updateCol) > 0 {
+			err = sandboxInfo.Update(updateCol)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "修改失败,Err:" + err.Error()
+				return
+			}
+		}
+	} else {
+		//移动的是分类
+		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+		if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
+			parentChartClassifyInfo, err := sandbox.GetSandboxClassifyById(req.ParentClassifyId)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
+				return
+			}
+			sandboxClassifyInfo.ParentId = parentChartClassifyInfo.SandboxClassifyId
+			sandboxClassifyInfo.Level = parentChartClassifyInfo.Level + 1
+			sandboxClassifyInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+		} else if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId == 0 {
+			//改为一级分类
+			sandboxClassifyInfo.ParentId = req.ParentClassifyId
+			sandboxClassifyInfo.Level = 1
+			sandboxClassifyInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
 		}
 
-		sandboxClassifyInfo.Sort = 0 //那就是排在第一位
-		sandboxClassifyInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
+		//如果有传入 上一个兄弟节点分类id
+		if req.PrevId > 0 {
+			if req.PrevType == 1 {
+				//上一个节点是分类
+				//上一个兄弟节点
+				prevClassify, err := sandbox.GetSandboxClassifyById(req.PrevId)
+				if err != nil {
+					br.Msg = "移动失败"
+					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+					return
+				}
 
-	//更新
-	if len(updateCol) > 0 {
-		err = sandboxClassifyInfo.Update(updateCol)
-		if err != nil {
-			br.Msg = "移动失败"
-			br.ErrMsg = "修改失败,Err:" + err.Error()
-			return
+				//如果是移动在两个兄弟节点之间
+				if req.NextId > 0 {
+					if req.NextType == 1 {
+						//上一个节点是分类 下一个节点是分类的情况
+						//下一个兄弟节点
+						nextClassify, err := sandbox.GetSandboxClassifyById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+						if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+						} else {
+							//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+							if nextClassify.Sort-prevClassify.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+							}
+						}
+					} else {
+						//上一个节点是分类 下一个节点是沙盘的情况
+						//下一个兄弟节点
+						nextChartInfo, err := sandbox.GetSandboxById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(分类)与下一个兄弟(沙盘)的排序权重是一致的，那么需要将下一个兄弟(沙盘)（以及下个兄弟(沙盘)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
+						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+						} else {
+							//如果下一个兄弟(沙盘)的排序权重正好是上个兄弟节点(分类)的下一层，那么需要再加一层了
+							if nextChartInfo.Sort-prevClassify.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.SandboxClassifyId, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevClassify.SandboxClassifyId, prevClassify.Sort, 0, updateSortStr)
+							}
+						}
+					}
+
+				}
+
+				sandboxClassifyInfo.Sort = prevClassify.Sort + 1
+				sandboxClassifyInfo.ModifyTime = time.Now()
+				updateCol = append(updateCol, "Sort", "ModifyTime")
+
+			} else {
+				//上一个节点是沙盘
+				prevSandbox, err := sandbox.GetSandboxById(req.PrevId)
+				if err != nil {
+					br.Msg = "移动失败"
+					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+					return
+				}
+
+				//如果是移动在两个兄弟节点之间
+				if req.NextId > 0 {
+					if req.NextType == 1 {
+						//上一个节点是沙盘 下一个节点是分类的情况
+						//下一个兄弟节点
+						nextClassify, err := sandbox.GetSandboxClassifyById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
+						if prevSandbox.Sort == nextClassify.Sort || prevSandbox.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+						} else {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
+							if nextClassify.Sort-prevSandbox.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+							}
+						}
+					} else {
+						//上一个节点是沙盘 下一个节点是沙盘的情况
+						//下一个兄弟节点
+						nextChartInfo, err := sandbox.GetSandboxById(req.NextId)
+						if err != nil {
+							br.Msg = "移动失败"
+							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+							return
+						}
+						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
+						if prevSandbox.Sort == nextChartInfo.Sort || prevSandbox.Sort == sandboxClassifyInfo.Sort {
+							//变更兄弟节点的排序
+							updateSortStr := `sort + 2`
+							_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+							_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+						} else {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
+							if nextChartInfo.Sort-prevSandbox.Sort == 1 {
+								//变更兄弟节点的排序
+								updateSortStr := `sort + 1`
+								_ = sandbox.UpdateSandboxClassifySortByParentId(prevSandbox.SandboxClassifyId, 0, prevSandbox.Sort, updateSortStr)
+								_ = sandbox.UpdateSandboxSortByClassifyId(prevSandbox.SandboxClassifyId, prevSandbox.Sort, prevSandbox.SandboxId, updateSortStr)
+							}
+						}
+					}
+
+				}
+				sandboxClassifyInfo.Sort = prevSandbox.Sort + 1
+				sandboxClassifyInfo.ModifyTime = time.Now()
+				updateCol = append(updateCol, "Sort", "ModifyTime")
+
+			}
+
+		} else {
+			firstClassify, err := sandbox.GetFirstSandboxClassifyByParentId(sandboxClassifyInfo.ParentId)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+				return
+			}
+
+			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+			if firstClassify != nil && firstClassify.Sort == 0 {
+				updateSortStr := ` sort + 1 `
+				_ = sandbox.UpdateSandboxClassifySortByParentId(firstClassify.ParentId, firstClassify.SandboxClassifyId-1, 0, updateSortStr)
+			}
+
+			sandboxClassifyInfo.Sort = 0 //那就是排在第一位
+			sandboxClassifyInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "Sort", "ModifyTime")
+		}
+
+		//更新
+		if len(updateCol) > 0 {
+			err = sandboxClassifyInfo.Update(updateCol)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "修改失败,Err:" + err.Error()
+				return
+			}
 		}
 	}
+
 	br.Ret = 200
 	br.Success = true
 	br.Msg = "移动成功"
@@ -1581,159 +1892,6 @@ func (this *SandboxController) GetSandboxDetail() {
 	br.Data = sandboxVersionInfo
 }
 
-// SandboxMove
-// @Title 移动沙盘接口
-// @Description 移动图表接口
-// @Success 200 {object} data_manage.MoveChartInfoReq
-// @router /move [post]
-func (this *SandboxController) SandboxMove() {
-	br := new(models.BaseResponse).Init()
-	defer func() {
-		this.Data["json"] = br
-		this.ServeJSON()
-	}()
-
-	sysUser := this.SysUser
-	if sysUser == nil {
-		br.Msg = "请登录"
-		br.ErrMsg = "请登录，SysUser Is Empty"
-		br.Ret = 408
-		return
-	}
-
-	var req sandbox.MoveSandboxReq
-	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
-	if err != nil {
-		br.Msg = "参数解析异常！"
-		br.ErrMsg = "参数解析失败，Err:" + err.Error()
-		return
-	}
-
-	if req.SandboxId <= 0 {
-		br.Msg = "参数错误"
-		br.ErrMsg = "沙盘id小于等于0"
-		return
-	}
-
-	if req.SandboxClassifyId <= 0 {
-		br.Msg = "请选择分类"
-		return
-	}
-	//判断分类是否存在
-	count, _ := sandbox.GetSandboxClassifyCountById(req.SandboxClassifyId)
-	if count <= 0 {
-		br.Msg = "分类已被删除，不可移动，请刷新页面"
-		return
-	}
-
-	sandboxInfo, err := sandbox.GetSandboxById(req.SandboxId)
-	if err != nil {
-		br.Msg = "移动失败"
-		br.ErrMsg = "获取沙盘信息失败,Err:" + err.Error()
-		return
-	}
-
-	//如果改变了分类，那么移动该图表数据
-	if sandboxInfo.SandboxClassifyId != req.SandboxClassifyId {
-		//查询需要修改的分类下是否存在同一个图表名称
-		tmpSandboxInfo, tmpErr := sandbox.GetSandboxByClassifyIdAndName(req.SandboxClassifyId, sandboxInfo.Name)
-		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
-			br.Msg = "移动失败"
-			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
-			return
-		}
-		if tmpSandboxInfo != nil {
-			br.Msg = "移动失败，同一个分类下沙盘名称不允许重复"
-			br.ErrMsg = "移动失败，同一个分类下沙盘名称不允许重复"
-			return
-		}
-		err = sandbox.MoveSandbox(req.SandboxId, req.SandboxClassifyId)
-		if err != nil {
-			br.Msg = "移动失败"
-			br.ErrMsg = "移动失败,Err:" + err.Error()
-			return
-		}
-	}
-
-	//移动排序
-	updateCol := make([]string, 0)
-	//如果有传入 上一个兄弟节点分类id
-	if req.PrevSandboxId > 0 {
-		prevChartInfo, err := sandbox.GetSandboxById(req.PrevSandboxId)
-		if err != nil {
-			br.Msg = "移动失败"
-			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
-			return
-		}
-
-		//如果是移动在两个兄弟节点之间
-		if req.NextSandboxId > 0 {
-			//下一个兄弟节点
-			nextChartInfo, err := sandbox.GetSandboxById(req.NextSandboxId)
-			if err != nil {
-				br.Msg = "移动失败"
-				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-				return
-			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevChartInfo.Sort == nextChartInfo.Sort || prevChartInfo.Sort == sandboxInfo.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				_ = sandbox.UpdateSandboxSortByClassifyId(prevChartInfo.SandboxClassifyId, prevChartInfo.Sort, prevChartInfo.SandboxId, updateSortStr)
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					_ = sandbox.UpdateSandboxSortByClassifyId(prevChartInfo.SandboxClassifyId, prevChartInfo.Sort, prevChartInfo.SandboxId, updateSortStr)
-				}
-			}
-		}
-
-		sandboxInfo.Sort = prevChartInfo.Sort + 1
-		sandboxInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-
-	} else {
-		firstClassify, err := sandbox.GetFirstSandboxByClassifyId(req.SandboxClassifyId)
-		if err != nil && err.Error() != utils.ErrNoRow() {
-			br.Msg = "移动失败"
-			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = sandbox.UpdateSandboxSortByClassifyId(firstClassify.SandboxClassifyId, 0, firstClassify.SandboxId-1, updateSortStr)
-		}
-
-		sandboxInfo.Sort = 0 //那就是排在第一位
-		sandboxInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = sandboxInfo.Update(updateCol)
-		if err != nil {
-			br.Msg = "移动失败"
-			br.ErrMsg = "修改失败,Err:" + err.Error()
-			return
-		}
-	}
-
-	if err != nil {
-		br.Msg = "移动失败"
-		br.ErrMsg = "修改失败,Err:" + err.Error()
-		return
-	}
-
-	br.Ret = 200
-	br.Success = true
-	br.Msg = "移动成功"
-}
-
 //// SandboxClassifyItems
 //// @Title 获取所有沙盘分类接口-包含沙盘-先分类后沙盘区分，暂时弃用
 //// @Description 获取所有沙盘分类接口-包含沙盘
@@ -1818,4 +1976,292 @@ func (this *SandboxController) SandboxMove() {
 //	br.Success = true
 //	br.Msg = "获取成功"
 //	br.Data = resp
+//}
+
+
+//// SandboxMove
+//// @Title 移动沙盘接口
+//// @Description 移动图表接口
+//// @Success 200 {object} data_manage.MoveChartInfoReq
+//// @router /move [post]
+//func (this *SandboxController) SandboxMove() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//
+//	var req sandbox.MoveSandboxReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	if req.SandboxId <= 0 {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "沙盘id小于等于0"
+//		return
+//	}
+//
+//	if req.SandboxClassifyId <= 0 {
+//		br.Msg = "请选择分类"
+//		return
+//	}
+//	//判断分类是否存在
+//	count, _ := sandbox.GetSandboxClassifyCountById(req.SandboxClassifyId)
+//	if count <= 0 {
+//		br.Msg = "分类已被删除，不可移动，请刷新页面"
+//		return
+//	}
+//
+//	sandboxInfo, err := sandbox.GetSandboxById(req.SandboxId)
+//	if err != nil {
+//		br.Msg = "移动失败"
+//		br.ErrMsg = "获取沙盘信息失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	//如果改变了分类，那么移动该图表数据
+//	if sandboxInfo.SandboxClassifyId != req.SandboxClassifyId {
+//		//查询需要修改的分类下是否存在同一个图表名称
+//		tmpSandboxInfo, tmpErr := sandbox.GetSandboxByClassifyIdAndName(req.SandboxClassifyId, sandboxInfo.Name)
+//		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+//			return
+//		}
+//		if tmpSandboxInfo != nil {
+//			br.Msg = "移动失败，同一个分类下沙盘名称不允许重复"
+//			br.ErrMsg = "移动失败，同一个分类下沙盘名称不允许重复"
+//			return
+//		}
+//		err = sandbox.MoveSandbox(req.SandboxId, req.SandboxClassifyId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "移动失败,Err:" + err.Error()
+//			return
+//		}
+//	}
+//
+//	//移动排序
+//	updateCol := make([]string, 0)
+//	//如果有传入 上一个兄弟节点分类id
+//	if req.PrevSandboxId > 0 {
+//		prevChartInfo, err := sandbox.GetSandboxById(req.PrevSandboxId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果是移动在两个兄弟节点之间
+//		if req.NextSandboxId > 0 {
+//			//下一个兄弟节点
+//			nextChartInfo, err := sandbox.GetSandboxById(req.NextSandboxId)
+//			if err != nil {
+//				br.Msg = "移动失败"
+//				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+//				return
+//			}
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevChartInfo.Sort == nextChartInfo.Sort || prevChartInfo.Sort == sandboxInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//				_ = sandbox.UpdateSandboxSortByClassifyId(prevChartInfo.SandboxClassifyId, prevChartInfo.Sort, prevChartInfo.SandboxId, updateSortStr)
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//					_ = sandbox.UpdateSandboxSortByClassifyId(prevChartInfo.SandboxClassifyId, prevChartInfo.Sort, prevChartInfo.SandboxId, updateSortStr)
+//				}
+//			}
+//		}
+//
+//		sandboxInfo.Sort = prevChartInfo.Sort + 1
+//		sandboxInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//
+//	} else {
+//		firstClassify, err := sandbox.GetFirstSandboxByClassifyId(req.SandboxClassifyId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = sandbox.UpdateSandboxSortByClassifyId(firstClassify.SandboxClassifyId, 0, firstClassify.SandboxId-1, updateSortStr)
+//		}
+//
+//		sandboxInfo.Sort = 0 //那就是排在第一位
+//		sandboxInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = sandboxInfo.Update(updateCol)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "修改失败,Err:" + err.Error()
+//			return
+//		}
+//	}
+//
+//	if err != nil {
+//		br.Msg = "移动失败"
+//		br.ErrMsg = "修改失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "移动成功"
+//}
+
+//// ChartClassifyMove
+//// @Title 沙盘分类移动接口
+//// @Description 沙盘分类移动接口
+//// @Success 200 {object} data_manage.MoveChartClassifyReq
+//// @router /classify/move [post]
+//func (this *SandboxController) ChartClassifyMove() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//
+//	var req sandbox.MoveSandboxClassifyReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	if req.ClassifyId <= 0 {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "分类id小于等于0"
+//		return
+//	}
+//	//判断分类是否存在
+//	sandboxClassifyInfo, err := sandbox.GetSandboxClassifyById(req.ClassifyId)
+//	if err != nil {
+//		br.Msg = "移动失败"
+//		br.ErrMsg = "获取分类信息失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	updateCol := make([]string, 0)
+//
+//	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+//	if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
+//		parentChartClassifyInfo, err := sandbox.GetSandboxClassifyById(req.ParentClassifyId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//		sandboxClassifyInfo.ParentId = parentChartClassifyInfo.SandboxClassifyId
+//		sandboxClassifyInfo.Level = parentChartClassifyInfo.Level + 1
+//		sandboxClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+//	} else if sandboxClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId == 0 {
+//		//改为一级分类
+//		sandboxClassifyInfo.ParentId = req.ParentClassifyId
+//		sandboxClassifyInfo.Level = 1
+//		sandboxClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+//	}
+//
+//	//如果有传入 上一个兄弟节点分类id
+//	if req.PrevClassifyId > 0 {
+//		//上一个兄弟节点
+//		prevClassify, err := sandbox.GetSandboxClassifyById(req.PrevClassifyId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果是移动在两个兄弟节点之间
+//		if req.NextClassifyId > 0 {
+//			//下一个兄弟节点
+//			nextClassify, err := sandbox.GetSandboxClassifyById(req.NextClassifyId)
+//			if err != nil {
+//				br.Msg = "移动失败"
+//				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+//				return
+//			}
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == sandboxClassifyInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//				_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, prevClassify.SandboxClassifyId, prevClassify.Sort, updateSortStr)
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextClassify.Sort-prevClassify.Sort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//					_ = sandbox.UpdateSandboxClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+//				}
+//			}
+//		}
+//
+//		sandboxClassifyInfo.Sort = prevClassify.Sort + 1
+//		sandboxClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//
+//	} else {
+//		firstClassify, err := sandbox.GetFirstSandboxClassifyByParentId(sandboxClassifyInfo.ParentId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = sandbox.UpdateSandboxClassifySortByParentId(firstClassify.ParentId, firstClassify.SandboxClassifyId-1, 0, updateSortStr)
+//		}
+//
+//		sandboxClassifyInfo.Sort = 0 //那就是排在第一位
+//		sandboxClassifyInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = sandboxClassifyInfo.Update(updateCol)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "修改失败,Err:" + err.Error()
+//			return
+//		}
+//	}
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "移动成功"
 //}

models/sandbox/sand_box_classify.go

@@ -51,7 +51,7 @@ type SandboxClassifyItems struct {
 	CreateTime          time.Time `description:"创建时间"`
 	ModifyTime          time.Time `description:"修改时间"`
 	SysUserId           int       `description:"创建人id"`
-	SysUserName     string    `description:"创建人姓名"`
+	SysUserName         string    `description:"创建人姓名"`
 	Level               int       `description:"层级"`
 	Sort                int       `description:"排序字段，越小越靠前，默认值：10"`
 	SandboxId           int       `description:"沙盘id"`
@@ -157,9 +157,12 @@ func DeleteSandboxClassify(classifyId int) (err error) {
 // MoveSandboxClassifyReq 移动沙盘分类请求参数
 type MoveSandboxClassifyReq struct {
 	ClassifyId       int `description:"分类id"`
-	ParentClassifyId int `description:"父级分类id"`
-	PrevClassifyId   int `description:"上一个兄弟节点分类id"`
-	NextClassifyId   int `description:"下一个兄弟节点分类id"`
+	SandboxId        int `description:"沙盘ID"`
+	ParentClassifyId int `description:"父级分类id 移动沙盘时为目标分类id"`
+	PrevId           int `description:"上一个兄弟节点分类id"`
+	NextId           int `description:"下一个兄弟节点分类id"`
+	PrevType         int `description:"上一个兄弟节点类型 1分类 2沙盘 "`
+	NextType         int `description:"上一个兄弟节点类型 1分类 2沙盘 "`
 }
 
 // UpdateSandboxClassifySortByParentId 根据沙盘父类id更新排序
@@ -228,4 +231,4 @@ ORDER BY
 	sandbox_classify_id ASC`
 	_, err = o.Raw(sql, parentId, parentId).QueryRows(&items)
 	return
-}
+}

models/sandbox/sandbox.go

@@ -385,11 +385,11 @@ func MoveSandbox(sandboxId, classifyId int) (err error) {
 
 
 // UpdateSandboxSortByClassifyId 根据沙盘id更新排序
-func UpdateSandboxSortByClassifyId(classifyId, nowSort, prevChartInfoId int, updateSort string) (err error) {
+func UpdateSandboxSortByClassifyId(classifyId, nowSort, prevSandboxId int, updateSort string) (err error) {
 	o := orm.NewOrmUsingDB("data")
 	sql := ` update sandbox set sort = ` + updateSort + ` WHERE sandbox_classify_id=?  AND `
-	if prevChartInfoId > 0 {
-		sql += ` (sort > ? or (sandbox_id > ` + fmt.Sprint(prevChartInfoId) + ` and sort = ` + fmt.Sprint(nowSort) + `))`
+	if prevSandboxId > 0 {
+		sql += ` (sort > ? or (sandbox_id > ` + fmt.Sprint(prevSandboxId) + ` and sort = ` + fmt.Sprint(nowSort) + `))`
 	}
 	_, err = o.Raw(sql, classifyId, nowSort).Exec()
 	return

routers/commentsRouter.go

@@ -4210,15 +4210,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta/eta_api/controllers/sandbox:SandboxController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/sandbox:SandboxController"],
-        beego.ControllerComments{
-            Method: "SandboxMove",
-            Router: `/move`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta/eta_api/controllers/sandbox:SandboxController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/sandbox:SandboxController"],
         beego.ControllerComments{
             Method: "SaveV2",