eta_api/models/data_manage/base_from_smm.go

package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"gorm.io/gorm"
	"time"

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

type BaseFromSmm struct {
	BaseFromSmmId int `orm:"column(base_from_smm_id);pk" gorm:"primaryKey"`
	Aid           int
	Name          string
	Interface     string
	ApiUpdate     int
	ApiUpdateType string
	ApiType       int
	ApiTypeAll    string
	Type1         string `gorm:"column:type_1"`
	Type2         string `gorm:"column:type_2"`
	Type3         string `gorm:"column:type_3"`
	ApiStartTime  string
	ApiUpdateTime string
	StartTime     string
	FinishTime    string
	AuthModule    string
	AuthLang      string
	ApiLabel      string
	Enable        string
	EditPerson    string
	EditTime      string
	AuthDur       int
	AuthDurType   string
}

func AddBaseFromSmm(item *BaseFromSmm) (lastId int64, err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(item).Error
	if err != nil {
		return
	}
	lastId = int64(item.BaseFromSmmId)
	return
}

func GetBaseFromSmmList() (list []*BaseFromSmm, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm `
	err = o.Raw(sql).Find(&list).Error
	return
}

func GetBaseFromSmmBySmmCode(smmCode string) (item *BaseFromSmm, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm WHERE interface=?`
	err = o.Raw(sql, smmCode).First(&item).Error
	return
}

type BaseFromSmmIndex struct {
	BaseFromSmmIndexId int `gorm:"column:base_from_smm_index_id;primaryKey"`
	ClassifyId         int
	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
	Sort               int
	CreateTime         time.Time
	ModifyTime         time.Time
	DataState          string
	ReleaseTime        string
	StartDate          string
	EndDate            string
	RenameFileName     string
	TerminalCode       string `description:"终端编码"`
}

func (m *BaseFromSmmIndex) AfterFind(tx *gorm.DB) (err error) {
			m.ApiStartTime = utils.GormDateStrToDateTimeStr(m.ApiStartTime)
			m.ApiUpdateTime = utils.GormDateStrToDateTimeStr(m.ApiUpdateTime)
			m.StartTime = utils.GormDateStrToDateTimeStr(m.StartTime)
			m.FinishTime = utils.GormDateStrToDateTimeStr(m.FinishTime)
			m.ReleaseTime = utils.GormDateStrToDateTimeStr(m.ReleaseTime)
			m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
			m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
	return
}
func AddBaseFromSmmIndex(item *BaseFromSmmIndex) (lastId int64, err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(item).Error
	if err != nil {
		return
	}
	lastId = int64(item.BaseFromSmmIndexId)
	return
}

func GetBaseFromSmmIndex() (list []*BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm_index `
	err = o.Raw(sql).Find(&list).Error
	return
}

type BaseFromSmmData struct {
	SmmDataId          int `orm:"column(smm_data_id);pk" gorm:"primaryKey"`
	BaseFromSmmIndexId int
	IndexCode          string
	DataTime           string
	Value              string
	CreateTime         time.Time
	ModifyTime         time.Time
	DataTimestamp      int64
}

func AddBaseFromSmmData(item *BaseFromSmmData) (lastId int64, err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(item).Error
	if err != nil {
		return
	}
	lastId = int64(item.SmmDataId)
	return
}

func GetBaseFromSmmDataAll() (list []*BaseFromSmmData, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm_data `
	err = o.Raw(sql).Find(&list).Error
	return
}

func ModifyBaseFromSmmData(smmDataId int, value string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `UPDATE base_from_smm_data SET value=?,modify_time=NOW() WHERE smm_data_id=? `
	err = o.Exec(sql, value, smmDataId).Error
	return
}

func GetBaseFromSmmIndexBySmmCode(smmCode string) (list []*BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM base_from_smm_index WHERE interface=? `
	err = o.Raw(sql, smmCode).Find(&list).Error
	return
}

func GetBaseFromSmmMaxOrMinDate(indexCode string) (min_date, max_date string, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT MIN(data_time) AS min_date,MAX(data_time) AS max_date FROM base_from_smm_data WHERE index_code=? `
	err = o.Raw(sql, indexCode).Row().Scan(&min_date, &max_date)
	return
}

func ModifyBaseFromSmmMinDateAndMaxDate(baseFromSmmIndexId int, minDate, maxDate string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` UPDATE base_from_smm_index SET start_date=?,end_date=?,modify_time=NOW() WHERE base_from_smm_index_id=? `
	err = o.Exec(sql, minDate, maxDate, baseFromSmmIndexId).Error
	return
}

func GetBaseFromSmmDataAllByIndexCode(indexCode string) (list []*BaseFromSmmData, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm_data WHERE index_code=? `
	err = o.Raw(sql, indexCode).Find(&list).Error
	return
}

func GetBaseFromSmmIndexByIndexCode(indexCode string) (list *BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM base_from_smm_index WHERE index_code=? `
	err = o.Raw(sql, indexCode).First(&list).Error
	return
}

