eta_api/services/material/material.go

package materialService

import (
	"eta/eta_api/models"
	"eta/eta_api/models/material"
	"eta/eta_api/models/system"
	_interface "eta/eta_api/services/interface"
	"eta/eta_api/utils"
	"fmt"
	"strings"
	"time"
)

func materialClassifyHaveChild(allNode []*material.MaterialClassifyItems, node *material.MaterialClassifyItems) (childs []*material.MaterialClassifyItems, yes bool) {
	for _, v := range allNode {
		if v.ParentId == node.ClassifyId {
			childs = append(childs, v)
		}
	}
	if len(childs) > 0 {
		yes = true
	}
	return
}

func MaterialClassifyItemsMakeTree(sysUser *system.Admin, allNode []*material.MaterialClassifyItems, node *material.MaterialClassifyItems) {

	childs, _ := materialClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
	if len(childs) > 0 {

		node.Children = append(node.Children, childs[0:]...) //添加子节点
		for _, v := range childs {                           //查询子节点的子节点，并添加到子节点
			_, has := materialClassifyHaveChild(allNode, v)
			if has {
				MaterialClassifyItemsMakeTree(sysUser, allNode, v) //递归添加节点
			} else {
				childrenArr := make([]*material.MaterialClassifyItems, 0)
				v.Children = childrenArr
			}
		}
	} else {
		childrenArr := make([]*material.MaterialClassifyItems, 0)
		node.Children = childrenArr
	}
}

// GetMaterialClassifyListForMe 获取我创建的素材
func GetMaterialClassifyListForMe(adminInfo system.Admin, resp *material.MaterialClassifyListResp, classifyId int) (errMsg string, err error) {

	classifyAll, err := material.GetMaterialClassifyByParentId(classifyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		errMsg = "获取失败"
		return
	}
	nodeAll := make([]*material.MaterialClassifyItems, 0)
	for k := range classifyAll {
		rootNode := classifyAll[k]
		MaterialClassifyItemsMakeTree(&adminInfo, classifyAll, rootNode)
		nodeAll = append(nodeAll, rootNode)
	}
	resp.AllNodes = nodeAll
	return
}

func BatchAddMaterial(materialMap map[string]string, classifyId, opUserId int, opUserName string) (err error) {
	materialList := make([]*material.Material, 0)
	sort, err := material.GetMaterialMaxSort()
	if err != nil {
		return
	}
	for k, v := range materialMap {
		sort = sort + 1
		materialList = append(materialList, &material.Material{
			MaterialName: k,
			ImgUrl:       v,
			SysUserId:    opUserId,
			SysUserName:  opUserName,
			ModifyTime:   time.Now(),
			CreateTime:   time.Now(),
			ClassifyId:   classifyId,
			Sort:         sort,
		})
	}
	if len(materialList) > 0 {
		err = material.AddMultiMaterial(materialList)
	}
	return
}

// AddMaterial 新增素材
func AddMaterial(req material.AddAndEditMaterial, opUserId int, opUserName string) (resp *material.MaterialSaveResp, err error) {
	resp = new(material.MaterialSaveResp)
	//素材主表信息
	materialInfo := &material.Material{
		MaterialName: utils.TrimStr(req.MaterialName),
		ImgUrl:       utils.TrimStr(req.ImgUrl),
		SysUserId:    opUserId,
		SysUserName:  opUserName,
		ModifyTime:   time.Now(),
		CreateTime:   time.Now(),
		ClassifyId:   req.ClassifyId,
		Sort:         0,
	}

	//新增素材
	id, err := material.AddMaterial(materialInfo)
	if err != nil {
		return
	}
	materialInfo.MaterialId = int(id)
	resp.Material = materialInfo
	return
}

func MaterialItemsMakeTree(allNode []*material.MaterialClassifyItems, sandListMap map[int][]*material.MaterialClassifyItems, classifyId int) (nodeAll []*material.MaterialClassifyItems) {
	for k := range allNode {
		if len(allNode[k].Children) > 0 {
			MaterialItemsMakeTree(allNode[k].Children, sandListMap, classifyId)
			allNode = append(allNode, sandListMap[allNode[k].ParentId]...)
			nodeAll = allNode
		} else if k == len(allNode)-1 {
			allNode = append(allNode, sandListMap[allNode[k].ParentId]...)
			nodeAll = allNode
		}
	}
	if len(allNode) == 0 {
		nodeAll = append(nodeAll, sandListMap[classifyId]...)
	}
	return
}

func MaterialClassifyHaveChild(allNode []*material.MaterialClassifyItems, node *material.MaterialClassifyItems) (childs []*material.MaterialClassifyItems, yes bool) {
	for _, v := range allNode {
		if v.ParentId == node.ClassifyId {
			childs = append(childs, v)
		}
	}
	if len(childs) > 0 {
		yes = true
	}
	return
}

func MaterialClassifyItemsMakeTreeV2(sysUser *system.Admin, allNode []*material.MaterialClassifyItems, node *material.MaterialClassifyItems) {

	childs, _ := materialClassifyHaveChildV2(allNode, node) //判断节点是否有子节点并返回
	if len(childs) > 0 {
		node.Children = append(node.Children, childs[0:]...) //添加子节点
		for _, v := range childs {                           //查询子节点的子节点，并添加到子节点
			_, has := materialClassifyHaveChildV2(allNode, v)
			if has {
				MaterialClassifyItemsMakeTreeV2(sysUser, allNode, v) //递归添加节点
			}
		}
	}
}

