eta_api/models/data_manage/baiinfo_data.go

package data_manage

import (
	"database/sql"
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
)

type BaiinfoClassify struct {
	TypeName string `orm:"column(type_name)" description:"分类名称"`
	TypeCode string `orm:"column(type_code)" description:"分类名称编码"`
}

func GetBaiinfoClassify() (items []*BaiinfoClassify, err error) {
	sql := `SELECT CONCAT(type_2,type_3) AS type_name,CONCAT(type_2,'#',type_3) type_code  FROM base_from_baiinfo_index GROUP BY CONCAT(type_2,type_3) ORDER BY CONCAT(type_2,type_3) ASC `
	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
	return
}

type BaiinfoFrequency struct {
	Frequency string `description:"频度"`
}

func GetBaiinfoFrequencyByClassifyId(classifyId int) (items []*GlFrequency, err error) {
	sql := ` SELECT frequency FROM base_from_baiinfo_index WHERE classify_id = ? `
	sql += ` GROUP BY frequency ORDER BY frequency ASC `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
	return
}

type BaiinfoIndex struct {
	BaseFromBaiinfoIndexId int `orm:"column(base_from_baiinfo_index_id);pk"`
	Interface              string
	Name                   string
	IndexCode              string
	IndexName              string
	Type1                  string `gorm:"column:type_1"`
	Type2                  string `gorm:"column:type_2"`
	Type3                  string `gorm:"column:type_3"`
	Frequency              string
	Unit                   string
	ApiStartTime           string
	ApiUpdateTime          string
	StartTime              string
	FinishTime             string
	CreateTime             string
	ModifyTime             string
}

func (obj *BaiinfoIndex) AfterFind(tx *gorm.DB) (err error) {
	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
		if obj.CreateTime != "" {
			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
		}
		if obj.ModifyTime != "" {
			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
		}

		if obj.ApiStartTime != "" {
			obj.ApiStartTime = utils.GormDateStrToDateTimeStr(obj.ApiStartTime)
		}
		if obj.ApiUpdateTime != "" {
			obj.ApiUpdateTime = utils.GormDateStrToDateTimeStr(obj.ApiUpdateTime)
		}
		if obj.StartTime != "" {
			obj.StartTime = utils.GormDateStrToDateStr(obj.StartTime)
		}
		if obj.FinishTime != "" {
			obj.FinishTime = utils.GormDateStrToDateStr(obj.FinishTime)
		}
	}
	return
}
func GetBaiinfoIndex(condition string, pars []interface{}) (items []*BaiinfoIndex, err error) {
	sql := ` SELECT * FROM base_from_baiinfo_index WHERE 1=1  `
	if condition != "" {
		sql += condition
	}
	sql += `ORDER BY sort ASC, base_from_baiinfo_index_id asc`
	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Find(&items).Error
	return
}

type BaiinfoExportIndex struct {
	TypeName   string
	IndexCode  string
	IndexName  string
	Type1      string `gorm:"column:type_1"`
	Type2      string `gorm:"column:type_2"`
	Type3      string `gorm:"column:type_3"`
	Frequency  string
	Unit       string
	ModifyTime string
}

func GetExportBaiinfoIndex(typeCodes []string) (items []*BaiinfoExportIndex, err error) {
	if len(typeCodes) == 0 {
		return
	}
	sql := ` SELECT *,CONCAT(type_2, "#", type_3) AS type_name FROM base_from_baiinfo_index WHERE CONCAT(type_2, "#", type_3) IN (` + utils.GetOrmInReplace(len(typeCodes)) + `) ORDER BY frequency ASC,index_code ASC`
	err = global.DbMap[utils.DbNameIndex].Raw(sql, typeCodes).Find(&items).Error
	return
}

func GetBaiinfoFrequency(classifyId int) (items []*string, err error) {
	sql := `SELECT DISTINCT frequency FROM base_from_baiinfo_index WHERE classify_id=? ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年','年度') `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
	return
}

func GetBaiinfoFrequencyByCode(code string) (items []*string, err error) {
	sql := `SELECT DISTINCT frequency FROM base_from_baiinfo_index WHERE index_code=? ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年','年度') `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, code).Find(&items).Error
	return
}

