package data

import (
	"errors"
	"eta/eta_api/models/data_manage"
	dataSourceModel "eta/eta_api/models/data_source"
	"eta/eta_api/models/system"
	"eta/eta_api/services/elastic"
	"eta/eta_api/utils"
	"fmt"
	"time"
)

// GetRadishResearchClassifyTreeRecursive 递归获取分类树形结构
func GetRadishResearchClassifyTreeRecursive(list []*data_manage.BaseFromRadishResearchClassifyItem, parentId int) []*data_manage.BaseFromRadishResearchClassifyItem {
	res := make([]*data_manage.BaseFromRadishResearchClassifyItem, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			t := GetRadishResearchClassifyTreeRecursive(list, v.ClassifyId)
			v.Children = nil // 这一步是方便前端组件判断null...
			if len(t) > 0 {
				v.Children = t
			}
			res = append(res, v)
		}
	}
	return res
}

// RadishResearchMoveClassify 移动指标分类
func RadishResearchMoveClassify(req data_manage.BaseFromRadishResearchClassifyMoveReq, sysUser *system.Admin) (err error, errMsg string) {
	// req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
	classifyId := req.ClassifyId
	parentClassifyId := req.ParentClassifyId
	prevClassifyId := req.PrevClassifyId
	nextClassifyId := req.NextClassifyId

	itemId := req.ItemId
	prevItemId := req.PrevItemId
	nextItemId := req.NextItemId

	//首先确定移动的对象是分类还是指标
	//判断上一个节点是分类还是指标
	//判断下一个节点是分类还是指标
	//同时更新分类目录下的分类sort和指标sort
	//更新当前移动的分类或者指标sort

	var parentEdbClassifyInfo *data_manage.BaseFromRadishResearchClassify
	if parentClassifyId > 0 {
		parentEdbClassifyInfo, err = data_manage.GetRadishResearchClassifyById(parentClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
			return
		}
	}

	//如果有传入 上一个兄弟节点分类id
	var (
		edbClassifyInfo *data_manage.BaseFromRadishResearchClassify
		prevClassify    *data_manage.BaseFromRadishResearchClassify
		nextClassify    *data_manage.BaseFromRadishResearchClassify

		edbInfo     *data_manage.BaseFromRadishResearchIndex
		prevEdbInfo *data_manage.BaseFromRadishResearchIndex
		nextEdbInfo *data_manage.BaseFromRadishResearchIndex
		prevSort    int
		nextSort    int
	)

	// 移动对象为分类， 判断权限
	if itemId == 0 {
		edbClassifyInfo, err = data_manage.GetRadishResearchClassifyById(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 parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 {
			errMsg = "最高只支持添加6级分类"
			err = errors.New(errMsg)
			return
		}
		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
		exists, e := data_manage.GetRadishResearchClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.ClassifyName, classifyId)
		if e != nil && !utils.IsErrNoRow(e) {
			errMsg = "移动失败"
			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
			return
		}
		if exists != nil && exists.ClassifyId > 0 {
			errMsg = "移动失败，分类名称已存在"
			return
		}

	} else {
		edbInfo, err = data_manage.GetRadishResearchIndexById(req.ItemId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "当前指标不存在"
				err = errors.New("获取分类信息失败,Err:" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取分类信息失败,Err:" + err.Error())
			return
		}
		if edbInfo != nil && edbInfo.BaseFromRadishResearchIndexId <= 0 {
			errMsg = "当前指标不存在"
			err = errors.New("获取指标信息失败, Err:" + err.Error())
			return
		}
		if parentClassifyId == 0 {
			errMsg = "移动失败,指标必须挂在分类下"
			err = errors.New(errMsg)
			return
		}

		//// 移动权限校验
		//button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
		//if !button.MoveButton {
		//	errMsg = "无操作权限"
		//	err = errors.New(errMsg)
		//	return
		//}
	}

	if prevClassifyId > 0 {
		prevClassify, err = data_manage.GetRadishResearchClassifyById(prevClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevClassify.Sort
	} else if prevItemId > 0 {
		prevEdbInfo, err = data_manage.GetRadishResearchIndexById(prevItemId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevEdbInfo.Sort
	}

	if nextClassifyId > 0 {
		//下一个兄弟节点
		nextClassify, err = data_manage.GetRadishResearchClassifyById(nextClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextClassify.Sort
	} else if nextItemId > 0 {
		//下一个兄弟节点
		nextEdbInfo, err = data_manage.GetRadishResearchIndexById(nextItemId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextEdbInfo.Sort
	}

	err, errMsg = radishResearchMoveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort)
	return
}

// radishResearchMoveEdbClassify 移动指标分类
func radishResearchMoveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.BaseFromRadishResearchClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.BaseFromRadishResearchIndex, parentClassifyId int, prevSort, nextSort int) (err error, errMsg string) {
	updateCol := make([]string, 0)
	var moveParent bool  // 是否移动分类的父级目录
	var moveParentId int // 被改变父级分类的目录ID

	indexOb := new(data_manage.BaseFromRadishResearchIndex)

	// 移动对象为分类， 判断分类是否存在
	if edbClassifyInfo != nil {
		oldParentId := edbClassifyInfo.ParentId
		oldLevel := edbClassifyInfo.Level
		var classifyIds []int
		if oldParentId != parentClassifyId {
			//更新子分类对应的level
			childList, e, m := GetRadishResearchChildClassifyByClassifyId(edbClassifyInfo.BaseFromRadishResearchClassifyId)
			if e != nil {
				errMsg = "移动失败"
				err = errors.New("查询子分类失败,Err:" + e.Error() + m)
				return
			}

			if len(childList) > 0 {
				for _, v := range childList {
					if v.BaseFromRadishResearchClassifyId == edbClassifyInfo.BaseFromRadishResearchClassifyId {
						continue
					}
					classifyIds = append(classifyIds, v.BaseFromRadishResearchClassifyId)
				}
			}
		}
		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
		if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
			if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整
				errMsg = "移动失败"
				err = errors.New("不支持目录层级变更")
				return
			}
			edbClassifyInfo.ParentId = parentEdbClassifyInfo.BaseFromRadishResearchClassifyId
			edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId
			edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
			edbClassifyInfo.LevelPath = fmt.Sprintf("%s,%d", parentEdbClassifyInfo.LevelPath, edbClassifyInfo.BaseFromRadishResearchClassifyId) // 注意更新层级路径
			edbClassifyInfo.ModifyTime = time.Now()
			// 更改层级路径
			edbClassifyInfo.LevelPath = fmt.Sprintf("%s,%d", parentEdbClassifyInfo.LevelPath, edbClassifyInfo.BaseFromRadishResearchClassifyId)
			updateCol = append(updateCol, "ParentId", "RootId", "Level", "LevelPath", "ModifyTime", "LevelPath")
			moveParent = true
			moveParentId = edbClassifyInfo.BaseFromRadishResearchClassifyId
		} else if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
			errMsg = "移动失败"
			err = errors.New("不支持目录层级变更")
			return
		}

		if prevSort > 0 {
			//如果是移动在两个兄弟节点之间
			if nextSort > 0 {
				//下一个兄弟节点
				//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
				if prevSort == nextSort || prevSort == edbClassifyInfo.Sort {
					//变更兄弟节点的排序
					updateSortStr := `sort + 2`

					//变更分类
					if prevClassify != nil {
						_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, prevClassify.BaseFromRadishResearchClassifyId, prevClassify.Sort, updateSortStr)
					} else {
						_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
					}

					//变更指标
					if prevEdbInfo != nil {
						//变更兄弟节点的排序
						_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.BaseFromRadishResearchIndexId, updateSortStr)
					} else {
						_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
					}
				} else {
					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
					if nextSort-prevSort == 1 {
						//变更兄弟节点的排序
						updateSortStr := `sort + 1`

						//变更分类
						if prevClassify != nil {
							_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, prevClassify.BaseFromRadishResearchClassifyId, prevSort, updateSortStr)
						} else {
							_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
						}

						//变更指标
						if prevEdbInfo != nil {
							//变更兄弟节点的排序
							_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.BaseFromRadishResearchIndexId, updateSortStr)
						} else {
							_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
						}

					}
				}
			}

			edbClassifyInfo.Sort = prevSort + 1
			edbClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
			//处理只拖动到目录里，默认放到目录底部的情况
			var maxSort int
			maxSort, err = GetRadishResearchClassifyMaxSort(parentClassifyId)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("查询组内排序信息失败,Err:" + err.Error())
				return
			}
			edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
			edbClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else {
			// 拖动到父级分类的第一位
			firstClassify, tmpErr := data_manage.GetFirstRadishResearchClassifyByParentId(parentClassifyId)
			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
				errMsg = "移动失败"
				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
				return
			}

			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
			if firstClassify != nil && firstClassify.Sort == 0 {
				updateSortStr := ` sort + 1 `
				_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, firstClassify.BaseFromRadishResearchClassifyId-1, 0, updateSortStr)
				//该分类下的所有指标也需要+1
				_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
			} else {
				//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
				firstEdb, tErr := data_manage.GetFirstRadishResearchIndexByClassifyId(parentClassifyId)
				if tErr != nil && !utils.IsErrNoRow(tErr) {
					errMsg = "移动失败"
					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
					return
				}

				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
				if firstEdb != nil && firstEdb.Sort == 0 {
					updateSortStr := ` sort + 1 `
					_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, 0, firstEdb.BaseFromRadishResearchIndexId-1, updateSortStr)
					_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr)
				}
			}

			edbClassifyInfo.Sort = 0 //那就是排在第一位
			edbClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		}

		//更新
		if len(updateCol) > 0 {
			err = edbClassifyInfo.Update(updateCol)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("修改失败,Err:" + err.Error())
				return
			}
			//更新对应分类的root_id和层级
			if oldParentId != parentClassifyId {
				if len(classifyIds) > 0 {
					levelStep := edbClassifyInfo.Level - oldLevel
					err = data_manage.UpdateRadishResearchClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep)
					if err != nil {
						errMsg = "移动失败"
						err = errors.New("更新子分类失败,Err:" + err.Error())
						return
					}
				}
			}
		}
	} else {
		if edbInfo == nil {
			errMsg = "当前指标不存在"
			err = errors.New(errMsg)
			return
		}
		//如果改变了分类，那么移动该指标数据
		if edbInfo.ClassifyId != parentClassifyId {
			edbInfo.ClassifyId = parentClassifyId
			edbInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, indexOb.Cols().ClassifyId, indexOb.Cols().ModifyTime)
		}
		if prevSort > 0 {
			//如果是移动在两个兄弟节点之间
			if nextSort > 0 {
				//下一个兄弟节点
				//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
				if prevSort == nextSort || prevSort == edbInfo.Sort {
					//变更兄弟节点的排序
					updateSortStr := `sort + 2`

					//变更分类
					if prevClassify != nil {
						_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, prevClassify.BaseFromRadishResearchClassifyId, prevClassify.Sort, updateSortStr)
					} else {
						_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
					}

					//变更指标
					if prevEdbInfo != nil {
						//变更兄弟节点的排序
						_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.BaseFromRadishResearchIndexId, updateSortStr)
					} else {
						_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
					}
				} else {
					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
					if nextSort-prevSort == 1 {
						//变更兄弟节点的排序
						updateSortStr := `sort + 1`
						//变更分类
						if prevClassify != nil {
							_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, prevClassify.BaseFromRadishResearchClassifyId, prevSort, updateSortStr)
						} else {
							_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
						}

						//变更指标
						if prevEdbInfo != nil {
							//变更兄弟节点的排序
							_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.BaseFromRadishResearchIndexId, updateSortStr)
						} else {
							_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
						}
					}
				}
			}

			edbInfo.Sort = prevSort + 1
			edbInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, indexOb.Cols().Sort, indexOb.Cols().ModifyTime)
		} else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
			//处理只拖动到目录里，默认放到目录底部的情况
			var maxSort int
			classifyOb := new(data_manage.BaseFromRadishResearchClassify)
			maxSort, err = classifyOb.GetSortMax(parentClassifyId)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("查询组内排序信息失败,Err:" + err.Error())
				return
			}
			edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位
			edbInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, indexOb.Cols().Sort, indexOb.Cols().ModifyTime)
		} else {
			// 拖动到父级分类的第一位
			firstClassify, tmpErr := data_manage.GetFirstRadishResearchClassifyByParentId(parentClassifyId)
			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
				errMsg = "移动失败"
				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
				return
			}

			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
			if firstClassify != nil && firstClassify.Sort == 0 {
				updateSortStr := ` sort + 1 `
				_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, firstClassify.BaseFromRadishResearchClassifyId-1, 0, updateSortStr)
				//该分类下的所有指标也需要+1
				_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
			} else {
				//如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序
				firstEdb, tErr := data_manage.GetFirstRadishResearchIndexByClassifyId(parentClassifyId)
				if tErr != nil && !utils.IsErrNoRow(tErr) {
					errMsg = "移动失败"
					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
					return
				}

				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
				if firstEdb != nil && firstEdb.Sort == 0 {
					updateSortStr := ` sort + 1 `
					_ = data_manage.UpdateRadishResearchIndexSortByClassifyId(parentClassifyId, 0, firstEdb.BaseFromRadishResearchIndexId-1, updateSortStr)
					_ = data_manage.UpdateRadishResearchClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr)
				}
			}

			edbInfo.Sort = 0 //那就是排在第一位
			edbInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, indexOb.Cols().Sort, indexOb.Cols().ModifyTime)
		}

		//更新
		if len(updateCol) > 0 {
			err = edbInfo.Update(updateCol)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("修改失败,Err:" + err.Error())
				return
			}

			// 更新ES
			go func() {
				indexItem := new(dataSourceModel.SearchDataSource)
				indexItem.PrimaryId = edbInfo.BaseFromRadishResearchIndexId
				indexItem.IndexCode = edbInfo.IndexCode
				indexItem.IndexName = edbInfo.IndexName
				indexItem.ClassifyId = edbInfo.ClassifyId
				indexItem.Unit = edbInfo.Unit
				indexItem.Frequency = edbInfo.Frequency
				indexItem.StartDate = edbInfo.StartDate.Format(utils.FormatDate)
				indexItem.EndDate = edbInfo.EndDate.Format(utils.FormatDate)
				indexItem.LatestValue = fmt.Sprint(edbInfo.LatestValue)
				indexItem.Source = utils.DATA_SOURCE_RADISH_RESEARCH
				indexItem.SourceName = utils.DATA_SOURCE_NAME_RADISH_RESEARCH
				indexItem.IsDeleted = 0
				indexItem.CreateTime = edbInfo.CreateTime.Format(utils.FormatDateTime)
				indexItem.ModifyTime = edbInfo.ModifyTime.Format(utils.FormatDateTime)

				docId := fmt.Sprintf("%d-%d", utils.DATA_SOURCE_RADISH_RESEARCH, edbInfo.BaseFromRadishResearchIndexId)
				if e := elastic.EsAddOrEditDataSourceIndex(utils.EsDataSourceIndexName, docId, indexItem); e != nil {
					utils.FileLog.Warning("RadishResearch-写入指标ES失败, %v", e)
					return
				}
			}()
		}
	}

	// 更新子分类的LevelPath
	if moveParent {
		UpdateRadishResearchClassifyLevelPathRecursive(moveParentId)
	}
	return
}

func GetRadishResearchChildClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.BaseFromRadishResearchClassify, err error, errMsg string) {
	//判断是否是挂在顶级目录下
	targetClassify, err := data_manage.GetRadishResearchClassifyById(targetClassifyId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "当前分类不存在"
			err = errors.New(errMsg)
			return
		}
		errMsg = "获取失败"
		err = errors.New("获取分类信息失败，Err:" + err.Error())
		return
	}
	orderStr := ` order by level asc, sort asc, base_from_radish_research_classify_id asc`
	tmpList, err := data_manage.GetRadishResearchClassifyByRootIdLevel(targetClassify.RootId, orderStr)
	if err != nil && !utils.IsErrNoRow(err) {
		errMsg = "获取失败"
		err = errors.New("获取数据失败，Err:" + err.Error())
		return
	}
	idMap := make(map[int]struct{})
	if len(tmpList) > 0 {
		for _, v := range tmpList {
			if v.BaseFromRadishResearchClassifyId == targetClassify.BaseFromRadishResearchClassifyId {
				idMap[v.BaseFromRadishResearchClassifyId] = struct{}{}
			}
		}
		for _, v := range tmpList {
			if _, ok := idMap[v.ParentId]; ok {
				idMap[v.BaseFromRadishResearchClassifyId] = struct{}{}
			}
		}
		for _, v := range tmpList {
			if _, ok := idMap[v.BaseFromRadishResearchClassifyId]; ok {
				targetItem := new(data_manage.BaseFromRadishResearchClassify)
				targetItem.BaseFromRadishResearchClassifyId = v.BaseFromRadishResearchClassifyId
				targetItem.ParentId = v.ParentId
				targetItem.RootId = v.RootId
				//targetItem.UniqueCode = v.UniqueCode
				targetItem.Level = v.Level
				targetItem.ClassifyName = v.ClassifyName
				//targetItem.IsJoinPermission = v.IsJoinPermission
				targetList = append(targetList, targetItem)
			}
		}
	}

	return
}

