Merge branch 'feature/eta_1.7.8'

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

@@ -0,0 +1,204 @@
+package fe_calendar
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/models/request"
+	"hongze/hongze_yb/models/tables/chart_permission"
+	"hongze/hongze_yb/models/tables/fe_calendar_matter"
+	"hongze/hongze_yb/services/company"
+	userService "hongze/hongze_yb/services/user"
+	"hongze/hongze_yb/utils"
+	"time"
+)
+
+// PermissionList 品种列表
+func PermissionList(c *gin.Context) {
+	userInfo := userService.GetInfoByClaims(c)
+
+	// 获取用户有权限的品种
+	validPermissionIds, e := company.GetValidPermissionIdListByCompany2ProductId(userInfo.CompanyID, int64(utils.FiccProductId))
+	if e != nil {
+		response.FailMsg("获取失败", "获取有权限品种列表失败, Err: "+e.Error(), c)
+		return
+	}
+
+	// 遍历品种树
+	permissions, e := chart_permission.GetChartPermissionsByProductId()
+	if e != nil {
+		response.FailMsg("获取失败", "获取品种列表失败, Err: "+e.Error(), c)
+		return
+	}
+	parents := make([]*chart_permission.SimpleChartPermission, 0)
+	parentPermissions := make(map[int][]*chart_permission.SimpleChartPermission, 0)
+	for _, v := range permissions {
+		if v.ParentId > 0 && utils.InArrayByInt(validPermissionIds, int(v.ChartPermissionID)) {
+			if parentPermissions[v.ParentId] == nil {
+				parentPermissions[v.ParentId] = make([]*chart_permission.SimpleChartPermission, 0)
+			}
+			parentPermissions[v.ParentId] = append(parentPermissions[v.ParentId], chart_permission.FormatChartPermission2Simple(v))
+			continue
+		}
+		parents = append(parents, chart_permission.FormatChartPermission2Simple(v))
+	}
+	resp := make([]*chart_permission.SimpleChartPermission, 0)
+	for _, v := range parents {
+		if parentPermissions[v.ChartPermissionId] == nil {
+			continue
+		}
+		v.Children = parentPermissions[v.ChartPermissionId]
+		resp = append(resp, v)
+	}
+
+	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
+	}
+	var month string
+	matterOb := new(fe_calendar_matter.FeCalendarMatter)
+
+	// 当月事项
+	currentMonth := time.Now().Format("2006-01")
+	cond := ` chart_permission_id = ? AND matter_month = ?`
+	pars := make([]interface{}, 0)
+	pars = append(pars, req.ChartPermissionId, currentMonth)
+	item, e := matterOb.GetItemByCondition(cond, pars)
+	if e != nil && e != utils.ErrNoRow {
+		response.FailMsg("获取失败", "获取当月事项失败, Err: "+e.Error(), c)
+		return
+	}
+	if item != nil && item.FeCalendarMatterId > 0 {
+		month = currentMonth
+	}
+
+	// 无当月事项则查询最近的
+	if month == "" {
+		lastest, e := matterOb.GetLastestMonthItemByPermissionId(req.ChartPermissionId)
+		if e != nil && e != utils.ErrNoRow {
+			response.FailMsg("获取失败", "获取事项失败, Err: "+e.Error(), c)
+			return
+		}
+		if lastest != nil && lastest.FeCalendarMatterId > 0 {
+			month = lastest.MatterMonth
+		}
+	}
+	response.OkData("获取成功", month, c)
+}
+
+// MatterList 事项列表
+func MatterList(c *gin.Context) {
+	var req request.FeCalendarMatterListReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误", c)
+		return
+	}
+	if req.ChartPermissionId <= 0 {
+		response.Fail("请选择品种", c)
+		return
+	}
+	//userInfo := userService.GetInfoByClaims(c)
+
+	cond := ` 1=1`
+	pars := make([]interface{}, 0)
+	if req.ChartPermissionId > 0 {
+		cond += fmt.Sprintf(` AND %s = ?`, fe_calendar_matter.FeCalendarMatterColumns.ChartPermissionId)
+		pars = append(pars, req.ChartPermissionId)
+	}
+	if req.StartDate != "" && req.EndDate != "" {
+		_, e := time.Parse(utils.FormatDate, req.StartDate)
+		if e != nil {
+			response.Fail("开始日期格式有误", c)
+			return
+		}
+		_, e = time.Parse(utils.FormatDate, req.EndDate)
+		if e != nil {
+			response.Fail("结束日期格式有误", c)
+			return
+		}
+		cond += fmt.Sprintf(` AND %s >= ? AND %s <= ?`, fe_calendar_matter.FeCalendarMatterColumns.MatterDate, fe_calendar_matter.FeCalendarMatterColumns.MatterDate)
+		pars = append(pars, req.StartDate, req.EndDate)
+	}
+
+	matterOb := new(fe_calendar_matter.FeCalendarMatter)
+	order := fmt.Sprintf(`%s ASC, %s ASC`, fe_calendar_matter.FeCalendarMatterColumns.MatterDate, fe_calendar_matter.FeCalendarMatterColumns.Sort)
+	matters, e := matterOb.GetItemsByCondition(cond, pars, []string{}, order)
+	if e != nil {
+		response.FailMsg("获取失败", "获取事项列表失败, Err: "+e.Error(), c)
+		return
+	}
+
+	dateMatter := make(map[string][]*fe_calendar_matter.FeCalendarMatterItem)
+	for _, v := range matters {
+		d := v.MatterDate.Format(utils.FormatDate)
+		if dateMatter[d] == nil {
+			dateMatter[d] = make([]*fe_calendar_matter.FeCalendarMatterItem, 0)
+		}
+		dateMatter[d] = append(dateMatter[d], fe_calendar_matter.FormatFeCalendarMatter2Item(v))
+	}
+	dateExist := make(map[string]bool)
+	resp := make([]*fe_calendar_matter.FeCalendarMatterListItem, 0)
+	for _, v := range matters {
+		d := v.MatterDate.Format(utils.FormatDate)
+		if dateExist[d] {
+			continue
+		}
+		dateExist[d] = true
+		resp = append(resp, &fe_calendar_matter.FeCalendarMatterListItem{
+			Date:    d,
+			Matters: dateMatter[d],
+		})
+	}
+
+	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

