eta_api/controllers/data_manage/edb_info.go

package data_manage

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/company"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/cross_variety"
	request2 "eta/eta_api/models/data_manage/excel/request"
	"eta/eta_api/models/data_manage/request"
	"eta/eta_api/models/data_manage/response"
	"eta/eta_api/models/system"
	"eta/eta_api/services"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data"
	"eta/eta_api/services/data/data_manage_permission"
	excel2 "eta/eta_api/services/data/excel"
	"eta/eta_api/services/data_stat"
	"eta/eta_api/services/elastic"
	etaTrialService "eta/eta_api/services/eta_trial"
	"eta/eta_api/utils"
	"fmt"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
)

// EdbInfoController 数据管理
type EdbInfoController struct {
	controllers.BaseAuthController
}

// EdbInfoSearch
// @Title 新增指标-查询指标信息接口
// @Description 新增指标-查询指标信息接口
// @Param   Source   query   int  true       "来源:1:同花顺,2:wind,3:彭博"
// @Param   SubSource   query   int  true       "子数据来源:0:经济数据库,1:日期序列"
// @Param   EdbCode   query   string  false       "指标编码/指标代码"
// @Param   StockCode   query   string  false       "证券代码"
// @Param   Frequency   query   string  false       "频度"
// @Success 200 {object} data_manage.EdbInfoSearchResp
// @router /edb_info/search [get]
func (this *EdbInfoController) EdbInfoSearch() {
	br := new(models.BaseResponse).Init()
	defer func() {
		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)
	subSource, _ := this.GetInt("SubSource")
	stockCode := this.GetString("StockCode")
	frequency := this.GetString("Frequency")

	extraPars := this.GetString("ExtraPars")
	extraPars = strings.TrimSpace(extraPars)

	if source <= 0 {
		br.Msg = "无效的数据来源"
		return
	}

	if edbCode == "" {
		br.Msg = "请输入指标ID"
		return
	}
	//如果是彭博财务指标，那么需要传入客户code
	if source == utils.DATA_SOURCE_PB_FINANCE {
		companyCode := this.GetString("CompanyCode")
		companyCode = strings.Trim(companyCode, "\t")
		companyCode = strings.Trim(companyCode, " ")
		companyCode = strings.Replace(companyCode, "\t", "", -1)

		// 如果财务数据，那么需要拼接上客户code
		edbCode = companyCode + "&&" + edbCode
	}
	resp := new(data_manage.EdbInfoSearchResp)
	//判断指标是否存在
	var item *data_manage.EdbInfo
	var err error
	if utils.InArrayByInt([]int{utils.DATA_SOURCE_GL, utils.DATA_SOURCE_MYSTEEL_CHEMICAL}, source) {
		//source = utils.DATA_SOURCE_MYSTEEL_CHEMICAL
		source, item, err = data.GetMySteelSourceByEdbCode(edbCode)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败,Err:" + err.Error()
			return
		}
	}

	if item == nil {
		item, err = data_manage.GetEdbInfoByEdbCode(source, edbCode)
		if err != nil {
			if !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败,Err:" + err.Error()
				return
			}
		}
	}

	var isAdd bool
	var isInEdb bool //是否在指标库中
	if item != nil && item.EdbInfoId > 0 {
		isInEdb = true //在指标库中
		resp.Status = 1
		searchItem := new(data_manage.EdbInfoSearch)
		searchItem.EdbCode = item.EdbCode
		searchItem.StartDate = item.StartDate
		searchItem.EndDate = item.EndDate
		searchItem.EdbName = item.EdbName
		resp.SearchItem = searchItem
		//查询目录
		resultList, _ := data_manage.GetClassifyAllByClassifyId(item.ClassifyId)
		resp.ClassifyList = resultList

		// 查询该指标是否有权限
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		conf, err := obj.GetByEdbInfoIdAndAdminId(this.SysUser.AdminId, item.EdbInfoId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取当前账号的不可见指标配置失败，err:" + err.Error()
			return
		}
		if conf != nil && conf.EdbInfoId > 0 {
			resp.Status = 3
		}
	} else {

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

		searchItem := new(data_manage.EdbInfoSearch)
		if source == utils.DATA_SOURCE_THS {
			fmt.Println("subSource:", subSource)
			if subSource == utils.DATA_SUB_SOURCE_EDB {
				dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_THS, subSource, utils.EDB_DATA_LIMIT)
				if err != nil && !utils.IsErrNoRow(err) {
					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.GetEdbDataThsMaxOrMinDate(edbCode)
					if err != nil {
						br.Msg = "获取失败"
						br.ErrMsg = "获取Ths日期信息失败,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.GetEdbDataByThs(edbCode, startDate, endDate)
					//if err != nil {
					//	br.Msg = "获取失败"
					//	br.ErrMsg = "获取失败,Err:" + err.Error()
					//	return
					//}
					respItem, err := data.AddEdbData(source, edbCode, frequency)
					if err != nil {
						br.Msg = "获取失败"
						br.ErrMsg = "获取失败,Err:" + err.Error()
						return
					}
					if respItem.Ret != 200 {
						br.Msg = "未搜索到该指标"
						br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
						return
					}
					isAdd = true
				}
			} else if subSource == utils.DATA_SUB_SOURCE_DATE {
				if stockCode == "" {
					br.Msg = "请输入证券代码"
					return
				}
				if edbCode == "" {
					br.Msg = "请输入指标代码"
					return
				}
				respItem, err := data.AddEdbDataThsDs(source, stockCode, edbCode, extraPars)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					if respItem.Ret == 421 {
						br.Msg = "该渠道已超过添加上限"
					} else if respItem.Ret == 4052 {
						br.Msg = "该指标已下架"
					} else {
						br.Msg = "未搜索到该指标"
					}
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			} else {
				br.Msg = "无效的渠道来源"
				return
			}
		} else if source == utils.DATA_SOURCE_WIND {
			fmt.Println("subSource:", subSource)
			if subSource == utils.DATA_SUB_SOURCE_EDB {
				dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_WIND, subSource, utils.EDB_DATA_LIMIT)
				if err != nil && !utils.IsErrNoRow(err) {
					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
					//}
					respItem, err := data.AddEdbData(source, edbCode, frequency)
					if err != nil {
						br.Msg = "获取失败"
						br.ErrMsg = "获取失败,Err:" + err.Error()
						return
					}
					if respItem.Ret != 200 {
						if respItem.Ret == 421 {
							br.Msg = "该渠道已超过添加上限"
						} else if respItem.Ret == 4052 {
							br.Msg = "该指标已下架"
						} else {
							br.Msg = "未搜索到该指标"
						}
						br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
						return
					}
					isAdd = true
				}
			} else if subSource == utils.DATA_SUB_SOURCE_DATE {
				if stockCode == "" {
					br.Msg = "请输入证券代码"
					return
				}
				if edbCode == "" {
					br.Msg = "请输入指标代码"
					return
				}
				respItem, err := data.AddEdbDataWindWsd(source, stockCode, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					if respItem.Ret == 421 {
						br.Msg = "该渠道已超过添加上限"
					} else if respItem.Ret == 4052 {
						br.Msg = "该指标已下架"
					} else {
						br.Msg = "未搜索到该指标"
					}
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			} else {
				br.Msg = "无效的渠道来源"
				return
			}
		} else if source == utils.DATA_SOURCE_PB || source == utils.DATA_SOURCE_PB_FINANCE {
			fmt.Println("pb data exist")
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
		} else if source == utils.DATA_SOURCE_MANUAL { //手工数据指标
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_MANUAL, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			manualInfo, err := models.GetEdbinfoByTradeCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				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, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			lzInfo, err := data_manage.GetLongzhongSurveyProductByCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				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, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			smmInfo, err := data_manage.GetBaseFromSmmIndexByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				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, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			glInfo, err := data_manage.GetGlIndexByCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				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"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromZhengzhouByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取郑商所指标详情失败,Err:" + err.Error()
				return
			}
			var zzInfo *data_manage.BaseInfoFromZz
			if allInfo != nil && len(allInfo) > 0 {
				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"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromDalianByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取大商所指标详情失败,Err:" + err.Error()
				return
			}
			var dlInfo *data_manage.BaseInfoFromDl
			if allInfo != nil && len(allInfo) > 0 {
				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"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromShByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所指标详情失败,Err:" + err.Error()
				return
			}
			var shInfo *data_manage.BaseInfoFromSh
			if allInfo != nil && len(allInfo) > 0 {
				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"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromCffexByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取中金所指标详情失败,Err:" + err.Error()
				return
			}
			var cffexInfo *data_manage.BaseInfoFromCffex
			if allInfo != nil && len(allInfo) > 0 {
				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"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromShfeByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期能源指标详情失败,Err:" + err.Error()
				return
			}
			var shfeInfo *data_manage.BaseInfoFromShfe
			if allInfo != nil && len(allInfo) > 0 {
				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 { //欧洲天然气
			var suffix string
			l := len(edbCode)
			if strings.Contains(edbCode[l-2:], "GS") {
				suffix = "GS"
			} else if strings.Contains(edbCode[l-2:], "CF") {
				suffix = "CF"
			} else if strings.Contains(edbCode[l-1:], "T") {
				suffix = "T"
			} else if strings.Contains(edbCode[l-2:], "In") {
				suffix = "In"
			} else if strings.Contains(edbCode[l-3:], "Out") {
				suffix = "Out"
			} else if strings.Contains(edbCode[l-3:], "WGV") {
				suffix = "WGV"
			} else if strings.Contains(edbCode[l-2:], "IC") {
				suffix = "IC"
			} else if strings.Contains(edbCode[l-2:], "WC") {
				suffix = "WC"
			} else if strings.Contains(edbCode[l-1:], "F") {
				suffix = "F"
			} else if strings.Contains(edbCode[l-1:], "C") {
				suffix = "C"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取欧洲天然气已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataGieMaxOrMinDate(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.GetEdbDataByGie(edbCode, suffix, startDate, "")
				//if err != nil {
				//	br.Msg = "获取失败"
				//	br.ErrMsg = "获取失败,GetEdbDataByGie Err:" + err.Error()
				//	return
				//}
				//if searchItem.StartDate == "" {
				//	minDate, maxDate, _ := data_manage.GetEdbDataGieMaxOrMinDate(edbCode)
				//	searchItem.StartDate = minDate
				//	searchItem.EndDate = maxDate
				//}

				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseFromEicDataAllByIndexCodeV2(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取欧洲天然气指标详情失败,Err:" + err.Error()
				return
			}
			var eicInfo *data_manage.BaseFromTradeEicIndexV2
			if allInfo != nil && len(allInfo) > 0 {
				eicInfo = allInfo[0]
			}
			var name string
			if eicInfo != nil {
				searchItem.Frequency = "日度"
				if suffix == "GS" {
					name = eicInfo.Name + "_gas_in_storage"
					searchItem.EdbName = name
					searchItem.Unit = "TWh"
				} else if suffix == "C" {
					name = eicInfo.Name + "_consumption"
					searchItem.EdbName = name
					searchItem.Unit = "TWh"
				} else if suffix == "CF" {
					name = eicInfo.Name + "_consumption_full"
					searchItem.EdbName = name
					searchItem.Unit = "百分比"
				} else if suffix == "F" {
					name = eicInfo.Name + "_full"
					searchItem.EdbName = name
					searchItem.Unit = "百分比"
				} else if suffix == "T" {
					name = eicInfo.Name + "_trend"
					searchItem.EdbName = name
					searchItem.Unit = "百分比"
				} else if suffix == "In" {
					name = eicInfo.Name + "_injection"
					searchItem.EdbName = name
					searchItem.Unit = "GWH/d"
				} else if suffix == "Out" {
					name = eicInfo.Name + "_withdrawal"
					searchItem.EdbName = name
					searchItem.Unit = "GWH/d"
				} else if suffix == "WGV" {
					name = eicInfo.Name + "_working_gas_volume"
					searchItem.EdbName = name
					searchItem.Unit = "TWh"
				} else if suffix == "IC" {
					name = eicInfo.Name + "_injection_capacity"
					searchItem.EdbName = name
					searchItem.Unit = "GWh/d"
				} else if suffix == "WC" {
					name = eicInfo.Name + "_withdrawal_capacity"
					searchItem.EdbName = name
					searchItem.Unit = "GWh/d"
				}
			}
		} else if source == utils.DATA_SOURCE_LT {
			fmt.Println("lt data exist")
			if strings.Contains(edbCode, "=") {
				br.Msg = "暂不支持编码中含有=的指标"
				br.ErrMsg = "暂不支持编码中含有=的指标"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_LT, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取 lt 已存在信息失败,Err:" + err.Error()
				return
			}
			fmt.Println("lt dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				edbInfoMaxAndMinInfo, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取lt日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = edbInfoMaxAndMinInfo.MinDate
				searchItem.EndDate = edbInfoMaxAndMinInfo.MaxDate
			} else {
				//endDate := dateNow.Format(utils.FormatDate)
				//searchItem, err = data.GetEdbDataByLt(edbCode, startDate, endDate)
				//if err != nil {
				//	br.Msg = "获取失败"
				//	br.ErrMsg = "lt 获取失败,Err:" + err.Error()
				//	return
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = respItem.Msg
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
		} else if source == utils.DATA_SOURCE_COAL { //中国煤炭市场网
			var suffix string
			if strings.Contains(edbCode, "jsm") {
				suffix = "jsm_index"
			} else if strings.Contains(edbCode, "company") {
				suffix = "company_index"
			} else if strings.Contains(edbCode, "firm") {
				suffix = "firm_index"
			} else if strings.Contains(edbCode, "coastal") {
				suffix = "coastal_index"
			} else if strings.Contains(edbCode, "inland") {
				suffix = "inland_index"
			} else {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = "指标code异常"
				return
			}
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取煤炭网已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataCoalMaxOrMinDate(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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			allInfo, err := data_manage.GetBaseInfoFromCoalByIndexCode(edbCode, suffix)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取煤炭网指标详情失败,Err:" + err.Error()
				return
			}
			var coalInfo *data_manage.BaseInfoFromCoal
			if allInfo != nil && len(allInfo) > 0 {
				coalInfo = allInfo[0]
			}
			if coalInfo != nil {
				searchItem.Frequency = coalInfo.Frequency
				searchItem.Unit = coalInfo.Unit
				searchItem.EdbName = coalInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_GOOGLE_TRAVEL { //谷歌出行数据
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取煤炭网已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				item, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取煤炭网日期信息失败,Err:" + err.Error()
					return
				}
				if item != nil {
					searchItem.DataList = dataItems
					searchItem.StartDate = item.MinDate
					searchItem.EndDate = item.MaxDate
				}
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
		} else if source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL { //钢联化工
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataMysteelChemicalMaxOrMinDate(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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			glInfo, err := data_manage.GetBaseFromMysteelChemicalIndexByCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联指标详情失败,Err:" + err.Error()
				return
			}
			if glInfo != nil {
				searchItem.Frequency = glInfo.Frequency
				searchItem.Unit = glInfo.Unit
				searchItem.EdbName = glInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_EIA_STEO { //eia steo报告
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				item, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取eia steo日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = item.MinDate
				searchItem.EndDate = item.MaxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			eiasteoInfo, err := data_manage.GetBaseFromEiaSteoIndexByCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联指标详情失败,Err:" + err.Error()
				return
			}
			if eiasteoInfo != nil {
				searchItem.Frequency = eiasteoInfo.Frequency
				searchItem.Unit = eiasteoInfo.Unit
				searchItem.EdbName = eiasteoInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_COM_TRADE { // un数据源
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取联合国商品贸易数据已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				item, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取联合国商品贸易数据日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = item.MinDate
				searchItem.EndDate = item.MaxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			eiasteoInfo, err := data_manage.GetComTradeIndex(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取钢联指标详情失败,Err:" + err.Error()
				return
			}
			if eiasteoInfo != nil {
				//eiasteoInfo.
				if eiasteoInfo.Type <= 2 {
					searchItem.Frequency = `年度`
				} else {
					searchItem.Frequency = `月度`
				}
				if eiasteoInfo.Type == 1 || eiasteoInfo.Type == 3 {
					searchItem.Unit = "美元"
				} else {
					searchItem.Unit = "千克"
				}
				searchItem.EdbName = eiasteoInfo.Name
			}
		} else if source == utils.DATA_SOURCE_SCI { //卓创数据（红桃三）
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取SCI已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataSciMaxAndMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取SCI日期信息失败,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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			smmInfo, err := data_manage.GetBaseFromSciIndexByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Sci指标详情失败,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_BAIINFO { //百川盈孚
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取BAIINFO已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataBaiinfoMaxAndMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取BAIINFO日期信息失败,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
				//}
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

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

		} else if source == utils.DATA_SOURCE_NATIONAL_STATISTICS { // 国家统计局
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取国家统计局已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				item, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取国家统计局日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = item.MinDate
				searchItem.EndDate = item.MaxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			nationalInfo, err := data_manage.GetBaseFromNationalStatisticsIndexByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取国家统计局详情失败,Err:" + err.Error()
				return
			}
			if nationalInfo != nil {
				searchItem.Frequency = nationalInfo.Frequency
				searchItem.Unit = nationalInfo.Unit
				searchItem.EdbName = fmt.Sprintf("%s%s", nationalInfo.Reg, nationalInfo.IndexName)
			}
		} else if source == utils.DATA_SOURCE_FUBAO { //数宝
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_FUBAO, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取Fubao已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("fubao len:", len(dataItems))
			if len(dataItems) > 0 {
				fmt.Println("fubao data exist")
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataFubaoMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取Ths日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败," + respItem.Msg
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标," + respItem.Msg
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
		} else if source == utils.DATA_SOURCE_GFEX { //广州期货交易所
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataGzMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			indexInfo, err := data_manage.GetBaseInfoFromGzByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所指标详情失败,Err:" + err.Error()
				return
			}

			if indexInfo != nil {
				searchItem.Frequency = indexInfo.Frequency
				searchItem.Unit = indexInfo.Unit
				searchItem.EdbName = indexInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_ICPI { //消费者指数
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataIcpiMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			indexInfo, err := data_manage.GetBaseInfoFromIcpiByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所指标详情失败,Err:" + err.Error()
				return
			}

			if indexInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "%"
				searchItem.EdbName = indexInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_BUSINESS { //自有数据
			indexObj := data_manage.BaseFromBusinessIndex{}
			indexInfo, err := indexObj.GetDetailByEdbCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取自有数据指标信息失败,Err:" + err.Error()
				return
			}

			_, tmpDataList, err := data.GetPageBaseBusinessIndexData(edbCode, 1, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取自有数据已存在信息失败,Err:" + err.Error()
				return
			}
			dataItems := make([]*data_manage.EdbInfoSearchData, 0)
			for _, v := range tmpDataList {
				dataItems = append(dataItems, &data_manage.EdbInfoSearchData{
					DataTime: v.DataTime,
					Value:    v.Value,
				})
			}
			searchItem.EdbCode = edbCode
			searchItem.DataList = dataItems
			searchItem.StartDate = indexInfo.StartDate.Format(utils.FormatDate)
			searchItem.EndDate = indexInfo.EndDate.Format(utils.FormatDate)
			searchItem.Frequency = indexInfo.Frequency
			searchItem.Unit = indexInfo.Unit
			searchItem.EdbName = indexInfo.IndexName
		} else if source == utils.DATA_SOURCE_SCI99 { //卓创资讯
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataSci99MaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			indexInfo, err := data_manage.GetBaseInfoFromSci99ByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取上期所指标详情失败,Err:" + err.Error()
				return
			}

			if indexInfo != nil {
				searchItem.Frequency = "日度"
				searchItem.Unit = "元/吨"
				searchItem.EdbName = indexInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_SCI_HQ {
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取SCIHQ已存在信息失败,Err:" + err.Error()
				return
			}

			fmt.Println("dataItems:", len(dataItems))
			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataSciHqMaxAndMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取SCIHQ日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}
			//获取指标信息
			sciHqInfo, err := data_manage.GetSciHqIndexByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取SciHq指标详情失败,Err:" + err.Error()
				return
			}
			if sciHqInfo != nil {
				searchItem.Frequency = sciHqInfo.Frequency
				searchItem.Unit = sciHqInfo.Unit
				searchItem.EdbName = sciHqInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_OILCHEM { //隆众资讯
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取隆众资讯已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataOilchemMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取上期所日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			indexInfo, err := data_manage.GetBaseInfoFromOilchemByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取隆众资讯指标详情失败,Err:" + err.Error()
				return
			}

			if indexInfo != nil {
				searchItem.Frequency = indexInfo.Frequency
				searchItem.Unit = indexInfo.Unit
				searchItem.EdbName = indexInfo.IndexName
			}
		} else if source == utils.DATA_SOURCE_HISUGAR { //泛糖科技
			dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取泛糖科技已存在信息失败,Err:" + err.Error()
				return
			}

			if len(dataItems) > 0 {
				searchItem.EdbCode = edbCode
				minDate, maxDate, err := data_manage.GetEdbDataHisugarMaxOrMinDate(edbCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取泛糖科技日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.DataList = dataItems
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
			} else {
				respItem, err := data.AddEdbData(source, edbCode, frequency)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + err.Error()
					return
				}
				if respItem.Ret != 200 {
					br.Msg = "未搜索到该指标"
					br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
					return
				}
				isAdd = true
			}

			//获取指标信息
			indexInfo, err := data_manage.GetBaseInfoFromHisugarByIndexCode(edbCode)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取泛糖科技指标详情失败,Err:" + err.Error()
				return
			}

			if indexInfo != nil {
				searchItem.Frequency = indexInfo.Frequency
				searchItem.Unit = indexInfo.Unit
				searchItem.EdbName = indexInfo.IndexName
			}
		} else {
			// 代码中没有的来源那么从edb_source中找是否有对应的
			sourceItem := data_manage.EdbSourceIdMap[source]
			if sourceItem == nil {
				br.Msg = "无效指标来源"
				return
			}

			// 获取指标数据
			dataList, e := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取指标数据失败, Err: " + e.Error()
				return
			}
			if len(dataList) > 0 {
				searchItem.EdbCode = edbCode
				searchItem.DataList = dataList
				// 获取最大最小值
				edbInfoMaxAndMinInfo, e := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if e != nil && !utils.IsErrNoRow(e) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据失败, GetEdbInfoMaxAndMinInfo Err:" + e.Error()
					return
				}
				if edbInfoMaxAndMinInfo != nil {
					searchItem.StartDate = edbInfoMaxAndMinInfo.MinDate
					searchItem.EndDate = edbInfoMaxAndMinInfo.MaxDate
				}
			} else {
				// 新增指标数据
				addRes, e := data.AddEdbData(source, edbCode, frequency)
				if e != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败,Err:" + e.Error()
					return
				}
				if addRes == nil {
					br.Msg = "获取失败"
					br.ErrMsg = "新增指标数据失败, addRes nil"
					return
				}
				if addRes.Ret != 200 {
					br.Msg = "未搜索到该指标, " + addRes.Msg
					//br.ErrMsg = addRes.ErrMsg + ";EdbCode:" + edbCode
					br.Success = true
					return
				}
				isAdd = true
			}
			// 查询基本信息
			baseIndexInfo, tErr := data_manage.GetBaseIndexInfoByEdbCode(edbCode, source)
			if tErr == nil {
				searchItem.EdbName = baseIndexInfo.IndexName
				searchItem.Frequency = baseIndexInfo.Frequency
				searchItem.Unit = baseIndexInfo.Unit
			}
			// 指标来源于桥接服务: 桥接服务获取指标取频度信息等
			if sourceItem.BridgeFlag != "" {
				bridgeOb := data.InitBridgeOB(sourceItem.BridgeFlag)
				if bridgeOb != nil {
					var r data.GetIndexFromBridgeReq
					r.IndexCode = edbCode
					r.Source = sourceItem.EdbSourceId
					r.SourceExtend = sourceItem.SourceExtend
					r.IndexCodeRequired = sourceItem.EdbCodeRequired
					bridgeIndex, e := bridgeOb.GetIndex(r)
					if e != nil {
						br.Msg = "获取失败"
						br.ErrMsg = "桥接服务获取指标信息失败, Err: " + e.Error()
						return
					}
					searchItem.EdbName = bridgeIndex.IndexName
					searchItem.Frequency = bridgeIndex.Frequency
					searchItem.Unit = bridgeIndex.Unit
				}
			}
		}
		if isAdd {
			if subSource == utils.DATA_SUB_SOURCE_DATE {
				if source == utils.DATA_SOURCE_WIND {
					//wsdData := windWsdRespItem.Data
					//var buf bytes.Buffer
					//// 创建一个encoder并指定目标为buf
					//enc := gob.NewEncoder(&buf)
					//
					//// 将data编码到buf中
					//err = enc.Encode(wsdData)
					//if err != nil {
					//	br.Msg = "获取失败"
					//	br.ErrMsg = "获取数据失败,wind wsd encoding GOB Err:" + err.Error()
					//	return
					//}
					//
					//wsdDataMap := make(map[string]map[string]interface{})
					//err = json.Unmarshal(buf.Bytes(), &wsdDataMap)
					//if err != nil {
					//	br.Msg = "获取失败"
					//	br.ErrMsg = "获取数据失败,wind wsd json.Unmarshal Err:" + err.Error()
					//	return
					//}
					//
					//stockList := make([]*data_manage.StockInfo, 0)
					//
					//dataList := make([]*data_manage.EdbInfoSearchData, 0)
					//for wk, wv := range wsdDataMap {
					//	for vk, vv := range wv {
					//		wkInt, err := strconv.ParseInt(wk, 10, 64)
					//		if err != nil {
					//			br.Msg = "获取失败"
					//			br.ErrMsg = "获取数据失败,转换日期类型失败 Err:" + err.Error()
					//			return
					//		}
					//
					//		vk = strings.ToLower(vk)
					//		wkInt = wkInt / 1000
					//		t := time.Unix(wkInt, 0)
					//		dateTime := t.Format(utils.FormatDate)
					//		//saveVal := utils.SubFloatToString(val, 20)
					//		if vv == nil {
					//			continue
					//		}
					//		var saveVal string
					//		switch vt := vv.(type) {
					//		case int:
					//			saveVal = strconv.Itoa(vt)
					//		case float64:
					//			saveVal = utils.SubFloatToFloatStr(vt, 20)
					//		case string:
					//			saveVal = vt
					//		}
					//
					//		dataItem := new(data_manage.EdbInfoSearchData)
					//		dataItem.Value = saveVal
					//		dataItem.DataTime = dateTime
					//		dataList = append(dataList, dataItem)
					//		if len(dataList) >= 10 {
					//			break
					//		}
					//	}
					//}
					//searchItem.StockList = stockList

					stockList := make([]*data_manage.StockInfo, 0)
					edbCodeArr := strings.Split(edbCode, ",")
					for _, v := range edbCodeArr {
						indexCode := utils.WindDbWsd + stockCode + v

						dataList, err := data_manage.GetEdbDataAllByEdbCodeAndSubSource(indexCode, source, utils.DATA_SUB_SOURCE_DATE, utils.EDB_DATA_LIMIT)
						if err != nil && !utils.IsErrNoRow(err) {
							br.Msg = "获取失败"
							br.ErrMsg = "获取数据失败,GetEdbDataAllByEdbCode Err:" + err.Error()
							return
						}

						stockInfo := new(data_manage.StockInfo)
						stockInfo.StockCode = stockCode
						stockInfo.EdbCode = v
						stockInfo.DataList = dataList
						stockList = append(stockList, stockInfo)
					}
					searchItem.StockList = stockList
				} else if source == utils.DATA_SOURCE_THS {
					stockList := make([]*data_manage.StockInfo, 0)
					edbCodeArr := strings.Split(edbCode, ",")
					for _, v := range edbCodeArr {
						indexCode := utils.ThsDs + stockCode + v

						dataList, err := data_manage.GetEdbDataAllByEdbCodeAndSubSource(indexCode, source, utils.DATA_SUB_SOURCE_DATE, utils.EDB_DATA_LIMIT)
						if err != nil && !utils.IsErrNoRow(err) {
							br.Msg = "获取失败"
							br.ErrMsg = "获取数据失败,GetEdbDataAllByEdbCode Err:" + err.Error()
							return
						}

						stockInfo := new(data_manage.StockInfo)
						stockInfo.StockCode = stockCode
						stockInfo.EdbCode = v
						stockInfo.DataList = dataList
						stockList = append(stockList, stockInfo)
					}
					searchItem.StockList = stockList
				} else {
					br.Msg = "来源错误"
					br.ErrMsg = "来源错误"
					return
				}
			} else {
				dataList, err := data_manage.GetEdbDataAllByEdbCode(edbCode, source, subSource, utils.EDB_DATA_LIMIT)
				if err != nil && !utils.IsErrNoRow(err) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据失败,GetEdbDataAllByEdbCode Err:" + err.Error()
					return
				}
				searchItem.DataList = dataList

				edbInfoMaxAndMinInfo, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
				if err != nil && !utils.IsErrNoRow(err) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error()
					return
				}
				searchItem.EdbCode = edbCode
				searchItem.DataList = dataList
				if edbInfoMaxAndMinInfo != nil {
					searchItem.StartDate = edbInfoMaxAndMinInfo.MinDate
					searchItem.EndDate = edbInfoMaxAndMinInfo.MaxDate
				}

				//edb指标信息
				edbInfoItem, err := data_manage.GetEdbInfoByEdbCode(source, edbCode)
				if edbInfoItem != nil && edbInfoItem.EdbInfoId > 0 {
					searchItem.EdbName = edbInfoItem.EdbName
				}
			}
		}
		resp.Status = 2
		resp.SearchItem = searchItem
	}

	//如果不在指标库中，且不是新增
	if !isInEdb && !isAdd {
		if resp.SearchItem.DataList == nil || len(resp.SearchItem.DataList) <= 0 {
			br.Msg = "目标指标无有效值，请重新搜索"
			br.Data = resp
			return
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoList
// @Title 指标列表接口
// @Description 指标列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   EdbInfoId   query   int  true       "指标id"
// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
// @Success 200 {object} data_manage.EdbInfoListResp
// @router /edb_info/list [get]
func (this *EdbInfoController) EdbInfoList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	edbInfoId, _ := this.GetInt("EdbInfoId")
	keyWord := this.GetString("KeyWord")

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	var condition string
	var pars []interface{}

	//if edbInfoId <= 0 && keyWord == "" {
	//	br.Msg = "参数错误"
	//	return
	//}
	// 指标类型，0：普通指标，1：预测指标
	condition += " AND edb_info_type=? "
	pars = append(pars, 0)

	if edbInfoId > 0 {
		condition += " AND edb_info_id=? "
		pars = append(pars, edbInfoId)

		// 获取当前账号的不可见指标配置
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		conf, err := obj.GetByEdbInfoIdAndAdminId(this.SysUser.AdminId, edbInfoId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取当前账号的不可见指标配置失败，err:" + err.Error()
			return
		}
		if conf != nil && conf.Id > 0 {
			br.Msg = "无权限，请联系管理员"
			br.IsSendEmail = false
			return
		}
	}

	if keyWord != "" {
		condition += ` AND  ( edb_code LIKE '%` + keyWord + `%'  OR  edb_name LIKE '%` + keyWord + `%' )`
		//pars = append(pars, keyWord)
		//pars = append(pars, keyWord)
	}

	resp := new(data_manage.EdbInfoListResp)
	if condition == "" {
		item := new(data_manage.EdbInfoList)
		resp.Paging = page
		resp.Item = item
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	//获取指标信息
	edbInfoItem, err := data_manage.GetEdbInfoByCondition(condition, pars)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Success = true
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	if edbInfoItem == nil || (err != nil && utils.IsErrNoRow(err)) {
		item := new(data_manage.EdbInfoList)
		resp.Paging = page
		resp.Item = item
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	//获取英文频度
	edbInfoItem.FrequencyEn = data.GetFrequencyEn(edbInfoItem.Frequency)
	// 获取是否供应商停更
	edbInfoItem.IsSupplierStop = data.GetIsSupplierStop(edbInfoItem.Source, edbInfoItem.EdbCode)
	relation, err := data.GetEdbRelationListById(edbInfoItem.EdbInfoId, edbInfoItem.Source)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取指标引用信息失败"
		br.ErrMsg = "获取指标引用信息失败,Err:" + err.Error()
		return
	}
	if relation != nil && relation.RelationNum > 0 {
		edbInfoItem.IsRelation = true
	}
	//查询目录
	classifyList, err, errMsg := data.GetFullClassifyByClassifyId(edbInfoItem.ClassifyId)
	if err != nil {
		br.Msg = err.Error()
		br.ErrMsg = errMsg
		return
	}

	// 权限校验
	{
		var currClassify *data_manage.EdbClassifyIdItems
		for _, v := range classifyList {
			if edbInfoItem.ClassifyId == v.ClassifyId {
				currClassify = v
				break
			}
		}
		if currClassify != nil {
			edbInfoItem.HaveOperaAuth, err = data_manage_permission.CheckEdbPermission(edbInfoItem.IsJoinPermission, currClassify.IsJoinPermission, this.SysUser.AdminId, edbInfoItem.EdbInfoId, edbInfoItem.ClassifyId)
			if err != nil {
				br.Msg = err.Error()
				br.ErrMsg = "校验指标权限失败，err:" + err.Error()
				return
			}
		}
	}

	// 按钮校验
	button := data.GetEdbOpButton(this.SysUser, edbInfoItem.SysUserId, edbInfoItem.EdbType, edbInfoItem.EdbInfoType, edbInfoItem.HaveOperaAuth)
	button.AddButton = false
	edbInfoItem.Button = button
	edbInfoItem.DataList = make([]*data_manage.EdbData, 0)

	// 如果有数据权限，那么就去获取指标数据
	if edbInfoItem.HaveOperaAuth {
		dataCount, dataList, err := data.GetPageData(edbInfoItem.EdbInfoId, edbInfoItem.Source, edbInfoItem.SubSource, "", startSize, pageSize)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
			return
		}
		page = paging.GetPaging(currentIndex, pageSize, dataCount)
		edbInfoItem.DataList = dataList
	}

	// 获取指标插入配置
	{
		edbDataInsertConfig, err := data_manage.GetEdbDataInsertConfigByEdbId(edbInfoId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标数据失败,Err:" + err.Error()
			return
		}
		if edbDataInsertConfig != nil && edbDataInsertConfig.EdbInfoId > 0 {
			edbInfoItem.DataInsertConfig.Date = edbDataInsertConfig.Date.Format(utils.FormatDate)
			edbInfoItem.DataInsertConfig.RealDate = edbDataInsertConfig.RealDate.Format(utils.FormatDate)
			edbInfoItem.DataInsertConfig.Value = edbDataInsertConfig.Value
		}
	}

	//是否展示英文标识
	edbInfoItem.IsEnEdb = data.CheckIsEnEdb(edbInfoItem.EdbNameEn, edbInfoItem.Unit, edbInfoItem.UnitEn)

	resp.Paging = page
	resp.Item = edbInfoItem
	resp.ClassifyList = classifyList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoAdd
// @Title 新增指标接口
// @Description 新增指标接口
// @Param	request	body data_manage.AddEdbInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /edb_info/add [post]
func (this *EdbInfoController) EdbInfoAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	var req data_manage.AddEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	source := req.Source
	if source <= 0 {
		br.Msg = "无效的数据来源"
		return
	}

	req.EdbName = strings.Trim(req.EdbName, " ")
	req.EdbCode = strings.Trim(req.EdbCode, " ")

	if req.EdbCode == "" {
		br.Msg = "指标ID不能为空"
		return
	}

	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	//if req.StartDate == "" || req.EndDate == "" {
	//	br.Msg = "日期不能为空"
	//	return
	//}

	// 兼容钢联与钢联化工数据
	if utils.InArrayByInt([]int{utils.DATA_SOURCE_GL, utils.DATA_SOURCE_MYSTEEL_CHEMICAL}, source) {
		// 如果是钢联的话，那么就先判断是不是存在钢联化工
		tmpInfo, err := data_manage.GetBaseFromMysteelChemicalIndexByCode(req.EdbCode)
		if err != nil {
			if !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败,Err:" + err.Error()
				return
			}
		}
		if tmpInfo != nil {
			source = utils.DATA_SOURCE_MYSTEEL_CHEMICAL
			req.Source = utils.DATA_SOURCE_MYSTEEL_CHEMICAL
		} else {
			source = utils.DATA_SOURCE_GL
			req.Source = utils.DATA_SOURCE_GL
		}
	}

	// 指标入库
	edbInfo, err, errMsg, isSendEmail := data.EdbInfoAdd(source, utils.DATA_SUB_SOURCE_EDB, req.ClassifyId, req.EdbCode, req.EdbName, req.Frequency, req.Unit, req.StartDate, req.EndDate, sysUser.AdminId, sysUser.RealName, this.Lang)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	// 试用平台更新用户累计新增指标数
	adminItem, e := system.GetSysAdminById(sysUser.AdminId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取系统用户数据失败，Err:" + err.Error()
		return
	}
	if utils.BusinessCode == utils.BusinessCodeSandbox && adminItem.DepartmentName == "ETA试用客户" {
		go func() {
			var r etaTrialService.EtaTrialUserReq
			r.Mobile = adminItem.Mobile
			_, _ = etaTrialService.UpdateUserIndexNum(r)
		}()
	}

	//新增操作日志
	{
		// 添加钢联指标更新日志
		if edbInfo.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
			go data_stat.AddEdbInfoUpdateLog(edbInfo.EdbInfoId, 1, "", sysUser, 2)
		}

		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "新增指标"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	// 更新es
	go data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	resp := new(data_manage.AddEdbInfoResp)
	resp.EdbInfoId = edbInfo.EdbInfoId
	resp.UniqueCode = edbInfo.UniqueCode
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// EdbInfoEdit
// @Title 编辑指标接口
// @Description 编辑指标接口
// @Success 200 {object} data_manage.EditEdbInfoReq
// @router /edb_info/edit [post]
func (this *EdbInfoController) EdbInfoEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.EditEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	req.EdbName = strings.Trim(req.EdbName, " ")

	if req.EdbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "指标id小于等于0"
		return
	}

	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "修改失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	// 记录旧的指标基本信息
	oldEdbName := edbInfo.EdbName
	oldFrequency := edbInfo.Frequency
	oldUnit := edbInfo.Unit

	var haveOperaAuth bool
	// 权限校验
	{
		haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, this.SysUser.AdminId)
		if err != nil {
			br.Msg = err.Error()
			br.ErrMsg = "校验指标权限失败，err:" + err.Error()
			return
		}
	}

	// 编辑权限校验
	button := data.GetEdbOpButton(this.SysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
	if !button.OpButton {
		br.Msg = "无权限操作"
		br.IsSendEmail = false
		return
	}

	//判断指标名称是否存在
	var condition string
	var pars []interface{}

	condition += " AND edb_info_id<>? "
	pars = append(pars, req.EdbInfoId)

	//condition += " AND source=? "
	//pars = append(pars, edbInfo.Source)

	updateCols := make([]string, 0)
	switch this.Lang {
	case utils.EnLangVersion:
		condition += " AND edb_name_en = ? "
		edbInfo.EdbNameEn = req.EdbName
		edbInfo.Frequency = req.Frequency
		edbInfo.UnitEn = req.Unit
		edbInfo.ClassifyId = req.ClassifyId
		updateCols = append(updateCols, "EdbNameEn", "Frequency", "UnitEn", "ClassifyId")
	default:
		condition += " AND edb_name=? "
		edbInfo.EdbName = req.EdbName
		edbInfo.EdbNameSource = req.EdbName
		edbInfo.Frequency = req.Frequency
		edbInfo.Unit = req.Unit
		edbInfo.ClassifyId = req.ClassifyId
		updateCols = append(updateCols, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId")
	}
	pars = append(pars, req.EdbName)

	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if count > 0 {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	if len(updateCols) > 0 {
		err = edbInfo.Update(updateCols)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "修改失败,Err:" + err.Error()
			return
		}
	}

	//处理同名指标
	//{
	//	edbNameList, err := data_manage.GetEdbInfoByName(req.EdbName)
	//	if err != nil {
	//		br.Msg = "保存失败"
	//		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
	//		return
	//	}
	//	if len(edbNameList) >= 2 {
	//		for _, v := range edbNameList {
	//			edbName := v.EdbName + "(" + v.SourceName + ")"
	//			err = data_manage.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
	//			if err != nil {
	//				br.Msg = "保存失败"
	//				br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
	//				return
	//			}
	//		}
	//	}
	//}

	// 新增保存记录日志
	oldEdbInfo := new(data_manage.EdbInfo)
	oldEdbInfo.EdbInfoId = edbInfo.EdbInfoId
	oldEdbInfo.EdbName = oldEdbName
	oldEdbInfo.Frequency = oldFrequency
	oldEdbInfo.Unit = oldUnit
	newEdbInfoRecord := new(data_manage.EdbInfoEditRecord)
	newEdbInfoRecord.EdbName = req.EdbName
	newEdbInfoRecord.Frequency = req.Frequency
	newEdbInfoRecord.Unit = req.Unit
	newEdbInfoRecord.OperateUserId = sysUser.AdminId
	newEdbInfoRecord.OperateUserRealName = sysUser.RealName
	go data.AddEditEdbInfoRcord(oldEdbInfo, newEdbInfoRecord)

	//新增操作日志
	{
		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "编辑指标"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	//添加es
	data.AddOrEditEdbInfoToEs(req.EdbInfoId)

	switch this.Lang {
	case utils.EnLangVersion:
		// 修改关联的预测指标基础信息
		go data.ModifyPredictEdbEnBaseInfoBySourceEdb(edbInfo, req.Unit)
	default:
		// 修改关联的预测指标基础信息
		go data.ModifyPredictEdbBaseInfoBySourceEdb(edbInfo, req.Frequency, req.Unit)
	}

	// 添加钢联指标更新日志
	if edbInfo.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
		if edbInfo.EdbName != req.EdbName || edbInfo.Frequency != req.Frequency || edbInfo.Unit != req.Unit {
			go data_stat.AddEdbInfoUpdateLog(req.EdbInfoId, 1, "", sysUser, 1)
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// EdbEnInfoEdit
// @Title 编辑指标英文信息接口
// @Description 编辑指标英文信息接口
// @Success 200 {object} data_manage.EditEdbEnInfoReq
// @router /edb_info/en/edit [post]
func (this *EdbInfoController) EdbEnInfoEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.EditEdbEnInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	req.EdbNameEn = strings.Trim(req.EdbNameEn, " ")
	req.UnitEn = strings.Trim(req.UnitEn, " ")
	if req.EdbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "指标id小于等于0"
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	if req.EdbNameEn != "" {
		//判断指标名称是否存在
		var condition string
		var pars []interface{}

		condition += " AND edb_info_id<>? "
		pars = append(pars, req.EdbInfoId)

		/*condition += " AND source=? "
		pars = append(pars, edbInfo.Source)*/

		condition += " AND edb_name_en=? "
		pars = append(pars, req.EdbNameEn)

		edbExist, err := data_manage.GetEdbInfoByCondition(condition, pars)
		if err != nil {
			if !utils.IsErrNoRow(err) {
				br.Msg = "判断英文指标名称是否存在失败"
				br.ErrMsg = "判断英文指标名称是否存在失败,Err:" + err.Error()
				return
			}
		}

		if err == nil && edbExist.EdbInfoId > 0 {
			br.Msg = edbExist.EdbName + "：" + req.EdbNameEn + "指标名称已存在"
			br.ErrMsg = "英文指标名称已存在，请重新填写"
			br.IsSendEmail = false
			return
		}
	}

	err = data_manage.ModifyEdbEnInfo(&req)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "修改失败,Err:" + err.Error()
		return
	}
	//新增操作日志
	{
		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "编辑指标英文信息"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	//添加es
	data.AddOrEditEdbInfoToEs(req.EdbInfoId)

	// 修改关联的预测指标基础信息
	if edbInfo.EdbInfoType == 0 {
		go data.ModifyPredictEdbEnBaseInfoBySourceEdb(edbInfo, req.UnitEn)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// EdbInfoBaseEdit
// @Title 编辑指标基础信息接口
// @Description 编辑指标基础信息接口
// @Success 200 {object} data_manage.EditEdbBaseInfoReq
// @router /edb_info/base/edit [post]
func (this *EdbInfoController) EdbInfoBaseEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.EditEdbBaseInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	req.EdbName = strings.Trim(req.EdbName, " ")
	req.Unit = strings.Trim(req.Unit, " ")
	if req.EdbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "指标id小于等于0"
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	updateCols := make([]string, 0)

	if req.EdbName != "" {
		//判断指标名称是否存在
		var condition string
		var pars []interface{}

		condition += " AND edb_info_id<>? "
		pars = append(pars, req.EdbInfoId)

		/*condition += " AND source=? "
		pars = append(pars, edbInfo.Source)*/

		switch this.Lang {
		case utils.EnLangVersion:
			condition += " AND edb_name_en = ? "
			edbInfo.EdbNameEn = req.EdbName
			edbInfo.UnitEn = req.Unit
			edbInfo.ModifyTime = time.Now()
			updateCols = append(updateCols, "EdbNameEn", "UnitEn", "ModifyTime")
		default:
			condition += " AND edb_name = ? "
			edbInfo.EdbName = req.EdbName
			edbInfo.EdbNameSource = req.EdbName
			edbInfo.Unit = req.Unit
			edbInfo.ModifyTime = time.Now()
			updateCols = append(updateCols, "EdbName", "EdbNameSource", "Unit", "ModifyTime")
		}
		pars = append(pars, req.EdbName)

		edbExist, err := data_manage.GetEdbInfoByCondition(condition, pars)
		if err != nil {
			if !utils.IsErrNoRow(err) {
				br.Msg = "判断英文指标名称是否存在失败"
				br.ErrMsg = "判断英文指标名称是否存在失败,Err:" + err.Error()
				return
			}
		}

		if err == nil && edbExist.EdbInfoId > 0 {
			br.Msg = edbExist.EdbName + "：" + req.EdbName + "指标名称已存在"
			br.ErrMsg = "英文指标名称已存在，请重新填写"
			br.IsSendEmail = false
			return
		}
	}

	if len(updateCols) > 0 {
		err = edbInfo.Update(updateCols)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "修改失败,Err:" + err.Error()
			return
		}
	}

	//新增操作日志
	{
		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "编辑指标英文信息"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	//添加es
	data.AddOrEditEdbInfoToEs(req.EdbInfoId)

	// 修改关联的预测指标基础信息
	if edbInfo.EdbInfoType == 0 {
		switch this.Lang {
		case utils.EnLangVersion:
			go data.ModifyPredictEdbEnBaseInfoBySourceEdb(edbInfo, req.Unit)
		default:
			go data.ModifyPredictEdbBaseInfoBySourceEdb(edbInfo, edbInfo.Frequency, req.Unit)

		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// EdbInfoNewest
// @Title 获取最新指标接口
// @Description 获取最新指标接口
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/newest [get]
func (this *EdbInfoController) EdbInfoNewest() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	item, err := data_manage.GetEdbInfoByNewest()
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取最新指标失败"
		br.ErrMsg = "获取最新指标失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = item
}

// EdbInfoRefresh
// @Title 指标刷新接口
// @Description 指标刷新接口
// @Param   EdbInfoId   query   int  true       "指标id"
// @Success Ret=200 刷新成功
// @router /edb_info/refresh [get]
func (this *EdbInfoController) EdbInfoRefresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	edbInfoId, _ := this.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "数据已被删除，请刷新页面"
			br.ErrMsg = "数据已被删除，请刷新页面，edbInfoId:" + strconv.Itoa(edbInfoId)
			return
		}
		br.Msg = "刷新失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfo.NoUpdate == 1 {
		br.Msg = "该指标已停用"
		br.ErrMsg = "该指标已停用，edbCode:" + edbInfo.EdbCode
		return
	}
	err, isAsync := data.EdbInfoRefreshAllFromBaseV2(edbInfoId, false, false)
	if err != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新指标失败,EdbInfoRefresh Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Msg = "刷新成功"
	if isAsync {
		br.Msg = "该指标关联指标较多，请10分钟后刷新页面查看最新数据"
	}
	br.Success = true
	br.IsAddLog = true
}

// EdbInfoMove
// @Title 移动指标接口
// @Description 移动指标接口
// @Success 200 {object} data_manage.MoveEdbInfoReq
// @router /edb_info/move [post]
func (this *EdbInfoController) EdbInfoMove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.MoveEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.EdbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "指标id小于等于0"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}
	//判断分类是否存在
	count, _ := data_manage.GetEdbClassifyCountById(req.ClassifyId)
	if count <= 0 {
		br.Msg = "分类已被删除，不可移动，请刷新页面"
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "移动失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	var haveOperaAuth bool
	// 权限校验
	{
		haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.IsJoinPermission, edbInfo.EdbInfoId, edbInfo.ClassifyId, this.SysUser.AdminId)
		if err != nil {
			br.Msg = err.Error()
			br.ErrMsg = "校验指标权限失败，err:" + err.Error()
			return
		}
	}

	// 移动权限校验
	button := data.GetEdbOpButton(this.SysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
	if !button.MoveButton {
		br.Msg = "无权限操作"
		br.IsSendEmail = false
		return
	}
	//如果改变了分类，那么移动该指标数据
	if edbInfo.ClassifyId != req.ClassifyId {
		err = data_manage.MoveEdbInfo(req.EdbInfoId, req.ClassifyId)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "移动指标失败,Err:" + err.Error()
			return
		}
	}

	updateCol := make([]string, 0)
	//如果有传入 上一个兄弟节点分类id
	if req.PrevEdbInfoId > 0 {
		prevEdbInfo, err := data_manage.GetEdbInfoById(req.PrevEdbInfoId)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
			return
		}
		//如果是移动在两个兄弟节点之间
		if req.NextEdbInfoId > 0 {
			//下一个兄弟节点
			nextEdbInfo, err := data_manage.GetEdbInfoById(req.NextEdbInfoId)
			if err != nil {
				br.Msg = "移动失败"
				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
				return
			}
			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
			if prevEdbInfo.Sort == nextEdbInfo.Sort || prevEdbInfo.Sort == edbInfo.Sort {
				//变更兄弟节点的排序
				updateSortStr := `sort + 2`
				_ = data_manage.UpdateEdbInfoSortByClassifyId(prevEdbInfo.ClassifyId, prevEdbInfo.Sort, prevEdbInfo.EdbInfoId, updateSortStr)
			} else {
				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
				if nextEdbInfo.Sort-prevEdbInfo.Sort == 1 {
					//变更兄弟节点的排序
					updateSortStr := `sort + 1`
					_ = data_manage.UpdateEdbInfoSortByClassifyId(prevEdbInfo.ClassifyId, prevEdbInfo.Sort, prevEdbInfo.EdbInfoId, updateSortStr)
				}
			}
		}

		edbInfo.Sort = prevEdbInfo.Sort + 1
		edbInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")

	} else {
		firstClassify, err := data_manage.GetFirstEdbInfoByClassifyId(req.ClassifyId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "移动失败"
			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
			return
		}

		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
		if firstClassify != nil && firstClassify.Sort == 0 {
			updateSortStr := ` sort + 1 `
			_ = data_manage.UpdateEdbInfoSortByClassifyId(firstClassify.ClassifyId, 0, firstClassify.EdbInfoId-1, updateSortStr)
		}

		edbInfo.Sort = 0 //那就是排在第一位
		edbInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")
	}

	//更新
	if len(updateCol) > 0 {
		err = edbInfo.Update(updateCol)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "修改失败,Err:" + err.Error()
			return
		}
		//添加es
		data.AddOrEditEdbInfoToEs(req.EdbInfoId)
	}

	if err != nil {
		br.Msg = "移动失败"
		br.ErrMsg = "修改失败,Err:" + err.Error()
		return
	}
	//新增操作日志
	{
		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "移动指标"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "移动成功"
}

