eta_api/controllers/material/material.go

package material

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

// 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 = "移动成功"
}

// List
// @Title 素材列表接口
// @Description 素材列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ClassifyId   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
	}

	classifyId, _ := this.GetInt("ClassifyId")

	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 classifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}
	// 查询当前的分类
	classifyInfo, err := material.GetMaterialClassifyById(classifyId)
	if err != nil {
		br.Msg = "分类不存在"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}
	// 获取所有子分类
	childList, e := material.GetMaterialClassifyByLevelPath(classifyInfo.LevelPath)
	if e != nil {
		err = fmt.Errorf("保存分类失败,Err:" + e.Error())
		return
	}
	// 把原先的父级levePath，替换成最新的父级序列
	classifyIdMap := make(map[string]struct{})
	classifyIds := make([]string, 0)
	childClassifyMap := make(map[int]*material.MaterialClassify)
	for _, tmp := range childList {
		childClassifyMap[tmp.ClassifyId] = tmp
		//获取字符串前缀的位置
		after, _ := strings.CutPrefix(tmp.LevelPath, classifyInfo.LevelPath)
		fmt.Println("after", after)
		// 拼接字符串
		if after != "" {
			ids := strings.Split(after, ",")
			for _, v := range ids {
				if _, ok := classifyIdMap[v]; !ok {
					classifyIds = append(classifyIds, v)
					classifyIdMap[v] = struct{}{}
				}
			}
		}
	}
	classifyIds = append(classifyIds, strconv.Itoa(classifyId))
	if len(classifyIds) > 0 {
		condition += " AND classify_id IN(" + utils.GetOrmInReplace(len(classifyIds)) + ") "
		pars = append(pars, classifyIds)
	}

	if keyword != "" {
		condition += ` AND  ( material_name LIKE '%` + keyword + `%' )`
	}

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

	//获取图表信息
	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 {
		if classifyTmp, ok := childClassifyMap[v.ClassifyId]; ok {
			list[i].ParentIds = classifyTmp.LevelPath
		}
	}
	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
}

