Merge branch 'ETA_2.3.2' into debug

models/data_manage/base_from_clarksons_classify.go

@@ -2,6 +2,7 @@ package data_manage
 
 import (
 	"eta/eta_api/utils"
+	"fmt"
 	"time"
 
 	"github.com/beego/beego/v2/client/orm"
@@ -211,3 +212,22 @@ func MoveDownClarksonsIndexClassifyBySort(parentId, prevSort, currentSort int) (
 	_, err = o.Raw(sql, parentId, prevSort, currentSort).Exec()
 	return
 }
+
+// UpdateClarksonsClassifySortByParentId 根据父类id更新排序
+func UpdateClarksonsClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` update base_from_clarksons_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? `
+	if classifyId > 0 {
+		sql += ` or ( base_from_clarksons_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
+	}
+	_, err = o.Raw(sql, parentId, nowSort).Exec()
+	return
+}
+
+// GetFirstClarksonsClassifyByParentId 获取当前父级分类下的排序第一条的数据
+func GetFirstClarksonsClassifyByParentId(parentId int) (item *ChartClassify, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM base_from_clarksons_classify WHERE parent_id=? order by sort asc,base_from_clarksons_classify_id asc limit 1`
+	err = o.Raw(sql, parentId).QueryRow(&item)
+	return
+}

services/data/base_from_clarksons.go

@@ -641,3 +641,182 @@ func GetClarkssonsIndexList(searchParams string) (rzdIndexInfoList []*data_manag
 
 	return rzdIndexList, nil
 }
+
+// MoveClarksonsClassify 移动克拉克森分类
+func MoveClarksonsClassifyV2(classifyId, parentClassifyId, prevClassifyId, nextClassifyId int) (err error, errMsg string) {
+	//判断分类是否存在
+	classifyInfo, err := data_manage.GetClarksonsClassifyById(classifyId)
+	if err != nil {
+		errMsg = "移动失败"
+		err = errors.New("获取分类信息失败,Err:" + err.Error())
+		return
+	}
+
+	updateCol := make([]string, 0)
+
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	if classifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
+		// 校验移动的父级目录下是否有重名分类
+		count, e := data_manage.GetBaseFromClarksonsClassifyCount(classifyInfo.ClassifyName, parentClassifyId)
+		if e != nil && e.Error() != utils.ErrNoRow() {
+			errMsg = "移动失败"
+			err = errors.New("获取父级目录下的同名分类失败, Err: " + e.Error())
+			return
+		}
+		if count > 0 {
+			errMsg = "移动失败，分类名称已存在"
+			err = errors.New("该父级目录下已存在同名分类，请重新命名")
+			return
+		}
+
+		parentClassifyInfo, tmpErr := data_manage.GetClarksonsClassifyById(parentClassifyId)
+		if tmpErr != nil {
+			errMsg = "移动失败"
+			err = errors.New("获取上级分类信息失败,Err:" + tmpErr.Error())
+			return
+		}
+		classifyInfo.ParentId = parentClassifyInfo.BaseFromClassifyId
+		classifyInfo.Level = parentClassifyInfo.Level + 1
+		updateCol = append(updateCol, "ParentId", "Level")
+	}
+	//var currentSort, prevSort, nextSort int
+	//currentSort = classifyInfo.Sort
+
+	var prevClassify *data_manage.BaseFromClarksonsClassify
+	var nextClassify *data_manage.BaseFromClarksonsClassify
+	//如果有传入 上一个兄弟节点分类id
+	if prevClassifyId > 0 {
+		prevClassify, err = data_manage.GetClarksonsClassifyById(prevClassifyId)
+		if err != nil {
+			if err.Error() == utils.ErrNoRow() {
+				errMsg = "移动失败"
+				err = errors.New("上一个兄弟节点分类信息不存在" + err.Error())
+				return
+			}
+			errMsg = "移动失败"
+			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
+			return
+		}
+		//如果是移动在两个兄弟节点之间
+		if nextClassifyId > 0 {
+			//下一个兄弟节点
+			nextClassify, err = data_manage.GetClarksonsClassifyById(nextClassifyId)
+			if err != nil {
+				errMsg = "移动失败"
+				err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+				return
+			}
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == classifyInfo.Sort {
+				//变更兄弟节点的排序
+				updateSortStr := `sort + 2`
+				_ = data_manage.UpdateClarksonsClassifySortByParentId(prevClassify.ParentId, prevClassify.BaseFromClassifyId, prevClassify.Sort, updateSortStr)
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextClassify.Sort-prevClassify.Sort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					_ = data_manage.UpdateClarksonsClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+				}
+			}
+		}
+
+		classifyInfo.Sort = prevClassify.Sort + 1
+		classifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	} else {
+		firstClassify, err := data_manage.GetFirstClarksonsClassifyByParentId(classifyInfo.ParentId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "移动失败"
+			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error())
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = data_manage.UpdateClarksonsClassifySortByParentId(firstClassify.ParentId, firstClassify.ChartClassifyId-1, 0, updateSortStr)
+		}
+
+		classifyInfo.Sort = 0 //那就是排在第一位
+		classifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	//if nextClassifyId > 0 {
+	//	//下一个兄弟节点
+	//	nextClassify, err = data_manage.GetClarksonsClassifyById(nextClassifyId)
+	//	if err != nil {
+	//		if err.Error() == utils.ErrNoRow() {
+	//			errMsg = "移动失败"
+	//			err = errors.New("下一个兄弟节点分类信息不存在" + err.Error())
+	//			return
+	//		}
+	//		errMsg = "移动失败"
+	//		err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
+	//		return
+	//	}
+	//	nextSort = nextClassify.Sort
+	//}
+	//
+	//// 修改历史数据中的排序为0的情况
+	//if prevSort == 0 && nextSort == 0 { //目标是让当前分类处于目录的最顶部
+	//	//更新为0排序的数据为当前最小排序
+	//	if nextClassify != nil {
+	//		minSort, e := data_manage.GetClarksonsIndexClassifyMinSort(parentClassifyId)
+	//		if e != nil {
+	//			errMsg = "移动失败"
+	//			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + e.Error())
+	//			return
+	//		}
+	//		if minSort > 1 {
+	//			minSort -= 1
+	//		}
+	//		nextClassify.Sort = minSort
+	//		err = nextClassify.Update([]string{"sort"})
+	//		if err != nil {
+	//			errMsg = "移动失败"
+	//			err = errors.New("更新下一个兄弟节点分类信息失败,Err:" + err.Error())
+	//			return
+	//		}
+	//		nextSort = minSort
+	//	}
+	//}
+	////移到两个排序值中间操作
+	//if prevSort >= currentSort {
+	//	//往下移动
+	//	err = data_manage.MoveDownClarksonsIndexClassifyBySort(parentClassifyId, prevSort, currentSort)
+	//	if err != nil {
+	//		err = errors.New("向下移动出错:" + err.Error())
+	//		return
+	//	}
+	//	classifyInfo.Sort = prevSort
+	//} else if nextSort <= currentSort && nextSort != 0 {
+	//	//往上移动
+	//	err = data_manage.MoveUpClarksonsIndexClassifyBySort(parentClassifyId, nextSort, currentSort)
+	//	if err != nil {
+	//		err = errors.New("向上移动出错:" + err.Error())
+	//		return
+	//	}
+	//	classifyInfo.Sort = nextSort
+	//}
+	//
+	//classifyInfo.ModifyTime = time.Now()
+	//updateCol = append(updateCol, "Sort", "ModifyTime")
+	//err = classifyInfo.Update(updateCol)
+	//if err != nil {
+	//	errMsg = "移动失败"
+	//	err = errors.New("修改失败,Err:" + err.Error())
+	//	return
+	//}
+	//更新
+	if len(updateCol) > 0 {
+		err = classifyInfo.Update(updateCol)
+		if err != nil {
+			errMsg = "移动失败"
+			err = errors.New("修改失败,Err:" + err.Error())
+			return
+		}
+	}
+	return
+}