去掉utils.NeedDateOrTimeFormat

models/data_manage/baiinfo_data.go

@@ -51,27 +51,12 @@ type BaiinfoIndex struct {
 }
 
 func (obj *BaiinfoIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-
-		if obj.ApiStartTime != "" {
 			obj.ApiStartTime = utils.GormDateStrToDateTimeStr(obj.ApiStartTime)
-		}
-		if obj.ApiUpdateTime != "" {
 			obj.ApiUpdateTime = utils.GormDateStrToDateTimeStr(obj.ApiUpdateTime)
-		}
-		if obj.StartTime != "" {
 			obj.StartTime = utils.GormDateStrToDateStr(obj.StartTime)
-		}
-		if obj.FinishTime != "" {
 			obj.FinishTime = utils.GormDateStrToDateStr(obj.FinishTime)
-		}
-	}
 	return
 }
 func GetBaiinfoIndex(condition string, pars []interface{}) (items []*BaiinfoIndex, err error) {
@@ -143,12 +128,7 @@ type BaiinfoIndexData struct {
 }
 
 func (obj *BaiinfoIndexData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
-
 	return
 }
 func GetBaiinfoIndexData(indexCode string, startSize, pageSize int) (items []*BaiinfoIndexData, err error) {

models/data_manage/base_from_business_index.go

@@ -174,26 +174,12 @@ type BaseFromBusinessIndexItem struct {
 }
 
 func (obj *BaseFromBusinessIndexItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.DataUpdateTime != "" {
 			obj.DataUpdateTime = utils.GormDateStrToDateTimeStr(obj.DataUpdateTime)
-		}
-		if obj.BaseModifyTime != "" {
 			obj.BaseModifyTime = utils.GormDateStrToDateTimeStr(obj.BaseModifyTime)
-		}
-		if obj.StartDate != "" {
 			obj.StartDate = utils.GormDateStrToDateStr(obj.StartDate)
-		}
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 func (m *BaseFromBusinessIndex) GetPageItemsByCondition(condition string, pars []interface{}, orderRule string, startSize, pageSize int) (items []*BaseFromBusinessIndexItem, err error) {

models/data_manage/base_from_ccf.go

@@ -44,11 +44,9 @@ func (b *BaseFromCCFIndexList) TableName() string {
 }
 
 func (b *BaseFromCCFIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
 		b.CreateTime = utils.GormDateStrToDateTimeStr(b.CreateTime)
 		b.EndDate = utils.GormDateStrToDateStr(b.EndDate)
-	}
 	return
 }
 
@@ -132,17 +130,9 @@ type BaseFromCCFData struct {
 }
 
 func (baseFromCCFData *BaseFromCCFData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCCFData.ModifyTime != "" {
 			baseFromCCFData.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCCFData.ModifyTime)
-		}
-		if baseFromCCFData.CreateTime != "" {
 			baseFromCCFData.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCCFData.CreateTime)
-		}
-		if baseFromCCFData.DataTime != "" {
 			baseFromCCFData.DataTime = utils.GormDateStrToDateStr(baseFromCCFData.DataTime)
-		}
-	}
 	return
 }
 
@@ -236,11 +226,9 @@ func GetCCFIndexDataByDataTime(indexCodes []string, startDate, endDate string) (
 func GetCCFIndexDataTimePageByCodes(indexCodes []string, startSize, pageSize int) (dataTimes []string, err error) {
 	sql := ` SELECT data_time FROM base_from_ccf_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY data_time ORDER BY data_time DESC LIMIT ?,? `
 	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes, startSize, pageSize).Find(&dataTimes).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range dataTimes {
 			dataTimes[i] = utils.GormDateStrToDateStr(dataTimes[i])
 		}
-	}
 	return
 }
 
@@ -267,11 +255,9 @@ func GetCCFDataDataTimeByIndexId(indexIdList []int) (items []string, err error)
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 

models/data_manage/base_from_changes_visitors_covid.go

@@ -15,9 +15,7 @@ func GetVisitorsCovidLastDate() (last_date string, err error) {
 	} else {
 		last_date = lastDateNull.String
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		last_date = utils.GormDateStrToDateStr(last_date)
-	}
 	return
 }
 

models/data_manage/base_from_clarksons_data.go

@@ -20,9 +20,7 @@ type BaseFromClarksonsData struct {
 }
 
 func (baseFromClarksonsData *BaseFromClarksonsData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		baseFromClarksonsData.DataTime = utils.GormDateStrToDateStr(baseFromClarksonsData.DataTime)
-	}
 	return
 }
 
@@ -40,11 +38,9 @@ func GetClarksonsDataDataTimeByIndexId(indexIdList []int) (items []string, err e
 	}
 	sql := ` SELECT DISTINCT data_time FROM base_from_clarksons_data WHERE base_from_clarksons_index_id IN (` + utils.GetOrmInReplace(len(indexIdList)) + `) ORDER BY data_time DESC`
 	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexIdList).Find(&items).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i, item := range items {
 			items[i] = utils.GormDateStrToDateStr(item)
 		}
