eta_api/controllers/material/material.go

package material

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/material"
	materialService "eta/eta_api/services/material"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"strings"
	"time"
)

// versionSize 版本列表第一页数据约定是：3条
var versionSize = 3

// MaterialController 逻辑导图
type MaterialController struct {
	controllers.BaseAuthController
}

// ClassifyMaterialItems
// @Title 获取所有素材库分类接口-包含素材库
// @Description 获取所有素材库分类接口-包含素材库
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartClassifyListResp
// @router /classify/materialList [get]
func (this *MaterialController) ClassifyMaterialItems() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	resp := new(material.MaterialClassifyListResp)
	MaterialClassifyId, _ := this.GetInt("MaterialClassifyId")

	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		errMsg, err := materialService.GetMaterialClassifyListForMe(*this.SysUser, resp, MaterialClassifyId)
		if err != nil {
			br.Msg = errMsg
			br.ErrMsg = err.Error()
			return
		}
		// 移除没有权限的图表

		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		fmt.Println("source my classify")
		return
	}

	rootList, err := material.GetMaterialClassifyAndInfoByParentId(MaterialClassifyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	classifyAll, err := material.GetMaterialClassifyAndInfoByParentId(MaterialClassifyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	nodeAll := make([]*material.MaterialClassifyItems, 0)
	for k := range rootList {
		rootNode := rootList[k]
		materialService.MaterialClassifyItemsMakeTreeV2(this.SysUser, classifyAll, rootNode)
		nodeAll = append(nodeAll, rootNode)
	}

	//newAll := materialService.MaterialItemsMakeTree(nodeAll, sandListMap, MaterialClassifyId)

	resp.AllNodes = nodeAll
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// AddMaterialClassify
// @Title 新增素材库分类
// @Description 新增材库分类接口
// @Param	request	body data_manage.AddChartClassifyReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /classify/add [post]
func (this *MaterialController) AddMaterialClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req material.AddMaterialClassifyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyName == "" {
		br.Msg = "请输入分类名称"
		br.IsSendEmail = false
		return
	}
	if req.ParentId < 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}

	level := 1
	levelPath := ""
	if req.ParentId > 0 {
		//查找父级分类
		parentClassify, e := material.GetMaterialClassifyById(req.ParentId)
		if e != nil {
			br.Msg = "获取父级分类失败"
			br.ErrMsg = "获取父级分类失败，Err:" + e.Error()
			return
		}
		level = parentClassify.Level + 1
		levelPath = parentClassify.LevelPath
	}

	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
	}
	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
	br.Msg = "保存成功"
	br.Success = true
}

// EditMaterialClassify
// @Title 修改素材库分类
// @Description 修改素材库分类接口
// @Param	request	body data_manage.EditChartClassifyReq true "type json string"
// @Success 200 Ret=200 修改成功
// @router /classify/edit [post]
func (this *MaterialController) EditMaterialClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req material.EditMaterialClassifyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyName == "" {
		br.Msg = "请输入分类名称"
		br.IsSendEmail = false
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		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
	br.IsAddLog = true
}

// DeleteMaterialClassifyCheck
// @Title 删除素材库检测接口
// @Description 删除素材库检测接口
// @Param	request	body data_manage.ChartClassifyDeleteCheckResp true "type json string"
// @Success 200 Ret=200 检测成功
// @router /classify/del/check [post]
func (this *MaterialController) DeleteMaterialClassifyCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req material.MaterialClassifyDeleteCheckReq
	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.IsSendEmail = false
		return
	}
	var deleteStatus int
	var tipsMsg string
	//删除分类
	// 查询当前的分类
	classifyInfo, err := material.GetMaterialClassifyById(req.ClassifyId)
	if err != nil {
		br.Msg = "分类不存在"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}
	classifyIds := strings.Split(classifyInfo.LevelPath, ",")
	if len(classifyIds) > 0 {
		//判断素材库分类下，是否含有素材库
		count, e := material.GetMaterialInfoCountByClassifyIds(classifyIds)
		if e != nil {
			br.Msg = "删除失败"
			br.ErrMsg = "分类下是否含有指标失败，Err:" + e.Error()
			return
		}

		if count > 0 {
			deleteStatus = 1
			tipsMsg = "该分类下关联素材库不可删除"
		} else {
			if len(classifyIds) > 1 {
				deleteStatus = 2
				tipsMsg = "确认删除当前目录及包含的子目录吗"
			}
		}
	}

	if deleteStatus == 0 {
		tipsMsg = "可删除，进行删除操作"
	}

	resp := new(material.MaterialClassifyDeleteCheckResp)
	resp.DeleteStatus = deleteStatus
	resp.TipsMsg = tipsMsg
	br.Ret = 200
	br.Msg = "检测成功"
	br.Success = true
	br.Data = resp
}