// GetBaseFromSmmIndexCountByClassifyIds 获取分类下指标的个数
func GetBaseFromSmmIndexCountByClassifyIds(classifyIds []int) (count int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	num := len(classifyIds)
	if num <= 0 {
		return
	}
	sql := `SELECT COUNT(1) AS count FROM base_from_smm_index WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
	err = o.Raw(sql, classifyIds).Scan(&count).Error
	return
}

// GetBaseFromSmmIndexByClassifyId 获取根据分类查询指标
func GetBaseFromSmmIndexByClassifyId(classifyId int) (list []*BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm_index WHERE classify_id =? ORDER BY sort ASC, base_from_smm_index_id ASC `
	err = o.Raw(sql, classifyId).Find(&list).Error
	return
}

// GetSmmIndexAll 用于分类展示
func GetSmmIndexAll() (items []*BaseFromSmmClassifyItems, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT base_from_smm_index_id, classify_id, index_name as classify_name, index_code as base_from_smm_index_code
            FROM base_from_smm_index ORDER BY sort ASC, base_from_smm_index_id ASC `
	err = o.Raw(sql).Find(&items).Error
	return
}

// GetBaseFromSmmIndexByIndexId 根据指标id获取指标信息
func GetBaseFromSmmIndexByIndexId(indexId int) (item *BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM base_from_smm_index WHERE base_from_smm_index_id=? `
	err = o.Raw(sql, indexId).First(&item).Error
	return
}

// GetBaseFromSmmIndexMaxSortByClassifyId 根据指标id获取指标信息
func GetBaseFromSmmIndexMaxSortByClassifyId(classifyId int) (sort int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT COALESCE(MAX(sort), 0) AS sort FROM base_from_smm_index WHERE classify_id=? `
	err = o.Raw(sql, classifyId).Scan(&sort).Error
	return
}

// GetBaseFromSmmIndexMinSortByClassifyId 获取最小不等于0的排序
func GetBaseFromSmmIndexMinSortByClassifyId(classifyId int) (sort int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT min(sort) FROM base_from_smm_index WHERE classify_id=? and sort <> 0 `
	err = o.Raw(sql, classifyId).Scan(&sort).Error
	return
}

type BaseFromSmmIndexType struct {
	Type2 string `gorm:"column:type_2"`
	Type3 string `gorm:"column:type_3"`
}

