change gorm

models/base_from_cffex.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -58,6 +59,13 @@ type BaseFromCffexDataSimple struct {
 	SoldValue string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromCffexDataSimple) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetCffexDataByTradeCode(condition string, pars []interface{}) (item []*BaseFromCffexDataSimple, err error) {
 	sql := ` SELECT * FROM base_from_trade_cffex_index WHERE 1=1 `
 	//o := orm.NewOrm()

models/base_from_coal.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -25,6 +26,15 @@ type BaseFromCoalmineIndex struct {
 	ModifyTime                     string `description:"修改时间"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromCoalmineIndex) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+	m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
+	m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
+
+	return
+}
+
 func GetBaseFromCoalIndexByCode(suffix, indexCode string) (items []*BaseFromCoalmineIndex, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_coalmine_%s WHERE index_code=? `

models/base_from_com_trade.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -35,6 +36,13 @@ type ComTradeData struct {
 	DataTime string  `orm:"column(data_time)" description:"日期"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *ComTradeData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetComTradeDataByTradeCode(tradeCode, startDate string) (items []*ComTradeData, err error) {
 	//o := orm.NewOrm()
 	pars := []interface{}{tradeCode}

models/base_from_dl.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -57,6 +58,13 @@ type BaseFromDlDataSimple struct {
 	SoldValue string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromDlDataSimple) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetDlDataByTradeCode(condition string, pars []interface{}) (item []*BaseFromDlDataSimple, err error) {
 	sql := ` SELECT * FROM base_from_trade_dalian_index WHERE 1=1 `
 	//o := orm.NewOrm()

models/base_from_gie.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -74,6 +75,13 @@ type BaseFromTradeEicIndexV2 struct {
 	ModifyTime             time.Time
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromTradeEicIndexV2) AfterFind(db *gorm.DB) (err error) {
+	m.GasDayStart = utils.GormDateStrToDateStr(m.GasDayStart)
+
+	return
+}
+
 func GetBaseFromEicDataAllByIndexCode(indexCode, suffix string) (list []*BaseFromTradeEicIndexV2, err error) {
 	//o := orm.NewOrm()
 	var name string

models/base_from_google_travel.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -27,6 +28,13 @@ type BaseFromChangesVisitorsCovid struct {
 	ModifyTime          string `description:"修改时间"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromChangesVisitorsCovid) AfterFind(db *gorm.DB) (err error) {
+	m.Day = utils.GormDateStrToDateStr(m.Day)
+
+	return
+}
+
 func GetBaseFromChangesVisitorsCovidDataAllByIndexCode(indexCode string) (list []*BaseFromChangesVisitorsCovid, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_changes_visitors_covid WHERE edb_code=? `

models/base_from_gz.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -35,6 +36,13 @@ type BaseFromTradeGuangzhouData struct {
 	ModifyTime                    time.Time `description:"修改日期"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromTradeGuangzhouData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetBaseFromGuangzhouDataByIndexCode(indexCode string) (items []*BaseFromTradeGuangzhouData, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_trade_guangzhou_data WHERE index_code=? `

models/base_from_lz.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -16,6 +17,13 @@ type lzSurveyData struct {
 	InputValue string `orm:"column(input_value)" description:"值"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *lzSurveyData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetLzSurveyDataFromLz(condition string, pars []interface{}) (item []*lzSurveyData, err error) {
 	sql := ` SELECT  a.* FROM longzhong_survey_data AS a
 				INNER JOIN longzhong_survey_product AS b ON a.survey_product_id=b.survey_product_id

models/base_from_manual.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"github.com/shopspring/decimal"
 	"go.mongodb.org/mongo-driver/bson"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -22,6 +23,13 @@ type ManualEdbdata struct {
 	ModifyTime time.Time `orm:"column(modify_time)" description:"修改时间"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *ManualEdbdata) AfterFind(db *gorm.DB) (err error) {
+	m.Dt = utils.GormDateStrToDateStr(m.Dt)
+
+	return
+}
+
 func GetEdbdataManualByCondition(condition string, pars []interface{}) (item []*ManualEdbdata, err error) {
 	sql := ` SELECT  * FROM edbdata WHERE 1=1  `
 	if condition != "" {

models/base_from_mysteel.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -16,6 +17,13 @@ type GlData struct {
 	DataTime   string  `orm:"column(DATA_DATE)" description:"值"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *GlData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetGlDataByCondition(condition string, pars []interface{}) (item []*GlData, err error) {
 	condition += " AND IS_DELETE=0 "
 	sql1 := ` SELECT * FROM mb_index_main_data WHERE 1=1 AND DATA_VALUE is not null `

models/base_from_mysteel_chemical.go

@@ -17,6 +17,13 @@ type MysteelChemicalData struct {
 	DataTime   string  `orm:"column(data_time)" description:"日期"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *MysteelChemicalData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetMysteelChemicalDataByCondition(condition string, pars []interface{}) (item []*MysteelChemicalData, err error) {
 	sql1 := ` SELECT * FROM base_from_mysteel_chemical_data WHERE 1=1  `
 	//o := orm.NewOrm()

models/base_from_national_statistics.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -21,6 +22,13 @@ type BaseFromNationalStatisticsData struct {
 	ModifyTime                        time.Time
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromNationalStatisticsData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 // GetBaseFromNationalStatisticsDataByCondition 获取指标值
 func GetBaseFromNationalStatisticsDataByCondition(condition string, pars []interface{}) (list []*BaseFromNationalStatisticsData, err error) {
 	//o := orm.NewOrm()

models/base_from_sci99.go

@@ -39,6 +39,12 @@ type BaseFromSci99DataItem struct {
 	ModifyTime         time.Time // 修改时间
 }
 
+func (e *BaseFromSci99DataItem) AfterFind(db *gorm.DB) (err error) {
+	e.DataTime = utils.GormDateStrToDateStr(e.DataTime)
+
+	return
+}
+
 // BaseFromSci99Data 代表卓创资讯-原始指标数据表的结构
 type BaseFromSci99Data struct {
 	BaseFromSciDataId int `gorm:"column:base_from_sci_data_id;primaryKey"` // 主键，自动递增

models/base_from_sh.go

@@ -49,6 +49,13 @@ type BaseFromShDataSimple struct {
 	SoldValue string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromShDataSimple) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetBaseFromShDataAllByIndexCode(indexCode, suffix string) (list []*BaseFromTradeShIndex, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_trade_shanghai_index WHERE %s_code=? `

models/base_from_shfe.go

@@ -37,6 +37,13 @@ type BaseFromTradeShfeIndex struct {
 	DataTime      string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromTradeShfeIndex) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetBaseFromShfeDataAllByIndexCode(indexCode, suffix string) (list []*BaseFromTradeShfeIndex, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_trade_ine_index WHERE %s_code=? `

models/base_from_stock_plant.go

@@ -5,6 +5,7 @@ import (
 	"eta/eta_index_lib/models/supply_analysis"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -19,6 +20,13 @@ type StockPlantEdbdata struct {
 	ModifyTime time.Time `orm:"column(modify_time)" description:"修改时间"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *StockPlantEdbdata) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 func GetStockPlantEdbDataByCondition(condition string, pars []interface{}) (item []*StockPlantEdbdata, err error) {
 	sql := ` SELECT  * FROM base_from_stock_plant_data WHERE 1=1  `
 	if condition != "" {

models/base_from_usda_fas.go

@@ -249,6 +249,14 @@ type BaseFromUsdaFasIndexList struct {
 	ModifyTime   string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromUsdaFasIndexList) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
 func (y *BaseFromUsdaFasData) GetByIndexCode(indexCode string) (list []*BaseFromUsdaFasData, err error) {
 	//o := orm.NewOrm()
 	sql := ` SELECT * FROM base_from_usda_fas_data WHERE index_code=? `

models/base_from_yongyi.go

@@ -246,6 +246,16 @@ type BaseFromYongyiIndexList struct {
 	ModifyTime    string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromYongyiIndexList) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+	m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
+	m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
+
+	return
+}
+
 func (y *BaseFromYongyiData) GetByIndexCode(indexCode string) (list []*BaseFromYongyiData, err error) {
 	//o := orm.NewOrm()
 	sql := ` SELECT * FROM base_from_yongyi_data WHERE index_code=? `

models/base_from_zz.go

@@ -4,6 +4,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -36,6 +37,13 @@ type BaseFromTradeZhengzhouIndex struct {
 	DataTime      string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromTradeZhengzhouIndex) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 type BaseFromZzDataSimple struct {
 	Id int `gorm:"column:base_from_trade_zhengzhou_index_id;primaryKey"`
 	//Id        int `orm:"column(base_from_trade_zhengzhou_index_id);pk"`
@@ -48,6 +56,12 @@ type BaseFromZzDataSimple struct {
 	SoldValue string
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *BaseFromZzDataSimple) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
 func GetBaseFromZhengzhouDataAllByIndexCode(indexCode, suffix string) (list []*BaseFromTradeZhengzhouIndex, err error) {
 	//o := orm.NewOrm()
 	sql := `SELECT * FROM base_from_trade_zhengzhou_index WHERE %s_code=? `

models/calculate_residual_analysis_config.go

@@ -2,6 +2,8 @@ package models
 
 import (
 	"eta/eta_index_lib/global"
+	"eta/eta_index_lib/utils"
+	"gorm.io/gorm"
 	"time"
 )
 
@@ -32,6 +34,14 @@ type ResidualAnalysisConfig struct {
 	ContrastIndexMax float64 `description:"对比指标上限"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *ResidualAnalysisConfig) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
 // GetResidualAnalysisConfigById 根据配置id查询配置信息
 func GetResidualAnalysisConfigById(edbInfoId int) (residualAnalysisConfig CalculateResidualAnalysisConfig, err error) {
 	sql := `SELECT t2.* FROM calculate_residual_analysis_config_mapping t1 

models/edb_data_base.go

@@ -34,14 +34,8 @@ type EdbData struct {
 
 // AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
 func (m *EdbData) AfterFind(db *gorm.DB) (err error) {
-	if m.DataTime == "" {
-		return
-	}
-	minDateTmp, err := time.ParseInLocation(utils.FormatDateWallWithLoc, m.DataTime, time.Local)
-	if err != nil {
-		return
-	}
-	m.DataTime = minDateTmp.Format(utils.FormatDate)
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
 	return
 }
 

models/edb_data_residual_analysis.go

@@ -5,6 +5,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"math"
 	"sort"
 	"strconv"
@@ -22,6 +23,13 @@ type edbDataResidualAnalysis struct {
 	DataTimestamp int64     `gorm:"column:data_timestamp;type:bigint(20);comment:数据日期时间戳;default:0;"` // 数据日期时间戳
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *edbDataResidualAnalysis) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 // ConvertTimeStr
 // @Description: 转成需要输出的格式
 // @receiver m

models/edb_data_rzd.go

@@ -5,6 +5,7 @@ import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
 	"fmt"
+	"gorm.io/gorm"
 	"strconv"
 	"strings"
 	"time"
@@ -21,6 +22,15 @@ type EdbDataRzd struct {
 	DataTimestamp uint64  `gorm:"column:data_timestamp;type:bigint(20) UNSIGNED;comment:数据日期时间戳;not null;default:0;"` // 数据日期时间戳
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *EdbDataRzd) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+	m.CreateTime = utils.GormDateStrToDateTimeStr(m.DataTime)
+	m.CreateTime = utils.GormDateStrToDateTimeStr(m.DataTime)
+
+	return
+}
+
 // ConvertTimeStr
 // @Description: 转成需要输出的格式
 // @receiver m

models/edb_info.go

@@ -69,11 +69,6 @@ type EdbInfo struct {
 	EndDateType      int       `description:"预测指标截止日期类型：0：未来日期，1未来期数"`
 }
 
-func (e *EdbInfo) Add() (err error) {
-	err = global.DEFAULT_DB.Create(e).Error
-	return
-}
-
 // AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
 func (m *EdbInfo) AfterFind(db *gorm.DB) (err error) {
 	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
@@ -97,6 +92,11 @@ func (e *EdbInfo) ConvertDate() {
 	return
 }
 
+func (e *EdbInfo) Add() (err error) {
+	err = global.DEFAULT_DB.Create(e).Error
+	return
+}
+
 // AddEdbInfo 添加指标
 func AddEdbInfo(item *EdbInfo) (lastId int64, err error) {
 	//o := orm.NewOrm()
@@ -168,6 +168,17 @@ type EdbInfoList struct {
 	//IsEnEdb         bool                   `description:"是否展示英文标识"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (e *EdbInfoList) AfterFind(db *gorm.DB) (err error) {
+	e.CreateTime = utils.GormDateStrToDateTimeStr(e.CreateTime)
+	e.ModifyTime = utils.GormDateStrToDateTimeStr(e.ModifyTime)
+	e.StartDate = utils.GormDateStrToDateStr(e.StartDate)
+	e.EndDate = utils.GormDateStrToDateStr(e.EndDate)
+	e.LatestDate = utils.GormDateStrToDateStr(e.LatestDate)
+
+	return
+}
+
 // ConvertDate
 // @Description: 格式化EdbInfoList的日期
 // @receiver e
@@ -531,22 +542,9 @@ type EdbInfoMaxAndMinInfo struct {
 
 // AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
 func (m *EdbInfoMaxAndMinInfo) AfterFind(db *gorm.DB) (err error) {
-	if m.MinDate != "" {
-		minDateTmp, e := time.ParseInLocation(utils.FormatDateWallWithLoc, m.MinDate, time.Local)
-		if e != nil {
-			err = e
-			return
-		}
-		m.MinDate = minDateTmp.Format(utils.FormatDate)
-	}
-	if m.MaxDate != "" {
-		maxDateTmp, e := time.ParseInLocation(utils.FormatDateWallWithLoc, m.MaxDate, time.Local)
-		if e != nil {
-			err = e
-			return
-		}
-		m.MaxDate = maxDateTmp.Format(utils.FormatDate)
-	}
+	m.MinDate = utils.GormDateStrToDateStr(m.MinDate)
+	m.MaxDate = utils.GormDateStrToDateStr(m.MaxDate)
+
 	return
 }
 
@@ -584,14 +582,8 @@ type EdbIndoDataUpdateTime struct {
 
 // AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
 func (m *EdbIndoDataUpdateTime) AfterFind(db *gorm.DB) (err error) {
-	if m.MinDate == "" {
-		return
-	}
-	minDateTmp, err := time.ParseInLocation(utils.FormatDateWallWithLoc, m.MinDate, time.Local)
-	if err != nil {
-		return
-	}
-	m.MinDate = minDateTmp.Format(utils.FormatDate)
+	m.MinDate = utils.GormDateStrToDateStr(m.MinDate)
+
 	return
 }
 
@@ -765,6 +757,13 @@ type EdbInfoSearchDataV1 struct {
 	Value     string `description:"数据"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *EdbInfoSearchDataV1) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 // GetEdbDataListAllV1ByTo 通过事务链接获取数据列表
 func GetEdbDataListAllV1ByTo(to *gorm.DB, condition string, pars []interface{}, source, subSource, order int) (items []*EdbInfoSearchDataV1, err error) {
 	sql := ``
@@ -1505,14 +1504,23 @@ type EdbInfoDetailResp struct {
 	UniqueCode    string `description:"指标唯一编码"`
 	CreateTime    time.Time
 	ModifyTime    time.Time
-	MinValue      float64 `description:"指标最小值"`
-	MaxValue      float64 `description:"指标最大值"`
-	EdbNameEn     string  `description:"英文指标名称"`
-	UnitEn        string  `description:"英文单位"`
-	LatestDate    string  `description:"数据最新日期"`
-	LatestValue   float64 `description:"数据最新值"`
-	ChartImage    string  `description:"图表图片"`
-	DataList      []*EdbInfoSearchData
+	MinValue      float64              `description:"指标最小值"`
+	MaxValue      float64              `description:"指标最大值"`
+	EdbNameEn     string               `description:"英文指标名称"`
+	UnitEn        string               `description:"英文单位"`
+	LatestDate    string               `description:"数据最新日期"`
+	LatestValue   float64              `description:"数据最新值"`
+	ChartImage    string               `description:"图表图片"`
+	DataList      []*EdbInfoSearchData `gorm:"-"`
+}
+
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *EdbInfoDetailResp) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+	m.LatestDate = utils.GormDateStrToDateStr(m.LatestDate)
+
+	return
 }
 
 type AddEdbInfoParams struct {

models/edb_info_calculate_mapping.go

@@ -3,6 +3,7 @@ package models
 import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
+	"gorm.io/gorm"
 	"time"
 )
 
@@ -86,12 +87,32 @@ type EdbInfoCalculateMappingView struct {
 	MoveFrequency             string    `description:"移动频度"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *EdbInfoCalculateMappingView) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
+func (m *EdbInfoCalculateMappingView) ConvDateTimeStr() {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
 // GetEdbInfoCalculateMappingDetail 获取单条关联指标
 func GetEdbInfoCalculateMappingDetail(edbInfoId int) (item *EdbInfoCalculateMappingView, err error) {
 	sql := ` SELECT a.*,b.start_date,b.end_date,b.calculate_formula,b.move_type,b.move_frequency FROM edb_info_calculate_mapping AS a
 			INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			WHERE a.edb_info_id=? `
 	err = global.DEFAULT_DB.Raw(sql, edbInfoId).First(&item).Error
+	if err != nil {
+		return
+	}
+	item.ConvDateTimeStr()
+
 	return
 }
 
@@ -114,13 +135,28 @@ type EdbInfoCalculateDetail struct {
 	EdbType            int       `description:"指标类型:1:基础指标,2:计算指标"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *EdbInfoCalculateDetail) AfterFind(db *gorm.DB) (err error) {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
+func (m *EdbInfoCalculateDetail) ConvDateTimeStr() {
+	m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
 // GetEdbInfoCalculateDetailList 获取关联指标列表
 func GetEdbInfoCalculateDetailList(edbInfoId int) (list []*EdbInfoCalculateDetail, err error) {
 	sql := ` SELECT a.*,b.start_date,b.end_date,b.edb_type FROM edb_info_calculate_mapping AS a
 			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
 			WHERE a.edb_info_id=? ORDER BY sort ASC `
 
-	err = global.DEFAULT_DB.Raw(sql, edbInfoId).Scan(&list).Error
+	err = global.DEFAULT_DB.Raw(sql, edbInfoId).Find(&list).Error
 
 	return
 }
@@ -138,7 +174,7 @@ func GetEdbInfoCalculateMappingListByEdbInfoIds(edbInfoIds []int) (items []*EdbI
 	sql := ` SELECT a.*,b.edb_type as from_edb_type,b.edb_info_type as from_edb_info_type, b.unique_code AS from_unique_code, b.classify_id AS from_classify_id,b.no_update FROM edb_info_calculate_mapping AS a
 			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
 			WHERE a.edb_info_id in (` + utils.GetOrmInReplace(len(edbInfoIds)) + `) `
-	err = global.DEFAULT_DB.Raw(sql, edbInfoIds).Scan(&items).Error
+	err = global.DEFAULT_DB.Raw(sql, edbInfoIds).Find(&items).Error
 
 	return
 }
@@ -148,7 +184,7 @@ func GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId int) (items []*EdbInfoC
 	sql := ` SELECT a.*,b.edb_type as from_edb_type,b.edb_info_type as from_edb_info_type, b.unique_code AS from_unique_code, b.classify_id AS from_classify_id,b.no_update FROM edb_info_calculate_mapping AS a
 			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
 			WHERE a.edb_info_id=? `
-	err = global.DEFAULT_DB.Raw(sql, edbInfoId).Scan(&items).Error
+	err = global.DEFAULT_DB.Raw(sql, edbInfoId).Find(&items).Error
 
 	return
 }

models/predict_edb.go

@@ -15,19 +15,26 @@ import (
 
 // CalculateRule 预测指标 规则 计算
 type CalculateRule struct {
-	EdbInfoId                  int `description:"指标id"`
-	ConfigId                   int `description:"配置id"`
-	TrendsCalculateMappingList []*PredictEdbConfCalculateMapping
-	EdbInfoList                []*EdbInfo
+	EdbInfoId                  int                               `description:"指标id"`
+	ConfigId                   int                               `description:"配置id"`
+	TrendsCalculateMappingList []*PredictEdbConfCalculateMapping `gorm:"-"`
+	EdbInfoList                []*EdbInfo                        `gorm:"-"`
 	EdbInfoIdBytes             []string
 	Formula                    string
 	RuleType                   int              `description:"预测规则，1：最新，2：固定值，3：同比，4：同差，5：环比，6：环差，7：N期移动均值，8：N期段线性外推值，9：动态环差"`
 	EndDate                    string           `description:"截止日期"`
-	EdbInfoIdArr               []EdbInfoFromTag `description:"指标信息"`
+	EdbInfoIdArr               []EdbInfoFromTag `description:"指标信息" gorm:"-"`
 	EmptyType                  int              `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
 	MaxEmptyType               int              `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *CalculateRule) AfterFind(db *gorm.DB) (err error) {
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
+}
+
 // RefreshCalculateByRuleBy9 刷新计算
 func RefreshCalculateByRuleBy9(rule CalculateRule) (resultDataList []*EdbInfoSearchData, err error) {
 	to := global.DEFAULT_DB.Begin()

models/predict_edb_conf.go

@@ -3,6 +3,7 @@ package models
 import (
 	"eta/eta_index_lib/global"
 	"eta/eta_index_lib/utils"
+	"gorm.io/gorm"
 	"time"
 )
 
@@ -29,7 +30,14 @@ type RuleConfig struct {
 	MaxEmptyType int              `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
 	EndDate      string           `description:"截止日期"`
 	EndNum       int              `description:"截止期数"`
-	EdbInfoIdArr []EdbInfoFromTag `description:"指标信息"`
+	EdbInfoIdArr []EdbInfoFromTag `description:"指标信息" gorm:"-"`
+}
+
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *RuleConfig) AfterFind(db *gorm.DB) (err error) {
+	m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
+
+	return
 }
 
 // EditPredictEdbInfoReq 编辑预测指标请求

models/predict_edb_rule_data.go

@@ -19,6 +19,13 @@ type PredictEdbRuleData struct {
 	DataTimestamp        int64
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *PredictEdbRuleData) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 // PredictEdbRuleDataItem 预测指标，动态规则的计算数据
 type PredictEdbRuleDataItem struct {
 	PredictEdbRuleDataId int `gorm:"primaryKey;autoIncrement;column:predict_edb_rule_data_id"`
@@ -31,6 +38,13 @@ type PredictEdbRuleDataItem struct {
 	DataTimestamp        int64
 }
 
+// AfterFind 在该模型上设置钩子函数，把日期转成正确的string，所以查询函数只能用Find函数，First或者Scan是不会触发该函数的来获取数据
+func (m *PredictEdbRuleDataItem) AfterFind(db *gorm.DB) (err error) {
+	m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
+
+	return
+}
+
 // GetPredictEdbRuleDataItemList 根据基础预测指标id集合 获取 所有的普通指标列表数据
 func GetPredictEdbRuleDataItemList(edbInfoId, configId int, startDate, endDate string) (list []*PredictEdbRuleDataItem, err error) {
 	var pars []interface{}

utils/common.go

@@ -1752,6 +1752,10 @@ func IsErrNoRow(err error) bool {
 // @param originalString
 // @return formatStr
 func GormDateStrToDateTimeStr(originalString string) (formatStr string) {
+	if originalString == `` {
+		return
+	}
+
 	formatStr = originalString
 	if !strings.Contains(originalString, "T") {
 		return
@@ -1775,6 +1779,10 @@ func GormDateStrToDateTimeStr(originalString string) (formatStr string) {
 // @param originalString
 // @return formatStr
 func GormDateStrToDateStr(originalString string) (formatStr string) {
+	if originalString == `` {
+		return
+	}
+
 	formatStr = originalString
 	if !strings.Contains(originalString, "T") {
 		return