// DeleteMaterialClassify
// @Title 删除素材库分类/素材库
// @Description 删除素材库分类/素材库接口
// @Param	request	body data_manage.DeleteChartClassifyReq true "type json string"
// @Success 200 Ret=200 删除成功
// @router /classify/del [post]
func (this *MaterialController) DeleteMaterialClassify() {
	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 material.DeleteMaterialClassifyReq
	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.IsSendEmail = false
		return
	}

	// 查询当前的分类
	classifyInfo, err := material.GetMaterialClassifyById(req.ClassifyId)
	if err != nil {
		br.Msg = "分类不存在"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}
	classifyIds := strings.Split(classifyInfo.LevelPath, ",")
	if len(classifyIds) > 0 {
		//判断素材库分类下，是否含有素材库
		count, e := material.GetMaterialInfoCountByClassifyIds(classifyIds)
		if e != nil {
			br.Msg = "删除失败"
			br.ErrMsg = "分类下是否含有指标失败，Err:" + e.Error()
			return
		}

		if count > 0 {
			br.Msg = "该目录下存在关联指标，不可删除"
			br.IsSendEmail = false
			return
		}

		err = material.DeleteMaterialClassify(classifyIds)
		if err != nil {
			br.Msg = "删除失败"
			br.ErrMsg = "删除失败,Err:" + err.Error()
			return
		}
	}

	//删除素材库
	/*if req.MaterialId > 0 {
		materialInfo, err := material.GetMaterialById(req.MaterialId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "素材库已删除，请刷新页面"
				br.ErrMsg = "指标不存在,Err:" + err.Error()
				return
			} else {
				br.Msg = "删除失败"
				br.ErrMsg = "删除失败，获取指标信息失败，Err:" + err.Error()
				return
			}
		}
		if materialInfo == nil {
			br.Msg = "素材库已删除，请刷新页面"
			return
		}
		err = materialService.DeleteMaterial(req.MaterialId)
		if err != nil {
			br.Msg = err.Error()
			return
		}
	}*/
	br.Ret = 200
	br.Msg = "删除成功"
	br.Success = true
	br.IsAddLog = true
}