// BatchAdd
// @Title 批量新增素材
// @Description 新增/编辑保存素材库接口
// @Param	request	body material.AddAndEditSandbox true "type json string"
// @Success 200 {object} material.Material
// @router /batch/add [post]
func (this *MaterialController) BatchAdd() {
	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.BatchAddMaterialReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	classifyId := req.ClassifyId
	if classifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}
	materialNames := make([]string, 0)
	for _, v := range req.MaterialList {
		if v.MaterialName == "" {
			br.Msg = "请填写图片名称"
			return
		}
		if v.ImgUrl == "" {
			br.Msg = "请上传图片"
			return
		}
		materialNames = append(materialNames, v.MaterialName)
	}
	if len(materialNames) == 0 {
		br.Msg = "请填写图片名称"
		return
	}

	// 判断文件名是否已存在
	exist, e := material.GetMaterialByNames(materialNames)
	if e != nil && e.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	if e == nil && exist.MaterialId > 0 {
		br.Msg = fmt.Sprintf("图片名称:%s 已存在", exist.MaterialName)
		return
	}
	// 获取表单中的所有文件
	/*files, err := this.GetFiles("Files")
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	if len(files) == 0 {
		br.Msg = "请选择文件"
		return
	}
	if len(materialNames) != len(files) {
		br.Msg = "图片数量与名称数量不一致"
		return
	}
	// 创建目标目录（如果不存在）
	uploadDir := utils.STATIC_DIR + "hongze/" + time.Now().Format("20060102")
	if err = os.MkdirAll(uploadDir, utils.DIR_MOD); err != nil {
		br.Msg = "存储目录创建失败"
		br.ErrMsg = "存储目录创建失败, Err:" + err.Error()
		return
	}

	// 处理单个文件（这里假设files是一个多文件字段）
	// 实际上，当使用<input type="file" name="files" multiple>时，
	// 它会作为多个文件字段发送到服务器，名字相同但后缀不同，例如：files, files[1], files[2]等。
	// 所以我们需要遍历这些字段。

	// 创建一个map来存储所有文件
	fileUrlMap := make(map[string]string)

	// 获取上传文件的头部信息
	//fileHeaders := this.Ctx.Request.Header["Content-Disposition"]
	for k, fileHeader := range files {
		// 解析Content-Disposition头以获取文件名
		// 获取文件名（避免路径遍历攻击，只使用文件名部分）
		fileName := filepath.Base(fileHeader.Filename)
		fileName = strings.TrimSpace(strings.Replace(fileName, "\\", "/", -1)) // 替换可能存在的反斜杠
		fileName = strings.Trim(fileName, " \"\n\r\t")                         // 去除文件名两侧的空白字符和引号

		ext := path.Ext(fileName)
		ossFileName := utils.GetRandStringNoSpecialChar(28) + ext
		filePath := filepath.Join(uploadDir, ossFileName)

		// 创建目标文件
		dst, e := os.Create(filePath)
		if e != nil {
			br.Msg = "文件创建失败"
			br.ErrMsg = "文件创建失败, Err:" + e.Error()
			//http.Error(w, e.Error(), http.StatusInternalServerError)
			return
		}
		defer dst.Close()
		src, e := fileHeader.Open()
		if e != nil {
			br.Msg = "文件打开失败"
			br.ErrMsg = "文件打开失败, Err:" + e.Error()
			return
		}
		// 将上传的文件内容复制到目标文件
		if _, err = io.Copy(dst, src); err != nil {
			br.Msg = "文件保存失败"
			br.ErrMsg = "文件保存失败, Err:" + err.Error()
			return
		}

		defer func() {
			_ = os.Remove(filePath)
		}()
		// 上传到阿里云
		ossDir := utils.RESOURCE_DIR + "cloud_disk/"

		savePath := ossDir + time.Now().Format("200601/20060102/") + ossFileName
		ossClient := services.NewOssClient()
		if ossClient == nil {
			br.Msg = "上传失败"
			br.ErrMsg = "初始化OSS服务失败"
			return
		}
		resourceUrl, e := ossClient.UploadFile(ossFileName, filePath, savePath)
		if e != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + e.Error()
			return
		}

		// 将文件保存到map中（这里主要是为了演示，实际使用中可能不需要）
		fileUrlMap[materialNames[k]] = resourceUrl
	}*/

	err = materialService.BatchAddMaterial(req.MaterialList, classifyId, sysUser.AdminId, sysUser.AdminName)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	msg := "添加成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
}

// Upload
// @Title 上传素材
// @Description 上传素材接口
// @Param	request	body material.AddAndEditSandbox true "type json string"
// @Success 200 {object} material.Material
// @router /upload [post]
func (this *MaterialController) Upload() {
	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
	}

	f, h, err := this.GetFile("file")
	if err != nil {
		br.Msg = "获取资源信息失败"
		br.ErrMsg = "获取资源信息失败,Err:" + err.Error()
		return
	}
	defer f.Close() //关闭上传文件

	// 不依赖于文件扩展名检查文件格式
	fileData, e := ioutil.ReadAll(f)
	if e != nil {
		br.Msg = "上传失败"
		br.ErrMsg = "读取文件失败, Err: " + e.Error()
		return
	}
	pass := filetype.IsImage(fileData)
	if !pass {
		br.Msg = "文件格式有误"
		br.ErrMsg = "文件格式有误"
		return
	}
	ext := path.Ext(h.Filename)
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ext

	// 上传到阿里云
	ossDir := utils.RESOURCE_DIR + "material_dir/"
	savePath := ossDir + time.Now().Format("200601/20060102/") + fileName
	// 上传文件
	resourceUrl, err := services.CommonUploadToOssAndFileName(f, fileName, savePath)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}

	resp := new(models.UploadImgResp)
	resp.ResourceUrl = resourceUrl

	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}