Przeglądaj źródła

Merge branch 'master' into feature/merge_yb_comment

xiexiaoyuan 2 lat temu
rodzic
commit
6749206856

+ 184 - 178
controller/chart/chart_info.go

@@ -10,11 +10,9 @@ import (
 	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
 	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
 	"hongze/hongze_yb/models/tables/chart_info_log"
-	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
 	"hongze/hongze_yb/services/alarm_msg"
 	"hongze/hongze_yb/services/chart"
-	edbDataService "hongze/hongze_yb/services/edb_data"
 	"hongze/hongze_yb/services/user"
 	"hongze/hongze_yb/utils"
 	"io/ioutil"
@@ -169,183 +167,191 @@ func GetChartInfoDetail(c *gin.Context) {
 	}
 
 	// 指标列表
-	sourceArr := make([]string, 0)
-	edbList := make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
-	for _, v := range mappingList {
-		item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
-		item.EdbInfoId = v.EdbInfoId
-		item.SourceName = v.SourceName
-		item.Source = v.Source
-		item.EdbCode = v.EdbCode
-		item.EdbName = v.EdbName
-		item.Frequency = v.Frequency
-		if v.Unit != "无" {
-			item.Unit = v.Unit
-		}
-		item.StartDate = v.StartDate
-		item.EndDate = v.EndDate
-		item.ModifyTime = v.ModifyTime
-
-		if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标,都展示为弘则研究
-			if !utils.InArray(v.SourceName, sourceArr) {
-				sourceArr = append(sourceArr, v.SourceName)
-			}
-		}
-		if chartInfoId <= 0 {
-			item.IsAxis = 1
-			item.LeadValue = 0
-			item.LeadUnit = ""
-			item.ChartEdbMappingId = 0
-			item.ChartInfoId = 0
-			item.IsOrder = false
-			item.EdbInfoType = 1
-			item.ChartStyle = ""
-			item.ChartColor = ""
-			item.ChartWidth = 0
-			item.MaxData = v.MaxValue
-			item.MinData = v.MinValue
-		} else {
-			item.IsAxis = v.IsAxis
-			item.EdbInfoType = v.EdbInfoType
-			item.LeadValue = v.LeadValue
-			item.LeadUnit = v.LeadUnit
-			item.ChartEdbMappingId = v.ChartEdbMappingId
-			item.ChartInfoId = v.ChartInfoId
-			item.ChartStyle = v.ChartStyle
-			item.ChartColor = v.ChartColor
-			item.ChartWidth = v.ChartWidth
-			item.IsOrder = v.IsOrder
-			item.MaxData = v.MaxData
-			item.MinData = v.MinData
-		}
-		item.LatestValue = v.LatestValue
-		item.LatestDate = v.LatestDate
-		item.UniqueCode = v.UniqueCode
-		item.ChartStyle = v.ChartStyle
-
-		var startDateReal string
-		var diffSeconds int64
-		if chartType == 2 { //季节性图表
-			startDateReal = startDate
-		} else {
-			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 {
-				// 领先指标
-				var startTimeRealTemp time.Time
-				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
-				switch v.LeadUnit {
-				case "天":
-					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
-				case "月":
-					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
-				case "季":
-					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
-				case "周":
-					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
-				case "年":
-					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
-				}
-				if startTimeRealTemp.Before(startDateParse) {
-					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
-					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
-				} else {
-					startDateReal = startDate
-					diffSeconds = 0
-				}
-			} else {
-				startDateReal = startDate
-			}
-		}
-		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
-		calendarPreYear := 0
-		if calendar == "农历" {
-			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
-			if err != nil {
-				response.FailMsg("获取失败", "农历时间转换有误4001, Err:"+err.Error(), c)
-				//fmt.Println("time.Parse:" + err.Error())
-				return
-			}
-			calendarPreYear = newStartDateReal.Year() - 1
-			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
-			startDateReal = newStartDateReal.Format(utils.FormatDate)
-		}
-		dataList := make([]*edbDataModel.EdbDataList, 0)
-		fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
-		dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
-		if err != nil {
-			response.FailMsg("获取失败", "获取图表指标信息失败4003, Err:"+err.Error(), c)
-			return
-		}
-		if diffSeconds != 0 && v.EdbInfoType == 0 {
-			dataListLen := len(dataList)
-			for i := 0; i < dataListLen; i++ {
-				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
-			}
-		}
-
-		if chartType == 2 {
-			if calendar == "农历" {
-				if len(dataList) <= 0 {
-					result := new(edbDataModel.EdbDataResult)
-					item.DataList = result
-				} else {
-					result, err := edbDataService.AddCalculateQuarter(dataList)
-					if err != nil {
-						response.FailMsg("获取失败", "获取农历数据失败4002, Err:"+err.Error(), c)
-						return
-					}
-					if result.List[0].Year != calendarPreYear {
-						itemList := make([]*edbDataModel.EdbDataList, 0)
-						items := new(edbDataModel.EdbDataItems)
-						//items.Year = calendarPreYear
-						items.Items = itemList
-
-						newResult := new(edbDataModel.EdbDataResult)
-						newResult.List = append(newResult.List, items)
-						newResult.List = append(newResult.List, result.List...)
-						item.DataList = newResult
-					} else {
-						item.DataList = result
-					}
-				}
-
-			} else {
-				currentYear := time.Now().Year()
-				quarterDataList := make([]*edbDataModel.QuarterData, 0)
-				quarterMap := make(map[int][]*edbDataModel.EdbDataList)
-				var quarterArr []int
-				for _, v := range dataList {
-					itemDate, err := time.Parse(utils.FormatDate, v.DataTime)
-					if err != nil {
-						response.FailMsg("获取失败", "季度指标日期转换失败, Err:"+err.Error()+";DataTime:"+v.DataTime, c)
-						return
-					}
-					year := itemDate.Year()
-					newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
-					timestamp := newItemDate.UnixNano() / 1e6
-					v.DataTimestamp = timestamp
-					if findVal, ok := quarterMap[year]; !ok {
-						quarterArr = append(quarterArr, year)
-						findVal = append(findVal, v)
-						quarterMap[year] = findVal
-					} else {
-						findVal = append(findVal, v)
-						quarterMap[year] = findVal
-					}
-				}
-				for _, v := range quarterArr {
-					itemList := quarterMap[v]
-					quarterItem := new(edbDataModel.QuarterData)
-					quarterItem.Year = v
-					quarterItem.DataList = itemList
-					quarterDataList = append(quarterDataList, quarterItem)
-				}
-				item.DataList = quarterDataList
-			}
-		} else {
-			item.DataList = dataList
-		}
-		edbList = append(edbList, item)
+	//sourceArr := make([]string, 0)
+	//edbList := make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
+	//for _, v := range mappingList {
+	//	item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
+	//	item.EdbInfoId = v.EdbInfoId
+	//	item.SourceName = v.SourceName
+	//	item.Source = v.Source
+	//	item.EdbCode = v.EdbCode
+	//	item.EdbName = v.EdbName
+	//	item.Frequency = v.Frequency
+	//	if v.Unit != "无" {
+	//		item.Unit = v.Unit
+	//	}
+	//	item.StartDate = v.StartDate
+	//	item.EndDate = v.EndDate
+	//	item.ModifyTime = v.ModifyTime
+	//
+	//	if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标,都展示为弘则研究
+	//		if !utils.InArray(v.SourceName, sourceArr) {
+	//			sourceArr = append(sourceArr, v.SourceName)
+	//		}
+	//	}
+	//	if chartInfoId <= 0 {
+	//		item.IsAxis = 1
+	//		item.LeadValue = 0
+	//		item.LeadUnit = ""
+	//		item.ChartEdbMappingId = 0
+	//		item.ChartInfoId = 0
+	//		item.IsOrder = false
+	//		item.EdbInfoType = 1
+	//		item.ChartStyle = ""
+	//		item.ChartColor = ""
+	//		item.ChartWidth = 0
+	//		item.MaxData = v.MaxValue
+	//		item.MinData = v.MinValue
+	//	} else {
+	//		item.IsAxis = v.IsAxis
+	//		item.EdbInfoType = v.EdbInfoType
+	//		item.LeadValue = v.LeadValue
+	//		item.LeadUnit = v.LeadUnit
+	//		item.ChartEdbMappingId = v.ChartEdbMappingId
+	//		item.ChartInfoId = v.ChartInfoId
+	//		item.ChartStyle = v.ChartStyle
+	//		item.ChartColor = v.ChartColor
+	//		item.ChartWidth = v.ChartWidth
+	//		item.IsOrder = v.IsOrder
+	//		item.MaxData = v.MaxData
+	//		item.MinData = v.MinData
+	//	}
+	//	item.LatestValue = v.LatestValue
+	//	item.LatestDate = v.LatestDate
+	//	item.UniqueCode = v.UniqueCode
+	//	item.ChartStyle = v.ChartStyle
+	//
+	//	var startDateReal string
+	//	var diffSeconds int64
+	//	if chartType == 2 { //季节性图表
+	//		startDateReal = startDate
+	//	} else {
+	//		if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 {
+	//			// 领先指标
+	//			var startTimeRealTemp time.Time
+	//			startDateParse, _ := time.Parse(utils.FormatDate, startDate)
+	//			switch v.LeadUnit {
+	//			case "天":
+	//				startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
+	//			case "月":
+	//				startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
+	//			case "季":
+	//				startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
+	//			case "周":
+	//				startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
+	//			case "年":
+	//				startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
+	//			}
+	//			if startTimeRealTemp.Before(startDateParse) {
+	//				startDateReal = startTimeRealTemp.Format(utils.FormatDate)
+	//				diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
+	//			} else {
+	//				startDateReal = startDate
+	//				diffSeconds = 0
+	//			}
+	//		} else {
+	//			startDateReal = startDate
+	//		}
+	//	}
+	//	//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	calendarPreYear := 0
+	//	if calendar == "农历" {
+	//		newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
+	//		if err != nil {
+	//			response.FailMsg("获取失败", "农历时间转换有误4001, Err:"+err.Error(), c)
+	//			//fmt.Println("time.Parse:" + err.Error())
+	//			return
+	//		}
+	//		calendarPreYear = newStartDateReal.Year() - 1
+	//		newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
+	//		startDateReal = newStartDateReal.Format(utils.FormatDate)
+	//	}
+	//	dataList := make([]*edbDataModel.EdbDataList, 0)
+	//	fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	if err != nil {
+	//		response.FailMsg("获取失败", "获取图表指标信息失败4003, Err:"+err.Error(), c)
+	//		return
+	//	}
+	//	if diffSeconds != 0 && v.EdbInfoType == 0 {
+	//		dataListLen := len(dataList)
+	//		for i := 0; i < dataListLen; i++ {
+	//			dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
+	//		}
+	//	}
+	//
+	//	if chartType == 2 {
+	//		if calendar == "农历" {
+	//			if len(dataList) <= 0 {
+	//				result := new(edbDataModel.EdbDataResult)
+	//				item.DataList = result
+	//			} else {
+	//				result, err := edbDataService.AddCalculateQuarter(dataList)
+	//				if err != nil {
+	//					response.FailMsg("获取失败", "获取农历数据失败4002, Err:"+err.Error(), c)
+	//					return
+	//				}
+	//				if result.List[0].Year != calendarPreYear {
+	//					itemList := make([]*edbDataModel.EdbDataList, 0)
+	//					items := new(edbDataModel.EdbDataItems)
+	//					//items.Year = calendarPreYear
+	//					items.Items = itemList
+	//
+	//					newResult := new(edbDataModel.EdbDataResult)
+	//					newResult.List = append(newResult.List, items)
+	//					newResult.List = append(newResult.List, result.List...)
+	//					item.DataList = newResult
+	//				} else {
+	//					item.DataList = result
+	//				}
+	//			}
+	//
+	//		} else {
+	//			currentYear := time.Now().Year()
+	//			quarterDataList := make([]*edbDataModel.QuarterData, 0)
+	//			quarterMap := make(map[int][]*edbDataModel.EdbDataList)
+	//			var quarterArr []int
+	//			for _, v := range dataList {
+	//				itemDate, err := time.Parse(utils.FormatDate, v.DataTime)
+	//				if err != nil {
+	//					response.FailMsg("获取失败", "季度指标日期转换失败, Err:"+err.Error()+";DataTime:"+v.DataTime, c)
+	//					return
+	//				}
+	//				year := itemDate.Year()
+	//				newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
+	//				timestamp := newItemDate.UnixNano() / 1e6
+	//				v.DataTimestamp = timestamp
+	//				if findVal, ok := quarterMap[year]; !ok {
+	//					quarterArr = append(quarterArr, year)
+	//					findVal = append(findVal, v)
+	//					quarterMap[year] = findVal
+	//				} else {
+	//					findVal = append(findVal, v)
+	//					quarterMap[year] = findVal
+	//				}
+	//			}
+	//			for _, v := range quarterArr {
+	//				itemList := quarterMap[v]
+	//				quarterItem := new(edbDataModel.QuarterData)
+	//				quarterItem.Year = v
+	//				quarterItem.DataList = itemList
+	//				quarterDataList = append(quarterDataList, quarterItem)
+	//			}
+	//			item.DataList = quarterDataList
+	//		}
+	//	} else {
+	//		item.DataList = dataList
+	//	}
+	//	edbList = append(edbList, item)
+	//}
+
+	// 获取图表中的指标数据
+	edbList, sourceArr, err := chart.GetChartEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList)
+	if err != nil {
+		response.FailMsg("获取失败", "获取图表,指标信息失败, Err:"+err.Error(), c)
+		return
 	}
