hongze_task/services/data/edb_info.go

package data

import (
	"context"
	"errors"
	"fmt"
	"hongze/hongze_task/models/data_manage"
	"hongze/hongze_task/utils"
	"rdluck_tools/http"
	"strconv"
	"sync"
	"time"
)

//刷新同花顺数据
func RefreshDataFromThs(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromThs Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromThs ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_THS)
	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		err = SyncEdbDataByThs(int64(v.EdbInfoId), v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("SyncEdbDataByThs:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
		//minDate, maxDate, err := data.GetEdbDataThsMaxOrMinDate(v.EdbInfoId)
		//if err != nil {
		//	return errors.New("GetEdbDataThsMaxOrMinDate:" + err.Error())
		//}
		//fmt.Println("minDate:" + minDate + ";maxDate:" + maxDate)
		//err = data.ModifyEdbDataInfoDate(v.EdbInfoId, maxDate)
		//if err != nil {
		//	return errors.New("ModifyEdbDataInfoDate:" + err.Error())
		//}
	}
	return err
}

//刷新万得数据
func RefreshDataFromWind(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromWind Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromWind ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_WIND)

	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return err
	}

	var endDate string
	endDate = time.Now().Format(utils.FormatDate)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		err = SyncEdbDataByWind(int64(v.EdbInfoId), v.EdbCode, startDate, endDate)
		if err != nil {
			return err
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
	}
	return err
}

//刷新彭博数据
func RefreshDataFromPb(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromPb Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromPb ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_PB)

	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDateUnSpace)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDateUnSpace)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDateUnSpace)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDateUnSpace)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDateUnSpace)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDateUnSpace)
		}
		err = SyncEdbDataByPb(int64(v.EdbInfoId), v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("SyncEdbDataByPb:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
		//minDate, maxDate, err := data.GetEdbDataPbMaxOrMinDate(v.EdbInfoId)
		//if err != nil {
		//	return errors.New("GetEdbDataThsMaxOrMinDate:" + err.Error())
		//}
		//fmt.Println("minDate:" + minDate + ";maxDate:" + maxDate)
		//err = data.ModifyEdbDataInfoDate(v.EdbInfoId, maxDate)
		//if err != nil {
		//	return errors.New("ModifyEdbDataInfoDate:" + err.Error())
		//}
	}
	return err
}

func CheckDataInterface(cont context.Context) (err error) {
	go func() {
		checkUrl := utils.Hz_Data_Url + `hz_server`
		body, err := http.Get(checkUrl)
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "CheckDataInterface ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		result := string(body)
		if result != "1" {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "CheckDataInterface ErrMsg:"+string(body), utils.EmailSendToUsers)
		}

		//阿里服务器监听
		checkUrl2 := utils.Hz_Server_Data_Url + `hz_server`
		body, err = http.Get(checkUrl2)
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测服务器数据接口：失败提醒", "CheckDataInterface ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		result = string(body)
		if result != "1" {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测服务器数据接口：失败提醒", "CheckDataInterface ErrMsg:"+string(body), utils.EmailSendToUsers)
		}
	}()
	return
}

func CheckPbDataInterface(cont context.Context) (err error) {
	go func() {
		checkUrl := utils.Hz_Data_PB_Url + `hz_server`
		body, err := http.Get(checkUrl)
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "CheckPbDataInterface ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		result := string(body)
		if result != "1" {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "CheckPbDataInterface ErrMsg:"+string(body), utils.EmailSendToUsers)
		}
	}()
	return
}