func GetRadishResearchClassifyMaxSort(parentId int) (maxSort int, err error) {
	//获取该层级下最大的排序数
	classifyOb := new(data_manage.BaseFromRadishResearchClassify)
	classifyMaxSort, err := classifyOb.GetSortMax(parentId)
	if err != nil {
		return
	}
	maxSort = classifyMaxSort
	edbMaxSort, err := data_manage.GetRadishResearchIndexMaxSortByClassifyId(parentId)
	if err != nil {
		return
	}
	if maxSort < edbMaxSort {
		maxSort = edbMaxSort
	}
	return
}

// UpdateRadishResearchClassifyLevelPathRecursive 分类父级ID变更后, 递归更新分类LevelPath
func UpdateRadishResearchClassifyLevelPathRecursive(parentId int) {
	fmt.Println("ParentId", parentId)
	classifyOb := new(data_manage.BaseFromRadishResearchClassify)
	cond := fmt.Sprintf(` AND %s = ?`, classifyOb.Cols().ParentId)
	pars := make([]interface{}, 0)
	pars = append(pars, parentId)
	classifies, e := classifyOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		utils.FileLog.Warning("UpdateRadishResearchClassifyLevelPathRecursive, errMsg: %v", e)
		return
	}
	if len(classifies) == 0 {
		return
	}

	// 批量更新子分类的LevelPath
	parentClassify, e := classifyOb.GetItemById(parentId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			return
		}
		utils.FileLog.Warning("UpdateRadishResearchClassifyLevelPathRecursive, parent errMsg: %v", e)
		return
	}
	if parentClassify != nil && parentClassify.BaseFromRadishResearchClassifyId <= 0 {
		return
	}

	// 继续递归处理
	for _, v := range classifies {
		e = classifyOb.UpdateLevelPath(v.BaseFromRadishResearchClassifyId, fmt.Sprintf("%s,%d", parentClassify.LevelPath, v.BaseFromRadishResearchClassifyId))
		if e != nil {
			utils.FileLog.Warning("UpdateRadishResearchClassifyLevelPathRecursive, update errMsg: %v", e)
			continue
		}
		UpdateRadishResearchClassifyLevelPathRecursive(v.BaseFromRadishResearchClassifyId)
	}
	return
}