eta_api/services/data/chart_public_classify.go

package data

import (
	"errors"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/utils"
	"fmt"
	"strconv"
	"time"
)

// TODO 移动的时候，获取上下级的分裂

// AddChartPublicClassify
// @Description: 添加公共指标分类
// @author: Roc
// @datetime 2024-12-04 18:00:22
// @param classifyName string
// @param parentId int
// @param source int
// @param sysUserId int
// @param sysUserName string
// @return classifyInfo *data_manage.ChartPublicClassify
// @return err error
// @return errMsg string
func AddChartPublicClassify(classifyName string, parentId, source int, sysUserId int, sysUserName string) (classifyInfo *data_manage.ChartPublicClassify, err error, errMsg string) {
	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	// 校验分类名称相同的数量
	{
		var count int
		count, err = chartPublicClassifyObj.GetChartClassifyCount(classifyName, parentId, source)
		if err != nil {
			errMsg = `判断名称是否已存在失败`
			return
		}
		if count > 0 {
			errMsg = `分类名称已存在，请重新输入`
			err = errors.New(errMsg)
			return
		}
	}

	//获取该层级下最大的排序数
	maxSort, err := GetChartPublicClassifyMaxSort(parentId, source)
	if err != nil {
		errMsg = "获取失败"
		err = errors.New("查询排序信息失败，Err:" + err.Error())
		return
	}
	//查询顶级rootId
	rootId := 0
	var classifyNamePath, classifyIdPath string

	// 层级
	level := 0
	if parentId > 0 {
		parentClassify, tErr := chartPublicClassifyObj.GetChartClassifyById(parentId)
		if tErr != nil {
			if utils.IsErrNoRow(tErr) {
				errMsg = "父级分类不存在"
				err = errors.New(errMsg)
				return
			}
			errMsg = "获取失败"
			err = errors.New("获取分类信息失败，Err:" + tErr.Error())
			return
		}
		level = parentClassify.Level
		rootId = parentClassify.RootId

		classifyNamePath = fmt.Sprint(parentClassify.ChartPublicClassifyNamePath, "|", classifyName)
		classifyIdPath = fmt.Sprint(parentClassify.ChartPublicClassifyIdPath, ",")
	} else {
		classifyNamePath = classifyName
	}

	// 层级校验
	if level > 6 {
		errMsg = fmt.Sprintf("最高只支持添加6级分类")
		return
	}

	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	classifyInfo = &data_manage.ChartPublicClassify{
		//ChartPublicClassifyId:       0,
		Source:                      source,
		ChartPublicClassifyName:     classifyName,
		ParentId:                    parentId,
		HasData:                     0,
		RootId:                      rootId,
		CreateTime:                  time.Now(),
		ModifyTime:                  time.Now(),
		SysUserId:                   sysUserId,
		SysUserRealName:             sysUserName,
		Level:                       level + 1,
		UniqueCode:                  utils.MD5(utils.PUBLIC_CLASSIFY_PREFIX + "_" + timestamp),
		Sort:                        maxSort + 1,
		LastModifyUserId:            sysUserId,
		LastModifyUserRealName:      sysUserName,
		ChartPublicClassifyNamePath: classifyNamePath,
		ChartPublicClassifyIdPath:   "",
	}
	err = classifyInfo.Add()
	if err != nil {
		errMsg = "保存分类失败"
		return
	}

	// 更改分类id完整路径path
	updateCols := []string{"ChartPublicClassifyIdPath"}
	classifyInfo.ChartPublicClassifyIdPath = fmt.Sprint(classifyIdPath, classifyInfo.ChartPublicClassifyId)
	if parentId == 0 { //一级目录的rootId等于自己本身
		classifyInfo.RootId = classifyInfo.ChartPublicClassifyId
		updateCols = append(updateCols, "RootId")

	}
	err = classifyInfo.Update(updateCols)
	if err != nil {
		errMsg = "更新分类失败"
		return
	}

	return
}