// EdbInfoDetail
// @Title 获取指标详情
// @Description 获取指标详情接口
// @Param   EdbInfoId   query   int  true       "指标id"
// @Success 200 {object} data_manage.EdbInfo
// @router /edb_info/detail [get]
func (this *EdbInfoController) EdbInfoDetail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	edbInfoId, _ := this.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}
	var resp data_manage.EdbInfoFullClassify
	classifyList, err, errMsg := data.GetFullClassifyByClassifyId(edbInfo.ClassifyId)
	if err != nil {
		br.Msg = err.Error()
		br.ErrMsg = errMsg
		return
	}

	// 权限校验
	{
		classifyMap := make(map[int]*data_manage.EdbClassifyIdItems)
		for _, v := range classifyList {
			classifyMap[v.ClassifyId] = v
		}
		if currClassify, ok := classifyMap[edbInfo.ClassifyId]; ok {
			haveOperaAuth, err := data_manage_permission.CheckEdbPermission(edbInfo.IsJoinPermission, currClassify.IsJoinPermission, this.SysUser.AdminId, edbInfo.EdbInfoId, edbInfo.ClassifyId)
			if err != nil {
				br.Msg = err.Error()
				br.ErrMsg = "校验指标权限失败，err:" + err.Error()
				return
			}
			resp.HaveOperaAuth = haveOperaAuth
		}
	}

	resp.EdbInfo = edbInfo
	resp.ClassifyList = classifyList

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoFilter
// @Title 指标筛选接口
// @Description 指标筛选接口
// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
// @Param   FilterSource   query   int  false       "搜索来源:1:其他搜索,2:累计值转月值搜索,3:变频，4：基础指标"
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/filter [get]
func (this *EdbInfoController) EdbInfoFilter() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	keyWord := this.GetString("KeyWord")
	filterSource, _ := this.GetInt("FilterSource")
	if filterSource <= 0 {
		filterSource = 1
	}

	var pars []interface{}

	noPermissionEdbInfoIdList := make([]int, 0) //无权限指标
	// 获取当前账号的不可见指标
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionEdbInfoIdList = append(noPermissionEdbInfoIdList, v.EdbInfoId)
		}
	}

	var keyWordArr []string
	keyWordArr = append(keyWordArr, keyWord)
	if keyWord != "" {
		newKeyWord := strings.Split(keyWord, " ")
		keyWordArr = append(keyWordArr, newKeyWord...)
	}
	//var err error
	edbInfoList := make([]*data_manage.EdbInfoList, 0)
	//if keyWord == "" {
	//	edbInfoList, err = data_manage.GetEdbInfoFilter(condition, pars)
	//	if err != nil && err.Error() != utils.ErrNoRow() {
	//		br.Success = true
	//		br.Msg = "获取指标信息失败"
	//		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
	//		return
	//	}
	//} else {
	//	//获取指标信息
	//	indexName := utils.DATA_INDEX_NAME
	//	edbInfoList, err = data.EsSearchEdbInfo(indexName, keyWord,filterSource)
	//	if err != nil && err.Error() != utils.ErrNoRow() {
	//		br.Success = true
	//		br.Msg = "获取指标信息失败"
	//		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
	//		return
	//	}
	//}

	var baseCondition string
	// 无权限指标id
	lenNoPermissionEdbInfoIdList := len(noPermissionEdbInfoIdList)
	if lenNoPermissionEdbInfoIdList > 0 {
		baseCondition = ` AND edb_info_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbInfoIdList) + `) `
		pars = append(pars, noPermissionEdbInfoIdList)
	}
	existMap := make(map[int]string)
	for _, v := range keyWordArr {
		v = strings.Replace(v, " ", "%", -1)
		var condition string
		if filterSource == 2 {
			condition += ` AND frequency='月度' `
		}
		if filterSource == 3 {
			condition += ` AND frequency <> '日度' `
		}
		if filterSource == 4 {
			condition += ` AND edb_type = 1 `
		}
		conditionWhere := `AND  ( edb_code LIKE '%` + v + `%'  OR  edb_name LIKE '%` + v + `%' )`

		condition += conditionWhere + baseCondition
		newEdbInfoList, err := data_manage.GetEdbInfoFilter(condition, pars)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Success = true
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
			return
		}
		for _, nv := range newEdbInfoList {
			if _, ok := existMap[nv.EdbInfoId]; !ok {
				edbInfoList = append(edbInfoList, nv)
			}
			existMap[nv.EdbInfoId] = nv.EdbCode
		}
	}

	if edbInfoList == nil {
		edbInfoList = make([]*data_manage.EdbInfoList, 0)
	}

	edbInfoListLen := len(edbInfoList)

	for i := 0; i < edbInfoListLen; i++ {
		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
	}

	for i := 0; i < edbInfoListLen; i++ {
		for j := 0; j < edbInfoListLen; j++ {
			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
			}
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyWord
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = edbInfoList
}

// EdbInfoFilterByEs
// @Title 指标筛选接口
// @Description 指标筛选接口
// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
// @Param   FilterSource   query   int  false       "搜索来源:1:其他搜索,2:累计值转月值搜索,3:变频，4：基础指标，5：同比"
// @Param   Frequency   query   string  false       "频度"
// @Param   IsAddPredictEdb   query   bool  false       "是否查询添加预测指标"
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/filter_by_es [get]
func (this *EdbInfoController) EdbInfoFilterByEs() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var total int64

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	keyWord := this.GetString("KeyWord")
	keyWord = strings.TrimSpace(keyWord) //移除字符串首尾空格
	filterSource, _ := this.GetInt("FilterSource")
	if filterSource <= 0 {
		filterSource = 1
	}
	//指标来源
	source, _ := this.GetInt("Source")

	frequency := this.GetString("Frequency") //频度

	isAddPredictEdb, _ := this.GetBool("IsAddPredictEdb") //是否查询添加预测指标

	var edbInfoList []*data_manage.EdbInfoList
	var err error

	noPermissionEdbInfoIdList := make([]int, 0) //无权限指标
	// 获取当前账号的不可见指标
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionEdbInfoIdList = append(noPermissionEdbInfoIdList, v.EdbInfoId)
		}
	}

	// 只看我的
	var sysUserId int
	mine, _ := this.GetBool("IsShowMe")
	if mine {
		sysUserId = this.SysUser.AdminId
	}

	// 是否走ES
	isEs := false
	if keyWord != "" {
		var keyWordArr []string
		keyWordArr = append(keyWordArr, keyWord)

		newKeyWord := strings.Split(keyWord, " ")
		keyWordArr = append(keyWordArr, newKeyWord...)

		// 普通的搜索
		if !isAddPredictEdb {
			if mine {
				total, edbInfoList, err = elastic.SearchEdbInfoDataByAdminId(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 0, frequency, sysUserId)
			} else {
				total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 0, frequency, noPermissionEdbInfoIdList)
			}
		} else {
			// 允许添加预测指标的搜索
			total, edbInfoList, err = elastic.SearchAddPredictEdbInfoData(utils.DATA_INDEX_NAME, keyWord, noPermissionEdbInfoIdList, startSize, pageSize, sysUserId)
		}
		isEs = true
	} else {
		var condition string
		var pars []interface{}
		// 普通指标
		condition += ` AND edb_info_type = ? `
		pars = append(pars, 0)

		// 无权限指标id
		lenNoPermissionEdbInfoIdList := len(noPermissionEdbInfoIdList)
		if lenNoPermissionEdbInfoIdList > 0 {
			condition += ` AND edb_info_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbInfoIdList) + `) `
			pars = append(pars, noPermissionEdbInfoIdList)
		}

		switch filterSource {
		case 2:
			condition += ` AND frequency='月度' `
		case 3:
			condition += ` AND frequency <> '日度' `
		case 4:
			condition += ` AND edb_type = 1 `
		case 5:
			condition += ` AND source = 6 ` //来源（同比值）
		case 6:
			condition += ` AND frequency != ? `
			pars = append(pars, "年度")
		}

		//频度
		if frequency != "" {
			condition += ` AND frequency = ? `
			pars = append(pars, frequency)
		}

		if source > 0 && filterSource != 5 {
			condition += ` AND source = ? `
			pars = append(pars, source)
		}
		// 查询只允许添加预测指标的搜索
		if isAddPredictEdb {
			condition += ` AND frequency in ("日度","周度","月度") `
		}

		if mine {
			condition += ` AND sys_user_id = ? `
			pars = append(pars, sysUserId)
		}

		total, edbInfoList, err = data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
	}
	if err != nil {
		edbInfoList = make([]*data_manage.EdbInfoList, 0)
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))

	edbInfoListLen := len(edbInfoList)

	classifyIdList := make([]int, 0)
	for i := 0; i < edbInfoListLen; i++ {
		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
		classifyIdList = append(classifyIdList, edbInfoList[i].ClassifyId)
		// 如果没有关键词，那么搜索结果字段取指标名，前端已统一用该字段显示搜索的列表内容
		if keyWord == "" {
			if this.Lang == utils.ZhLangVersion {
				edbInfoList[i].SearchText = edbInfoList[i].EdbName
			}
			if this.Lang == utils.EnLangVersion {
				edbInfoList[i].SearchText = edbInfoList[i].EdbNameEn
			}
		}
	}

	// 当前列表中的分类map
	classifyMap := make(map[int]*data_manage.EdbClassify)
	if edbInfoListLen > 0 {
		classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
			return
		}

		for _, v := range classifyList {
			classifyMap[v.ClassifyId] = v
		}

		// 获取所有有权限的指标和分类
		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
			return
		}

		// 如果是ES的话，需要重新查一下指标的信息，主要是为了把是否授权字段找出来
		if isEs {
			edbInfoIdList := make([]int, 0)
			for i := 0; i < edbInfoListLen; i++ {
				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
				tmpEdbInfo := edbInfoList[i]
				if currClassify, ok := classifyMap[tmpEdbInfo.ClassifyId]; ok {
					edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfo.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfo.EdbInfoId, tmpEdbInfo.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
				}
			}

			tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
				return
			}
			edbInfoMap := make(map[int]*data_manage.EdbInfo)
			for _, v := range tmpEdbList {
				edbInfoMap[v.EdbInfoId] = v
			}

			for i := 0; i < edbInfoListLen; i++ {
				tmpEdbInfo, ok := edbInfoMap[edbInfoList[i].EdbInfoId]
				if !ok {
					continue
				}
				edbInfoList[i].IsJoinPermission = tmpEdbInfo.IsJoinPermission
			}
		}

		// 权限校验
		for i := 0; i < edbInfoListLen; i++ {
			tmpEdbInfoItem := edbInfoList[i]
			if currClassify, ok := classifyMap[tmpEdbInfoItem.ClassifyId]; ok {
				edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfoItem.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfoItem.EdbInfoId, tmpEdbInfoItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
			}
		}
	}

	for i := 0; i < edbInfoListLen; i++ {
		for j := 0; j < edbInfoListLen; j++ {
			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
			}
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyWord
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	resp := data_manage.EdbInfoFilterDataResp{
		Paging: page,
		List:   edbInfoList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

func (this *EdbInfoController) EdbInfoFilter2() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	keyWord := this.GetString("KeyWord")
	keyWord = strings.TrimSpace(keyWord) //移除字符串首尾空格
	filterSource, _ := this.GetInt("FilterSource")
	if filterSource <= 0 {
		filterSource = 1
	}

	var pars []interface{}

	//if keyWord != "" {
	//	condition += ` AND  ( edb_code LIKE '%` + keyWord + `%'  OR  edb_name LIKE '%` + keyWord + `%' )`
	//}

	var keyWordArr []string
	keyWordArr = append(keyWordArr, keyWord)
	if keyWord != "" {
		newKeyWord := strings.Split(keyWord, " ")
		keyWordArr = append(keyWordArr, newKeyWord...)
	}
	keywordLen := len(keyWordArr)

	ch := make(chan map[int][]*data_manage.EdbInfoList, keywordLen)
	searchWait := sync.WaitGroup{}
	searchWait.Add(keywordLen)
	for index, v := range keyWordArr {
		v = strings.Replace(v, " ", "%", -1)
		var condition string
		if filterSource == 2 {
			condition += ` AND frequency='月度' `
		}
		if filterSource == 3 {
			condition += ` AND frequency <> '日度' `
		}
		if filterSource == 4 {
			condition += ` AND edb_type = 1 `
		}
		conditionWhere := `AND  ( edb_code LIKE '%` + v + `%'  OR  edb_name LIKE '%` + v + `%' )`
		condition += conditionWhere
		go searchEdbInfoFilter(condition, pars, index, ch, &searchWait)
	}
	searchWait.Wait()

	newEdbInfoListMap := make(map[int][]*data_manage.EdbInfoList)
	i := 0
	for tmpEdbInfoList := range ch {
		i++
		for k, v := range tmpEdbInfoList {
			newEdbInfoListMap[k] = v
		}
		if i == keywordLen {
			break
		}
	}
	close(ch)

	edbInfoList := make([]*data_manage.EdbInfoList, 0)
	existMap := make(map[int]string)
	for i := 0; i < keywordLen; i++ {
		if newEdbInfoList, ok := newEdbInfoListMap[i]; ok {
			for _, nv := range newEdbInfoList {
				if _, ok := existMap[nv.EdbInfoId]; !ok {
					edbInfoList = append(edbInfoList, nv)
				}
				existMap[nv.EdbInfoId] = nv.EdbCode
			}
		}
	}

	if edbInfoList == nil {
		edbInfoList = make([]*data_manage.EdbInfoList, 0)
	}

	edbInfoListLen := len(edbInfoList)

	for i := 0; i < edbInfoListLen; i++ {
		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
	}

	for i := 0; i < edbInfoListLen; i++ {
		for j := 0; j < edbInfoListLen; j++ {
			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
			}
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyWord
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = edbInfoList
}

func searchEdbInfoFilter(condition string, pars []interface{}, i int, ch chan map[int][]*data_manage.EdbInfoList, searchWait *sync.WaitGroup) (newEdbInfoListMap map[int][]*data_manage.EdbInfoList, err error) {
	newEdbInfoListMap = make(map[int][]*data_manage.EdbInfoList)
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("查询近6个月的客户增量数据异常："+err.Error(), 3)
			//go utils.SendEmail(utils.APPNAME+"查询近6个月的客户增量数据异常："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		}
		ch <- newEdbInfoListMap
		searchWait.Done()
	}()
	newEdbInfoList, err := data_manage.GetEdbInfoFilter(condition, pars)
	newEdbInfoListMap[i] = newEdbInfoList
	return
}

// EdbInfoAllRefresh
// @Title 指标全部刷新接口
// @Description 指标全部刷新接口
// @Param   EdbInfoId   query   int  true       "指标id"
// @Success Ret=200 全部刷新成功
// @router /edb_info/refresh/all [get]
func (this *EdbInfoController) EdbInfoAllRefresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	edbInfoId, _ := this.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "数据已被删除，请刷新页面"
			br.ErrMsg = "数据已被删除，请刷新页面，edbInfoId:" + strconv.Itoa(edbInfoId)
			return
		}
		br.Msg = "刷新失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfo == nil {
		br.Msg = "数据已被删除，请刷新页面"
		br.ErrMsg = "数据已被删除，请刷新页面，edbInfoId:" + strconv.Itoa(edbInfoId)
		return
	}
	err, isAsync := data.EdbInfoRefreshAllFromBaseV2(edbInfoId, true, false)
	if err != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新指标失败,EdbInfoRefreshAllFromBase Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
	if isAsync {
		br.Msg = "该指标关联指标较多，请10分钟后刷新页面查看最新数据"
	}
}

