package controllers

import (
	"fmt"
	"hongze/hongze_edb_lib/models"
	"hongze/hongze_edb_lib/utils"
	"strings"
	"time"
)

type EdbController struct {
	BaseAuthController
}

// Search
// @Title 新增指标-查询指标信息接口
// @Description 查询指标信息接口
// @Params Source query int true "指标来源；1：同花顺；2：Wind；3：彭博 ..."
// @Params EdbCode query string true "指标编码"
// @Success 200 {object} data_manage.EditEdbInfoReq
// @router /add [post]
func (this *ThsController) Search() {
	br := new(models.BaseResponse).Init()
	var cacheKey string
	defer func() {
		utils.Rc.Delete(cacheKey)
		this.Data["json"] = br
		this.ServeJSON()
	}()
	source, _ := this.GetInt("Source")
	edbCode := this.GetString("EdbCode")
	edbCode = strings.Trim(edbCode, "\t")
	edbCode = strings.Trim(edbCode, " ")
	edbCode = strings.Replace(edbCode, "\t", "", -1)
	if source <= 0 {
		br.Msg = "无效的数据来源"
		return
	}
	if edbCode == "" {
		br.Msg = "请输入指标ID"
		return
	}

	resp := new(models.EdbInfoSearchResp)
	//判断指标是否存在
	item, err := models.GetEdbInfoByEdbCode(source, edbCode)
	if err != nil {
		if err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "根据指标编码获取指标信息失败,Err:" + err.Error()
			return
		}
	}

	{

		dateNow := time.Now()

		startDate := dateNow.AddDate(-30, 0, 0).Format(utils.FormatDate)

		searchItem := new(models.EdbInfoSearch)
		if source == utils.DATA_SOURCE_THS {
			dataItems, err := models.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_THS, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Ths已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("ths len:", len(dataItems))
			if len(dataItems) > 0 {
				fmt.Println("ths data exist")
				searchItem.EdbCode = edbCode
				edbInfoMaxAndMinInfo, err := models.GetEdbInfoMaxAndMinInfo(source, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取Ths日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = edbInfoMaxAndMinInfo.MinDate
				searchItem.EndDate = edbInfoMaxAndMinInfo.MaxDate
			} else {
				endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
				searchItem, err = data.GetEdbDataByThs(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
			}
		} else if source == utils.DATA_SOURCE_WIND {
			fmt.Println("wind data exist")
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_WIND, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Wind已存在信息失败,Err:" + err.Error()
				return
			}
			fmt.Println("wind dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataWindMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取wind日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				endDate := dateNow.Format(utils.FormatDate)
				searchItem, err = data.GetEdbDataByWind(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "wind 获取失败,Err:" + err.Error()
					return
				}
			}
		} else if source == utils.DATA_SOURCE_PB {
			fmt.Println("pb data exist")
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_PB, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Pb已存在信息失败,Err:" + err.Error()
				return
			}
			fmt.Println("pb dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataPbMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取Pb日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
				startDate := dateNow.AddDate(-30, 0, 0).Format(utils.FormatDateUnSpace)
				searchItem, err = data.GetEdbDataByPb(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "彭博数据获取失败,Err:" + err.Error()
					return
				}
			}
		} else if source == utils.DATA_SOURCE_MANUAL { //手工数据指标
			endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_MANUAL, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Ths已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("ths len:", len(dataItems))
			if len(dataItems) > 0 {
				fmt.Println("ths data exist")
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataManualMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取Ths日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataByManual(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
			}
			//获取指标信息
			manualInfo, err := models.GetEdbinfoByTradeCode(edbCode)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取手工指标详情失败,Err:" + err.Error()
				return
			}
			if manualInfo != nil {
				searchItem.Frequency = manualInfo.Frequency
				searchItem.Unit = manualInfo.Unit
				searchItem.EdbName = manualInfo.SecName
			}

		} else if source == utils.DATA_SOURCE_LZ {
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_LZ, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取隆众已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("ths len:", len(dataItems))
			if len(dataItems) > 0 {
				fmt.Println("ths data exist")
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataLzMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取隆众日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
				searchItem, err = data_manage.GetEdbDataByLz(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取隆众数据失败,Err:" + err.Error()
					return
				}
			}
			//获取指标信息
			lzInfo, err := data_manage.GetLongzhongSurveyProductByCode(edbCode)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取手工指标详情失败,Err:" + err.Error()
				return
			}
			if lzInfo != nil {
				frequency := lzInfo.Frequency
				var frequencyStr string
				if frequency == 1 {
					frequencyStr = "日度"
				} else if frequency == 2 {
					frequencyStr = "周度"
				} else if frequency == 3 {
					frequencyStr = "月度"
				} else if frequency == 4 {
					frequencyStr = "季度"
				} else if frequency == 5 {
					frequencyStr = "年度"
				} else if frequency == 99 {
					frequencyStr = "无固定频率"
				}
				searchItem.Frequency = frequencyStr
				searchItem.Unit = lzInfo.UnitName
				searchItem.EdbName = lzInfo.SampleName + lzInfo.BreedName + lzInfo.QuotaName
			}
		} else if source == utils.DATA_SOURCE_YS { //有色网
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_YS, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Ys已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataYsMaxAndMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取YS日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
				searchItem, err = data_manage.GetEdbDataByYs(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataByYs Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataYsMaxAndMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			smmInfo, err := data_manage.GetBaseFromSmmIndexByIndexCode(edbCode)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取有色指标详情失败,Err:" + err.Error()
				return
			}
			if smmInfo != nil {
				searchItem.Frequency = smmInfo.Frequency
				searchItem.Unit = smmInfo.Unit
				searchItem.EdbName = smmInfo.IndexName
			}

		} else if source == utils.DATA_SOURCE_GL { //钢联
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataGlMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取钢联日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				endDate := dateNow.AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
				searchItem, err = data_manage.GetEdbDataByGl(edbCode, startDate, endDate)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取钢联数据失败,Err:" + err.Error()
					return
				}
			}
			//获取指标信息
			glInfo, err := data_manage.GetGlIndexByCode(edbCode)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联指标详情失败,Err:" + err.Error()
				return
			}
			if glInfo != nil {
				searchItem.Frequency = glInfo.FrequencyName
				searchItem.Unit = glInfo.UnitName
				searchItem.EdbName = glInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_ZZ { //郑商所
			var suffix string
			if strings.Contains(edbCode, "deal") {
				suffix = "deal"
			} else if strings.Contains(edbCode, "buy") {
				suffix = "buy"
			} else if strings.Contains(edbCode, "sold") {
				suffix = "sold"
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取郑商所已存在信息失败,Err:" + err.Error()
				return
			}
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataZzMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取郑商所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataByZz(edbCode, suffix, startDate, "")
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataByZz Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataZzMaxOrMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromZhengzhouByIndexCode(edbCode, suffix)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取郑商所指标详情失败,Err:" + err.Error()
				return
			}
			var zzInfo *data_manage.BaseInfoFromZz
			if allInfo != nil {
				zzInfo = allInfo[0]
			}
			if zzInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "手"
				if suffix == "deal" {
					searchItem.EdbName = zzInfo.DealName
				} else if suffix == "buy" {
					searchItem.EdbName = zzInfo.BuyName
				} else {
					searchItem.EdbName = zzInfo.SoldName
				}
			}
		} else if source == utils.DATA_SOURCE_DL { //大商所
			var suffix string
			if strings.Contains(edbCode, "deal") {
				suffix = "deal"
			} else if strings.Contains(edbCode, "buy") {
				suffix = "buy"
			} else if strings.Contains(edbCode, "sold") {
				suffix = "sold"
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取大商所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataDlMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取大商所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataByDl(edbCode, suffix, startDate, "")
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataByDl Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataDlMaxOrMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromDalianByIndexCode(edbCode, suffix)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取大商所指标详情失败,Err:" + err.Error()
				return
			}
			var dlInfo *data_manage.BaseInfoFromDl
			if allInfo != nil {
				dlInfo = allInfo[0]
			}
			if dlInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "手"
				if suffix == "deal" {
					searchItem.EdbName = dlInfo.DealName
				} else if suffix == "buy" {
					searchItem.EdbName = dlInfo.BuyName
				} else {
					searchItem.EdbName = dlInfo.SoldName
				}
			}
		} else if source == utils.DATA_SOURCE_SH { //上期所
			var suffix string
			if strings.Contains(edbCode, "deal") {
				suffix = "deal"
			} else if strings.Contains(edbCode, "buy") {
				suffix = "buy"
			} else if strings.Contains(edbCode, "sold") {
				suffix = "sold"
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataShMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataBySh(edbCode, suffix, startDate, "")
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataBySh Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataShMaxOrMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromShByIndexCode(edbCode, suffix)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所指标详情失败,Err:" + err.Error()
				return
			}
			var shInfo *data_manage.BaseInfoFromSh
			if allInfo != nil {
				shInfo = allInfo[0]
			}
			if shInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "手"
				if suffix == "deal" {
					searchItem.EdbName = shInfo.DealName
				} else if suffix == "buy" {
					searchItem.EdbName = shInfo.BuyName
				} else {
					searchItem.EdbName = shInfo.SoldName
				}
			}
		} else if source == utils.DATA_SOURCE_CFFEX { //中金所
			var suffix string
			if strings.Contains(edbCode, "deal") {
				suffix = "deal"
			} else if strings.Contains(edbCode, "buy") {
				suffix = "buy"
			} else if strings.Contains(edbCode, "sold") {
				suffix = "sold"
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取中金所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataCffexMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取中金所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataByCffex(edbCode, suffix, startDate, "")
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataByCffex Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataCffexMaxOrMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromCffexByIndexCode(edbCode, suffix)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取中金所指标详情失败,Err:" + err.Error()
				return
			}
			var cffexInfo *data_manage.BaseInfoFromCffex
			if allInfo != nil {
				cffexInfo = allInfo[0]
			}
			if cffexInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "手"
				if suffix == "deal" {
					searchItem.EdbName = cffexInfo.DealName
				} else if suffix == "buy" {
					searchItem.EdbName = cffexInfo.BuyName
				} else {
					searchItem.EdbName = cffexInfo.SoldName
				}
			}
		} else if source == utils.DATA_SOURCE_SHFE { //上期能源
			var suffix string
			if strings.Contains(edbCode, "deal") {
				suffix = "deal"
			} else if strings.Contains(edbCode, "buy") {
				suffix = "buy"
			} else if strings.Contains(edbCode, "sold") {
				suffix = "sold"
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, utils.EDB_DATA_LIMIT)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期能源已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataShfeMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期能源日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				searchItem, err = data_manage.GetEdbDataByShfe(edbCode, suffix, startDate, "")
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,GetEdbDataByShfe Err:" + err.Error()
					return
				}
				if searchItem.StartDate == "" {
					minDate, maxDate, _ := data_manage.GetEdbDataShfeMaxOrMinDate(edbCode)
					searchItem.StartDate = minDate
					searchItem.EndDate = maxDate
				}
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromShfeByIndexCode(edbCode, suffix)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期能源指标详情失败,Err:" + err.Error()
				return
			}
			var shfeInfo *data_manage.BaseInfoFromShfe
			if allInfo != nil {
				shfeInfo = allInfo[0]
			}
			if shfeInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "手"
				if suffix == "deal" {
					searchItem.EdbName = shfeInfo.DealName
				} else if suffix == "buy" {
					searchItem.EdbName = shfeInfo.BuyName
				} else {
					searchItem.EdbName = shfeInfo.SoldName
				}
			}
		} else if source == utils.DATA_SOURCE_GIE { //欧洲天然气
			br.Msg = "无效的数据来源"
			return
		} else {
			br.Msg = "无效的数据来源"
			return
		}
		resp.Status = 2
		resp.SearchItem = searchItem
	}
}