hongze_task/services/data/edb_info.go

package data

import (
	"context"
	"errors"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/http"
	"hongze/hongze_task/models/data_manage"
	"hongze/hongze_task/utils"
	"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 {
		err = errors.New("GetEdbInfoByCondition:" + err.Error())
		return
	}

	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 {
			err = errors.New("SyncEdbDataByThs Err:" + err.Error())
			return err
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			err = errors.New("GetEdbInfoMaxAndMinInfo Err:" + err.Error())
			return err
		}
		if item != nil {
			err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
			if err != nil {
				err = errors.New("ModifyEdbInfoMaxAndMinInfo Err:" + err.Error())
				return err
			}
		}
	}
	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
}

// CheckLtDataInterface 检测路透数据服务器
func CheckLtDataInterface(cont context.Context) (err error) {
	go func() {
		checkUrl := utils.Hz_Data_LT_Url + `hz_server`
		body, err := http.Get(checkUrl)
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "检测路透数据服务器失败：CheckLtDataInterface ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		result := string(body)
		if result != `"ek true"` {
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"检测数据接口：失败提醒", "检测路透数据服务器失败：CheckLtDataInterface 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 is_update=1 "

	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, source)
		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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				return errors.New("GetEdbInfoCalculateLjzzyDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
			if err != nil {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				return errors.New("GetEdbInfoById Err:" + err.Error())
			}
			startDate := time.Now().AddDate(-2, -2, 0).Format(utils.FormatDate)
			endDate := "" //time.Now().Format(utils.FormatDate)
			formulaInt, _ := strconv.Atoi(v.CalculateFormula)
			err = data_manage.RefreshCalculateHbz(edbInfoId, source, fromEdbInfo, calculateHbz.EdbCode, startDate, endDate, formulaInt)
			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 {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				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 {
					if err.Error() == utils.ErrNoRow() {
						continue
					}
					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 if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
			calculate, err := data_manage.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				return fmt.Errorf("GetEdbInfoCalculateTbzDetail Err:" + err.Error())
			}
			fromEdbInfo, err := data_manage.GetEdbInfoById(calculate.FromEdbInfoId)
			if err != nil {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				return fmt.Errorf("GetEdbInfoById Err:" + err.Error())
			}
			//startDate := v.StartDate.Format(utils.FormatDate)
			//endDate := time.Now().Format(utils.FormatDate)
			formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
			err = data_manage.RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, calculate.MoveFrequency)
			if err != nil {
				return fmt.Errorf("RefreshAllCalculateTimeShift Err:" + err.Error())
			}

		} else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //刷新直接拼接
			tmpEdbInfo, err := data_manage.GetEdbInfoById(v.EdbInfoId)
			if err != nil {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				return fmt.Errorf("GetEdbInfoById Err:" + err.Error())
			}
			err = data_manage.RefreshAllCalculateZjpj(tmpEdbInfo)
			if err != nil {
				return fmt.Errorf("RefreshAllCalculateZjpj Err:" + err.Error())
			}
		} else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //刷新累计值同比拼接
			tmpEdbInfo, err := data_manage.GetEdbInfoById(v.EdbInfoId)
			if err != nil {
				if err.Error() == utils.ErrNoRow() {
					continue
				}
				return fmt.Errorf("GetEdbInfoById Err:" + err.Error())
			}
			err = data_manage.RefreshAllCalculateLjztbpj(tmpEdbInfo)
			if err != nil {
				return fmt.Errorf("RefreshAllCalculateLjztbpj 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 {
			fmt.Println("GetEdbInfoMaxAndMinInfo Err:" + err.Error() + ";source:" + strconv.Itoa(source) + ";edbCode:" + edbCode)
			err = errors.New("GetEdbInfoMaxAndMinInfo Err:" + err.Error() + ";source:" + strconv.Itoa(source) + ";edbCode:" + edbCode)
			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())
	}

	for _, v := range items {
		err = data_manage.RefreshManual(v)
		if err != nil {
			return errors.New("RefreshManual：edbCode：" + v.EdbCode + ":" + err.Error())
		}
		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
		if err != nil {
			if err.Error() != utils.ErrNoRow() {
				return err
			} else {
				err = nil
			}
		} else {
			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
}

// RefreshDataFromSh 刷新上期所数据
func RefreshDataFromSh(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromSh Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromSh ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_SH)
	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.RefreshEdbDataBySh(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataBySh:" + 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
}

// RefreshDataFromDl 刷新大商所数据
func RefreshDataFromDl(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromDl Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromDl ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_DL)
	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.RefreshEdbDataByDl(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByDl:" + 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
}

// RefreshDataFromShfe 刷新上期能源数据
func RefreshDataFromShfe(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromShfe Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromShfe ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_SHFE)
	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.RefreshEdbDataByShfe(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByShfe:" + 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
}

// RefreshDataFromCffex 刷新中金所数据
func RefreshDataFromCffex(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromCffex Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromCffex ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_CFFEX)
	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.RefreshEdbDataByCffex(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByCffex:" + 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
}

// RefreshDataFromZz 刷新郑商所数据
func RefreshDataFromZz(wg *sync.WaitGroup) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("RefreshDataFromZz Err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "RefreshDataFromZz ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
		wg.Done()
	}()
	var condition string
	var pars []interface{}
	condition += " AND source=? "
	pars = append(pars, utils.DATA_SOURCE_ZZ)
	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.RefreshEdbDataByZz(v.EdbInfoId, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByZz:" + 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
}

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

	endDate := time.Now().Format(utils.FormatDate)
	for _, v := range items {
		startDate := v.StartDate.Format(utils.FormatDate)
		err = data_manage.RefreshAllEdbDataByLt(v.EdbInfoId, utils.DATA_SOURCE_LT, v.EdbCode, startDate, endDate)
		if err != nil {
			return errors.New("RefreshEdbDataByLt:" + 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
}