eta_api/models/ai_predict_model/ai_predict_model_index.go

package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"strconv"
	"strings"
	"time"
)

// AiPredictModelIndex AI预测模型标的
type AiPredictModelIndex struct {
	AiPredictModelIndexId int       `orm:"column(ai_predict_model_index_id);pk" gorm:"primaryKey"`
	IndexName             string    `description:"标的名称"`
	IndexCode             string    `description:"自生成的指标编码"`
	ClassifyId            int       `description:"分类ID"`
	ModelFramework        string    `description:"模型框架"`
	PredictDate           time.Time `description:"预测日期"`
	PredictValue          float64   `description:"预测值"`
	PredictFrequency      string    `description:"预测频度"`
	DirectionAccuracy     string    `description:"方向准确度"`
	AbsoluteDeviation     string    `description:"绝对偏差"`
	ExtraConfig           string    `description:"模型参数"`
	Sort                  int       `description:"排序"`
	SysUserId             int       `description:"创建人ID"`
	SysUserRealName       string    `description:"创建人姓名"`
	LeftMin               string    `description:"图表左侧最小值"`
	LeftMax               string    `description:"图表左侧最大值"`
	CreateTime            time.Time `description:"创建时间"`
	ModifyTime            time.Time `description:"修改时间"`
}

func (m *AiPredictModelIndex) TableName() string {
	return "ai_predict_model_index"
}

type AiPredictModelIndexCols struct {
	PrimaryId         string
	IndexName         string
	IndexCode         string
	ClassifyId        string
	ModelFramework    string
	PredictDate       string
	PredictValue      string
	DirectionAccuracy string
	AbsoluteDeviation string
	ExtraConfig       string
	Sort              string
	SysUserId         string
	SysUserRealName   string
	LeftMin           string
	LeftMax           string
	CreateTime        string
	ModifyTime        string
}

func (m *AiPredictModelIndex) Cols() AiPredictModelIndexCols {
	return AiPredictModelIndexCols{
		PrimaryId:         "ai_predict_model_index_id",
		IndexName:         "index_name",
		IndexCode:         "index_code",
		ClassifyId:        "classify_id",
		ModelFramework:    "model_framework",
		PredictDate:       "predict_date",
		PredictValue:      "predict_value",
		DirectionAccuracy: "direction_accuracy",
		AbsoluteDeviation: "absolute_deviation",
		ExtraConfig:       "extra_config",
		Sort:              "sort",
		SysUserId:         "sys_user_id",
		SysUserRealName:   "sys_user_real_name",
		LeftMin:           "left_min",
		LeftMax:           "left_max",
		CreateTime:        "create_time",
		ModifyTime:        "modify_time",
	}
}

func (m *AiPredictModelIndex) Create() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(m).Error
	return
}

func (m *AiPredictModelIndex) CreateMulti(items []*AiPredictModelIndex) (err error) {
	if len(items) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	err = o.CreateInBatches(items, utils.MultiAddNum).Error
	return
}

func (m *AiPredictModelIndex) Update(cols []string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Select(cols).Updates(m).Error
	return
}

func (m *AiPredictModelIndex) Remove() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
	err = o.Exec(sql, m.AiPredictModelIndexId).Error
	return
}

func (m *AiPredictModelIndex) MultiRemove(ids []int) (err error) {
	if len(ids) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
	err = o.Exec(sql, ids).Error
	return
}

func (m *AiPredictModelIndex) RemoveByCondition(condition string, pars []interface{}) (err error) {
	if condition == "" {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
	err = o.Exec(sql, pars...).Error
	return
}

func (m *AiPredictModelIndex) GetItemById(id int) (item *AiPredictModelIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
	err = o.Raw(sql, id).First(&item).Error
	return
}

func (m *AiPredictModelIndex) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *AiPredictModelIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	order := ``
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
	err = o.Raw(sql, pars...).First(&item).Error
	return
}

func (m *AiPredictModelIndex) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
	err = o.Raw(sql, pars...).Scan(&count).Error
	return
}

func (m *AiPredictModelIndex) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*AiPredictModelIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := fmt.Sprintf(`ORDER BY %s DESC`, m.Cols().CreateTime)
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

func (m *AiPredictModelIndex) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*AiPredictModelIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := fmt.Sprintf(`ORDER BY %s DESC`, m.Cols().CreateTime)
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
	pars = append(pars, startSize, pageSize)
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