-	}
 	return
 }
 

models/data_manage/base_from_clarksons_index.go

@@ -25,14 +25,8 @@ type BaseFromClarksonsIndex struct {
 }
 
 func (baseFromClarksonsIndex *BaseFromClarksonsIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromClarksonsIndex.StartDate != "" {
 			baseFromClarksonsIndex.StartDate = utils.GormDateStrToDateStr(baseFromClarksonsIndex.StartDate)
-		}
-		if baseFromClarksonsIndex.EndDate != "" {
 			baseFromClarksonsIndex.EndDate = utils.GormDateStrToDateStr(baseFromClarksonsIndex.EndDate)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_eia_stero.go

@@ -86,17 +86,9 @@ type BaseFromEiaSteoDataItem struct {
 }
 
 func (obj *BaseFromEiaSteoDataItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_fenwei.go

@@ -37,10 +37,8 @@ type BaseFromFenweiIndexList struct {
 }
 
 func (b *BaseFromFenweiIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.CreateTime = utils.GormDateStrToDateTimeStr(b.CreateTime)
 		b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
-	}
 	return
 }
 type FenweiSingleDataResp struct {
@@ -157,11 +155,9 @@ type BaseFromFenweiData struct {
 }
 
 func (b *BaseFromFenweiData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.CreateTime = utils.GormDateStrToDateTimeStr(b.CreateTime)
 		b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
 		b.DataTime = utils.GormDateStrToDateStr(b.DataTime)
-	}
 	return
 }
 type BaseFromFenweiIndexSearchItem struct {
@@ -264,11 +260,9 @@ func GetFenWeiDataListByIndexCodes(IndexCodes string) (items []string, err error
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 

models/data_manage/base_from_gpr_risk.go

@@ -48,20 +48,10 @@ type BaseFromGprRiskIndexList struct {
 }
 
 func (baseFromGprRiskIndexList *BaseFromGprRiskIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromGprRiskIndexList.CreateTime != "" {
 			baseFromGprRiskIndexList.CreateTime = utils.GormDateStrToDateTimeStr(baseFromGprRiskIndexList.CreateTime)
-		}
-		if baseFromGprRiskIndexList.ModifyTime != "" {
 			baseFromGprRiskIndexList.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromGprRiskIndexList.ModifyTime)
-		}
-		if baseFromGprRiskIndexList.StartDate != "" {
 			baseFromGprRiskIndexList.StartDate = utils.GormDateStrToDateStr(baseFromGprRiskIndexList.StartDate)
-		}
-		if baseFromGprRiskIndexList.EndDate != "" {
 			baseFromGprRiskIndexList.EndDate = utils.GormDateStrToDateStr(baseFromGprRiskIndexList.EndDate)
-		}
-	}
 	return
 }
 
@@ -190,11 +180,9 @@ func GetGprRiskDataDataTimeByIndexId(indexIdList []int) (items []string, err err
 	}
 	sql := ` SELECT DISTINCT data_time FROM base_from_gpr_risk_data WHERE base_from_gpr_risk_index_id IN (` + utils.GetOrmInReplace(len(indexIdList)) + `) ORDER BY data_time DESC`
 	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexIdList).Find(&items).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i, item := range items {
 			items[i] = utils.GormDateStrToDateStr(item)
 		}
-	}
 	return
 }
 
@@ -210,17 +198,9 @@ type BaseFromGprRiskData struct {
 }
 
 func (baseFromGprRiskData *BaseFromGprRiskData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromGprRiskData.ModifyTime != "" {
 			baseFromGprRiskData.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromGprRiskData.ModifyTime)
-		}
-		if baseFromGprRiskData.CreateTime != "" {
 			baseFromGprRiskData.CreateTime = utils.GormDateStrToDateTimeStr(baseFromGprRiskData.CreateTime)
-		}
-		if baseFromGprRiskData.DataTime != "" {
 			baseFromGprRiskData.DataTime = utils.GormDateStrToDateStr(baseFromGprRiskData.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_hisugar.go

@@ -50,11 +50,9 @@ type BaseFromHisugarData struct {
 }
 
 func (b *BaseFromHisugarData) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.CreateTime = utils.GormDateStrToDateTimeStr(b.CreateTime)
 		b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
 		b.DataTime = utils.GormDateStrToDateStr(b.DataTime)
-	}
 	return
 }
 
@@ -83,10 +81,8 @@ type BaseFromHisugarIndexList struct {
 }
 
 func (b *BaseFromHisugarIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
 		b.CreateTime = utils.GormDateStrToDateTimeStr(b.CreateTime)
-	}
 	return
 }
 
@@ -263,14 +259,8 @@ type ExportHisugarExcelReq struct {
 }
 
 func (baseFromHisugarIndex *BaseFromHisugarIndex) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromHisugarIndex.ModifyTime != "" {
 			baseFromHisugarIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromHisugarIndex.ModifyTime)
-		}
-		if baseFromHisugarIndex.CreateTime != "" {
 			baseFromHisugarIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromHisugarIndex.CreateTime)
