eta_api/services/export_stat.go

package services

import (
	"errors"
	"eta/eta_api/models"
	"eta/eta_api/models/roadshow"
	"eta/eta_api/utils"
	"fmt"
	"github.com/tealeg/xlsx"
	"sort"
	"time"
)

// exportReportStat
// @Description: 导出报告统计数据
func exportReportStat() {
	startDate := `2025-01-01 00:00:00`
	endDate := `2025-07-01 00:00:00`

	// 特殊的报告分类id列表（本身是章节报告，可是却要统计在普通报告里面）
	otherReportClassifyIdList := []int{185, 91}
	hongGuanReportClassifyId := []int{91}  // 宏观报告，需要按照二级分类来分组
	onlyReportClassifyIdList := []int{185} // 章节报告，但是需要统计成普通报告

	adminIdList := make([]int, 0)
	adminIdMap := make(map[int]string)
	adminClassifyMap := make(map[int]map[int]*models.ExportReportItem)

	type ClassifyItem struct {
		ClassifyIdFirst    int
		ClassifyNameFirst  string
		ClassifyIdSecond   int
		ClassifyNameSecond string
	}
	classifyIdMap := make(map[int]ClassifyItem)

	realClassifyIdFirstMap := make(map[int]bool)
	realFirstClassifyIdSecondMap := make(map[int]map[int]bool)

	// 普通报告
	exportReportList, err := models.GetExportReportList(startDate, endDate, otherReportClassifyIdList)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取普通报告列表失败：%s", err.Error()))
		return
	}
	for _, v := range exportReportList {
		_, ok := adminIdMap[v.AdminId]
		if !ok {
			adminIdList = append(adminIdList, v.AdminId)
			adminIdMap[v.AdminId] = v.AdminName
			adminClassifyMap[v.AdminId] = make(map[int]*models.ExportReportItem)
		}

		_, ok = classifyIdMap[v.ClassifyIdFirst]
		if !ok {
			classifyItem := ClassifyItem{
				ClassifyIdFirst:   v.ClassifyIdFirst,
				ClassifyNameFirst: v.ClassifyNameFirst,
			}
			classifyIdMap[v.ClassifyIdFirst] = classifyItem
			realClassifyIdFirstMap[v.ClassifyIdFirst] = true
		}

		adminClassifyMap[v.AdminId][v.ClassifyIdFirst] = v
	}

	// 章节报告
	exportReportChapterList, err := models.GetExportReportChapterList(startDate, endDate, otherReportClassifyIdList)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取章节报告列表失败：%s", err.Error()))
		return
	}

	for _, v := range exportReportChapterList {
		_, ok := adminIdMap[v.AdminId]
		if !ok {
			adminIdList = append(adminIdList, v.AdminId)
			adminIdMap[v.AdminId] = v.AdminName
			adminClassifyMap[v.AdminId] = make(map[int]*models.ExportReportItem)
		}

		_, ok = classifyIdMap[v.ClassifyIdFirst]
		if !ok {
			classifyIdMap[v.ClassifyIdFirst] = ClassifyItem{
				ClassifyIdFirst:   v.ClassifyIdFirst,
				ClassifyNameFirst: v.ClassifyNameFirst,
			}
			realClassifyIdFirstMap[v.ClassifyIdFirst] = true
		}

		if exportReportItem, ok := adminClassifyMap[v.AdminId][v.ClassifyIdFirst]; ok {
			v.Total = exportReportItem.Total + v.Total
		}
		adminClassifyMap[v.AdminId][v.ClassifyIdFirst] = v
	}

	// 特殊的报告列表（本身是章节报告，可是却要统计在普通报告里面）
	exportOtherReportList, err := models.GetExportReportListByClassifyIdList(startDate, endDate, onlyReportClassifyIdList)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取特殊的报告列表失败：%s", err.Error()))
		return
	}

	// 其他类型的报告
	for _, v := range exportOtherReportList {
		_, ok := adminIdMap[v.AdminId]
		if !ok {
			adminIdList = append(adminIdList, v.AdminId)
			adminIdMap[v.AdminId] = v.AdminName
			adminClassifyMap[v.AdminId] = make(map[int]*models.ExportReportItem)
		}

		_, ok = classifyIdMap[v.ClassifyIdFirst]
		if !ok {
			classifyIdMap[v.ClassifyIdFirst] = ClassifyItem{
				ClassifyIdFirst:   v.ClassifyIdFirst,
				ClassifyNameFirst: v.ClassifyNameFirst,
			}
			realClassifyIdFirstMap[v.ClassifyIdFirst] = true
		}

		if exportReportItem, ok := adminClassifyMap[v.AdminId][v.ClassifyIdFirst]; ok {
			v.Total = exportReportItem.Total + v.Total
		}
		adminClassifyMap[v.AdminId][v.ClassifyIdFirst] = v
	}

	// 特殊的报告列表（本身是章节报告，可是却要统计在普通报告里面）
	exportHongGuanReportList, err := models.GetExportHongGuanReportListByClassifyIdList(startDate, endDate, hongGuanReportClassifyId)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取宏观报告列表失败：%s", err.Error()))
		return
	}

	// 宏观报告类型的报告
	for _, v := range exportHongGuanReportList {
		_, ok := adminIdMap[v.AdminId]
		if !ok {
			adminIdList = append(adminIdList, v.AdminId)
			adminIdMap[v.AdminId] = v.AdminName
			adminClassifyMap[v.AdminId] = make(map[int]*models.ExportReportItem)
		}

		_, ok = classifyIdMap[v.ClassifyIdSecond]
		if !ok {
			classifyIdMap[v.ClassifyIdSecond] = ClassifyItem{
				ClassifyIdFirst:    v.ClassifyIdFirst,
				ClassifyNameFirst:  v.ClassifyNameFirst,
				ClassifyIdSecond:   v.ClassifyIdSecond,
				ClassifyNameSecond: v.ClassifyNameSecond,
			}
			//realClassifyIdFirstMap[v.ClassifyIdFirst] = true
		}

		_, ok = realFirstClassifyIdSecondMap[v.ClassifyIdFirst]
		if !ok {
			realFirstClassifyIdSecondMap[v.ClassifyIdFirst] = make(map[int]bool)
		}
		realFirstClassifyIdSecondMap[v.ClassifyIdFirst][v.ClassifyIdSecond] = true

		if exportReportItem, ok := adminClassifyMap[v.AdminId][v.ClassifyIdSecond]; ok {
			v.Total = exportReportItem.Total + v.Total
		}
		adminClassifyMap[v.AdminId][v.ClassifyIdSecond] = v
	}

	// 语音播报的数据
	voiceBroadcastStat, err := models.GetExportVoiceBroadcastList(startDate, endDate)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取语音播报列表失败：%s", err.Error()))
		return
	}
	adminNameMap := map[string]int{
		`姚昕泽`: 251,
		`张立舟`: 466,
		`郑露`:  478,
		`方正`:  761,
	}
	voiceBroadcastMap := make(map[int]int)
	for _, voiceBroadcast := range voiceBroadcastStat {
		adminId, ok := adminNameMap[voiceBroadcast.AdminName]
		if !ok {
			panic(voiceBroadcast.AdminName + "未匹配到系统用户ID")
		}
		voiceBroadcastMap[adminId] = voiceBroadcast.Total
	}

	//dir, _ := os.Executable()
	//exPath := filepath.Dir(dir)
	//
	//downLoadnFilePath := exPath + "/研究员报告统计.xlsx"
	downLoadnFilePath := "static/imgs/研究员报告统计.xlsx"
	xlsxFile := xlsx.NewFile()

	if err != nil {
		fmt.Println("新增Sheet失败", err.Error())
		return
	}
	//sheetNew.SetColWidth()
	// 获取研究员报告统计
	sheetNew, _ := xlsxFile.AddSheet("研究员报告统计")
	titleRow := sheetNew.AddRow()
	titleRow.AddCell().SetValue("研究员")

	classifyFirstIdList := []int{124, 180, 179, 181, 42, 125, 214, 96, 91, 129, 175, 185}
	classifySecondIdMap := make(map[int][]int)
	classifySecondIdMap[91] = []int{55, 93, 94, 113, 114, 154, 161, 197, 208, 224, 226, 227, 228, 239}

	sortClassifyIdList := make([]int, 0)

	for k, classifyFirstId := range classifyFirstIdList {
		if k == 1 {
			// 语音播报需要插在第二列
			titleRow.AddCell().SetValue(`语音播报`)
		}
		if tmpClassifySecondIdList, ok := classifySecondIdMap[classifyFirstId]; ok {
			// 该一级分类下真实的二级分类列表
			realClassifyIdSecondMap := realFirstClassifyIdSecondMap[classifyFirstId]

			for _, classifySecondId := range tmpClassifySecondIdList {
				classifyName := ``
				if classifyItem, ok := classifyIdMap[classifySecondId]; ok {
					classifyName = fmt.Sprintf("%s \n（%s）", classifyItem.ClassifyNameFirst, classifyItem.ClassifyNameSecond)
				}
				titleRow.AddCell().SetValue(classifyName)

				delete(realClassifyIdSecondMap, classifySecondId)
				sortClassifyIdList = append(sortClassifyIdList, classifySecondId)
			}

			// 后面新加的二级分类
			for classifySecondId, _ := range realClassifyIdSecondMap {
				classifyName := ``
				if classifyItem, ok := classifyIdMap[classifySecondId]; ok {
					classifyName = fmt.Sprintf("%s \n（%s）", classifyItem.ClassifyNameFirst, classifyItem.ClassifyNameSecond)
				}
				titleRow.AddCell().SetValue(classifyName)

				delete(realClassifyIdSecondMap, classifySecondId)
				sortClassifyIdList = append(sortClassifyIdList, classifySecondId)
			}
		} else {
			classifyName := ``
			if classifyItem, ok := classifyIdMap[classifyFirstId]; ok {
				classifyName = classifyItem.ClassifyNameFirst
			}
			titleRow.AddCell().SetValue(classifyName)

			delete(realClassifyIdFirstMap, classifyFirstId)
			sortClassifyIdList = append(sortClassifyIdList, classifyFirstId)
		}
	}

	// 后面新加的一级分类
	for classifyFirstId, _ := range realClassifyIdFirstMap {
		classifyName := ``
		if classifyItem, ok := classifyIdMap[classifyFirstId]; ok {
			classifyName = classifyItem.ClassifyNameFirst
		}
		titleRow.AddCell().SetValue(classifyName)

		delete(realClassifyIdFirstMap, classifyFirstId)
		sortClassifyIdList = append(sortClassifyIdList, classifyFirstId)
	}

	for adminId, classifyMap := range adminClassifyMap {
		dataRow := sheetNew.AddRow()
		dataRow.AddCell().SetValue(adminIdMap[adminId])
		for k, classifyId := range sortClassifyIdList {

			if k == 1 { // 语音播报
				dataRow.AddCell().SetValue(voiceBroadcastMap[adminId])
			}
			reportItem, ok := classifyMap[classifyId]
			total := 0
			if ok {
				total = reportItem.Total
			}
			dataRow.AddCell().SetValue(total)
		}
	}

	// 路演统计
	err = exportRoadShowReport(startDate, endDate, xlsxFile)
	if err != nil {
		fmt.Println("路演统计失败,err:", err)
		return
	}

	// 英文研报统计
	err = exportEnglishReport(startDate, endDate, xlsxFile)
	if err != nil {
		fmt.Println("英文研报统计失败,err:", err)
		return
	}

	err = xlsxFile.Save(downLoadnFilePath)
	if err != nil {
		fmt.Println("保存文件失败,err:", err)
		return
	}

	fmt.Println("操作完成")
}