// AiPredictModelIndexItem AI预测模型标的信息
type AiPredictModelIndexItem struct {
	IndexId           int     `description:"标的ID"`
	IndexName         string  `description:"标的名称"`
	IndexCode         string  `description:"自生成的指标编码"`
	ClassifyId        int     `description:"分类ID"`
	ClassifyName      string  `description:"分类名称"`
	ModelFramework    string  `description:"模型框架"`
	PredictDate       string  `description:"预测日期"`
	PredictValue      float64 `description:"预测值"`
	PredictFrequency  string  `description:"预测频度"`
	DirectionAccuracy string  `description:"方向准确度"`
	AbsoluteDeviation string  `description:"绝对偏差"`
	ExtraConfig       string  `description:"模型参数"`
	SysUserId         int     `description:"创建人ID"`
	SysUserRealName   string  `description:"创建人姓名"`
	CreateTime        string  `description:"创建时间"`
	ModifyTime        string  `description:"修改时间"`
	SearchText        string  `description:"搜索结果（含高亮）"`
}

func (m *AiPredictModelIndex) Format2Item() (item *AiPredictModelIndexItem) {
	item = new(AiPredictModelIndexItem)
	item.IndexId = m.AiPredictModelIndexId
	item.IndexName = m.IndexName
	item.IndexCode = m.IndexCode
	item.ClassifyId = m.ClassifyId
	item.ModelFramework = m.ModelFramework
	item.PredictDate = utils.TimeTransferString(utils.FormatDate, m.PredictDate)
	item.PredictValue = m.PredictValue
	item.PredictFrequency = m.PredictFrequency
	item.DirectionAccuracy = m.DirectionAccuracy
	item.AbsoluteDeviation = m.AbsoluteDeviation
	item.ExtraConfig = m.ExtraConfig
	item.SysUserId = m.SysUserId
	item.SysUserRealName = m.SysUserRealName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, m.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, m.ModifyTime)
	return
}

type AiPredictModelIndexPageListResp struct {
	Paging *paging.PagingItem
	List   []*AiPredictModelIndexItem `description:"列表"`
}

// RemoveIndexAndData 删除标的及数据
func (m *AiPredictModelIndex) RemoveIndexAndData(indexId int, chartIds []int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	sql := `DELETE FROM ai_predict_model_index WHERE ai_predict_model_index_id = ? LIMIT 1`
	e := tx.Exec(sql, indexId).Error
	if e != nil {
		err = fmt.Errorf("remove index err: %v", e)
		return
	}
	sql = ` DELETE FROM ai_predict_model_data WHERE ai_predict_model_index_id = ?`
	e = tx.Exec(sql, indexId).Error
	if e != nil {
		err = fmt.Errorf("remove index data err: %v", e)
		return
	}

	// 删除图表
	if len(chartIds) == 0 {
		return
	}
	sql = ` DELETE FROM chart_info WHERE chart_info_id IN ?`
	if e = tx.Exec(sql, chartIds).Error; e != nil {
		err = fmt.Errorf("remove charts err: %v", e)
		return
	}
	sql = ` DELETE FROM chart_edb_mapping WHERE chart_info_id IN ?`
	if e = tx.Exec(sql, chartIds).Error; e != nil {
		err = fmt.Errorf("remove chart mappings err: %v", e)
		return
	}
	return
}

// UpdateAiPredictModelIndexSortByClassifyId 根据分类id更新排序
func UpdateAiPredictModelIndexSortByClassifyId(classifyId, nowSort int, prevEdbInfoId int, updateSort string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` UPDATE ai_predict_model_index SET sort = ` + updateSort + ` WHERE classify_id = ?`
	if prevEdbInfoId > 0 {
		sql += ` AND ( sort > ? or ( ai_predict_model_index_id > ` + fmt.Sprint(prevEdbInfoId) + ` and sort=` + fmt.Sprint(nowSort) + ` )) `
	} else {
		sql += ` AND ( sort > ? )`
	}
	err = o.Exec(sql, classifyId, nowSort).Error
	return
}