//刷新所有计算指标
func RefreshDataFromCalculateAll() (err error) {
	defer func() {
		if err != nil {
			utils.FileLog.Info("RefreshDataFromCalculateAll Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromCalculateAll ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	var condition string
	var pars []interface{}
	condition += " AND edb_type=? "
	pars = append(pars, 2)

	//condition += " AND source=? "
	//pars = append(pars, utils.DATA_SOURCE_CALCULATE_BP)

	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return err
	}
	for _, v := range items {
		edbInfoId := v.EdbInfoId
		edbCode := v.EdbCode
		source := v.Source
		fmt.Println(v.EdbInfoId, v.EdbCode, v.EdbName, v.SourceName)
		if source == utils.DATA_SOURCE_CALCULATE {
			startDate := ""
			if v.Frequency == "日度" {
				startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
			} else if v.Frequency == "周度" {
				startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
			} else if v.Frequency == "月度" {
				startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
			} else if v.Frequency == "季度" {
				startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
			} else if v.Frequency == "年度" {
				startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
			} else {
				startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
			}
			endDate := time.Now().Format(utils.FormatDate)
			var edbInfoIdBytes []string
			calculateMap, err := data_manage.GetEdbInfoCalculateDetail(int(v.EdbInfoId))
			if err != nil {
				return errors.New("GetEdbInfoCalculateDetail Err:" + err.Error())
			}
			var formulaStr string
			edbInfoList := make([]*data_manage.EdbInfo, 0)
			for _, v := range calculateMap {
				formulaStr += v.FromTag + ","
				edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
				edbInfo, _ := data_manage.GetEdbInfoById(v.FromEdbInfoId)
				edbInfoList = append(edbInfoList, edbInfo)
			}
			endDate = ""
			err = RefreshCalculate(edbInfoList, edbInfoId, edbCode, v.CalculateFormula, startDate, endDate, edbInfoIdBytes)
			if err != nil {
				return errors.New("RefreshCalculate Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_LJZZY {
			calculateLjzzy, err := data_manage.GetEdbInfoCalculateLjzzyDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateLjzzyDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			year := time.Now().Year() - 1
			startDate := strconv.Itoa(year) + "-01" + "-01"
			endDate := ""//time.Now().Format(utils.FormatDate)
			err = data_manage.RefreshCalculateLjzzy(edbInfoId, fromEdbInfo, edbCode, startDate, endDate)
			if err != nil {
				return errors.New("RefreshCalculateLjzzy Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_TBZ {
			calculateTbz, err := data_manage.GetEdbInfoCalculateTbzDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateTbzDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
			endDate := ""//time.Now().Format(utils.FormatDate)
			err = data_manage.RefreshCalculateTbz(edbInfoId, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
			if err != nil {
				return errors.New("RefreshCalculateTbz Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_TCZ {
			calculateTcz, err := data_manage.GetEdbInfoCalculateTczDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateTczDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTcz.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
			endDate := ""//time.Now().Format(utils.FormatDate)
			err = data_manage.RefreshCalculateTcz(edbInfoId, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
			if err != nil {
				return errors.New("RefreshCalculateTcz Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
			calculateNszydpjjs, err := data_manage.GetEdbInfoCalculateNszydpjjsDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			formulaInt, _ := strconv.Atoi(v.CalculateFormula)
			err = data_manage.RefreshCalculateNszydpjjs(edbInfoId, v.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode)
			if err != nil {
				return errors.New("RefreshCalculateNszydpjjs Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_HBZ {
			calculateHbz, err := data_manage.GetEdbInfoCalculateHbzDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateHbzDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateHbz.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
			endDate := ""//time.Now().Format(utils.FormatDate)
			err = data_manage.RefreshCalculateHbz(edbInfoId, source, fromEdbInfo, calculateHbz.EdbCode, startDate, endDate)
			if err != nil {
				return errors.New("RefreshCalculateTbz Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_HCZ {
			calculateHcz, err := data_manage.GetEdbInfoCalculateHczDetail(edbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoCalculateHczDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateHcz.FromEdbInfoId)
			if err != nil {
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
			endDate := ""//time.Now().Format(utils.FormatDate)
			err = data_manage.RefreshCalculateHcz(edbInfoId, source, fromEdbInfo, calculateHcz.EdbCode, startDate, endDate)
			if err != nil {
				return errors.New("RefreshCalculateTbz Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_BP {
			calculateBp, err := data_manage.GetEdbInfoCalculateBpDetail(edbInfoId)
			if err != nil && err.Error() != utils.ErrNoRow() {
				return errors.New("GetEdbInfoCalculateBpDetail Err:" + err.Error())
			}
			if calculateBp != nil {
				fromEdbInfo, err := data_manage.GetEdbInfoById(calculateBp.FromEdbInfoId)
				if err != nil {
					return errors.New("GetEdbInfoById Err:" + err.Error())
				}
				startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
				endDate := ""//time.Now().Format(utils.FormatDate)
				err = data_manage.RefreshCalculateBp(edbInfoId, fromEdbInfo, calculateBp.EdbCode, startDate, endDate)
				if err != nil {
					return errors.New("RefreshCalculateTbz Err:" + err.Error())
				}
			}
		} else {
			msg := "刷新失败,无效的指标渠道:source:" + strconv.Itoa(source) + " EdbCode:" + v.EdbCode
			err = errors.New(msg)
			return err
		}

		maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
		if err != nil {
			return err
		}
		if maxAndMinItem != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
			if err != nil {
				return err
			}
		}
	}
	return err
}

//刷新手工指标数据
func RefreshDataFromManual(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromManual Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromManual ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_MANUAL)
	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		err = data_manage.RefreshManual(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("SyncEdbDataByThs:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
	}
	return err
}

//刷新隆众数据
func RefreshDataFromLz(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromLz Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromLz ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_LZ)
	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		fmt.Println(startDate, endDate)
		err = data_manage.RefreshEdbDataByLz(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByLz:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
	}
	return err
}

//刷新有色数据
func RefreshDataFromYs(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromYs Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromYs ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_YS)
	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		fmt.Println(startDate, endDate)
		err = data_manage.RefreshEdbDataByYs(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByYs:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
	}
	return err
}

//刷新钢联数据
func RefreshDataFromGl(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromGl Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromYs ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_GL)
	items, err := data_manage.GetEdbInfoByCondition(condition, pars, 0)
	if err != nil {
		return errors.New("GetEdbInfoByCondition:" + err.Error())
	}

	var endDate string
	endDate = time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
	for _, v := range items {
		startDate := ""
		if v.Frequency == "日度" {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		} else if v.Frequency == "周度" {
			startDate = v.EndDate.AddDate(0, 0, -(utils.DATA_REFRESH * 7)).Format(utils.FormatDate)
		} else if v.Frequency == "月度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH, 0).Format(utils.FormatDate)
		} else if v.Frequency == "季度" {
			startDate = v.EndDate.AddDate(0, -utils.DATA_REFRESH*3, 0).Format(utils.FormatDate)
		} else if v.Frequency == "年度" {
			startDate = v.EndDate.AddDate(-utils.DATA_REFRESH, 0, 0).Format(utils.FormatDate)
		} else {
			startDate = v.EndDate.AddDate(0, 0, -utils.DATA_REFRESH).Format(utils.FormatDate)
		}
		fmt.Println(startDate, endDate)
		err = data_manage.RefreshEdbDataByGl(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByGl:" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				return err
			}
		}
	}
	return err
}

func ResetEdbInfoIsUpdate(cont context.Context) (err error) {
	go data_manage.ResetEdbInfoIsUpdate()
	return nil
}