Merge branch 'feature/eta_1.6.3' into debug

controllers/data_manage/correlation/correlation_chart_classify.go

@@ -545,10 +545,12 @@ func (this *CorrelationChartClassifyController) DeleteChartClassify() {
 func (this *CorrelationChartClassifyController) ChartClassifyMove() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
 		this.Data["json"] = br
 		this.ServeJSON()
 	}()
-
 	sysUser := this.SysUser
 	if sysUser == nil {
 		br.Msg = "请登录"
@@ -556,7 +558,6 @@ func (this *CorrelationChartClassifyController) ChartClassifyMove() {
 		br.Ret = 408
 		return
 	}
-
 	var req data_manage.MoveChartClassifyReq
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
@@ -564,12 +565,30 @@ func (this *CorrelationChartClassifyController) ChartClassifyMove() {
 		br.ErrMsg = "参数解析失败，Err:" + err.Error()
 		return
 	}
+	//if req.ClassifyId <= 0 && req.ChartInfoId <= 0 {
+	//	br.Msg = "参数错误"
+	//	br.ErrMsg = "请选择拖动目标，分类目录或者指标"
+	//	return
+	//}
+
+	//err, errMsg := data.MoveChartClassify(req, sysUser, utils.CHART_SOURCE_CORRELATION)
+	//if errMsg != `` {
+	//	br.Msg = errMsg
+	//	br.ErrMsg = errMsg
+	//	if err != nil {
+	//		br.ErrMsg = err.Error()
+	//	} else {
+	//		br.IsSendEmail = false
+	//	}
+	//	return
+	//}
 
 	if req.ClassifyId <= 0 {
 		br.Msg = "参数错误"
 		br.ErrMsg = "分类id小于等于0"
 		return
 	}
+
 	//判断分类是否存在
 	chartClassifyInfo, err := data_manage.GetChartClassifyById(req.ClassifyId)
 	if err != nil {

controllers/data_manage/correlation/correlation_chart_info.go

@@ -2531,7 +2531,7 @@ func (this *CorrelationChartInfoController) MultiFactorDetail() {
 	}
 
 	// 系列信息
-	seriesItems := make([]*data_manage.FactorEdbSeriesItem, 0)
+	seriesDetails := make([]*data_manage.FactorEdbSeriesDetail, 0)
 	{
 		seriesOb := new(data_manage.FactorEdbSeries)
 		cond := fmt.Sprintf(" AND %s IN (%s)", seriesOb.Cols().PrimaryId, utils.GetOrmInReplace(len(seriesIds)))
@@ -2544,7 +2544,10 @@ func (this *CorrelationChartInfoController) MultiFactorDetail() {
 			return
 		}
 		for _, v := range list {
-			seriesItems = append(seriesItems, v.Format2Item())
+			seriesDetails = append(seriesDetails, &data_manage.FactorEdbSeriesDetail{
+				FactorEdbSeriesItem: v.Format2Item(),
+				EdbMappings:         make([]*data_manage.FactorEdbSeriesMappingItem, 0),
+			})
 		}
 	}
 
@@ -2587,6 +2590,8 @@ func (this *CorrelationChartInfoController) MultiFactorDetail() {
 	}
 
 	// 相关性矩阵
+	seriesEdb := make(map[int][]*data_manage.FactorEdbSeriesMappingItem)
+	var matrixItems []data_manage.FactorEdbSeriesCorrelationMatrixItem
 	for _, v := range edbMappings {
 		edbItem := edbIdItem[v.EdbInfoId]
 		if edbItem == nil {
@@ -2610,16 +2615,33 @@ func (this *CorrelationChartInfoController) MultiFactorDetail() {
 		item.Values = values
 		s := fmt.Sprintf("%d-%d", v.FactorEdbSeriesId, v.EdbInfoId)
 		item.Used = factorUsed[s]
-		// TODO:指标来源名称
+		item.SourceName = edbItem.SourceName
+		matrixItems = append(matrixItems, item)
+
+		// 系列关联的指标详情
+		if seriesEdb[v.FactorEdbSeriesId] == nil {
+			seriesEdb[v.FactorEdbSeriesId] = make([]*data_manage.FactorEdbSeriesMappingItem, 0)
+		}
+		seriesEdb[v.FactorEdbSeriesId] = append(seriesEdb[v.FactorEdbSeriesId], &data_manage.FactorEdbSeriesMappingItem{
+			SeriesId:  v.FactorEdbSeriesId,
+			EdbInfoId: v.EdbInfoId,
+			EdbCode:   edbItem.EdbCode,
+			EdbName:   edbItem.EdbName,
+			EdbNameEn: edbItem.EdbNameEn,
+		})
+	}
 
-		resp.CorrelationMatrix = append(resp.CorrelationMatrix, item)
+	// 系列关联的指标详情
+	for _, v := range seriesDetails {
+		v.EdbMappings = seriesEdb[v.SeriesId]
 	}
 
 	resp.ChartInfoId = chartInfo.ChartInfoId
 	resp.UniqueCode = chartInfo.UniqueCode
 	resp.BaseEdbInfo = baseEdbMapping
-	resp.EdbSeries = seriesItems
+	resp.EdbSeries = seriesDetails
 	resp.CorrelationConfig = correlateConf
+	resp.CorrelationMatrix = matrixItems
 
 	br.Data = resp
 	br.Ret = 200

models/data_manage/chart_classify.go

@@ -22,6 +22,7 @@ type ChartClassify struct {
 	Source              int       `description:"1：ETA图库；2：商品价格曲线"`
 	IsJoinPermission    int       `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
 	ChartClassifyNameEn string    `description:"英文分类名称"`
+	RootId              int       `description:"顶级ID"`
 }
 
 func AddChartClassify(item *ChartClassify) (lastId int64, err error) {
@@ -262,6 +263,9 @@ type MoveChartClassifyReq struct {
 	ParentClassifyId int `description:"父级分类id"`
 	PrevClassifyId   int `description:"上一个兄弟节点分类id"`
 	NextClassifyId   int `description:"下一个兄弟节点分类id"`
+	ChartInfoId      int `description:"图表ID, 如果图表ID有值，则移动对象为图表，否则认为移动对象分类"`
+	PrevChartInfoId  int `description:"上一个图表ID"`
+	NextChartInfoId  int `description:"下一个图表ID"`
 }
 
 // GetFirstChartClassifyByParentId 获取当前父级图表分类下的排序第一条的数据
@@ -416,3 +420,38 @@ func GetChartClassifyBySourceAndIsJoinPermission(source, isJoinPermission int) (
 	_, err = o.Raw(sql, source, isJoinPermission).QueryRows(&items)
 	return
 }
+
+type ChartClassifyIdItems struct {
+	ChartClassifyId   int    `description:"分类id"`
+	ChartClassifyName string `description:"分类名称"`
+	UniqueCode        string `description:"唯一编码"`
+	ParentId          int    `description:"父级分类id"`
+	Level             int    `description:"层级"`
+	RootId            int    `description:"顶级分类id"`
+	IsJoinPermission  int    `description:"是否加入权限管控，0：不加入；1：加入；默认：0" json:"-"`
+	HaveOperaAuth     bool   `description:"是否有该数据权限，默认：false"`
+}
+
+func GetChartClassifyByRootIdLevel(rootId, source int, orderStr string) (items []*ChartClassifyIdItems, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM chart_classify WHERE root_id = ? AND source = ? `
+	if orderStr != "" {
+		sql += orderStr
+	} else {
+		sql += ` order by level desc, sort asc, chart_classify_id asc`
+	}
+
+	_, err = o.Raw(sql, rootId, source).QueryRows(&items)
+	return
+}
+
+// UpdateChartClassifySortByParentIdAndSource 根据图表父类id更新排序
+func UpdateChartClassifySortByParentIdAndSource(parentId, classifyId, nowSort int, updateSort string, source int) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` update chart_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? AND source = ? `
+	if classifyId > 0 {
+		sql += ` or ( chart_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
+	}
+	_, err = o.Raw(sql, parentId, nowSort, source).Exec()
+	return
+}

models/data_manage/chart_info.go

@@ -2390,3 +2390,24 @@ type ChartInfoSourcesFrom struct {
 	Color    string `description:"来源颜色" json:"color"`
 	FontSize int    `description:"来源字号" json:"fontSize"`
 }
+
+// UpdateChartInfoSortByClassifyIdV2 根据分类id更新排序
+func UpdateChartInfoSortByClassifyIdV2(classifyId, nowSort int, prevChartInfoId int, updateSort string) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` update chart_info set sort = ` + updateSort + ` WHERE chart_classify_id = ?`
+	if prevChartInfoId > 0 {
+		sql += ` AND ( sort > ? or ( chart_info_id > ` + fmt.Sprint(prevChartInfoId) + ` and sort=` + fmt.Sprint(nowSort) + ` )) `
+	} else {
+		sql += ` AND ( sort > ? )`
+	}
+	_, err = o.Raw(sql, classifyId, nowSort).Exec()
+	return
+}
+
+// GetChartInfoMaxSortByClassifyId 获取分类下指标的最大的排序数
+func GetChartInfoMaxSortByClassifyId(classifyId int) (sort int, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `SELECT Max(sort) AS sort FROM chart_info WHERE chart_classify_id = ? `
+	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	return
+}

models/data_manage/chart_info_correlation.go

@@ -295,7 +295,7 @@ type FactorCorrelationEditDetail struct {
 	ChartInfoId       int                                    `description:"图表ID"`
 	UniqueCode        string                                 `description:"图表唯一编码"`
 	BaseEdbInfo       *ChartEdbInfoMapping                   `description:"标的指标信息"`
-	EdbSeries         []*FactorEdbSeriesItem                 `description:"指标系列"`
+	EdbSeries         []*FactorEdbSeriesDetail               `description:"指标系列"`
 	CorrelationConfig CorrelationConfig                      `description:"相关性基础配置"`
 	CorrelationMatrix []FactorEdbSeriesCorrelationMatrixItem `description:"相关性矩阵"`
 }

models/data_manage/factor_edb_series_mapping.go

@@ -157,6 +157,8 @@ type FactorEdbSeriesMappingItem struct {
 	SeriesId  int    `description:"因子指标系列ID"`
 	EdbInfoId int    `description:"指标ID"`
 	EdbCode   string `description:"指标编码"`
+	EdbName   string `description:"指标名称"`
+	EdbNameEn string `description:"指标名称-英文"`
 }
 
 func (m *FactorEdbSeriesMapping) Format2Item() (item *FactorEdbSeriesMappingItem) {

services/data/chart_classify.go

@@ -374,3 +374,530 @@ func EditChartClassify(chartClassifyId, source int, chartClassifyName, lang stri
 
 	return
 }
+
+// MoveChartClassify 移动图表分类
+func MoveChartClassify(req data_manage.MoveChartClassifyReq, sysUser *system.Admin, source int) (err error, errMsg string) {
+	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.ChartClassify
+		prevClassify      *data_manage.ChartClassify
+		nextClassify      *data_manage.ChartClassify
+
+		chartInfo     *data_manage.ChartInfo
+		prevChartInfo *data_manage.ChartInfo
+		nextChartInfo *data_manage.ChartInfo
+		prevSort      int
+		nextSort      int
+	)
+
+	// 移动对象为分类， 判断权限
+	if chartInfoId == 0 {
+		chartClassifyInfo, err = data_manage.GetChartClassifyById(classifyId)
+		if err != nil {
+			if err.Error() == utils.ErrNoRow() {
+				errMsg = "当前分类不存在"
+				err = errors.New("获取分类信息失败,Err:" + err.Error())
+				return
+			}
+			errMsg = "移动失败"
+			err = errors.New("获取分类信息失败,Err:" + err.Error())
+			return
+		}
+		if parentClassifyId > 0 && parentChartClassifyInfo.Level == 6 {
+			errMsg = "最高只支持添加6级分类"
+			err = errors.New(errMsg)
+			return
+		}
+		// 如果是移动目录, 那么校验一下父级目录下是否有重名目录
+		exists, e := data_manage.GetChartClassifyByParentIdAndName(parentClassifyId, chartClassifyInfo.ChartClassifyName, classifyId)
+		if e != nil && e.Error() != utils.ErrNoRow() {
+			errMsg = "移动失败"
+			err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
+			return
+		}
+		if exists != nil {
+			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.ChartClassifyId, permissionClassifyIdList)
+
+			button := GetChartClassifyOpButton(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 err.Error() == utils.ErrNoRow() {
+				errMsg = "当前图表不存在"
+				err = errors.New("获取分类信息失败,Err:" + err.Error())
+				return
+			}
+			errMsg = "移动失败"
+			err = errors.New("获取分类信息失败,Err:" + err.Error())
+			return
+		}
+		if parentClassifyId == 0 {
+			errMsg = "移动失败,图表必须挂在分类下"
+			err = errors.New(errMsg)
+			return
+		}
+
+		var haveOperaAuth bool
+		// 权限校验
+		{
+			haveOperaAuth, err = data_manage_permission.CheckChartPermissionByChartInfoId(chartInfo.ChartInfoId, chartInfo.ChartClassifyId, chartInfo.IsJoinPermission, sysUser.AdminId)
+			if err != nil {
+				errMsg = "移动失败"
+				err = errors.New("获取图表权限信息失败,Err:" + err.Error())
+				return
+			}
+		}
+
+		// 移动权限校验
+		button := GetChartOpButton(sysUser, chartInfo.SysUserId, 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 = moveChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify, chartInfo, prevChartInfo, nextChartInfo, parentClassifyId, prevSort, nextSort, source)
+	return
+}
+
+// moveChartClassify 移动图表分类
+func moveChartClassify(parentChartClassifyInfo, chartClassifyInfo, prevClassify, nextClassify *data_manage.ChartClassify, chartInfo, prevChartInfo, nextChartInfo *data_manage.ChartInfo, parentClassifyId, prevSort, nextSort, source int) (err error, errMsg string) {
+	updateCol := make([]string, 0)
+
+	// 移动对象为分类， 判断分类是否存在
+	if chartClassifyInfo != nil {
+		oldParentId := chartClassifyInfo.ParentId
+		oldLevel := chartClassifyInfo.Level
+		var classifyIds []int
+		if oldParentId != parentClassifyId {
+			//更新子分类对应的level
+			childList, e, m := GetChildChartClassifyByClassifyId(chartClassifyInfo.ChartClassifyId)
+			if e != nil {
+				errMsg = "移动失败"
+				err = errors.New("查询子分类失败,Err:" + e.Error() + m)
+				return
+			}
+
+			if len(childList) > 0 {
+				for _, v := range childList {
+					if v.ChartClassifyId == chartClassifyInfo.ChartClassifyId {
+						continue
+					}
+					classifyIds = append(classifyIds, v.ChartClassifyId)
+				}
+			}
+		}
+		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+		if chartClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+			if chartClassifyInfo.Level != parentChartClassifyInfo.Level+1 { //禁止层级调整
+				errMsg = "移动失败"
+				err = errors.New("不支持目录层级变更")
+				return
+			}
+			chartClassifyInfo.ParentId = parentChartClassifyInfo.ChartClassifyId
+			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.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, prevClassify.ChartClassifyId, prevClassify.Sort, updateSortStr, source)
+					} else {
+						_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, 0, prevSort, updateSortStr, source)
+					}
+
+					//变更图表
+					if prevChartInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+					} else {
+						_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, 0, updateSortStr)
+					}
+				} else {
+					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+					if nextSort-prevSort == 1 {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 1`
+
+						//变更分类
+						if prevClassify != nil {
+							_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, prevClassify.ChartClassifyId, prevSort, updateSortStr, source)
+						} else {
+							_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, 0, prevSort, updateSortStr, source)
+						}
+
+						//变更图表
+						if prevChartInfo != nil {
+							//变更兄弟节点的排序
+							_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+						} else {
+							_ = data_manage.UpdateChartInfoSortByClassifyIdV2(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 && tmpErr.Error() != utils.ErrNoRow() {
+				errMsg = "移动失败"
+				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+				return
+			}
+
+			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+			if firstClassify != nil && firstClassify.Sort == 0 {
+				updateSortStr := ` sort + 1 `
+				_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, firstClassify.ChartClassifyId-1, 0, updateSortStr, source)
+				//该分类下的所有图表也需要+1
+				_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, 0, 0, updateSortStr)
+			} else {
+				//如果该分类下存在图表，且第一个图表的排序等于0，那么需要调整排序
+				firstEdb, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
+				if tErr != nil && tErr.Error() != utils.ErrNoRow() {
+					errMsg = "移动失败"
+					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+					return
+				}
+
+				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+				if firstEdb != nil && firstEdb.Sort == 0 {
+					updateSortStr := ` sort + 1 `
+					_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, 0, firstEdb.ChartInfoId-1, updateSortStr)
+					_ = data_manage.UpdateChartClassifySortByParentIdAndSource(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.UpdateEdbClassifyChildByParentClassifyId(classifyIds, chartClassifyInfo.RootId, levelStep)
+					if err != nil {
+						errMsg = "移动失败"
+						err = errors.New("更新子分类失败,Err:" + err.Error())
+						return
+					}
+				}
+			}
+		}
+	} else {
+		if chartInfo == nil {
+			errMsg = "当前图表不存在"
+			err = errors.New(errMsg)
+			return
+		}
+		//如果改变了分类，那么移动该图表数据
+		if chartInfo.ChartClassifyId != parentClassifyId {
+			chartInfo.ChartClassifyId = parentClassifyId
+			chartInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "ChartClassifyId", "ModifyTime")
+		}
+		if prevSort > 0 {
+			//如果是移动在两个兄弟节点之间
+			if nextSort > 0 {
+				//下一个兄弟节点
+				//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+				if prevSort == nextSort || prevSort == chartInfo.Sort {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 2`
+
+					//变更分类
+					if prevClassify != nil {
+						_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, prevClassify.ChartClassifyId, prevClassify.Sort, updateSortStr, source)
+					} else {
+						_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, 0, prevSort, updateSortStr, source)
+					}
+
+					//变更图表
+					if prevChartInfo != nil {
+						//变更兄弟节点的排序
+						_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+					} else {
+						_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, 0, updateSortStr)
+					}
+				} else {
+					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+					if nextSort-prevSort == 1 {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 1`
+						//变更分类
+						if prevClassify != nil {
+							_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, prevClassify.ChartClassifyId, prevSort, updateSortStr, source)
+						} else {
+							_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, 0, prevSort, updateSortStr, source)
+						}
+
+						//变更图表
+						if prevChartInfo != nil {
+							//变更兄弟节点的排序
+							_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, prevSort, prevChartInfo.ChartInfoId, updateSortStr)
+						} else {
+							_ = data_manage.UpdateChartInfoSortByClassifyIdV2(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 && tmpErr.Error() != utils.ErrNoRow() {
+				errMsg = "移动失败"
+				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
+				return
+			}
+
+			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+			if firstClassify != nil && firstClassify.Sort == 0 {
+				updateSortStr := ` sort + 1 `
+				_ = data_manage.UpdateChartClassifySortByParentIdAndSource(parentClassifyId, firstClassify.ChartClassifyId-1, 0, updateSortStr, source)
+				//该分类下的所有图表也需要+1
+				_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, 0, 0, updateSortStr)
+			} else {
+				//如果该分类下存在图表，且第一个图表的排序等于0，那么需要调整排序
+				firstEdb, tErr := data_manage.GetFirstChartInfoByClassifyId(parentClassifyId)
+				if tErr != nil && tErr.Error() != utils.ErrNoRow() {
+					errMsg = "移动失败"
+					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
+					return
+				}
+
+				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+				if firstEdb != nil && firstEdb.Sort == 0 {
+					updateSortStr := ` sort + 1 `
+					_ = data_manage.UpdateChartInfoSortByClassifyIdV2(parentClassifyId, 0, firstEdb.ChartInfoId-1, updateSortStr)
+					_ = data_manage.UpdateChartClassifySortByParentIdAndSource(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
+}
+
+func GetChildChartClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.ChartClassifyIdItems, err error, errMsg string) {
+	//判断是否是挂在顶级目录下
+	targetClassify, err := data_manage.GetChartClassifyById(targetClassifyId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			errMsg = "当前分类不存在"
+			err = errors.New(errMsg)
+			return
+		}
+		errMsg = "获取失败"
+		err = errors.New("获取分类信息失败，Err:" + err.Error())
+		return
+	}
+	orderStr := ` order by level asc, sort asc, chart_classify_id asc`
+	tmpList, err := data_manage.GetChartClassifyByRootIdLevel(targetClassify.RootId, targetClassify.Source, orderStr)
+	if err != nil && err.Error() != utils.ErrNoRow() {
+		errMsg = "获取失败"
+		err = errors.New("获取数据失败，Err:" + err.Error())
+		return
+	}
+	idMap := make(map[int]struct{})
+	if len(tmpList) > 0 {
+		for _, v := range tmpList {
+			if v.ChartClassifyId == targetClassify.ChartClassifyId {
+				idMap[v.ChartClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.ParentId]; ok {
+				idMap[v.ChartClassifyId] = struct{}{}
+			}
+		}
+		for _, v := range tmpList {
+			if _, ok := idMap[v.ChartClassifyId]; ok {
+				targetItem := new(data_manage.ChartClassifyIdItems)
+				targetItem.ChartClassifyId = v.ChartClassifyId
+				targetItem.ParentId = v.ParentId
+				targetItem.RootId = v.RootId
+				targetItem.UniqueCode = v.UniqueCode
+				targetItem.Level = v.Level
+				targetItem.ChartClassifyName = v.ChartClassifyName
+				targetItem.IsJoinPermission = v.IsJoinPermission
+				targetList = append(targetList, targetItem)
+			}
+		}
+	}
+
+	return
+}
+
+func GetChartClassifyMaxSort(parentId, source int) (maxSort int, err error) {
+	//获取该层级下最大的排序数
+	classifyMaxSort, err := data_manage.GetChartClassifyMaxSort(parentId, source)
+	if err != nil {
+		return
+	}
+	maxSort = classifyMaxSort
+	edbMaxSort, err := data_manage.GetChartInfoMaxSortByClassifyId(parentId)
+	if err != nil {
+		return
+	}
+	if maxSort < edbMaxSort {
+		maxSort = edbMaxSort
+	}
+	return
+}