// GetFirstAiPredictModelIndexByClassifyId 获取当前分类下，且排序数相同 的排序第一条的数据
func GetFirstAiPredictModelIndexByClassifyId(classifyId int) (item *AiPredictModelIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM ai_predict_model_index WHERE classify_id = ? order by sort asc,ai_predict_model_index_id asc limit 1`
	err = o.Raw(sql, classifyId).First(&item).Error
	return
}

type AiPredictModelImportData struct {
	Index  *AiPredictModelIndex
	Data   []*AiPredictModelData
	Charts []*AiPredictModelImportCharts
}

type AiPredictModelImportCharts struct {
	ChartInfo   *data_manage.ChartInfo
	EdbMappings []*data_manage.ChartEdbMapping
}

// ImportIndexAndData 导入数据
func (m *AiPredictModelIndex) ImportIndexAndData(createIndexes, updateIndexes []*AiPredictModelImportData, updateCols []string) (chartIds []int, err error) {
	if len(createIndexes) == 0 && len(updateIndexes) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	if len(updateIndexes) > 0 {
		for _, v := range updateIndexes {
			// 更新指标
			e := tx.Select(updateCols).Updates(v.Index).Error
			if e != nil {
				err = fmt.Errorf("update index err: %v", e)
				return
			}
			for _, d := range v.Data {
				d.AiPredictModelIndexId = v.Index.AiPredictModelIndexId
				d.IndexCode = v.Index.IndexCode
				d.DataTimestamp = d.DataTime.UnixNano() / 1e6
			}

			// 清空指标并新增
			sql := `DELETE FROM ai_predict_model_data WHERE ai_predict_model_index_id = ?`
			e = tx.Exec(sql, v.Index.AiPredictModelIndexId).Error
			if e != nil {
				err = fmt.Errorf("clear index data err: %v", e)
				return
			}
			e = tx.CreateInBatches(v.Data, utils.MultiAddNum).Error
			if e != nil {
				err = fmt.Errorf("insert index data err: %v", e)
				return
			}
		}
	}

	if len(createIndexes) > 0 {
		for _, v := range createIndexes {
			if e := tx.Create(v.Index).Error; e != nil {
				err = fmt.Errorf("insert index err: %v", e)
				return
			}

			indexId := v.Index.AiPredictModelIndexId
			for _, d := range v.Data {
				d.AiPredictModelIndexId = indexId
				d.IndexCode = v.Index.IndexCode
				d.DataTimestamp = d.DataTime.UnixNano() / 1e6
			}
			if e := tx.CreateInBatches(v.Data, utils.MultiAddNum).Error; e != nil {
				err = fmt.Errorf("insert index data err: %v", e)
				return
			}

			// 图表
			if len(v.Charts) == 0 {
				continue
			}
			for _, ct := range v.Charts {
				if e := tx.Create(ct.ChartInfo).Error; e != nil {
					err = fmt.Errorf("insert chart err: %v", e)
					return
				}
				for _, cm := range ct.EdbMappings {
					cm.ChartInfoId = ct.ChartInfo.ChartInfoId
					cm.EdbInfoId = indexId
					time.Sleep(time.Microsecond)
					cm.UniqueCode = utils.MD5(fmt.Sprint(utils.CHART_PREFIX, "_", indexId, "_", strconv.FormatInt(time.Now().UnixNano(), 10)))
				}
				if e := tx.CreateInBatches(ct.EdbMappings, utils.MultiAddNum).Error; e != nil {
					err = fmt.Errorf("insert chart mapping err: %v", e)
					return
				}
				chartIds = append(chartIds, ct.ChartInfo.ChartInfoId)
			}
		}
	}
	return
}

type AiPredictModelDetailResp struct {
	TableData      []*AiPredictModelDataItem        `description:"表格数据"`
	ChartView      *data_manage.ChartInfoDetailResp `description:"月度预测数据图表"`
	DailyChartView *data_manage.ChartInfoDetailResp `description:"日度预测数据图表"`
}

type AiPredictModelIndexSaveReq struct {
	IndexId      int                           `description:"指标ID"`
	MonthlyChart *AiPredictModelIndexSaveChart `description:"月度图表信息"`
	DailyChart   *AiPredictModelIndexSaveChart `description:"日度图表信息"`
}

type AiPredictModelIndexSaveChart struct {
	LeftMin string `description:"图表左侧最小值"`
	LeftMax string `description:"图表左侧最大值"`
	Unit    string `description:"单位"`
}

type AiPredictModelIndexExtraConfig struct {
	MonthlyChart struct {
		LeftMin string `description:"图表左侧最小值"`
		LeftMax string `description:"图表左侧最大值"`
		Unit    string `description:"单位"`
	}
	DailyChart struct {
		LeftMin           string `description:"图表左侧最小值"`
		LeftMax           string `description:"图表左侧最大值"`
		Unit              string `description:"单位"`
		PredictLegendName string `description:"预测图例的名称（通常为Predicted）"`
	}
}