func materialClassifyHaveChildV2(allNode []*material.MaterialClassifyItems, node *material.MaterialClassifyItems) (childs []*material.MaterialClassifyItems, yes bool) {
	for _, v := range allNode {
		if v.ParentId == node.ClassifyId && node.ClassifyId == 0 {
			childs = append(childs, v)
		}
	}
	if len(childs) > 0 {
		yes = true
	}
	return
}

// DeleteMaterial 删除素材
func DeleteMaterial(materialId int) (err error) {
	// 获取素材主表信息
	/*materialInfo, err := materialId.dele(materialId)
	if err != nil {
		return
	}

	materialInfo.IsDelete = 1
	var updateMaterialColumn = []string{"IsDelete"}
	err = materialInfo.Update(updateMaterialColumn)*/
	return
}

func MoveMaterialClassify(classifyInfo *material.MaterialClassify, req *material.MoveMaterialClassifyReq) (err error, errMsg string) {
	nodeMove := models.SingleMoveNodeReq{}
	nodeMove.NodeId = req.ClassifyId
	nodeMove.ParentNodeId = req.ParentClassifyId
	nodeMove.PrevNodeId = req.PrevClassifyId
	nodeMove.NextNodeId = req.NextClassifyId

	materialClassifyMove := new(ClassifyMove)

	nodeInfo, updateCol, err, errMsg := _interface.MoveSingleNode(materialClassifyMove, nodeMove)
	if err != nil {
		return
	}
	oldParentId := classifyInfo.ParentId
	oldLevelPath := classifyInfo.LevelPath
	if len(updateCol) > 0 {
		classifyInfo.Sort = nodeInfo.Sort
		classifyInfo.ModifyTime = nodeInfo.ModifyTime
		classifyInfo.ParentId = nodeInfo.ParentId

		levelPath := ""
		if classifyInfo.ParentId != oldParentId {
			//查找父级分类
			parentClassify, e := material.GetMaterialClassifyById(classifyInfo.ParentId)
			if e != nil {
				errMsg = "获取父级分类失败"
				err = fmt.Errorf("获取父级分类失败，Err:" + e.Error())
				return
			}
			levelPath = fmt.Sprintf("%s,%d", parentClassify.LevelPath, classifyInfo.ClassifyId)
		}
		classifyInfo.LevelPath = levelPath
		updateCol = append(updateCol, "LevelPath")
		err = classifyInfo.Update(updateCol)
		if err != nil {
			err = fmt.Errorf("修改失败,Err:" + err.Error())
			return
		}

		if classifyInfo.ParentId != oldParentId {
			tmpList, e := material.GetMaterialClassifyByLevelPath(oldLevelPath)
			if e != nil {
				err = fmt.Errorf("保存分类失败,Err:" + e.Error())
				return
			}
			// 把原先的父级levePath，替换成最新的父级序列
			for _, tmp := range tmpList {
				//获取字符串前缀的位置
				after, _ := strings.CutPrefix(tmp.LevelPath, oldLevelPath)
				fmt.Println("after", after)
				// 拼接字符串
				if after != "" {
					tmp.LevelPath = levelPath + after
					tmp.ModifyTime = time.Now()
					e = tmp.Update([]string{"LevelPath", "ModifyTime"})
					if e != nil {
						err = fmt.Errorf("修改子分类,Err:" + e.Error())
						return
					}
				}
			}
		}
	}
	return
}

type ClassifyMove struct{}

func (m *ClassifyMove) GetNodeInfoById(nodeId int) (nodeInfo *models.NodeInfo, err error) {
	classifyInfo, err := material.GetMaterialClassifyById(nodeId)
	if err != nil {
		return
	}
	nodeInfo = &models.NodeInfo{
		NodeId:     classifyInfo.ClassifyId,
		NodeName:   classifyInfo.ClassifyName,
		ParentId:   classifyInfo.ParentId,
		Level:      classifyInfo.Level,
		Sort:       classifyInfo.Sort,
		ModifyTime: classifyInfo.ModifyTime,
	}
	return
}

func (m *ClassifyMove) UpdateNodeInfoSortByParentIdAndSource(parentNodeId, nodeId, prevNodeSort int, updateSortStr string, nodeType int) (err error) {
	err = material.UpdateMaterialClassifySortByParentId(parentNodeId, nodeId, prevNodeSort, updateSortStr)
	return
}

func (m *ClassifyMove) GetNodeMaxSort(parentId, nodeType int) (maxSort int, err error) {
	maxSort, err = material.GetMaterialClassifyMaxSort(parentId)
	return
}

func (m *ClassifyMove) GetFirstNodeInfoByParentId(parentId int) (nodeInfo *models.NodeInfo, err error) {
	classifyInfo, err := material.GetFirstMaterialClassifyByParentId(parentId)
	if err != nil {
		return
	}
	nodeInfo = &models.NodeInfo{
		NodeId:     classifyInfo.ClassifyId,
		NodeName:   classifyInfo.ClassifyName,
		ParentId:   classifyInfo.ParentId,
		Level:      classifyInfo.Level,
		Sort:       classifyInfo.Sort,
		ModifyTime: classifyInfo.ModifyTime,
	}
	return
}