eta_index_lib/models/base_from_smm.go

package models

import (
	sql2 "database/sql"
	"eta/eta_index_lib/global"
	"eta/eta_index_lib/utils"
	"fmt"
	"gorm.io/gorm"
	"strconv"
	"strings"
	"time"
)

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

func (e *BaseFromSmmData) AfterFind(db *gorm.DB) (err error) {
	e.DataTime = utils.GormDateStrToDateStr(e.DataTime)

	return
}

func (s *BaseFromSmmData) Update(cols []string) (err error) {
	//o := orm.NewOrm()
	//_, err = o.Update(s, cols...)
	err = global.DEFAULT_DB.Model(&s).Select(cols).Updates(&s).Error

	return
}

func AddBaseFromSmmData(item []*BaseFromSmmData) (err error) {
	//o := orm.NewOrm()
	//_, err = o.InsertMulti(500, item)
	err = global.DEFAULT_DB.CreateInBatches(item, utils.MultiAddNum).Error
	return
}

func GetBaseFromSmmDataByCondition(condition string, pars []interface{}) (list []*BaseFromSmmData, err error) {
	//o := orm.NewOrm()
	sql := `SELECT * FROM base_from_smm_data WHERE 1=1 `
	if condition != "" {
		sql += condition
	}
	//_, err = o.Raw(sql, pars).QueryRows(&list)
	err = global.DEFAULT_DB.Raw(sql, pars...).Find(&list).Error
	return
}