// EditChartPublicClassify
// @Description: 编辑指标分类
// @author: Roc
// @datetime 2024-12-05 09:29:38
// @param classifyId int
// @param classifyName string
// @param sysUser *system.Admin
// @return err error
// @return errMsg string
func EditChartPublicClassify(classifyId int, classifyName string, sysUser *system.Admin) (err error, errMsg string) {
	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	item, err := chartPublicClassifyObj.GetChartClassifyById(classifyId)
	if err != nil {
		errMsg = `修改失败`
		return
	}

	// TODO 操作权限校验
	{
	}

	// 需要变更的字段
	updateCols := make([]string, 0)

	// 旧完整路径  ， 新的完整路径
	var oldClassifyNamePath, newClassifyNamePath string

	// 名字相同，那么就直接返回
	if item.ChartPublicClassifyName == classifyName {
		return
	}

	// 判断名称是否已存在
	count, tmpErr := chartPublicClassifyObj.GetChartClassifyCount(classifyName, item.ParentId, item.Source)
	if tmpErr != nil {
		err = tmpErr
		errMsg = "判断名称是否已存在失败"
		return
	}
	if count > 0 {
		errMsg = "分类名称已存在，请重新输入"
		err = errors.New(errMsg)
		return
	}

	// 旧完整路径
	oldClassifyNamePath = item.ChartPublicClassifyNamePath

	if item.ParentId > 0 {
		parentItem, tmpErr := chartPublicClassifyObj.GetChartClassifyById(item.ParentId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		newClassifyNamePath = fmt.Sprint(parentItem.ChartPublicClassifyNamePath, "|", classifyName)
	} else {
		newClassifyNamePath = classifyName
	}

	// 更新自己的信息
	item.ChartPublicClassifyName = classifyName
	item.ChartPublicClassifyNamePath = newClassifyNamePath
	item.LastModifyUserId = sysUser.AdminId
	item.LastModifyUserRealName = sysUser.RealName
	updateCols = append(updateCols, "ChartPublicClassifyName", "ChartPublicClassifyNamePath", "LastModifyUserId", "LastModifyUserRealName")

	// 修改数据
	if len(updateCols) > 0 {
		err = item.UpdateChartClassifyNameAndNamePath(updateCols, oldClassifyNamePath, newClassifyNamePath)
		if err != nil {
			errMsg = "保存失败"
		}
	}

	return
}

// GetChartPublicClassifyMaxSort
// @Description: 获取最大排序值
// @author: Roc
// @datetime 2024-12-04 16:54:57
// @param parentId int
// @param source int
// @return maxSort int
// @return err error
func GetChartPublicClassifyMaxSort(parentId, source int) (maxSort int, err error) {
	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	//获取该层级下最大的排序数
	classifyMaxSort, err := chartPublicClassifyObj.GetChartClassifyMaxSort(parentId, source)
	if err != nil {
		return
	}
	maxSort = classifyMaxSort
	chartMaxSort, err := data_manage.GetChartInfoMaxSortByClassifyId(parentId)
	if err != nil {
		return
	}
	if maxSort < chartMaxSort {
		maxSort = chartMaxSort
	}

	return
}

// DeleteChartPublicClassifyCheck 删除检测
func DeleteChartPublicClassifyCheck(classifyId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, allClassifyIdList []int, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
	// TODO 操作权限校验
	{

	}

	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	// 查找当前分类
	item, tmpErr := chartPublicClassifyObj.GetChartClassifyById(classifyId)
	if tmpErr != nil {
		errMsg = `查找分类失败`
		err = tmpErr
		return
	}

	// 查找分类下所有子分类
	childClassifyIdList, tmpErr := item.GetAllChildClassifyIdList()
	if tmpErr != nil {
		errMsg = `查找下级分类失败`
		err = tmpErr
		return
	}
	allClassifyIdList = childClassifyIdList
	allClassifyIdList = append(allClassifyIdList, item.ChartPublicClassifyId)

	// 判断分类下，是否含有指标
	{
		//判断分类下，是否含有指标
		count, tmpErr := chartPublicClassifyObj.GetChartInfoCountByClassifyIdList(allClassifyIdList)
		if tmpErr != nil {
			errMsg = "删除失败"
			err = errors.New("分类下是否含有指标失败，Err:" + tmpErr.Error())
			return
		}

		if count > 0 {
			deleteStatus = 1
			tipsMsg = "目录关联指标不可删除"
			return
		}
	}

	// 子目录数量校验
	if len(childClassifyIdList) > 0 {
		deleteStatus = 2
		tipsMsg = "确认删除当前目录及包含的子目录吗"
		return
	}

	return
}

// DeleteChartPublicClassify 删除分类/指标
func DeleteChartPublicClassify(classifyId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.ChartInfo, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
	//删除分类校验
	deleteStatus, tipsMsg, allClassifyIdList, _, err, errMsg := DeleteChartPublicClassifyCheck(classifyId, sysUser)
	// 0：可以；2：删除子目录；1：不可删除（有关联指标）
	if deleteStatus == 1 {
		if tipsMsg != `` {
			errMsg = tipsMsg
		}
		if err == nil {
			err = errors.New(errMsg)
		}
		return
	}

	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	err = chartPublicClassifyObj.BatchesDel(allClassifyIdList)
	if err != nil {
		errMsg = "删除失败"
		return
	}

	return
}

// MoveChartClassify 移动指标分类 TODO
//func MoveChartPublicClassify(req data_manage.MoveChartClassifyReq, sysUser *system.Admin, source int) (err error, errMsg string) {
//	// req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
//	classifyId := req.ClassifyId
//	parentClassifyId := req.ParentClassifyId
//	prevClassifyId := req.PrevClassifyId
//	nextClassifyId := req.NextClassifyId
//
//	chartInfoId := req.ChartInfoId
//	prevChartInfoId := req.PrevChartInfoId
//	nextChartInfoId := req.NextChartInfoId
//
//	//首先确定移动的对象是分类还是指标
//	//判断上一个节点是分类还是指标
//	//判断下一个节点是分类还是指标
//	//同时更新分类目录下的分类sort和指标sort
//	//更新当前移动的分类或者指标sort
//
//	var parentChartClassifyInfo *data_manage.ChartClassify
//	if parentClassifyId > 0 {
//		parentChartClassifyInfo, err = data_manage.GetChartClassifyById(parentClassifyId)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
//			return
//		}
//	}
//
//	//如果有传入 上一个兄弟节点分类id
//	var (
//		chartClassifyInfo *data_manage.ChartPublicClassify
//		prevClassify      *data_manage.ChartPublicClassify
//		nextClassify      *data_manage.ChartPublicClassify
//
//		chartInfo     *data_manage.ChartInfo
//		prevChartInfo *data_manage.ChartInfo
//		nextChartInfo *data_manage.ChartInfo
//		prevSort      int
//		nextSort      int
//	)
//
//	obj:= data_manage.ChartPublicClassify{}
//
//	// 移动对象为分类， 判断权限
//	if chartInfoId == 0 {
//		chartClassifyInfo, err = obj.GetChartClassifyById(classifyId)
//		if err != nil {
//			if utils.IsErrNoRow(err) {
//				errMsg = "当前分类不存在"
//				err = errors.New("获取分类信息失败,Err:" + err.Error())
//				return
//			}
//			errMsg = "移动失败"
//			err = errors.New("获取分类信息失败,Err:" + err.Error())
//			return
//		}
//		if chartClassifyInfo.SysUserId != sysUser.AdminId {
//			errMsg = "不是本人目录，您没有操作权限"
//			err = errors.New(errMsg)
//			return
//		}
//		if parentClassifyId > 0 && parentChartClassifyInfo.Level == 6 {
//			errMsg = "最高只支持添加6级分类"
//			err = errors.New(errMsg)
//			return
//		}
//		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
//		exists, e := data_manage.GetChartPublicClassifyByParentIdAndName(source, parentClassifyId, chartClassifyInfo.ChartClassifyName, classifyId)
//		if e != nil && !utils.IsErrNoRow(e) {
//			errMsg = "移动失败"
//			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
//			return
//		}
//		if exists != nil && exists.ChartClassifyId > 0 {
//			errMsg = "移动失败，分类名称已存在"
//			return
//		}
//
//		// 权限校验
//		{
//			// 已授权分类id
//			permissionClassifyIdList, tmpErr := data_manage_permission.GetUserChartClassifyPermissionList(sysUser.AdminId, classifyId)
//			if tmpErr != nil {
//				errMsg = "移动失败"
//				err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error())
//				return
//			}
//			// 数据权限
//			haveOperaAuth := data_manage_permission.CheckChartClassifyPermissionByPermissionIdList(chartClassifyInfo.IsJoinPermission, chartClassifyInfo.ClassifyId, permissionClassifyIdList)
//
//			if chartClassifyInfo.ClassifyType == 0 { // 普通指标
//				button := GetChartClassifyOpButton(sysUser, chartClassifyInfo.SysUserId, haveOperaAuth)
//				if !button.MoveButton {
//					errMsg = "无操作权限"
//					err = errors.New(errMsg)
//					return
//				}
//			} else if chartClassifyInfo.ClassifyType == 1 { // 预测指标
//				button := GetPredictChartClassifyOpButton(sysUser, chartClassifyInfo.SysUserId, haveOperaAuth)
//				if !button.MoveButton {
//					errMsg = "无操作权限"
//					err = errors.New(errMsg)
//					return
//				}
//			}
//		}
//
//	} else {
//		chartInfo, err = data_manage.GetChartInfoById(req.ChartInfoId)
//		if err != nil {
//			if utils.IsErrNoRow(err) {
//				errMsg = "当前指标不存在"
//				err = errors.New("获取分类信息失败,Err:" + err.Error())
//				return
//			}
//			errMsg = "移动失败"
//			err = errors.New("获取分类信息失败,Err:" + err.Error())
//			return
//		}
//
//		if chartInfo.SysUserId != sysUser.AdminId {
//			errMsg = "不是本人指标，您没有操作权限"
//			err = errors.New(errMsg)
//			return
//		}
//
//		if parentClassifyId == 0 {
//			errMsg = "移动失败,指标必须挂在分类下"
//			err = errors.New(errMsg)
//			return
//		}
//
//		var haveOperaAuth bool
//		// 权限校验
//		{
//			haveOperaAuth, err = data_manage_permission.CheckChartPermissionByChartInfoId(chartInfo.ChartInfoId, chartInfo.ClassifyId, chartInfo.IsJoinPermission, sysUser.AdminId)
//			if err != nil {
//				errMsg = "移动失败"
//				err = errors.New("获取指标权限信息失败,Err:" + err.Error())
//				return
//			}
//		}
//
//		// 移动权限校验
//		button := GetChartOpButton(sysUser, chartInfo.SysUserId, chartInfo.ChartType, chartInfo.ChartInfoType, haveOperaAuth)
//		if !button.MoveButton {
//			errMsg = "无操作权限"
//			err = errors.New(errMsg)
//			return
//		}
//	}
//
//	if prevClassifyId > 0 {
//		prevClassify, err = data_manage.GetChartClassifyById(prevClassifyId)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
//			return
//		}
//		prevSort = prevClassify.Sort
//	} else if prevChartInfoId > 0 {
//		prevChartInfo, err = data_manage.GetChartInfoById(prevChartInfoId)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
//			return
//		}
//		prevSort = prevChartInfo.Sort
//	}
//
//	if nextClassifyId > 0 {
//		//下一个兄弟节点
//		nextClassify, err = data_manage.GetChartClassifyById(nextClassifyId)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
//			return
//		}
//		nextSort = nextClassify.Sort
//	} else if nextChartInfoId > 0 {
//		//下一个兄弟节点
//		nextChartInfo, err = data_manage.GetChartInfoById(nextChartInfoId)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
//			return
//		}
//		nextSort = nextChartInfo.Sort
//	}
//
//	err, errMsg = moveChartOrClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
//	return
//}

// moveChartOrClassify 移动指标分类 TODO
//func moveChartOrPublicClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
//
//	if chartClassifyInfo != nil {
//		// 移动分类
//		return moveChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
//	} else {
//		// 移动指标
//		return moveChart(prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
//	}
//
//	return
//}

// moveChart TODO
// @Description: 移动指标
// @author: Roc
// @datetime 2024-11-26 16:07:37
// @param prevClassify *data_manage.ChartClassify
// @param nextClassify *data_manage.ChartClassify
// @param chartInfo *data_manage.ChartInfo
// @param prevChartInfo *data_manage.ChartInfo
// @param nextChartInfo *data_manage.ChartInfo
// @param parentClassifyId int
// @param prevSort int
// @param nextSort int
// @param source int
// @return err error
// @return errMsg string
//func movePublicChart(prevClassify, nextClassify *data_manage.ChartClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
//	updateCol := make([]string, 0)
//
//	if chartInfo == nil {
//		errMsg = "当前指标不存在"
//		err = errors.New(errMsg)
//		return
//	}
//	//如果改变了分类，那么移动该指标数据
//	if chartInfo.ClassifyId != parentClassifyId {
//		chartInfo.ClassifyId = parentClassifyId
//		chartInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "ClassifyId", "ModifyTime")
//	}
//	if prevSort > 0 {
//		//如果是移动在两个兄弟节点之间
//		if nextSort > 0 {
//			//下一个兄弟节点
//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
//			if prevSort == nextSort || prevSort == chartInfo.Sort {
//				//变更兄弟节点的排序
//				updateSortStr := `sort + 2`
//
//				//变更分类
//				if prevClassify != nil {
//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, source)
//				} else {
//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
//				}
//
//				//变更指标
//				if prevChartInfo != nil {
//					//变更兄弟节点的排序
//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
//				} else {
//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
//				}
//			} else {
//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
//				if nextSort-prevSort == 1 {
//					//变更兄弟节点的排序
//					updateSortStr := `sort + 1`
//					//变更分类
//					if prevClassify != nil {
//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, source)
//					} else {
//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
//					}
//
//					//变更指标
//					if prevChartInfo != nil {
//						//变更兄弟节点的排序
//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
//					} else {
//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
//					}
//				}
//			}
//		}
//
//		chartInfo.Sort = prevSort + 1
//		chartInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	} else if prevClassify == nil && nextClassify == nil && prevChartInfo == nil && nextChartInfo == nil && parentClassifyId > 0 {
//		//处理只拖动到目录里，默认放到目录底部的情况
//		var maxSort int
//		maxSort, err = GetChartClassifyMaxSort(parentClassifyId, source)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
//			return
//		}
//		chartInfo.Sort = maxSort + 1 //那就是排在组内最后一位
//		chartInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	} else {
//		// 拖动到父级分类的第一位
//		firstClassify, tmpErr := data_manage.GetFirstChartClassifyByParentId(parentClassifyId)
//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
//			errMsg = "移动失败"
//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
//			return
//		}
//
//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
//			updateSortStr := ` sort + 1 `
//			_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, source)
//			//该分类下的所有指标也需要+1
//			_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
//		} else {
//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
//			firstChart, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
//			if tErr != nil && !utils.IsErrNoRow(tErr) {
//				errMsg = "移动失败"
//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
//				return
//			}
//
//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
//			if firstChart != nil && firstChart.ClassifyId > 0 && firstChart.Sort == 0 {
//				updateSortStr := ` sort + 1 `
//				_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateSortStr)
//				_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
//			}
//		}
//
//		chartInfo.Sort = 0 //那就是排在第一位
//		chartInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	}
//
//	//更新
//	if len(updateCol) > 0 {
//		err = chartInfo.Update(updateCol)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("修改失败,Err:" + err.Error())
//			return
//		}
//	}
//
//	return
//}

// moveChartClassify
// @Description: 移动指标分类
// @author: Roc
// @datetime 2024-11-26 16:07:44
// @param parentChartClassifyInfo *data_manage.ChartClassify
// @param chartClassifyInfo *data_manage.ChartClassify
// @param prevClassify *data_manage.ChartClassify
// @param nextClassify *data_manage.ChartClassify
// @param chartInfo *data_manage.ChartInfo
// @param prevChartInfo *data_manage.ChartInfo
// @param nextChartInfo *data_manage.ChartInfo
// @param parentClassifyId int
// @param prevSort int
// @param nextSort int
// @param source int
// @return err error
// @return errMsg string
//func moveChartPublicClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartClassify, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
//	updateCol := make([]string, 0)
//
//	// 移动对象为分类， 判断分类是否存在
//	oldParentId := chartClassifyInfo.ParentId
//	oldLevel := chartClassifyInfo.Level
//	var classifyIds []int
//	if oldParentId != parentClassifyId {
//		//更新子分类对应的level
//		childList, e, m := GetChildClassifyByClassifyId(chartClassifyInfo.ClassifyId)
//		if e != nil {
//			errMsg = "移动失败"
//			err = errors.New("查询子分类失败,Err:" + e.Error() + m)
//			return
//		}
//
//		if len(childList) > 0 {
//			for _, v := range childList {
//				if v.ClassifyId == chartClassifyInfo.ClassifyId {
//					continue
//				}
//				classifyIds = append(classifyIds, v.ClassifyId)
//			}
//		}
//	}
//	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
//	if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
//		if chartClassifyInfo.Level != parentChartClassifyInfo.Level+1 { //禁止层级调整
//			errMsg = "移动失败"
//			err = errors.New("不支持目录层级变更")
//			return
//		}
//		chartClassifyInfo.ParentId = parentChartClassifyInfo.ClassifyId
//		chartClassifyInfo.RootId = parentChartClassifyInfo.RootId
//		chartClassifyInfo.Level = parentChartClassifyInfo.Level + 1
//		chartClassifyInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
//	} else if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
//		errMsg = "移动失败"
//		err = errors.New("不支持目录层级变更")
//		return
//	}
//
//	if prevSort > 0 {
//		//如果是移动在两个兄弟节点之间
//		if nextSort > 0 {
//			//下一个兄弟节点
//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
//			if prevSort == nextSort || prevSort == chartClassifyInfo.Sort {
//				//变更兄弟节点的排序
//				updateSortStr := `sort + 2`
//
//				//变更分类
//				if prevClassify != nil {
//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, source)
//				} else {
//					_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
//				}
//
//				//变更指标
//				if prevChartInfo != nil {
//					//变更兄弟节点的排序
//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
//				} else {
//					_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
//				}
//			} else {
//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
//				if nextSort-prevSort == 1 {
//					//变更兄弟节点的排序
//					updateSortStr := `sort + 1`
//
//					//变更分类
//					if prevClassify != nil {
//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, source)
//					} else {
//						_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
//					}
//
//					//变更指标
//					if prevChartInfo != nil {
//						//变更兄弟节点的排序
//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
//					} else {
//						_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
//					}
//
//				}
//			}
//		}
//
//		chartClassifyInfo.Sort = prevSort + 1
//		chartClassifyInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	} else if prevClassify == nil && nextClassify == nil && prevChartInfo == nil && nextChartInfo == nil && parentClassifyId > 0 {
//		//处理只拖动到目录里，默认放到目录底部的情况
//		var maxSort int
//		maxSort, err = GetChartClassifyMaxSort(parentClassifyId, source)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("查询组内排序信息失败,Err:" + err.Error())
//			return
//		}
//		chartClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
//		chartClassifyInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	} else {
//		// 拖动到父级分类的第一位
//		firstClassify, tmpErr := data_manage.GetFirstChartClassifyByParentId(parentClassifyId)
//		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
//			errMsg = "移动失败"
//			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
//			return
//		}
//
//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
//		if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 {
//			updateSortStr := ` sort + 1 `
//			_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, source)
//			//该分类下的所有指标也需要+1
//			_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
//		} else {
//			//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
//			firstChart, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
//			if tErr != nil && !utils.IsErrNoRow(tErr) {
//				errMsg = "移动失败"
//				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
//				return
//			}
//
//			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
//			if firstChart != nil && firstChart.ChartClassifyId > 0 && firstChart.Sort == 0 {
//				updateSortStr := ` sort + 1 `
//				_ = data_manage.UpdateChartInfoSortByClassifyId(parentClassifyId, 0, firstChart.ChartInfoId-1, updateSortStr)
//				_ = data_manage.UpdateChartClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
//			}
//		}
//
//		chartClassifyInfo.Sort = 0 //那就是排在第一位
//		chartClassifyInfo.ModifyTime = time.Now()
//		updateCol = append(updateCol, "Sort", "ModifyTime")
//	}
//
//	//更新
//	if len(updateCol) > 0 {
//		err = chartClassifyInfo.Update(updateCol)
//		if err != nil {
//			errMsg = "移动失败"
//			err = errors.New("修改失败,Err:" + err.Error())
//			return
//		}
//		//更新对应分类的root_id和层级
//		if oldParentId != parentClassifyId {
//			if len(classifyIds) > 0 {
//				levelStep := chartClassifyInfo.Level - oldLevel
//				err = data_manage.UpdateChartClassifyChildByParentClassifyId(classifyIds, chartClassifyInfo.RootId, levelStep)
//				if err != nil {
//					errMsg = "移动失败"
//					err = errors.New("更新子分类失败,Err:" + err.Error())
//					return
//				}
//			}
//		}
//
//	}
//
//	return
//}