// GetBaseFromSmmIndexType 获取历史指标信息类型
func GetBaseFromSmmIndexType() (list []BaseFromSmmIndexType, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT type_2, type_3 from base_from_smm_index where type_2 <> "" GROUP BY type_2, type_3`
	err = o.Raw(sql).Find(&list).Error
	return
}

// MoveBaseFromSmmIndex 移动指标分类
func MoveBaseFromSmmIndex(chartInfoId, classifyId int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` UPDATE base_from_smm_index
			SET
			  classify_id = ?, modify_time=NOW() 
			WHERE base_from_smm_index_id = ?`
	err = o.Exec(sql, classifyId, chartInfoId).Error
	return
}

// UpdateBaseFromSmmIndexByClassifyId 根据指标id更新排序
func UpdateBaseFromSmmIndexByClassifyId(classifyId, nowSort, prevIndexInfoId int, updateSort string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` update base_from_smm_index set sort = ` + updateSort + ` WHERE classify_id=? AND  `
	if prevIndexInfoId > 0 {
		sql += ` ( sort > ? or (base_from_smm_index_id > ` + fmt.Sprint(prevIndexInfoId) + ` and sort = ` + fmt.Sprint(nowSort) + `))`
	}
	err = o.Exec(sql, classifyId, nowSort).Error
	return
}

// MoveUpSmmIndexBySort 往上移动
func MoveUpSmmIndexBySort(classifyId, nextSort, currentSort int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `update base_from_smm_index set sort = sort + 1 where classify_id=? and sort >= ? and sort< ?`
	err = o.Exec(sql, classifyId, nextSort, currentSort).Error
	return
}

// MoveDownSmmIndexBySort 往下移动
func MoveDownSmmIndexBySort(classifyId, prevSort, currentSort int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `update base_from_smm_index set sort = sort - 1 where classify_id=? and sort <= ? and sort> ? `
	err = o.Exec(sql, classifyId, prevSort, currentSort).Error
	return
}

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

// Update 更新Smm指标基础信息
func (item *BaseFromSmmIndex) Update(cols []string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Select(cols).Updates(item).Error
	return
}

// DeleteBaseFromSmmIndexById 根据指标id删除对应的指标、指标数据
func DeleteBaseFromSmmIndexById(smmIndexId int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	if tx.Error != nil {
		return tx.Error
	}
	defer func() {
		if err != nil {
			_ = tx.Rollback()
		} else {
			_ = tx.Commit()
		}
	}()

	//删除指标
	sql := `DELETE FROM base_from_smm_index WHERE base_from_smm_index_id = ? `
	err = tx.Exec(sql, smmIndexId).Error
	if err != nil {
		return
	}

	//删除指标数据
	sql = `DELETE FROM base_from_smm_data WHERE base_from_smm_index_id = ? `
	err = tx.Exec(sql, smmIndexId).Error
	if err != nil {
		return
	}

	return
}

// EditSmmIndexInfoResp 新增指标的返回
type EditSmmIndexInfoResp struct {
	BaseFromSmmIndexId int    `description:"指标ID"`
	IndexCode          string `description:"指标code"`
}

type SmmSingleDataResp struct {
	BaseFromSmmIndexId int
	ClassifyId         int
	Interface          string
	Name               string
	IndexCode          string
	IndexName          string
	Frequency          string
	Unit               string
	ApiStartTime       string
	ApiUpdateTime      string
	StartTime          string
	FinishTime         string
	CreateTime         string
	ModifyTime         string
	Data               []*SmmIndexData
}

func GetSmmIndexDataList(condition, sortStr string, pars []interface{}, startSize, pageSize int) (items []*BaseFromSmmIndexItem, err error) {
	sql := `select * FROM base_from_smm_index
               WHERE 1=1 `
	if condition != "" {
		sql += condition
	}
	sql += ` ORDER BY ` + sortStr
	sql += `  limit ?,? `
	o := global.DbMap[utils.DbNameIndex]
	pars = append(pars, startSize, pageSize)
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

func GetSmmIndexDataListCount(condition string, pars []interface{}) (total int, err error) {
	sql := `select count(1) FROM base_from_smm_index
               WHERE 1=1 `
	if condition != "" {
		sql += condition
	}
	o := global.DbMap[utils.DbNameIndex]
	err = o.Raw(sql, pars...).Scan(&total).Error
	return
}

type BaseFromSmmIndexListResp struct {
	List   []*BaseFromSmmIndexItem
	Paging *paging.PagingItem `description:"分页数据"`
}

type BaseFromSmmIndexItem struct {
	BaseFromSmmIndexId int `orm:"column(base_from_smm_index_id);pk" gorm:"primaryKey"`
	ClassifyId         int
	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
	Sort               int
	CreateTime         string
	ModifyTime         string
	DataState          string
	ReleaseTime        string
	StartDate          string
	EndDate            string
	TypeAll            string
}

func (item *BaseFromSmmIndexItem) AfterFind(tx *gorm.DB) (err error) {
			item.CreateTime = utils.GormDateStrToDateTimeStr(item.CreateTime)
			item.ModifyTime = utils.GormDateStrToDateTimeStr(item.ModifyTime)
			item.StartDate = utils.GormDateStrToDateStr(item.StartDate)
			item.EndDate = utils.GormDateStrToDateStr(item.EndDate)
			item.ApiStartTime = utils.GormDateStrToDateTimeStr(item.ApiStartTime)
			item.ApiUpdateTime = utils.GormDateStrToDateTimeStr(item.ApiUpdateTime)
			item.StartTime = utils.GormDateStrToDateTimeStr(item.StartTime)
			item.FinishTime = utils.GormDateStrToDateTimeStr(item.FinishTime)
			item.ReleaseTime = utils.GormDateStrToDateTimeStr(item.ReleaseTime)
	return
}

type BaseFromSmmIndexTypeList struct {
	Type1 string `gorm:"column:type_1"`
	Type2 string `gorm:"column:type_2"`
	Type3 string `gorm:"column:type_3"`
}

// GetBaseFromSmmIndexTypeList
func GetBaseFromSmmIndexTypeList() (list []BaseFromSmmIndexTypeList, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT type_1,type_2, type_3 from base_from_smm_index GROUP BY type_1,type_2,type_3 `
	err = o.Raw(sql).Find(&list).Error
	return
}

type TypeListRespItem struct {
	Type  string
	Child []TypeListRespItem
}

func GetSmmIndexDataListNoPage(condition string, pars []interface{}) (items []*BaseFromSmmIndexItem, err error) {
	sql := `select * FROM base_from_smm_index
               WHERE 1=1 `
	if condition != "" {
		sql += condition
	}
	o := global.DbMap[utils.DbNameIndex]
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

func GetBaseFromSmmIndexByIndexCodes(indexCodes string) (list []*BaseFromSmmIndex, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM base_from_smm_index WHERE index_code IN (` + indexCodes + `)`
	err = o.Raw(sql).Find(&list).Error
	return
}

// SmmIndexListReq
type SmmIndexListReq struct {
	Types        []string `description:"分类"`
	Frequency    string   `description:"频度"`
	DataState    string   `description:"数据状态"`
	Keyword      string   `description:"关键字"`
	IndexCodes   string   `description:"指标代码"`
	SortType     string   `description:"排序类型"`
	SortParam    string   `description:"排序参数"`
	PageSize     int
	CurrentIndex int
}

// SmmIndexExistCheckReq
type SmmIndexExistCheckReq struct {
	Types     []string `description:"分类"`
	Frequency string   `description:"频度"`
	DataState string   `description:"数据状态"`
	EdbCode   string   `description:"指标代码"`
	SelectAll bool     `description:"是否全选"`
	Keyword   string   `description:"关键字"`
}