移动分类

controllers/material/material.go

@@ -20,13 +20,13 @@ type MaterialController struct {
 	controllers.BaseAuthController
 }
 
-// MaterialClassifyItems
+// ClassifyMaterialItems
 // @Title 获取所有素材库分类接口-包含素材库
 // @Description 获取所有素材库分类接口-包含素材库
 // @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
 // @Success 200 {object} data_manage.ChartClassifyListResp
-// @router /classify/list [get]
-func (this *MaterialController) MaterialClassifyItems() {
+// @router /classify/materialList [get]
+func (this *MaterialController) ClassifyMaterialItems() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
@@ -84,18 +84,19 @@ func (this *MaterialController) MaterialClassifyItems() {
 	br.Data = resp
 }
 
-// @Title 新增/编辑素材库分类
-// @Description 新增/编辑材库分类接口
+// AddMaterialClassify
+// @Title 新增素材库分类
+// @Description 新增材库分类接口
 // @Param	request	body data_manage.AddChartClassifyReq true "type json string"
 // @Success 200 Ret=200 保存成功
-// @router /classify/save [post]
-func (this *MaterialController) SaveMaterialClassify() {
+// @router /classify/add [post]
+func (this *MaterialController) AddMaterialClassify() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
 		this.ServeJSON()
 	}()
-	var req material.SaveMaterialClassifyReq
+	var req material.AddMaterialClassifyReq
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
 		br.Msg = "参数解析异常！"
@@ -114,7 +115,7 @@ func (this *MaterialController) SaveMaterialClassify() {
 	}
 
 	level := 1
-	//levelPath := ""
+	levelPath := ""
 	if req.ParentId > 0 {
 		//查找父级分类
 		parentClassify, e := material.GetMaterialClassifyById(req.ParentId)
@@ -124,84 +125,50 @@ func (this *MaterialController) SaveMaterialClassify() {
 			return
 		}
 		level = parentClassify.Level + 1
-		//levelPath = parentClassify.LevelPath
+		levelPath = parentClassify.LevelPath
 	}
 
-	if req.ClassifyId > 0 {
-		// 只允许修改分类名称
-		item, e := material.GetMaterialClassifyById(req.ClassifyId)
-		if e != nil {
-			br.Msg = "保存失败"
-			br.Msg = "获取分类信息失败,Err:" + e.Error()
-			return
-		}
-		count, e := material.GetMaterialClassifyNameNotSelfCount(req.ClassifyId, req.ClassifyName, item.ParentId)
-		if e != nil {
-			br.Msg = "判断名称是否已存在失败"
-			br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
-			return
-		}
-		if count > 0 {
-			br.Msg = "分类名称已存在，请重新输入"
-			br.IsSendEmail = false
-			return
-		}
-		//levelPath = fmt.Sprintf("%s,%d", levelPath, req.ClassifyId)
-		//item.LevelPath = levelPath
-		//item.ParentId = req.ParentId
-		item.ClassifyName = req.ClassifyName
-		item.ModifyTime = time.Now()
-		//e = item.Update([]string{"LevelPath", "ParentId", "ClassifyName", "ModifyTime"})
-		e = item.Update([]string{"ClassifyName", "ModifyTime"})
-		if e != nil {
-			br.Msg = "保存分类失败"
-			br.ErrMsg = "保存分类失败,Err:" + e.Error()
-			return
-		}
-		//todo 更新子集的levelPath
-		/*e = material.UpdateMaterialClassifyLevelPath(req.ClassifyId, levelPath)
-		if e != nil {
-			br.Msg = "保存分类失败"
-			br.ErrMsg = "保存分类失败,Err:" + e.Error()
-			return
-		}*/
-	} else {
-		count, e := material.GetMaterialClassifyNameCount(req.ClassifyName, req.ParentId)
-		if e != nil {
-			br.Msg = "判断名称是否已存在失败"
-			br.ErrMsg = "判断名称是否已存在失败，Err:" + e.Error()
-			return
-		}
-		if count > 0 {
-			br.Msg = "分类名称已存在，请重新输入"
-			br.IsSendEmail = false
-			return
-		}
+	count, e := material.GetMaterialClassifyNameCount(req.ClassifyName, req.ParentId)
+	if e != nil {
+		br.Msg = "判断名称是否已存在失败"
+		br.ErrMsg = "判断名称是否已存在失败，Err:" + e.Error()
+		return
+	}
+	if count > 0 {
+		br.Msg = "分类名称已存在，请重新输入"
+		br.IsSendEmail = false
+		return
+	}
 
-		//获取该层级下最大的排序数
-		classify := new(material.MaterialClassify)
-		maxSort, _ := material.GetMaterialClassifyMaxSort(req.ParentId)
-		classify.ParentId = req.ParentId
-		classify.ClassifyName = req.ClassifyName
-		classify.CreateTime = time.Now()
-		classify.ModifyTime = time.Now()
-		classify.SysUserId = this.SysUser.AdminId
-		classify.SysUserRealName = this.SysUser.RealName
-		classify.Level = level
-		classify.Sort = maxSort + 1
-		classifyId, e := material.AddMaterialClassify(classify)
-		if e != nil {
-			br.Msg = "保存分类失败"
-			br.ErrMsg = "保存分类失败,Err:" + e.Error()
-			return
-		}
-		classify.LevelPath = fmt.Sprint(classifyId)
-		e = classify.Update([]string{"LevelPath"})
-		if e != nil {
-			br.Msg = "保存分类失败"
-			br.ErrMsg = "保存分类失败,Err:" + e.Error()
-			return
-		}
+	//获取该层级下最大的排序数
+	classify := new(material.MaterialClassify)
+	maxSort, _ := material.GetMaterialClassifyMaxSort(req.ParentId)
+	classify.ParentId = req.ParentId
+	classify.ClassifyName = req.ClassifyName
+	classify.CreateTime = time.Now()
+	classify.ModifyTime = time.Now()
+	classify.SysUserId = this.SysUser.AdminId
+	classify.SysUserRealName = this.SysUser.RealName
+	classify.Level = level
+	classify.Sort = maxSort + 1
+	classifyId, e := material.AddMaterialClassify(classify)
+	if e != nil {
+		br.Msg = "保存分类失败"
+		br.ErrMsg = "保存分类失败,Err:" + e.Error()
+		return
+	}
+	if req.ParentId > 0 {
+		levelPath = fmt.Sprintf("%s,%d", levelPath, classifyId)
+	} else {
+		levelPath = fmt.Sprintf("%d", classifyId)
+	}
+	classify.ClassifyId = int(classifyId)
+	classify.LevelPath = levelPath
+	e = classify.Update([]string{"LevelPath"})
+	if e != nil {
+		br.Msg = "保存分类失败"
+		br.ErrMsg = "保存分类失败,Err:" + e.Error()
+		return
 	}
 
 	br.Ret = 200
@@ -209,6 +176,7 @@ func (this *MaterialController) SaveMaterialClassify() {
 	br.Success = true
 }
 
+// EditMaterialClassify
 // @Title 修改素材库分类
 // @Description 修改素材库分类接口
 // @Param	request	body data_manage.EditChartClassifyReq true "type json string"
@@ -239,6 +207,73 @@ func (this *MaterialController) EditMaterialClassify() {
 		return
 	}
 
+	// 只允许修改分类名称
+	item, err := material.GetMaterialClassifyById(req.ClassifyId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "分类不存在"
+			return
+		}
+		br.Msg = "保存失败"
+		br.Msg = "获取分类信息失败,Err:" + err.Error()
+		return
+	}
+	count, err := material.GetMaterialClassifyNameNotSelfCount(req.ClassifyId, req.ClassifyName, item.ParentId)
+	if err != nil {
+		br.Msg = "判断名称是否已存在失败"
+		br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+		return
+	}
+	if count > 0 {
+		br.Msg = "分类名称已存在，请重新输入"
+		br.IsSendEmail = false
+		return
+	}
+	//levelPath = fmt.Sprintf("%s,%d", levelPath, req.ClassifyId)
+	//item.LevelPath = levelPath
+	//item.ParentId = req.ParentId
+	item.ClassifyName = req.ClassifyName
+	item.ModifyTime = time.Now()
+	//e = item.Update([]string{"LevelPath", "ParentId", "ClassifyName", "ModifyTime"})
+	err = item.Update([]string{"ClassifyName", "ModifyTime"})
+	if err != nil {
+		br.Msg = "保存分类失败"
+		br.ErrMsg = "保存分类失败,Err:" + err.Error()
+		return
+	}
+	//todo 测试更新子集的levelPath
+	/*levelPath := ""
+	oldLevelPath := item.LevelPath
+	if item.ParentId > 0 {
+		//查找父级分类
+		parentClassify, e := material.GetMaterialClassifyById(item.ParentId)
+		if e != nil {
+			br.Msg = "获取父级分类失败"
+			br.ErrMsg = "获取父级分类失败，Err:" + e.Error()
+			return
+		}
+		levelPath = fmt.Sprintf("%s,%d", parentClassify.LevelPath, item.ClassifyId)
+		tmpList, e := material.GetMaterialClassifyByLevelPath(oldLevelPath)
+		if e != nil {
+			br.Msg = "保存分类失败"
+			br.ErrMsg = "保存分类失败,Err:" + e.Error()
+			return
+		}
+		// 把原先的父级levePath，替换成最新的父级序列
+		for _, tmp := range tmpList {
+			tmp.LevelPath = strings.Replace(tmp.LevelPath, oldLevelPath, levelPath, -1)
+			tmp.ModifyTime = time.Now()
+			e = tmp.Update([]string{"LevelPath", "ModifyTime"})
+			if e != nil {
+				br.Msg = "保存分类失败"
+				br.ErrMsg = "保存分类失败,Err:" + e.Error()
+				return
+			}
+		}
+	} else {
+		// 只有更改了父级才需要更新levelPath
+	}*/
+
 	br.Ret = 200
 	br.Msg = "保存成功"
 	br.Success = true
@@ -400,12 +435,12 @@ func (this *MaterialController) DeleteMaterialClassify() {
 	br.IsAddLog = true
 }
 
-// ChartClassifyMove
+// ClassifyMove
 // @Title 素材库分类移动接口
 // @Description 素材库分类移动接口
 // @Success 200 {object} data_manage.MoveChartClassifyReq
 // @router /classify/move [post]
-func (this *MaterialController) ChartClassifyMove() {
+func (this *MaterialController) ClassifyMove() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
@@ -434,401 +469,230 @@ func (this *MaterialController) ChartClassifyMove() {
 		return
 	}
 	//判断分类是否存在
-	MaterialClassifyInfo, err := material.GetMaterialClassifyById(req.ClassifyId)
+	materialClassifyInfo, err := material.GetMaterialClassifyById(req.ClassifyId)
 	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "分类不存在，请刷新页面"
+			br.ErrMsg = "分类不存在,Err:" + err.Error()
+			return
+		}
 		br.Msg = "移动失败"
 		br.ErrMsg = "获取分类信息失败,Err:" + err.Error()
 		return
 	}
