eta_api/models/data_source/data_source.go

package data_source

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

// SearchDataSource 数据源ES搜索
type SearchDataSource struct {
	PrimaryId   int    `description:"主键ID"`
	IndexCode   string `description:"指标编码"`
	IndexName   string `description:"指标名称"`
	ClassifyId  int    `description:"分类ID"`
	Unit        string `description:"单位"`
	Frequency   string `description:"频度"`
	StartDate   string `description:"开始日期"`
	EndDate     string `description:"结束日期"`
	LatestValue string `description:"最新值(部分数据源如中国煤炭网存在97%这种数据...)"`
	Source      int    `description:"来源"`
	SourceName  string `description:"数据源名称"`
	SubSource   int    `description:"子来源"`
	IsDeleted   int    `description:"是否已删除：0-正常；1-已删除"`
	CreateTime  string `description:"创建时间"`
	ModifyTime  string `description:"修改时间"`
}

// SearchDataSourceItem 数据源ES搜索
type SearchDataSourceItem struct {
	SearchDataSource
	SearchText string `description:"搜索结果（含高亮）"`
}

// ToMap 为了方便前端那边的修改，这里兼容一下部分Key的变动，不然改动量很大
func (s *SearchDataSourceItem) ToMap(primaryIdKey, indexNameKey, classifyIdKey string) map[string]interface{} {
	data := make(map[string]interface{})
	if primaryIdKey != "" {
		data[primaryIdKey] = s.PrimaryId
	} else {
		data["PrimaryId"] = s.PrimaryId
	}
	if indexNameKey != "" {
		data[indexNameKey] = s.IndexName
	} else {
		data["IndexName"] = s.IndexName
	}
	if classifyIdKey != "" {
		data[classifyIdKey] = s.ClassifyId
	} else {
		data["ClassifyId"] = s.ClassifyId
	}
	data["IndexCode"] = s.IndexCode
	data["Unit"] = s.Unit
	data["Frequency"] = s.Frequency
	data["StartDate"] = s.StartDate
	data["EndDate"] = s.EndDate
	data["LatestValue"] = s.LatestValue
	data["Source"] = s.Source
	data["SourceName"] = s.SourceName
	data["IsDeleted"] = s.IsDeleted
	data["CreateTime"] = s.CreateTime
	data["ModifyTime"] = s.ModifyTime
	data["SearchText"] = s.SearchText
	return data
}

// SearchDataSourceResp 数据源ES-分页搜索响应
type SearchDataSourceResp struct {
	Paging *paging.PagingItem
	List   []map[string]interface{}
}

// SearchEsCols 数据源ES搜索字段
type SearchEsCols struct {
	PrimaryId   string
	IndexCode   string
	IndexName   string
	ClassifyId  string
	Unit        string
	Frequency   string
	StartDate   string
	EndDate     string
	LatestValue string
	CreateTime  string
	ModifyTime  string
}

// EsBaseFromIndex 数据源ES统一实现的接口
type EsBaseFromIndex interface {
	EsCols() SearchEsCols
	SourceInfo() (int, int, string)
}

// GetEsBaseFromIndexByTableName 根据表名获取对应数据源
func GetEsBaseFromIndexByTableName(tableName string) EsBaseFromIndex {
	switch tableName {
	case "base_from_rzd_index":
		return &BaseFromRzdIndex{}
	case "base_from_hisugar_index":
		return &BaseFromHisugarIndex{}
	case "base_from_ly_index":
		return &BaseFromLyIndex{}
	case "base_from_sci_hq_index":
		return &BaseFromSciHqIndex{}
	case "base_from_oilchem_index":
		return &BaseFromOilchemIndex{}
	case "base_from_ths_hf_index":
		return &BaseFromThsHfIndex{}
	case "base_from_ccf_index":
		return &BaseFromCcfIndex{}
	case "base_from_usda_fas_index":
		return &BaseFromUsdaFasIndex{}
	case "base_from_mysteel_chemical_index":
		return &BaseFromMysteelChemicalIndex{}
	case "base_from_smm_index":
		return &BaseFromSmmIndex{}
	case "base_from_baiinfo_index":
		return &BaseFromBaiinfoIndex{}
	case "base_from_sci_index":
		return &BaseFromSciIndex{}
	case "base_from_coalmine_mapping":
		return &BaseFromCoalmineMapping{}
	case "base_from_eia_steo_index":
		return &BaseFromEiaSteoIndex{}
	case "base_from_icpi_index":
		return &BaseFromIcpiIndex{}
	case "base_from_yongyi_index":
		return &BaseFromYongyiIndex{}
	case "base_from_fenwei_index":
		return &BaseFromFenweiIndex{}
	case "base_from_sci99_index":
		return &BaseFromSci99Index{}
	case "mb_index_main_info":
		return &BaseFromGlIndex{}
	case "edbinfo":
		return &BaseFromManualEdb{}
	case "base_from_business_index":
		return &BaseFromBusinessIndex{}
	case "base_from_bloomberg_index":
		return &BaseFromBloombergIndex{}
	case "base_from_mtjh_mapping":
		return &BaseFromMtjhMapping{}
	case "base_from_kpler_index":
		return &BaseFromKplerIndex{}
	}

	return nil
}

// BaseFromRzdIndex 睿咨得
type BaseFromRzdIndex struct {
	BaseFromRzdIndexId    int       `gorm:"column:base_from_rzd_index_id;primaryKey"`
	BaseFromRzdClassifyId int       `description:"分类ID"`
	IndexCode             string    `description:"指标编码"`
	IndexName             string    `description:"指标名称"`
	Unit                  string    `description:"单位"`
	Frequency             string    `description:"频度"`
	StartDate             time.Time `description:"开始日期"`
	EndDate               time.Time `description:"结束日期"`
	LatestValue           float64   `description:"最新值"`
	CreateTime            time.Time `description:"创建时间"`
	ModifyTime            time.Time `description:"更新时间"`
}

