素材库分类信息

controllers/material/material.go

@@ -1,11 +1,10 @@
-package sandbox
+package material
 
 import (
 	"encoding/json"
 	"eta/eta_api/controllers"
 	"eta/eta_api/models"
 	"eta/eta_api/models/material"
-	"eta/eta_api/services/data"
 	materialService "eta/eta_api/services/material"
 	"eta/eta_api/utils"
 	"fmt"
@@ -22,8 +21,8 @@ type MaterialController struct {
 }
 
 // MaterialClassifyItems
-// @Title 获取所有沙盘分类接口-包含沙盘
-// @Description 获取所有沙盘分类接口-包含沙盘
+// @Title 获取所有素材库分类接口-包含素材库
+// @Description 获取所有素材库分类接口-包含素材库
 // @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
 // @Success 200 {object} data_manage.ChartClassifyListResp
 // @router /classify/list [get]
@@ -69,24 +68,6 @@ func (this *MaterialController) MaterialClassifyItems() {
 		return
 	}
 
-	//sandboxAll, err := material.GetMaterialItemsByClassifyId(MaterialClassifyId)
-	//if err != nil && err.Error() != utils.ErrNoRow() {
-	//	br.Msg = "获取失败"
-	//	br.ErrMsg = "获取数据失败，Err:" + err.Error()
-	//	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]
@@ -103,8 +84,8 @@ func (this *MaterialController) MaterialClassifyItems() {
 	br.Data = resp
 }
 
-// @Title 新增沙盘分类
-// @Description 新增沙盘分类接口
+// @Title 新增素材库分类
+// @Description 新增素材库分类接口
 // @Param	request	body data_manage.AddChartClassifyReq true "type json string"
 // @Success 200 Ret=200 保存成功
 // @router /classify/add [post]
@@ -167,8 +148,8 @@ func (this *MaterialController) AddMaterialClassify() {
 	br.Success = true
 }
 
-// @Title 修改沙盘分类
-// @Description 修改沙盘分类接口
+// @Title 修改素材库分类
+// @Description 修改素材库分类接口
 // @Param	request	body data_manage.EditChartClassifyReq true "type json string"
 // @Success 200 Ret=200 修改成功
 // @router /classify/edit [post]
@@ -240,8 +221,8 @@ func (this *MaterialController) EditMaterialClassify() {
 	br.IsAddLog = true
 }
 
-// @Title 删除沙盘检测接口
-// @Description 删除沙盘检测接口
+// @Title 删除素材库检测接口
+// @Description 删除素材库检测接口
 // @Param	request	body data_manage.ChartClassifyDeleteCheckResp true "type json string"
 // @Success 200 Ret=200 检测成功
 // @router /classify/delete/check [post]
@@ -268,7 +249,7 @@ func (this *MaterialController) DeleteMaterialClassifyCheck() {
 	var tipsMsg string
 	//删除分类
 	if req.ClassifyId > 0 {
-		//判断沙盘分类下，是否含有沙盘
+		//判断素材库分类下，是否含有素材库
 		count, err := material.GetMaterialInfoCountByClassifyId(req.ClassifyId)
 		if err != nil {
 			br.Msg = "删除失败"
@@ -278,7 +259,7 @@ func (this *MaterialController) DeleteMaterialClassifyCheck() {
 
 		if count > 0 {
 			deleteStatus = 1
-			tipsMsg = "该分类下关联沙盘不可删除"
+			tipsMsg = "该分类下关联素材库不可删除"
 		}
 	}
 
@@ -286,7 +267,7 @@ func (this *MaterialController) DeleteMaterialClassifyCheck() {
 		classifyCount, err := material.GetMaterialInfoCountByClassifyId(req.ClassifyId)
 		if err != nil && err.Error() != utils.ErrNoRow() {
 			br.Msg = "删除失败"
-			br.ErrMsg = "分类下是否含有沙盘失败，Err:" + err.Error()
+			br.ErrMsg = "分类下是否含有素材库失败，Err:" + err.Error()
 			return
 		}
 		if classifyCount > 0 {
@@ -307,8 +288,8 @@ func (this *MaterialController) DeleteMaterialClassifyCheck() {
 	br.Data = resp
 }
 
-// @Title 删除沙盘分类/沙盘
-// @Description 删除沙盘分类/沙盘接口
+// @Title 删除素材库分类/素材库
+// @Description 删除素材库分类/素材库接口
 // @Param	request	body data_manage.DeleteChartClassifyReq true "type json string"
 // @Success 200 Ret=200 删除成功
 // @router /classify/delete [post]
@@ -365,12 +346,12 @@ func (this *MaterialController) DeleteMaterialClassify() {
 		}
 	}
 
-	//删除沙盘
+	//删除素材库
 	if req.MaterialId > 0 {
-		sandboxInfo, err := material.GetMaterialById(req.MaterialId)
+		materialInfo, err := material.GetMaterialById(req.MaterialId)
 		if err != nil {
 			if err.Error() == utils.ErrNoRow() {
-				br.Msg = "沙盘已删除，请刷新页面"
+				br.Msg = "素材库已删除，请刷新页面"
 				br.ErrMsg = "指标不存在,Err:" + err.Error()
 				return
 			} else {
@@ -379,8 +360,8 @@ func (this *MaterialController) DeleteMaterialClassify() {
 				return
 			}
 		}
-		if sandboxInfo == nil {
-			br.Msg = "沙盘已删除，请刷新页面"
+		if materialInfo == nil {
+			br.Msg = "素材库已删除，请刷新页面"
 			return
 		}
 		err = materialService.DeleteMaterial(req.MaterialId)
@@ -396,8 +377,8 @@ func (this *MaterialController) DeleteMaterialClassify() {
 }
 
 // ChartClassifyMove
-// @Title 沙盘分类移动接口
-// @Description 沙盘分类移动接口
+// @Title 素材库分类移动接口
+// @Description 素材库分类移动接口
 // @Success 200 {object} data_manage.MoveChartClassifyReq
 // @router /classify/move [post]
 func (this *MaterialController) ChartClassifyMove() {
@@ -438,37 +419,25 @@ func (this *MaterialController) ChartClassifyMove() {
 
 	updateCol := make([]string, 0)
 
-	// 判断移动的是分类还是沙盘
+	// 判断移动的是分类还是素材库
 	if req.MaterialId > 0 {
 		//判断分类是否存在
-		count, _ := material.GetMaterialClassifyCountById(req.ClassifyId)
+		/*count, _ := material.GetMaterialClassifyCountById(req.ClassifyId)
 		if count <= 0 {
 			br.Msg = "分类已被删除，不可移动，请刷新页面"
 			return
 		}
 
-		sandboxInfo, err := material.GetMaterialById(req.MaterialId)
+		materialInfo, err := material.GetMaterialById(req.MaterialId)
 		if err != nil {
 			br.Msg = "移动失败"
-			br.ErrMsg = "获取沙盘信息失败,Err:" + err.Error()
+			br.ErrMsg = "获取素材库信息失败,Err:" + err.Error()
 			return
 		}
 
 		//如果改变了分类，那么移动该图表数据
 		// 11/22 ETA逻辑优化去除名称重复限制
-		if sandboxInfo.ClassifyId != req.ParentClassifyId {
-			////查询需要修改的分类下是否存在同一个图表名称
-			//tmpSandboxInfo, tmpErr := material.GetMaterialByClassifyIdAndName(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
-			//}
+		if materialInfo.ClassifyId != req.ParentClassifyId {
 			err = material.MoveSandbox(req.MaterialId, req.ParentClassifyId)
 			if err != nil {
 				br.Msg = "移动失败"
@@ -517,7 +486,7 @@ func (this *MaterialController) ChartClassifyMove() {
 							}
 						}
 					} else {
-						//上一个节点是分类 下一个节点是沙盘的情况
+						//上一个节点是分类 下一个节点是素材库的情况
 						//下一个兄弟节点
 						nextChartInfo, err := material.GetMaterialById(req.NextId)
 						if err != nil {
@@ -525,14 +494,14 @@ func (this *MaterialController) ChartClassifyMove() {
 							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
 							return
 						}
-						//如果上一个兄弟(分类)与下一个兄弟(沙盘)的排序权重是一致的，那么需要将下一个兄弟(沙盘)（以及下个兄弟(沙盘)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
-						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == sandboxInfo.Sort {
+						//如果上一个兄弟(分类)与下一个兄弟(素材库)的排序权重是一致的，那么需要将下一个兄弟(素材库)（以及下个兄弟(素材库)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
+						if prevClassify.Sort == nextChartInfo.Sort || prevClassify.Sort == materialInfo.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`
@@ -544,12 +513,12 @@ func (this *MaterialController) ChartClassifyMove() {
 
 				}
 
-				sandboxInfo.Sort = prevClassify.Sort + 1
-				sandboxInfo.ModifyTime = time.Now()
+				materialInfo.Sort = prevClassify.Sort + 1
+				materialInfo.ModifyTime = time.Now()
 				updateCol = append(updateCol, "Sort", "ModifyTime")
 
 			} else {
-				prevSandbox, err := material.GetMaterialById(req.PrevId)
+				prevMaterial, err := material.GetMaterialById(req.PrevId)
 				if err != nil {
 					br.Msg = "移动失败"
 					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
@@ -559,7 +528,7 @@ func (this *MaterialController) ChartClassifyMove() {
 				//如果是移动在两个兄弟节点之间
 				if req.NextId > 0 {
 					if req.NextType == 1 {
-						//上一个节点是沙盘 下一个节点是分类的情况
+						//上一个节点是素材库 下一个节点是分类的情况
 						//下一个兄弟节点
 						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
 						if err != nil {
@@ -567,23 +536,23 @@ func (this *MaterialController) ChartClassifyMove() {
 							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)
+							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevmaterial.Sort == 1 {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+							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)
+								_ = 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 {
@@ -591,33 +560,33 @@ func (this *MaterialController) ChartClassifyMove() {
 							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
 							return
 						}
-						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
-						if prevmaterial.Sort == nextChartInfo.Sort || prevmaterial.Sort == sandboxInfo.Sort {
+						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(素材库)的排序权重+1
+						if prevMaterial.Sort == nextChartInfo.Sort || prevMaterial.Sort == materialInfo.Sort {
 							//变更兄弟节点的排序
 							updateSortStr := `sort + 2`
-							_ = material.UpdateMaterialClassifySortByParentId(prevmaterial.ClassifyId, 0, prevmaterial.Sort, updateSortStr)
-							_ = material.UpdateMaterialSortByClassifyId(prevmaterial.ClassifyId, prevmaterial.Sort, prevmaterial.MaterialId, updateSortStr)
+							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevmaterial.Sort == 1 {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+							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)
+								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 							}
 						}
 					}
 
 				}
 
-				sandboxInfo.Sort = prevmaterial.Sort + 1
-				sandboxInfo.ModifyTime = time.Now()
+				materialInfo.Sort = prevMaterial.Sort + 1
+				materialInfo.ModifyTime = time.Now()
 				updateCol = append(updateCol, "Sort", "ModifyTime")
 			}
 
 		} else {
-			// prevId为0，也就是沙盘移到最前端
-			firstClassify, err := material.GetFirstSandboxByClassifyId(req.ClassifyId)
+			// prevId为0，也就是素材库移到最前端
+			firstClassify, err := material.GetFirstMaterialByClassifyId(req.ClassifyId)
 			if err != nil && err.Error() != utils.ErrNoRow() {
 				br.Msg = "移动失败"
 				br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
@@ -630,21 +599,21 @@ func (this *MaterialController) ChartClassifyMove() {
 				_ = material.UpdateMaterialSortByClassifyId(firstClassify.ClassifyId, 0, firstClassify.MaterialId-1, updateSortStr)
 			}
 
-			sandboxInfo.Sort = 0 //那就是排在第一位
-			sandboxInfo.ModifyTime = time.Now()
+			materialInfo.Sort = 0 //那就是排在第一位
+			materialInfo.ModifyTime = time.Now()
 			updateCol = append(updateCol, "Sort", "ModifyTime")
 
 		}
 
 		//更新
 		if len(updateCol) > 0 {
-			err = sandboxInfo.Update(updateCol)
+			err = materialInfo.Update(updateCol)
 			if err != nil {
 				br.Msg = "移动失败"
 				br.ErrMsg = "修改失败,Err:" + err.Error()
 				return
 			}
-		}
+		}*/
 	} else {
 		//移动的是分类
 		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
@@ -706,7 +675,7 @@ func (this *MaterialController) ChartClassifyMove() {
 							}
 						}
 					} else {
-						//上一个节点是分类 下一个节点是沙盘的情况
+						//上一个节点是分类 下一个节点是素材库的情况
 						//下一个兄弟节点
 						nextChartInfo, err := material.GetMaterialById(req.NextId)
 						if err != nil {
@@ -714,14 +683,14 @@ func (this *MaterialController) ChartClassifyMove() {
 							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
 							return
 						}
-						//如果上一个兄弟(分类)与下一个兄弟(沙盘)的排序权重是一致的，那么需要将下一个兄弟(沙盘)（以及下个兄弟(沙盘)的同样排序权重）的排序权重+2，自己变成上一个兄弟(分类)的排序权重+1
+						//如果上一个兄弟(分类)与下一个兄弟(素材库)的排序权重是一致的，那么需要将下一个兄弟(素材库)（以及下个兄弟(素材库)的同样排序权重）的排序权重+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`
@@ -738,8 +707,8 @@ func (this *MaterialController) ChartClassifyMove() {
 				updateCol = append(updateCol, "Sort", "ModifyTime")
 
 			} else {
-				//上一个节点是沙盘
-				prevSandbox, err := material.GetMaterialById(req.PrevId)
+				//上一个节点是素材库
+				prevMaterial, err := material.GetMaterialById(req.PrevId)
 				if err != nil {
 					br.Msg = "移动失败"
 					br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
@@ -749,7 +718,7 @@ func (this *MaterialController) ChartClassifyMove() {
 				//如果是移动在两个兄弟节点之间
 				if req.NextId > 0 {
 					if req.NextType == 1 {
-						//上一个节点是沙盘 下一个节点是分类的情况
+						//上一个节点是素材库 下一个节点是分类的情况
 						//下一个兄弟节点
 						nextClassify, err := material.GetMaterialClassifyById(req.NextId)
 						if err != nil {
@@ -757,23 +726,23 @@ func (this *MaterialController) ChartClassifyMove() {
 							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)
+							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
-							if nextClassify.Sort-prevmaterial.Sort == 1 {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+							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)
+								_ = 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 {
@@ -781,25 +750,25 @@ func (this *MaterialController) ChartClassifyMove() {
 							br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
 							return
 						}
-						//如果上一个兄弟(沙盘)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+2，自己变成上一个兄弟(沙盘)的排序权重+1
-						if prevmaterial.Sort == nextChartInfo.Sort || prevmaterial.Sort == MaterialClassifyInfo.Sort {
+						//如果上一个兄弟(素材库)与下一个兄弟(分类)的排序权重是一致的，那么需要将下一个兄弟(分类)（以及下个兄弟(分类)的同样排序权重）的排序权重+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)
+							_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+							_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 						} else {
-							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(沙盘)节点的下一层，那么需要再加一层了
-							if nextChartInfo.Sort-prevmaterial.Sort == 1 {
+							//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
+							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)
+								_ = material.UpdateMaterialClassifySortByParentId(prevMaterial.ClassifyId, 0, prevMaterial.Sort, updateSortStr)
+								_ = material.UpdateMaterialSortByClassifyId(prevMaterial.ClassifyId, prevMaterial.Sort, prevMaterial.MaterialId, updateSortStr)
 							}
 						}
 					}
 
 				}
-				MaterialClassifyInfo.Sort = prevmaterial.Sort + 1
+				MaterialClassifyInfo.Sort = prevMaterial.Sort + 1
 				MaterialClassifyInfo.ModifyTime = time.Now()
 				updateCol = append(updateCol, "Sort", "ModifyTime")
 
@@ -832,26 +801,7 @@ func (this *MaterialController) ChartClassifyMove() {
 				br.ErrMsg = "修改失败,Err:" + err.Error()
 				return
 			}
-			if req.ParentClassifyId > 0 {
-				ids, err := material.GetMaterialClassifySubcategories(req.ClassifyId)
-				if err != nil {
-					br.Msg = "查询子级分类id失败"
-					br.ErrMsg = "查询子级分类id失败,Err:" + err.Error()
-					return
-				}
-				parentChartClassifyInfo, err := material.GetMaterialClassifyById(req.ParentClassifyId)
-				if err != nil {
-					br.Msg = "移动失败"
-					br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
-					return
-				}
-				err = material.UpdateMaterialClassifyChartPermissionById(parentChartClassifyInfo.ChartPermissionId, parentChartClassifyInfo.ChartPermissionName, ids)
-				if err != nil {
-					br.Msg = "修改子级分类错误"
-					br.ErrMsg = "修改子级分类错误,Err:" + err.Error()
-					return
-				}
-			}
+			// todo 记录整个层级的分类ID
 		}
 	}
 
@@ -930,8 +880,8 @@ func (this *MaterialController) List() {
 	list, err := material.GetMaterialListByCondition(condition, pars, startSize, pageSize)
 	if err != nil && err.Error() != utils.ErrNoRow() {
 		br.Success = true
-		br.Msg = "获取沙盘信息失败"
-		br.ErrMsg = "获取沙盘信息失败,Err:" + err.Error()
+		br.Msg = "获取素材库信息失败"
+		br.ErrMsg = "获取素材库信息失败,Err:" + err.Error()
 		return
 	}
 
@@ -971,8 +921,8 @@ func (this *MaterialController) List() {
 }
 
 // Save
-// @Title 新增/编辑保存沙盘
-// @Description 新增/编辑保存沙盘接口
+// @Title 新增/编辑保存素材库
+// @Description 新增/编辑保存素材库接口
 // @Param	request	body material.AddAndEditSandbox true "type json string"
 // @Success 200 {object} material.Material
 // @router /save [post]
@@ -997,14 +947,13 @@ func (this *MaterialController) Save() {
 		return
 	}
 
-	var sandboxResp *material.MaterialSaveResp
+	var materialResp *material.MaterialSaveResp
 
 	var errMsg string
 
-	var sandBoxData *material.Material
 	if req.MaterialId <= 0 {
-		//新增沙盘
-		sandboxResp, err = materialService.AddMaterial(req, sysUser.AdminId, sysUser.RealName)
+		//新增素材库
+		materialResp, err = materialService.AddMaterial(req, sysUser.AdminId, sysUser.RealName)
 		if err != nil {
 			br.Msg = "保存失败！"
 			if errMsg != `` {
@@ -1013,27 +962,23 @@ func (this *MaterialController) Save() {
 			br.ErrMsg = "保存失败，Err:" + err.Error()
 			return
 		}
-		sandBoxData = sandboxResp.Material
 	} else {
-		//编辑沙盘
-		sandboxInfo := &material.Material{
-			SandboxId:          req.MaterialId,
-			Name:               utils.TrimStr(req.Name),
-			Content:            req.Content,
-			MindmapData:        req.MindmapData,
-			PicUrl:             utils.TrimStr(req.PicUrl),
-			ModifyTime:         time.Now(),
-			MaterialClassifyId: req.ClassifyId,
-			Style:              req.Style,
+		//编辑素材库
+		materialInfo := &material.Material{
+			MaterialId:   req.MaterialId,
+			MaterialName: utils.TrimStr(req.MaterialName),
+			ImgUrl:       utils.TrimStr(req.ImgUrl),
+			ModifyTime:   time.Now(),
+			ClassifyId:   req.ClassifyId,
 		}
 		//缩略图为空时不更新
 		var updateSandboxColumn = []string{}
-		if req.PicUrl == "" {
+		if req.ImgUrl == "" {
 			updateSandboxColumn = []string{"Name", "Content", "MindmapData", "ModifyTime", "MaterialClassifyId", "Style"}
 		} else {
-			updateSandboxColumn = []string{"Name", "Content", "MindmapData", "PicUrl", "ModifyTime", "MaterialClassifyId", "Style"}
+			updateSandboxColumn = []string{"Name", "Content", "MindmapData", "ImgUrl", "ModifyTime", "MaterialClassifyId", "Style"}
 		}
-		err = sandboxInfo.Update(updateSandboxColumn)
+		err = materialInfo.Update(updateSandboxColumn)
 		if err != nil {
 			br.Msg = "保存失败！"
 			if errMsg != `` {
@@ -1042,22 +987,17 @@ func (this *MaterialController) Save() {
 			br.ErrMsg = "保存失败，Err:" + err.Error()
 			return
 		}
-		sandBoxData = sandboxInfo
 	}
-
-	//解析逻辑图的指标
-	_ = data.SaveSandBoxEdbInfoRelation(sandBoxData.MaterialId, sandBoxData.Content)
-
 	msg := "保存成功"
 	br.Ret = 200
 	br.Success = true
 	br.Msg = msg
-	br.Data = sandboxResp
+	br.Data = materialResp
 }
 
 // Delete
-// @Title 删除沙盘
-// @Description 删除沙盘接口
+// @Title 删除素材库
+// @Description 删除素材库接口
 // @Param	request	body material.DeleteSandbox true "type json string"
 // @Success 200 标记成功
 // @router /delete [post]
@@ -1083,12 +1023,12 @@ func (this *MaterialController) Delete() {
 	}
 
 	if req.MaterialId <= 0 {
-		br.Msg = "缺少沙盘编号"
+		br.Msg = "缺少素材库编号"
 		return
 	}
 
-	//删除沙盘
-	err = materialService.DeleteSandbox(req.MaterialId)
+	//删除素材库
+	err = materialService.DeleteMaterial(req.MaterialId)
 	if err != nil {
 		br.Msg = err.Error()
 		return
@@ -1101,9 +1041,9 @@ func (this *MaterialController) Delete() {
 }
 
 // GetMaterialVersionDetail
-// @Title 获取沙盘版本数据详情（已保存的）
-// @Description 获取沙盘版本数据详情接口（已保存的）
-// @Param   SandboxVersionCode   query   string  true       "沙盘版本code"
+// @Title 获取素材库版本数据详情（已保存的）
+// @Description 获取素材库版本数据详情接口（已保存的）
+// @Param   SandboxVersionCode   query   string  true       "素材库版本code"
 // @Success 200 {object} material.MaterialVersion
 // @router /detail [get]
 func (this *MaterialController) GetMaterialDetail() {
@@ -1122,12 +1062,12 @@ func (this *MaterialController) GetMaterialDetail() {
 
 	sandboxId, _ := this.GetInt("SandboxId")
 	if sandboxId == 0 {
-		br.Msg = "缺少沙盘Id"
+		br.Msg = "缺少素材库Id"
 		return
 	}
 
-	//获取沙盘数据详情（已保存的）
-	sandboxInfo, err := material.GetMaterialById(sandboxId)
+	//获取素材库数据详情（已保存的）
+	materialInfo, err := material.GetMaterialById(sandboxId)
 	if err != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取失败，Err：" + err.Error()
@@ -1137,12 +1077,12 @@ func (this *MaterialController) GetMaterialDetail() {
 	br.Ret = 200
 	br.Success = true
 	br.Msg = msg
-	br.Data = sandboxInfo
+	br.Data = materialInfo
 }
 
 // MaterialClassifyItems
-// @Title 获取所有沙盘分类接口-不包含沙盘
-// @Description 获取所有沙盘分类接口-不包含沙盘
+// @Title 获取所有素材库分类接口-不包含素材库
+// @Description 获取所有素材库分类接口-不包含素材库
 // @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
 // @Success 200 {object} data_manage.ChartClassifyListResp
 // @router /classifyList [get]

models/material/material_classify.go

@@ -105,7 +105,7 @@ type MaterialClassifyDeleteCheckReq struct {
 	ClassifyId int `description:"分类id"`
 }
 
-func GetSandboxInfoCountByClassifyId(classifyId int) (count int, err error) {
+func GetMaterialInfoCountByClassifyId(classifyId int) (count int, err error) {
 	o := orm.NewOrmUsingDB("rddp")
 	sql := ` SELECT COUNT(1) AS count FROM sandbox AS a
 				WHERE a.classify_id IN(
@@ -130,8 +130,7 @@ type MaterialClassifyDeleteCheckResp struct {
 
 type DeleteMaterialClassifyReq struct {
 	ClassifyId int `description:"分类id"`
-	MaterialId int
-	SandboxId  int `description:"指标id"`
+	MaterialId int `description:"素材id"`
 }
 
 func DeleteMaterialClassify(classifyId int) (err error) {
@@ -155,7 +154,7 @@ func DeleteMaterialClassify(classifyId int) (err error) {
 // MoveMaterialClassifyReq 移动沙盘分类请求参数
 type MoveMaterialClassifyReq struct {
 	ClassifyId       int `description:"分类id"`
-	SandboxId        int `description:"沙盘ID"`
+	MaterialId       int `description:"沙盘ID"`
 	ParentClassifyId int `description:"父级分类id 移动沙盘时为目标分类id"`
 	PrevId           int `description:"上一个兄弟节点分类id"`
 	NextId           int `description:"下一个兄弟节点分类id"`

routers/commentsRouter.go

@@ -7360,6 +7360,105 @@ 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",
+            Router: `/classify/delete`,
+            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: "DeleteMaterialClassifyCheck",
+            Router: `/classify/delete/check`,
+            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: "EditMaterialClassify",
+            Router: `/classify/edit`,
+            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: "MaterialClassifyItems",
+            Router: `/classify/list`,
+            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: "ChartClassifyMove",
+            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",
+            Router: `/delete`,
+            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: "GetMaterialDetail",
+            Router: `/detail`,
+            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: "List",
+            Router: `/list`,
+            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: "Save",
+            Router: `/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_api/controllers/report_approve:ReportApproveController"] = append(beego.GlobalControllerRouter["eta/eta_api/controllers/report_approve:ReportApproveController"],
         beego.ControllerComments{
             Method: "Approve",

routers/router.go

@@ -26,6 +26,7 @@ import (
 	"eta/eta_api/controllers/english_report"
 	"eta/eta_api/controllers/eta_trial"
 	"eta/eta_api/controllers/fe_calendar"
+	"eta/eta_api/controllers/material"
 	"eta/eta_api/controllers/report_approve"
 	"eta/eta_api/controllers/roadshow"
 	"eta/eta_api/controllers/sandbox"
@@ -397,6 +398,11 @@ func init() {
 				&document_manage.DocumentManageController{},
 			),
 		),
+		web.NSNamespace("/material",
+			web.NSInclude(
+				&material.MaterialController{},
+			),
+		),
 	)
 	web.AddNamespace(ns)
 }

services/material/material.go

@@ -172,3 +172,17 @@ func materialClassifyHaveChildV2(allNode []*material.MaterialClassifyItems, node
 	}
 	return
 }
+
+// DeleteMaterial 删除沙盘
+func DeleteMaterial(materialId int) (err error) {
+	// 获取沙盘主表信息
+	materialInfo, err := materialId.GetMaterialById(materialId)
+	if err != nil {
+		return
+	}
+
+	materialInfo.IsDelete = 1
+	var updateMaterialColumn = []string{"IsDelete"}
+	err = materialInfo.Update(updateMaterialColumn)
+	return
+}