// exportRoadShowReport
// @Description: 路演统计
// @param startDate
// @param endDate
// @param xlsxFile
// @return err
func exportRoadShowReport(startDate, endDate string, xlsxFile *xlsx.File) (err error) {
	sheetNew, _ := xlsxFile.AddSheet("研究员路演统计")
	titleRow := sheetNew.AddRow()
	titleRow.AddCell().SetValue("研究员")
	titleRow.AddCell().SetValue("试用路演（已反馈）")
	titleRow.AddCell().SetValue("试用路演（未反馈）")
	titleRow.AddCell().SetValue("正式路演（已反馈）")
	titleRow.AddCell().SetValue("正式路演（未反馈）")
	titleRow.AddCell().SetValue("公开会议")

	userList, err := roadshow.GetResearcherListV2()
	if err != nil {
		fmt.Println(`获取用户失败`)
		return
	}
	userMap := make(map[int]bool)
	for _, v := range userList {
		userMap[v.AdminId] = true
	}

	adminDataMap, err := getResearcherSectionData(startDate, endDate)
	if err != nil {
		fmt.Println("获取时间区间数据失败：", err.Error())
		return
	}
	for adminId, adminName := range adminDataMap.AdminIdMap {
		if !userMap[adminId] {
			continue
		}
		dataRow := sheetNew.AddRow()
		dataRow.AddCell().SetValue(adminName)

		// 试用路演
		askTryOutNum := adminDataMap.AskTryOutMap[adminId]
		noAskTryOutNum := adminDataMap.TryOutMap[adminId] - askTryOutNum
		dataRow.AddCell().SetValue(askTryOutNum)
		dataRow.AddCell().SetValue(noAskTryOutNum)

		// 正式路演
		askFormalNum := adminDataMap.AskFormalMap[adminId]
		noAskFormalNum := adminDataMap.FormalMap[adminId] - askFormalNum
		dataRow.AddCell().SetValue(askFormalNum)
		dataRow.AddCell().SetValue(noAskFormalNum)

		// 公开会议
		dataRow.AddCell().SetValue(adminDataMap.MeetingMap[adminId])
	}

	return
}

