eta_api/models/data_manage/base_from_sci.go

package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"time"
)

type BaseFromSci struct {
	BaseFromSciId int `orm:"column(base_from_sci_id);pk" gorm:"primaryKey"`
	Aid           int
	Name          string
	Interface     string
	ApiUpdate     int
	ApiUpdateType string
	ApiType       int
	ApiTypeAll    string
	Type1         string `orm:"column(type_1)"`
	Type2         string `orm:"column(type_2)"`
	Type3         string `orm:"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 AddBaseFromSci(item *BaseFromSci) (lastId int64, err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(item).Error
	if err != nil {
		return
	}
	lastId = int64(item.BaseFromSciId)
	return
}

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

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

type BaseFromSciIndex struct {
	BaseFromSciIndexId int `orm:"column(base_from_sci_index_id);pk" gorm:"primaryKey"`
	ClassifyId         int
	Interface          string
	IndexCode          string
	IndexName          string
	Frequency          string
	Unit               string
	Sort               int
	CreateTime         time.Time
	ModifyTime         time.Time
	FilePath           string
	TerminalCode       string `description:"终端编码"`
}

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

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

type BaseFromSciData struct {
	SciDataId          int `orm:"column(sci_data_id);pk" gorm:"primaryKey"`
	BaseFromSciIndexId int
	IndexCode          string
	DataTime           string
	Value              string
	CreateTime         time.Time
	ModifyTime         time.Time
	DataTimestamp      int64
}

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

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

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

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

func GetBaseFromSciMaxOrMinDate(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_sci_data WHERE index_code=? `
	err = o.Raw(sql, indexCode).Row().Scan(&min_date, &max_date)
	return
}

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

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

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

// GetBaseFromSciIndexCountByClassifyIds 获取分类下指标的个数
func GetBaseFromSciIndexCountByClassifyIds(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_sci_index WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
	err = o.Raw(sql, classifyIds).Scan(&count).Error
	return
}

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

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

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

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

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

type BaseFromSciIndexType struct {
	Type2 string `orm:"column(type_2)"`
	Type3 string `orm:"column(type_3)"`
}

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

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

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

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

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

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

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

// DeleteBaseFromSciIndexById 根据指标id删除对应的指标、指标数据
func DeleteBaseFromSciIndexById(sciIndexId 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_sci_index WHERE base_from_sci_index_id = ? `
	err = tx.Exec(sql, sciIndexId).Error
	if err != nil {
		return
	}

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

	return
}

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

type SciSingleDataResp struct {
	BaseFromSciIndexId 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               []*SciIndexData
}