Merge branch 'feature/eta_1.7.8' into debug

controller/edb_info/edb_info.go

@@ -0,0 +1,60 @@
+package edb_info
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/models/request"
+	"hongze/hongze_yb/models/tables/edb_data"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	"hongze/hongze_yb/utils"
+	"strconv"
+)
+
+// EdbData 指标数据
+func EdbData(c *gin.Context) {
+	var req request.EdbInfoDataReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误", c)
+		return
+	}
+	if req.EdbInfoId <= 0 {
+		response.Fail("参数错误", c)
+		return
+	}
+	if req.DateType <= 0 {
+		req.DateType = 3
+	}
+	if req.EdbInfoType <= 0 {
+		req.EdbInfoType = 1
+	}
+
+	edbInfo, e := edbInfoModel.GetEdbInfoById(req.EdbInfoId)
+	if e != nil {
+		if e == utils.ErrNoRow {
+			response.FailMsg("获取失败", "指标不存在，EdbInfoId:"+strconv.Itoa(req.EdbInfoId), c)
+			return
+		}
+		response.FailMsg("获取失败", "获取指标信息失败，Err:"+e.Error(), c)
+		return
+	}
+	maxYear := 0
+	if !edbInfo.LatestDate.IsZero() {
+		maxYear = edbInfo.LatestDate.Year()
+	}
+	dataList := make([]*edb_data.EdbDataList, 0)
+	startDate, endDate := utils.GetDateByDateTypeV2(req.DateType, req.StartDate, req.EndDate, req.StartYear, maxYear)
+	dataList, e = edb_data.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, req.EdbInfoId, startDate, endDate)
+	if e != nil {
+		response.FailMsg("获取失败", "获取指标数据失败, Err: "+e.Error(), c)
+		return
+	}
+
+	type EdbInfoDataFullClassifyResp struct {
+		EdbInfo  *edbInfoModel.EdbInfo
+		DataList []*edb_data.EdbDataList
+	}
+	resp := new(EdbInfoDataFullClassifyResp)
+	resp.EdbInfo = edbInfo
+	resp.DataList = dataList
+	response.OkData("获取成功", resp, c)
+}

controller/edb_info/predict_edb_info.go

@@ -0,0 +1,90 @@
+package edb_info
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/models/request"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	"hongze/hongze_yb/services/chart"
+	"hongze/hongze_yb/utils"
+	"strconv"
+	"time"
+)
+
+// PredictEdbData 预测指标数据
+func PredictEdbData(c *gin.Context) {
+	var req request.PredictEdbInfoDataReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误", c)
+		return
+	}
+	if req.EdbInfoId <= 0 {
+		response.Fail("参数错误", c)
+		return
+	}
+	if req.DateType <= 0 {
+		req.DateType = 3
+	}
+	if req.EdbInfoType <= 0 {
+		req.EdbInfoType = 1
+	}
+	if req.ChartType <= 0 {
+		req.ChartType = 1
+	}
+	if req.Calendar == "" {
+		req.Calendar = "公历"
+	}
+	isTimeBetween := false //是否是时间区间
+
+	if req.ChartType == 2 {
+		req.DateType = 0
+		isTimeBetween = true
+	}
+	if req.DateType == 5 {
+		isTimeBetween = true
+	}
+
+	edbInfo, e := edbInfoModel.GetEdbInfoById(req.EdbInfoId)
+	if e != nil {
+		if e == utils.ErrNoRow {
+			response.FailMsg("获取失败", "指标不存在，EdbInfoId:"+strconv.Itoa(req.EdbInfoId), c)
+			return
+		}
+		response.FailMsg("获取失败", "获取指标信息失败，Err:"+e.Error(), c)
+		return
+	}
+	maxYear := 0
+	if !edbInfo.LatestDate.IsZero() {
+		maxYear = edbInfo.LatestDate.Year()
+	}
+	startDate, endDate := utils.GetDateByDateTypeV2(req.DateType, req.StartDate, req.EndDate, req.StartYear, maxYear)
+	if endDate == "" {
+		endDate = time.Now().Format(utils.FormatDate)
+	}
+	if req.DateType == 10 {
+		startDate = ""
+		endDate = ""
+	}
+
+	dataList, _, _, e, _ := chart.GetPredictDataListByPredictEdbInfo(edbInfo, startDate, endDate, isTimeBetween)
+	if e != nil {
+		response.FailMsg("获取失败", "获取预测指标数据失败, Err: "+e.Error(), c)
+		return
+	}
+
+	// 季节性图、公历、农历处理
+	resultDataList, err := chart.GetChartDataList(dataList, req.ChartType, req.Calendar, edbInfo.LatestDate.Format(utils.FormatDate), startDate)
+	if err != nil {
+		response.FailMsg("获取失败", "季节性图、公历、农历处理失败, Err: "+e.Error(), c)
+		return
+	}
+
+	type PredictEdbInfoDataResp struct {
+		EdbInfo  *edbInfoModel.EdbInfo
+		DataList interface{}
+	}
+	resp := new(PredictEdbInfoDataResp)
+	resp.EdbInfo = edbInfo
+	resp.DataList = resultDataList
+	response.OkData("获取成功", resp, c)
+}