type AdminDataMap struct {
	TryOutMap    map[int]int    `description:"试用路演次数"`
	FormalMap    map[int]int    `description:"正式路演次数"`
	MeetingMap   map[int]int    `description:"会议次数"`
	AskTryOutMap map[int]int    `description:"试用路演次数（已反馈）"`
	AskFormalMap map[int]int    `description:"正式路演次数（已反馈）"`
	StartDate    string         `description:"开始日期"`
	EndDate      string         `description:"开始日期"`
	AdminIdMap   map[int]string `description:"系统用户名称"`
}

// getResearcherSectionData 获取研究员周期数据
func getResearcherSectionData(startDateStr, endDateStr string) (adminDataMap AdminDataMap, err error) {
	startDate, _ := time.ParseInLocation(utils.FormatDateTime, startDateStr, time.Local)
	endDate, _ := time.ParseInLocation(utils.FormatDateTime, endDateStr, time.Local)
	endDate = endDate.Add(-1 * time.Second) //本月最后一天

	tryOutMap := make(map[int]int)
	formalMap := make(map[int]int)
	meetingMap := make(map[int]int)
	asktryOutMap := make(map[int]int)  //填写过客户问答的路演次数(试用)
	askformalMap := make(map[int]int)  //填写过客户问答的路演次数(正式)
	adminIdMap := make(map[int]string) //系统用户名称
	//正式客户
	{
		var condition string
		var pars []interface{}
		condition = ` and start_date >= ? and end_date <= ?  and company_status = ? `
		pars = append(pars, startDate, endDate, "正式")
		data, tmpErr := roadshow.GetGroupResearcherRecordList(condition, pars)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range data {
			formalMap[v.AdminId] = v.Num
			adminIdMap[v.AdminId] = v.AdminName
		}

		var conditionAsk string
		var parsAsk []interface{}
		conditionAsk = ` and  c.question_status = 1  and a.start_date >= ? and a.end_date <= ?  and a.company_status = ? `
		parsAsk = append(parsAsk, startDate, endDate, "正式")
		dataAsk, tmpErr := roadshow.GetGroupResearcherRecordListAsk(conditionAsk, parsAsk)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range dataAsk {
			askformalMap[v.AdminId] = v.Num
			adminIdMap[v.AdminId] = v.AdminName
		}
	}

	//试用客户
	{
		var condition string
		var pars []interface{}
		condition = ` and start_date >= ? and end_date <= ? and company_status = ? `
		pars = append(pars, startDate, endDate, "试用")
		data, tmpErr := roadshow.GetGroupResearcherRecordList(condition, pars)

		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range data {
			//fmt.Println(v)
			tryOutMap[v.AdminId] = v.Num
			adminIdMap[v.AdminId] = v.AdminName
		}

		var conditionAsk string
		var parsAsk []interface{}
		conditionAsk = ` and  c.question_status = 1  and a.start_date >= ? and a.end_date <= ?  and a.company_status = ? `
		parsAsk = append(parsAsk, startDate, endDate, "试用")
		dataAsk, tmpErr := roadshow.GetGroupResearcherRecordListAsk(conditionAsk, parsAsk)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range dataAsk {
			asktryOutMap[v.AdminId] = v.Num
			adminIdMap[v.AdminId] = v.AdminName
		}
	}

	//公开会议
	{
		var condition string
		var pars []interface{}
		condition = ` and start_date >= ? and end_date <= ? and activity_type = ? `
		pars = append(pars, startDate, endDate, "公开会议")
		data, tmpErr := roadshow.GetGroupResearcherRecordList(condition, pars)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range data {
			//fmt.Println(v)
			meetingMap[v.AdminId] = v.Num
			adminIdMap[v.AdminId] = v.AdminName
		}
	}

	adminDataMap = AdminDataMap{
		TryOutMap:    tryOutMap,
		FormalMap:    formalMap,
		MeetingMap:   meetingMap,
		AdminIdMap:   adminIdMap,
		AskTryOutMap: asktryOutMap,
		AskFormalMap: askformalMap,
		StartDate:    startDate.Format(utils.FormatDate),
		EndDate:      endDate.Format(utils.FormatDate),
	}
	return
}