-		}
-	}
 	return
 }
 
@@ -306,11 +296,9 @@ func GetHisugarIndexDataByCode(indexCode string) (items []*BaseFromHisugarData,
 	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT *  FROM base_from_hisugar_data WHERE index_code=? ORDER BY data_time DESC  `
 	err = o.Raw(sql, indexCode).Find(&items).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for _, item := range items {
 			item.DataTime = utils.GormDateStrToDateStr(item.DataTime)
 		}
-	}
 	return
 }
 
@@ -376,11 +364,9 @@ func GetHisugarDataDataTimeByIndexId(indexIdList []int) (items []string, err err
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i, v := range items {
 			items[i] = utils.GormDateStrToDateStr(v)
 		}
-	}
 	return
 }
 

models/data_manage/base_from_ly_data.go

@@ -64,11 +64,9 @@ func GetLyDataListByIndexCodes(IndexCodes string) (items []string, err error) {
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 

models/data_manage/base_from_mtjh.go

@@ -53,17 +53,9 @@ type BaseFromMtjhIndexItem struct {
 }
 
 func (obj *BaseFromMtjhIndexItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 
@@ -138,11 +130,7 @@ type BaseFromMtjhMappingItem struct {
 }
 
 func (obj *BaseFromMtjhMappingItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-	}
 	return
 }
 func GetMtjhMapping(condition string, pars []interface{}) (items []*BaseFromMtjhMappingItem, err error) {
@@ -258,11 +246,7 @@ func GetMtjhIndexLatestDate(indexCode string) (ModifyTime string, err error) {
 	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT modify_time FROM base_from_mtjh_index WHERE index_code=? ORDER BY modify_time DESC limit 1 `
 	err = o.Raw(sql, indexCode).Scan(&ModifyTime).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if ModifyTime != "" {
 			ModifyTime = utils.GormDateStrToDateTimeStr(ModifyTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_oilchem.go

@@ -33,14 +33,8 @@ type BaseFromOilchemIndex struct {
 }
 
 func (baseFromOilchemIndex *BaseFromOilchemIndex) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromOilchemIndex.ModifyTime != "" {
 			baseFromOilchemIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromOilchemIndex.ModifyTime)
-		}
-		if baseFromOilchemIndex.CreateTime != "" {
 			baseFromOilchemIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromOilchemIndex.CreateTime)
-		}
-	}
 	return
 }
 
@@ -55,17 +49,9 @@ type BaseFromOilchemData struct {
 }
 
 func (baseFromOilchemData *BaseFromOilchemData) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromOilchemData.ModifyTime != "" {
 			baseFromOilchemData.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromOilchemData.ModifyTime)
-		}
-		if baseFromOilchemData.CreateTime != "" {
 			baseFromOilchemData.CreateTime = utils.GormDateStrToDateTimeStr(baseFromOilchemData.CreateTime)
-		}
-		if baseFromOilchemData.DataTime != "" {
 			baseFromOilchemData.DataTime = utils.GormDateStrToDateStr(baseFromOilchemData.DataTime)
-		}
-	}
 	return
 }
 func GetOilchemClassifyList() (list []*BaseFromOilchemClassify, err error) {
@@ -231,20 +217,10 @@ type BaseFromOilchemIndexView struct {
 }
 
 func (baseFromOilchemIndexView *BaseFromOilchemIndexView) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromOilchemIndexView.DataTime != "" {
 			baseFromOilchemIndexView.DataTime = utils.GormDateStrToDateStr(baseFromOilchemIndexView.DataTime)
-		}
-		if baseFromOilchemIndexView.StartDate != "" {
 			baseFromOilchemIndexView.StartDate = utils.GormDateStrToDateStr(baseFromOilchemIndexView.StartDate)
-		}
-		if baseFromOilchemIndexView.EndDate != "" {
 			baseFromOilchemIndexView.EndDate = utils.GormDateStrToDateStr(baseFromOilchemIndexView.EndDate)
-		}
-		if baseFromOilchemIndexView.ModifyTime != "" {
 			baseFromOilchemIndexView.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromOilchemIndexView.ModifyTime)
-		}
-	}
 	return
 }
 
@@ -352,10 +328,8 @@ func GetOilchemDataDataTimeByIndexId(indexIdList []int) (items []string, err err
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := 0; i < len(items); i++ {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }

models/data_manage/base_from_rzd_data.go

@@ -19,17 +19,9 @@ type BaseFromRzdData struct {
 }
 
 func (baseFromRzdData *BaseFromRzdData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromRzdData.ModifyTime != "" {
 			baseFromRzdData.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromRzdData.ModifyTime)
-		}
-		if baseFromRzdData.CreateTime != "" {
 			baseFromRzdData.CreateTime = utils.GormDateStrToDateTimeStr(baseFromRzdData.CreateTime)
-		}
-		if baseFromRzdData.DataTime != "" {
 			baseFromRzdData.DataTime = utils.GormDateStrToDateStr(baseFromRzdData.DataTime)
-		}
-	}
 	return
 }
 