controller/fe_calendar/fe_calendar.go

@@ -54,6 +54,31 @@ func PermissionList(c *gin.Context) {
 	response.OkData("获取成功", resp, c)
 }
 
+// LastestPermissionMonth 获取品种有数据最近的月份
+func LastestPermissionMonth(c *gin.Context) {
+	var req request.FeCalendarLastestPermissionMonthReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误", c)
+		return
+	}
+	if req.ChartPermissionId <= 0 {
+		response.Fail("请选择品种", c)
+		return
+	}
+
+	matterOb := new(fe_calendar_matter.FeCalendarMatter)
+	item, e := matterOb.GetLastestMonthItemByPermissionId(req.ChartPermissionId)
+	if e != nil && e != utils.ErrNoRow {
+		response.FailMsg("获取失败", "获取事项失败, Err: "+e.Error(), c)
+		return
+	}
+	var month string
+	if item != nil {
+		month = item.MatterMonth
+	}
+	response.OkData("获取成功", month, c)
+}
+
 // MatterList 事项列表
 func MatterList(c *gin.Context) {
 	var req request.FeCalendarMatterListReq
@@ -120,3 +145,43 @@ func MatterList(c *gin.Context) {
 
 	response.OkData("获取成功", resp, c)
 }
+
+// MatterDetail 事项详情
+func MatterDetail(c *gin.Context) {
+	var req request.FeCalendarMatterDetailReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误", c)
+		return
+	}
+	if req.ChartPermissionId <= 0 {
+		response.Fail("请选择品种", c)
+		return
+	}
+	if req.MatterDate == "" {
+		response.Fail("请选择日期", c)
+		return
+	}
+	_, e := time.Parse(utils.FormatDate, req.MatterDate)
+	if e != nil {
+		response.Fail("日期格式有误", c)
+		return
+	}
+	//userInfo := userService.GetInfoByClaims(c)
+
+	matterOb := new(fe_calendar_matter.FeCalendarMatter)
+	cond := fmt.Sprintf(` %s = ? AND %s = ?`, fe_calendar_matter.FeCalendarMatterColumns.ChartPermissionId, fe_calendar_matter.FeCalendarMatterColumns.MatterDate)
+	pars := make([]interface{}, 0)
+	pars = append(pars, req.ChartPermissionId, req.MatterDate)
+	order := fmt.Sprintf(`%s ASC`, fe_calendar_matter.FeCalendarMatterColumns.Sort)
+	matters, e := matterOb.GetItemsByCondition(cond, pars, []string{}, order)
+	if e != nil {
+		response.FailMsg("获取失败", "获取事项列表失败, Err: "+e.Error(), c)
+		return
+	}
+	resp := make([]*fe_calendar_matter.FeCalendarMatterItem, 0)
+	for _, v := range matters {
+		resp = append(resp, fe_calendar_matter.FormatFeCalendarMatter2Item(v))
+	}
+
+	response.OkData("获取成功", resp, c)
+}

init_serve/router.go

@@ -83,5 +83,7 @@ func InitRouter() (r *gin.Engine) {
 	routers.InitTradeAnalysis(r)
 	// 外汇日历
 	routers.InitFeCalendar(r)
+	// 指标信息
+	routers.InitEdbInfo(r)
 	return
 }

models/request/edb_info.go

