eta_index_lib/models/base_from_rzd_data.go

// @Author gmy 2024/10/21 9:50:00
package models

import (
	"eta/eta_index_lib/global"
	"eta/eta_index_lib/utils"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"time"
)

type BaseFromRzdData struct {
	BaseFromRzdDataId  int     `gorm:"column:base_from_rzd_data_id;primaryKey"`
	BaseFromRzdIndexId int     `gorm:"column:base_from_rzd_index_id"`
	CreateTime         string  `gorm:"column:create_time"`
	DataTime           string  `gorm:"column:data_time"`
	IndexCode          string  `gorm:"column:index_code"`
	ModifyTime         string  `gorm:"column:modify_time"`
	Value              float64 `gorm:"column:value"`
}

type IndexInfo struct {
	IndexName   string
	IndexCode   string
	Frequency   string
	Unit        string
	ClassifyId  int
	StartDate   time.Time
	EndDate     time.Time
	LatestValue decimal.Decimal
	DataList    []IndexData
}

type IndexData struct {
	DataTime time.Time
	Value    decimal.Decimal
}

// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
func (m *BaseFromRzdData) AfterFind(db *gorm.DB) (err error) {
	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
	m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
	m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)

	return
}

func (m *BaseFromRzdData) ConvDateTimeStr() {
	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
	m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
	m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)

	return
}

// AddRzdDataList 批量插入数据记录列表
func AddRzdDataList(items []BaseFromRzdData) (err error) {
	//o := orm.NewOrm()
	//_, err = o.InsertMulti(len(items), items)
	err = global.DEFAULT_DB.CreateInBatches(items, len(items)).Error

	return
}
func UpdateIndexAndAddRzdDataList(index *BaseFromRzdIndex, items []*BaseFromRzdData) (err error) {
	tx := global.DEFAULT_DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	err = tx.Model(index).Select([]string{"latest_value", "start_date", "end_date", "base_from_rzd_classify_id"}).Updates(&index).Error
	if err != nil {
		return
	}
	err = tx.Clauses(
		clause.OnConflict{
			Columns:   []clause.Column{{Name: "base_from_rzd_index_id"}, {Name: "data_time"}},
			DoUpdates: clause.AssignmentColumns([]string{"value"})}).CreateInBatches(items, len(items)).Error
	return
}

// GetRzdDataByIndexCodeAndDataTime 根据指标id和数据日期查询数据
func GetRzdDataByIndexCodeAndDataTime(indexCode string, dataTime string) (item BaseFromRzdData, err error) {
	//o := orm.NewOrm()
	sql := `SELECT * FROM base_from_rzd_data WHERE index_code=? AND data_time=?`
	//err = o.Raw(sql, indexCode, dataTime).QueryRow(&items) // 使用 QueryRow
	err = global.DEFAULT_DB.Raw(sql, indexCode, dataTime).First(&item).Error
	if utils.IsErrNoRow(err) {
		return item, nil
	}
	if err != nil {
		return item, err
	}
	item.ConvDateTimeStr()

	return
}

// UpdateRzdDataById 根据主键id更新数据
func UpdateRzdDataById(dataId int, value float64) (err error) {
	//o := orm.NewOrm()
	sql := `UPDATE base_from_rzd_data SET value=? WHERE base_from_rzd_data_id=?`
	//_, err = o.Raw(sql, value, dataId).Exec()
	err = global.DEFAULT_DB.Exec(sql, value, dataId).Error
	return
}

// GetBaseFromRzdDataByCondition 添加查询
func GetBaseFromRzdDataByCondition(condition string, pars []interface{}) (items []BaseFromRzdData, err error) {
	sql := `SELECT * FROM base_from_rzd_data WHERE 1=1 `
	//o := orm.NewOrm()
	if condition != "" {
		sql += condition
	}
	//_, err = o.Raw(sql, pars...).QueryRows(&items)
	err = global.DEFAULT_DB.Raw(sql, pars...).Find(&items).Error
	if utils.IsErrNoRow(err) {
		return nil, nil
	}
	return
}

// UpdateRzdData 修改睿姿得数据
func UpdateRzdData(item *BaseFromRzdData) (err error) {
	//o := orm.NewOrm()
	//_, err = o.Update(item)
	err = global.DEFAULT_DB.Save(&item).Error
	return
}

// GetRzdDataMaxAndMinDateByIndexCodes 查询数据时间最新值，数据时间最小值和最新值对应的value值
func GetRzdDataMaxAndMinDateByIndexCodes(indexCodes []string) (resultMap map[string]*EdbInfoMaxAndMinInfo, err error) {
	resultMap = make(map[string]*EdbInfoMaxAndMinInfo)

	//o := orm.NewOrm()
	sql := ` SELECT index_code, MIN(data_time) AS min_date,MAX(data_time) AS max_date,MIN(value) AS min_value,MAX(value) AS max_value FROM base_from_rzd_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY index_code`
	var items []EdbInfoMaxAndMinInfo
	//_, err = o.Raw(sql, indexCodes).QueryRows(&items)
	err = global.DEFAULT_DB.Raw(sql, indexCodes).Find(&items).Error
	if err != nil {
		return nil, err
	}

	for _, row := range items {
		resultMap[row.IndexCode] = &EdbInfoMaxAndMinInfo{
			MinDate:  row.MinDate,
			MaxDate:  row.MaxDate,
			MinValue: row.MinValue,
			MaxValue: row.MaxValue,
		}
	}

	// 查询最新的值（最新数据时间对应的 value）
	sql = `SELECT a.index_code, a.value AS latest_value
        FROM base_from_rzd_data a
        JOIN (
            SELECT index_code, MAX(data_time) AS latest_time
            FROM base_from_rzd_data
            WHERE index_code IN (` + utils.GetOrmInReplace(len(indexCodes)) + `)
            GROUP BY index_code
        ) b ON a.index_code = b.index_code AND a.data_time = b.latest_time`
	//_, err = o.Raw(sql, indexCodes).QueryRows(&items)
	err = global.DEFAULT_DB.Raw(sql, indexCodes).Find(&items).Error
	if err != nil {
		return nil, err
	}
	for _, row := range items {
		if _, ok := resultMap[row.IndexCode]; ok {
			resultMap[row.IndexCode].LatestValue = row.LatestValue
		}
	}

	return resultMap, nil
}

func UpdateRzdEdbDataByIndexCodes(indexCode string, info *EdbInfoMaxAndMinInfo) error {
	//o := orm.NewOrm()
	sql := `UPDATE base_from_rzd_index SET start_date=?, end_date=?, latest_value=? WHERE index_code=?`
	//_, err := o.Raw(sql, info.MinDate, info.MaxDate, info.LatestValue, indexCode).Exec()
	err := global.DEFAULT_DB.Exec(sql, info.MinDate, info.MaxDate, info.LatestValue, indexCode).Error
	return err
}