@@ -103,11 +95,9 @@ func GetRzdDataListByIndexCodes(IndexCodes string) (items []string, err error) {
 	sql := ` SELECT DISTINCT data_time FROM base_from_rzd_data WHERE index_code IN(` + IndexCodes + `)  ORDER BY data_time DESC `
 	o := global.DbMap[utils.DbNameIndex]
 	err = o.Raw(sql).Find(&items).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := 0; i < len(items); i++ {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 

models/data_manage/base_from_rzd_index.go

@@ -55,15 +55,8 @@ type BaseFromRzdIndexList struct {
 }
 
 func (baseFromRzdIndexList *BaseFromRzdIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromRzdIndexList.ModifyTime != "" {
 			baseFromRzdIndexList.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromRzdIndexList.ModifyTime)
-		}
-		if baseFromRzdIndexList.CreateTime != "" {
 			baseFromRzdIndexList.CreateTime = utils.GormDateStrToDateTimeStr(baseFromRzdIndexList.CreateTime)
-		}
-
-	}
 	return
 }
 

models/data_manage/base_from_sci.go

@@ -103,9 +103,7 @@ type BaseFromSciData struct {
 }
 
 func (b *BaseFromSciData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		b.DataTime = utils.GormDateStrToDateStr(b.DataTime)
-	}
 	return
 }
 

models/data_manage/base_from_sci_hq_data.go

@@ -19,11 +19,7 @@ type BaseFromSciHqData struct {
 }
 
 func (obj *BaseFromSciHqData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 
@@ -46,11 +42,9 @@ func GetSciHqDataDataTimeByIndexId(indexIdList []int) (items []string, err error
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 

models/data_manage/base_from_sci_hq_index.go

@@ -44,21 +44,10 @@ type BaseFromSciHqIndexView struct {
 }
 
 func (b *BaseFromSciHqIndexView) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if b.LatestDate != "" {
 			b.LatestDate = utils.GormDateStrToDateStr(b.LatestDate)
-		}
-		if b.StartDate != "" {
 			b.StartDate = utils.GormDateStrToDateStr(b.StartDate)
-		}
-		if b.EndDate != "" {
 			b.EndDate = utils.GormDateStrToDateStr(b.EndDate)
-		}
-		if b.ModifyTime != "" {
 			b.ModifyTime = utils.GormDateStrToDateTimeStr(b.ModifyTime)
-		}
-	}
-
 	return
 }
 func (b *BaseFromSciHqIndex) Update(cols []string) (err error) {

models/data_manage/base_from_smm.go

@@ -88,29 +88,13 @@ type BaseFromSmmIndex struct {
 }
 
 func (m *BaseFromSmmIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.ApiStartTime != "" {
 			m.ApiStartTime = utils.GormDateStrToDateTimeStr(m.ApiStartTime)
-		}
-		if m.ApiUpdateTime != "" {
 			m.ApiUpdateTime = utils.GormDateStrToDateTimeStr(m.ApiUpdateTime)
-		}
-		if m.StartTime != "" {
 			m.StartTime = utils.GormDateStrToDateTimeStr(m.StartTime)
-		}
-		if m.FinishTime != "" {
 			m.FinishTime = utils.GormDateStrToDateTimeStr(m.FinishTime)
-		}
-		if m.ReleaseTime != "" {
 			m.ReleaseTime = utils.GormDateStrToDateTimeStr(m.ReleaseTime)
-		}
-		if m.StartDate != "" {
 			m.StartDate = utils.GormDateStrToDateStr(m.StartDate)
-		}
-		if m.EndDate != "" {
 			m.EndDate = utils.GormDateStrToDateStr(m.EndDate)
-		}
-	}
 	return
 }
 func AddBaseFromSmmIndex(item *BaseFromSmmIndex) (lastId int64, err error) {
@@ -432,35 +416,15 @@ type BaseFromSmmIndexItem struct {
 }
 
 func (item *BaseFromSmmIndexItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if item.CreateTime != "" {
 			item.CreateTime = utils.GormDateStrToDateTimeStr(item.CreateTime)
-		}
-		if item.ModifyTime != "" {
 			item.ModifyTime = utils.GormDateStrToDateTimeStr(item.ModifyTime)
-		}
-		if item.StartDate != "" {
 			item.StartDate = utils.GormDateStrToDateStr(item.StartDate)
-		}
-		if item.EndDate != "" {
 			item.EndDate = utils.GormDateStrToDateStr(item.EndDate)
-		}
-		if item.ApiStartTime != "" {
 			item.ApiStartTime = utils.GormDateStrToDateTimeStr(item.ApiStartTime)
-		}
-		if item.ApiUpdateTime != "" {
 			item.ApiUpdateTime = utils.GormDateStrToDateTimeStr(item.ApiUpdateTime)
-		}
-		if item.StartTime != "" {
 			item.StartTime = utils.GormDateStrToDateTimeStr(item.StartTime)
-		}
-		if item.FinishTime != "" {
 			item.FinishTime = utils.GormDateStrToDateTimeStr(item.FinishTime)
-		}
-		if item.ReleaseTime != "" {
 			item.ReleaseTime = utils.GormDateStrToDateTimeStr(item.ReleaseTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_trade_index.go

@@ -146,9 +146,7 @@ func GetLatestDate(exchange string) (dataTime string, err error) {
 	o := global.DbMap[utils.DbNameIndex]
 	sql := "SELECT data_time FROM base_from_trade_" + exchange + "_index ORDER BY data_time desc limit 1"
 	err = o.Raw(sql).Scan(&dataTime).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		dataTime = utils.GormDateStrToDateStr(dataTime)
-	}
 	return
 }
 
@@ -226,17 +224,9 @@ type BaseFromCoalmineJsmIndex struct {
 }
 
 func (baseFromCoalmineJsmIndex *BaseFromCoalmineJsmIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCoalmineJsmIndex.CreateTime != "" {
 			baseFromCoalmineJsmIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineJsmIndex.CreateTime)
-		}
-		if baseFromCoalmineJsmIndex.ModifyTime != "" {
 			baseFromCoalmineJsmIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineJsmIndex.ModifyTime)
-		}
-		if baseFromCoalmineJsmIndex.DataTime != "" {
 			baseFromCoalmineJsmIndex.DataTime = utils.GormDateStrToDateStr(baseFromCoalmineJsmIndex.DataTime)
-		}
-	}
 	return
 }
 