@@ -2,8 +2,8 @@ package init_serve
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/swaggo/gin-swagger"
 	"github.com/swaggo/files"
+	"github.com/swaggo/gin-swagger"
 	_ "hongze/hongze_yb/docs"
 	"hongze/hongze_yb/global"
 	"hongze/hongze_yb/middleware"
@@ -81,5 +81,9 @@ func InitRouter() (r *gin.Engine) {
 	routers.InitMyChart(r)
 	// 持仓分析
 	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

@@ -0,0 +1,19 @@
+package request
+
+// FeCalendarMatterListReq 事项列表请求体
+type FeCalendarMatterListReq struct {
+	ChartPermissionId int    `form:"chart_permission_id" json:"chart_permission_id" description:"品种ID"`
+	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/chart_permission/query.go

@@ -61,3 +61,27 @@ func GetFiccFirstListExceptTacticByProductId() (list []*ChartPermission, err err
 	err = global.DEFAULT_MYSQL.Where(" enabled = 1 AND permission_type = 0 AND product_id = 1 and classify_name != '市场策略' AND parent_id = 0").Order("sort asc").Find(&list).Error
 	return
 }
+
+// GetChartPermissionsByProductId 获取权限列表
+func GetChartPermissionsByProductId() (list []*ChartPermission, err error) {
+	err = global.DEFAULT_MYSQL.Where(" enabled = 1 AND product_id = 1").Order("parent_id ASC, sort ASC, created_time ASC").Find(&list).Error
+	return
+}
+
+type SimpleChartPermission struct {
+	ChartPermissionId   int                      `description:"品种ID" json:"chart_permission_id"`
+	ChartPermissionName string                   `description:"品种名称" json:"chart_permission_name"`
+	Sort                int                      `description:"排序" json:"sort"`
+	Children            []*SimpleChartPermission `description:"子分类" json:"children"`
+}
+
+func FormatChartPermission2Simple(origin *ChartPermission) (item *SimpleChartPermission) {
+	if origin == nil {
+		return
+	}
+	item = new(SimpleChartPermission)
+	item.ChartPermissionId = int(origin.ChartPermissionID)
+	item.ChartPermissionName = origin.PermissionName
+	item.Sort = origin.Sort
+	return
+}

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/entity.go

@@ -0,0 +1,71 @@
+package fe_calendar_matter
+
+import "time"
+
+// FeCalendarMatter 外汇日历-事项表
+type FeCalendarMatter struct {
+	FeCalendarMatterId  int       `gorm:"primaryKey;column:fe_calendar_matter_id;type:int(10) unsigned;not null" json:"-"`                                            // 事项Id
+	ChartPermissionId   int       `gorm:"index:idx_chart_permission_id;column:chart_permission_id;type:int(10) unsigned;not null;default:0" json:"chartPermissionId"` // 品种Id
+	ChartPermissionName string    `gorm:"column:chart_permission_name;type:varchar(128);not null;default:''" json:"chartPermissionName"`                              // 品种名称
+	MatterMonth         string    `gorm:"index:idx_matter_month;column:matter_month;type:varchar(16);not null;default:''" json:"matterMonth"`                         // 事项年月：格式2006-01
+	MatterDate          time.Time `gorm:"index:idx_matter_date;column:matter_date;type:date" json:"matterDate"`                                                       // 事项日期
+	Title               string    `gorm:"column:title;type:varchar(255);not null;default:''" json:"title"`                                                            // 标题
+	MatterType          int       `gorm:"column:matter_type;type:tinyint(4) unsigned;not null;default:0" json:"matterType"`                                           // 事项类型：1-自定义事项；2-基础指标；3-预测指标
+	EdbInfoId           int       `gorm:"column:edb_info_id;type:int(10) unsigned;not null;default:0" json:"edbInfoId"`                                               // 指标Id
+	EdbUniqueCode       string    `gorm:"column:edb_unique_code;type:varchar(128);not null;default:''" json:"edbUniqueCode"`                                          // 指标唯一编码
+	EdbCode             string    `gorm:"column:edb_code;type:varchar(128);not null;default:''" json:"edbCode"`                                                       // 指标编码
+	FontColor           string    `gorm:"column:font_color;type:varchar(64);not null;default:''" json:"fontColor"`                                                    // 字体颜色
+	FillingColor        string    `gorm:"column:filling_color;type:varchar(64);not null;default:''" json:"fillingColor"`                                              // 填充颜色
+	FontBold            int       `gorm:"column:font_bold;type:tinyint(4) unsigned;not null;default:0" json:"fontBold"`                                               // 字体加粗：0-否；1-是
+	Sort                int       `gorm:"column:sort;type:int(10) unsigned;not null;default:0" json:"sort"`                                                           // 排序
+	SysUserId           int       `gorm:"column:sys_user_id;type:int(10) unsigned;not null;default:0" json:"sysUserId"`                                               // 创建人Id
+	SysUserName         string    `gorm:"column:sys_user_name;type:varchar(128);not null;default:''" json:"sysUserName"`                                              // 创建人姓名
+	CreateTime          time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                                                         // 创建时间
+	ModifyTime          time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                                                         // 更新时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *FeCalendarMatter) TableName() string {
+	return "fe_calendar_matter"
+}
+
+// FeCalendarMatterColumns get sql column name.获取数据库列名
+var FeCalendarMatterColumns = struct {
+	FeCalendarMatterId  string
+	ChartPermissionId   string
+	ChartPermissionName string
+	MatterMonth         string
+	MatterDate          string
+	Title               string
+	MatterType          string
+	EdbInfoId           string
+	EdbUniqueCode       string
+	EdbCode             string
+	FontColor           string
+	FillingColor        string
+	FontBold            string
+	Sort                string
+	SysUserId           string
+	SysUserName         string
+	CreateTime          string
+	ModifyTime          string
+}{
+	FeCalendarMatterId:  "fe_calendar_matter_id",
+	ChartPermissionId:   "chart_permission_id",
+	ChartPermissionName: "chart_permission_name",
+	MatterMonth:         "matter_month",
+	MatterDate:          "matter_date",
+	Title:               "title",
+	MatterType:          "matter_type",
+	EdbInfoId:           "edb_info_id",
+	EdbUniqueCode:       "edb_unique_code",
+	EdbCode:             "edb_code",
+	FontColor:           "font_color",
+	FillingColor:        "filling_color",
+	FontBold:            "font_bold",
+	Sort:                "sort",
+	SysUserId:           "sys_user_id",
+	SysUserName:         "sys_user_name",
+	CreateTime:          "create_time",
+	ModifyTime:          "modify_time",
+}

models/tables/fe_calendar_matter/model.go

@@ -0,0 +1,69 @@
+package fe_calendar_matter
+
+import (
+	"fmt"
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/utils"
+)
+
+type FeCalendarMatterItem struct {
+	FeCalendarMatterId  int    `description:"事项ID" json:"fe_calendar_matter_id"`
+	ChartPermissionId   int    `description:"品种ID" json:"chart_permission_id"`
+	ChartPermissionName string `description:"品种名称" json:"chart_permission_name"`
+	MatterDate          string `description:"事项日期" json:"matter_date"`
+	Title               string `description:"标题" json:"title"`
+	MatterType          int    `description:"事项类型：1-自定义事项；2-基础指标；3-预测指标" json:"matter_type"`
+	EdbInfoId           int    `description:"指标ID" json:"edb_info_id"`
+	EdbUniqueCode       string `description:"指标唯一编码" json:"edb_unique_code"`
+	EdbCode             string `description:"指标编码" json:"edb_code"`
+	FontColor           string `description:"字体颜色" json:"font_color"`
+	FillingColor        string `description:"填充颜色" json:"filling_color"`
+	FontBold            int    `description:"字体加粗：0-否；1-是" json:"font_bold"`
+	Sort                int    `description:"排序" json:"sort"`
+}
+
+func FormatFeCalendarMatter2Item(origin *FeCalendarMatter) (item *FeCalendarMatterItem) {
+	if origin == nil {
+		return
+	}
+	item = new(FeCalendarMatterItem)
+	item.FeCalendarMatterId = origin.FeCalendarMatterId
+	item.ChartPermissionId = origin.ChartPermissionId
+	item.ChartPermissionName = origin.ChartPermissionName
+	item.MatterDate = utils.TimeTransferString(utils.FormatDate, origin.MatterDate)
+	item.Title = origin.Title
+	item.MatterType = origin.MatterType
+	item.EdbInfoId = origin.EdbInfoId
+	item.EdbUniqueCode = origin.EdbUniqueCode
+	item.EdbCode = origin.EdbCode
+	item.FontColor = origin.FontColor
+	item.FillingColor = origin.FillingColor
+	item.FontBold = origin.FontBold
+	item.Sort = origin.Sort
+	return
+}
+
+// FeCalendarMatterListItem 事项列表
+type FeCalendarMatterListItem struct {
+	Date    string                  `description:"日期" json:"date"`
+	Matters []*FeCalendarMatterItem `description:"日期事项" json:"matters"`
+}
+
+func (m *FeCalendarMatter) GetItemByCondition(cond string, pars []interface{}) (item *FeCalendarMatter, err error) {
+	err = global.MYSQL["data"].Where(cond, pars...).First(&item).Error
+	return
+}
+
+func (m *FeCalendarMatter) GetItemsByCondition(cond string, pars []interface{}, fieldArr []string, orderRule string) (items []*FeCalendarMatter, err error) {
+	order := fmt.Sprintf(`%s DESC`, FeCalendarMatterColumns.CreateTime)
+	if orderRule != "" {
+		order = orderRule
+	}
+	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

@@ -0,0 +1,15 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/fe_calendar"
+	"hongze/hongze_yb/middleware"
+)
+
+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
+}

utils/constants.go

@@ -4,7 +4,7 @@ package utils
 const (
 	FormatTime            = "15:04:05"                //时间格式
 	FormatDate            = "2006-01-02"              //日期格式
-	FormatDateCN          = "2006年01月02日"          //日期格式（中文）
+	FormatDateCN          = "2006年01月02日"             //日期格式（中文）
 	FormatDateUnSpace     = "20060102"                //日期格式
 	FormatDateTime        = "2006-01-02 15:04:05"     //完整时间格式
 	HlbFormatDateTime     = "2006-01-02_15:04:05.999" //完整时间格式
@@ -197,9 +197,9 @@ const (
 )
 
 const (
-	AdminId     = 11           //系统操作的用户id
+	AdminId     = 11      //系统操作的用户id
 	RealName    = "超级管理员" //系统操作的用户名称
-	HzCompanyId = 16           // 弘则研究公司ID
+	HzCompanyId = 16      // 弘则研究公司ID
 )
 
 // 图表样式类型
@@ -354,3 +354,7 @@ const (
 
 // 默认的品种图片
 const APPLY_VARIETY_IMG_DEFAULT = "https://hzstatic.hzinsights.com/static/yb_variety/default_permission.png"
+
+const (
+	FiccProductId = 1 // FICC标识ID
+)