// ClassifyMove
// @Title 素材库分类移动接口
// @Description 素材库分类移动接口
// @Success 200 {object} data_manage.MoveChartClassifyReq
// @router /classify/move [post]
func (this *MaterialController) ClassifyMove() {
	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 material.MoveMaterialClassifyReq
	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
	}
	//判断分类是否存在
	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
	}
	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()
	}

	// 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()
			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)
						}
					}
				}

			}

			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 {
						//变更兄弟节点的排序
						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 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 {
						//如果下一个兄弟(分类)的排序权重正好是上个兄弟(素材库)节点的下一层，那么需要再加一层了
						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.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 = "移动成功"
}

// @Title ETA图表列表接口
// @Description ETA图表列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ChartClassifyId   query   int  true       "分类id"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartListResp
// @router /list [get]
func (this *MaterialController) List() {
	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
	}

	MaterialClassifyId, _ := this.GetInt("MaterialClassifyId")

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyWord := this.GetString("KeyWord")

	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	var condition string
	var pars []interface{}

	if MaterialClassifyId > 0 {
		MaterialClassifyId, err := material.GetMaterialClassify(MaterialClassifyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取图表信息失败"
			br.ErrMsg = "获取信息失败,GetChartClassify,Err:" + err.Error()
			return
		}
		condition += " AND sandbox_classify_id IN(" + MaterialClassifyId + ") "
		//pars = append(pars, chartClassifyId)
	}
	if keyWord != "" {
		condition += ` AND  ( name LIKE '%` + keyWord + `%' )`
	}

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	//获取图表信息
	condition += ` AND is_delete = 0 `
	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()
		return
	}

	for i, v := range list {
		ids, err := material.GetMaterialAllParentByClassifyId(v.ClassifyId)
		if err != nil {
			br.Msg = "获取父级信息错误！"
			br.ErrMsg = "获取父级信息错误，Err:" + err.Error()
			return
		}
		list[i].ParentIds = ids
	}
	resp := new(material.MaterialListResp)
	if list == nil || len(list) <= 0 || (err != nil && err.Error() == utils.ErrNoRow()) {
		items := make([]*material.MaterialListItems, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	dataCount, err := material.GetMaterialListCountByCondition(condition, pars)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
		return
	}
	page = paging.GetPaging(currentIndex, pageSize, dataCount)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// Save
// @Title 新增/编辑保存素材库
// @Description 新增/编辑保存素材库接口
// @Param	request	body material.AddAndEditSandbox true "type json string"
// @Success 200 {object} material.Material
// @router /save [post]
func (this *MaterialController) Save() {
	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 material.AddAndEditMaterial
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	var materialResp *material.MaterialSaveResp

	var errMsg string

	if req.MaterialId <= 0 {
		//新增素材库
		materialResp, err = materialService.AddMaterial(req, sysUser.AdminId, sysUser.RealName)
		if err != nil {
			br.Msg = "保存失败！"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "保存失败，Err:" + err.Error()
			return
		}
	} else {
		//编辑素材库
		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.ImgUrl == "" {
			updateSandboxColumn = []string{"Name", "Content", "MindmapData", "ModifyTime", "MaterialClassifyId", "Style"}
		} else {
			updateSandboxColumn = []string{"Name", "Content", "MindmapData", "ImgUrl", "ModifyTime", "MaterialClassifyId", "Style"}
		}
		err = materialInfo.Update(updateSandboxColumn)
		if err != nil {
			br.Msg = "保存失败！"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "保存失败，Err:" + err.Error()
			return
		}
	}
	msg := "保存成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = materialResp
}

// Delete
// @Title 删除素材库
// @Description 删除素材库接口
// @Param	request	body material.DeleteSandbox true "type json string"
// @Success 200 标记成功
// @router /delete [post]
func (this *MaterialController) Delete() {
	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 material.DeleteMaterial
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.MaterialId <= 0 {
		br.Msg = "缺少素材库编号"
		return
	}

	//删除素材库
	err = materialService.DeleteMaterial(req.MaterialId)
	if err != nil {
		br.Msg = err.Error()
		return
	}

	msg := "删除成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
}

// GetMaterialVersionDetail
// @Title 获取素材库版本数据详情（已保存的）
// @Description 获取素材库版本数据详情接口（已保存的）
// @Param   SandboxVersionCode   query   string  true       "素材库版本code"
// @Success 200 {object} material.MaterialVersion
// @router /detail [get]
func (this *MaterialController) GetMaterialDetail() {
	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
	}

	sandboxId, _ := this.GetInt("SandboxId")
	if sandboxId == 0 {
		br.Msg = "缺少素材库Id"
		return
	}

	//获取素材库数据详情（已保存的）
	materialInfo, err := material.GetMaterialById(sandboxId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err：" + err.Error()
		return
	}
	msg := "获取成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = materialInfo
}

// MaterialClassifyList
// @Title 获取所有素材库分类接口-不包含素材库
// @Description 获取所有素材库分类接口-不包含素材库
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartClassifyListResp
// @router /classify/list [get]
func (this *MaterialController) MaterialClassifyList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	resp := new(material.MaterialClassifyListResp)

	rootList, err := material.GetMaterialClassifyByParentId(0)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	classifyAll, err := material.GetMaterialClassifyAll()
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	nodeAll := make([]*material.MaterialClassifyItems, 0)
	for k := range rootList {
		rootNode := rootList[k]
		materialService.MaterialClassifyItemsMakeTree(this.SysUser, classifyAll, rootNode)
		nodeAll = append(nodeAll, rootNode)
	}

	resp.AllNodes = nodeAll
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}