type BaiinfoIndexList struct {
	BaseFromBaiinfoIndexId int `orm:"column(base_from_baiinfo_index_id);pk"`
	Interface              string
	Name                   string
	IndexCode              string
	IndexName              string
	Type1                  string `gorm:"column:type_1"`
	Type2                  string `gorm:"column:type_2"`
	Type3                  string `gorm:"column:type_3"`
	Frequency              string
	Unit                   string
	ApiStartTime           string
	ApiUpdateTime          string
	StartTime              string
	FinishTime             string
	ModifyTime             string
	DataList               []*BaiinfoIndexData `gorm:"-"`
	Paging                 *paging.PagingItem  `description:"分页数据" gorm:"-"`
}

type BaiinfoIndexData struct {
	Value    decimal.Decimal `gorm:"column:value" description:"日期"`
	DataTime string          `gorm:"column:data_time" description:"值"`
}

func (obj *BaiinfoIndexData) AfterFind(tx *gorm.DB) (err error) {
	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
		if obj.DataTime != "" {
			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
		}
	}

	return
}
func GetBaiinfoIndexData(indexCode string, startSize, pageSize int) (items []*BaiinfoIndexData, err error) {
	sql := ` SELECT *  FROM base_from_baiinfo_data WHERE index_code=? ORDER BY data_time DESC LIMIT ?,? `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode, startSize, pageSize).Find(&items).Error
	return
}

func GetBaiinfoIndexDataCount(indexCode string) (count int, err error) {
	sqlStr := ` SELECT COUNT(1) AS count  FROM base_from_baiinfo_data WHERE index_code=? `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCode).Scan(&totalNull).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

// GetBaiinfoItemList 模糊查询Baiinfo数据库指标列表
func GetBaiinfoItemList(keyword string) (items []*BaiinfoIndex, err error) {
	sql := "SELECT * FROM base_from_baiinfo_index WHERE CONCAT(index_name,index_code) LIKE ? "
	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.GetLikeKeyword(keyword)).Find(&items).Error
	return
}

func GetBaiinfoIndexDataByCode(indexCode string) (items []*BaiinfoIndexData, err error) {
	sql := ` SELECT *  FROM base_from_baiinfo_data WHERE index_code=? ORDER BY data_time DESC  `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&items).Error
	return
}

func GetBaiinfoDataMaxCount(classifyId int) (count int, err error) {
	sqlStr := `SELECT MAX(t.num) AS count FROM (
				SELECT COUNT(1) AS num  FROM base_from_baiinfo_index AS a
				INNER JOIN base_from_baiinfo_data AS b ON a.index_code=b.index_code
				WHERE a.classify_id=?
				GROUP BY a.base_from_baiinfo_index_id
			)AS t `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&count).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

type ExportBaiinfoDataMaxCount struct {
	TypeName string
	Count    int
}

func GetExportBaiinfoDataMaxCount(typeCodes []string) (items []*ExportBaiinfoDataMaxCount, err error) {
	if len(typeCodes) == 0 {
		return
	}
	sql := ` SELECT
				MAX(t.num) AS count,
				t.type_name
			FROM
				(
					SELECT
						COUNT(1) AS num,
						CONCAT(a.type_2, "#", a.type_3) AS type_name
					FROM
						base_from_baiinfo_index AS a
					INNER JOIN base_from_baiinfo_data AS b ON a.index_code = b.index_code
					WHERE
						CONCAT(a.type_2, "#", a.type_3) IN (` + utils.GetOrmInReplace(len(typeCodes)) + `)
					GROUP BY
						a.base_from_baiinfo_index_id
				) AS t
			GROUP BY
				type_name `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, typeCodes).Find(&items).Error

	return
}

type ExportBaiinfoIndexData struct {
	Value     string `orm:"column(value)" description:"日期"`
	DataTime  string `orm:"column(data_time)" description:"值"`
	IndexCode string `orm:"column(index_code)" description:"指标编码"`
}

func GetExportBaiinfoIndexDataByCodes(indexCodes []string) (items []*ExportBaiinfoIndexData, err error) {
	if len(indexCodes) == 0 {
		return
	}
	sql := ` SELECT index_code,data_time,value FROM base_from_baiinfo_data WHERE index_code IN (` + utils.GetOrmInReplace(len(indexCodes)) + `) ORDER BY data_time DESC  `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Find(&items).Error
	return
}