@@ -0,0 +1,23 @@
+package request
+
+// EdbInfoDataReq 指标数据请求体
+type EdbInfoDataReq struct {
+	EdbInfoId   int    `form:"edb_info_id" json:"edb_info_id" description:"指标ID"`
+	DateType    int    `form:"date_type" json:"date_type" description:"日期类型"`
+	EdbInfoType int    `form:"edb_info_type" json:"edb_info_type" description:"指标类型"`
+	StartDate   string `form:"start_date" json:"start_date" description:"开始日期"`
+	EndDate     string `form:"end_date" json:"end_date" description:"结束日期"`
+	StartYear   int    `form:"start_year" json:"start_year" description:"开始年份"`
+}
+
+// PredictEdbInfoDataReq 预测指标数据请求体
+type PredictEdbInfoDataReq struct {
+	EdbInfoId   int    `form:"edb_info_id" json:"edb_info_id" description:"指标ID"`
+	DateType    int    `form:"date_type" json:"date_type" description:"日期类型"`
+	EdbInfoType int    `form:"edb_info_type" json:"edb_info_type" description:"指标类型"`
+	StartDate   string `form:"start_date" json:"start_date" description:"开始日期"`
+	EndDate     string `form:"end_date" json:"end_date" description:"结束日期"`
+	StartYear   int    `form:"start_year" json:"start_year" description:"开始年份"`
+	ChartType   int    `form:"chart_type" json:"chart_type" description:"图表类型"`
+	Calendar    string `form:"calendar" json:"calendar" description:"公历/农历"`
+}

models/request/fe_calendar.go

@@ -6,3 +6,14 @@ type FeCalendarMatterListReq struct {
 	StartDate         string `form:"start_date" json:"start_date" description:"开始日期"`
 	EndDate           string `form:"end_date" json:"end_date" description:"结束日期"`
 }
+
+// FeCalendarMatterDetailReq 事项详情请求体
+type FeCalendarMatterDetailReq struct {
+	ChartPermissionId int    `form:"chart_permission_id" json:"chart_permission_id" description:"品种ID"`
+	MatterDate        string `form:"matter_date" json:"matter_date" description:"事项日期"`
+}
+
+// FeCalendarLastestPermissionMonthReq 获取品种有数据最近的月份
+type FeCalendarLastestPermissionMonthReq struct {
+	ChartPermissionId int `form:"chart_permission_id" json:"chart_permission_id" description:"品种ID"`
+}

models/tables/edb_data/edb_data_quarter.go