@@ -265,17 +255,9 @@ type BaseFromCoalmineCompanyIndex struct {
 }
 
 func (baseFromCoalmineCompanyIndex *BaseFromCoalmineCompanyIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCoalmineCompanyIndex.CreateTime != "" {
 			baseFromCoalmineCompanyIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineCompanyIndex.CreateTime)
-		}
-		if baseFromCoalmineCompanyIndex.ModifyTime != "" {
 			baseFromCoalmineCompanyIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineCompanyIndex.ModifyTime)
-		}
-		if baseFromCoalmineCompanyIndex.DataTime != "" {
 			baseFromCoalmineCompanyIndex.DataTime = utils.GormDateStrToDateStr(baseFromCoalmineCompanyIndex.DataTime)
-		}
-	}
 	return
 }
 
@@ -303,17 +285,9 @@ type BaseFromCoalmineFirmIndex struct {
 }
 
 func (baseFromCoalmineFirmIndex *BaseFromCoalmineFirmIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCoalmineFirmIndex.CreateTime != "" {
 			baseFromCoalmineFirmIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineFirmIndex.CreateTime)
-		}
-		if baseFromCoalmineFirmIndex.ModifyTime != "" {
 			baseFromCoalmineFirmIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineFirmIndex.ModifyTime)
-		}
-		if baseFromCoalmineFirmIndex.DataTime != "" {
 			baseFromCoalmineFirmIndex.DataTime = utils.GormDateStrToDateStr(baseFromCoalmineFirmIndex.DataTime)
-		}
-	}
 	return
 }
 
@@ -343,17 +317,9 @@ type BaseFromCoalmineCoastalIndex struct {
 }
 
 func (baseFromCoalmineCoastalIndex *BaseFromCoalmineCoastalIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCoalmineCoastalIndex.CreateTime != "" {
 			baseFromCoalmineCoastalIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineCoastalIndex.CreateTime)
-		}
-		if baseFromCoalmineCoastalIndex.ModifyTime != "" {
 			baseFromCoalmineCoastalIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineCoastalIndex.ModifyTime)
-		}
-		if baseFromCoalmineCoastalIndex.DataTime != "" {
 			baseFromCoalmineCoastalIndex.DataTime = utils.GormDateStrToDateStr(baseFromCoalmineCoastalIndex.DataTime)
-		}
-	}
 	return
 }
 