func UpdateBaseFromSmmDataListByIndexCode(items []*BaseFromSmmData) (err error) {
	//o := orm.NewOrm()
	to := global.DEFAULT_DB.Begin()
	defer func() {
		if err != nil {
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()

	sql := `UPDATE base_from_smm_data SET value=? WHERE index_code=? AND data_time=? `
	for _, item := range items {
		err = to.Exec(sql, item.Value, item.IndexCode, item.DataTime).Error
		if err != nil {
			return
		}
	}
	//stmt, err := o.Raw(sql).Prepare()
	//if err != nil {
	//	return
	//}
	//defer stmt.Close()
	//for _, item := range items {
	//	_, err = stmt.Exec(item.Value, item.IndexCode, item.DataTime)
	//	if err != nil {
	//		return
	//	}
	//}

	return
}

func GetBaseFromSmmDataByIds(smmDataIds []int) (list []*BaseFromSmmData, err error) {
	if len(smmDataIds) == 0 {
		return
	}
	//o := orm.NewOrm()
	//sql := `SELECT * FROM base_from_smm_data WHERE 1=1 AND base_from_smm_index_id in (` + utils.GetOrmInReplace(len(smmDataIds)) + `)`
	sql := `SELECT * FROM base_from_smm_data WHERE 1=1 AND base_from_smm_index_id in ?`
	//_, err = o.Raw(sql, smmDataIds).QueryRows(&list)
	err = global.DEFAULT_DB.Raw(sql, smmDataIds).Find(&list).Error
	return
}

func GetBaseFromSmmDataByCodeAndDate(indexCode string, dataTime string) (item *BaseFromSmmData, err error) {
	//o := orm.NewOrm()
	sql := `SELECT * FROM base_from_smm_data WHERE 1=1 AND index_code=? AND data_time=? `
	//err = o.Raw(sql, indexCode, dataTime).QueryRow(&item)
	err = global.DEFAULT_DB.Raw(sql, indexCode, dataTime).First(&item).Error
	return
}

// 新增有色指标数据
func AddEdbDataFromSmm(edbCode string, smmBaseDataAll []*BaseFromSmmData) (err error) {
	//o := orm.NewOrm()
	var isAdd bool
	addSql := ` INSERT INTO edb_data_ys(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
	existMap := make(map[string]string)
	for _, sv := range smmBaseDataAll {
		eDate := sv.DataTime
		dataTime, err := time.ParseInLocation(utils.FormatDate, eDate, time.Local)
		if err != nil {
			return err
		}
		timestamp := dataTime.UnixNano() / 1e6
		timeStr := fmt.Sprintf("%d", timestamp)
		if _, ok := existMap[eDate]; !ok {
			addSql += GetAddSql("0", edbCode, eDate, timeStr, sv.Value)
			isAdd = true
		}
		existMap[eDate] = sv.Value
	}
	if isAdd {
		addSql = strings.TrimRight(addSql, ",")
		utils.FileLog.Info("addSql:" + addSql)
		//_, err = o.Raw(addSql).Exec()
		err = global.DEFAULT_DB.Exec(addSql).Error
		if err != nil {
			return err
		}
	}
	return
}

// RefreshEdbDataFromSmm 刷新有色指标数据
func RefreshEdbDataFromSmm(edbInfoId int, edbCode, startDate string) (err error) {
	source := utils.DATA_SOURCE_YS
	subSource := utils.DATA_SUB_SOURCE_EDB

	//o := orm.NewOrm()
	if err != nil {
		return
	}
	edbInfoIdStr := strconv.Itoa(edbInfoId)
	//计算数据
	var condition string
	var pars []interface{}

	if edbCode != "" {
		condition += " AND index_code=? "
		pars = append(pars, edbCode)
	}

	if startDate != "" {
		condition += " AND data_time>=? "
		pars = append(pars, startDate)
	}

	smmDataList, err := GetBaseFromSmmDataByCondition(condition, pars)
	if err != nil {
		return
	}

	// 真实数据的最大日期  ， 插入规则配置的日期
	var realDataMaxDate, edbDataInsertConfigDate time.Time
	var edbDataInsertConfig *EdbDataInsertConfig
	var isFindConfigDateRealData bool //是否找到配置日期的实际数据的值
	{
		edbDataInsertConfig, err = GetEdbDataInsertConfigByEdbId(edbInfoId)
		if err != nil && !utils.IsErrNoRow(err) {
			return
		}
		if edbDataInsertConfig != nil {
			edbDataInsertConfigDate = edbDataInsertConfig.Date
		}
	}

	var existCondition string
	var existPars []interface{}

	existCondition += " AND edb_info_id=? "
	existPars = append(existPars, edbInfoId)
	if startDate != "" {
		existCondition += " AND data_time>=? "
		existPars = append(existPars, startDate)
	}

	existList, err := GetEdbDataByCondition(source, subSource, existCondition, existPars)
	if err != nil {
		return err
	}
	existMap := make(map[string]*EdbInfoSearchData)
	for _, v := range existList {
		existMap[v.DataTime] = v
	}
	addSql := ` INSERT INTO edb_data_ys(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
	var isAdd bool
	for _, v := range smmDataList {
		item := v
		eDate := item.DataTime
		dataTime, err := time.ParseInLocation(utils.FormatDate, eDate, time.Local)
		if err != nil {
			return err
		}
		if findItem, ok := existMap[v.DataTime]; !ok {
			sValue := item.Value

			timestamp := dataTime.UnixNano() / 1e6
			timeStr := fmt.Sprintf("%d", timestamp)

			addSql += GetAddSql(edbInfoIdStr, edbCode, eDate, timeStr, sValue)
			isAdd = true
		} else {
			if findItem != nil && utils.SubFloatToString(findItem.Value, 30) != item.Value {
				err = ModifyEdbDataById(source, subSource, findItem.EdbDataId, item.Value)
				if err != nil {
					return err
				}
			}
		}

		// 下面代码主要目的是处理掉手动插入的数据判断
		{
			if realDataMaxDate.IsZero() || dataTime.After(realDataMaxDate) {
				realDataMaxDate = dataTime
			}
			if edbDataInsertConfigDate.IsZero() || dataTime.Equal(edbDataInsertConfigDate) {
				isFindConfigDateRealData = true
			}
		}
	}

	// 处理手工数据补充的配置
	HandleConfigInsertEdbData(realDataMaxDate, edbDataInsertConfig, edbInfoId, source, subSource, existMap, isFindConfigDateRealData)

	if isAdd {
		addSql = strings.TrimRight(addSql, ",")
		err = global.DEFAULT_DB.Exec(addSql).Error
		//_, err = o.Raw(addSql).Exec()
		if err != nil {
			fmt.Println("RefreshEdbDataFromSmm add Err", err.Error())
			return
		}
	}
	return
}

type BaseFromSmmIndex struct {
	BaseFromSmmIndexId int64 `gorm:"column:base_from_smm_index_id;primaryKey"`
	//BaseFromSmmIndexId int64 `orm:"column(base_from_smm_index_id);pk"`
	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
	BaseFileName   string
	RenameFileName string
	StartDate      string
	EndDate        string
	TerminalCode   string `description:"编码"`
	CreateTime     time.Time
	ModifyTime     time.Time
	DataState      string
	ReleaseTime    string
}

func (e *BaseFromSmmIndex) AfterFind(db *gorm.DB) (err error) {
	e.ApiStartTime = utils.GormDateStrToDateTimeStr(e.ApiStartTime)
	e.ApiUpdateTime = utils.GormDateStrToDateTimeStr(e.ApiUpdateTime)
	e.StartTime = utils.GormDateStrToDateTimeStr(e.StartTime)
	e.FinishTime = utils.GormDateStrToDateTimeStr(e.FinishTime)

	return
}

func (d *BaseFromSmmIndex) AddBaseFromSmmIndex() (lastId int64, err error) {
	//o := orm.NewOrm()
	//lastId, err = o.Insert(d)
	err = global.DEFAULT_DB.Create(&d).Error
	if err != nil {
		return
	}
	lastId = d.BaseFromSmmIndexId
	return
}

func (d *BaseFromSmmIndex) GetSmmIndexItem(indexCode string) (item *BaseFromSmmIndex, err error) {
	//o := orm.NewOrm()
	sql := ` SELECT * FROM base_from_smm_index WHERE index_code=? `

	//fmt.Println(sql, indexCode)
	//err = o.Raw(sql, indexCode).QueryRow(&item)
	err = global.DEFAULT_DB.Raw(sql, indexCode).First(&item).Error
	return
}

// Add 新增
func (m *BaseFromSmmIndex) Add() (err error) {
	//o := orm.NewOrm()
	//_, err = o.Insert(m)
	err = global.DEFAULT_DB.Create(&m).Error

	return
}

func GetBaseFromSmmDataBySmmCode(smmCode string) (list []*BaseFromSmmData, err error) {
	//o := orm.NewOrm()
	sql := ` SELECT * FROM base_from_smm_data WHERE index_code=? `
	//_, err = o.Raw(sql, smmCode).QueryRows(&list)
	err = global.DEFAULT_DB.Raw(sql, smmCode).Find(&list).Error
	return
}

func ModifySmmIndexSort(baseFromSmmIndexId int64) (err error) {
	//o := orm.NewOrm()
	sql := ` UPDATE base_from_smm_index SET sort=? WHERE base_from_smm_index_id=? `
	//_, err = o.Raw(sql, baseFromSmmIndexId, baseFromSmmIndexId).Exec()
	err = global.DEFAULT_DB.Exec(sql, baseFromSmmIndexId, baseFromSmmIndexId).Error
	return
}

func GetSmmIndexInfoMaxAndMinInfo(indexCode string) (item *EdbInfoMaxAndMinInfo, err error) {
	//o := orm.NewOrm()
	sql := ` SELECT MIN(data_time) AS min_date,MAX(data_time) AS max_date,MIN(value) AS min_value,MAX(value) AS max_value FROM base_from_smm_data WHERE index_code=? `
	//err = o.Raw(sql, indexCode).QueryRow(&item)
	err = global.DEFAULT_DB.Raw(sql, indexCode).First(&item).Error
	if err != nil {
		return
	}

	// 获取最新值
	sql = ` SELECT value AS latest_value FROM base_from_smm_data WHERE index_code=? ORDER BY data_time DESC LIMIT 1 `
	//err = o.Raw(sql, indexCode).QueryRow(&latest_value)
	var latestValueNull sql2.NullFloat64
	err = global.DEFAULT_DB.Raw(sql, indexCode).Scan(&latestValueNull).Error
	if err == nil && latestValueNull.Valid {
		item.LatestValue = latestValueNull.Float64
	}

	return
}

func ModifySmmIndexMaxAndMinInfo(indexCode string, item *EdbInfoMaxAndMinInfo) (err error) {
	//o := orm.NewOrm()
	sql := ` UPDATE base_from_smm_index SET start_date=?,end_date=?,end_value=?,modify_time=NOW() WHERE index_code=? `
	//_, err = o.Raw(sql, item.MinDate, item.MaxDate, item.LatestValue, indexCode).Exec()
	err = global.DEFAULT_DB.Exec(sql, item.MinDate, item.MaxDate, item.LatestValue, indexCode).Error
	return
}

// HandleSmmExcelDataReq SMM的excel数据
type HandleSmmExcelDataReq struct {
	BaseFilePath   string
	RenameFilePath string
	IndexName      string
	Source         string
	IndexCode      string
	Unit           string
	Frequency      string
	ExcelDataMap   map[string]string
	TerminalCode   string `description:"编码"`
}

// MultiUpdateBaseFromSmmDataValue 批量更新SMM指标数据
func MultiUpdateBaseFromSmmDataValue(items []*BaseFromSmmData) (err error) {
	if len(items) == 0 {
		return
	}

	//o := orm.NewOrm()
	to := global.DEFAULT_DB.Begin()
	defer func() {
		if err != nil {
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()
	sql := `UPDATE base_from_smm_data SET value = ?, modify_time = NOW() WHERE index_code = ? AND data_time = ? LIMIT 1`
	for _, v := range items {
		if v.IndexCode == "" || v.DataTime == "" {
			continue
		}
		//_, err = o.Raw(sql, v.Value, v.IndexCode, v.DataTime).Exec()
		err = to.Exec(sql, v.Value, v.IndexCode, v.DataTime).Error
		if err != nil {
			return
		}
	}
	//p, err := o.Raw(sql).Prepare()
	//if err != nil {
	//	return
	//}
	//defer func() {
	//	_ = p.Close()
	//}()
	//for _, v := range items {
	//	if v.IndexCode == "" || v.DataTime == "" {
	//		continue
	//	}
	//	_, err = p.Exec(v.Value, v.IndexCode, v.DataTime)
	//	if err != nil {
	//		return
	//	}
	//}
	return
}

type AddSmmIndexToDataSourceResp struct {
	EdbCode         string `description:"指标编码"`
	ClassifyId      int    `description:"指标分类"`
	SysUserId       int    `description:"操作人id"`
	SysUserRealName string `description:"操作人真实名称"`
}

func (m *BaseFromSmmIndex) GetIndexItem(indexCode string) (item *BaseFromSmmIndex, err error) {
	//o := orm.NewOrm()
	sql := `SELECT * FROM base_from_smm_index WHERE index_code = ? `
	//err = o.Raw(sql, indexCode).QueryRow(&item)
	err = global.DEFAULT_DB.Raw(sql, indexCode).First(&item).Error
	return
}

// 修改
func (m *BaseFromSmmIndex) Update(updateParams, whereParam map[string]interface{}) (err error) {
	//to := orm.NewOrm()
	tx := global.DEFAULT_DB.Model(&BaseFromSmmIndex{})

	//ptrStructOrTableName := "base_from_smm_index"

	//qs := to.QueryTable(ptrStructOrTableName)
	//for expr, exprV := range whereParam {
	//	qs = qs.Filter(expr, exprV)
	//}
	for expr, exprV := range whereParam {
		tx = tx.Where(expr, exprV)
	}
	//_, err = qs.Update(updateParams)
	// 执行更新操作
	result := tx.Updates(updateParams)
	if result.Error != nil {
		err = fmt.Errorf("update err: %s", result.Error.Error())
		return
	}

	return
}

// BridgeZhongJiIndexDataParams 桥接服务-获取中基指标数据入参
type BridgeZhongJiIndexDataParams struct {
	EdbCode string `json:"edb_code" form:"edb_code" description:"指标编码"`
}

type BridgeZhongJiIndexListParams struct {
	Page     int `json:"page" form:"page" description:"页码"`
	PageSize int `json:"page_size" form:"page_size" description:"每页指标个数，每页不能超过500条，超过会固定为500"`
}

type BaseFromSmmDataList struct {
	Data      []*BaseFromSmmData
	IndexCode string
}

type UpdateRule struct {
	RuleDesc    string         `json:"rule_desc"`
	Notice      string         `json:"notice"`
	ReleaseTime string         `json:"release_time"`
	RuleInfo    UpdateRuleInfo `json:"rule_info"`
}

type UpdateRuleInfo struct {
	UpdCal       string `json:"upd_cal"`
	UpdCalUnit   string `json:"upd_cal_unit"`
	PeriodOffset int    `json:"period_offset"`
	UpdCount     int    `json:"upd_count"`
}

type DataItem struct {
	QuotaID     string     `json:"quota_id"`
	QuotaName   string     `json:"quota_name"`
	Mark        string     `json:"mark"`
	Unit        string     `json:"unit"`
	ValueType   string     `json:"value_type"`
	Source      string     `json:"source"`
	ListOrder   int        `json:"list_order"`
	DataStart   string     `json:"data_start"`
	DataEnd     string     `json:"data_end"`
	Frequency   string     `json:"frequency"`
	Precision   int        `json:"precision"`
	TypeCode    string     `json:"type_code"`
	TypeName    string     `json:"type_name"`
	TypeCodeAll string     `json:"type_code_all"`
	TypeAll     string     `json:"type_all"`
	Tags        string     `json:"tags"`
	AuthStart   string     `json:"auth_start"`
	AuthFinish  string     `json:"auth_finish"`
	AuthLang    string     `json:"auth_lang"`
	AuthModule  string     `json:"auth_module"`
	DataDur     string     `json:"data_dur"`
	Spec        string     `json:"spec"`
	Area        string     `json:"area"`
	DataState   string     `json:"data_state"`
	UpdateRule  UpdateRule `json:"update_rule"`
}

type ListData struct {
	Total       int        `json:"total"`
	CurrentPage int        `json:"current_page"`
	PageSize    int        `json:"page_size"`
	PageCount   int        `json:"page_count"`
	Data        []DataItem `json:"data"`
}

type SmmIndexListResponse struct {
	Code int      `json:"code"`
	Msg  string   `json:"msg"`
	Data ListData `json:"data"`
}

type SmmListResp struct {
	Code int                  `json:"code"`
	Msg  string               `json:"msg"`
	Data SmmIndexListResponse `json:"data"`
}

func AddBaseFromSmmIndex(list []*BaseFromSmmIndex) (lastId int64, err error) {
	//o := orm.NewOrm()
	//_, err = o.InsertMulti(len(list), list)
	err = global.DEFAULT_DB.CreateInBatches(list, len(list)).Error
	return
}

// BridgeZhongJiIndexLatestDataParams 桥接服务-获取中基更新指标数据入参
type BridgeZhongJiIndexLatestDataParams struct {
	EdbCode  string `json:"edb_code" form:"edb_code" description:"指标编码"`
	LastTime int64  `json:"last_time" form:"last_time" description:"上次更新时间戳（秒）"`
}

func GetBaseFromSmmIndex() (list []*BaseFromSmmIndex, err error) {
	//o := orm.NewOrm()
	sql := ` SELECT * FROM base_from_smm_index`
	//_, err = o.Raw(sql).QueryRows(&list)
	err = global.DEFAULT_DB.Raw(sql).Find(&list).Error
	return
}

func ModifyBaseFromSmmIndex(item *BaseFromSmmIndex) (err error) {
	//o := orm.NewOrm()
	sql := ` UPDATE base_from_smm_index SET end_date = ?, modify_time=NOW(), data_state= ? `
	//_, err = o.Raw(sql, item.EndDate, item.DataState).Exec()
	err = global.DEFAULT_DB.Exec(sql, item.EndDate, item.DataState).Error
	return
}

func (m *BaseFromSmmIndex) UpdateCols(cols []string) (err error) {
	//o := orm.NewOrm()
	//_, err = o.Update(m, cols...)
	err = global.DEFAULT_DB.Model(&m).Select(cols).Updates(&m).Error
	return
}

func ModifyBaseFromSmmIndexDate(item *BaseFromSmmIndex) (err error) {
	//o := orm.NewOrm()
	sql := ` UPDATE base_from_smm_index SET end_date = ?, modify_time=NOW(), data_state= ? WHERE base_from_smm_index_id=?`
	//_, err = o.Raw(sql, item.EndDate, item.DataState, item.BaseFromSmmIndexId).Exec()
	err = global.DEFAULT_DB.Exec(sql, item.EndDate, item.DataState, item.BaseFromSmmIndexId).Error
	return
}

type SmmLatestDataResponse struct {
	Code int           `json:"code"`
	Msg  string        `json:"msg"`
	Data SmmLatestResp `json:"data"`
}

type SmmLatestResp struct {
	Code int           `json:"code"`
	Msg  string        `json:"msg"`
	Data SmmLatestData `json:"data"`
}

type SmmLatestData struct {
	DataLen  int     `json:"data_len"`
	DataList []Datum `json:"data_list"`
}

type Datum struct {
	QuotaID string `json:"quota_id"`
	Date    string `json:"date"`
	Value   string `json:"value"`
	Mark    string `json:"mark"`
	Create  string `json:"create"`
	Update  string `json:"update"`
}

// RefreshEdbDataFromSmmToEdb 刷新有色指标数据
func RefreshEdbDataFromSmmToEdb(edbInfoId int, edbCode, startDate string, smmDataList []*BaseFromSmmData) (err error) {
	source := utils.DATA_SOURCE_YS
	subSource := utils.DATA_SUB_SOURCE_EDB

	//o := orm.NewOrm()
	if err != nil {
		return
	}
	edbInfoIdStr := strconv.Itoa(edbInfoId)
	//计算数据
	var condition string
	var pars []interface{}

	if edbCode != "" {
		condition += " AND index_code=? "
		pars = append(pars, edbCode)
	}

	if startDate != "" {
		condition += " AND data_time>=? "
		pars = append(pars, startDate)
	}

	// 真实数据的最大日期  ， 插入规则配置的日期
	var realDataMaxDate, edbDataInsertConfigDate time.Time
	var edbDataInsertConfig *EdbDataInsertConfig
	var isFindConfigDateRealData bool //是否找到配置日期的实际数据的值
	{
		edbDataInsertConfig, err = GetEdbDataInsertConfigByEdbId(edbInfoId)
		if err != nil && !utils.IsErrNoRow(err) {
			return
		}
		if edbDataInsertConfig != nil {
			edbDataInsertConfigDate = edbDataInsertConfig.Date
		}
	}

	var existCondition string
	var existPars []interface{}

	existCondition += " AND edb_info_id=? "
	existPars = append(existPars, edbInfoId)
	if startDate != "" {
		existCondition += " AND data_time>=? "
		existPars = append(existPars, startDate)
	}

	existList, err := GetEdbDataByCondition(source, subSource, existCondition, existPars)
	if err != nil {
		return err
	}
	existMap := make(map[string]*EdbInfoSearchData)
	for _, v := range existList {
		existMap[v.DataTime] = v
	}
	addSql := ` INSERT INTO edb_data_ys(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
	var isAdd bool
	for _, v := range smmDataList {
		item := v
		eDate := item.DataTime
		dataTime, err := time.ParseInLocation(utils.FormatDate, eDate, time.Local)
		if err != nil {
			return err
		}
		if findItem, ok := existMap[v.DataTime]; !ok {
			sValue := item.Value

			timestamp := dataTime.UnixNano() / 1e6
			timeStr := fmt.Sprintf("%d", timestamp)

			addSql += GetAddSql(edbInfoIdStr, edbCode, eDate, timeStr, sValue)
			isAdd = true
		} else {
			if findItem != nil && utils.SubFloatToString(findItem.Value, 30) != item.Value {
				err = ModifyEdbDataById(source, subSource, findItem.EdbDataId, item.Value)
				if err != nil {
					return err
				}
			}
		}

		// 下面代码主要目的是处理掉手动插入的数据判断
		{
			if realDataMaxDate.IsZero() || dataTime.After(realDataMaxDate) {
				realDataMaxDate = dataTime
			}
			if edbDataInsertConfigDate.IsZero() || dataTime.Equal(edbDataInsertConfigDate) {
				isFindConfigDateRealData = true
			}
		}
	}

	// 处理手工数据补充的配置
	HandleConfigInsertEdbData(realDataMaxDate, edbDataInsertConfig, edbInfoId, source, subSource, existMap, isFindConfigDateRealData)

	if isAdd {
		addSql = strings.TrimRight(addSql, ",")
		//_, err = o.Raw(addSql).Exec()
		err = global.DEFAULT_DB.Exec(addSql).Error
		if err != nil {
			fmt.Println("RefreshEdbDataFromSmm add Err", err.Error())
			return
		}
	}
	return
}

type BaseFromSmmRecord struct {
	BaseFromSmmRecordId int64 `gorm:"column:base_from_smm_record_id;primaryKey"`
	BaseFromSmmIndexId  int64
	OldIndexName        string    `description:"原始名称"`
	NewIndexName        string    `description:"新的名称"`
	CreateTime          time.Time `description:"记录创建时间"`
	Timestamp           int64     `description:"记录创建时间戳"`
}

func AddBaseFromSmmRecord(item *BaseFromSmmRecord) (err error) {
	//o := orm.NewOrm()
	//_, err = o.Insert(item)
	err = global.DEFAULT_DB.Create(&item).Error
	return
}