修复多章节排序

models/report_chapter.go

@@ -642,6 +642,12 @@ func (chapterChapterInfo *ReportChapter) Update(cols []string) (err error) {
 	return
 }
 
+func (m *ReportChapter) UpdateChapters(order []*ReportChapter) (err error) {
+	o := global.DbMap[utils.DbNameReport]
+	err = o.Updates(order).Error
+	return
+}
+
 // DelReportChapterReq
 // @Description: 删除报告章节请求体
 type DelReportChapterReq struct {

services/report_chapter.go

@@ -6,7 +6,6 @@ import (
 	"eta/eta_api/models/system"
 	"eta/eta_api/utils"
 	"fmt"
-	"time"
 )
 
 // MoveReportChapter
@@ -74,6 +73,12 @@ func MoveReportChapter(req *models.ReportChapterMoveReq) (err error, errMsg stri
 	return
 }
 
+type chapterSort struct {
+	prev *chapterSort
+	node *models.ReportChapter
+	next *chapterSort
+}
+
 // moveReportChapter
 // @Description: 移动章节分类
 // @author: Roc
@@ -87,86 +92,210 @@ func MoveReportChapter(req *models.ReportChapterMoveReq) (err error, errMsg stri
 // @return err error
 // @return errMsg string
 func moveReportChapter(reportChapter, prevReportChapter, nextReportChapter *models.ReportChapter, reportId int, prevSort, nextSort int) (err error, errMsg string) {
-	ob := new(models.ReportChapter)
-	updateCol := make([]string, 0)
-
-	if prevSort > 0 {
-		//如果是移动在两个兄弟节点之间
-		if nextSort > 0 {
-			//下一个兄弟节点
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevSort == nextSort || prevSort == reportChapter.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-
-				//变更分类
-				if prevReportChapter != nil {
-					_ = ob.UpdateReportChapterSortByReportId(reportId, prevReportChapter.ReportChapterId, prevReportChapter.Sort, updateSortStr)
-				} else {
-					_ = ob.UpdateReportChapterSortByReportId(reportId, 0, prevSort, updateSortStr)
-				}
-
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextSort-prevSort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-
-					//变更分类
-					if prevReportChapter != nil {
-						_ = ob.UpdateReportChapterSortByReportId(reportId, prevReportChapter.ReportChapterId, prevSort, updateSortStr)
-					} else {
-						_ = ob.UpdateReportChapterSortByReportId(reportId, 0, prevSort, updateSortStr)
-					}
-
-				}
-			}
+	reportChapters, err := models.GetChapterListByReportId(reportId)
+	if err != nil {
+		errMsg = "移动失败"
+		err = fmt.Errorf("查询报告章节列表失败,Err:" + err.Error())
+		return
+	}
+	// 查找目标章节
+	var targetIndex int
+	var found bool
+	for i, ch := range reportChapters {
+		if ch.ReportChapterId == reportChapter.ReportChapterId {
+			targetIndex = i
+			found = true
+			break
 		}
+	}
+	if !found {
+		err = fmt.Errorf("未找到目标章节")
+		errMsg = "移动失败"
+		return
+	}
 
-		reportChapter.Sort = prevSort + 1
-		reportChapter.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else if prevReportChapter == nil && nextReportChapter == nil {
-		//处理只拖动到目录里，默认放到目录底部的情况
-		var maxSort int
-		maxSort, err = ob.GetMaxSortByReportId(reportId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = fmt.Errorf("查询组内排序信息失败,Err:" + err.Error())
-			return
-		}
-		reportChapter.Sort = maxSort + 1 //那就是排在组内最后一位
-		reportChapter.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	} else {
-		// 拖动到父级分类的第一位
-		firstReportChapter, tmpErr := ob.GetFirstReportChapterByReportId(reportId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = fmt.Errorf("获取当前报告下，且排序数相同 的排序第一条的数据失败,Err:" + tmpErr.Error())
-			return
-		}
+	// 移除旧位置
+	removed := append(reportChapters[:targetIndex], reportChapters[targetIndex+1:]...)
 
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstReportChapter != nil && firstReportChapter.ReportChapterId != 0 && firstReportChapter.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = ob.UpdateReportChapterSortByReportId(reportId, firstReportChapter.ReportChapterId-1, 0, updateSortStr)
+	// 插入新位置
+	var insertIndex int
+	if prevReportChapter != nil {
+		for i, ch := range removed {
+			if ch.ReportChapterId == prevReportChapter.ReportChapterId {
+				insertIndex = i + 1
+				break
+			}
 		}
-
-		reportChapter.Sort = 0 //那就是排在第一位
-		reportChapter.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
+	} else if nextReportChapter != nil {
+		for i, ch := range removed {
+			if ch.ReportChapterId == nextReportChapter.ReportChapterId {
+				insertIndex = i
+				break
+			}
+		}
+	} else {
+		insertIndex = len(removed) // 插入末尾
 	}
 
-	//更新
-	if len(updateCol) > 0 {
-		err = reportChapter.UpdateChapter(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = fmt.Errorf("修改失败,Err:" + err.Error())
-			return
-		}
+	// 插入章节
+	newOrder := append(removed[:insertIndex], append([]*models.ReportChapter{reportChapter}, removed[insertIndex:]...)...)
+	for i, ch := range newOrder {
+		ch.Sort = i + 1
+	}
+	err = reportChapter.UpdateChapters(newOrder)
+	if err != nil {
+		errMsg = "移动失败"
+		err = fmt.Errorf("修改失败,Err:" + err.Error())
+		return
 	}
+
+	//var headNode = &chapterSort{
+	//	node: reportChapters[0],
+	//}
+	//var targetNode *chapterSort
+	//var endNode = &chapterSort{
+	//	node: reportChapters[len(reportChapters)-1],
+	//}
+	//var prevNode *chapterSort
+	//var current = &chapterSort{
+	//	node: reportChapters[0],
+	//}
+	//for i := 1; i < len(reportChapters); i++ {
+	//	prevNode = current
+	//	if i == 1 {
+	//		headNode = current
+	//	}
+	//	if i == len(reportChapters)-1 {
+	//		endNode = current
+	//	}
+	//	if current.node.ReportChapterId == reportChapter.ReportChapterId {
+	//		targetNode = current
+	//	}
+	//	current = &chapterSort{
+	//		node: reportChapters[i],
+	//		prev: prevNode,
+	//	}
+	//	prevNode.next = current
+	//}
+	//
+	//if prevReportChapter !=nil {
+	//	if nextReportChapter !=nil {
+	//		current=headNode
+	//		for current.next  != nil {
+	//			if current.next.node.ReportChapterId == prevReportChapter.ReportChapterId {
+	//				lastNode := targetNode.prev
+	//				nextNode := targetNode.next
+	//				lastNode.next = nextNode
+	//				nextNode.prev = lastNode
+	//				current.next = targetNode
+	//				targetNode.prev = current
+	//				break
+	//			}
+	//			current = current.next
+	//		}
+	//
+	//	} else {
+	//		lastNode := targetNode.prev
+	//		nextNode := targetNode.next
+	//		lastNode.next = nextNode
+	//		nextNode.prev = lastNode
+	//		targetNode.prev = endNode
+	//		endNode.next = targetNode
+	//	}
+	//}else{
+	//	lastNode := targetNode.prev
+	//	nextNode := targetNode.next
+	//	lastNode.next = nextNode
+	//	nextNode.prev = lastNode
+	//	targetNode.next = headNode
+	//	headNode.prev = targetNode
+	//	headNode=targetNode
+	//}
+	//var sort =1
+	//var newChapterList []*models.ReportChapter
+	//for node := headNode; node != nil; node = node.next {
+	//	node.node.Sort = sort
+	//	newChapterList = append(newChapterList, node.node)
+	//	sort++
+	//}
+	//if prevSort > 0 {
+	//	//如果是移动在两个兄弟节点之间
+	//	if nextSort > 0 {
+	//		//下一个兄弟节点
+	//		//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+	//		if prevSort == nextSort || prevSort == reportChapter.Sort {
+	//			//变更兄弟节点的排序
+	//			updateSortStr := `sort + 2`
+	//
+	//			//变更分类
+	//			if prevReportChapter != nil {
+	//				_ = ob.UpdateReportChapterSortByReportId(reportId, prevReportChapter.ReportChapterId, prevReportChapter.Sort, updateSortStr)
+	//			} else {
+	//				_ = ob.UpdateReportChapterSortByReportId(reportId, 0, prevSort, updateSortStr)
+	//			}
+	//
+	//		} else {
+	//			//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+	//			if nextSort-prevSort == 1 {
+	//				//变更兄弟节点的排序
+	//				updateSortStr := `sort + 1`
+	//
+	//				//变更分类
+	//				if prevReportChapter != nil {
+	//					_ = ob.UpdateReportChapterSortByReportId(reportId, prevReportChapter.ReportChapterId, prevSort, updateSortStr)
+	//				} else {
+	//					_ = ob.UpdateReportChapterSortByReportId(reportId, 0, prevSort, updateSortStr)
+	//				}
+	//
+	//			}
+	//		}
+	//	}
+	//
+	//	reportChapter.Sort = prevSort + 1
+	//	reportChapter.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "Sort", "ModifyTime")
+	//} else if prevReportChapter == nil && nextReportChapter == nil {
+	//	//处理只拖动到目录里，默认放到目录底部的情况
+	//	var maxSort int
+	//	maxSort, err = ob.GetMaxSortByReportId(reportId)
+	//	if err != nil {
+	//		errMsg = "移动失败"
+	//		err = fmt.Errorf("查询组内排序信息失败,Err:" + err.Error())
+	//		return
+	//	}
+	//	reportChapter.Sort = maxSort + 1 //那就是排在组内最后一位
+	//	reportChapter.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "Sort", "ModifyTime")
+	//} else {
+	//	// 拖动到父级分类的第一位
+	//	firstReportChapter, tmpErr := ob.GetFirstReportChapterByReportId(reportId)
+	//	if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
+	//		errMsg = "移动失败"
+	//		err = fmt.Errorf("获取当前报告下，且排序数相同 的排序第一条的数据失败,Err:" + tmpErr.Error())
+	//		return
+	//	}
+	//
+	//	//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+	//	if firstReportChapter != nil && firstReportChapter.ReportChapterId != 0 && firstReportChapter.Sort == 0 {
+	//		updateSortStr := ` sort + 1 `
+	//		_ = ob.UpdateReportChapterSortByReportId(reportId, firstReportChapter.ReportChapterId-1, 0, updateSortStr)
+	//	}
+	//
+	//	reportChapter.Sort = 0 //那就是排在第一位
+	//	reportChapter.ModifyTime = time.Now()
+	//	updateCol = append(updateCol, "Sort", "ModifyTime")
+	//}
+	//
+	////更新
+	//if len(updateCol) > 0 {
+	//	err = reportChapter.UpdateChapter(updateCol)
+	//	if err != nil {
+	//		errMsg = "移动失败"
+	//		err = fmt.Errorf("修改失败,Err:" + err.Error())
+	//		return
+	//	}
+	//}
+
 	return
 }