@@ -381,17 +347,9 @@ type BaseFromCoalmineInlandIndex struct {
 }
 
 func (baseFromCoalmineInlandIndex *BaseFromCoalmineInlandIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if baseFromCoalmineInlandIndex.CreateTime != "" {
 			baseFromCoalmineInlandIndex.CreateTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineInlandIndex.CreateTime)
-		}
-		if baseFromCoalmineInlandIndex.ModifyTime != "" {
 			baseFromCoalmineInlandIndex.ModifyTime = utils.GormDateStrToDateTimeStr(baseFromCoalmineInlandIndex.ModifyTime)
-		}
-		if baseFromCoalmineInlandIndex.DataTime != "" {
 			baseFromCoalmineInlandIndex.DataTime = utils.GormDateStrToDateStr(baseFromCoalmineInlandIndex.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_usda_fas.go

@@ -47,21 +47,10 @@ type BaseFromUsdaFasIndexList struct {
 }
 
 func (obj *BaseFromUsdaFasIndexList) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.StartDate != "" {
 			obj.StartDate = utils.GormDateStrToDateStr(obj.StartDate)
-		}
-
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 
@@ -147,10 +136,8 @@ func GetUsdaFasIndexDataTimePageByCodes(indexCodes []string, startSize, pageSize
 	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT data_time FROM base_from_usda_fas_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY data_time ORDER BY data_time DESC LIMIT ?,? `
 	err = o.Raw(sql, indexCodes, startSize, pageSize).Scan(&dataTimes).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range dataTimes {
 			dataTimes[i] = utils.GormDateStrToDateStr(dataTimes[i])
-		}
 	}
 	return
 }
@@ -208,11 +195,9 @@ func GetUsdaFasDataDataTimeByIndexId(indexIdList []int) (items []string, err err
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 
@@ -228,17 +213,9 @@ type BaseFromUsdaFasData struct {
 }
 
 func (obj *BaseFromUsdaFasData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/base_from_yongyi.go

@@ -42,14 +42,8 @@ type BaseFromYongyiIndexList struct {
 }
 
 func (m *BaseFromYongyiIndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.CreateTime != "" {
 			m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
-		}
-		if m.ModifyTime != "" {
 			m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
-		}
-	}
 	return
 }
 
@@ -148,11 +142,9 @@ func GetYongyiDataDataTimeByIndexId(indexIdList []int) (items []string, err erro
 	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT DISTINCT data_time FROM base_from_yongyi_data WHERE yongyi_index_id IN (` + utils.GetOrmInReplace(len(indexIdList)) + `) ORDER BY data_time DESC`
 	err = o.Raw(sql, indexIdList).Find(&items).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 
@@ -168,17 +160,9 @@ type BaseFromYongyiData struct {
 }
 
 func (m *BaseFromYongyiData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.CreateTime != "" {
 			m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
-		}
-		if m.ModifyTime != "" {
 			m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
-		}
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/coal_data.go

@@ -89,17 +89,9 @@ type BaseFromCoalmineIndex struct {
 }
 
 func (m *BaseFromCoalmineIndex) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.CreateTime != "" {
 			m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
-		}
-		if m.ModifyTime != "" {
 			m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
-		}
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 func GetBaseFromCoalIndexByCode(suffix, indexCode string) (items []*BaseFromCoalmineIndex, err error) {

models/data_manage/edb_info.go

@@ -761,26 +761,14 @@ type EdbInfoMaxAndMinInfo struct {
 }
 
 func (edbInfoMaxAndMinInfo *EdbInfoMaxAndMinInfo) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if edbInfoMaxAndMinInfo.MinDate != "" {
 			edbInfoMaxAndMinInfo.MinDate = utils.GormDateStrToDateStr(edbInfoMaxAndMinInfo.MinDate)
-		}
-		if edbInfoMaxAndMinInfo.MaxDate != "" {
 			edbInfoMaxAndMinInfo.MaxDate = utils.GormDateStrToDateStr(edbInfoMaxAndMinInfo.MaxDate)
-		}
-	}
 	return
 }
 
 func (edbInfoMaxAndMinInfo *EdbInfoMaxAndMinInfo) ConvertTimeStr() {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if edbInfoMaxAndMinInfo.MinDate != "" {
 			edbInfoMaxAndMinInfo.MinDate = utils.GormDateStrToDateStr(edbInfoMaxAndMinInfo.MinDate)
-		}
-		if edbInfoMaxAndMinInfo.MaxDate != "" {
 			edbInfoMaxAndMinInfo.MaxDate = utils.GormDateStrToDateStr(edbInfoMaxAndMinInfo.MaxDate)
-		}
-	}
 }
 
 // GetEdbInfoMaxAndMinInfo

models/data_manage/future_good/future_good_edb_info_data.go

@@ -56,17 +56,9 @@ type FutureGoodEdbDataItem struct {
 }
 
 func (m *FutureGoodEdbDataItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.CreateTime != "" {
 			m.CreateTime = utils.GormDateStrToDateTimeStr(m.CreateTime)
-		}
-		if m.ModifyTime != "" {
 			m.ModifyTime = utils.GormDateStrToDateTimeStr(m.ModifyTime)
-		}
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/lz_data.go

@@ -99,11 +99,7 @@ type LzProductData struct {
 }
 
 func (m *LzProductData) AfterFind(db *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 

models/data_manage/mysteel_chemical_index.go

@@ -205,11 +205,7 @@ type MysteelChemicalList struct {
 }
 
 func (m *MysteelChemicalList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.UpdateTime != "" {
 			m.UpdateTime = utils.GormDateStrToDateTimeStr(m.UpdateTime)
-		}
-	}
 	return
 }
 
@@ -220,11 +216,7 @@ type MysteelChemicalData struct {
 }
 
 func (m *MysteelChemicalData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 
@@ -354,11 +346,9 @@ func GetBaseFromMysteelChemicalDataTimeByIndexId(indexIdList []int) (items []str
 	if err != nil {
 		return
 	}
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		for i := range items {
 			items[i] = utils.GormDateStrToDateStr(items[i])
 		}
-	}
 	return
 }
 
@@ -558,11 +548,7 @@ type BaseRefreshEdbInfo struct {
 }
 
 func (obj *BaseRefreshEdbInfo) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 

models/data_manage/sci_data.go

@@ -51,26 +51,12 @@ type SciIndex struct {
 }
 
 func (sciIndex *SciIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if sciIndex.CreateTime != "" {
 			sciIndex.CreateTime = utils.GormDateStrToDateTimeStr(sciIndex.CreateTime)
-		}
-		if sciIndex.ModifyTime != "" {
 			sciIndex.ModifyTime = utils.GormDateStrToDateTimeStr(sciIndex.ModifyTime)
-		}
-		if sciIndex.ApiStartTime != "" {
 			sciIndex.ApiStartTime = utils.GormDateStrToDateStr(sciIndex.ApiStartTime)
-		}
-		if sciIndex.ApiUpdateTime != "" {
 			sciIndex.ApiUpdateTime = utils.GormDateStrToDateTimeStr(sciIndex.ApiUpdateTime)
-		}
-		if sciIndex.StartTime != "" {
 			sciIndex.StartTime = utils.GormDateStrToDateTimeStr(sciIndex.StartTime)
-		}
-		if sciIndex.FinishTime != "" {
 			sciIndex.FinishTime = utils.GormDateStrToDateTimeStr(sciIndex.FinishTime)
-		}
-	}
 	return
 }
 func GetSciIndex(condition string, pars []interface{}) (items []*SciIndex, err error) {
@@ -146,11 +132,7 @@ type SciIndexData struct {
 }
 
 func (sciIndexData *SciIndexData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if sciIndexData.DataTime != "" {
 			sciIndexData.DataTime = utils.GormDateStrToDateStr(sciIndexData.DataTime)
-		}
-	}
 	return
 }
 func GetSciIndexData(indexCode string, startSize, pageSize int) (items []*SciIndexData, err error) {

models/data_manage/smm_data.go

@@ -55,26 +55,12 @@ type SmmIndex struct {
 }
 
 func (obj *SmmIndex) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.StartTime != "" {
 			obj.StartTime = utils.GormDateStrToDateTimeStr(obj.StartTime)
-		}
-		if obj.FinishTime != "" {
 			obj.FinishTime = utils.GormDateStrToDateTimeStr(obj.FinishTime)
-		}
-		if obj.ApiStartTime != "" {
 			obj.ApiStartTime = utils.GormDateStrToDateTimeStr(obj.ApiStartTime)
-		}
-		if obj.ApiUpdateTime != "" {
 			obj.ApiUpdateTime = utils.GormDateStrToDateTimeStr(obj.ApiUpdateTime)
-		}
-	}
 	return
 }
 
@@ -189,11 +175,7 @@ type SmmIndexData struct {
 }
 
 func (m *SmmIndexData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if m.DataTime != "" {
 			m.DataTime = utils.GormDateStrToDateStr(m.DataTime)
-		}
-	}
 	return
 }
 func GetSmmIndexData(indexCode string, startSize, pageSize int) (items []*SmmIndexData, err error) {

models/data_manage/supply_analysis/variety_edb_info.go

@@ -88,20 +88,10 @@ type VarietyEdbInfoItem struct {
 }
 
 func (v *VarietyEdbInfoItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if v.CreateTime != "" {
 			v.CreateTime = utils.GormDateStrToDateTimeStr(v.CreateTime)
-		}
-		if v.ModifyTime != "" {
 			v.ModifyTime = utils.GormDateStrToDateTimeStr(v.ModifyTime)
-		}
-		if v.StartDate != "" {
 			v.StartDate = utils.GormDateStrToDateStr(v.StartDate)
-		}
-		if v.EndDate != "" {
 			v.EndDate = utils.GormDateStrToDateStr(v.EndDate)
-		}
-	}
 	return
 }
 