// EdbInfoData
// @Title 获取指标数据
// @Description 获取指标数据
// @Param   EdbInfoId   query   int  true       "指标ID"
// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间,6:自定义起始时间至今，7：18年至今,8:19年至今,9:20年至今,10:全部"
// @Param   StartDate   query   string  true       "自定义开始日期"
// @Param   EndDate   query   string  true       "自定义结束日期"
// @Success 200 {object} data_manage.EdbInfoDataResp
// @router /edb_info/data [get]
func (this *ChartInfoController) EdbInfoData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	fullEdb := new(data_manage.EdbInfoFullClassify)
	resp := new(data_manage.EdbInfoDataFullClassifyResp)
	dataList := make([]*data_manage.EdbDataList, 0)

	edbInfoId, _ := this.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "参数错误"
		return
	}
	dateType, _ := this.GetInt("DateType")
	if dateType <= 0 {
		dateType = 3
	}

	edbInfoType, _ := this.GetInt("EdbInfoType")
	if edbInfoType < 0 {
		edbInfoType = 1
	}

	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Ret = 200
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败,Err:" + err.Error()
		return
	}

	// 分类
	classifyList, err, errMsg := data.GetFullClassifyByClassifyId(edbInfo.ClassifyId)
	if err != nil {
		br.Msg = err.Error()
		br.ErrMsg = errMsg
		return
	}
	fullEdb.EdbInfo = edbInfo
	// 是否供应商停更
	fullEdb.IsSupplierStop = data.GetIsSupplierStop(edbInfo.Source, edbInfo.EdbCode)
	//是否被引用
	relation, err := data.GetEdbRelationListById(edbInfo.EdbInfoId, edbInfo.Source)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = err.Error()
		br.ErrMsg = "获取指标关联关系失败，err:" + err.Error()
		return
	}
	if relation != nil && relation.RelationNum > 0 {
		fullEdb.IsRelation = true
	}
	fullEdb.ClassifyList = classifyList

	var currClassifyItem *data_manage.EdbClassifyIdItems
	for _, v := range classifyList {
		if v.ClassifyId == edbInfo.ClassifyId {
			currClassifyItem = v
		}
	}
	if currClassifyItem != nil {
		haveOperaAuth, err := data_manage_permission.CheckEdbPermission(edbInfo.IsJoinPermission, currClassifyItem.IsJoinPermission, sysUser.AdminId, edbInfo.EdbInfoId, edbInfo.ClassifyId)
		if err != nil {
			br.Msg = err.Error()
			br.ErrMsg = "校验指标权限失败，err:" + err.Error()
			return
		}
		fullEdb.HaveOperaAuth = haveOperaAuth
	}
	resp.EdbInfo = fullEdb

	resp.DataList = make([]*data_manage.EdbDataList, 0)
	// 数据获取
	if fullEdb.HaveOperaAuth { // 有权限才获取数据
		var latestDateT time.Time
		if edbInfo.LatestDate != "" {
			latestDateT, _ = time.Parse(utils.FormatDate, edbInfo.LatestDate)
		}
		startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, latestDateT)
		dataList, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfoId, startDate, endDate)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败,Err:" + err.Error()
			return
		}

		resp.DataList = dataList
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoReplaceCheck
// @Title 指标一键刷新接口
// @Description 指标一键刷新接口
// @Success Ret=200 更新成功
// @router /edb_info/replace/check [post]
func (this *EdbInfoController) EdbInfoReplaceCheck() {
	br := new(models.BaseResponse).Init()
	setNxKey := "EDB_INFO_REPLACE"
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	status := 0
	if utils.Rc.IsExist(setNxKey) {
		status = 1
	} else {
		status = 2
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "检测成功"
	br.Data = status
}

// EdbInfoReplace
// @Title 替换指标
// @Description 替换指标
// @Param	request	body data_manage.EdbInfoReplaceReq true "type json string"
// @Success 200 {object} data_manage.EdbInfoDataResp
// @router /edb_info/replace [post]
func (this *ChartInfoController) EdbInfoReplace() {
	br := new(models.BaseResponse).Init()
	setNxKey := "EDB_INFO_REPLACE"
	deleteCache := true

	defer func() {
		if deleteCache {
			utils.Rc.Delete(setNxKey)
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	if !utils.Rc.SetNX(setNxKey, 1, 30*time.Minute) {
		deleteCache = false
		br.Msg = "当前正在替换中，请耐心等待！"
		br.IsSendEmail = false
		return
	}

	var req data_manage.EdbInfoReplaceReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.OldEdbInfoId <= 0 || req.NewEdbInfoId <= 0 {
		br.Msg = "参数错误！"
		br.ErrMsg = "参数错误，指标id为0"
		return
	}

	oldEdbInfo, err := data_manage.GetEdbInfoById(req.OldEdbInfoId)
	if err != nil {
		br.Msg = "替换失败！"
		br.ErrMsg = "获取原指标失败，Err:" + err.Error()
		return
	}

	newEdbInfo, err := data_manage.GetEdbInfoById(req.NewEdbInfoId)
	if err != nil {
		br.Msg = "替换失败！"
		br.ErrMsg = "获取替换目标指标失败，Err:" + err.Error()
		return
	}

	//if oldEdbInfo.EdbType != 1 {
	//	br.Msg = "原指标为计算指标，不可替换！"
	//	br.ErrMsg = "原指标为计算指标，不可替换！"
	//	return
	//}
	//
	//if newEdbInfo.EdbType != 1 {
	//	br.Msg = "替换指标为计算指标，不可替换！"
	//	br.ErrMsg = "替换指标为计算指标，不可替换！"
	//	return
	//}

	if oldEdbInfo.Frequency != newEdbInfo.Frequency {
		br.Msg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
		br.ErrMsg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
		return
	}

	if oldEdbInfo.EdbInfoType == 1 || newEdbInfo.EdbInfoType == 1 {
		br.Msg = "预测指标不允许替换"
		br.ErrMsg = "预测指标不允许替换"
		return
	}
	// 判断指标是否循环引用
	if oldEdbInfo.EdbType == 2 {
		// 查询该计算指标的所有相关指标，如果相关指标中包含新指标，则提示
		hasRelation, e := data.CheckTwoEdbInfoRelation(oldEdbInfo, newEdbInfo)
		if e != nil {
			br.Msg = "替换失败！"
			br.ErrMsg = "查询指标引用关系失败，Err:" + e.Error()
			return
		}
		if hasRelation {
			br.Msg = "原指标与替换指标存在引用关系，不允许替换"
			br.ErrMsg = "原指标与替换指标存在引用关系，不允许替换"
			return
		}
	}

	if newEdbInfo.EdbType == 2 {
		// 查询该计算指标的所有相关指标，如果相关指标中包含新指标，则提示
		hasRelation, e := data.CheckTwoEdbInfoRelation(newEdbInfo, oldEdbInfo)
		if e != nil {
			br.Msg = "替换失败！"
			br.ErrMsg = "查询指标引用关系失败，Err:" + e.Error()
			return
		}
		if hasRelation {
			br.Msg = "原指标与替换指标存在引用关系，不允许替换"
			br.ErrMsg = "原指标与替换指标存在引用关系，不允许替换"
			return
		}
	}

	sysAdminId := sysUser.AdminId
	//replaceChartTotal, replaceCalculateTotal, err := data.EdbInfoReplace(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
	_, _, err = data.EdbInfoReplace(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
	//msgContent := ``
	if err != nil {
		br.Msg = "替换失败"
		br.ErrMsg = "替换失败 replace err:" + err.Error()
		return
	}

	br.Msg = "替换成功"
	br.ErrMsg = "替换成功"
	br.Ret = 200
	br.IsAddLog = true
	return
}

// RelationChartList
// @Title 获取ETA指标关联的图表列表接口
// @Description 获取ETA指标关联的图表列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   EdbInfoId   query   int  true       "指标id"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartListResp
// @router /edb_info/relation/chart_list [get]
func (this *EdbInfoController) RelationChartList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	edbInfoId, _ := this.GetInt("EdbInfoId")
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	resp := data_manage.ChartListResp{}
	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	var condition string
	var pars []interface{}

	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.ErrMsg = "请选择指标"
		br.IsSendEmail = false
		return
	}

	/*// 关联指标
	condition += ` AND b.edb_info_id = ? `
	pars = append(pars, edbInfoId)*/

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		condition += ` AND a.sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	chartIds := make([]int, 0)
	chartIdMap := make(map[int]bool)
	// 查询指标绑定的图表
	edbListTemp, err := data_manage.GetEdbMappingListByEdbInfoId(edbInfoId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}
	for _, v := range edbListTemp {
		if _, ok := chartIdMap[v.ChartInfoId]; !ok {
			chartIdMap[v.ChartInfoId] = true
		}
	}
	// 查询相关性的图表
	correlationChart := new(data_manage.ChartInfoCorrelation)
	correlationChartId, err := correlationChart.GetChartInfoIdByEdb(edbInfoId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}
	if correlationChartId > 0 {
		chartIdMap[correlationChartId] = true
	}
	// 查询跨品种的图表
	tagXList, err := cross_variety.GetChartInfoCrossVarietyByXEdbInfoId(edbInfoId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	for _, v := range tagXList {
		if _, ok := chartIdMap[v.ChartInfoId]; !ok {
			chartIdMap[v.ChartInfoId] = true
		}
	}

	tagYList, err := cross_variety.GetChartInfoCrossVarietyByYEdbInfoId(edbInfoId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}
	for _, v := range tagYList {
		if _, ok := chartIdMap[v.ChartInfoId]; !ok {
			chartIdMap[v.ChartInfoId] = true
		}
	}

	// 获取当前账号的不可见图表
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			if _, ok := chartIdMap[v.ChartInfoId]; ok {
				delete(chartIdMap, v.ChartInfoId)
			}
		}
	}
	for k, _ := range chartIdMap {
		chartIds = append(chartIds, k)
	}

	// 关联指标
	if len(chartIds) > 0 {
		condition += `  AND a.chart_info_id in  (` + utils.GetOrmInReplace(len(chartIds)) + `)`
		pars = append(pars, chartIds)
	} else {
		items := make([]*data_manage.ChartInfoView, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	// 得到图表ID
	//获取关联图表列表
	list, err := data_manage.GetRelationChartListByCondition(condition, pars, startSize, pageSize)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Success = true
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	if list == nil || len(list) <= 0 || (err != nil && utils.IsErrNoRow(err)) {
		items := make([]*data_manage.ChartInfoView, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	// 获取关联图表总数
	dataCount, err := data_manage.GetRelationChartListCountByCondition(condition, pars)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
		return
	}

	// 获取MY ETA 图表,用来判断是否加入我的图库
	myChartList, err := data_manage.GetMyChartListByAdminId(sysUser.AdminId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取我的图表信息失败,Err:" + err.Error()
		return
	}
	myChartMap := make(map[int]*data_manage.MyChartView)
	for _, v := range myChartList {
		myChartMap[v.ChartInfoId] = v
	}
	listLen := len(list)

	if listLen > 0 {
		// 分类id
		classifyIdList := make([]int, 0)
		// 当前列表中的分类map
		classifyMap := make(map[int]*data_manage.ChartClassify)
		for _, v := range list {
			classifyIdList = append(classifyIdList, v.ChartClassifyId)
		}
		classifyList, err := data_manage.GetChartClassifyByIdList(classifyIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
			return
		}

		for _, v := range classifyList {
			classifyMap[v.ChartClassifyId] = v
		}

		// 已授权分类id
		permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取已授权分类id数据失败，Err:" + err.Error()
			return
		}

		for _, v := range list {
			if existItem, ok := myChartMap[v.ChartInfoId]; ok {
				v.IsAdd = true
				v.MyChartId = existItem.MyChartId
				v.MyChartClassifyId = existItem.MyChartClassifyId
			}
			// 权限
			if currClassify, ok := classifyMap[v.ChartClassifyId]; ok {
				v.HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(v.IsJoinPermission, currClassify.IsJoinPermission, v.ChartInfoId, v.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
			}
		}
	}

	page = paging.GetPaging(currentIndex, pageSize, dataCount)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// RelationEdbList
// @Title 获取ETA指标关联的指标列表接口
// @Description 获取ETA指标关联的指标列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   EdbInfoId   query   int  true       "指标id"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartListResp
// @router /edb_info/relation/edbinfo_list [get]
func (this *EdbInfoController) RelationEdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	edbInfoId, _ := this.GetInt("EdbInfoId")
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	resp := data_manage.RelationEdbInfoListResp{}
	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	var condition string
	var pars []interface{}

	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.ErrMsg = "请选择指标"
		br.IsSendEmail = false
		return
	}

	// 关联指标
	condition += ` AND b.from_edb_info_id = ? `
	pars = append(pars, edbInfoId)

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		condition += ` AND a.sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	// 获取当前账号的不可见图表
	noPermissionEdbIdList := make([]int, 0)
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionEdbIdList = append(noPermissionEdbIdList, v.EdbInfoId)
		}
	}
	noPermissionEdbIdNum := len(noPermissionEdbIdList)
	if noPermissionEdbIdNum > 0 {
		condition += ` AND a.edb_info_id not in  (` + utils.GetOrmInReplace(noPermissionEdbIdNum) + `) `
		pars = append(pars, noPermissionEdbIdList)
	}

	//获取关联图表列表
	list, err := data_manage.GetRelationEdbInfoListByCondition(condition, pars, startSize, pageSize)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Success = true
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	if list == nil || len(list) <= 0 || (err != nil && utils.IsErrNoRow(err)) {
		items := make([]*data_manage.ChartEdbInfoMapping, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	// 获取关联图表总数
	dataCount, err := data_manage.GetRelationEdbInfoListCountByCondition(condition, pars)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
		return
	}

	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	edbList := make([]*data_manage.ChartEdbInfoMapping, 0)

	if len(list) > 0 {

		// 当前的分类
		classifyMap := make(map[int]*data_manage.EdbClassify)
		{
			classifyIdList := make([]int, 0)
			for _, v := range list {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
			if err != nil {
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
					return
				}
			}

			for _, v := range classifyList {
				classifyMap[v.ClassifyId] = v
			}
		}

		// 获取所有有权限的指标和分类
		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
			return
		}

		for _, v := range list {
			item := new(data_manage.ChartEdbInfoMapping)
			item.EdbInfoId = v.EdbInfoId
			item.SourceName = v.SourceName
			item.Source = v.Source
			item.EdbCode = v.EdbCode
			item.EdbName = v.EdbName
			item.EdbNameEn = v.EdbNameEn
			item.Frequency = v.Frequency
			item.FrequencyEn = data.GetFrequencyEn(v.Frequency)
			if v.Unit != `无` {
				item.Unit = v.Unit
			}
			item.UnitEn = v.UnitEn
			item.StartDate = v.StartDate
			item.EndDate = v.EndDate
			item.ModifyTime = v.ModifyTime
			item.IsAxis = 1
			item.LeadValue = 0
			item.LeadUnit = ""
			item.ChartEdbMappingId = 0
			item.ChartInfoId = 0
			item.IsOrder = false
			item.EdbInfoType = v.EdbInfoType
			item.EdbInfoCategoryType = v.EdbInfoType
			item.ChartStyle = ""
			item.ChartColor = ""
			item.ChartWidth = 0
			item.MaxData = v.MaxValue
			item.MinData = v.MinValue
			item.LatestValue = v.LatestValue
			item.LatestDate = v.LatestDate
			item.UniqueCode = v.UniqueCode
			item.ClassifyId = v.ClassifyId

			dataList := make([]*data_manage.EdbDataList, 0)
			// 指标权限
			if currClassify, ok := classifyMap[v.ClassifyId]; ok {
				item.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(v.IsJoinPermission, currClassify.IsJoinPermission, v.EdbInfoId, v.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
			}

			// 有权限则获取数据
			if item.HaveOperaAuth {
				if v.EdbInfoType == 0 {
					dataList, err = data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, "", "")
				} else {
					_, dataList, _, _, err, _ = data.GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, "", "", false)
				}
				if err != nil {
					br.Msg = "获取失败"
					br.Msg = "获取失败,Err:" + err.Error()
					return
				}
			}

			item.DataList = dataList
			edbList = append(edbList, item)
		}
	}

	page = paging.GetPaging(currentIndex, pageSize, dataCount)
	resp.Paging = page
	resp.List = edbList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoDataTb
// @Title 获取指标数据同比值
// @Description 获取指标数据
// @Param   EdbInfoId   query   int  true       "指标ID"
// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间,6:自定义起始时间至今，7：18年至今,8:19年至今,9:20年至今,10:全部"
// @Param   StartDate   query   string  true       "自定义开始日期"
// @Param   EndDate   query   string  true       "自定义结束日期"
// @Success 200 {object} data_manage.EdbInfoDataResp
// @router /edb_info/data/tb [get]
func (this *ChartInfoController) EdbInfoDataTb() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	edbInfoId, _ := this.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "参数错误"
		return
	}
	dateType, _ := this.GetInt("DateType")
	if dateType <= 0 {
		dateType = 3
	}

	edbInfoType, _ := this.GetInt("EdbInfoType")
	if edbInfoType < 0 {
		edbInfoType = 1
	}

	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		return
	}
	var latestDateT time.Time
	if edbInfo.LatestDate != "" {
		latestDateT, _ = time.Parse(utils.FormatDate, edbInfo.LatestDate)
	}

	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, latestDateT)

	var startDateTime time.Time
	if startDate != `` {
		startDateTime, err = time.ParseInLocation(utils.FormatDate, startDate, time.Local)
		if err != nil {
			br.Msg = "开始日期异常"
			br.Msg = "开始日期异常,Err:" + err.Error()
			return
		}
		//同比值的计算方式,是需要与去年同期对比,所以如果用户需要某个时间段的数据的话,获取基础数据时,需要往前面推(1年+兼容的日期频度(目前是35天))
		startDate = startDateTime.AddDate(-1, 0, -35).Format(utils.FormatDate)
	}
	tmpDataList, err := data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfoId, startDate, endDate)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		return
	}

	// 计算同比值
	dataList, minValue, maxValue, err := data.GetEdbDataTbz(edbInfo, tmpDataList, startDateTime)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "计算同比值失败,Err:" + err.Error()
		return
	}

	edbInfo.MaxValue = maxValue
	edbInfo.MinValue = minValue

	resp := new(data_manage.EdbInfoDataResp)
	resp.EdbInfo = edbInfo
	resp.DataList = dataList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoDataSeasonal
