eta_api/controllers/data_manage/ai_predict_model/index.go

package ai_predict_model

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	aiPredictModel "eta/eta_api/models/ai_predict_model"
	"eta/eta_api/models/ai_predict_model/request"
	"eta/eta_api/models/ai_predict_model/response"
	"eta/eta_api/models/data_manage"
	dataSourceModel "eta/eta_api/models/data_source"
	"eta/eta_api/models/system"
	"eta/eta_api/services"
	"eta/eta_api/services/data"
	"eta/eta_api/services/elastic"
	"eta/eta_api/utils"
	"fmt"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/tealeg/xlsx"
)

// AiPredictModelIndexController AI预测模型标的
type AiPredictModelIndexController struct {
	controllers.BaseAuthController
}

// List
// @Title 标的列表
// @Description 标的列表
// @Param   PageSize   query   int   true   "每页数据条数"
// @Param   CurrentIndex   query   int   true   "当前页页码，从1开始"
// @Param   ClassifyId   query   int   false   "分类id"
// @Param   IndexId   query   int   false   "模型标的ID"
// @Param   Keyword   query   string   false   "搜索关键词"
// @Success 200 {object} data_manage.ChartListResp
// @router /index/list [get]
func (this *AiPredictModelIndexController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	classifyId, _ := this.GetInt("ClassifyId")
	indexId, _ := this.GetInt("IndexId")
	keyword := this.GetString("KeyWord")
	if keyword == "" {
		keyword = this.GetString("Keyword")
	}
	keyword = strings.TrimSpace(keyword)
	resp := new(aiPredictModel.AiPredictModelIndexPageListResp)

	// 分页
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	// 分类
	classifyIdName := make(map[int]string)
	{
		classifyOb := new(aiPredictModel.AiPredictModelClassify)
		list, e := classifyOb.GetItemsByCondition("", make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取分类失败, %v", e)
			return
		}
		for _, v := range list {
			classifyIdName[v.AiPredictModelClassifyId] = v.ClassifyName
		}
	}
	classifyIds := make([]int, 0)
	// 筛选条件
	highlightMap := make(map[int]string)
	indexOb := new(aiPredictModel.AiPredictModelIndex)
	var cond string
	var pars []interface{}
	{
		if indexId > 0 {
			cond += fmt.Sprintf(" AND %s = ?", indexOb.Cols().PrimaryId)
			pars = append(pars, indexId)
		}
		if classifyId > 0 {
			// 查询所有子分类
			classifyInfo, err := aiPredictModel.GetAiPredictModelClassifyById(classifyId)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "查询失败"
				br.ErrMsg = "查询失败，Err:" + err.Error()
				return
			}
			classifyIds, err = aiPredictModel.GetAiPredictModelClassifyChildIdsByLevelPath(classifyInfo.LevelPath)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "查询失败"
				br.ErrMsg = "查询子分类失败，Err:" + err.Error()
				return
			}
			cond += fmt.Sprintf(" AND %s IN (%s)", indexOb.Cols().ClassifyId, utils.GetOrmInReplace(len(classifyIds)))
			pars = append(pars, classifyIds)
		}
		//if keyword != "" {
		//	cond += fmt.Sprintf(" AND %s LIKE ?", indexOb.Cols().IndexName)
		//	pars = append(pars, fmt.Sprint("%", keyword, "%"))
		//}

		// 有关键词从es中搜索
		if keyword != "" {
			_, list, e := elastic.SearchDataSourceIndex(utils.EsDataSourceIndexName, keyword, utils.DATA_SOURCE_AI_PREDICT_MODEL, 0, classifyIds, []int{}, []string{}, startSize, pageSize)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprintf("ES-搜索AI预测模型列表失败, %v", e)
				return
			}
			if len(list) == 0 {
				resp.List = make([]*aiPredictModel.AiPredictModelIndexItem, 0)
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			}
			var ids []int
			for _, v := range list {
				ids = append(ids, v.PrimaryId)
				highlightMap[v.PrimaryId] = v.SearchText
			}
			cond += fmt.Sprintf(` AND %s IN (%s)`, indexOb.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
			pars = append(pars, ids)
		}
	}

	// 获取列表
	total, e := indexOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取标的总数失败, %v", e)
		return
	}
	list, e := indexOb.GetPageItemsByCondition(cond, pars, []string{}, "", startSize, pageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取分页列表失败, %v", e)
		return
	}
	pageList := make([]*aiPredictModel.AiPredictModelIndexItem, 0)
	for _, v := range list {
		t := v.Format2Item()
		t.ClassifyName = classifyIdName[v.ClassifyId]
		// 搜索高亮
		t.SearchText = v.IndexName
		s := highlightMap[v.AiPredictModelIndexId]
		if s != "" {
			t.SearchText = s
		}
		pageList = append(pageList, t)
	}

	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page
	resp.List = pageList
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Import
// @Title 导入标的和数据
// @Description 导入标的和数据
// @Param   IndexFile   query   file   true   "标的文件"
// @Success 200 Ret=200 录入成功
// @router /index/import [post]
func (this *AiPredictModelIndexController) Import() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	file, _, e := this.GetFile("IndexFile")
	if e != nil {
		br.Msg = "导入失败"
		br.ErrMsg = fmt.Sprintf("获取文件失败, %v", e)
		return
	}
	path := "./static/ai_predict_model_temp_" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	defer func() {
		_ = file.Close()
		_ = os.Remove(path)
	}()
	if e = this.SaveToFile("IndexFile", path); e != nil {
		br.Msg = "导入失败"
		br.ErrMsg = fmt.Sprintf("保存文件失败, %v", e)
		return
	}
	xlFile, e := xlsx.OpenFile(path)
	if e != nil {
		br.Msg = "导入失败"
		br.ErrMsg = fmt.Sprintf("打开excel文件失败, %v", e)
		return
	}

	// 获取分类和用户，遍历时校验
	classifyNameId := make(map[string]int)
	classifyMap := make(map[int]string)
	adminNameId := make(map[string]int)
	{
		classifyOb := new(aiPredictModel.AiPredictModelClassify)
		classifyCond := ``
		classifyPars := make([]interface{}, 0)
		classifies, e := classifyOb.GetItemsByCondition(classifyCond, classifyPars, []string{}, "")
		if e != nil {
			br.Msg = "导入失败"
			br.ErrMsg = fmt.Sprintf("获取分类失败, %v", e)
			return
		}

		// 构建完整的分类路径映射
		for _, v := range classifies {
			if this.Lang == utils.EnLangVersion {
				classifyMap[v.AiPredictModelClassifyId] = v.ClassifyNameEn
			} else {
				classifyMap[v.AiPredictModelClassifyId] = v.ClassifyName
			}
		}
		for _, v := range classifies {
			levels := strings.Split(v.LevelPath, ",")
			fullName := ""
			for _, level := range levels {
				if level == "" {
					continue
				}
				cid, _ := strconv.Atoi(level)
				fullName = fullName + "/" + classifyMap[cid]
			}
			fullName = strings.Trim(fullName, "/")
			classifyNameId[fullName] = v.AiPredictModelClassifyId
		}

		admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "导入失败"
			br.ErrMsg = fmt.Sprintf("获取用户失败, %v", e)
			return
		}
		for _, v := range admins {
			adminNameId[v.RealName] = v.AdminId
		}
	}

	// 遍历sheet页
	// 列表页：预测标的|分类|模型框架|创建人|预测日期|预测值|预测频度|方向准确率|绝对偏差
	type ImportDataColKey struct {
		IndexName string
		ColKey    int
		DataDate  time.Time
	}
	imports := make(map[string]*aiPredictModel.AiPredictModelImportData)
	importsData := make(map[string]map[time.Time]*aiPredictModel.AiPredictModelData)
	importsDailyData := make(map[string]map[time.Time]*aiPredictModel.AiPredictModelData)
	for sheetKey, sheet := range xlFile.Sheets {
		maxRow := sheet.MaxRow

		// 列表页
		if sheetKey == 0 {
			for i := 0; i < maxRow; i++ {
				// 忽略首行标题
				if i < 1 {
					continue
				}
				row := sheet.Row(i)
				cells := row.Cells
				if len(cells) < 9 {
					continue
				}

				// 标的名称
				indexName := strings.TrimSpace(cells[0].String())
				if indexName == "" {
					continue
				}
				if imports[indexName] == nil {
					imports[indexName] = new(aiPredictModel.AiPredictModelImportData)
					imports[indexName].Index = new(aiPredictModel.AiPredictModelIndex)
					imports[indexName].Data = make([]*aiPredictModel.AiPredictModelData, 0)
				}
				imports[indexName].Index.IndexName = indexName
				imports[indexName].Index.CreateTime = time.Now()
				imports[indexName].Index.ModifyTime = time.Now()
				imports[indexName].Index.TrainStatus = `训练成功`
				imports[indexName].Index.RunStatus = `运行成功`

				// 分类改成多级用斜杠/区分例如：一级/二级/三级/四级/五级/六级
				classifyName := strings.TrimSpace(cells[1].String())
				if classifyNameId[classifyName] <= 0 {
					br.Msg = fmt.Sprintf("分类：%s不存在", classifyName)
					br.ErrMsg = fmt.Sprintf("分类：%s不存在，请先在系统中创建对应的分类", classifyName)
					return
				}
				imports[indexName].Index.ClassifyId = classifyNameId[classifyName]

				// 创建人
				adminName := strings.TrimSpace(cells[3].String())
				if adminNameId[adminName] <= 0 {
					br.Msg = fmt.Sprintf("创建人：%s不存在", adminName)
					return
				}
				imports[indexName].Index.SysUserId = adminNameId[adminName]
				imports[indexName].Index.SysUserRealName = adminName

				// 其余信息
				imports[indexName].Index.ModelFramework = strings.TrimSpace(cells[2].String())
				strDate := strings.TrimSpace(cells[4].String())
				predictDate, _ := utils.GetExcelDate(strDate)
				imports[indexName].Index.PredictDate = predictDate

				strVal := strings.TrimSpace(cells[5].String())
				if strVal == "" {
					continue
				}
				predictVal, _ := strconv.ParseFloat(strVal, 64)
				imports[indexName].Index.PredictValue = predictVal
				imports[indexName].Index.PredictFrequency = strings.TrimSpace(cells[6].String())
				imports[indexName].Index.DirectionAccuracy = strings.TrimSpace(cells[7].String())
				imports[indexName].Index.AbsoluteDeviation = strings.TrimSpace(cells[8].String())
			}
		}

		// 月度数据页
		if sheetKey == 1 {
			// 每五列为一个指标的数据
			colKeys := make(map[int]*ImportDataColKey) // 每一列对应的指标名称以及对应的字段序号
			for i := 0; i < maxRow; i++ {
				// 首行为指标名称
				if i == 0 {
					nameCol := 0
					row := sheet.Row(i)
					for ck, cell := range row.Cells {
						nameCol += 1
						if nameCol > 5 {
							nameCol = 1
						}
						if nameCol == 1 {
							// nameCol=1时为指标/数据行则为日期
							indexName := strings.TrimSpace(cell.String())
							if indexName == "" {
								continue
							}
							importsData[indexName] = make(map[time.Time]*aiPredictModel.AiPredictModelData)

							colKeys[ck] = &ImportDataColKey{
								ColKey:    1,
								IndexName: indexName,
							}

							// 后面四列分别对应: 实际值|预测值|方向|偏差率, 这里直接加无须考虑是否会越界
							colKeys[ck+1] = &ImportDataColKey{
								ColKey:    2,
								IndexName: indexName,
							}
							colKeys[ck+2] = &ImportDataColKey{
								ColKey:    3,
								IndexName: indexName,
							}
							colKeys[ck+3] = &ImportDataColKey{
								ColKey:    4,
								IndexName: indexName,
							}
							colKeys[ck+4] = &ImportDataColKey{
								ColKey:    5,
								IndexName: indexName,
							}
							continue
						}
					}
					continue
				}

				// 第二行为标题，跳过
				if i == 1 {
					continue
				}

				// 剩余为数据行
				row := sheet.Row(i)
				for ck, cell := range row.Cells {
					if colKeys[ck] == nil {
						continue
					}
					if colKeys[ck].IndexName == "" {
						continue
					}
					switch colKeys[ck].ColKey {
					case 1:
						// 日期列
						strDate := strings.TrimSpace(cell.String())
						dataDate, _ := utils.GetExcelDate(strDate)
						if dataDate.IsZero() {
							continue
						}
						colKeys[ck].DataDate = dataDate
						colKeys[ck+1].DataDate = dataDate
						colKeys[ck+2].DataDate = dataDate
						colKeys[ck+3].DataDate = dataDate
						colKeys[ck+4].DataDate = dataDate
						importRow := imports[colKeys[ck].IndexName]
						if importRow == nil {
							continue
						}
						// 新增当前日期数据
						importsData[colKeys[ck].IndexName][dataDate] = new(aiPredictModel.AiPredictModelData)
						importsData[colKeys[ck].IndexName][dataDate].DataTime = dataDate
						importsData[colKeys[ck].IndexName][dataDate].CreateTime = time.Now()
						importsData[colKeys[ck].IndexName][dataDate].ModifyTime = time.Now()
						importsData[colKeys[ck].IndexName][dataDate].Source = aiPredictModel.ModelDataSourceMonthly
					case 2, 3:
						// 实际值和预测值, 可能为空
						dataDate := colKeys[ck].DataDate
						if importsData[colKeys[ck].IndexName][dataDate] == nil {
							continue
						}
						strVal := strings.TrimSpace(cell.String())
						if strVal == "" {
							continue
						}
						val, _ := strconv.ParseFloat(strVal, 64)
						if colKeys[ck].ColKey == 2 {
							importsData[colKeys[ck].IndexName][dataDate].Value.Valid = true
							importsData[colKeys[ck].IndexName][dataDate].Value.Float64 = val
						} else {
							importsData[colKeys[ck].IndexName][dataDate].PredictValue.Valid = true
							importsData[colKeys[ck].IndexName][dataDate].PredictValue.Float64 = val
						}
					case 4, 5:
						// 方向/偏差率
						dataDate := colKeys[ck].DataDate
						if importsData[colKeys[ck].IndexName][dataDate] == nil {
							continue
						}
						str := strings.TrimSpace(cell.String())
						if str == "" {
							continue
						}
						if colKeys[ck].ColKey == 4 {
							importsData[colKeys[ck].IndexName][dataDate].Direction = str
						} else {
							importsData[colKeys[ck].IndexName][dataDate].DeviationRate = str
						}
					default:
						continue
					}
				}
			}
		}

		// 日度数据页
		if sheetKey == 2 {
			// 每3列为一个指标的数据
			colKeys := make(map[int]*ImportDataColKey) // 每一列对应的指标名称以及对应的字段序号
			for i := 0; i < maxRow; i++ {
				// 首行为指标名称
				if i == 0 {
					nameCol := 0
					row := sheet.Row(i)
					for ck, cell := range row.Cells {
						nameCol += 1
						if nameCol > 3 {
							nameCol = 1
						}
						if nameCol == 1 {
							// nameCol=1时为指标/数据行则为日期
							indexName := strings.TrimSpace(cell.String())
							if indexName == "" {
								continue
							}
							importsDailyData[indexName] = make(map[time.Time]*aiPredictModel.AiPredictModelData)

							colKeys[ck] = &ImportDataColKey{
								ColKey:    1,
								IndexName: indexName,
							}

							// 后面两列分别对应: 实际值|预测值, 这里直接加无须考虑是否会越界
							colKeys[ck+1] = &ImportDataColKey{
								ColKey:    2,
								IndexName: indexName,
							}
							colKeys[ck+2] = &ImportDataColKey{
								ColKey:    3,
								IndexName: indexName,
							}
							continue
						}
					}
					continue
				}

				// 第二行为标题，遇到"预测值"单元格，需要取出其中的值作为预测图例名称
				if i == 1 {
					row := sheet.Row(i)
					for ck, cell := range row.Cells {
						if colKeys[ck] == nil {
							continue
						}
						if colKeys[ck].IndexName == "" {
							continue
						}
						if colKeys[ck].ColKey != 3 {
							continue
						}
						if imports[colKeys[ck].IndexName] != nil && imports[colKeys[ck].IndexName].Index != nil {
							var extraConfig aiPredictModel.AiPredictModelIndexExtraConfig
							extraConfig.DailyChart.PredictLegendName = strings.TrimSpace(cell.String())
							b, _ := json.Marshal(extraConfig)
							imports[colKeys[ck].IndexName].Index.ExtraConfig = string(b)
						}
					}
					continue
				}

				// 剩余为数据行
				row := sheet.Row(i)
				for ck, cell := range row.Cells {
					if colKeys[ck] == nil {
						continue
					}
					if colKeys[ck].IndexName == "" {
						continue
					}
					switch colKeys[ck].ColKey {
					case 1:
						// 日期列
						strDate := strings.TrimSpace(cell.String())
						dataDate, _ := utils.GetExcelDate(strDate)
						if dataDate.IsZero() {
							continue
						}
						colKeys[ck].DataDate = dataDate
						colKeys[ck+1].DataDate = dataDate
						colKeys[ck+2].DataDate = dataDate
						importRow := imports[colKeys[ck].IndexName]
						if importRow == nil {
							continue
						}
						// 新增当前日期数据
						importsDailyData[colKeys[ck].IndexName][dataDate] = new(aiPredictModel.AiPredictModelData)
						importsDailyData[colKeys[ck].IndexName][dataDate].DataTime = dataDate
						importsDailyData[colKeys[ck].IndexName][dataDate].CreateTime = time.Now()
						importsDailyData[colKeys[ck].IndexName][dataDate].ModifyTime = time.Now()
						importsDailyData[colKeys[ck].IndexName][dataDate].Source = aiPredictModel.ModelDataSourceDaily
					case 2, 3:
						// 实际值和预测值, 可能为空
						dataDate := colKeys[ck].DataDate
						if importsDailyData[colKeys[ck].IndexName][dataDate] == nil {
							continue
						}
						strVal := strings.TrimSpace(cell.String())
						if strVal == "" {
							continue
						}
						val, _ := strconv.ParseFloat(strVal, 64)
						if colKeys[ck].ColKey == 2 {
							importsDailyData[colKeys[ck].IndexName][dataDate].Value.Valid = true
							importsDailyData[colKeys[ck].IndexName][dataDate].Value.Float64 = val
						} else {
							importsDailyData[colKeys[ck].IndexName][dataDate].PredictValue.Valid = true
							importsDailyData[colKeys[ck].IndexName][dataDate].PredictValue.Float64 = val
						}
					default:
						continue
					}
				}
			}
		}
	}

	for indexName, v := range importsData {
		if imports[indexName] == nil {
			continue
		}
		for _, dateData := range v {
			imports[indexName].Data = append(imports[indexName].Data, dateData)
		}
	}
	for indexName, v := range importsDailyData {
		if imports[indexName] == nil {
			continue
		}
		for _, dateData := range v {
			imports[indexName].Data = append(imports[indexName].Data, dateData)
		}
	}
	importIndexes := make([]*aiPredictModel.AiPredictModelImportData, 0)
	for _, v := range imports {
		importIndexes = append(importIndexes, v)
	}

	// 导入指标
	if e = services.ImportAiPredictModelIndexAndData(importIndexes, sysUser.AdminId, sysUser.RealName); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("导入指标数据失败, %v", e)
		return
	}

	// 写入es
	go func() {
		for _, v := range importIndexes {
			indexItem := new(dataSourceModel.SearchDataSource)
			indexItem.PrimaryId = v.Index.AiPredictModelIndexId
			indexItem.IndexName = v.Index.IndexName
			indexItem.IndexCode = v.Index.IndexCode
			indexItem.ClassifyId = v.Index.ClassifyId
			indexItem.Source = utils.DATA_SOURCE_AI_PREDICT_MODEL
			indexItem.SourceName = "AI预测模型"
			indexItem.CreateTime = utils.TimeTransferString(utils.FormatDateTime, v.Index.CreateTime)
			indexItem.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, v.Index.ModifyTime)

			docId := fmt.Sprintf("%d-%d", indexItem.Source, indexItem.PrimaryId)
			if e := elastic.EsAddOrEditDataSourceIndex(utils.EsDataSourceIndexName, docId, indexItem); e != nil {
				utils.FileLog.Info("AI预测模型-写入es失败, %v", e)
				continue
			}
		}
	}()

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Detail
// @Title 标的详情
// @Description 标的详情
// @Param   IndexId   query   int   true   "标的ID"
// @Success 200 {object} data_manage.ChartListResp
// @router /index/detail [get]
func (this *AiPredictModelIndexController) Detail() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	indexId, _ := this.GetInt("IndexId")
	if indexId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, IndexId: %d", indexId)
		return
	}
	resp := new(aiPredictModel.AiPredictModelDetailResp)

	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(indexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}

	// 获取标的数据
	monthData, dailyData := make([]*aiPredictModel.AiPredictModelData, 0), make([]*aiPredictModel.AiPredictModelData, 0)
	{
		tableData := make([]*aiPredictModel.AiPredictModelDataItem, 0)
		dataOb := new(aiPredictModel.AiPredictModelData)
		dataCond := fmt.Sprintf(` AND %s = ?`, dataOb.Cols().IndexCode)
		dataPars := make([]interface{}, 0)
		dataPars = append(dataPars, indexItem.IndexCode)
		list, e := dataOb.GetItemsByCondition(dataCond, dataPars, []string{}, fmt.Sprintf("%s DESC", dataOb.Cols().DataTime))
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取标的数据失败, %v", e)
			return
		}

		// tableData取月度数据，最多显示10条
		count, limit := 0, 10
		for _, v := range list {
			// 日度数据
			if v.Source == aiPredictModel.ModelDataSourceDaily {
				dailyData = append(dailyData, v)
				continue
			}

			// 月度数据
			if count < limit {
				tableData = append(tableData, v.Format2Item())
				count += 1
			}
			monthData = append(monthData, v)
		}
		resp.TableData = tableData
	}

	// 月度图表
	if len(monthData) > 0 {
		chartDetail, e := services.GetAiPredictChartDetailByData(indexItem, monthData, aiPredictModel.ModelDataSourceMonthly)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取月度图表失败, %v", e)
			return
		}
		resp.ChartView = chartDetail
	}

	// 日度图表
	if len(dailyData) > 0 {
		dailyChartDetail, e := services.GetAiPredictChartDetailByData(indexItem, dailyData, aiPredictModel.ModelDataSourceDaily)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取日度图表失败, %v", e)
			return
		}
		resp.DailyChartView = dailyChartDetail
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Save
// @Title 保存标的
// @Description 保存标的
// @Param	request	body aiPredictModel.AiPredictModelIndexSaveReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /index/save [post]
func (this *AiPredictModelIndexController) Save() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req aiPredictModel.AiPredictModelIndexSaveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.IndexId < 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("标的ID有误, IndexId: %d", req.IndexId)
		return
	}

	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(req.IndexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}

	var extraConfig aiPredictModel.AiPredictModelIndexExtraConfig
	if indexItem.ExtraConfig != "" {
		if e = json.Unmarshal([]byte(indexItem.ExtraConfig), &extraConfig); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("标的配置解析失败, %v", e)
			return
		}
	}
	if req.MonthlyChart != nil {
		extraConfig.MonthlyChart.LeftMin = req.MonthlyChart.LeftMin
		extraConfig.MonthlyChart.LeftMax = req.MonthlyChart.LeftMax
		extraConfig.MonthlyChart.Unit = req.MonthlyChart.Unit
	}
	if req.DailyChart != nil {
		extraConfig.DailyChart.LeftMin = req.DailyChart.LeftMin
		extraConfig.DailyChart.LeftMax = req.DailyChart.LeftMax
		extraConfig.DailyChart.Unit = req.DailyChart.Unit
	}

	configByte, _ := json.Marshal(extraConfig)
	indexItem.ExtraConfig = string(configByte)
	indexItem.ModifyTime = time.Now()
	updateCols := []string{indexOb.Cols().ExtraConfig, indexOb.Cols().ModifyTime}
	if e = indexItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("保存标的失败, %v", e)
		return
	}

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// DashboardSave
// @Title 保存看板
// @Description 保存看板
// @Param	request	body aiPredictModel.AiPredictModelDashboardSaveReq true "type json string"
// @Success 200 Ret=200 新增成功
// @router /index/dashboard/save [post]
func (this *AiPredictModelIndexController) DashboardSave() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req aiPredictModel.AiPredictModelDashboardSaveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.IndexId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, %d", req.IndexId)
		return
	}
	req.DashboardName = strings.TrimSpace(req.DashboardName)

	indexOb := new(aiPredictModel.AiPredictModelIndex)
	_, e := indexOb.GetItemById(req.IndexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}

	// 获取看板
	var isUpdate bool
	var updateCols []string
	dashboardItem := new(aiPredictModel.AiPredictModelDashboard)
	if req.IndexId > 0 {
		cond := fmt.Sprintf(" AND %s = ?", dashboardItem.Cols().AiPredictModelIndexId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.IndexId)
		item, e := dashboardItem.GetItemByCondition(cond, pars, "")
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取标的看板失败, %v", e)
			return
		}
		if item != nil && item.AiPredictModelIndexId > 0 {
			isUpdate = true
			dashboardItem = item
			dashboardItem.DashboardName = req.DashboardName
			dashboardItem.ModifyTime = time.Now()
			updateCols = append(updateCols, dashboardItem.Cols().DashboardName, dashboardItem.Cols().ModifyTime)
		}
	}
	if !isUpdate {
		dashboardItem.AiPredictModelIndexId = req.IndexId
		dashboardItem.DashboardName = req.DashboardName
		dashboardItem.SysUserId = sysUser.AdminId
		dashboardItem.SysUserRealName = sysUser.RealName
		dashboardItem.CreateTime = time.Now()
		dashboardItem.ModifyTime = time.Now()
	}

	// 详情
	dashboardDetails := make([]*aiPredictModel.AiPredictModelDashboardDetail, 0)
	for i, v := range req.List {
		t := &aiPredictModel.AiPredictModelDashboardDetail{
			Type:       v.Type,
			UniqueCode: v.UniqueCode,
			Sort:       i + 1,
			CreateTime: time.Now(),
			ModifyTime: time.Now(),
		}
		dashboardDetails = append(dashboardDetails, t)
	}

	// 保存
	if e := dashboardItem.SaveIndexDashboard(dashboardItem, dashboardDetails, isUpdate, updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("保存标的看板失败, %v", e)
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// DashboardDetail
// @Title 看板详情
// @Description 看板详情
// @Param   IndexId   query   int   true   "标的ID"
// @Success 200 {object} aiPredictModel.AiPredictModelDashboardDetailResp
// @router /index/dashboard/detail [get]
func (this *AiPredictModelIndexController) DashboardDetail() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	indexId, _ := this.GetInt("IndexId")
	resp := new(aiPredictModel.AiPredictModelDashboardDetailResp)

	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(indexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}
	resp.CreateUserId = indexItem.SysUserId
	resp.CreateUserRealName = indexItem.SysUserRealName

	// 获取标的看板
	dashboardOb := new(aiPredictModel.AiPredictModelDashboard)
	dashboardItem := new(aiPredictModel.AiPredictModelDashboardItem)
	{
		cond := fmt.Sprintf(" AND %s = ?", dashboardOb.Cols().AiPredictModelIndexId)
		pars := make([]interface{}, 0)
		pars = append(pars, indexId)
		item, e := dashboardOb.GetItemByCondition(cond, pars, "")
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取标的看板失败, %v", e)
			return
		}
		if item != nil {
			dashboardItem = item.Format2Item()
		}
	}

	// 获取看板详情
	dashboardDetails := make([]*aiPredictModel.AiPredictModelDashboardDetailItem, 0)
	if dashboardItem.DashboardId > 0 {
		detailOb := new(aiPredictModel.AiPredictModelDashboardDetail)
		cond := fmt.Sprintf(" AND %s = ?", detailOb.Cols().AiPredictModelDashboardId)
		pars := make([]interface{}, 0)
		pars = append(pars, dashboardItem.DashboardId)
		list, e := detailOb.GetItemsByCondition(cond, pars, []string{}, fmt.Sprintf("%s ASC", detailOb.Cols().Sort))
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取看板详情失败, %v", e)
			return
		}
		for _, v := range list {
			dashboardDetails = append(dashboardDetails, v.Format2Item())
		}
	}

	resp.AiPredictModelDashboardItem = dashboardItem
	resp.List = dashboardDetails
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// SearchByEs
// @Title 图表模糊搜索（从es获取）
// @Description  图表模糊搜索（从es获取）
// @Param   Keyword   query   string  true       "图表名称"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Param   Source   query   int  true       "来源，14：日度预测，15：月度预测，默认0：全部14+15"
// @Success 200 {object} data_manage.ChartInfo
// @router /chart/search_by_es [get]
func (this *AiPredictModelIndexController) SearchByEs() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	keyword := this.GetString("Keyword")
	keyword = strings.TrimSpace(keyword)
	if keyword == "" {
		keyword = this.GetString("KeyWord")
		keyword = strings.TrimSpace(keyword)
	}

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	showSysId := 0
	if isShowMe {
		showSysId = sysUser.AdminId
	}

	source, _ := this.GetInt("Source")
	sourceList := make([]int, 0)
	if source <= 0 {
		sourceList = append(sourceList, utils.CHART_SOURCE_AI_PREDICT_MODEL_MONTHLY, utils.CHART_SOURCE_AI_PREDICT_MODEL_DAILY)
	} else {
		sourceList = append(sourceList, source)
	}

	var searchList []*data_manage.ChartInfoMore
	var total int64
	var err error

	// 获取当前账号的不可见指标(AI预测的指标为标的均可见)
	noPermissionChartIdList := make([]int, 0)
	//{
	//	obj := data_manage.EdbInfoNoPermissionAdmin{}
	//	confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "获取失败"
	//		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
	//		return
	//	}
	//	for _, v := range confList {
	//		noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
	//	}
	//}

	if keyword != "" {
		searchList, total, err = data.EsSearchChartInfo(keyword, showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
	} else {
		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
	}

	finalList := make([]*data_manage.ChartInfoMore, 0)
	if len(searchList) > 0 {
		chartInfoIds := ""
		chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
		for _, v := range searchList {
			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
		}
		if chartInfoIds != "" {
			chartInfoIds = strings.Trim(chartInfoIds, ",")
			//判断是否需要展示英文标识
			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
				return
			}
			for _, v := range edbList {
				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
			}
		}

		for _, v := range searchList {
			tmp := new(data_manage.ChartInfoMore)
			tmp.ChartInfo = v.ChartInfo
			// 图表数据权限
			tmp.HaveOperaAuth = true
			//判断是否需要展示英文标识
			if edbTmpList, ok := chartEdbMap[v.ChartInfoId]; ok {
				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, edbTmpList, v.Source, v.ChartType)
			}
			tmp.SearchText = v.SearchText
			if tmp.SearchText == "" {
				tmp.SearchText = v.ChartName
			}
			finalList = append(finalList, tmp)
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyword
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))
	resp := data_manage.ChartInfoListByEsResp{
		Paging: page,
		List:   finalList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ScriptPathSave
// @Title 保存标的关联脚本路径
// @Description 保存标的关联脚本路径
// @Param	request	body request.AiPredictModelIndexSaveScriptPathReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /index/script_path/save [post]
func (this *AiPredictModelIndexController) ScriptPathSave() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.AiPredictModelIndexSaveScriptPathReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.IndexId < 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("标的ID有误, IndexId: %d", req.IndexId)
		return
	}
	req.ScriptPath = strings.TrimSpace(req.ScriptPath)
	if req.ScriptPath == "" {
		br.Msg = "标的路径不能为空"
		br.ErrMsg = fmt.Sprintf("标的路径有误, ScriptPath: %s", req.ScriptPath)
		return
	}

	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(req.IndexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}

	indexItem.ScriptPath = req.ScriptPath
	indexItem.ModifyTime = time.Now()
	updateCols := []string{indexOb.Cols().ScriptPath, indexOb.Cols().ModifyTime}
	if e = indexItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("保存标的失败, %v", e)
		return
	}

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// GetCurrentRunningAiPredictModelIndexCount
// @Title 获取当前正在运行中的模型数量
// @Description 获取当前正在运行中的模型数量
// @Success 200 Ret=200 保存成功
// @Success 200 {object} response.CurrentRunningCountResp
// @router /index/running/count [get]
func (this *AiPredictModelIndexController) GetCurrentRunningAiPredictModelIndexCount() {
	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 = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	// 查找当前标的是否存在待训练/训练中的模型
	count, err := services.GetCurrentRunningAiPredictModelIndexCount()
	if err != nil {
		br.Msg = "训练失败"
		br.ErrMsg = "训练失败，查找待训练的模型失败，Err:" + err.Error()
		return
	}

	resp := response.CurrentRunningCountResp{
		Total: count,
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Run
// @Title 获取当前正在运行中的模型数量
// @Description 获取当前正在运行中的模型数量
// @Success 200 Ret=200 保存成功
// @Success 200 {object} response.CurrentRunningCountResp
// @router /index/run [post]
func (this *AiPredictModelIndexController) Run() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req request.AiPredictModelIndexRunReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}

	classifyId := req.ClassifyId
	//indexId, _ := this.GetInt("IndexId")
	keyword := strings.TrimSpace(req.Keyword)

	// 查找当前标的是否存在待训练/训练中的模型
	count, err := services.GetCurrentRunningAiPredictModelIndexCount()
	if err != nil {
		br.Msg = "训练失败"
		br.ErrMsg = "训练失败，查找待训练的模型失败，Err:" + err.Error()
		return
	}
	if count > 0 {
		br.Msg = "当前有模型正在训练/运行中，请勿重复训练"
		br.ErrMsg = "当前有模型正在训练/运行中，请勿重复训练"
		br.IsSendEmail = false
		return
	}

	// 分类
	classifyIdName := make(map[int]string)
	{
		classifyOb := new(aiPredictModel.AiPredictModelClassify)
		list, e := classifyOb.GetItemsByCondition("", make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取分类失败, %v", e)
			return
		}
		for _, v := range list {
			classifyIdName[v.AiPredictModelClassifyId] = v.ClassifyName
		}
	}

	// 筛选条件
	highlightMap := make(map[int]string)
	indexOb := new(aiPredictModel.AiPredictModelIndex)
	var cond string
	var pars []interface{}

	cond += fmt.Sprintf(` AND %s NOT IN (?)  AND %s NOT IN (?) `, indexOb.Cols().TrainStatus, indexOb.Cols().RunStatus)
	pars = append(pars, []string{aiPredictModel.TrainStatusWaiting, aiPredictModel.TrainStatusTraining}, []string{aiPredictModel.RunStatusWaiting, aiPredictModel.RunStatusRunning})

	if req.SelectAll {
		// 如果列表全选
		if classifyId > 0 {
			cond += fmt.Sprintf(" AND %s = ?", indexOb.Cols().ClassifyId)
			pars = append(pars, classifyId)
		}

		// 有关键词从es中搜索
		if keyword != "" {
			// 使用scroll API获取所有匹配的数据
			list, e := getAllSearchDataSource(keyword, utils.DATA_SOURCE_AI_PREDICT_MODEL, 0)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprintf("获取失败,Err：%v", e)
				return
			}

			if len(list) == 0 {
				br.Msg = "没有找到可以运行的标的"
				br.IsSendEmail = false
				return
			}
			var ids []int
			for _, v := range list {
				ids = append(ids, v.PrimaryId)
				highlightMap[v.PrimaryId] = v.SearchText
			}
			cond += fmt.Sprintf(` AND %s IN (%s)`, indexOb.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
			pars = append(pars, ids)
		}

		// 不勾选的标的
		if len(req.NotIndexIdList) > 0 {
			var ids []int
			for _, v := range req.NotIndexIdList {
				ids = append(ids, v)
			}
			cond += fmt.Sprintf(` AND %s NOT IN (%s)`, indexOb.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
			pars = append(pars, ids)
		}
	} else {
		// 如果不是列表全选
		if len(req.IndexIdList) <= 0 {
			br.Msg = `请选择标的`
			br.IsSendEmail = false
			return
		}
		var ids []int
		for _, v := range req.IndexIdList {
			ids = append(ids, v)
		}
		cond += fmt.Sprintf(` AND %s IN (%s)`, indexOb.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
		pars = append(pars, ids)
	}

	// 获取列表
	list, e := indexOb.GetItemsByCondition(cond, pars, []string{`ai_predict_model_index_id,ai_predict_model_index_config_id,script_path`}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取列表失败, %v", e)
		return
	}

	indexIdList := make([]int, 0)
	for _, v := range list {
		// 没有配置python脚本路径
		if v.ScriptPath == `` {
			continue
		}
		// 没有配置默认参数
		if v.AiPredictModelIndexConfigId <= 0 {
			continue
		}
		indexIdList = append(indexIdList, v.AiPredictModelIndexId)
	}

	if len(indexIdList) <= 0 {
		br.Msg = "没有找到可以运行的标的"
		br.IsSendEmail = false
		return
	}

	err = indexOb.UpdateRunStatusByIdList(indexIdList)
	if err != nil {
		br.Msg = "运行失败"
		br.ErrMsg = fmt.Sprintf("运行失败, %v", e)
		return
	}

	// 加入模型运行任务中
	go services.AddAiModelRunTask(indexIdList, this.SysUser)

	br.Data = indexIdList
	br.Ret = 200
	br.Success = true
	br.Msg = "运行成功"
}

// getAllSearchDataSource
// @Description: 根据条件获取ES中的所有数据
// @author: Roc
// @datetime 2025-05-08 11:15:27
// @param keyword string
// @param source int
// @param subSource int
// @return list []*dataSourceModel.SearchDataSourceItem
// @return err error
func getAllSearchDataSource(keyword string, source, subSource int) (list []*dataSourceModel.SearchDataSourceItem, err error) {
	dataLimit := 1000 // 每页获取的数据量
	var scrollId string
	// 使用scroll API获取所有匹配的数据
	scrollId, list, e := elastic.SearchDataSourceIndexWithScroll(utils.EsDataSourceIndexName, keyword, source, subSource, []int{}, []int{}, []string{}, dataLimit)
	if e != nil {
		err = fmt.Errorf("ES-搜索列表失败, %v", e)
		return
	}
	// 最终清理用的 scrollId 放到一个指针里，保证 defer 拿到最新值
	finalScrollId := &scrollId

	defer func() {
		// 清除滚动查询的缓存
		if *finalScrollId != "" {
			elastic.ClearScrollDataSourceIndex(*finalScrollId)
		}
	}()

	// 如果scrollId不为空，说明还有更多数据，继续获取
	for scrollId != "" {
		nextScrollId, nextList, e := elastic.ScrollDataSourceIndex(scrollId)
		if e != nil {
			err = fmt.Errorf("ES-获取更多数据失败, %v", e)
			return
		}

		// 如果没有更多数据，则退出循环
		if len(nextList) <= 0 {
			break
		}

		list = append(list, nextList...)

		if nextScrollId != `` {
			scrollId = nextScrollId
			*finalScrollId = scrollId // 更新 finalScrollId 的指向内容
		}

	}

	return
}

// DownloadTemplate
// @Title 下载导入模版
// @Description 下载导入模版
// @Success 200 {object} models.EdbdataClassifyResp
// @Param   Source   query   int  false       "来源：1：同花顺；2：wind；34：钢联"
// @Param   IsApi   query   int  false       "是否api：1：是；0：否"
// @router /index/download_template [get]
func (c *AiPredictModelIndexController) DownloadTemplate() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	c.Ctx.Output.Download("./static/template/AI预测模型导入模版.xlsx", "AI预测模型导入模版.xlsx")

	br.Ret = 200
	br.Success = true
	br.Msg = "下载成功"
}

// Export
// @Title 导出AI预测模型
// @Description 导出AI预测模型
// @Success 200 {object} models.EdbdataClassifyResp
// @Param   IndexId   query   int  false       "预测标的ID"
// @router /index/export [get]
func (c *AiPredictModelIndexController) Export() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	indexId, _ := c.GetInt("IndexId")
	if indexId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, IndexId: %d", indexId)
		return
	}

	// 获取标的信息
	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(indexId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "标的已被删除，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取标的失败, %v", e)
		return
	}

	// 获取分类名称
	classifyOb := new(aiPredictModel.AiPredictModelClassify)
	classifies, e := classifyOb.GetItemsByCondition("", make([]interface{}, 0), []string{}, "")
	if e != nil {
		br.Msg = "导出失败"
		br.ErrMsg = fmt.Sprintf("获取分类失败, %v", e)
		return
	}

	// 构建分类ID到完整路径的映射
	classifyIdToFullPath := make(map[int]string)
	classifyMap := make(map[int]string)
	for _, v := range classifies {
		if c.Lang == utils.EnLangVersion {
			classifyMap[v.AiPredictModelClassifyId] = v.ClassifyNameEn
		} else {
			classifyMap[v.AiPredictModelClassifyId] = v.ClassifyName
		}
	}
	for _, v := range classifies {
		levels := strings.Split(v.LevelPath, ",")
		fullPath := ""
		for _, level := range levels {
			if level == "" {
				continue
			}
			cid, _ := strconv.Atoi(level)
			if fullPath == "" {
				fullPath = classifyMap[cid]
			} else {
				fullPath = fullPath + "/" + classifyMap[cid]
			}
		}
		classifyIdToFullPath[v.AiPredictModelClassifyId] = fullPath
	}

	// 获取标的数据
	dataOb := new(aiPredictModel.AiPredictModelData)
	dataCond := fmt.Sprintf(` AND %s = ?`, dataOb.Cols().IndexCode)
	dataPars := make([]interface{}, 0)
	dataPars = append(dataPars, indexItem.IndexCode)
	dataList, e := dataOb.GetItemsByCondition(dataCond, dataPars, []string{}, fmt.Sprintf("%s DESC", dataOb.Cols().DataTime))
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取标的数据失败, %v", e)
		return
	}

	// 创建Excel文件
	xlFile := xlsx.NewFile()

	// 创建预测标的列表页
	sheet1, err := xlFile.AddSheet("列表页")
	if err != nil {
		br.Msg = "导出失败"
		br.ErrMsg = fmt.Sprintf("创建Excel sheet失败, %v", err)
		return
	}

	// 添加标题行
	titleRow := sheet1.AddRow()
	titles := []string{"预测标的", "分类", "模型类别", "创建人", "预测日期", "预测值", "预测频度", "方向准确率", "绝对偏差"}
	for _, title := range titles {
		cell := titleRow.AddCell()
		cell.Value = title
	}

	// 添加数据行
	dataRow := sheet1.AddRow()
	dataRow.AddCell().Value = indexItem.IndexName
	dataRow.AddCell().Value = classifyIdToFullPath[indexItem.ClassifyId]
	dataRow.AddCell().Value = indexItem.ModelFramework
	dataRow.AddCell().Value = indexItem.SysUserRealName
	dataRow.AddCell().Value = indexItem.PredictDate.Format("2006-01-02")
	dataRow.AddCell().Value = fmt.Sprintf("%.4f", indexItem.PredictValue)
	dataRow.AddCell().Value = indexItem.PredictFrequency
	dataRow.AddCell().Value = indexItem.DirectionAccuracy
	dataRow.AddCell().Value = indexItem.AbsoluteDeviation

	// 创建月度数据页
	sheet2, err := xlFile.AddSheet("详情页")
	if err != nil {
		br.Msg = "导出失败"
		br.ErrMsg = fmt.Sprintf("创建Excel sheet失败, %v", err)
		return
	}

	// 添加标的名称行
	nameRow := sheet2.AddRow()
	nameCell := nameRow.AddCell()
	nameCell.Value = indexItem.IndexName

	// 添加标题行
	titleRow2 := sheet2.AddRow()
	titles2 := []string{"指标日期", "实际值", "预测值", "方向", "偏差率"}
	for _, title := range titles2 {
		cell := titleRow2.AddCell()
		cell.Value = title
	}

	// 添加月度数据
	monthlyData := make([]*aiPredictModel.AiPredictModelData, 0)
	for _, data := range dataList {
		if data.Source == aiPredictModel.ModelDataSourceMonthly {
			monthlyData = append(monthlyData, data)
		}
	}
	for _, data := range monthlyData {
		dataRow := sheet2.AddRow()
		dataRow.AddCell().Value = data.DataTime.Format("2006-01-02")
		if data.Value.Valid {
			dataRow.AddCell().Value = fmt.Sprintf("%.4f", data.Value.Float64)
		} else {
			dataRow.AddCell().Value = ""
		}
		if data.PredictValue.Valid {
			dataRow.AddCell().Value = fmt.Sprintf("%.4f", data.PredictValue.Float64)
		} else {
			dataRow.AddCell().Value = ""
		}
		dataRow.AddCell().Value = data.Direction
		dataRow.AddCell().Value = data.DeviationRate
	}

	// 创建日度数据页
	sheet3, err := xlFile.AddSheet("日度数据表")
	if err != nil {
		br.Msg = "导出失败"
		br.ErrMsg = fmt.Sprintf("创建Excel sheet失败, %v", err)
		return
	}

	// 添加标的名称行
	nameRow3 := sheet3.AddRow()
	nameCell3 := nameRow3.AddCell()
	nameCell3.Value = indexItem.IndexName

	// 添加标题行
	titleRow3 := sheet3.AddRow()
	titles3 := []string{"日期", "实际值", "预测值"}
	for _, title := range titles3 {
		cell := titleRow3.AddCell()
		cell.Value = title
	}

	// 添加日度数据
	dailyData := make([]*aiPredictModel.AiPredictModelData, 0)
	for _, data := range dataList {
		if data.Source == aiPredictModel.ModelDataSourceDaily {
			dailyData = append(dailyData, data)
		}
	}
	for _, data := range dailyData {
		dataRow := sheet3.AddRow()
		dataRow.AddCell().Value = data.DataTime.Format("2006-01-02")
		if data.Value.Valid {
			dataRow.AddCell().Value = fmt.Sprintf("%.4f", data.Value.Float64)
		} else {
			dataRow.AddCell().Value = ""
		}
		if data.PredictValue.Valid {
			dataRow.AddCell().Value = fmt.Sprintf("%.4f", data.PredictValue.Float64)
		} else {
			dataRow.AddCell().Value = ""
		}
	}

	// 文件名称：预测标的名称+年月日
	fileName := fmt.Sprintf("%s_%s.xlsx", indexItem.IndexName, time.Now().Format(utils.FormatDateShortUnSpace))
	filePath := "./static/" + fileName

	// 保存Excel文件
	if err := xlFile.Save(filePath); err != nil {
		br.Msg = "导出失败"
		br.ErrMsg = fmt.Sprintf("保存Excel文件失败, %v", err)
		return
	}

	// 下载文件
	defer os.Remove(filePath)
	c.Ctx.Output.Download(filePath, fileName)

	br.Ret = 200
	br.Success = true
	br.Msg = "导出成功"
}