models/data_manage/supply_analysis/variety_plant.go

@@ -93,20 +93,10 @@ type VarietyPlantItem struct {
 }
 
 func (v *VarietyPlantItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if v.CreateTime != "" {
 			v.CreateTime = utils.GormDateStrToDateTimeStr(v.CreateTime)
-		}
-		if v.ModifyTime != "" {
 			v.ModifyTime = utils.GormDateStrToDateTimeStr(v.ModifyTime)
-		}
-		if v.MaintenanceDate != "" {
 			v.MaintenanceDate = utils.GormDateStrToDateStr(v.MaintenanceDate)
-		}
-		if v.ResumptionDate != "" {
 			v.ResumptionDate = utils.GormDateStrToDateStr(v.ResumptionDate)
-		}
-	}
 	return
 }
 

models/data_source/base_from_sci99.go

@@ -55,17 +55,9 @@ type BaseFromSci99DataItem struct {
 }
 
 func (obj *BaseFromSci99DataItem) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 
@@ -83,14 +75,8 @@ type BaseFromSci99IndexList struct {
 	Paging             *paging.PagingItem       `description:"分页数据" gorm:"-"`
 }
 func (obj *BaseFromSci99IndexList) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-	}
 	return
 }
 

models/data_source/guagnzhouqihuo.go