// @Title 获取指标数据(季节性)
// @Description 获取指标数据
// @Param   EdbInfoId   query   int  true       "指标ID"
// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间,6:自定义起始时间至今，7：18年至今,8:19年至今,9:20年至今,10:全部"
// @Param   StartDate   query   string  true       "自定义开始日期"
// @Param   EndDate   query   string  true       "自定义结束日期"
// @Param   Calendar   query   string  true       "公历/农历"
// @Success 200 {object} data_manage.EdbInfoDataResp
// @router /edb_info/data/seasonal [get]
func (this *ChartInfoController) EdbInfoDataSeasonal() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	dateType, _ := this.GetInt("DateType")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	edbInfoIdStr := this.GetString("EdbInfoId")
	edbInfoId, err := strconv.Atoi(edbInfoIdStr)
	if err != nil {
		br.Msg = "指标id异常"
		br.Msg = "指标id转换异常,Err:" + err.Error()
		return
	}

	fmt.Println("startDate:", startDate)
	fmt.Println("endDate:", endDate)

	calendar := this.GetString("Calendar")
	if calendar == "" {
		calendar = "公历"
	}
	if dateType == 0 {
		if startDate == "" {
			dateType = utils.DateTypeNYears
		} else {
			dateType = 5
		}
	}

	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		return
	}
	var latestDateT time.Time
	if edbInfo.LatestDate != "" {
		// 季节性图需要特殊处理最近N年数据
		latestDateT, _ = time.Parse(utils.FormatDate, edbInfo.LatestDate)
		latestDateT = time.Date(latestDateT.Year()+1, 1, 1, 0, 0, 0, 0, time.Local)
	}

	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, latestDateT)

	dataList, err := data.GetChartEdbSeasonalData(calendar, startDate, endDate, edbInfo)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	resp := new(data_manage.EdbInfoDataSeasonalResp)
	resp.EdbInfo = edbInfo
	resp.DataList = dataList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// SetEdbDataInsertConfig 设置插入值
// @Title 设置插入值接口
// @Description 设置插入值接口
// @Success 200 {object} data_manage.EditEdbEnInfoReq
// @router /edb_info/insert_config/set [post]
func (this *EdbInfoController) SetEdbDataInsertConfig() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.SetEdbDataInsertConfigReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	dateStr := req.Date
	if dateStr == `` {
		br.Msg = "请选择日期"
		br.IsSendEmail = false
		return
	}
	date, err := time.ParseInLocation(utils.FormatDate, dateStr, time.Local)
	if err != nil {
		br.Msg = "日期异常"
		br.ErrMsg = "日期异常，err:" + err.Error()
		br.IsSendEmail = false
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}

	err, errMsg, isSendEmail := data_manage.CreateEdbDataInsertConfigAndData(edbInfo, date, req.Value)
	if err != nil {
		br.Msg = "设置失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "修改失败,Err:" + err.Error()
		br.IsSendEmail = isSendEmail
		return
	}
	//新增操作日志
	{
		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "设置插入值"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// TraceEdbInfo
// @Title 指标溯源接口
// @Description 指标溯源接口
// @Param   UniqueCode   query   int  true       "指标唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Success 200 {object} data_manage.ChartListResp
// @router /edb_info/trace [get]
func (this *EdbInfoController) TraceEdbInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	//edbInfoId, _ := this.GetInt("EdbInfoId")
	//if edbInfoId <= 0 {
	//	br.Msg = "参数错误"
	//	br.ErrMsg = "参数错误"
	//	return
	//}

	uniqueCode := this.GetString("UniqueCode")
	if uniqueCode == `` {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}

	//  根据UniqueCode获取指标信息
	edbInfo, err := data_manage.GetEdbInfoByUniqueCode(uniqueCode)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		if utils.IsErrNoRow(err) {
			br.Msg = "指标不存在"
		}
		return
	}

	resp, err := data.TraceEdbInfoByEdbInfoId(edbInfo.EdbInfoId, this.SysUser.AdminId)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Data = resp
	br.Success = true
	br.Msg = "刷新成功"
}

