eta_index_lib/controllers/ai_predict_model/index.go

package ai_predict_model

import (
	"encoding/json"
	"errors"
	"eta/eta_index_lib/controllers"
	aiPredictModelLogic "eta/eta_index_lib/logic/ai_predict_model"
	"eta/eta_index_lib/models"
	"eta/eta_index_lib/models/ai_predict_model"
	"eta/eta_index_lib/models/ai_predict_model/response"
	"eta/eta_index_lib/utils"
	"fmt"
	"github.com/go-redis/redis/v8"
	"strconv"
)

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

type IndexTaskRecordOp struct {
	IndexTaskRecordId int
	TaskType          string
}

// 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 /op_todo [post]
func (this *AiPredictModelIndexController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	resp := response.AiPredictModelIndexConfigResp{}

	val, err := utils.Rc.BrpopVal(utils.CACHE_INDEX_TASK)
	if err != nil {
		if errors.Is(err, redis.Nil) {
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}

		br.Msg = "获取失败"
		br.ErrMsg = `从redis中获取数据失败，Err:` + err.Error()

		return
	}

	indexTaskRecordOp := new(IndexTaskRecordOp)
	if err = json.Unmarshal([]byte(val), &indexTaskRecordOp); err != nil {
		fmt.Println("json unmarshal wrong!")
		return
	}

	indexTaskRecordObj := new(models.IndexTaskRecord)
	indexTaskRecordInfo, err := indexTaskRecordObj.GetByID(indexTaskRecordOp.IndexTaskRecordId)
	if err != nil {
		fmt.Println("get index task record info wrong!")
		br.Msg = "获取失败"
		return
	}
	if indexTaskRecordInfo.Status != `待处理` {
		fmt.Println("任务状态不是待运行!")
		br.Msg = "任务状态不是待运行"
		return
	}

	var indexConfigItem *ai_predict_model.AiPredictModelIndexConfig
	var indexItem *ai_predict_model.AiPredictModelIndex

	resp.IndexTaskRecordId = indexTaskRecordInfo.IndexTaskRecordID

	defer func() {
		// 获取完成任务后，需要更新任务状态
		if resp.AiPredictModelIndexId <= 0 {
			// 如果获取失败了，那么就标记失败
			go aiPredictModelLogic.HandleTaskRecordFailByTaskRecord(indexTaskRecordOp.TaskType, indexTaskRecordInfo, indexConfigItem, indexItem, br.Msg)
		} else {
			// 如果获取成功了，那么就标记进行中
			go aiPredictModelLogic.HandleTaskRecordProcessingByTaskRecord(indexTaskRecordOp.TaskType, indexTaskRecordInfo, indexConfigItem, indexItem)
		}
	}()

	indexConfigObj := new(ai_predict_model.AiPredictModelIndexConfig)
	indexOb := new(ai_predict_model.AiPredictModelIndex)

	switch indexTaskRecordOp.TaskType {
	case utils.INDEX_TASK_TYPE_AI_MODEL_TRAIN:
		// 训练模型
		indexConfigId, err := strconv.Atoi(indexTaskRecordInfo.Parameters) // 模型配置ID
		if err != nil {
			fmt.Println("模型配置ID转换错误!")
			br.Msg = "模型配置ID转换错误"
			br.ErrMsg = "模型配置ID转换错误,err:" + err.Error()
			return
		}

		// 查找配置
		indexConfigItem, err = indexConfigObj.GetById(indexConfigId)
		if err != nil {
			br.Msg = "获取模型配置失败"
			br.ErrMsg = "获取模型配置失败，查找配置失败，Err:" + err.Error()
			if utils.IsErrNoRow(err) {
				br.Msg = "配置不存在"
				br.IsSendEmail = false
			}
			return
		}

		// 查询标的情况
		indexItem, err = indexOb.GetItemById(indexConfigItem.AiPredictModelIndexId)
		if err != nil {
			br.Msg = "训练失败，查找标的失败"
			br.ErrMsg = fmt.Sprintf("训练失败，查找标的失败, %v", err)
			if utils.IsErrNoRow(err) {
				br.Msg = "标的不存在"
				br.IsSendEmail = false
			}
			return
		}

	case utils.INDEX_TASK_TYPE_AI_MODEL_RUN:
		// 运行模型

		// 标的id转换
		indexId, err := strconv.Atoi(indexTaskRecordInfo.Parameters)
		if err != nil {
			fmt.Println("标的ID转换错误!")
			br.Msg = "标的ID转换错误"
			br.ErrMsg = "标的ID转换错误,err:" + err.Error()
			return
		}

		// 查询标的情况
		indexItem, err = indexOb.GetItemById(indexId)
		if err != nil {
			br.Msg = "训练失败，查找标的失败"
			br.ErrMsg = fmt.Sprintf("训练失败，查找标的失败, %v", err)
			if utils.IsErrNoRow(err) {
				br.Msg = "标的不存在"
				br.IsSendEmail = false
			}
			return
		}

		// 查找配置
		indexConfigItem, err = indexConfigObj.GetById(indexItem.AiPredictModelIndexConfigId)
		if err != nil {
			br.Msg = "获取模型配置失败"
			br.ErrMsg = "获取模型配置失败，查找配置失败，Err:" + err.Error()
			if utils.IsErrNoRow(err) {
				br.Msg = "配置不存在"
				br.IsSendEmail = false
			}
			return
		}
	default:
		br.Msg = "异常的任务类型"
		br.ErrMsg = "异常的任务类型，Err：" + indexTaskRecordOp.TaskType
		return
	}

	if indexItem.ScriptPath == `` {
		br.Msg = `没有配置脚本路径`
		br.ErrMsg = `没有配置脚本路径`
		return
	}

	var configParams response.ConfigParams
	if e := json.Unmarshal([]byte(indexConfigItem.Params), &configParams); e != nil {
		br.Msg = "获取模型配置失败"
		br.ErrMsg = "获取模型配置失败，解析配置失败，Err:" + e.Error()
		return
	}

	resp.AiPredictModelIndexId = indexConfigItem.AiPredictModelIndexId
	resp.AiPredictModelIndexConfigId = indexConfigItem.AiPredictModelIndexConfigId
	resp.ConfigParams = configParams

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