@@ -67,9 +67,7 @@ func (obj *BaseFromTradeGuangzhouIndex) GetBaseFromTradeGuangzhouMaxDate() (max_
 	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT MAX(a.end_date) AS max_date FROM base_from_trade_guangzhou_index AS a `
 	err = o.Raw(sql).Scan(&max_date).Error
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
 		max_date = utils.GormDateStrToDateStr(max_date)
-	}
 	return max_date, err
 }
 
@@ -93,14 +91,8 @@ type BaseFromTradeGuangzhouIndexView struct {
 }
 
 func (obj *BaseFromTradeGuangzhouIndexView) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.StartDate != "" {
 			obj.StartDate = utils.GormDateStrToDateStr(obj.StartDate)
-		}
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 

models/data_source/icpi.go

@@ -59,11 +59,7 @@ type BaseFromIcpiDataView struct {
 }
 
 func (obj *BaseFromIcpiDataView) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 
@@ -83,20 +79,10 @@ type BaseFromIcpiIndexView struct {
 }
 
 func (obj *BaseFromIcpiIndexView) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.StartDate != "" {
 			obj.StartDate = utils.GormDateStrToDateStr(obj.StartDate)
-		}
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 func (obj *BaseFromIcpiIndex) GetIcpiIndex(condition string, pars []interface{}) (items []*BaseFromIcpiIndexView, err error) {

models/data_source/longzhong.go

@@ -163,11 +163,7 @@ type LongzhongSurveyData struct {
 }
 
 func (obj *LongzhongSurveyData) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.DataTime != "" {
 			obj.DataTime = utils.GormDateStrToDateStr(obj.DataTime)
-		}
-	}
 	return
 }
 func GetLongzhongSurveyDataById(lzInfoId int) (items []*LongzhongSurveyData, err error) {

models/english_report.go

@@ -250,38 +250,18 @@ type EnglishReportDetail struct {
 }
 
 func (obj *EnglishReportDetail) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.PublishTime != "" {
 			obj.PublishTime = utils.GormDateStrToDateTimeStr(obj.PublishTime)
-		}
-		if obj.PrePublishTime != "" {
 			obj.PrePublishTime = utils.GormDateStrToDateTimeStr(obj.PrePublishTime)
-		}
-	}
 	return
 }
 
 func (obj *EnglishReportDetail) ConvertTimeStr() {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-		if obj.PublishTime != "" {
 			obj.PublishTime = utils.GormDateStrToDateTimeStr(obj.PublishTime)
-		}
-		if obj.PrePublishTime != "" {
 			obj.PrePublishTime = utils.GormDateStrToDateTimeStr(obj.PrePublishTime)
-		}
-	}
 	return
 }
 

models/material/material.go

@@ -84,14 +84,8 @@ type MaterialListItems struct {
 }
 
 func (obj *MaterialListItems) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.CreateTime != "" {
 			obj.CreateTime = utils.GormDateStrToDateTimeStr(obj.CreateTime)
-		}
-		if obj.ModifyTime != "" {
 			obj.ModifyTime = utils.GormDateStrToDateTimeStr(obj.ModifyTime)
-		}
-	}
 	return
 }
 

models/target.go

@@ -1336,14 +1336,8 @@ type LongzhongSurveyProduct struct {
 }
 
 func (obj *LongzhongSurveyProduct) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if obj.StartDate != "" {
 			obj.StartDate = utils.GormDateStrToDateStr(obj.StartDate)
-		}
-		if obj.EndDate != "" {
 			obj.EndDate = utils.GormDateStrToDateStr(obj.EndDate)
-		}
-	}
 	return
 }
 func GetLongzhongSurveyProductByClassifyName(productName string) (items []*LongzhongSurveyProduct, err error) {
@@ -1780,14 +1774,8 @@ type EdbinfoMaxMinDate struct {
 }
 
 func (mmDate *EdbinfoMaxMinDate) AfterFind(tx *gorm.DB) (err error) {
-	if utils.NeedDateOrTimeFormat(utils.DbDriverName) {
-		if mmDate.MinDate != "" {
 			mmDate.MinDate = utils.GormDateStrToDateStr(mmDate.MinDate)
-		}
-		if mmDate.MaxDate != "" {
 			mmDate.MaxDate = utils.GormDateStrToDateStr(mmDate.MaxDate)
-		}
-	}
 	return
 }
 

utils/sql.go

@@ -308,20 +308,6 @@ func getDriverInstance(driver string) (dbDriver Driver, err error) {
 	}
 	return
 }
-
-func NeedDateOrTimeFormat(driver string) bool {
-	var dbDriver Driver
-	if driver == "" {
-		dbDriver = supportDriverMap[DbDriverName]
-	} else {
-		dbDriver, _ = getDriverInstance(driver)
-	}
-	if dbDriver == DM {
-		return true
-	}
-	return false
-}
-
 func ReplaceDriverKeywords(driver string, sql string) string {
 	dbDriver, _ := getDriverInstance(driver)
 	rules := map[Driver]map[string]string{