// AllEdbInfoByEs
// @Title 所有指标筛选接口
// @Description 所有指标筛选接口
// @Param   KeyWord   query   string  false       "搜索关键词:指标ID/指标名称"
// @Param   FilterSource   query   int  false       "搜索来源:1:其他搜索,2:累计值转月值搜索,3:变频，4：基础指标，5：同比"
// @Param   Frequency   query   string  false       "频度"
// @Param   IsAddPredictEdb   query   bool  false       "是否查询添加预测指标"
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/filter_by_es/all [get]
func (this *EdbInfoController) AllEdbInfoByEs() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var total int64

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	keyWord := this.GetString("KeyWord")
	keyWord = strings.TrimSpace(keyWord) //移除字符串首尾空格
	filterSource, _ := this.GetInt("FilterSource")
	if filterSource <= 0 {
		filterSource = 1
	}
	//指标来源
	source, _ := this.GetInt("Source")

	frequency := this.GetString("Frequency") //频度

	isAddPredictEdb, _ := this.GetBool("IsAddPredictEdb") //是否查询添加预测指标

	var edbInfoList []*data_manage.EdbInfoList
	var err error

	noPermissionEdbInfoIdList := make([]int, 0) //无权限指标
	// 获取当前账号的不可见指标
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionEdbInfoIdList = append(noPermissionEdbInfoIdList, v.EdbInfoId)
		}
	}

	// 只看我的
	mine, _ := this.GetBool("IsShowMe")

	// 是否走ES
	isEs := false
	if keyWord != "" {
		var keyWordArr []string
		keyWordArr = append(keyWordArr, keyWord)

		newKeyWord := strings.Split(keyWord, " ")
		keyWordArr = append(keyWordArr, newKeyWord...)

		// 普通的搜索
		if mine {
			total, edbInfoList, err = elastic.SearchEdbInfoDataByAdminId(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, 1, frequency, this.SysUser.AdminId)
		} else {
			total, edbInfoList, err = elastic.SearchEdbInfoData(utils.DATA_INDEX_NAME, keyWord, startSize, pageSize, filterSource, source, -1, frequency, noPermissionEdbInfoIdList)
		}

		isEs = true
	} else {
		var condition string
		var pars []interface{}
		// 普通指标
		condition += ` AND edb_info_type = ? `
		pars = append(pars, 0)

		// 无权限指标id
		lenNoPermissionEdbInfoIdList := len(noPermissionEdbInfoIdList)
		if lenNoPermissionEdbInfoIdList > 0 {
			condition += ` AND edb_info_id  not in (` + utils.GetOrmInReplace(lenNoPermissionEdbInfoIdList) + `) `
			pars = append(pars, noPermissionEdbInfoIdList)
		}

		switch filterSource {
		case 2:
			condition += ` AND frequency='月度' `
		case 3:
			condition += ` AND frequency <> '日度' `
		case 4:
			condition += ` AND edb_type = 1 `
		case 5:
			condition += ` AND source = 6 ` //来源（同比值）
		case 6:
			condition += ` AND frequency != ? `
			pars = append(pars, "年度")
		}

		//频度
		if frequency != "" {
			condition += ` AND frequency = ? `
			pars = append(pars, frequency)
		}

		// 查询只允许添加预测指标的搜索
		if isAddPredictEdb {
			condition += ` AND frequency in ("日度","周度","月度") `
		}

		if mine {
			condition += ` AND sys_user_id = ? `
			pars = append(pars, this.SysUser.AdminId)
		}

		total, edbInfoList, err = data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
	}
	if err != nil {
		edbInfoList = make([]*data_manage.EdbInfoList, 0)
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))

	edbInfoListLen := len(edbInfoList)

	classifyIdList := make([]int, 0)
	for i := 0; i < edbInfoListLen; i++ {
		edbInfoList[i].EdbNameAlias = edbInfoList[i].EdbName
		classifyIdList = append(classifyIdList, edbInfoList[i].ClassifyId)
		// 如果没有关键词，那么搜索结果字段取指标名，前端已统一用该字段显示搜索的列表内容
		if keyWord == "" {
			if this.Lang == utils.ZhLangVersion {
				edbInfoList[i].SearchText = edbInfoList[i].EdbName
			}
			if this.Lang == utils.EnLangVersion {
				edbInfoList[i].SearchText = edbInfoList[i].EdbNameEn
			}
		}
	}

	// 当前列表中的分类map
	classifyMap := make(map[int]*data_manage.EdbClassify)
	if edbInfoListLen > 0 {
		classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
			return
		}

		for _, v := range classifyList {
			classifyMap[v.ClassifyId] = v
		}

		// 获取所有有权限的指标和分类
		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
			return
		}

		// 如果是ES的话，需要重新查一下指标的信息，主要是为了把是否授权字段找出来
		if isEs {
			edbInfoIdList := make([]int, 0)
			for i := 0; i < edbInfoListLen; i++ {
				edbInfoIdList = append(edbInfoIdList, edbInfoList[i].EdbInfoId)
				tmpEdbInfo := edbInfoList[i]
				if currClassify, ok := classifyMap[tmpEdbInfo.ClassifyId]; ok {
					edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfo.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfo.EdbInfoId, tmpEdbInfo.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
				}
			}

			tmpEdbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
				return
			}
			edbInfoMap := make(map[int]*data_manage.EdbInfo)
			for _, v := range tmpEdbList {
				edbInfoMap[v.EdbInfoId] = v
			}

			for i := 0; i < edbInfoListLen; i++ {
				tmpEdbInfo, ok := edbInfoMap[edbInfoList[i].EdbInfoId]
				if !ok {
					continue
				}
				edbInfoList[i].IsJoinPermission = tmpEdbInfo.IsJoinPermission
			}
		}

		// 权限校验
		for i := 0; i < edbInfoListLen; i++ {
			tmpEdbInfoItem := edbInfoList[i]
			if currClassify, ok := classifyMap[tmpEdbInfoItem.ClassifyId]; ok {
				edbInfoList[i].HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(tmpEdbInfoItem.IsJoinPermission, currClassify.IsJoinPermission, tmpEdbInfoItem.EdbInfoId, tmpEdbInfoItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
			}
		}

	}

	for i := 0; i < edbInfoListLen; i++ {
		for j := 0; j < edbInfoListLen; j++ {
			if (edbInfoList[i].EdbNameAlias == edbInfoList[j].EdbNameAlias) &&
				(edbInfoList[i].EdbInfoId != edbInfoList[j].EdbInfoId) &&
				!(strings.Contains(edbInfoList[i].EdbName, edbInfoList[i].SourceName)) {
				edbInfoList[i].EdbName = edbInfoList[i].EdbName + "(" + edbInfoList[i].SourceName + ")"
			}
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyWord
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	resp := data_manage.EdbInfoFilterDataResp{
		Paging: page,
		List:   edbInfoList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// GetEdbDateData
// @Title 根据指标ID和具体日期获取对应日期的数据值
// @Description 根据指标ID和具体日期获取对应日期的数据值
// @Param   EdbInfoId   query   int  false       "指标id"
// @Param   Date   query   string  false       "日期"
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/date_data [get]
func (this *EdbInfoController) GetEdbDateData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	edbInfoId, _ := this.GetInt("EdbInfoId")
	date := this.GetString("Date")
	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	if date == `` {
		br.Msg = "请选择日期"
		br.IsSendEmail = false
		return
	}
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取指标信息失败,Err:", err.Error())
		return
	}
	startDate := date
	endDate := date

	dateType := "day"
	//如果填写的是月度日期
	if strings.Count(date, "-") == 1 {
		startDate = date + "-01"
		endDate = ``
		dateType = "month"
	}
	dataItem, err := data.GetDateData(edbInfo, startDate, endDate)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取指数据失败,Err:", err.Error())
		return
	}
	val := ``
	if dataItem != nil {
		switch dateType {
		case "month":
			dateTime, _ := time.ParseInLocation(utils.FormatDate, dataItem.DataTime, time.Local)
			dateTimeStr := dateTime.Format(utils.FormatYearMonthDate)
			if dateTimeStr != date {
				val = ``
			}
		}
		val = fmt.Sprint(dataItem.Value)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = val
}

// GetEdbBeforeAndAfterDateData
// @Title 根据指标ID和具体日期获取对应日期的数据值+前后几期
// @Description 根据指标ID和具体日期获取对应日期的数据值+前后几期
// @Param   EdbInfoId   query   int  false       "指标id"
// @Param   Date   query   string  false       "日期"
// @Param   Num   query   int  false       "前后几期数据"
// @Success 200 {object} data_manage.EdbInfoList
// @router /edb_info/date_data/before_after [post]
func (this *EdbInfoController) GetEdbBeforeAndAfterDateData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	requestBody := string(this.Ctx.Input.RequestBody)
	var req request2.DateDataBeforeAfterReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	edbInfoId := req.EdbInfoId
	currDate := req.Date
	num := req.Num

	// 默认2期数据
	if num <= 0 {
		num = 2
	}

	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取指标信息失败,Err:", err.Error())
		return
	}

	dataList := make([]*data_manage.EdbDataList, 0)
	switch edbInfo.EdbInfoType {
	case 0:
		dataList, _ = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, ``, ``)
	case 1:
		_, dataList, _, _, _, _ = data.GetPredictDataListByPredictEdbInfoId(edbInfo.EdbInfoId, ``, ``, false)
	default:
		br.Msg = "指标类型异常！"
		br.ErrMsg = "指标类型异常，Err:" + strconv.Itoa(edbInfo.EdbInfoType)
		return
	}

	if currDate == `` {
		currDate, err = excel2.GetEdbDateByMoveForward(requestBody, dataList)
		if err != nil {
			br.Msg = "日期前移失败"
			br.ErrMsg = "日期前移失败，Err:" + err.Error()
			return
		}
	} else {
		if strings.Count(currDate, "-") == 1 {
			currDate = currDate + "-01"
			// 查找这个月早的时间作为起始时间
			for _, v := range dataList {
				if v.DataTime >= currDate {
					currDate = v.DataTime
					break
				}
			}
		}
	}
	currDate, err = excel2.HandleMixTableDateChange(currDate, requestBody)
	if err != nil {
		br.Msg = "日期变换失败"
		br.ErrMsg = "日期变换失败，Err:" + err.Error()
		return
	}
	list := make([]*data_manage.EdbDataList, 5)

	list, err = data.GetEdbBeforeAndAfterDateData(currDate, dataList)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取后面的指数据失败,Err:", err.Error())
		return
	}
	// 这个日期不存在的话直接返回空数组
	resp := data_manage.BeforeAndAfterDateDataResp{
		List: list,
		Date: currDate,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbChartAdminList
// @Title 获取创建人员分组
// @Description 获取创建人员分组
// @Param   Source   query   int  false       "来源 ：1：手工数据指标 2：钢联化工数据库 3：ETA指标库 4：ETA预测指标 5：图库"
// @Success 200 {object} company.DepartmentGroupSellersResp
// @router /edb_chart/adminList [get]
func (this *EdbInfoController) EdbChartAdminList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	source, _ := this.GetInt("Source", 0)
	if source <= 0 || source > 5 {
		br.Msg = "错误的来源"
		br.IsSendEmail = false
		return
	}

	idList, err := data.GetEdbChartAdminList(source)
	if err != nil {
		//br.Success = true
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败,Err:" + err.Error()
		return
	}

	fmt.Println("idlist:", idList)
	systemAdminMap := make(map[int]*system.Admin)
	departmentMap := make(map[string]string)
	departmentAdminMap := make(map[int]string)
	groupMap := make(map[string]string)
	systemAdminList, err := system.GetAdminListByIdListWithoutEnable(idList)
	if err != nil {
		br.Msg = "获取用户列表失败"
		br.ErrMsg = "获取用户列表失败,Err:" + err.Error()
		return
	}

	for _, v := range systemAdminList {
		systemAdminMap[v.AdminId] = v
		departmentMap[v.DepartmentName] = v.DepartmentName
		departmentAdminMap[v.AdminId] = v.DepartmentName
		groupMap[v.GroupName+v.DepartmentName] = v.DepartmentName
	}

	depList := make([]company.DepartmentGroupAdmins, 0)

	i := 1
	for _, v := range departmentMap {
		item := company.DepartmentGroupAdmins{
			AdminId:  "dep_" + strconv.Itoa(i),
			RealName: v,
		}
		i++
		depList = append(depList, item)
	}

	for k := 0; k < len(depList); k++ {
		for k1, v1 := range groupMap {
			if v1 == depList[k].RealName && v1 != "" {
				item := &company.DepartmentGroupAdmins{
					AdminId:  "group_" + strconv.Itoa(k),
					RealName: strings.Replace(k1, v1, "", -1),
				}
				depList[k].ChildrenList = append(depList[k].ChildrenList, item)
			}
		}
	}

	for _, admin := range systemAdminList {
		for i, v := range depList {
			for k, group := range v.ChildrenList {
				if admin.GroupName == group.RealName && admin.DepartmentName == v.RealName {
					item := &company.DepartmentGroupAdmins{
						AdminId:      strconv.Itoa(admin.AdminId),
						RealName:     admin.RealName,
						RoleTypeCode: admin.RoleTypeCode,
						Authority:    admin.Authority,
					}
					if group.RealName != "" {
						depList[i].ChildrenList[k].ChildrenList = append(depList[i].ChildrenList[k].ChildrenList, item)
					} else {
						depList[i].ChildrenList = append(depList[i].ChildrenList, item)
					}
				}
			}
		}
	}

	for i, groupList := range depList {
		for k, v := range groupList.ChildrenList {
			if v.RealName == "" {
				newChildrenList := append(groupList.ChildrenList[:k], groupList.ChildrenList[k+1:]...)
				depList[i].ChildrenList = newChildrenList
			}
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = depList
}

// EdbSourceList
// @Title 指标来源列表
// @Description 指标来源列表
// @Param   IsBase   query   int  false	"是否为基础指标: 1-是"
// @Success 200 {object} data_manage.EdbInfoListResp
// @router /edb_source/list [get]
func (this *EdbInfoController) EdbSourceList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	isBase, _ := this.GetInt("IsBase", 0)

	cond := ``
	if isBase > 0 {
		cond = ` AND is_base = 1`
	}
	pars := make([]interface{}, 0)
	list, e := data_manage.GetEdbSourceItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标来源列表失败, Err: " + e.Error()
		return
	}

	br.Data = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// EdbSourceListByPython
// @Title 指标来源列表
// @Description 指标来源列表
// @Param   IsBase   query   int  false	"是否为基础指标: 1-是"
// @Success 200 {object} data_manage.EdbInfoListResp
// @router /edb_source/list/python [get]
func (this *EdbInfoController) EdbSourceListByPython() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	isBase, _ := this.GetInt("IsBase", 0)

	cond := ``
	if isBase > 0 {
		cond = ` AND is_base = 1`
	}
	pars := make([]interface{}, 0)
	list, e := data_manage.GetEdbSourceItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标来源列表失败, Err: " + e.Error()
		return
	}

	baseEdbList := make([]data_manage.EdbSourceChild, 0)
	calEdbList := make([]data_manage.EdbSourceChild, 0)
	for _, v := range list {
		switch v.IsBase {
		case 1:
			baseEdbList = append(baseEdbList, data_manage.EdbSourceChild{
				EdbSourceId: v.EdbSourceId,
				SourceName:  v.SourceName,
				IsBase:      v.IsBase,
				TableName:   v.TableName,
				Child:       []data_manage.EdbSourceChild{},
			})
		case 2:
			calEdbList = append(calEdbList, data_manage.EdbSourceChild{
				EdbSourceId: v.EdbSourceId,
				SourceName:  v.SourceName,
				IsBase:      v.IsBase,
				TableName:   v.TableName,
				Child:       []data_manage.EdbSourceChild{},
			})
		}
	}
	resp := []data_manage.EdbSourceChild{
		{
			EdbSourceId: 0,
			SourceName:  "基础指标",
			IsBase:      1,
			Child:       baseEdbList,
		},
		{
			EdbSourceId: 0,
			SourceName:  "计算指标",
			IsBase:      1,
			Child:       calEdbList,
		},
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// EdbChartList
// @Title 指标缩略图列表接口
// @Description 指标缩略图列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ClassifyId   query   int  true       "分类id"
// @Param   AdminId   query   int  false       "创建人id"
// @Param   IsOnlyMe   query   bool  false       "是否只看我的"
// @Success 200 {object} response.EdbInfoChartListResp
// @router /edb_info/chart/list [get]
func (this *EdbInfoController) EdbChartList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	// 分页
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	// 基础指标
	var condition string
	var pars []interface{}
	condition += ` AND edb_info_type = ? `
	pars = append(pars, 0)

	// 分类筛选
	classifyId, _ := this.GetInt("ClassifyId")
	if classifyId > 0 {
		childClassify, e, _ := data.GetChildClassifyByClassifyId(classifyId)
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类信息失败, GetEdbClassify,Err:" + e.Error()
			return
		}
		var classifyIds []int
		for _, v := range childClassify {
			classifyIds = append(classifyIds, v.ClassifyId)
		}
		condition += fmt.Sprintf(` AND classify_id IN (%s) `, utils.GetOrmInReplace(len(classifyIds)))
		pars = append(pars, classifyIds)
	}

	// 创建人
	adminId, _ := this.GetInt("AdminId")
	if adminId > 0 {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, adminId)
	}

	// 只看我的
	isOnlyMe, _ := this.GetBool("IsOnlyMe")
	if isOnlyMe {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	// 获取当前账号的不可见指标
	obj := data_manage.EdbInfoNoPermissionAdmin{}
	confList, e := obj.GetAllListByAdminId(this.SysUser.AdminId)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取不可见指标配置数据失败，Err:" + e.Error()
		return
	}
	noPermissionEdbInfoIdList := make([]int, 0)
	for _, v := range confList {
		noPermissionEdbInfoIdList = append(noPermissionEdbInfoIdList, v.EdbInfoId)
	}
	noPermissionEdbInfoIdNum := len(noPermissionEdbInfoIdList)
	if noPermissionEdbInfoIdNum > 0 {
		condition += ` AND edb_info_id NOT IN (` + utils.GetOrmInReplace(noPermissionEdbInfoIdNum) + `) `
		pars = append(pars, noPermissionEdbInfoIdList)
	}

	// 获取指标信息
	dataCount, list, e := data_manage.GetEdbInfoFilterList(condition, pars, startSize, pageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取普通指标列表失败, Err:" + e.Error()
		return
	}
	if len(list) == 0 {
		list = make([]*data_manage.EdbInfoList, 0)
	} else {
		classifyIdList := make([]int, 0)
		for _, v := range list {
			classifyIdList = append(classifyIdList, v.ClassifyId)
		}

		// 指标权限
		{
			// 当前的分类
			classifyMap := make(map[int]*data_manage.EdbClassify)
			classifyList, err := data_manage.GetEdbClassifyByIdList(classifyIdList)
			if err != nil {
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取分类列表失败，Err:" + err.Error()
					return
				}
			}

			for _, v := range classifyList {
				classifyMap[v.ClassifyId] = v
			}

			// 获取所有有权限的指标和分类
			permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(this.SysUser.AdminId, 0, 0)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
				return
			}

			issSupplierStopIndexCodeMap := make(map[string]bool)
			{
				tmpEdbCodeList := make([]string, 0)
				for _, v := range list {
					if v.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
						tmpEdbCodeList = append(tmpEdbCodeList, v.EdbCode)
					}
				}
				if len(tmpEdbCodeList) > 0 {
					notIsSupplierStopIndexList, e := data_manage.GetNotIsSupplierStopIndexByCodeList(tmpEdbCodeList, 1)
					if e != nil {
						br.Msg = "获取失败"
						br.ErrMsg = "获取数据失败，Err:" + e.Error()
						return
					}

					// 已被供应商暂停的指标编码
					for _, v := range notIsSupplierStopIndexList {
						issSupplierStopIndexCodeMap[v.IndexCode] = true
					}
				}
			}

			for _, v := range list {
				if currClassify, ok := classifyMap[v.ClassifyId]; ok {
					v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(v.IsJoinPermission, currClassify.IsJoinPermission, v.EdbInfoId, v.ClassifyId, permissionEdbIdList, permissionClassifyIdList)

					v.Button = data.GetEdbOpButton(sysUser, v.SysUserId, v.EdbType, v.EdbInfoType, v.HaveOperaAuth)
				}

				// 供应商停用
				if v.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
					if _, ok := issSupplierStopIndexCodeMap[v.EdbCode]; ok {
						v.IsSupplierStop = 1
					}
				}
				var relation *data_manage.BaseRelationEdbInfo
				relation, err = data.GetEdbRelationListById(v.EdbInfoId, v.Source)
				if err != nil && !utils.IsErrNoRow(err) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据引用信息失败，Err:" + e.Error()
					return
				}
				if relation != nil && relation.RelationNum > 0 {
					v.IsRelation = true
				}
			}
		}
		page = paging.GetPaging(currentIndex, pageSize, int(dataCount))
	}

	resp := response.EdbInfoChartListResp{
		Paging: page,
		List:   list,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// Modify
// @Title 修改指标信息接口
// @Description 编辑指标接口
// @Success 200 string "操作成功"
// @router /edb_info/modify [post]
func (this *EdbInfoController) Modify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req request.ModifyEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	edbInfoId := req.EdbInfoId
	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}

	edbInfo, e := data_manage.GetEdbInfoById(req.EdbInfoId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取指标信息失败, Err:" + err.Error()
		return
	}

	var haveOperaAuth bool
	// 权限校验
	{
		haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, this.SysUser.AdminId)
		if err != nil {
			br.Msg = err.Error()
			br.ErrMsg = "校验指标权限失败，err:" + err.Error()
			return
		}
	}

	// 编辑权限校验
	button := data.GetEdbOpButton(this.SysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
	if !button.OpButton {
		br.Msg = "无权限操作"
		return
	}

	edbInfo.MaxValue = req.MaxValue
	edbInfo.MinValue = req.MinValue
	edbInfo.ManualSave = 1
	edbInfo.ModifyTime = time.Now()
	err = edbInfo.Update([]string{"MaxValue", "MinValue", "ManualSave", "ModifyTime"})
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败,Err:" + err.Error()
		return
	}

	//修改es
	data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	br.Ret = 200
	br.Success = true
	br.Msg = "修改成功"
	br.IsAddLog = true
}