-
-	updateCol := make([]string, 0)
-
-	// 判断移动的是分类还是素材库
-	if req.MaterialId > 0 {
-		//判断分类是否存在
-		/*count, _ := material.GetMaterialClassifyCountById(req.ClassifyId)
-		if count <= 0 {
-			br.Msg = "分类已被删除，不可移动，请刷新页面"
+	if materialClassifyInfo.ParentId != req.ParentClassifyId {
+		count, err := material.GetMaterialClassifyNameNotSelfCount(materialClassifyInfo.ClassifyId, materialClassifyInfo.ClassifyName, materialClassifyInfo.ParentId)
+		if err != nil {
+			br.Msg = "判断名称是否已存在失败"
+			br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+			return
+		}
+		if count > 0 {
+			br.Msg = "移动失败，分类名称已存在"
+			br.IsSendEmail = false
 			return
 		}
+	}
+	err, errMsg := materialService.MoveMaterialClassify(materialClassifyInfo, &req)
+	if err != nil {
+		br.Msg = errMsg
+		if errMsg == "" {
+			br.Msg = "移动失败"
+		}
+		br.ErrMsg = err.Error()
+	}
 
-		materialInfo, err := material.GetMaterialById(req.MaterialId)
+	// todo权限校验
+	//移动的是分类
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	/*updateCol := make([]string, 0)
+	if MaterialClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
+		parentChartClassifyInfo, err := material.GetMaterialClassifyById(req.ParentClassifyId)
 		if err != nil {
 			br.Msg = "移动失败"
-			br.ErrMsg = "获取素材库信息失败,Err:" + err.Error()
+			br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
 			return
 		}
-
-		//如果改变了分类，那么移动该图表数据
-		// 11/22 ETA逻辑优化去除名称重复限制
-		if materialInfo.ClassifyId != req.ParentClassifyId {
-			err = material.MoveSandbox(req.MaterialId, req.ParentClassifyId)
+		MaterialClassifyInfo.ParentId = parentChartClassifyInfo.ClassifyId
+		MaterialClassifyInfo.Level = parentChartClassifyInfo.Level + 1
+		MaterialClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+	} else if MaterialClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId == 0 {
+		//改为一级分类
+		MaterialClassifyInfo.ParentId = req.ParentClassifyId
+		MaterialClassifyInfo.Level = 1
+		MaterialClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+	}
+
+	//如果有传入 上一个兄弟节点分类id
+	if req.PrevId > 0 {
+		if req.PrevType == 1 {
+			//上一个节点是分类
+			//上一个兄弟节点
+			prevClassify, err := material.GetMaterialClassifyById(req.PrevId)
 			if err != nil {
 				br.Msg = "移动失败"
-				br.ErrMsg = "移动失败,Err:" + err.Error()
+				br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
 				return
 			}
-		}
 
-		//移动排序
-		updateCol := make([]string, 0)
-		//如果有传入 上一个兄弟节点分类id
-		if req.PrevId > 0 {
-			if req.PrevType == 1 {
-				//上一个兄弟节点
-				prevClassify, err := material.GetMaterialClassifyById(req.PrevId)
-				if err != nil {
-					br.Msg = "移动失败"
-					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
-					return
-				}
-
-				//如果是移动在两个兄弟节点之间
-				if req.NextId > 0 {
-					if req.NextType == 1 {
-						//上一个节点是分类 下一个节点是分类的情况
-						//下一个兄弟节点
-						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-						if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == MaterialClassifyInfo.Sort {
-							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-						} else {
-							//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevClassify.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-							}
-						}
+			//如果是移动在两个兄弟节点之间
+			if req.NextId > 0 {
+				if req.NextType == 1 {
+					//上一个节点是分类 下一个节点是分类的情况
+					//下一个兄弟节点
+					nextClassify, err := material.GetMaterialClassifyById(req.NextId)
+					if err != nil {
+						br.Msg = "移动失败"
+						br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+						return
+					}
+					//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+					if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == MaterialClassifyInfo.Sort {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 2`
+						_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
+						_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
 					} else {
-						//上一个节点是分类 下一个节点是素材库的情况
-						//下一个兄弟节点
-						nextChartInfo, err := material.GetMaterialById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(分类)与下一个兄弟(素材库)的排序权重是一致的，那么需要将下一个兄弟(素材库)（以及下个兄弟(素材库)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
-						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == materialInfo.Sort {
+						//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+						if nextClassify.Sort-prevClassify.Sort == 1 {
 							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
+							updateSortStr := `sort + 1`
+							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
 							_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-						} else {
-							//如果下一个兄弟(素材库)的排序权重正好是上个兄弟节点(分类)的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevClassify.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.ClassifyId, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-							}
 						}
 					}
-
-				}
-
-				materialInfo.Sort = prevClassify.Sort + 1
-				materialInfo.ModifyTime = time.Now()
-				updateCol = append(updateCol, "Sort", "ModifyTime")
-
-			} else {
-				prevMaterial, err := material.GetMaterialById(req.PrevId)
-				if err != nil {
-					br.Msg = "移动失败"
-					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
-					return
-				}
-
-				//如果是移动在两个兄弟节点之间
-				if req.NextId > 0 {
-					if req.NextType == 1 {
-						//上一个节点是素材库 下一个节点是分类的情况
-						//下一个兄弟节点
-						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
-						if prevMaterial.Sort == nextClassify.Sort || prevMaterial.Sort == MaterialClassifyInfo.Sort {
-							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevMaterial.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-							}
-						}
+				} else {
+					//上一个节点是分类 下一个节点是素材库的情况
+					//下一个兄弟节点
+					nextChartInfo, err := material.GetMaterialById(req.NextId)
+					if err != nil {
+						br.Msg = "移动失败"
+						br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+						return
+					}
+					//如果上一个兄弟(分类)与下一个兄弟(素材库)的排序权重是一致的，那么需要将下一个兄弟(素材库)（以及下个兄弟(素材库)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
+					if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == MaterialClassifyInfo.Sort {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 2`
+						_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
+						_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
 					} else {
-						//上一个节点是素材库 下一个节点是素材库的情况
-						//下一个兄弟节点
-						nextChartInfo, err := material.GetMaterialById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
-						if prevMaterial.Sort == nextChartInfo.Sort || prevMaterial.Sort == materialInfo.Sort {
+						//如果下一个兄弟(素材库)的排序权重正好是上个兄弟节点(分类)的下一层，那么需要再加一层了
+						if nextChartInfo.Sort-prevClassify.Sort == 1 {
 							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevMaterial.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-							}
+							updateSortStr := `sort + 1`
+							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.ClassifyId, updateSortStr)
+							_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
 						}
 					}
-
 				}
 
-				materialInfo.Sort = prevMaterial.Sort + 1
-				materialInfo.ModifyTime = time.Now()
-				updateCol = append(updateCol, "Sort", "ModifyTime")
 			}
 
-		} else {
-			// prevId为0，也就是素材库移到最前端
-			firstClassify, err := material.GetFirstMaterialByClassifyId(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 `
-				_ = material.UpdateMaterialSortByClassifyId(firstClassify.ClassifyId, 0, firstClassify.MaterialId-1, updateSortStr)
-			}
-
-			materialInfo.Sort = 0 //那就是排在第一位
-			materialInfo.ModifyTime = time.Now()
+			MaterialClassifyInfo.Sort = prevClassify.Sort + 1
+			MaterialClassifyInfo.ModifyTime = time.Now()
 			updateCol = append(updateCol, "Sort", "ModifyTime")
 
-		}
-
-		//更新
-		if len(updateCol) > 0 {
-			err = materialInfo.Update(updateCol)
-			if err != nil {
-				br.Msg = "移动失败"
-				br.ErrMsg = "修改失败,Err:" + err.Error()
-				return
-			}
-		}*/
-	} else {
-		//移动的是分类
-		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
-		if MaterialClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
-			parentChartClassifyInfo, err := material.GetMaterialClassifyById(req.ParentClassifyId)
+		} else {
+			//上一个节点是素材库
+			prevMaterial, err := material.GetMaterialById(req.PrevId)
 			if err != nil {
 				br.Msg = "移动失败"
-				br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
+				br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
 				return
 			}
-			MaterialClassifyInfo.ParentId = parentChartClassifyInfo.ClassifyId
-			MaterialClassifyInfo.Level = parentChartClassifyInfo.Level + 1
-			MaterialClassifyInfo.ModifyTime = time.Now()
-			updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
-		} else if MaterialClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId == 0 {
-			//改为一级分类
-			MaterialClassifyInfo.ParentId = req.ParentClassifyId
-			MaterialClassifyInfo.Level = 1
-			MaterialClassifyInfo.ModifyTime = time.Now()
-			updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
-		}
 