+
 	sourceArr = append(sourceArr, "弘则研究")
 	chartInfo.ChartSource = strings.Join(sourceArr, ",")
 

+ 44 - 33
models/tables/chart_edb_mapping/query.go

@@ -1,46 +1,57 @@
 package chart_edb_mapping
 
-import "hongze/hongze_yb/global"
+import (
+	"hongze/hongze_yb/global"
+	"time"
+)
 
 type ChartEdbInfoMapping struct {
-	EdbInfoId         int     `description:"指标id"`
-	SourceName        string  `description:"来源名称"`
-	Source            int     `description:"来源id"`
-	EdbCode           string  `description:"指标编码"`
-	EdbName           string  `description:"指标名称"`
-	EdbType           int     `description:"指标类型:1:基础指标,2:计算指标"`
-	Frequency         string  `description:"频率"`
-	Unit              string  `description:"单位"`
-	StartDate         string  `description:"起始日期"`
-	EndDate           string  `description:"终止日期"`
-	ModifyTime        string  `description:"指标最后更新时间"`
-	ChartEdbMappingId int     `description:"图表指标id"`
-	ChartInfoId       int     `description:"图表id"`
-	MaxData           float64 `description:"上限"`
-	MinData           float64 `description:"下限"`
-	IsOrder           bool    `description:"true:正序,false:逆序"`
-	IsAxis            int     `description:"1:左轴,0:右轴"`
-	EdbInfoType       int     `description:"1:标准指标,0:领先指标"`
-	LeadValue         int     `description:"领先值"`
-	LeadUnit          string  `description:"领先单位"`
-	ChartStyle        string  `description:"图表类型"`
-	ChartColor        string  `description:"颜色"`
-	ChartWidth        float64 `description:"线条大小"`
-	LatestDate        string  `description:"数据最新日期"`
-	LatestValue       float64 `description:"数据最新值"`
-	UniqueCode        string  `description:"指标唯一编码"`
-	MinValue          float64 `json:"-" description:"最小值"`
-	MaxValue          float64 `json:"-" description:"最大值"`
+	EdbInfoId         int       `description:"指标id"`
+	SourceName        string    `description:"来源名称"`
+	Source            int       `description:"来源id"`
+	EdbCode           string    `description:"指标编码"`
+	EdbName           string    `description:"指标名称"`
+	EdbType           int       `description:"指标类型:1:基础指标,2:计算指标"`
+	Frequency         string    `description:"频率"`
+	Unit              string    `description:"单位"`
+	StartDate         string    `description:"起始日期"`
+	EndDate           string    `description:"终止日期"`
+	ModifyTime        string    `description:"指标最后更新时间"`
+	ChartEdbMappingId int       `description:"图表指标id"`
+	ChartInfoId       int       `description:"图表id"`
+	MaxData           float64   `description:"上限"`
+	MinData           float64   `description:"下限"`
+	IsOrder           bool      `description:"true:正序,false:逆序"`
+	IsAxis            int       `description:"1:左轴,0:右轴"`
+	EdbInfoType       int       `description:"1:标准指标,0:领先指标"`
+	LeadValue         int       `description:"领先值"`
+	LeadUnit          string    `description:"领先单位"`
+	ChartStyle        string    `description:"图表类型"`
+	ChartColor        string    `description:"颜色"`
+	ChartWidth        float64   `description:"线条大小"`
+	LatestDate        time.Time `description:"数据最新日期"`
+	LatestValue       float64   `description:"数据最新值"`
+	UniqueCode        string    `description:"指标唯一编码"`
+	MinValue          float64   `json:"-" description:"最小值"`
+	MaxValue          float64   `json:"-" description:"最大值"`
+
+	EdbNameEn           string `description:"英文指标名称"`
+	FrequencyEn         string `description:"英文频率"`
+	UnitEn              string `description:"英文单位"`
+	EdbInfoCategoryType int    `description:"0:普通指标,1:预测指标"`
+	LeadUnitEn          string `description:"领先英文单位"`
+	PredictChartColor   string `description:"预测数据的颜色"`
+	ChartType           int    `description:"生成样式:1:曲线图,2:季节性图,3:面积图,4:柱状图,5:散点图,6:组合图"`
 }
 
 type ChartEdbInfoMappingList struct {
 	ChartEdbInfoMapping
-	DataList	interface{}
+	DataList interface{}
 }
 
 // GetMappingListByChartInfoId 根据图表ID获取指标映射列表
 func GetMappingListByChartInfoId(chartInfoId int) (list []*ChartEdbInfoMapping, err error) {
-	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.frequency,b.unit,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code
+	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
              FROM chart_edb_mapping AS a
 			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			 WHERE chart_info_id=? 
@@ -52,7 +63,7 @@ func GetMappingListByChartInfoId(chartInfoId int) (list []*ChartEdbInfoMapping,
 
 // GetMappingListByEdbInfoId 根据指标ID获取指标映射列表
 func GetMappingListByEdbInfoId(edbInfoStr string) (list []*ChartEdbInfoMapping, err error) {
-	sql := ` SELECT * FROM edb_info WHERE edb_info_id IN(` + edbInfoStr + `) ORDER BY FIELD(edb_info_id,` + edbInfoStr + `) `
+	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value FROM edb_info WHERE edb_info_id IN(` + edbInfoStr + `) ORDER BY FIELD(edb_info_id,` + edbInfoStr + `) `
 	err = global.MYSQL["data"].Raw(sql).Scan(&list).Error
 	return
-}
+}

+ 7 - 4
models/tables/edb_data/query.go

@@ -90,8 +90,10 @@ type EdbDataList struct {
 }
 
 type EdbDataItems struct {
-	Items []*EdbDataList
-	Year  int
+	Items                []*EdbDataList
+	Year                 int
+	BetweenDay           int   `json:"-" description:"公历与农历之间相差的天数"`
+	CuttingDataTimestamp int64 `description:"切割的时间戳"`
 }
 
 type EdbDataResult struct {
@@ -99,8 +101,9 @@ type EdbDataResult struct {
 }
 
 type QuarterData struct {
-	Year     int
-	DataList []*EdbDataList
+	Year                 int
+	DataList             []*EdbDataList
+	CuttingDataTimestamp int64 `description:"切割的时间戳"`
 }
 
 // GetEdbDataList 获取指标数据

+ 20 - 2
models/tables/edb_info/edb_info.go

@@ -4,7 +4,8 @@ import "time"
 
 // EdbInfo 指标信息表
 type EdbInfo struct {
-	EdbInfoId        int       `gorm:"primaryKey;column:edb_info_id;type:int(11);not null" json:"edbInfoId"`							 // 指标id
+	EdbInfoId        int       `gorm:"primaryKey;column:edb_info_id;type:int(11);not null" json:"edbInfoId"`                             // 指标id
+	EdbInfoType      uint8     `gorm:"column:edb_info_type;type:tinyint(9) unsigned;default:0" json:"edbInfoType"`                       // 指标类型,0:普通指标,1:预测指标
 	SourceName       string    `gorm:"column:source_name;type:varchar(100)" json:"sourceName"`                                           // 来源名称
 	Source           int       `gorm:"uniqueIndex:idx_code_source;uniqueIndex:idx_edb_name;column:source;type:tinyint(4)" json:"source"` // 来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,9:手工指标,10:隆众,11:有色,12:环比值,13:环差值,14:变频,15:钢联
 	EdbCode          string    `gorm:"uniqueIndex:idx_code_source;unique;column:edb_code;type:varchar(255);default:''" json:"edbCode"`   // 指标编码
@@ -30,6 +31,11 @@ type EdbInfo struct {
 	LatestValue      float64   `gorm:"column:latest_value;type:double" json:"latestValue"`                                               // 数据最新值
 	MoveType         int       `gorm:"column:move_type;type:tinyint(4);default:1" json:"moveType"`                                       // 移动方式:1:领先(默认),2:滞后
 	MoveFrequency    string    `gorm:"column:move_frequency;type:varchar(20);default:''" json:"moveFrequency"`                           // 移动频度
+	NoUpdate         int8      `gorm:"column:no_update;type:tinyint(4);default:0" json:"noUpdate"`                                       // 是否停止更新,0:继续更新;1:停止更新
+	ServerURL        string    `gorm:"column:server_url;type:varchar(255);default:''" json:"serverUrl"`                                  // 服务器地址
+	EdbNameEn        string    `gorm:"column:edb_name_en;type:varchar(255);default:''" json:"edbNameEn"`                                 // 英文指标名称
+	UnitEn           string    `gorm:"column:unit_en;type:varchar(20);default:''" json:"unitEn"`                                         // 英文单位
+	ChartImage       string    `gorm:"column:chart_image;type:varchar(255);default:''" json:"chartImage"`                                // 图表图片
 }
 
 // TableName get sql table name.获取数据库表名
@@ -40,6 +46,7 @@ func (m *EdbInfo) TableName() string {
 // EdbInfoColumns get sql column name.获取数据库列名
 var EdbInfoColumns = struct {
 	EdbInfoID        string
+	EdbInfoType      string
 	SourceName       string
 	Source           string
 	EdbCode          string
@@ -65,8 +72,14 @@ var EdbInfoColumns = struct {
 	LatestValue      string
 	MoveType         string
 	MoveFrequency    string
+	NoUpdate         string
+	ServerURL        string
+	EdbNameEn        string
+	UnitEn           string
+	ChartImage       string
 }{
 	EdbInfoID:        "edb_info_id",
+	EdbInfoType:      "edb_info_type",
 	SourceName:       "source_name",
 	Source:           "source",
 	EdbCode:          "edb_code",
@@ -92,4 +105,9 @@ var EdbInfoColumns = struct {
 	LatestValue:      "latest_value",
 	MoveType:         "move_type",
 	MoveFrequency:    "move_frequency",
-}
+	NoUpdate:         "no_update",
+	ServerURL:        "server_url",
+	EdbNameEn:        "edb_name_en",
+	UnitEn:           "unit_en",
+	ChartImage:       "chart_image",
+}

+ 37 - 0
models/tables/predict_edb_conf/predict_edb_info.go

@@ -0,0 +1,37 @@
+package predict_edb_conf
+
+import (
+	"time"
+)
+
+// PredictEdbConf 预测指标规则配置表
+type PredictEdbConf struct {
+	PredictEdbInfoID uint64    `gorm:"primaryKey;column:predict_edb_info_id;type:bigint(9) unsigned;not null;default:0" json:"-"` // 预测指标id
+	SourceEdbInfoID  uint64    `gorm:"column:source_edb_info_id;type:bigint(9) unsigned;default:0" json:"sourceEdbInfoId"`        // 来源指标id
+	RuleType         uint8     `gorm:"column:rule_type;type:tinyint(9) unsigned;default:1" json:"ruleType"`                       // 预测规则,1:最新,2:固定值
+	FixedValue       float64   `gorm:"column:fixed_value;type:decimal(38,4)" json:"fixedValue"`                                   // 固定值
+	ModifyTime       time.Time `gorm:"column:modify_time;type:datetime;default:CURRENT_TIMESTAMP" json:"modifyTime"`              // 修改时间
+	CreateTime       time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                        // 添加时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *PredictEdbConf) TableName() string {
+	return "predict_edb_conf"
+}
+
+// PredictEdbConfColumns get sql column name.获取数据库列名
+var PredictEdbConfColumns = struct {
+	PredictEdbInfoID string
+	SourceEdbInfoID  string
+	RuleType         string
+	FixedValue       string
+	ModifyTime       string
+	CreateTime       string
+}{
+	PredictEdbInfoID: "predict_edb_info_id",
+	SourceEdbInfoID:  "source_edb_info_id",
+	RuleType:         "rule_type",
+	FixedValue:       "fixed_value",
+	ModifyTime:       "modify_time",
+	CreateTime:       "create_time",
+}

+ 9 - 0
models/tables/predict_edb_conf/query.go

@@ -0,0 +1,9 @@
+package predict_edb_conf
+
+import "hongze/hongze_yb/global"
+
+// GetPredictEdbConfById 根据预测指标获取配置信息
+func GetPredictEdbConfById(edbInfoId int) (item *PredictEdbConf, err error) {
+	err = global.MYSQL["data"].Where("predict_edb_info_id = ? ", edbInfoId).First(&item).Error
+	return
+}

+ 293 - 0
services/chart/chart_info.go

@@ -7,11 +7,13 @@ import (
 	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
 	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
 	company2 "hongze/hongze_yb/models/tables/company"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
 	"hongze/hongze_yb/models/tables/my_chart_classify"
 	"hongze/hongze_yb/models/tables/yb_chart_daily_visit_log"
 	"hongze/hongze_yb/models/tables/yb_chart_visit_log"
 	"hongze/hongze_yb/services/alarm_msg"
+	edbDataService "hongze/hongze_yb/services/edb_data"
 	"hongze/hongze_yb/services/user"
 	"hongze/hongze_yb/utils"
 	"sort"
@@ -292,6 +294,10 @@ func RefreshChart(chartInfoId int) (err error) {
 	newBaseEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)
 	baseMap := make(map[int]*edbInfoModel.EdbInfo)
 	for _, bv := range baseEdbInfoArr {
+		// 如果不是普通指标,那么过滤
+		if bv.EdbInfoType != 0 {
+			continue
+		}
 		if _, ok := baseMap[bv.EdbInfoId]; !ok {
 			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
 		}
@@ -392,3 +398,290 @@ func RefreshChart(chartInfoId int) (err error) {
 
 	return
 }
+
+// GetChartEdbData 获取图表的指标数据
+func GetChartEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*chartEdbMappingModel.ChartEdbInfoMapping) (edbList []*chartEdbMappingModel.ChartEdbInfoMappingList, sourceArr []string, err error) {
+	edbList = make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
+	sourceArr = make([]string, 0)
+
+	for _, v := range mappingList {
+		//fmt.Println("v:", v.EdbInfoId)
+		item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
+		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 = 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.EdbInfoCategoryType = v.EdbInfoCategoryType
+		item.PredictChartColor = v.PredictChartColor
+
+		if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标,都展示为弘则研究
+			if !utils.InArray(v.SourceName, sourceArr) {
+				sourceArr = append(sourceArr, v.SourceName)
+			}
+		}
+		if chartInfoId <= 0 {
+			item.IsAxis = 1
+			item.LeadValue = 0
+			item.LeadUnit = ""
+			item.ChartEdbMappingId = 0
+			item.ChartInfoId = 0
+			item.IsOrder = false
+			item.EdbInfoType = 1
+			item.ChartStyle = ""
+			item.ChartColor = ""
+			item.ChartWidth = 0
+			item.MaxData = v.MaxValue
+			item.MinData = v.MinValue
+		} else {
+			item.IsAxis = v.IsAxis
+			item.EdbInfoType = v.EdbInfoType
+			item.LeadValue = v.LeadValue
+			item.LeadUnit = v.LeadUnit
+			item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
+			item.ChartEdbMappingId = v.ChartEdbMappingId
+			item.ChartInfoId = v.ChartInfoId
+			item.ChartStyle = v.ChartStyle
+			item.ChartColor = v.ChartColor
+			item.ChartWidth = v.ChartWidth
+			item.IsOrder = v.IsOrder
+			item.MaxData = v.MaxData
+			item.MinData = v.MinData
+		}
+		item.LatestValue = v.LatestValue
+		item.LatestDate = v.LatestDate
+		item.UniqueCode = v.UniqueCode
+
+		var startDateReal string
+		var diffSeconds int64
+		if chartType == 2 { //季节性图
+			startDateReal = startDate
+		} else {
+			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
+				var startTimeRealTemp time.Time
+				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
+				switch v.LeadUnit {
+				case "天":
+					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
+				case "月":
+					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
+				case "季":
+					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
+				case "周":
+					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
+				case "年":
+					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
+				}
+				if startTimeRealTemp.Before(startDateParse) {
+					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
+					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
+				} else {
+					startDateReal = startDate
+					diffSeconds = 0
+				}
+			} else {
+				startDateReal = startDate
+			}
+		}
+		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+		calendarPreYear := 0
+		if calendar == "农历" {
+			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
+			if err != nil {
+				fmt.Println("time.Parse:" + err.Error())
+			}
+			calendarPreYear = newStartDateReal.Year() - 1
+			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
+			startDateReal = newStartDateReal.Format(utils.FormatDate)
+		}
+		dataList := make([]*edbDataModel.EdbDataList, 0)
+		//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate, ";EdbInfoCategoryType:", v.EdbInfoCategoryType)
+
+		switch v.EdbInfoCategoryType {
+		case 0:
+			dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
+		case 1:
+			dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, false)
+		default:
+			err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
+		}
+		if err != nil {
+			return
+		}
+		if diffSeconds != 0 && v.EdbInfoType == 0 {
+			dataListLen := len(dataList)
+			for i := 0; i < dataListLen; i++ {
+				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
+			}
+		}
+
+		if chartType == 2 {
+			latestDateStr := v.LatestDate.Format(utils.FormatDate) //实际数据的截止日期
+			latestDate := v.LatestDate
+			//latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
+			//if tmpErr != nil {
+			//	err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
+			//	return
+			//}
+			latestDateYear := latestDate.Year() //实际数据截止年份
+
+			if calendar == "农历" {
+				if len(dataList) <= 0 {
+					result := new(edbDataModel.EdbDataResult)
+					item.DataList = result
+				} else {
+					result, tmpErr := edbDataService.AddCalculateQuarter(dataList)
+					if tmpErr != nil {
+						err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
+						return
+					}
+
+					// 处理季节图的截止日期
+					for k, edbDataItems := range result.List {
+						var cuttingDataTimestamp int64
+
+						// 切割的日期时间字符串
+						cuttingDataTimeStr := latestDate.AddDate(0, 0, edbDataItems.BetweenDay).Format(utils.FormatDate)
+						//如果等于最后的实际日期,那么遍历找到该日期对应的时间戳,并将其赋值为 切割时间戳
+						if edbDataItems.Year >= latestDateYear {
+							for _, tmpData := range edbDataItems.Items {
+								if tmpData.DataTime == cuttingDataTimeStr {
+									cuttingDataTimestamp = tmpData.DataTimestamp
+									break
+								}
+							}
+						}
+						edbDataItems.CuttingDataTimestamp = cuttingDataTimestamp
+						result.List[k] = edbDataItems
+					}
+
+					if result.List[0].Year != calendarPreYear {
+						itemList := make([]*edbDataModel.EdbDataList, 0)
+						items := new(edbDataModel.EdbDataItems)
+						//items.Year = calendarPreYear
+						items.Items = itemList
+
+						newResult := new(edbDataModel.EdbDataResult)
+						newResult.List = append(newResult.List, items)
+						newResult.List = append(newResult.List, result.List...)
+						item.DataList = newResult
+					} else {
+						item.DataList = result
+					}
+				}
+
+			} else {
+				currentYear := time.Now().Year()
+
+				quarterDataList := make([]*edbDataModel.QuarterData, 0)
+				quarterMap := make(map[int][]*edbDataModel.EdbDataList)
+				var quarterArr []int
+
+				for _, v := range dataList {
+					itemDate, tmpErr := time.Parse(utils.FormatDate, v.DataTime)
+					if tmpErr != nil {
+						err = errors.New("季度指标日期转换,Err:" + tmpErr.Error() + ";DataTime:" + v.DataTime)
+						return
+					}
+					year := itemDate.Year()
+					newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
+					timestamp := newItemDate.UnixNano() / 1e6
+					v.DataTimestamp = timestamp
+					if findVal, ok := quarterMap[year]; !ok {
+						quarterArr = append(quarterArr, year)
+						findVal = append(findVal, v)
+						quarterMap[year] = findVal
+					} else {
+						findVal = append(findVal, v)
+						quarterMap[year] = findVal
+					}
+				}
+				for _, v := range quarterArr {
+					itemList := quarterMap[v]
+					quarterItem := new(edbDataModel.QuarterData)
+					quarterItem.Year = v
+					quarterItem.DataList = itemList
+
+					//如果等于最后的实际日期,那么将切割时间戳记录
+					if v == latestDateYear {
+						var cuttingDataTimestamp int64
+						for _, tmpData := range itemList {
+							if tmpData.DataTime == latestDateStr {
+								cuttingDataTimestamp = tmpData.DataTimestamp
+								break
+							}
+						}
+						quarterItem.CuttingDataTimestamp = cuttingDataTimestamp
+					} else if v > latestDateYear {
+						//如果大于最后的实际日期,那么第一个点就是切割的时间戳
+						if len(itemList) > 0 {
+							quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
+						}
+					}
+					quarterDataList = append(quarterDataList, quarterItem)
+				}
+				item.DataList = quarterDataList
+			}
+		} else {
+			item.DataList = dataList
+		}
+		edbList = append(edbList, item)
+	}
+	return
+}
+
+// 获取频度的英文版
+func GetFrequencyEn(frequency string) (frequencyEn string) {
+	switch frequency {
+	case "日度":
+		frequencyEn = "day"
+		return
+	case "周度":
+		frequencyEn = "week"
+		return
+	case "旬度":
+		frequencyEn = "ten days"
+		return
+	case "月度":
+		frequencyEn = "month"
+		return
+	case "季度":
+		frequencyEn = "quarter"
+		return
+	case "年度":
+		frequencyEn = "year"
+		return
+	}
+	return
+}
+
+func GetLeadUnitEn(unit string) (unitEn string) {
+	switch unit {
+	case "天":
+		unitEn = "day"
+		return
+	case "周":
+		unitEn = "week"
+		return
+	case "月":
+		unitEn = "month"
+		return
+	case "季":
+		unitEn = "quarter"
+		return
+	case "年":
+		unitEn = "year"
+		return
+	}
+	return
+}

+ 158 - 0
services/chart/predict_edb_info.go

@@ -0,0 +1,158 @@
+package chart
+
+import (
+	"errors"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	predictEdbConfModel "hongze/hongze_yb/models/tables/predict_edb_conf"
+	"hongze/hongze_yb/utils"
+	"time"
+)
+
+// GetChartPredictEdbInfoDataList 获取图表的预测指标的未来数据
+func GetChartPredictEdbInfoDataList(predictEdbConf predictEdbConfModel.PredictEdbConf, filtrateStartDateStr, latestDateStr string, lastDataValue float64, endDateStr, frequency string) (predictEdbInfoData []*edbDataModel.EdbDataList, err error) {
+	endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local)
+	if err != nil {
+		return
+	}
+
+	latestDate, err := time.ParseInLocation(utils.FormatDate, latestDateStr, time.Local)
+	if err != nil {
+		return
+	}
+
+	// 开始预测数据的时间
+	startDate := latestDate
+
+	// 如果有筛选时间的话
+	if filtrateStartDateStr != `` {
+		filtrateStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, filtrateStartDateStr, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		//如果筛选时间晚于实际数据时间,那么就以筛选时间作为获取预测数据的时间
+		if filtrateStartDate.After(latestDate) {
+			startDate = filtrateStartDate.AddDate(0, 0, -1)
+		}
+	}
+
+	dataValue := lastDataValue
+	if predictEdbConf.RuleType == 2 {
+		dataValue = predictEdbConf.FixedValue
+	}
+	//获取后面的预测数据
+	dayList := getPredictEdbDayList(startDate, endDate, frequency)
+	predictEdbInfoData = make([]*edbDataModel.EdbDataList, 0)
+	for k, v := range dayList {
+		predictEdbInfoData = append(predictEdbInfoData, &edbDataModel.EdbDataList{
+			EdbDataId:     int(predictEdbConf.PredictEdbInfoID) + 10000000000 + k,
+			EdbInfoId:     int(predictEdbConf.PredictEdbInfoID),
+			DataTime:      v.Format(utils.FormatDate),
+			Value:         dataValue,
+			DataTimestamp: (v.UnixNano() / 1e6) + 1000, //前端需要让加1s,说是2022-09-01 00:00:00 这样的整点不合适
+		})
+	}
+	return
+}
+
+// GetPredictEdbDayList 获取预测指标日期列表
+func getPredictEdbDayList(startDate, endDate time.Time, frequency string) (dayList []time.Time) {
+	//if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, frequency)
+	switch frequency {
+	case "日度":
+		for currDate := startDate.AddDate(0, 0, 1); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 1) {
+			//周六、日排除
+			if currDate.Weekday() == time.Sunday || currDate.Weekday() == time.Saturday {
+				continue
+			}
+			dayList = append(dayList, currDate)
+		}
+	case "周度":
+		//nextDate := startDate.AddDate(0, 0, 7)
+		for currDate := startDate.AddDate(0, 0, 7); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 7) {
+			dayList = append(dayList, currDate)
+		}
+	case "月度":
+		for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); {
+			currDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 2, -1)
+			if !currDate.After(endDate) {
+				dayList = append(dayList, currDate)
+			}
+		}
+	}
+	return
+}
+
+// GetPredictDataListByPredictEdbInfoId 根据预测指标id获取预测指标的数据
+func GetPredictDataListByPredictEdbInfoId(edbInfoId int, startDate, endDate string, isTimeBetween bool) (dataList []*edbDataModel.EdbDataList, sourceEdbInfoItem *edbInfoModel.EdbInfo, predictEdbConf *predictEdbConfModel.PredictEdbConf, err error, errMsg string) {
+	edbInfo, err := edbInfoModel.GetEdbInfoById(edbInfoId)
+	if err != nil {
+		errMsg = `获取预测指标信息失败`
+		return
+	}
+	return GetPredictDataListByPredictEdbInfo(edbInfo, startDate, endDate, isTimeBetween)
+}
+
+// GetPredictDataListByPredictEdbInfo 根据预测指标信息获取预测指标的数据
+func GetPredictDataListByPredictEdbInfo(edbInfo *edbInfoModel.EdbInfo, startDate, endDate string, isTimeBetween bool) (dataList []*edbDataModel.EdbDataList, sourceEdbInfoItem *edbInfoModel.EdbInfo, predictEdbConf *predictEdbConfModel.PredictEdbConf, err error, errMsg string) {
+	// 查找该预测指标配置
+	predictEdbConf, err = predictEdbConfModel.GetPredictEdbConfById(edbInfo.EdbInfoId)
+	if err != nil && err != utils.ErrNoRow {
+		errMsg = "获取预测指标配置信息失败"
+		return
+	}
+	if predictEdbConf == nil {
+		errMsg = "获取预测指标配置信息失败"
+		err = errors.New(errMsg)
+		return
+	}
+
+	// 来源指标
+	sourceEdbInfoItem, err = edbInfoModel.GetEdbInfoById(int(predictEdbConf.SourceEdbInfoID))
+	if err != nil {
+		if err == utils.ErrNoRow {
+			errMsg = "找不到来源指标信息"
+			err = errors.New(errMsg)
+		}
+		return
+	}
+
+	//获取指标数据(实际已生成)
+	dataList, err = edbDataModel.GetEdbDataList(sourceEdbInfoItem.Source, sourceEdbInfoItem.EdbInfoId, startDate, endDate)
+	if err != nil {
+		return
+	}
+
+	// 获取预测指标未来的数据
+	predictDataList := make([]*edbDataModel.EdbDataList, 0)
+
+	endDateStr := edbInfo.EndDate.Format(utils.FormatDate) //预测指标的结束日期
+
+	if isTimeBetween { //如果是时间区间,那么
+		reqEndDateTime, _ := time.ParseInLocation(utils.FormatDate, endDate, time.Local)
+		// 如果选择的时间区间结束日期 晚于 当天,那么预测数据截止到当天
+		if reqEndDateTime.Before(edbInfo.EndDate) {
+			endDateStr = endDate
+		}
+	}
+	predictDataList, err = GetChartPredictEdbInfoDataList(*predictEdbConf, startDate, sourceEdbInfoItem.LatestDate.Format(utils.FormatDate), sourceEdbInfoItem.LatestValue, endDateStr, edbInfo.Frequency)
+	if err != nil {
+		return
+	}
+	dataList = append(dataList, predictDataList...)
+	if len(predictDataList) > 0 {
+		tmpValue := predictDataList[0]
+
+		// 如果最大值 小于 预测值,那么将预测值作为最大值数据返回
+		if edbInfo.MaxValue < tmpValue.Value {
+			edbInfo.MaxValue = tmpValue.Value
+		}
+
+		// 如果最小值 大于 预测值,那么将预测值作为最小值数据返回
+		if edbInfo.MinValue > tmpValue.Value {
+			edbInfo.MinValue = tmpValue.Value
+		}
+	}
+	return
+}

+ 2 - 0
services/comment/comment.go

@@ -101,6 +101,8 @@ func Comment(user user.UserInfo, req reqComment.ReqComment) (ret response.RespCo
 		ModifyTime:         now,
 		OldReportId:        req.OldReportId,
 		OldReportChapterId: req.OldReportChapterId,
+		IsHot: 1,
+		HotTopTime: time.Now(),
 	}
 	err = commentInfo.Create()
 	if err != nil {