// ChartImageSet
// @Title 设置指标的图表图片
// @Description 设置指标的图表图片接口
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /edb_info/image/set [post]
func (this *EdbInfoController) ChartImageSet() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req data_manage.SetEdbInfoImageReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if req.EdbInfoId <= 0 || req.ImageUrl == "" {
		br.Ret = 200
		br.Success = true
		br.Msg = "保存成功"
		return
	}

	edbInfo, e := data_manage.GetEdbInfoById(req.EdbInfoId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "找不到该指标"
			return
		}
		br.Msg = "保存失败"
		br.ErrMsg = "获取指标失败, Err:" + e.Error()
		return
	}
	edbInfo.ChartImage = req.ImageUrl
	if e = edbInfo.Update([]string{"ChartImage"}); e != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "更新指标缩略图失败, Err:" + e.Error()
		return
	}

	// 修改es数据
	go data.AddOrEditEdbInfoToEs(req.EdbInfoId)

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
}

// EdbInfoExistCheck
// @Title 新增指标-检验指标是否存在接口
// @Description 新增指标-检验指标是否存在接口
// @Param   Source   query   int  true       "来源:1:同花顺,2:wind"
// @Param   SubSource   query   int  true       "子数据来源:0:经济数据库,1:日期序列"
// @Param   EdbCode   query   string  false       "指标编码/指标代码"
// @Param   StockCode   query   string  false       "证券代码"
// @Success 200 {object} data_manage.EdbInfoExistCheckResp
// @router /edb_info/exist/check [get]
func (this *EdbInfoController) EdbInfoExistCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		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)
	subSource, _ := this.GetInt("SubSource")
	stockCode := this.GetString("StockCode")

	if source <= 0 {
		br.Msg = "无效的数据来源"
		return
	}

	if edbCode == "" {
		br.Msg = "请输入指标ID"
		return
	}

	if source != utils.DATA_SOURCE_WIND && source != utils.DATA_SOURCE_THS {
		br.Msg = "无效的数据来源"
		return
	}
	if subSource != utils.DATA_SUB_SOURCE_DATE {
		br.Msg = "无效的数据库来源"
		return
	}

	var indexCodeArr []string
	edbCodeArr := strings.Split(edbCode, ",")
	stockCodeArr := strings.Split(stockCode, ",")

	var prefix string
	if source == utils.DATA_SOURCE_WIND {
		prefix = utils.WindDbWsd
	} else if source == utils.DATA_SOURCE_THS {
		prefix = utils.ThsDs
	} else {
		br.Msg = "来源错误"
		br.ErrMsg = "来源错误"
		return
	}
	for _, sv := range stockCodeArr {
		for _, ev := range edbCodeArr {
			indexCode := prefix + sv + ev
			indexCodeArr = append(indexCodeArr, indexCode)
		}
	}
	indexList, err := data_manage.GetEdbInfoByEdbCodeList(source, indexCodeArr)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "校验指标是否存在失败"
		br.ErrMsg = "校验指标是否存在失败,Err:" + err.Error()
		return
	}
	var existStockCodeArr []string
	var existEdbCodeArr []string
	var existClassifyId []int
	var existIndexId []int

	for _, indexItem := range indexList {
		for _, sv := range stockCodeArr {
			for _, ev := range edbCodeArr {
				if strings.Contains(indexItem.EdbCode, sv) {
					existStockCodeArr = append(existStockCodeArr, sv)
				}
				if strings.Contains(indexItem.EdbCode, ev) {
					existEdbCodeArr = append(existEdbCodeArr, ev)
					existClassifyId = append(existClassifyId, indexItem.ClassifyId)
					existIndexId = append(existIndexId, indexItem.EdbInfoId)
				}
			}
		}
	}

	resp := new(data_manage.EdbInfoExistCheckResp)
	if len(indexList) > 0 {
		resp.IndexExist = true
	}
	resp.ExistEdbCodeArr = existEdbCodeArr
	resp.ExistStockCodeArr = existStockCodeArr
	resp.ExistClassifyId = existClassifyId
	resp.ExistIndexId = existIndexId
	resp.ExistEdbInfo = indexList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoAdd
// @Title 指标批量保存接口
// @Description 指标批量保存接口
// @Param	request	body data_manage.BatchAddEdbInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /edb_info/batch/add [post]
func (this *EdbInfoController) EdbInfoBatchAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_BATCH_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	var req data_manage.BatchAddEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	resp := new(data_manage.AddEdbInfoResp)

	var edbNames string
	for _, v := range req.BatchList {
		edbNames += "'" + v.EdbName + "',"
	}
	edbNames = strings.Trim(edbNames, ",")
	infoList, err := data_manage.GetEdbInfoByNames(edbNames)
	if err != nil {
		br.Msg = "查询指标名称重复错误！"
		br.ErrMsg = "GetEdbInfoByNames，Err:" + err.Error()
		return
	}
	if len(infoList) > 0 {
		for _, v := range infoList {
			resp.ExistEdbName = append(resp.ExistEdbName, v.EdbName)
		}
		br.Data = resp
		br.Msg = "指标名称重复！"
		br.ErrMsg = "指标名称重复"
		return
	}

	for k, v := range req.BatchList {
		v.EdbName = strings.Trim(v.EdbName, " ")
		v.EdbCode = strings.Trim(v.EdbCode, " ")
		v.StockCode = strings.Trim(v.StockCode, " ")

		if v.Source <= 0 {
			br.Msg = "无效的数据来源"
			return
		}

		if v.EdbCode == "" {
			br.Msg = "指标ID不能为空"
			return
		}

		if v.StockCode == "" {
			br.Msg = "证券代码不能为空"
			return
		}

		if v.EdbName == "" {
			br.Msg = "指标名称不能为空"
			return
		}

		if v.Frequency == "" {
			br.Msg = "频率不能为空"
			return
		}

		if v.ClassifyId <= 0 {
			br.Msg = "请选择分类"
			return
		}

		terminalCode, serverUrl, _, e := data.GetEdbTerminalCodeBySource(v.Source, v.EdbCode, v.StockCode)
		if e != nil {
			br.Msg = "获取可以使用的终端地址失败"
			br.ErrMsg = "获取可以使用的终端地址失败，Err:" + e.Error()
			return
		}

		edbInfoItem := new(data_manage.EdbInfo)
		edbInfoItem.Source = v.Source
		switch v.Source {
		case utils.DATA_SOURCE_WIND:
			edbInfoItem.SourceName = "wind"
			edbInfoItem.EdbCode = utils.WindDbWsd + v.StockCode + v.EdbCode
		case utils.DATA_SOURCE_THS:
			edbInfoItem.SourceName = "ths"
			edbInfoItem.EdbCode = utils.ThsDs + v.StockCode + v.EdbCode
		}
		edbInfoItem.SubSource = utils.DATA_SUB_SOURCE_DATE
		edbInfoItem.SubSourceName = "日期序列"
		edbInfoItem.EdbName = v.EdbName
		edbInfoItem.EdbNameSource = v.EdbName
		edbInfoItem.EdbNameEn = v.EdbName
		edbInfoItem.Frequency = v.Frequency
		edbInfoItem.Unit = v.Unit
		edbInfoItem.UnitEn = v.Unit
		edbInfoItem.ClassifyId = v.ClassifyId
		edbInfoItem.SysUserId = sysUser.AdminId
		edbInfoItem.SysUserRealName = sysUser.RealName
		edbInfoItem.IndicatorCode = v.EdbCode
		edbInfoItem.StockCode = v.StockCode
		edbInfoItem.TerminalCode = terminalCode
		edbInfoItem.ServerUrl = serverUrl
		var extra data_manage.EdbInfoExtra
		if v.ApiExtraPars != "" {
			extra.ApiExtraPars = v.ApiExtraPars
			b, e := json.Marshal(extra)
			if e != nil {
				br.Msg = "保存失败"
				br.ErrMsg = fmt.Sprintf("额外参数JSON格式化失败, %v", e)
				return
			}
			edbInfoItem.Extra = string(b)
		}

		// 指标入库
		edbInfo, err, errMsg, isSendEmail := data.EdbInfoWsdAdd(edbInfoItem)
		if err != nil {
			br.Msg = "保存失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = err.Error()
			br.IsSendEmail = isSendEmail
			return
		}
		//新增操作日志
		{
			edbLog := new(data_manage.EdbInfoLog)
			edbLog.EdbInfoId = edbInfo.EdbInfoId
			edbLog.SourceName = edbInfo.SourceName
			edbLog.Source = edbInfo.Source
			edbLog.EdbCode = edbInfo.EdbCode
			edbLog.EdbName = edbInfo.EdbName
			edbLog.ClassifyId = edbInfo.ClassifyId
			edbLog.SysUserId = sysUser.AdminId
			edbLog.SysUserRealName = sysUser.RealName
			edbLog.CreateTime = time.Now()
			edbLog.Content = string(this.Ctx.Input.RequestBody)
			edbLog.Status = "新增指标"
			edbLog.Method = this.Ctx.Input.URI()
			go data_manage.AddEdbInfoLog(edbLog)
		}

		if k <= 0 {
			resp.EdbInfoId = edbInfo.EdbInfoId
			resp.UniqueCode = edbInfo.UniqueCode
		}
	}

	// 试用平台更新用户累计新增指标数
	adminItem, e := system.GetSysAdminById(sysUser.AdminId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取系统用户数据失败，Err:" + err.Error()
		return
	}
	if utils.BusinessCode == utils.BusinessCodeSandbox && adminItem.DepartmentName == "ETA试用客户" {
		go func() {
			var r etaTrialService.EtaTrialUserReq
			r.Mobile = adminItem.Mobile
			_, _ = etaTrialService.UpdateUserIndexNum(r)
		}()
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// SmmExistCheck
// @Title 新增指标-检验指标是否存在接口-smm
// @Description 新增指标-检验指标是否存在接口-smm
// @Param   SubSource   query   int  true       "子数据来源:0:经济数据库,1:日期序列"
// @Param   EdbCode   query   string  false       "指标编码/指标代码"
// @Param   StockCode   query   string  false       "证券代码"
// @Success 200 {object} data_manage.EdbInfoExistCheckResp
// @router /edb_info/smm/exist/check [post]
func (this *EdbInfoController) SmmExistCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.SmmIndexExistCheckReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	types := req.Types
	frequency := req.Frequency
	dataState := req.DataState
	selectAll := req.SelectAll
	keyword := req.Keyword

	edbCode := req.EdbCode
	edbCode = strings.Trim(edbCode, "\t")
	edbCode = strings.Trim(edbCode, " ")
	edbCode = strings.Replace(edbCode, "\t", "", -1)

	var edbCodeArr []string
	var codeArr []string

	if selectAll {
		// 如果勾了列表全选，那么EdbCode传的就是排除的code

		var condition string
		var pars []interface{}

		if len(types) > 0 {
			condition += " AND ( "
			for _, v := range types {
				typeArr := strings.Split(v, ",")
				for i, v := range typeArr {
					if i == 0 {
						condition += " ( "
					}
					typeStr := "type_"
					typeStr += fmt.Sprintf("%d", i+1)
					condition += typeStr + " =? "
					pars = append(pars, v)
					if i == len(typeArr)-1 {
						condition += " ) "
					} else {
						condition += " AND "
					}
				}
				condition += " OR "
			}
			condition = strings.Trim(condition, "OR ")
			condition += " ) "
		}

		if frequency != "" {
			frequencyArr := strings.Split(frequency, ",")
			condition += ` AND frequency IN (` + utils.GetOrmInReplace(len(frequencyArr)) + `) `
			pars = append(pars, frequencyArr)
		}

		if dataState != "" {
			stateArr := strings.Split(dataState, ",")
			if strings.Contains(dataState, "normal") {
				stateArr = append(stateArr, "")
				condition += ` AND data_state IN (` + utils.GetOrmInReplace(len(stateArr)) + `) `
				pars = append(pars, stateArr)
			} else {
				condition += ` AND data_state IN (` + utils.GetOrmInReplace(len(stateArr)) + `) `
				pars = append(pars, stateArr)
			}
		}

		if keyword != "" {
			keyWordArr := strings.Split(keyword, " ")
			if len(keyWordArr) > 0 {
				condition += " AND ( "
				for _, v := range keyWordArr {
					condition += ` CONCAT(index_name,index_code) LIKE '%` + v + `%' OR`
				}
				condition = strings.TrimRight(condition, "OR")
				condition += " ) "
			}
		}

		indexList, err := data_manage.GetSmmIndexDataListNoPage(condition, pars)
		if err != nil {
			br.Msg = "获取指标列表失败"
			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
			return
		}

		for _, v := range indexList {
			codeArr = append(codeArr, v.IndexCode)
		}

		noUseCodeArr := strings.Split(edbCode, ",")

		for _, code := range codeArr {
			// 检查code是否在noUseCodeArr数组中
			if !utils.ArrContainsStr(noUseCodeArr, code) {
				// 如果不在，将其添加到结果数组中
				edbCodeArr = append(edbCodeArr, code)
			}
		}

	} else {
		//未勾选全选EdbCode就是需要的code
		edbCodeArr = strings.Split(edbCode, ",")
	}

	if len(edbCodeArr) > 30 {
		br.Msg = "最多只能选择30个指标"
		return
	}

	if len(edbCodeArr) <= 0 {
		br.Msg = "无符合指标或指标代码错误"
		return
	}

	indexList, err := data_manage.GetEdbInfoByEdbCodeList(utils.DATA_SOURCE_YS, edbCodeArr)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "校验指标是否存在失败"
		br.ErrMsg = "校验指标是否存在失败,Err:" + err.Error()
		return
	}
	var existEdbCodeArr []string
	var existClassifyId []int
	var existIndexId []int

	for _, indexItem := range indexList {
		for _, ev := range edbCodeArr {
			if strings.Contains(indexItem.EdbCode, ev) {
				existEdbCodeArr = append(existEdbCodeArr, ev)
				existClassifyId = append(existClassifyId, indexItem.ClassifyId)
				existIndexId = append(existIndexId, indexItem.EdbInfoId)
			}
		}
	}

	resp := new(data_manage.EdbInfoSmmExistCheckResp)
	if len(indexList) > 0 {
		resp.IndexExist = true
	}
	if len(existEdbCodeArr) == len(edbCodeArr) {
		resp.ExistAll = true
	}
	resp.ExistEdbCodeArr = existEdbCodeArr
	resp.ExistClassifyId = existClassifyId
	resp.ExistIndexId = existIndexId
	resp.ExistEdbInfo = indexList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbInfoSearch
// @Title 新增指标-查询指标信息接口-smm
// @Description 新增指标-查询指标信息接口-smm
// @Param   Source   query   int  true       "来源:1:同花顺,2:wind,3:彭博"
// @Param   SubSource   query   int  true       "子数据来源:0:经济数据库,1:日期序列"
// @Param   EdbCode   query   string  false       "指标编码/指标代码"
// @Param   StockCode   query   string  false       "证券代码"
// @Success 200 {object} data_manage.EdbInfoSearchResp
// @router /edb_info/smm/search [post]
func (this *EdbInfoController) EdbInfoSmmSearch() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.SmmIndexExistCheckReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	types := req.Types
	frequency := req.Frequency
	dataState := req.DataState
	selectAll := req.SelectAll
	keyword := req.Keyword
	edbCode := req.EdbCode
	edbCode = strings.Trim(edbCode, "\t")
	edbCode = strings.Trim(edbCode, " ")
	edbCode = strings.Replace(edbCode, "\t", "", -1)

	var edbCodeArr []string
	var codeArr []string

	if selectAll {
		// 如果勾了列表全选，那么EdbCode传的就是排除的code

		var condition string
		var pars []interface{}

		if len(types) > 0 {
			condition += " AND ( "
			for _, v := range types {
				typeArr := strings.Split(v, ",")
				for i, v := range typeArr {
					if i == 0 {
						condition += " ( "
					}
					typeStr := "type_"
					typeStr += fmt.Sprintf("%d", i+1)
					condition += typeStr + " =? "
					pars = append(pars, v)
					if i == len(typeArr)-1 {
						condition += " ) "
					} else {
						condition += " AND "
					}
				}
				condition += " OR "
			}
			condition = strings.Trim(condition, "OR ")
			condition += " ) "
		}

		if frequency != "" {
			frequencyArr := strings.Split(frequency, ",")
			condition += ` AND frequency IN (` + utils.GetOrmInReplace(len(frequencyArr)) + `) `
			pars = append(pars, frequencyArr)
		}

		if dataState != "" {
			stateArr := strings.Split(dataState, ",")
			if strings.Contains(dataState, "normal") {
				stateArr = append(stateArr, "")
				condition += ` AND data_state IN (` + utils.GetOrmInReplace(len(stateArr)) + `) `
				pars = append(pars, stateArr)
			} else {
				condition += ` AND data_state IN (` + utils.GetOrmInReplace(len(stateArr)) + `) `
				pars = append(pars, stateArr)
			}
		}

		if keyword != "" {
			keyWordArr := strings.Split(keyword, " ")
			if len(keyWordArr) > 0 {
				condition += " AND ( "
				for _, v := range keyWordArr {
					condition += ` CONCAT(index_name,index_code) LIKE '%` + v + `%' OR`
				}
				condition = strings.TrimRight(condition, "OR")
				condition += " ) "
			}
		}

		indexList, err := data_manage.GetSmmIndexDataListNoPage(condition, pars)
		if err != nil {
			br.Msg = "获取指标列表失败"
			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
			return
		}

		for _, v := range indexList {
			codeArr = append(codeArr, v.IndexCode)
		}

		noUseCodeArr := strings.Split(edbCode, ",")

		for _, code := range codeArr {
			// 检查code是否在noUseCodeArr数组中
			if !utils.ArrContainsStr(noUseCodeArr, code) {
				// 如果不在，将其添加到结果数组中
				edbCodeArr = append(edbCodeArr, code)
			}
		}

	} else {
		//未勾选全选EdbCode就是需要的code
		edbCodeArr = strings.Split(edbCode, ",")
	}

	if len(edbCodeArr) > 30 {
		br.Msg = "最多只能选择30个指标"
		return
	}

	if len(edbCodeArr) <= 0 {
		br.Msg = "无符合指标或指标代码错误"
		return
	}

	edbCodeStr := ""
	for i, _ := range edbCodeArr {
		edbCodeStr += "'" + edbCodeArr[i] + "'" + ","
	}
	edbCodeStr = strings.Trim(edbCodeStr, ",")
	smmInfoList, err := data_manage.GetBaseFromSmmIndexByIndexCodes(edbCodeStr)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取失败"
		br.ErrMsg = "获取有色指标详情失败,Err:" + err.Error()
		return
	}

	smmInfoMap := make(map[string]*data_manage.BaseFromSmmIndex)
	for _, v := range smmInfoList {
		smmInfoMap[v.IndexCode] = v
	}

	searchItemList := make([]*data_manage.EdbInfoSearch, 0)

	resp := new(data_manage.EdbInfoSearchResp)
	needAddCodeArr := make([]string, 0)
	noNeedAddCodeMap := make(map[string]string, 0)

	for _, edbCode := range edbCodeArr {
		dataItems, err := data_manage.GetEdbDataAllByEdbCode(edbCode, utils.DATA_SOURCE_YS, utils.DATA_SUB_SOURCE_EDB, utils.EDB_DATA_LIMIT)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取Ys已存在信息失败,Err:" + err.Error()
			return
		}

		fmt.Println("dataItems:", len(dataItems))
		if len(dataItems) > 0 {
			searchItem := new(data_manage.EdbInfoSearch)
			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
			searchItem.Frequency = smmInfoMap[edbCode].Frequency
			searchItem.Unit = smmInfoMap[edbCode].Unit
			searchItem.EdbName = smmInfoMap[edbCode].IndexName
			searchItem.EdbCode = smmInfoMap[edbCode].IndexCode

			searchItemList = append(searchItemList, searchItem)

			noNeedAddCodeMap[edbCode] = edbCode
		} else {
			// 把需要新加的code添加到needAddCodeArr数组中，一起批量请求
			needAddCodeArr = append(needAddCodeArr, edbCode)
		}
	}
	if len(needAddCodeArr) > 0 {
		edbCode = strings.Join(needAddCodeArr, ",")
		respItem, err := data.AddEdbData(utils.DATA_SOURCE_YS, edbCode, "")
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败,Err:" + err.Error()
			return
		}
		if respItem.Ret != 200 {
			if respItem.Ret == 421 {
				br.Msg = "该渠道已超过添加上限"
			} else if respItem.Ret == 4052 {
				br.Msg = "该指标已下架"
			} else {
				br.Msg = "未搜索到该指标"
			}
			br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + edbCode
			return
		}
	}

	for _, smmInfo := range smmInfoList {
		if smmInfo != nil {
			if _, ok := noNeedAddCodeMap[smmInfo.IndexCode]; !ok {
				searchItem := new(data_manage.EdbInfoSearch)
				minDate, maxDate, err := data_manage.GetEdbDataYsMaxAndMinDate(smmInfo.IndexCode)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取YS日期信息失败,Err:" + err.Error()
					return
				}
				searchItem.StartDate = minDate
				searchItem.EndDate = maxDate
				searchItem.Frequency = smmInfo.Frequency
				searchItem.Unit = smmInfo.Unit
				searchItem.EdbName = smmInfo.IndexName
				searchItem.EdbCode = smmInfo.IndexCode
				dataList, err := data_manage.GetEdbDataAllByEdbCode(smmInfo.IndexCode, utils.DATA_SOURCE_YS, utils.DATA_SUB_SOURCE_EDB, utils.EDB_DATA_LIMIT)
				if err != nil && !utils.IsErrNoRow(err) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据失败,GetEdbDataAllByEdbCode Err:" + err.Error()
					return
				}
				searchItem.DataList = dataList

				searchItemList = append(searchItemList, searchItem)
			}
		}
	}

	resp.Status = 2
	resp.StockSearchList = searchItemList

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// SmmEdbInfoBatchAdd
// @Title 指标批量保存接口-smm
// @Description 指标批量保存接口-smm
// @Param	request	body data_manage.BatchAddEdbInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /edb_info/smm/batch/add [post]
func (this *EdbInfoController) SmmEdbInfoBatchAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_BATCH_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	var req data_manage.BatchAddEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	resp := new(data_manage.AddEdbInfoResp)

	var edbNames string
	for _, v := range req.BatchList {
		edbNames += "'" + v.EdbName + "',"
	}
	edbNames = strings.Trim(edbNames, ",")
	infoList, err := data_manage.GetEdbInfoByNames(edbNames)
	if err != nil {
		br.Msg = "查询指标名称重复错误！"
		br.ErrMsg = "GetEdbInfoByNames，Err:" + err.Error()
		return
	}
	if len(infoList) > 0 {
		for _, v := range infoList {
			resp.ExistEdbName = append(resp.ExistEdbName, v.EdbName)
		}
		br.Data = resp
		br.Msg = "指标名称重复！"
		br.ErrMsg = "指标名称重复"
		return
	}

	for k, v := range req.BatchList {
		v.EdbName = strings.Trim(v.EdbName, " ")
		v.EdbCode = strings.Trim(v.EdbCode, " ")

		if v.Source <= 0 {
			br.Msg = "无效的数据来源"
			return
		}

		if v.EdbCode == "" {
			br.Msg = "指标ID不能为空"
			return
		}

		if v.EdbName == "" {
			br.Msg = "指标名称不能为空"
			return
		}

		if v.Frequency == "" {
			br.Msg = "频率不能为空"
			return
		}

		if v.ClassifyId <= 0 {
			br.Msg = "请选择分类"
			return
		}

		edbInfoItem := new(data_manage.EdbInfo)
		edbInfoItem.Source = v.Source
		edbInfoItem.SourceName = "SMM"
		edbInfoItem.EdbCode = v.EdbCode
		edbInfoItem.SubSource = 0
		edbInfoItem.SubSourceName = ""
		edbInfoItem.EdbName = v.EdbName
		edbInfoItem.EdbNameSource = v.EdbName
		edbInfoItem.EdbNameEn = v.EdbName
		edbInfoItem.Frequency = v.Frequency
		edbInfoItem.Unit = v.Unit
		edbInfoItem.UnitEn = v.Unit
		edbInfoItem.ClassifyId = v.ClassifyId
		edbInfoItem.SysUserId = sysUser.AdminId
		edbInfoItem.SysUserRealName = sysUser.RealName
		edbInfoItem.IndicatorCode = ""
		edbInfoItem.StockCode = ""

		// 指标入库
		edbInfo, err, errMsg, isSendEmail := data.EdbInfoWsdAdd(edbInfoItem)
		if err != nil {
			br.Msg = "保存失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = err.Error()
			br.IsSendEmail = isSendEmail
			return
		}
		//新增操作日志
		{
			edbLog := new(data_manage.EdbInfoLog)
			edbLog.EdbInfoId = edbInfo.EdbInfoId
			edbLog.SourceName = edbInfo.SourceName
			edbLog.Source = edbInfo.Source
			edbLog.EdbCode = edbInfo.EdbCode
			edbLog.EdbName = edbInfo.EdbName
			edbLog.ClassifyId = edbInfo.ClassifyId
			edbLog.SysUserId = sysUser.AdminId
			edbLog.SysUserRealName = sysUser.RealName
			edbLog.CreateTime = time.Now()
			edbLog.Content = string(this.Ctx.Input.RequestBody)
			edbLog.Status = "新增指标"
			edbLog.Method = this.Ctx.Input.URI()
			go data_manage.AddEdbInfoLog(edbLog)
		}

		if k <= 0 {
			resp.EdbInfoId = edbInfo.EdbInfoId
			resp.UniqueCode = edbInfo.UniqueCode
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// ChartImageSetBySvg
// @Title 设置指标的图表图片
// @Description 设置指标的图表图片接口
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /edb_info/image/set_by_svg [post]
func (this *EdbInfoController) ChartImageSetBySvg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	picType := this.GetString("PicType")
	imgData := this.GetString("Img")
	if imgData == "" {
		br.Msg = "图片参数错误"
		br.ErrMsg = "图片参数错误,Img Is Empty"
		return
	}
	if strings.ToLower(picType) == "png" {
		b, _ := regexp.MatchString(`^data:\s*image\/(\w+);base64,`, imgData)
		if !b {
			br.Msg = "图片格式不正确"
			br.ErrMsg = "图片格式不正确"
			return
		}
		re, _ := regexp.Compile(`^data:\s*image\/(\w+);base64,`)
		base64Str := re.ReplaceAllString(imgData, "")
		base64Str = strings.Replace(base64Str, " ", "", -1)
		imgData = base64Str
	}
	edbInfoId, _ := this.GetInt("EdbInfoId", 0)
	if edbInfoId <= 0 {
		br.Msg = "指标参数错误"
		br.ErrMsg = "指标参数错误,EdbInfoId Is Empty"
		return
	}

	// 通过svg图片生成图片资源地址
	resourceUrl, err, errMsg := services.GetResourceUrlBySvgImg(imgData)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	if edbInfoId <= 0 || resourceUrl == "" {
		br.Ret = 200
		br.Success = true
		br.Msg = "保存成功"
		return
	}

	edbInfo, e := data_manage.GetEdbInfoById(edbInfoId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "找不到该指标"
			return
		}
		br.Msg = "保存失败"
		br.ErrMsg = "获取指标失败, Err:" + e.Error()
		return
	}
	edbInfo.ChartImage = resourceUrl
	if e = edbInfo.Update([]string{"ChartImage"}); e != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "更新指标缩略图失败, Err:" + e.Error()
		return
	}

	// 修改es数据
	go data.AddOrEditEdbInfoToEs(edbInfoId)

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
}

// ModifyChartList
// @Title 批量修改图表
// @Description 批量修改图表
// @Param   SysUserIds   query   string  true       "根据创建人查询"
// @Param   ChartClassifyIds   query   string  true       "图片分类id"
// @Success 200 {object} models.ChartClassifyListResp
// @router /modify/edbList [post]
func (this *EdbInfoController) ModifyEdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.ModifyEdbListReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	classifyIds := strings.Split(req.EdbClassifyIds, ",")

	if !req.SelectAll && req.EdbInfoIds == "" {
		br.Msg = "请选择图表"
		return
	}
	if req.ClassifyId < 0 {
		br.Msg = "请选择新分类"
		return
	}

	var condition string
	var pars []interface{}
	edbInfoIds := make([]int, 0)

	if req.SelectAll {
		// 已授权分类id
		permissionClassifyIdList, err := data_manage_permission.GetUserEdbClassifyPermissionList(this.SysUser.AdminId, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取已授权分类id数据失败，Err:" + err.Error()
			return
		}

		// 提交上来的分类id
		tmpClassifyIdsArr := make([]int, 0)
		for _, v := range classifyIds {
			if v != `` {
				id, _ := strconv.Atoi(v)
				tmpClassifyIdsArr = append(tmpClassifyIdsArr, id)
			}
		}

		// 我有权限的分类id
		classifyIdsArr := make([]int, 0)
		if len(tmpClassifyIdsArr) > 0 {
			classifyInfoList, err := data_manage.GetEdbClassifyByIdList(tmpClassifyIdsArr)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "获取失败"
				br.ErrMsg = "获取数据失败，Err:" + err.Error()
				return
			}

			permissionClassifyIdMap := make(map[int]bool)
			for _, classifyId := range permissionClassifyIdList {
				permissionClassifyIdMap[classifyId] = true
			}
			for _, v := range classifyInfoList {
				// 没有加入指标目录管控，那么就直接加入并进入下个循环
				if v.IsJoinPermission == 0 {
					classifyIdsArr = append(classifyIdsArr, v.ClassifyId)
					continue
				}

				// 如果加入指标目录管控了，同时自己有权限，那么就加入
				if _, ok := permissionClassifyIdMap[v.ClassifyId]; ok {
					classifyIdsArr = append(classifyIdsArr, v.ClassifyId)
					continue
				}

			}
		}

		if len(classifyIds) > 0 && len(classifyIdsArr) <= 0 {
			br.Msg = `所选中的指标目录没有权限`
			br.IsSendEmail = false
			return
		}

		//if len(permissionClassifyIdList) > 0 {
		//	classifyIdsArr = utils.IntersectInt(permissionClassifyIdList, classifyIdsArr)
		//}

		condition += " AND edb_info_type = 0 "
		if len(classifyIdsArr) > 0 {
			if !req.SubClassify {
				condition += " AND classify_id IN(" + utils.GetOrmInReplace(len(classifyIdsArr)) + ") "
				pars = append(pars, classifyIdsArr)
			} else {
				classifyAll, err := data_manage.GetNormalEdbClassifyAll()
				if err != nil && !utils.IsErrNoRow(err) {
					br.Msg = "获取失败"
					br.ErrMsg = "获取数据失败，Err:" + err.Error()
					return
				}
				finalClassifyIds := make([]int, 0)
				parents := data.GetEdbClassifyChildrenRecursiveByParentIds(classifyAll, classifyIds)
				sort.Slice(parents, func(i, j int) bool {
					return parents[i].Level < parents[i].Level
				})
				for _, v := range parents {
					finalClassifyIds = append(finalClassifyIds, v.ClassifyId)
				}

				condition += " AND classify_id IN(" + utils.GetOrmInReplace(len(finalClassifyIds)) + ") "
				pars = append(pars, finalClassifyIds)
			}
		}
		if req.KeyWord != "" {
			condition += ` AND edb_name LIKE '%` + req.KeyWord + `%' `
		}
		if req.Sources != "" {
			condition += " AND source IN(" + utils.GetOrmInReplace(len(strings.Split(req.Sources, ","))) + ") "
			pars = append(pars, strings.Split(req.Sources, ","))
		}
		if req.SysUserIds != "" {
			adminIds := strings.Split(req.SysUserIds, ",")
			if len(adminIds) == 0 {
				br.Msg = "请选择正确的创建人"
				return
			}
			adminIdsSlice := make([]int, 0)
			for _, adminId := range adminIds {
				adminIdInt, e := strconv.Atoi(adminId)
				if e != nil {
					br.Msg = "请选择正确的创建人"
					return
				}
				adminIdsSlice = append(adminIdsSlice, adminIdInt)
			}
			condition += "  AND sys_user_id in (" + utils.GetOrmInReplace(len(adminIds)) + ") "
			pars = append(pars, adminIdsSlice)
		}
		// 获取当前账号的不可见指标
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllListByAdminId(this.SysUser.AdminId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		noPermissionEdbInfoIds := make([]int, 0)
		for _, v := range confList {
			noPermissionEdbInfoIds = append(noPermissionEdbInfoIds, v.EdbInfoId)
		}
		if len(noPermissionEdbInfoIds) > 0 {
			condition += " AND edb_info_id NOT IN(" + utils.GetOrmInReplace(len(noPermissionEdbInfoIds)) + ") "
			pars = append(pars, noPermissionEdbInfoIds)
		}

		count, err := data_manage.GetEdbInfoByConditionCount(condition, pars)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取数据失败，Err:" + err.Error()
			return
		}
		if count > 100 {
			br.Msg = "最多选择100个"
			return
		}

		list, err := data_manage.GetEdbInfoListByCondition(condition, pars, 0, 0, "")
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取数据失败，Err:" + err.Error()
			return
		}

		for _, v := range list {
			edbInfoIds = append(edbInfoIds, v.EdbInfoId)
		}
	} else {
		edbIds := strings.Split(req.EdbInfoIds, ",")
		if len(edbIds) == 0 {
			br.Msg = "请选择图表"
			return
		}
		for _, id := range edbIds {
			tmp, e := strconv.Atoi(id)
			if e != nil {
				br.Msg = "请选择正确的分类"
				return
			}
			edbInfoIds = append(edbInfoIds, tmp)
		}
		if len(edbInfoIds) > 100 {
			br.Msg = "最多只能选择100个图表"
			return
		}
	}

	err = data_manage.UpdateEdbClassifyIdByChartInfoId(edbInfoIds, req.ClassifyId)
	if err != nil {
		br.Msg = "更新失败"
		br.ErrMsg = "更新图表分类失败，Err:" + err.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}