@@ -0,0 +1,187 @@
+package edb_data
+
+import (
+	"fmt"
+	"github.com/nosixtools/solarlunar"
+	"hongze/hongze_yb/utils"
+	"strconv"
+	"time"
+)
+
+// AddCalculateQuarterV4 指标季度数据计算(公历转农历)
+func AddCalculateQuarterV4(dataList []*EdbDataList) (result *EdbDataResult, err error) {
+	var errMsg string
+	defer func() {
+		if errMsg != "" {
+			fmt.Println("errMsg:", errMsg)
+		}
+	}()
+
+	endDate := dataList[len(dataList)-1].DataTime
+	endDateForm, err := time.Parse(utils.FormatDate, endDate)
+	if err != nil {
+		return result, err
+	}
+	thisMonth := int(endDateForm.Month())
+
+	result = new(EdbDataResult)
+	var yearArr []int
+	yearMap := make(map[int]int)
+	var cureentDate time.Time
+	if thisMonth < 11 {
+		for k, v := range dataList {
+			dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
+			if err != nil {
+				errMsg = "time.Parse Err:" + err.Error() + ";DataTime:" + v.DataTime
+				return result, err
+			}
+			if k == len(dataList)-1 {
+				cureentDate = dateTime
+			}
+			year := dateTime.Year()
+			if _, ok := yearMap[year]; !ok {
+				yearArr = append(yearArr, year)
+			}
+			yearMap[year] = year
+		}
+	} else {
+		for k, v := range dataList {
+			dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
+			if err != nil {
+				errMsg = "time.Parse Err:" + err.Error() + ";DataTime:" + v.DataTime
+				return result, err
+			}
+			if k == len(dataList)-1 {
+				cureentDate = dateTime
+			}
+			year := dateTime.Year() + 1
+			if _, ok := yearMap[year]; !ok {
+				yearArr = append(yearArr, year)
+			}
+			yearMap[year] = year
+		}
+	}
+	//排序
+	fmt.Println("yearArr:", yearArr)
+	thisYear := cureentDate.Year()
+	//thisMonth := int(cureentDate.Month())
+
+	fmt.Println("thisMonth:", thisMonth)
+	for ky, vy := range yearArr {
+		fmt.Println("line 432:", ky, vy, thisYear, thisMonth)
+		if thisMonth < 11 {
+			currentYearCjnl := strconv.Itoa(thisYear) + "-01-01"               //当前年份春节农历
+			currentYearCjgl := solarlunar.LunarToSolar(currentYearCjnl, false) //当前年份春节公历
+			currentYearCjglDate, err := time.Parse(utils.FormatDate, currentYearCjgl)
+			if err != nil {
+				errMsg = "生成当前春节失败,Err:" + err.Error()
+				return result, err
+			}
+
+			preYear := vy
+			preYearCjnl := strconv.Itoa(preYear) + "-01-01"            //之前年份春节农历
+			preYearCjgl := solarlunar.LunarToSolar(preYearCjnl, false) //之前年份春节公历
+			preYearCjglDate, err := time.Parse(utils.FormatDate, preYearCjgl)
+			if err != nil {
+				errMsg = "生成历史年份春节失败,Err:" + err.Error()
+				return result, err
+			}
+			day := currentYearCjglDate.Sub(preYearCjglDate).Hours() / float64(24)
+
+			fmt.Println("day:", day, currentYearCjglDate, preYearCjglDate)
+
+			items := new(EdbDataItems)
+			items.BetweenDay = int(day) //公历日期换算成农历，需要减除的天数
+			items.Year = preYear
+			for _, v := range dataList {
+				dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
+				if err != nil {
+					errMsg = "time.Parse Err:" + err.Error() + ";DataTime:" + v.DataTime
+					return result, err
+				}
+				newDate := dateTime.AddDate(0, 0, int(day))
+				selectDateStr := strconv.Itoa(thisYear) + "-11" + "-30"
+				selectDate, _ := time.Parse(utils.FormatDate, selectDateStr)
+				if newDate.Before(selectDate) || newDate == selectDate {
+					timestamp := newDate.UnixNano() / 1e6
+					item := new(EdbDataList)
+					item.DataTime = newDate.Format(utils.FormatDate)
+					item.EdbInfoId = v.EdbInfoId
+					item.Value = v.Value
+					item.EdbDataId = v.EdbDataId
+					item.DataTimestamp = timestamp
+					items.Items = append(items.Items, item)
+				}
+			}
+			result.List = append(result.List, items)
+		} else {
+			nextYear := thisYear + 1
+			nextYearCjnl := strconv.Itoa(nextYear) + "-01-01"            //当前年份春节农历
+			nextYearCjgl := solarlunar.LunarToSolar(nextYearCjnl, false) //当前年份春节公历
+
+			nextYearCjglDate, err := time.Parse(utils.FormatDate, nextYearCjgl)
+			if err != nil {
+				errMsg = "生成当前春节失败,Err:" + err.Error()
+				return result, err
+			}
+			preYear := vy
+			preYearCjnl := strconv.Itoa(preYear) + "-01-01"            //之前年份春节农历
+			preYearCjgl := solarlunar.LunarToSolar(preYearCjnl, false) //之前年份春节公历
+			preYearCjglDate, err := time.Parse(utils.FormatDate, preYearCjgl)
+			if err != nil {
+				errMsg = "生成历史年份春节失败,Err:" + err.Error()
+				return result, err
+			}
+			day := nextYearCjglDate.Sub(preYearCjglDate).Hours() / float64(24)
+
+			fmt.Println("day:", day, nextYearCjglDate, preYearCjglDate)
+
+			items := new(EdbDataItems)
+			items.BetweenDay = int(day) //公历日期换算成农历，需要减除的天数
+			items.Year = preYear - 1
+			fmt.Println("preYear:", preYear, "ky:", ky, "yearArrLen:", len(yearArr))
+			if ky+1 < len(yearArr) {
+				for _, v := range dataList {
+					dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
+					if err != nil {
+						errMsg = "time.Parse Err:" + err.Error() + ";DataTime:" + v.DataTime
+						return result, err
+					}
+					newDate := dateTime.AddDate(0, 0, int(day))
+					selectDateStr := strconv.Itoa(nextYear) + "-05" + "-31"
+					selectDate, _ := time.Parse(utils.FormatDate, selectDateStr)
+
+					if newDate.Before(selectDate) || newDate == selectDate {
+						timestamp := newDate.UnixNano() / 1e6
+						item := new(EdbDataList)
+						item.DataTime = newDate.Format(utils.FormatDate)
+						item.EdbInfoId = v.EdbInfoId
+						item.Value = v.Value
+						item.EdbDataId = v.EdbDataId
+						item.DataTimestamp = timestamp
+						items.Items = append(items.Items, item)
+					}
+				}
+				result.List = append(result.List, items)
+			} else {
+				for _, v := range dataList {
+					dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
+					if err != nil {
+						errMsg = "time.Parse Err:" + err.Error() + ";DataTime:" + v.DataTime
+						return result, err
+					}
+					timestamp := dateTime.UnixNano() / 1e6
+					item := new(EdbDataList)
+					item.DataTime = dateTime.Format(utils.FormatDate)
+					item.EdbInfoId = v.EdbInfoId
+					item.Value = v.Value
+					item.EdbDataId = v.EdbDataId
+					item.DataTimestamp = timestamp
+					items.Items = append(items.Items, item)
+				}
+				result.List = append(result.List, items)
+			}
+		}
+	}
+	return
+}