// exportRoadShowReport
// @Description: 路演统计
// @param startDate
// @param endDate
// @param xlsxFile
// @return err
func exportEnglishReport(startDate, endDate string, xlsxFile *xlsx.File) (err error) {
	sheetNew, _ := xlsxFile.AddSheet("研究员英文报告统计")
	titleRow := sheetNew.AddRow()
	titleRow.AddCell().SetValue("研究员")

	adminIdList := make([]int, 0)
	adminIdMap := make(map[int]string)
	adminClassifyMap := make(map[int]map[int]*models.ExportEnglishReportItem)

	type ClassifyItem struct {
		ClassifyIdFirst    int
		ClassifyNameFirst  string
		ClassifyIdSecond   int
		ClassifyNameSecond string
		ClassifyIdThird    int
		ClassifyNameThird  string
	}
	classifyIdMap := make(map[int]ClassifyItem)

	realClassifyIdFirstMap := make(map[int]bool)
	realClassifyIdSecondMap := make(map[int]bool)
	realClassifyIdThirdMap := make(map[int]bool)

	// 父级与子级的关系
	classifyIdChildIdMap := make(map[int]map[int]bool)

	// 普通报告
	exportReportList, err := models.GetExportEnglishReportList(startDate, endDate)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取普通报告列表失败：%s", err.Error()))
		return
	}
	//
	classifySecondIdList := make([]int, 0)
	for _, v := range exportReportList {
		classifySecondIdList = append(classifySecondIdList, v.SecondClassifyId)
	}

	obj := models.EnglishClassify{}
	secondClassifyList, err := obj.GetClassifyListByIdList(classifySecondIdList)
	if err != nil {
		fmt.Println(fmt.Sprintf("获取一级分类列表失败：%s", err.Error()))
		return
	}
	// 二级分类与一级分类的关系
	secondAndFirstMap := make(map[int]int)
	firstIdList := make([]int, 0)
	for _, v := range secondClassifyList {
		secondAndFirstMap[v.Id] = v.ParentId
		firstIdList = append(firstIdList, v.ParentId)
	}

	// 一级分类信息
	firstIdNameMap := make(map[int]string)
	{
		firstClassifyList, tmpErr := obj.GetClassifyListByIdList(firstIdList)
		if tmpErr != nil {
			fmt.Println(fmt.Sprintf("获取一级分类列表失败：%s", tmpErr.Error()))
			err = tmpErr
			return
		}
		for _, v := range firstClassifyList {
			firstIdNameMap[v.Id] = v.ClassifyName
			realClassifyIdFirstMap[v.Id] = true
		}
	}

	for _, v := range exportReportList {
		_, ok := adminIdMap[v.AdminId]
		if !ok {
			adminIdList = append(adminIdList, v.AdminId)
			adminIdMap[v.AdminId] = v.AdminName
			adminClassifyMap[v.AdminId] = make(map[int]*models.ExportEnglishReportItem)
		}

		_, ok = classifyIdMap[v.ThirdClassifyId]
		if !ok {
			classifyItem := ClassifyItem{
				ClassifyIdSecond:   v.SecondClassifyId,
				ClassifyNameSecond: v.SecondClassifyName,
				ClassifyIdThird:    v.ThirdClassifyId,
				ClassifyNameThird:  v.ThirdClassifyName,
			}
			firstId, ok := secondAndFirstMap[v.SecondClassifyId]
			if !ok {
				err = errors.New(`找不到父级分类id`)
				return
			}
			firstClassifyName, ok := firstIdNameMap[firstId]
			if !ok {
				err = errors.New(`找不到父级分类名称`)
				return
			}
			classifyItem.ClassifyIdFirst = firstId
			classifyItem.ClassifyNameFirst = firstClassifyName
			classifyIdMap[v.ThirdClassifyId] = classifyItem

			if classifyItem.ClassifyIdSecond > 0 {
				realClassifyIdSecondMap[classifyItem.ClassifyIdSecond] = true

				// 一级与二级的关系
				_, ok = classifyIdChildIdMap[classifyItem.ClassifyIdFirst]
				if !ok {
					classifyIdChildIdMap[classifyItem.ClassifyIdFirst] = make(map[int]bool)
				}
				classifyIdChildIdMap[classifyItem.ClassifyIdFirst][classifyItem.ClassifyIdSecond] = true
			}
			if classifyItem.ClassifyIdThird > 0 {
				realClassifyIdThirdMap[classifyItem.ClassifyIdThird] = true

				// 二级与三级的关系
				_, ok = classifyIdChildIdMap[classifyItem.ClassifyIdSecond]
				if !ok {
					classifyIdChildIdMap[classifyItem.ClassifyIdSecond] = make(map[int]bool)
				}

				classifyIdChildIdMap[classifyItem.ClassifyIdSecond][classifyItem.ClassifyIdThird] = true
			}
		}

		adminClassifyMap[v.AdminId][v.ThirdClassifyId] = v
	}

	realClassifyIdFirstList := getSortInt(realClassifyIdFirstMap)
	realClassifyIdSecondList := getSortInt(realClassifyIdSecondMap)
	realClassifyIdThirdList := getSortInt(realClassifyIdThirdMap)

	sortClassifyIdList := make([]int, 0)
	for _, firstId := range realClassifyIdFirstList {
		secondIdMap, ok := classifyIdChildIdMap[firstId]
		if !ok {
			fmt.Println("遍历realClassifyIdFirstList找不到一级分类Id")
		}
		for _, secondId := range realClassifyIdSecondList {
			if _, ok = secondIdMap[secondId]; !ok {
				continue
			}
			thirdIdMap, ok := classifyIdChildIdMap[secondId]
			if !ok {
				fmt.Println("遍历realClassifyIdFirstList找不到二级分类Id")
			}
			for _, thirdId := range realClassifyIdThirdList {
				if _, ok = thirdIdMap[thirdId]; !ok {
					continue
				}

				classifyName := ``
				classifyItem, ok := classifyIdMap[thirdId]
				if ok {
					classifyName = fmt.Sprintf("%s\n（%s）\n（%s）", classifyItem.ClassifyNameFirst, classifyItem.ClassifyNameSecond, classifyItem.ClassifyNameThird)
				}
				titleRow.AddCell().SetValue(classifyName)
				sortClassifyIdList = append(sortClassifyIdList, thirdId)
			}
		}
	}

	for adminId, classifyMap := range adminClassifyMap {
		dataRow := sheetNew.AddRow()
		dataRow.AddCell().SetValue(adminIdMap[adminId])
		for _, classifyId := range sortClassifyIdList {

			reportItem, ok := classifyMap[classifyId]
			total := 0
			if ok {
				total = reportItem.Total
			}
			dataRow.AddCell().SetValue(total)
		}
	}

	return
}

func getSortInt(classifyIdMap map[int]bool) []int {
	// 1. 提取所有的 key 到切片中
	keys := make([]int, 0, len(classifyIdMap))
	for k := range classifyIdMap {
		keys = append(keys, k)
	}

	// 2. 对 key 进行升序排序
	sort.Ints(keys)

	return keys
}