-		//如果有传入 上一个兄弟节点分类id
-		if req.PrevId > 0 {
-			if req.PrevType == 1 {
-				//上一个节点是分类
-				//上一个兄弟节点
-				prevClassify, err := material.GetMaterialClassifyById(req.PrevId)
-				if err != nil {
-					br.Msg = "移动失败"
-					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
-					return
-				}
-
-				//如果是移动在两个兄弟节点之间
-				if req.NextId > 0 {
-					if req.NextType == 1 {
-						//上一个节点是分类 下一个节点是分类的情况
-						//下一个兄弟节点
-						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-						if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == MaterialClassifyInfo.Sort {
-							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-						} else {
-							//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevClassify.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-							}
-						}
-					} else {
-						//上一个节点是分类 下一个节点是素材库的情况
-						//下一个兄弟节点
-						nextChartInfo, err := material.GetMaterialById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(分类)与下一个兄弟(素材库)的排序权重是一致的，那么需要将下一个兄弟(素材库)（以及下个兄弟(素材库)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
-						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == MaterialClassifyInfo.Sort {
-							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-						} else {
-							//如果下一个兄弟(素材库)的排序权重正好是上个兄弟节点(分类)的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevClassify.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.ClassifyId, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevClassify.ClassifyId, prevClassify.Sort, 0, updateSortStr)
-							}
-						}
+			//如果是移动在两个兄弟节点之间
+			if req.NextId > 0 {
+				if req.NextType == 1 {
+					//上一个节点是素材库 下一个节点是分类的情况
+					//下一个兄弟节点
+					nextClassify, err := material.GetMaterialClassifyById(req.NextId)
+					if err != nil {
+						br.Msg = "移动失败"
+						br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+						return
 					}
-
-				}
-
-				MaterialClassifyInfo.Sort = prevClassify.Sort + 1
-				MaterialClassifyInfo.ModifyTime = time.Now()
-				updateCol = append(updateCol, "Sort", "ModifyTime")
-
-			} else {
-				//上一个节点是素材库
-				prevMaterial, err := material.GetMaterialById(req.PrevId)
-				if err != nil {
-					br.Msg = "移动失败"
-					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
-					return
-				}
-
-				//如果是移动在两个兄弟节点之间
-				if req.NextId > 0 {
-					if req.NextType == 1 {
-						//上一个节点是素材库 下一个节点是分类的情况
-						//下一个兄弟节点
-						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
-						if prevMaterial.Sort == nextClassify.Sort || prevMaterial.Sort == MaterialClassifyInfo.Sort {
+					//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
+					if prevMaterial.Sort == nextClassify.Sort || prevMaterial.Sort == MaterialClassifyInfo.Sort {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 2`
+						_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+						_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
+					} else {
+						//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+						if nextClassify.Sort-prevMaterial.Sort == 1 {
 							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
+							updateSortStr := `sort + 1`
 							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
 							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevMaterial.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-							}
 						}
+					}
+				} else {
+					//上一个节点是素材库 下一个节点是素材库的情况
+					//下一个兄弟节点
+					nextChartInfo, err := material.GetMaterialById(req.NextId)
+					if err != nil {
+						br.Msg = "移动失败"
+						br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+						return
+					}
+					//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
+					if prevMaterial.Sort == nextChartInfo.Sort || prevMaterial.Sort == MaterialClassifyInfo.Sort {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 2`
+						_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+						_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 					} else {
-						//上一个节点是素材库 下一个节点是素材库的情况
-						//下一个兄弟节点
-						nextChartInfo, err := material.GetMaterialById(req.NextId)
-						if err != nil {
-							br.Msg = "移动失败"
-							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
-							return
-						}
-						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
-						if prevMaterial.Sort == nextChartInfo.Sort || prevMaterial.Sort == MaterialClassifyInfo.Sort {
+						//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+						if nextChartInfo.Sort-prevMaterial.Sort == 1 {
 							//变更兄弟节点的排序
-							updateSortStr := `sort + 2`
+							updateSortStr := `sort + 1`
 							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
 							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevMaterial.Sort == 1 {
-								//变更兄弟节点的排序
-								updateSortStr := `sort + 1`
-								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
-								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
-							}
 						}
 					}
-
 				}
-				MaterialClassifyInfo.Sort = prevMaterial.Sort + 1
-				MaterialClassifyInfo.ModifyTime = time.Now()
-				updateCol = append(updateCol, "Sort", "ModifyTime")
 
 			}
-
-		} else {
-			firstClassify, err := material.GetFirstMaterialClassifyByParentId(MaterialClassifyInfo.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 `
-				_ = material.UpdateMaterialClassifySortByParentId(firstClassify.ParentId, firstClassify.ClassifyId-1, 0, updateSortStr)
-			}
-
-			MaterialClassifyInfo.Sort = 0 //那就是排在第一位
+			MaterialClassifyInfo.Sort = prevMaterial.Sort + 1
 			MaterialClassifyInfo.ModifyTime = time.Now()
 			updateCol = append(updateCol, "Sort", "ModifyTime")
+
 		}
 
-		//更新
-		if len(updateCol) > 0 {
-			err = MaterialClassifyInfo.Update(updateCol)
-			if err != nil {
-				br.Msg = "移动失败"
-				br.ErrMsg = "修改失败,Err:" + err.Error()
-				return
-			}
-			// todo 记录整个层级的分类ID
+	} else {
+		firstClassify, err := material.GetFirstMaterialClassifyByParentId(MaterialClassifyInfo.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 `
+			_ = material.UpdateMaterialClassifySortByParentId(firstClassify.ParentId, firstClassify.ClassifyId-1, 0, updateSortStr)
+		}
+
+		MaterialClassifyInfo.Sort = 0 //那就是排在第一位
+		MaterialClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
 	}
 
+	//更新
+	if len(updateCol) > 0 {
+		err = MaterialClassifyInfo.Update(updateCol)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "修改失败,Err:" + err.Error()
+			return
+		}
+		// todo 记录整个层级的分类ID
+	}*/
+
 	br.Ret = 200
 	br.Success = true
 	br.Msg = "移动成功"
@@ -1104,12 +968,12 @@ func (this *MaterialController) GetMaterialDetail() {
 	br.Data = materialInfo
 }
 
-// MaterialClassifyItems
+// MaterialClassifyList
 // @Title 获取所有素材库分类接口-不包含素材库
 // @Description 获取所有素材库分类接口-不包含素材库
 // @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
 // @Success 200 {object} data_manage.ChartClassifyListResp
-// @router /classifyList [get]
+// @router /classify/list [get]
 func (this *MaterialController) MaterialClassifyList() {
 	br := new(models.BaseResponse).Init()
 	defer func() {

models/data_manage/chart_classify.go

@@ -566,6 +566,6 @@ func GetChartClassifiesById(chartClassifyId int) (items []*ChartClassifyItems, e
         FROM chart_classify
         WHERE parent_id = ?
     );`
-	_,err = o.Raw(sql, chartClassifyId, chartClassifyId, chartClassifyId).QueryRows(&items)
+	_, err = o.Raw(sql, chartClassifyId, chartClassifyId, chartClassifyId).QueryRows(&items)
 	return
-}
+}

models/material/material_classify.go

@@ -58,8 +58,7 @@ type MaterialClassifyListResp struct {
 	AllNodes []*MaterialClassifyItems
 }
 
-type SaveMaterialClassifyReq struct {
-	ClassifyId   int
+type AddMaterialClassifyReq struct {
 	ClassifyName string `description:"分类名称"`
 	ParentId     int    `description:"父级id,第一级传0"`
 	//Level               int    `description:"层级,第一级传0，其余传上一级的层级"`
@@ -88,10 +87,8 @@ func GetMaterialClassifyMaxSort(parentId int) (sort int, err error) {
 }
 
 type EditMaterialClassifyReq struct {
-	ClassifyName        string `description:"分类名称"`
-	ClassifyId          int    `description:"分类id"`
-	ChartPermissionId   int    `description:"品种id"`
-	ChartPermissionName string `description:"品种名称"`
+	ClassifyName string `description:"分类名称"`
+	ClassifyId   int    `description:"分类id"`
 }
 
 func GetMaterialClassifyById(classifyId int) (item *MaterialClassify, err error) {
@@ -160,13 +157,13 @@ func DeleteMaterialClassify(classifyId int) (err error) {
 
 // MoveMaterialClassifyReq 移动沙盘分类请求参数
 type MoveMaterialClassifyReq struct {
-	ClassifyId       int `description:"分类id"`
-	MaterialId       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沙盘 "`
+	ClassifyId int `description:"分类id"`
+	//MaterialId       int `description:"沙盘ID"`
+	ParentClassifyId int `description:"目标父级分类id"`
+	PrevClassifyId   int `description:"上一个兄弟节点分类id"`
+	NextClassifyId   int `description:"下一个兄弟节点分类id"`
+	//PrevType         int `description:"上一个兄弟节点类型 1分类 2沙盘 "`
+	//NextType         int `description:"上一个兄弟节点类型 1分类 2沙盘 "`
 }
 
 // UpdateMaterialClassifySortByParentId 根据沙盘父类id更新排序
@@ -198,46 +195,15 @@ func (m *MaterialClassify) Update(cols []string) (err error) {
 // GetMaterialClassifyAndInfoByParentId
 func GetMaterialClassifyAndInfoByParentId(parentId int) (items []*MaterialClassifyItems, err error) {
 	o := orm.NewOrmUsingDB("rddp")
-	sql := ` SELECT
-	0 AS sandbox_id,
-	classify_id,
-	classify_name,
-	parent_id,
-	create_time,
-	modify_time,
-	sys_user_id,
-	sys_user_real_name AS sys_user_name,
-	sort,
-	level,
-	chart_permission_id,
-	chart_permission_name,
-	0 AS is_delete
+	sql := ` SELECT *
 FROM
 	material_classify 
 WHERE
-	parent_id = ? UNION ALL
-SELECT
-	sandbox_id,
-	classify_id,
-	name AS classify_name,
-	0 AS parent_id,
-	create_time,
-	modify_time,
-	sys_user_id,
-	sys_user_name,
-	sort,
-	0 AS level,
-	chart_permission_id,
-	chart_permission_name,
-	is_delete 
-FROM
-	sandbox 
-WHERE
-	classify_id = ? AND is_delete = 0
+	parent_id = ?
 ORDER BY
 	sort ASC,
 	classify_id ASC`
-	_, err = o.Raw(sql, parentId, parentId).QueryRows(&items)
+	_, err = o.Raw(sql, parentId).QueryRows(&items)
 	return
 }
 

models/move_interface.go

@@ -0,0 +1,26 @@
+package models
+
+import "time"
+
+// SingleMoveNodeReq 移动请求参数
+type SingleMoveNodeReq struct {
+	NodeId       int `description:"id"`
+	ParentNodeId int `description:"父级id"`
+	PrevNodeId   int `description:"上一个兄弟节点id"`
+	NextNodeId   int `description:"下一个兄弟节点id"`
+	NodeType     int
+	/*ChartInfoId      int `description:"图表ID, 如果图表ID有值，则移动对象为图表，否则认为移动对象分类"`
+	PrevChartInfoId  int `description:"上一个图表ID"`
+	NextChartInfoId  int `description:"下一个图表ID"`*/
+}
+
+type NodeInfo struct {
+	NodeId     int `description:"id"`
+	NodeName   string
+	ParentId   int `description:"父级id"`
+	Sort       int
+	Level      int
+	LevelPath  string
+	ModifyTime time.Time
+	//Update     func([]string) (err error)
+}

routers/commentsRouter.go

@@ -7360,6 +7360,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
+        beego.ControllerComments{
+            Method: "AddMaterialClassify",
+            Router: `/classify/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
         beego.ControllerComments{
             Method: "DeleteMaterialClassify",
@@ -7389,7 +7398,7 @@ func init() {
 
     beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
         beego.ControllerComments{
-            Method: "MaterialClassifyItems",
+            Method: "MaterialClassifyList",
             Router: `/classify/list`,
             AllowHTTPMethods: []string{"get"},
             MethodParams: param.Make(),
@@ -7398,31 +7407,22 @@ func init() {
 
     beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
         beego.ControllerComments{
-            Method: "ChartClassifyMove",
-            Router: `/classify/move`,
-            AllowHTTPMethods: []string{"post"},
+            Method: "ClassifyMaterialItems",
+            Router: `/classify/materialList`,
+            AllowHTTPMethods: []string{"get"},
             MethodParams: param.Make(),
             Filters: nil,
             Params: nil})
 
     beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
         beego.ControllerComments{
-            Method: "SaveMaterialClassify",
-            Router: `/classify/save`,
+            Method: "ClassifyMove",
+            Router: `/classify/move`,
             AllowHTTPMethods: []string{"post"},
             MethodParams: param.Make(),
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
-        beego.ControllerComments{
-            Method: "MaterialClassifyList",
-            Router: `/classifyList`,
-            AllowHTTPMethods: []string{"get"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/material:MaterialController"],
         beego.ControllerComments{
             Method: "Delete",

services/interface/move_interface.go

@@ -0,0 +1,194 @@
+package _interface
+
+import (
+	"errors"
+	"eta/eta_api/models"
+	"eta/eta_api/utils"
+	"time"
+)
+
+type SingleNodeMoveInterface interface {
+	GetNodeInfoById(nodeId int) (nodeInfo *models.NodeInfo, err error)
+	UpdateNodeInfoSortByParentIdAndSource(parentNodeId, nodeId, prevNodeSort int, updateSortStr string, nodeType int) (err error)
+	GetNodeMaxSort(parentId, nodeType int) (maxSort int, err error)
+	GetFirstNodeInfoByParentId(parentId int) (nodeInfo *models.NodeInfo, err error)
+}
+
+// MoveSingleNode 移动节点
+func MoveSingleNode(sm SingleNodeMoveInterface, req models.SingleMoveNodeReq) (newNodeInfo *models.NodeInfo, updateCol []string, err error, errMsg string) {
+	nodeId := req.NodeId
+	parentNodeId := req.ParentNodeId
+	prevNodeId := req.PrevNodeId
+	nextNodeId := req.NextNodeId
+	source := req.NodeType
+
+	//首先确定移动的对象是分类还是指标
+	//判断上一个节点是分类还是指标
+	//判断下一个节点是分类还是指标
+	//同时更新分类目录下的分类sort和指标sort
+	//更新当前移动的分类或者指标sort
+
+	var parentChartNodeInfo *models.NodeInfo
+	if parentNodeId > 0 {
+		parentChartNodeInfo, err = sm.GetNodeInfoById(parentNodeId)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
+			return
+		}
+	}
+
+	//如果有传入 上一个兄弟节点分类id
+	var (
+		//nodeInfo *models.NodeInfo
+		prevNode *models.NodeInfo
+		nextNode *models.NodeInfo
+		prevSort int
+		nextSort int
+	)
+
+	// 移动对象为分类
+	nodeInfo, err := sm.GetNodeInfoById(nodeId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			errMsg = "当前分类不存在"
+			err = errors.New("获取分类信息失败,Err:" + err.Error())
+			return
+		}
+		errMsg = "移动失败"
+		err = errors.New("获取分类信息失败,Err:" + err.Error())
+		return
+	}
+
+	if prevNodeId > 0 {
+		prevNode, err = sm.GetNodeInfoById(prevNodeId)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+			return
+		}
+		prevSort = prevNode.Sort
+	}
+
+	if nextNodeId > 0 {
+		//下一个兄弟节点
+		nextNode, err = sm.GetNodeInfoById(nextNodeId)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+			return
+		}
+		nextSort = nextNode.Sort
+	}
+
+	newNodeInfo, updateCol, err, errMsg = moveSingleNode(sm, parentChartNodeInfo, nodeInfo, prevNode, nextNode, parentNodeId, prevSort, nextSort, source)
+	return
+}
+
+// moveSingleNode 移动节点
+func moveSingleNode(sm SingleNodeMoveInterface, parentChartNodeInfo, nodeInfo, prevNode, nextNode *models.NodeInfo, parentNodeId, prevSort, nextSort, source int) (newNodeInfo *models.NodeInfo, updateCol []string, err error, errMsg string) {
+	updateCol = make([]string, 0)
+	newNodeInfo = nodeInfo
+	// 移动对象为分类， 判断分类是否存在
+	oldParentId := nodeInfo.ParentId
+	//oldLevel := nodeInfo.Level
+	if oldParentId != parentNodeId {
+		// todo 更新子分类对应的level
+	}
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	if nodeInfo.ParentId != parentNodeId && parentNodeId != 0 {
+		if nodeInfo.Level != parentChartNodeInfo.Level+1 { //禁止层级调整
+			errMsg = "不支持目录层级变更"
+			err = errors.New("不支持目录层级变更")
+			return
+		}
+		newNodeInfo.ParentId = parentChartNodeInfo.NodeId
+		//nodeInfo.RootId = parentChartNodeInfo.RootId
+		newNodeInfo.Level = parentChartNodeInfo.Level + 1
+		newNodeInfo.ModifyTime = time.Now()
+		//updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
+		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+	} else if nodeInfo.ParentId != parentNodeId && parentNodeId == 0 {
+		errMsg = "不支持目录层级变更"
+		err = errors.New("不支持目录层级变更")
+		return
+	}
+
+	if prevSort > 0 {
+		//如果是移动在两个兄弟节点之间
+		if nextSort > 0 {
+			//下一个兄弟节点
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevSort == nextSort || prevSort == nodeInfo.Sort {
+				//变更兄弟节点的排序
+				updateSortStr := `sort + 2`
+
+				//变更分类
+				if prevNode != nil {
+					_ = sm.UpdateNodeInfoSortByParentIdAndSource(parentNodeId, prevNode.NodeId, prevNode.Sort, updateSortStr, source)
+				} else {
+					_ = sm.UpdateNodeInfoSortByParentIdAndSource(parentNodeId, 0, prevSort, updateSortStr, source)
+				}
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextSort-prevSort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+
+					//变更分类
+					if prevNode != nil {
+						_ = sm.UpdateNodeInfoSortByParentIdAndSource(parentNodeId, prevNode.NodeId, prevSort, updateSortStr, source)
+					} else {
+						_ = sm.UpdateNodeInfoSortByParentIdAndSource(parentNodeId, 0, prevSort, updateSortStr, source)
+					}
+				}
+			}
+		}
+
+		newNodeInfo.Sort = prevSort + 1
+		newNodeInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	} else if prevNode == nil && nextNode == nil && parentNodeId > 0 {
+		//处理只拖动到目录里，默认放到目录底部的情况
+		var maxSort int
+		maxSort, err = sm.GetNodeMaxSort(parentNodeId, source)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
+			return
+		}
+		newNodeInfo.Sort = maxSort + 1 //那就是排在组内最后一位
+		newNodeInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	} else {
+		// 拖动到父级分类的第一位
+		firstClassify, tmpErr := sm.GetFirstNodeInfoByParentId(parentNodeId)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = sm.UpdateNodeInfoSortByParentIdAndSource(parentNodeId, firstClassify.NodeId-1, 0, updateSortStr, source)
+		}
+
+		newNodeInfo.Sort = 0 //那就是排在第一位
+		newNodeInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	// todo 更新层级
+	if len(updateCol) > 0 {
+		/*err = nodeInfo.Update(updateCol)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("修改失败,Err:" + err.Error())
+			return
+		}*/
+		// todo 更新对应分类的root_id和层级
+	}
+	return
+}

services/material/material.go

@@ -1,9 +1,13 @@
-package sandbox
+package materialService
 
 import (
+	"eta/eta_api/models"
 	"eta/eta_api/models/material"
 	"eta/eta_api/models/system"
+	_interface "eta/eta_api/services/interface"
 	"eta/eta_api/utils"
+	"fmt"
+	"strings"
 	"time"
 )
 
@@ -42,47 +46,19 @@ func MaterialClassifyItemsMakeTree(sysUser *system.Admin, allNode []*material.Ma
 
 // GetMaterialClassifyListForMe 获取我创建的沙盘
 func GetMaterialClassifyListForMe(adminInfo system.Admin, resp *material.MaterialClassifyListResp, classifyId int) (errMsg string, err error) {
-	rootList, err := material.GetMaterialClassifyByParentId(classifyId)
-	if err != nil && err.Error() != utils.ErrNoRow() {
-		errMsg = "获取失败"
-		return
-	}
 
 	classifyAll, err := material.GetMaterialClassifyByParentId(classifyId)
 	if err != nil && err.Error() != utils.ErrNoRow() {
 		errMsg = "获取失败"
 		return
 	}
-
-	sandboxAll, err := material.GetMaterialInfoByAdminId(adminInfo.AdminId)
-	if err != nil && err.Error() != utils.ErrNoRow() {
-		errMsg = "获取失败"
-		return
-	}
-
-	sandListMap := make(map[int][]*material.MaterialClassifyItems)
-	for _, v := range sandboxAll {
-		if _, ok := sandListMap[v.ClassifyId]; !ok {
-			list := make([]*material.MaterialClassifyItems, 0)
-			list = append(list, v)
-			sandListMap[v.ClassifyId] = list
-		} else {
-			sandListMap[v.ClassifyId] = append(sandListMap[v.ClassifyId], v)
-		}
-	}
-
 	nodeAll := make([]*material.MaterialClassifyItems, 0)
-	for k := range rootList {
-		rootNode := rootList[k]
+	for k := range classifyAll {
+		rootNode := classifyAll[k]
 		MaterialClassifyItemsMakeTree(&adminInfo, classifyAll, rootNode)
 		nodeAll = append(nodeAll, rootNode)
 	}
-	//for k := range nodeAll {
-	//
-	//}
-	newAll := MaterialItemsMakeTree(nodeAll, sandListMap, classifyId)
-	resp.AllNodes = newAll
-
+	resp.AllNodes = nodeAll
 	return
 }
 
@@ -144,20 +120,13 @@ func MaterialClassifyItemsMakeTreeV2(sysUser *system.Admin, allNode []*material.
 
 	childs, _ := materialClassifyHaveChildV2(allNode, node) //判断节点是否有子节点并返回
 	if len(childs) > 0 {
-
 		node.Children = append(node.Children, childs[0:]...) //添加子节点
 		for _, v := range childs {                           //查询子节点的子节点，并添加到子节点
 			_, has := materialClassifyHaveChildV2(allNode, v)
 			if has {
 				MaterialClassifyItemsMakeTreeV2(sysUser, allNode, v) //递归添加节点
-			} else {
-				//childrenArr := make([]*material.MaterialClassifyItems, 0)
-				//v.Children = childrenArr
 			}
 		}
-	} else {
-		//childrenArr := make([]*material.MaterialClassifyItems, 0)
-		//node.Children = childrenArr
 	}
 }
 
@@ -186,3 +155,113 @@ func DeleteMaterial(materialId int) (err error) {
 	err = materialInfo.Update(updateMaterialColumn)*/
 	return
 }
+
+func MoveMaterialClassify(classifyInfo *material.MaterialClassify, req *material.MoveMaterialClassifyReq) (err error, errMsg string) {
+	nodeMove := models.SingleMoveNodeReq{}
+	nodeMove.NodeId = req.ClassifyId
+	nodeMove.ParentNodeId = req.ParentClassifyId
+	nodeMove.PrevNodeId = req.PrevClassifyId
+	nodeMove.NextNodeId = req.NextClassifyId
+
+	materialClassifyMove := new(ClassifyMove)
+
+	nodeInfo, updateCol, err, errMsg := _interface.MoveSingleNode(materialClassifyMove, nodeMove)
+	if err != nil {
+		return
+	}
+	oldParentId := classifyInfo.ParentId
+	oldLevelPath := classifyInfo.LevelPath
+	if len(updateCol) > 0 {
+		classifyInfo.Sort = nodeInfo.Sort
+		classifyInfo.ModifyTime = nodeInfo.ModifyTime
+		classifyInfo.ParentId = nodeInfo.ParentId
+
+		levelPath := ""
+		if classifyInfo.ParentId != oldParentId {
+			//查找父级分类
+			parentClassify, e := material.GetMaterialClassifyById(classifyInfo.ParentId)
+			if e != nil {
+				errMsg = "获取父级分类失败"
+				err = fmt.Errorf("获取父级分类失败，Err:" + e.Error())
+				return
+			}
+			levelPath = fmt.Sprintf("%s,%d", parentClassify.LevelPath, classifyInfo.ClassifyId)
+		}
+		classifyInfo.LevelPath = levelPath
+		updateCol = append(updateCol, "LevelPath")
+		err = classifyInfo.Update(updateCol)
+		if err != nil {
+			err = fmt.Errorf("修改失败,Err:" + err.Error())
+			return
+		}
+
+		if classifyInfo.ParentId != oldParentId {
+			tmpList, e := material.GetMaterialClassifyByLevelPath(oldLevelPath)
+			if e != nil {
+				err = fmt.Errorf("保存分类失败,Err:" + e.Error())
+				return
+			}
+			// 把原先的父级levePath，替换成最新的父级序列
+			for _, tmp := range tmpList {
+				//获取字符串前缀的位置
+				after, _ := strings.CutPrefix(tmp.LevelPath, oldLevelPath)
+				fmt.Println("after", after)
+				// 拼接字符串
+				if after != "" {
+					tmp.LevelPath = levelPath + after
+					tmp.ModifyTime = time.Now()
+					e = tmp.Update([]string{"LevelPath", "ModifyTime"})
+					if e != nil {
+						err = fmt.Errorf("修改子分类,Err:" + e.Error())
+						return
+					}
+				}
+			}
+		}
+	}
+	return
+}
+
+type ClassifyMove struct{}
+
+func (m *ClassifyMove) GetNodeInfoById(nodeId int) (nodeInfo *models.NodeInfo, err error) {
+	classifyInfo, err := material.GetMaterialClassifyById(nodeId)
+	if err != nil {
+		return
+	}
+	nodeInfo = &models.NodeInfo{
+		NodeId:     classifyInfo.ClassifyId,
+		NodeName:   classifyInfo.ClassifyName,
+		ParentId:   classifyInfo.ParentId,
+		Level:      classifyInfo.Level,
+		Sort:       classifyInfo.Sort,
+		ModifyTime: classifyInfo.ModifyTime,
+	}
+	return
+}
+
+func (m *ClassifyMove) UpdateNodeInfoSortByParentIdAndSource(parentNodeId, nodeId, prevNodeSort int, updateSortStr string, nodeType int) (err error) {
+	err = material.UpdateMaterialClassifySortByParentId(parentNodeId, nodeId, prevNodeSort, updateSortStr)
+	return
+}
+
+func (m *ClassifyMove) GetNodeMaxSort(parentId, nodeType int) (maxSort int, err error) {
+	maxSort, err = material.GetMaterialClassifyMaxSort(parentId)
+	return
+}
+
+func (m *ClassifyMove) GetFirstNodeInfoByParentId(parentId int) (nodeInfo *models.NodeInfo, err error) {
+	classifyInfo, err := material.GetFirstMaterialClassifyByParentId(parentId)
+	if err != nil {
+		return
+	}
+	nodeInfo = &models.NodeInfo{
+		NodeId:     classifyInfo.ClassifyId,
+		NodeName:   classifyInfo.ClassifyName,
+		ParentId:   classifyInfo.ParentId,
+		Level:      classifyInfo.Level,
+		Sort:       classifyInfo.Sort,
+		ModifyTime: classifyInfo.ModifyTime,
+	}
+	return
+}