models/tables/fe_calendar_matter/model.go

@@ -57,3 +57,8 @@ func (m *FeCalendarMatter) GetItemsByCondition(cond string, pars []interface{},
 	err = global.MYSQL["data"].Where(cond, pars...).Order(order).Find(&items).Error
 	return
 }
+
+func (m *FeCalendarMatter) GetLastestMonthItemByPermissionId(permissionId int) (item *FeCalendarMatter, err error) {
+	err = global.MYSQL["data"].Where("chart_permission_id = ?", permissionId).Order("matter_date DESC").First(&item).Error
+	return
+}

routers/edb_info.go

@@ -0,0 +1,15 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/edb_info"
+	"hongze/hongze_yb/middleware"
+)
+
+func InitEdbInfo(r *gin.Engine) {
+	rg := r.Group("api/edb_info").Use(middleware.Token(), middleware.CheckBaseAuth())
+	rg.GET("/data", edb_info.EdbData)
+
+	prg := r.Group("api/predict_edb_info").Use(middleware.Token(), middleware.CheckBaseAuth())
+	prg.GET("/data", edb_info.PredictEdbData)
+}

routers/fe_calendar.go

@@ -9,5 +9,7 @@ import (
 func InitFeCalendar(r *gin.Engine) {
 	rGroup := r.Group("api/fe_calendar").Use(middleware.Token(), middleware.CheckBaseAuth())
 	rGroup.GET("/permission/list", fe_calendar.PermissionList)
+	rGroup.GET("/permission/latest_month", fe_calendar.LastestPermissionMonth)
 	rGroup.GET("/matter/list", fe_calendar.MatterList)
+	rGroup.GET("/matter/detail", fe_calendar.MatterDetail)
 }

services/chart/predict_edb_info.go

@@ -3,6 +3,7 @@ package chart
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"github.com/shopspring/decimal"
 	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
@@ -434,3 +435,128 @@ func GetPredictCalculateDataListByPredictEdbInfo(edbInfo *edbInfoModel.EdbInfo,
 	dataList, err = edbDataModel.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, startDate, endDate)
 	return
 }
+
+// GetChartDataList 通过完整的预测数据 进行 季节性图、公历、农历处理
+func GetChartDataList(dataList []*edbDataModel.EdbDataList, chartType int, calendar, latestDateStr, startDate string) (resultDataList interface{}, err error) {
+	startDateReal := startDate
+	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)
+	}
+	//实际数据的截止日期
+	latestDate, tmpErr := time.Parse(utils.FormatDate, latestDateStr)
+	if tmpErr != nil {
+		err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + latestDateStr))
+		return
+	}
+	latestDateYear := latestDate.Year() //实际数据截止年份
+
+	// 曲线图
+	if chartType == 1 {
+		resultDataList = dataList
+		return
+	}
+
+	if calendar == "农历" {
+		if len(dataList) <= 0 {
+			resultDataList = edbDataModel.EdbDataResult{}
+		} else {
+			result, tmpErr := edbDataModel.AddCalculateQuarterV4(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...)
+				resultDataList = newResult
+			} else {
+				resultDataList = 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 = strconv.Itoa(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)
+		}
+		resultDataList = quarterDataList
+	}
+	return
+}