fix:中文视频的报告分类筛选，支持三级选择

controllers/yb/road_video.go

@@ -11,7 +11,6 @@ import (
 	"hongze/hz_crm_api/services"
 	"hongze/hz_crm_api/services/yb"
 	"hongze/hz_crm_api/utils"
-	"sort"
 	"strings"
 	"time"
 )
@@ -421,55 +420,64 @@ func (r *RoadVideoController) TwoWeekClassifyList() {
 	}
 
 	// 2023-04-19 取classify表relate_video=1的二级分类, 但是需要分层级, 所以对应的一级分类也要组合起来
-	list, e := models.GetAllClassify()
+	list, e := models.GetAllClassifyByRelateVideo()
 	if e != nil {
 		br.Msg = "获取失败"
 		br.ErrMsg = "获取路演视频可选报告分类失败, Err: " + e.Error()
 		return
 	}
-	resp := make([]*models.SimpleClassifyList, 0)
-	parentMap := make(map[int]*models.SimpleClassifyList)
-	classifyMap := make(map[int]*models.Classify)
-	for _, c := range list {
-		classifyMap[c.Id] = c
-		if c.ParentId > 0 && c.RelateVideo == 1 {
-			if parentMap[c.ParentId] == nil {
-				parentMap[c.ParentId] = new(models.SimpleClassifyList)
+
+	// 获取父级的分类
+	{
+		idMap := make(map[int]bool)
+
+		currParentClassifyIdList := make([]int, 0)
+		for _, v := range list {
+			idMap[v.Id] = true
+			if v.ParentId > 0 {
+				currParentClassifyIdList = append(currParentClassifyIdList, v.ParentId)
 			}
 		}
-	}
-	for k, v := range parentMap {
-		p := classifyMap[k]
-		if p == nil {
-			continue
+
+		findList := list
+		list = make([]*models.Classify, 0)
+
+		tmpList, tmpErr := services.GetParentClassifyListByParentIdList(currParentClassifyIdList)
+		if tmpErr != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取上级分类信息失败，Err:" + tmpErr.Error()
+			return
 		}
-		v.Id = p.Id
-		v.ClassifyName = p.ClassifyName
-		v.Sort = p.Sort
-		v.Child = make([]*models.SimpleClassifyList, 0)
-		for _, c := range list {
-			if c.ParentId == v.Id && c.RelateVideo == 1 {
-				v.Child = append(v.Child, &models.SimpleClassifyList{
-					Id:           c.Id,
-					ClassifyName: c.ClassifyName,
-					ParentId:     c.ParentId,
-					Sort:         c.Sort,
-				})
+		for _, v := range tmpList {
+			if _, ok := idMap[v.Id]; !ok {
+				list = append(list, v)
 			}
 		}
-		sort.Slice(v.Child, func(i, j int) bool {
-			return v.Child[j].Sort > v.Child[i].Sort
+
+		list = append(list, findList...)
+	}
+
+	allList := make([]*models.SimpleClassifyList, 0)
+	for _, v := range list {
+		allList = append(allList, &models.SimpleClassifyList{
+			Id:           v.Id,
+			ClassifyName: v.ClassifyName,
+			ParentId:     v.ParentId,
+			Sort:         v.Sort,
+			CreateTime:   v.CreateTime,
+			Child:        make([]*models.SimpleClassifyList, 0),
 		})
-		resp = append(resp, v)
 	}
-	sort.Slice(resp, func(i, j int) bool {
-		return resp[j].Sort > resp[i].Sort
-	})
+
+	// 先将分类列表排序
+	services.SortClassifyListBySortAndCreateTime(allList)
+	// 接着转换结构
+	allList = services.GetClassifyListTreeRecursive(allList, 0)
 
 	br.Ret = 200
 	br.Success = true
 	br.Msg = "操作成功"
-	br.Data = resp
+	br.Data = allList
 }
 
 // SimpleReportList

models/classify.go

@@ -209,10 +209,11 @@ func GetAllClassify() (list []*Classify, err error) {
 
 // SimpleClassifyList 简版分类列表
 type SimpleClassifyList struct {
-	Id           int    `description:"分类ID"`
-	ClassifyName string `description:"分类名称"`
-	ParentId     int    `description:"父级ID"`
-	Sort         int    `description:"排序"`
+	Id           int       `description:"分类ID"`
+	ClassifyName string    `description:"分类名称"`
+	ParentId     int       `description:"父级ID"`
+	Sort         int       `description:"排序"`
+	CreateTime   time.Time `description:"创建时间"`
 	Child        []*SimpleClassifyList
 }
 
@@ -231,3 +232,36 @@ func GetClassifyByCondition(condition, orderRule string, pars []interface{}) (it
 	_, err = o.Raw(sql, pars).QueryRows(&items)
 	return
 }
+
+// GetAllClassifyByRelateVideo
+// @Description: 获取关联视频的所有分类
+// @author: Roc
+// @datetime 2024-07-12 17:19:06
+// @return list []*Classify
+// @return err error
+func GetAllClassifyByRelateVideo() (list []*Classify, err error) {
+	o := orm.NewOrmUsingDB("rddp")
+	sql := ` SELECT * FROM classify where relate_video = 1`
+	_, err = o.Raw(sql).QueryRows(&list)
+	return
+}
+
+// GetClassifyListByParentIdList
+// @Description: 获取分类列表
+// @author: Roc
+// @datetime 2024-06-19 09:49:33
+// @param keyWord string
+// @param enabled int
+// @return items []*ClassifyList
+// @return err error
+func GetClassifyListByParentIdList(parentClassifyIdList []int) (items []*Classify, err error) {
+	num := len(parentClassifyIdList)
+	if num <= 0 {
+		return
+	}
+	sql := `SELECT * FROM classify WHERE id in (` + utils.GetOrmInReplace(num) + `) ORDER BY sort ASC, create_time ASC`
+
+	o := orm.NewOrmUsingDB("rddp")
+	_, err = o.Raw(sql, parentClassifyIdList).QueryRows(&items)
+	return
+}

services/classify.go

@@ -7,6 +7,7 @@ import (
 	"hongze/hz_crm_api/utils"
 	"io/ioutil"
 	"net/http"
+	"sort"
 	"strings"
 )
 
@@ -182,3 +183,89 @@ type GetClassifyListResp struct {
 	Data   models.ClassifyListResp `json:"data" description:"返回数据"`
 	ErrMsg string                  `json:"-" description:"错误信息，不用返回给前端，只是做日志记录"`
 }
+
+// GetParentClassifyListByParentIdList
+// @Description: 递归获取父级分类信息，正常来讲只有三次
+// @author: Roc
+// @datetime 2024-06-19 13:23:33
+// @param parentClassifyIdList []int
+// @return list []*models.ClassifyList
+// @return err error
+func GetParentClassifyListByParentIdList(parentClassifyIdList []int) (list []*models.Classify, err error) {
+	num := len(parentClassifyIdList)
+	if num <= 0 {
+		return
+	}
+	list, err = models.GetClassifyListByParentIdList(parentClassifyIdList)
+	if err != nil {
+		return
+	}
+
+	// 是否还有上级
+	{
+		currParentClassifyIdList := make([]int, 0)
+		for _, v := range list {
+			if v.ParentId > 0 {
+				currParentClassifyIdList = append(currParentClassifyIdList, v.ParentId)
+			}
+		}
+
+		if len(currParentClassifyIdList) > 0 {
+			tmpList, tmpErr := GetParentClassifyListByParentIdList(currParentClassifyIdList)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			list = append(tmpList, list...)
+		}
+	}
+
+	return
+}
+
+// GetClassifyListTreeRecursive
+// @Description: 递归获取分类树形结构
+// @author: Roc
+// @datetime 2024-06-19 13:23:28
+// @param list []*models.ClassifyList
+// @param parentId int
+// @return []*models.ClassifyList
+func GetClassifyListTreeRecursive(list []*models.SimpleClassifyList, parentId int) []*models.SimpleClassifyList {
+	res := make([]*models.SimpleClassifyList, 0)
+	for _, v := range list {
+		if v.ParentId == parentId {
+			v.Child = GetClassifyListTreeRecursive(list, v.Id)
+			res = append(res, v)
+		}
+	}
+
+	// 前端的JP需要我这么返回
+	if len(res) <= 0 {
+		res = nil
+	}
+
+	return res
+}
+
+// BySortAndCreateTime 用来排序，先按Sort字段升序排序，若Sort相同，则按照CreateTime字段升序排序。
+type BySortAndCreateTime []*models.SimpleClassifyList
+
+func (a BySortAndCreateTime) Len() int {
+	return len(a)
+}
+
+func (a BySortAndCreateTime) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a BySortAndCreateTime) Less(i, j int) bool {
+	if a[i].Sort == a[j].Sort {
+		return a[i].CreateTime.Before(a[j].CreateTime)
+	}
+	return a[i].Sort < a[j].Sort
+}
+
+// SortClassifyListBySortAndCreateTime sorts the ClassifyList slice by Sort and then CreateTime in ascending order.
+func SortClassifyListBySortAndCreateTime(classifyList []*models.SimpleClassifyList) {
+	sort.Sort(BySortAndCreateTime(classifyList))
+}