func (m *BaseFromRzdIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_RZD, 0, "睿咨得"
}

func (m *BaseFromRzdIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_rzd_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_rzd_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromRzdIndex) Format2SearchDataSource(origin *BaseFromRzdIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromRzdIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromRzdClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromHisugarIndex 泛糖科技
type BaseFromHisugarIndex struct {
	BaseFromHisugarIndexId int       `gorm:"column:base_from_hisugar_index_id;primaryKey"`
	ClassifyId             int       `description:"分类ID"`
	IndexCode              string    `description:"指标编码"`
	IndexName              string    `description:"指标名称"`
	Unit                   string    `description:"单位"`
	Frequency              string    `description:"频度"`
	Source                 string    `description:"数据来源"`
	Describe               string    `description:"指标描述"`
	Sort                   int       `description:"排序"`
	StartDate              time.Time `description:"开始日期"`
	EndDate                time.Time `description:"结束日期"`
	LatestValue            float64   `description:"最新值"`
	CreateTime             time.Time `description:"创建时间"`
	ModifyTime             time.Time `description:"更新时间"`
}

func (m *BaseFromHisugarIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_HISUGAR, 0, "泛糖科技"
}

func (m *BaseFromHisugarIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_hisugar_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromHisugarIndex) Format2SearchDataSource(origin *BaseFromHisugarIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromHisugarIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromLyIndex 粮油商务网
type BaseFromLyIndex struct {
	BaseFromLyIndexId    int       `gorm:"column:base_from_ly_index_id;primaryKey"`
	BaseFromLyClassifyId int       `description:"分类ID"`
	IndexCode            string    `description:"指标编码"`
	IndexName            string    `description:"指标名称"`
	Unit                 string    `description:"单位"`
	Frequency            string    `description:"频度"`
	StartDate            time.Time `description:"开始日期"`
	EndDate              time.Time `description:"结束日期"`
	LatestValue          float64   `description:"最新值"`
	EdbExist             int       `description:"指标库是否已添加：0-否；1-是"`
	CreateTime           time.Time `description:"创建时间"`
	ModifyTime           time.Time `description:"更新时间"`
}

func (m *BaseFromLyIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_LY, 0, "粮油商务网"
}

func (m *BaseFromLyIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_ly_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_ly_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromLyIndex) Format2SearchDataSource(origin *BaseFromLyIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromLyIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromLyClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromSciHqIndex 卓创红期
type BaseFromSciHqIndex struct {
	BaseFromSciHqIndexId int       `gorm:"column:base_from_sci_hq_index_id;primaryKey"`
	ClassifyId           int       `description:"分类ID"`
	IndexCode            string    `description:"指标编码"`
	IndexName            string    `description:"指标名称"`
	Unit                 string    `description:"单位"`
	Frequency            string    `description:"频度"`
	Sort                 int       `description:"排序"`
	StartDate            time.Time `description:"开始日期"`
	EndDate              time.Time `description:"结束日期"`
	LatestValue          float64   `description:"最新值"`
	LatestDate           time.Time `description:"最新更新时间"`
	TerminalCode         string    `description:"指标描述"`
	FilePath             string    `description:"文件路径"`
	CreateTime           time.Time `description:"创建时间"`
	ModifyTime           time.Time `description:"更新时间"`
}

func (m *BaseFromSciHqIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_SCI_HQ, 0, "卓创红期"
}

func (m *BaseFromSciHqIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_sci_hq_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromSciHqIndex) Format2SearchDataSource(origin *BaseFromSciHqIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromSciHqIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromOilchemIndex 隆众资讯
type BaseFromOilchemIndex struct {
	BaseFromOilchemIndexId int       `gorm:"column:base_from_oilchem_index_id;primaryKey"`
	ClassifyId             int       `description:"分类ID"`
	IndexCode              string    `description:"指标编码"`
	IndexName              string    `description:"指标名称"`
	Unit                   string    `description:"单位"`
	Frequency              string    `description:"频度"`
	StartDate              time.Time `description:"开始日期"`
	EndDate                time.Time `description:"结束日期"`
	LatestValue            float64   `description:"最新值"`
	CreateTime             time.Time `description:"创建时间"`
	ModifyTime             time.Time `description:"更新时间"`
}

func (m *BaseFromOilchemIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_OILCHEM, 0, "隆众资讯"
}

func (m *BaseFromOilchemIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_oilchem_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromOilchemIndex) Format2SearchDataSource(origin *BaseFromOilchemIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromOilchemIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromThsHfIndex 同花顺高频数据
type BaseFromThsHfIndex struct {
	BaseFromThsHfIndexId    int       `gorm:"column:base_from_ths_hf_index_id;primaryKey"`
	BaseFromThsHfClassifyId int       `description:"分类ID"`
	IndexCode               string    `description:"指标编码"`
	IndexName               string    `description:"指标名称"`
	Unit                    string    `description:"单位"`
	Source                  string    `description:"数据来源"`
	Frequency               string    `description:"频度"`
	StartDate               time.Time `description:"开始日期（至时分秒）"`
	EndDate                 time.Time `description:"结束日期（至时分秒）"`
	Describe                string    `description:"指标描述"`
	Sort                    int       `description:"排序"`
	IsStop                  int       `description:"是否停更：0-否；1-停更"`
	TerminalCode            string    `description:"所属终端编码"`
	StockCode               string    `description:"证券代码"`
	Indicator               string    `description:"同花顺指标代码"`
	ApiPars                 string    `description:"API请求参数"`
	LatestValue             float64   `description:"最新值"`
	SysUserId               int       `description:"创建人ID"`
	SysUserRealName         string    `description:"创建人姓名"`
	CreateTime              time.Time `description:"创建时间"`
	ModifyTime              time.Time `description:"修改时间"`
}

func (m *BaseFromThsHfIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_THS, utils.DATA_SUB_SOURCE_HIGH_FREQUENCY, "同花顺高频"
}

func (m *BaseFromThsHfIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_ths_hf_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_ths_hf_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromThsHfIndex) Format2SearchDataSource(origin *BaseFromThsHfIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromThsHfIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromThsHfClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDateTime, origin.StartDate) // 高频这里是到时分秒
	item.EndDate = utils.TimeTransferString(utils.FormatDateTime, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromCcfIndex CCF化纤信息
type BaseFromCcfIndex struct {
	BaseFromCcfIndexId int       `gorm:"column:base_from_ccf_index_id;primaryKey"`
	ClassifyId         int       `description:"分类ID"`
	IndexCode          string    `description:"指标编码"`
	IndexName          string    `description:"指标名称"`
	Unit               string    `description:"单位"`
	Frequency          string    `description:"频度"`
	StartDate          time.Time `description:"开始日期"`
	EndDate            time.Time `description:"结束日期"`
	LatestValue        float64   `description:"最新值"`
	CreateTime         time.Time `description:"创建时间"`
	ModifyTime         time.Time `description:"更新时间"`
}

func (m *BaseFromCcfIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_CCF, 0, "CCF化纤信息"
}

func (m *BaseFromCcfIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_ccf_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromCcfIndex) Format2SearchDataSource(origin *BaseFromCcfIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromCcfIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromUsdaFasIndex 美国农业部
type BaseFromUsdaFasIndex struct {
	BaseFromUsdaFasIndexId int       `gorm:"column:base_from_usda_fas_index_id;primaryKey"`
	ClassifyId             int       `description:"分类ID"`
	IndexCode              string    `description:"指标编码"`
	IndexName              string    `description:"指标名称"`
	Unit                   string    `description:"单位"`
	Frequency              string    `description:"频度"`
	StartDate              time.Time `description:"开始日期"`
	EndDate                time.Time `description:"结束日期"`
	LatestValue            float64   `description:"最新值"`
	CreateTime             time.Time `description:"创建时间"`
	ModifyTime             time.Time `description:"更新时间"`
}

func (m *BaseFromUsdaFasIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_USDA_FAS, 0, "美国农业部"
}

func (m *BaseFromUsdaFasIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_usda_fas_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "end_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromUsdaFasIndex) Format2SearchDataSource(origin *BaseFromUsdaFasIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromUsdaFasIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromMysteelChemicalIndex 上海钢联
type BaseFromMysteelChemicalIndex struct {
	BaseFromMysteelChemicalIndexId    int       `gorm:"column:base_from_mysteel_chemical_index_id;primaryKey"`
	BaseFromMysteelChemicalClassifyId int       `description:"分类ID"`
	IndexCode                         string    `description:"指标编码"`
	IndexName                         string    `description:"指标名称"`
	Unit                              string    `description:"单位"`
	Frequency                         string    `description:"频度"`
	StartDate                         time.Time `description:"开始日期"`
	EndDate                           time.Time `description:"结束日期"`
	LatestValue                       float64   `description:"最新值"`
	CreateTime                        time.Time `description:"创建时间"`
	ModifyTime                        time.Time `description:"更新时间"`
}

func (m *BaseFromMysteelChemicalIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_MYSTEEL_CHEMICAL, 0, "上海钢联"
}

func (m *BaseFromMysteelChemicalIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_mysteel_chemical_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_mysteel_chemical_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "end_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromMysteelChemicalIndex) Format2SearchDataSource(origin *BaseFromMysteelChemicalIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromMysteelChemicalIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromMysteelChemicalClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromSmmIndex 有色原始数据库
type BaseFromSmmIndex struct {
	BaseFromSmmIndexId int       `gorm:"column:base_from_smm_index_id;primaryKey"`
	ClassifyId         int       `description:"分类ID"`
	IndexCode          string    `description:"指标编码"`
	IndexName          string    `description:"指标名称"`
	Unit               string    `description:"单位"`
	Frequency          string    `description:"频度"`
	StartDate          time.Time `description:"开始日期"`
	EndDate            time.Time `description:"结束日期"`
	LatestValue        float64   `description:"最新值"`
	CreateTime         time.Time `description:"创建时间"`
	ModifyTime         time.Time `description:"更新时间"`
}

func (m *BaseFromSmmIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_YS, 0, "SMM原始数据库"
}

func (m *BaseFromSmmIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_smm_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "end_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromSmmIndex) Format2SearchDataSource(origin *BaseFromSmmIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromSmmIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromBaiinfoIndex 百川盈孚
type BaseFromBaiinfoIndex struct {
	BaseFromBaiinfoIndexId int       `gorm:"column:base_from_baiinfo_index_id;primaryKey"`
	ClassifyId             int       `description:"分类ID"`
	IndexCode              string    `description:"指标编码"`
	IndexName              string    `description:"指标名称"`
	Unit                   string    `description:"单位"`
	Frequency              string    `description:"频度"`
	StartDate              time.Time `description:"开始日期"`
	EndDate                time.Time `description:"结束日期"`
	LatestValue            float64   `description:"最新值"`
	CreateTime             time.Time `description:"创建时间"`
	ModifyTime             time.Time `description:"更新时间"`
}

func (m *BaseFromBaiinfoIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_BAIINFO, 0, "百川盈孚"
}

func (m *BaseFromBaiinfoIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_baiinfo_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromBaiinfoIndex) Format2SearchDataSource(origin *BaseFromBaiinfoIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromBaiinfoIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromSciIndex 卓创数据（红桃3）
type BaseFromSciIndex struct {
	BaseFromSciIndexId int       `gorm:"column:base_from_sci_index_id;primaryKey"`
	ClassifyId         int       `description:"分类ID"`
	IndexCode          string    `description:"指标编码"`
	IndexName          string    `description:"指标名称"`
	Unit               string    `description:"单位"`
	Frequency          string    `description:"频度"`
	StartDate          time.Time `description:"开始日期"`
	EndDate            time.Time `description:"结束日期"`
	LatestValue        float64   `description:"最新值"`
	CreateTime         time.Time `description:"创建时间"`
	ModifyTime         time.Time `description:"更新时间"`
}

func (m *BaseFromSciIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_SCI, 0, "卓创数据（红桃3）"
}

func (m *BaseFromSciIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_sci_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromSciIndex) Format2SearchDataSource(origin *BaseFromSciIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromSciIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromCoalmineMapping 中国煤炭市场网
type BaseFromCoalmineMapping struct {
	BaseFromCoalmineMappingId int       `gorm:"column:base_from_coalmine_mapping_id;primaryKey"`
	ClassifyId                int       `description:"分类ID"`
	IndexCode                 string    `description:"指标编码"`
	IndexName                 string    `description:"指标名称"`
	Unit                      string    `description:"单位"`
	Frequency                 string    `description:"频度"`
	StartDate                 time.Time `description:"开始日期"`
	EndDate                   time.Time `description:"结束日期"`
	LatestValue               string    `description:"最新值"`
	CreateTime                time.Time `description:"创建时间"`
	ModifyTime                time.Time `description:"更新时间"`
}

func (m *BaseFromCoalmineMapping) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_COAL, 0, "中国煤炭市场网"
}

func (m *BaseFromCoalmineMapping) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_coalmine_mapping_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromCoalmineMapping) Format2SearchDataSource(origin *BaseFromCoalmineMapping) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromCoalmineMappingId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = origin.LatestValue
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromEiaSteoIndex EIA STEO报告
type BaseFromEiaSteoIndex struct {
	BaseFromEiaSteoIndexId    int       `gorm:"column:base_from_eia_steo_index_id;primaryKey"`
	BaseFromEiaSteoClassifyId int       `description:"分类ID"`
	IndexCode                 string    `description:"指标编码"`
	IndexName                 string    `description:"指标名称"`
	Unit                      string    `description:"单位"`
	Frequency                 string    `description:"频度"`
	StartDate                 time.Time `description:"开始日期"`
	EndDate                   time.Time `description:"结束日期"`
	LatestValue               float64   `description:"最新值"`
	CreateTime                time.Time `description:"创建时间"`
	ModifyTime                time.Time `description:"更新时间"`
}

func (m *BaseFromEiaSteoIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_EIA_STEO, 0, "EIA STEO报告"
}

func (m *BaseFromEiaSteoIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_eia_steo_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_eia_steo_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromEiaSteoIndex) Format2SearchDataSource(origin *BaseFromEiaSteoIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromEiaSteoIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromEiaSteoClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromIcpiIndex ICPI消费价格指数
//type BaseFromIcpiIndex struct {
//	BaseFromIcpiIndexId    int       `gorm:"column:base_from_icpi_index_id;primaryKey"`
//	BaseFromIcpiClassifyId int       `description:"分类ID"`
//	IndexCode              string    `description:"指标编码"`
//	IndexName              string    `description:"指标名称"`
//	Unit                   string    `description:"单位"`
//	Frequency              string    `description:"频度"`
//	StartDate              time.Time `description:"开始日期"`
//	EndDate                time.Time `description:"结束日期"`
//	LatestValue            float64   `description:"最新值"`
//	CreateTime             time.Time `description:"创建时间"`
//	ModifyTime             time.Time `description:"更新时间"`
//}

func (m *BaseFromIcpiIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_ICPI, 0, "ICPI消费价格指数"
}

func (m *BaseFromIcpiIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_icpi_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "base_from_icpi_classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromIcpiIndex) Format2SearchDataSource(origin *BaseFromIcpiIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromIcpiIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.BaseFromIcpiClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromYongyiIndex 涌益咨询
type BaseFromYongyiIndex struct {
	YongyiIndexId int       `gorm:"column:yongyi_index_id;primaryKey"`
	ClassifyId    int       `description:"分类ID"`
	IndexCode     string    `description:"指标编码"`
	IndexName     string    `description:"指标名称"`
	Unit          string    `description:"单位"`
	Frequency     string    `description:"频度"`
	StartDate     time.Time `description:"开始日期"`
	EndDate       time.Time `description:"结束日期"`
	LatestValue   float64   `description:"最新值"`
	CreateTime    time.Time `description:"创建时间"`
	ModifyTime    time.Time `description:"更新时间"`
}

func (m *BaseFromYongyiIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_YONYI, 0, "涌益咨询"
}

func (m *BaseFromYongyiIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "yongyi_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromYongyiIndex) Format2SearchDataSource(origin *BaseFromYongyiIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.YongyiIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromFenweiIndex 汾渭数据
type BaseFromFenweiIndex struct {
	FenweiIndexId int       `gorm:"column:fenwei_index_id;primaryKey"`
	ClassifyId    int       `description:"分类ID"`
	IndexCode     string    `description:"指标编码"`
	IndexName     string    `description:"指标名称"`
	Unit          string    `description:"单位"`
	Frequency     string    `description:"频度"`
	StartDate     time.Time `description:"开始日期"`
	EndDate       time.Time `description:"结束日期"`
	LatestValue   float64   `description:"最新值"`
	CreateTime    time.Time `description:"创建时间"`
	ModifyTime    time.Time `description:"更新时间"`
}

func (m *BaseFromFenweiIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_FENWEI, 0, "汾渭数据"
}

func (m *BaseFromFenweiIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "fenwei_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromFenweiIndex) Format2SearchDataSource(origin *BaseFromFenweiIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.FenweiIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromSci99Index 卓创资讯
//type BaseFromSci99Index struct {
//	BaseFromSciIndexId int       `gorm:"column:base_from_sci_index_id;primaryKey"`
//	ClassifyId         int       `description:"分类ID"`
//	IndexCode          string    `description:"指标编码"`
//	IndexName          string    `description:"指标名称"`
//	Unit               string    `description:"单位"`
//	Frequency          string    `description:"频度"`
//	StartDate          time.Time `description:"开始日期"`
//	EndDate            time.Time `description:"结束日期"`
//	LatestValue        float64   `description:"最新值"`
//	CreateTime         time.Time `description:"创建时间"`
//	ModifyTime         time.Time `description:"更新时间"`
//}

func (m *BaseFromSci99Index) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_SCI99, 0, "卓创资讯"
}

func (m *BaseFromSci99Index) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_sci_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromSci99Index) Format2SearchDataSource(origin *BaseFromSci99Index) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromSciIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromGlIndex 钢联原始指标库
type BaseFromGlIndex struct {
	PrimaryId   int       `gorm:"column:ID;primaryKey"`
	IndexCode   string    `gorm:"column:INDEX_CODE" description:"指标编码"`
	IndexName   string    `gorm:"column:INDEX_NAME" description:"指标名称"`
	Unit        string    `gorm:"column:UNIT_NAME" description:"单位"`
	Frequency   string    `gorm:"column:FREQUENCY_NAME" description:"频度"`
	StartDate   string    `gorm:"column:BEGIN_DATE" description:"开始日期"`
	EndDate     string    `gorm:"column:END_DATE" description:"结束日期"`
	LatestValue float64   `gorm:"column:DATA_VALUE" description:"最新值"`
	CreateTime  time.Time `gorm:"column:CREATE_TIME" description:"创建时间"`
	ModifyTime  time.Time `gorm:"column:UPDATE_TIME" description:"更新时间"`
}

func (m *BaseFromGlIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_GL, 0, "钢联原始数据库"
}

func (m *BaseFromGlIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "ID",
		IndexCode:   "INDEX_CODE",
		IndexName:   "INDEX_NAME",
		ClassifyId:  "",
		Unit:        "UNIT_NAME",
		Frequency:   "FREQUENCY_NAME",
		StartDate:   "BEGIN_DATE",
		EndDate:     "END_DATE",
		LatestValue: "DATA_VALUE",
		CreateTime:  "CREATE_TIME",
		ModifyTime:  "UPDATE_TIME",
	}
}

func (m *BaseFromGlIndex) Format2SearchDataSource(origin *BaseFromGlIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.PrimaryId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	//item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = origin.StartDate
	item.EndDate = origin.EndDate
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromManualEdb 手工数据录入
type BaseFromManualEdb struct {
	//PrimaryId   int       `gorm:"column:TRADE_CODE)"` // 注手工指标没自增ID...
	IndexCode   string    `gorm:"column:TRADE_CODE" description:"指标编码"`
	IndexName   string    `gorm:"column:SEC_NAME" description:"指标名称"`
	ClassifyId  int       `gorm:"column:classify_id" description:"分类ID"`
	Unit        string    `gorm:"column:UNIT" description:"单位"`
	Frequency   string    `gorm:"column:frequency" description:"频度"`
	StartDate   time.Time `gorm:"column:start_date" description:"开始日期"`
	EndDate     time.Time `gorm:"column:end_date" description:"结束日期"`
	LatestValue float64   `gorm:"column:latest_value" description:"最新值"`
	CreateTime  time.Time `gorm:"column:create_date" description:"创建时间"`
	ModifyTime  time.Time `gorm:"column:modify_time" description:"更新时间"`
}

func (m *BaseFromManualEdb) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_MANUAL, 0, "手工指标录入"
}

func (m *BaseFromManualEdb) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "",
		IndexCode:   "TRADE_CODE",
		IndexName:   "SEC_NAME",
		ClassifyId:  "classify_id",
		Unit:        "UNIT",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_date",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromManualEdb) Format2SearchDataSource(origin *BaseFromManualEdb) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	//item.PrimaryId = origin.PrimaryId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromBusinessIndex 自有数据
type BaseFromBusinessIndex struct {
	BaseFromBusinessIndexId int `gorm:"column:base_from_business_index_id;primaryKey"`
	//ClassifyId              int       `description:"分类ID"`
	IndexCode   string    `description:"指标编码"`
	IndexName   string    `description:"指标名称"`
	Unit        string    `description:"单位"`
	Frequency   string    `description:"频度"`
	StartDate   time.Time `description:"开始日期"`
	EndDate     time.Time `description:"结束日期"`
	LatestValue float64   `description:"最新值"`
	CreateTime  time.Time `description:"创建时间"`
	ModifyTime  time.Time `description:"更新时间"`
}

func (m *BaseFromBusinessIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_BUSINESS, 0, "自有数据"
}

func (m *BaseFromBusinessIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_business_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromBusinessIndex) Format2SearchDataSource(origin *BaseFromBusinessIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromBusinessIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	//item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromBloombergIndex Bloomberg
type BaseFromBloombergIndex struct {
	BaseFromBloombergIndexId int `gorm:"column:base_from_bloomberg_index_id;primaryKey"`
	//ClassifyId              int       `description:"分类ID"`
	IndexCode   string    `description:"指标编码"`
	IndexName   string    `description:"指标名称"`
	Unit        string    `description:"单位"`
	Frequency   string    `description:"频度"`
	StartDate   time.Time `description:"开始日期"`
	EndDate     time.Time `description:"结束日期"`
	LatestValue float64   `description:"最新值"`
	CreateTime  time.Time `description:"创建时间"`
	ModifyTime  time.Time `description:"更新时间"`
}

func (m *BaseFromBloombergIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_BLOOMBERG, 0, "Bloomberg"
}

func (m *BaseFromBloombergIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_bloomberg_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromBloombergIndex) Format2SearchDataSource(origin *BaseFromBloombergIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromBloombergIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	//item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseFromMtjhMapping 煤炭江湖
type BaseFromMtjhMapping struct {
	BaseFromMtjhMappingId int `gorm:"column:base_from_mtjh_mapping_id;primaryKey"`
	//ClassifyId            int       `description:"分类ID"`
	IndexCode   string    `description:"指标编码"`
	IndexName   string    `description:"指标名称"`
	Unit        string    `description:"单位"`
	Frequency   string    `description:"频度"`
	StartDate   time.Time `description:"开始日期"`
	EndDate     time.Time `description:"结束日期"`
	LatestValue float64   `description:"最新值"`
	CreateTime  time.Time `description:"创建时间"`
	ModifyTime  time.Time `description:"更新时间"`
}

func (m *BaseFromMtjhMapping) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_MTJH, 0, "煤炭江湖"
}

func (m *BaseFromMtjhMapping) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "base_from_mtjh_mapping_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue: "latest_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromMtjhMapping) Format2SearchDataSource(origin *BaseFromMtjhMapping) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromMtjhMappingId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	//item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.LatestValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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

// BaseIndexDataMinMax 数据源极值信息
type BaseIndexDataMinMax struct {
	MinDate     string `description:"最小日期"`
	MaxDate     string `description:"最大日期"`
	LatestValue string `description:"最新值"`
	//MinValue    float64 `description:"最小值"`
	//MaxValue    float64 `description:"最大值"`
}

// GetBaseIndexDataTableName 根据来源获取原始指标表和数据表名（很大一部分来源不存在原始指标）
func GetBaseIndexDataTableName(source, subSource int) (indexTable, dataTable string) {
	switch source {
	case utils.DATA_SOURCE_THS:
		if subSource == utils.DATA_SUB_SOURCE_HIGH_FREQUENCY {
			indexTable = "base_from_ths_hf_index"
			dataTable = "base_from_ths_hf_data"
		}
	case utils.DATA_SOURCE_RZD:
		indexTable = "base_from_rzd_index"
		dataTable = "base_from_rzd_data"
	case utils.DATA_SOURCE_HISUGAR:
		indexTable = "base_from_hisugar_index"
		dataTable = "base_from_hisugar_data"
	case utils.DATA_SOURCE_LY:
		indexTable = "base_from_ly_index"
		dataTable = "base_from_ly_data"
	case utils.DATA_SOURCE_SCI_HQ:
		indexTable = "base_from_sci_hq_index"
		dataTable = "base_from_sci_hq_data"
	case utils.DATA_SOURCE_OILCHEM:
		indexTable = "base_from_oilchem_index"
		dataTable = "base_from_oilchem_data"
	case utils.DATA_SOURCE_CCF:
		indexTable = "base_from_ccf_index"
		dataTable = "base_from_ccf_data"
	case utils.DATA_SOURCE_USDA_FAS:
		indexTable = "base_from_usda_fas_index"
		dataTable = "base_from_usda_fas_data"
	case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
		indexTable = "base_from_mysteel_chemical_index"
		dataTable = "base_from_mysteel_chemical_data"
	case utils.DATA_SOURCE_YS:
		indexTable = "base_from_smm_index"
		dataTable = "base_from_smm_data"
	case utils.DATA_SOURCE_BAIINFO:
		indexTable = "base_from_baiinfo_index"
		dataTable = "base_from_baiinfo_data"
	case utils.DATA_SOURCE_SCI:
		indexTable = "base_from_sci_index"
		dataTable = "base_from_sci_data"
	case utils.DATA_SOURCE_EIA_STEO:
		indexTable = "base_from_eia_steo_index"
		dataTable = "base_from_eia_steo_data"
	case utils.DATA_SOURCE_ICPI:
		indexTable = "base_from_icpi_index"
		dataTable = "base_from_icpi_data"
	case utils.DATA_SOURCE_YONYI:
		indexTable = "base_from_yongyi_index"
		dataTable = "base_from_yongyi_data"
	case utils.DATA_SOURCE_FENWEI:
		indexTable = "base_from_fenwei_index"
		dataTable = "base_from_fenwei_data"
	case utils.DATA_SOURCE_SCI99:
		indexTable = "base_from_sci99_index"
		dataTable = "base_from_sci99_data"
	case utils.DATA_SOURCE_BUSINESS:
		indexTable = "base_from_business_index"
		dataTable = "base_from_business_data"
	case utils.DATA_SOURCE_BLOOMBERG:
		indexTable = "base_from_bloomberg_index"
		dataTable = "base_from_bloomberg_data"
	case utils.DATA_SOURCE_KPLER:
		indexTable = "base_from_kpler_index"
		dataTable = "base_from_kpler_data"
	default:
		utils.FileLog.Info(fmt.Sprintf("数据源无对应表名, source: %d, sub: %d", source, subSource))
	}
	return
}

// getCoalmineDataTableName 获取中国煤炭市场网数据表名
func getCoalmineDataTableName(indexCode string) string {
	if strings.Contains(indexCode, "jsm") {
		return "base_from_coalmine_jsm_index"
	}
	if strings.Contains(indexCode, "company") {
		return "base_from_coalmine_company_index"
	}
	if strings.Contains(indexCode, "firm") {
		return "base_from_coalmine_firm_index"
	}
	if strings.Contains(indexCode, "coastal") {
		return "base_from_coalmine_coastal_index"
	}
	if strings.Contains(indexCode, "inland") {
		return "base_from_coalmine_inland_index"
	}
	return ""
}

// GetBaseIndexDataMinMax 获取数据源极值
func GetBaseIndexDataMinMax(source, subSource int, indexCode string) (item *BaseIndexDataMinMax, err error) {
	o := global.DbMap[utils.DbNameIndex]
	var sql string
	var latestVal string

	// 煤炭江湖
	if source == utils.DATA_SOURCE_MTJH {
		sql = `SELECT MIN(data_time) AS min_date, MAX(data_time) AS max_date FROM base_from_mtjh_index WHERE index_code = ?`
		if err = o.Raw(sql, indexCode).First(&item).Error; err != nil {
			return
		}

		sql = `SELECT deal_value AS latest_value FROM base_from_mtjh_index WHERE index_code = ? ORDER BY data_time DESC LIMIT 1`
		if err = o.Raw(sql, indexCode).Scan(&latestVal).Error; err != nil {
			return
		}
		item.LatestValue = latestVal
		return
	}

	// 中国煤炭市场网
	if source == utils.DATA_SOURCE_COAL {
		dataTable := getCoalmineDataTableName(indexCode)
		if dataTable == "" {
			err = fmt.Errorf("中国煤炭市场网-指标无对应表名: %s", indexCode)
			return
		}
		fieldDataTime := "data_time"
		if dataTable == "base_from_coalmine_firm_index" {
			fieldDataTime = "data_time_date"
		}
		sql = `SELECT MIN(%s) AS min_date, MAX(%s) AS max_date FROM %s WHERE index_code = ?`
		sql = fmt.Sprintf(sql, fieldDataTime, fieldDataTime, dataTable)
		if err = o.Raw(sql, indexCode).First(&item).Error; err != nil {
			return
		}

		sql = `SELECT deal_value AS latest_value FROM %s WHERE index_code = ? ORDER BY %s DESC LIMIT 1`
		sql = fmt.Sprintf(sql, dataTable, fieldDataTime)
		if err = o.Raw(sql, indexCode).Scan(&latestVal).Error; err != nil {
			return
		}
		item.LatestValue = latestVal
		return
	}

	// 其他数据源
	_, dataTable := GetBaseIndexDataTableName(source, subSource)
	if dataTable == "" {
		err = fmt.Errorf("数据源无对应数据表, source: %d, sub: %d, code: %s", source, subSource, indexCode)
		return
	}

	sql = `SELECT MIN(data_time) AS min_date, MAX(data_time) AS max_date FROM %s WHERE index_code = ?`
	sql = fmt.Sprintf(sql, dataTable)
	if err = o.Raw(sql, indexCode).First(&item).Error; err != nil {
		return
	}

	sql = `SELECT value AS latest_value FROM %s WHERE index_code = ? ORDER BY data_time DESC LIMIT 1`
	sql = fmt.Sprintf(sql, dataTable)
	sql = utils.ReplaceDriverKeywords("", sql)
	if err = o.Raw(sql, indexCode).Scan(&latestVal).Error; err != nil {
		return
	}
	item.LatestValue = latestVal
	return
}

// BaseFromMtjhIndex 煤炭江湖数据表
type BaseFromMtjhIndex struct {
	BaseFromMtjhIndexId int       `gorm:"column:base_from_mtjh_index_id;primaryKey"`
	IndexCode           string    `description:"指标编码"`
	IndexName           string    `description:"指标名称"`
	DealValue           string    `description:"成交量"`
	DataTime            time.Time `description:"数据日期"`
	Unit                string    `description:"单位"`
	Frequency           string    `description:"频度"`
	StartDate           time.Time `description:"开始日期"`
	EndDate             time.Time `description:"结束日期"`
	LatestValue         float64   `description:"最新值"`
	CreateTime          time.Time `description:"创建时间"`
	ModifyTime          time.Time `description:"更新时间"`
}

// GetMtjhBaseInfoFromDataTable 煤炭江湖-从数据表获取基础信息
func GetMtjhBaseInfoFromDataTable(codes []string) (items []*BaseFromMtjhIndex, err error) {
	codeLens := len(codes)
	if codeLens == 0 {
		return
	}
	sql := fmt.Sprintf(`SELECT * FROM base_from_mtjh_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(codeLens))
	err = global.DbMap[utils.DbNameIndex].Raw(sql, codes).Find(&items).Error
	return
}

// BaseFromCoalmineIndexBase 中国煤炭市场网数据表基础信息
type BaseFromCoalmineIndexBase struct {
	IndexCode  string    `description:"指标编码"`
	IndexName  string    `description:"指标名称"`
	Unit       string    `description:"单位"`
	Frequency  string    `description:"频度"`
	CreateTime time.Time `description:"创建时间"`
	ModifyTime time.Time `description:"更新时间"`
}

// GetCoalmineBaseInfoFromDataTable 中国煤炭市场网-从数据表获取基础信息
func GetCoalmineBaseInfoFromDataTable(codes []string) (items []*BaseFromCoalmineIndexBase, err error) {
	codeLens := len(codes)
	if codeLens == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	items = make([]*BaseFromCoalmineIndexBase, 0)
	var jsmCodes, companyCodes, firmCodes, coastalCodes, inlandCodes []string
	for _, code := range codes {
		if strings.Contains(code, "jsm") {
			jsmCodes = append(jsmCodes, code)
		}
		if strings.Contains(code, "company") {
			companyCodes = append(companyCodes, code)
		}
		if strings.Contains(code, "firm") {
			firmCodes = append(firmCodes, code)
		}
		if strings.Contains(code, "coastal") {
			coastalCodes = append(coastalCodes, code)
		}
		if strings.Contains(code, "inland") {
			inlandCodes = append(inlandCodes, code)
		}
	}
	var sql string
	itemsOnce := make([]*BaseFromCoalmineIndexBase, 0)
	if len(jsmCodes) > 0 {
		sql = fmt.Sprintf(`SELECT * FROM base_from_coalmine_jsm_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(len(jsmCodes)))
		err = o.Raw(sql, jsmCodes).Find(&itemsOnce).Error
		if err != nil {
			return
		}
		items = append(items, itemsOnce...)
	}
	if len(companyCodes) > 0 {
		sql = fmt.Sprintf(`SELECT * FROM base_from_coalmine_company_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(len(companyCodes)))
		err = o.Raw(sql, companyCodes).Find(&itemsOnce).Error
		if err != nil {
			return
		}
		items = append(items, itemsOnce...)
	}
	if len(firmCodes) > 0 {
		sql = fmt.Sprintf(`SELECT * FROM base_from_coalmine_firm_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(len(firmCodes)))
		err = o.Raw(sql, firmCodes).Find(&itemsOnce).Error
		if err != nil {
			return
		}
		items = append(items, itemsOnce...)
	}
	if len(coastalCodes) > 0 {
		sql = fmt.Sprintf(`SELECT * FROM base_from_coalmine_coastal_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(len(coastalCodes)))
		err = o.Raw(sql, coastalCodes).Find(&itemsOnce).Error
		if err != nil {
			return
		}
		items = append(items, itemsOnce...)
	}
	if len(inlandCodes) > 0 {
		sql = fmt.Sprintf(`SELECT * FROM base_from_coalmine_inland_index WHERE index_code IN (%s) GROUP BY index_code`, utils.GetOrmInReplace(len(inlandCodes)))
		err = o.Raw(sql, inlandCodes).Find(&itemsOnce).Error
		if err != nil {
			return
		}
		items = append(items, itemsOnce...)
	}
	return
}


type BaseFromKplerIndex struct {
	BaseFromKplerIndexId int `orm:"column(base_from_kpler_index_id);pk" gorm:"primaryKey"`
	ClassifyId           int
	IndexCode            string
	IndexName            string
	Frequency            string
	Unit                 string
	Sort                 int
	StartDate            time.Time `description:"开始日期"`
	EndDate              time.Time `description:"结束日期"`
	EndValue             float64
	CreateTime           time.Time
	ModifyTime           time.Time
	BaseFileName         string `description:"文件目录"`
	TerminalCode         string `description:"所属终端编码"`
	ApiQueryUrl          string `description:"API查询URL"`
	ProductNames         string `description:"产品名称"`
	FromZoneId           string    `description:"区域ID"`
	FromZoneName         string `description:"区域名称"`
	ToZoneId             string    `description:"区域ID"`
	ToZoneName           string `description:"区域名称"`
	FlowDirection        string `description:"流向"`
	Granularity          string `description:"粒度"`
	Split                string `description:"拆分类型"`
}

func (m *BaseFromKplerIndex) SourceInfo() (int, int, string) {
	return utils.DATA_SOURCE_KPLER, 0, "Kpler"
}

func (m *BaseFromKplerIndex) EsCols() SearchEsCols {
	return SearchEsCols{
		PrimaryId:   "kpler_index_id",
		IndexCode:   "index_code",
		IndexName:   "index_name",
		ClassifyId:  "classify_id",
		Unit:        "unit",
		Frequency:   "frequency",
		StartDate:   "start_date",
		EndDate:     "end_date",
		LatestValue:    "end_value",
		CreateTime:  "create_time",
		ModifyTime:  "modify_time",
	}
}

func (m *BaseFromKplerIndex) Format2SearchDataSource(origin *BaseFromKplerIndex) (item *SearchDataSource) {
	if origin == nil {
		return
	}
	source, subSource, sourceName := m.SourceInfo()
	item = new(SearchDataSource)
	item.PrimaryId = origin.BaseFromKplerIndexId
	item.IndexCode = origin.IndexCode
	item.IndexName = origin.IndexName
	item.ClassifyId = origin.ClassifyId
	item.Unit = origin.Unit
	item.Frequency = origin.Frequency
	item.StartDate = utils.TimeTransferString(utils.FormatDate, origin.StartDate)
	item.EndDate = utils.TimeTransferString(utils.FormatDate, origin.EndDate)
	item.LatestValue = fmt.Sprint(origin.EndValue)
	item.Source = source
	item.SubSource = subSource
	item.SourceName = sourceName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	return
}

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