add: 图表详情接口

controller/chart/chart_info.go

@@ -0,0 +1,331 @@
+package chart
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/models/response/chart_info"
+	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
+	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
+	edbDataService "hongze/hongze_yb/services/edb_data"
+	"hongze/hongze_yb/utils"
+	"strconv"
+	"time"
+)
+
+// GetChartInfoDetail 获取图表详情
+// @Tags 图库模块
+// @Summary  获取图表详情
+// @Description 获取图表详情
+// @Security ApiKeyAuth
+// @Param Authorization	header string true "Bearer 31a165baebe6dec616b1f8f3207b4273"
+// @Accept  json
+// @Product json
+// @Param DateType query string false "时间段：1-00年至今; 2-10年至今; 3-15年至今; 4-21年至今; 5-指定区间; 6-指定年月至今; 7-18年至今; 8-19年至今; 9-20年至今
+// @Param ClassifyId query string false "图表分类ID"
+// @Success 200 {object} []my_chart.MyChartList
+// @failure 400 {string} string "图表详情获取失败"
+// @Router /chart/GetChartInfoDetail [get]
+func GetChartInfoDetail(c *gin.Context)  {
+	// 图表ID
+	reqChartInfoId := c.DefaultQuery("ChartInfoId", "")
+	if reqChartInfoId == "" {
+		response.Fail("参数有误:图表ID", c)
+		return
+	}
+	chartInfoId, _ := strconv.Atoi(reqChartInfoId)
+
+	startDate := c.DefaultQuery("StartDate", "")
+	endDate := c.DefaultQuery("EndDate", "")
+	// 时段筛选
+	reqDateType := c.DefaultQuery("DateType", "")
+	dateType, _ := strconv.Atoi(reqDateType)
+	if dateType <= 0 {
+		dateType = 3	// 默认同后台15年至今
+	}
+	switch dateType {
+	case 1:
+		startDate = "2000-01-01"
+	case 2:
+		startDate = "2010-01-01"
+	case 3:
+		startDate = "2015-01-01"
+	case 4:
+		startDate = "2021-01-01"
+	case 5:
+		startDate = startDate + "-01"
+		endDate = endDate + "-01"
+	case 6:
+		startDate = startDate + "-01"
+	case 7:
+		startDate = "2018-01-01"
+	case 8:
+		startDate = "2019-01-01"
+	case 9:
+		startDate = "2020-01-01"
+	}
+	// 图表样式类型
+	reqChartType := c.DefaultQuery("ChartType", "")
+	chartType, _ := strconv.Atoi(reqChartType)
+	// 季节性图表时间
+	seasonStartDate := c.DefaultQuery("SeasonStartDate", "")
+	seasonEndDate := c.DefaultQuery("SeasonEndDate", "")
+	// 指标ID
+	edbInfoId := c.DefaultQuery("EdbInfoId", "")
+	// 公历/农历
+	calendar := c.DefaultQuery("Calendar", "公历")
+
+	// 获取图表信息
+	var err error
+	chartInfo := new(chartInfoModel.ChartInfoView)
+	if chartInfoId > 0 {
+		chartInfo, err = chartInfoModel.GetChartInfoViewById(chartInfoId)
+		if err != nil {
+			if err == utils.ErrNoRow {
+				response.Fail("图表不存在，请刷新页面", c)
+				return
+			}
+			response.Fail("获取图表信息失败, Err:" + err.Error(), c)
+			return
+		}
+		chartType = chartInfo.ChartType
+	}
+	if chartType == 2 {
+		// 季节性图表
+		if seasonStartDate != "" {
+			startDate = seasonStartDate + "-01-01"
+		} else {
+			fivePre := time.Now().AddDate(-4, 0, 0).Year()
+			startDate = strconv.Itoa(fivePre) + "-01-01"
+		}
+		if seasonEndDate != "" {
+			endDate = seasonEndDate + "-12-31"
+		} else {
+			endDate = ""
+		}
+	}
+
+	// 获取图表指标映射
+	mappingList := make([]*chartEdbMappingModel.ChartEdbInfoMapping, 0)
+	if chartInfoId > 0 {
+		mappingList, err = chartEdbMappingModel.GetMappingListByChartInfoId(chartInfoId)
+		if err != nil {
+			response.Fail("获取图表指标信息失败, Err:" + err.Error(), c)
+			return
+		}
+	} else {
+		if edbInfoId != "" {
+			mappingList, err = chartEdbMappingModel.GetMappingListByEdbInfoId(edbInfoId)
+			if err != nil {
+				response.Fail("获取图表指标信息失败, Err:" + err.Error(), c)
+				return
+			}
+		}
+	}
+
+	edbList := make([]*chartEdbMappingModel.ChartEdbInfoMapping, 0)
+	for _, v := range mappingList {
+		item := new(chartEdbMappingModel.ChartEdbInfoMapping)
+		item.EdbInfoId = v.EdbInfoId
+		item.SourceName = v.SourceName
+		item.Source = v.Source
+		item.EdbCode = v.EdbCode
+		item.EdbName = v.EdbName
+		item.Frequency = v.Frequency
+		item.Unit = v.Unit
+		item.StartDate = v.StartDate
+		item.EndDate = v.EndDate
+		item.ModifyTime = v.ModifyTime
+		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
+
+		var startDateReal string
+		var diffSeconds int64
+		if chartType == 1 {
+			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
+			}
+		} 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.Fail("农历时间转换有误, 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.Fail("获取图表指标信息失败, 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.Fail("获取农历数据失败, 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.Fail("季度指标日期转换失败, 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)
+	}
+
+	/*if chartInfoId > 0 && chartInfo != nil {
+		// 判断是否加入我的图库
+		{
+			var myChartCondition string
+			var myChartPars []interface{}
+			myChartCondition += ` AND a.admin_id = ? `
+			myChartPars = append(myChartPars, userInfo.AdminId)
+			myChartCondition += ` AND a.chart_info_id = ? `
+			myChartPars = append(myChartPars, chartInfo.ChartInfoId)
+
+			myChartList, err := my_chart.GetMyChartByCondition(myChartCondition, myChartPars)
+			if err != nil && err != utils.ErrNoRow {
+				response.Fail("获取我的图表信息失败, Err:" + err.Error(), c)
+				return
+			}
+			if myChartList != nil && len(myChartList) > 0 {
+				chartInfo.IsAdd = true
+				chartInfo.MyChartId = myChartList[0].MyChartId
+				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
+			}
+		}
+	}*/
+
+	resp := new(chart_info.ChartInfoDetailResp)
+	resp.ChartInfo = chartInfo
+	resp.EdbInfoList = edbList
+	response.OkData("获取成功", resp, c)
+}
+
+// RefreshChartInfo 刷新图表信息
+func RefreshChartInfo(c *gin.Context)  {
+
+}
+
+// EditChartInfo 编辑图表信息
+func EditChartInfo(c *gin.Context)  {
+
+}

controller/chart/my_chart.go

@@ -8,7 +8,6 @@ import (
 	"hongze/hongze_yb/services/chart"
 	"hongze/hongze_yb/services/user"
 	"strconv"
-	"strings"
 )
 
 // GetMyChartChassify 获取图表分类列表
@@ -56,6 +55,7 @@ func GetMyChartChassify(c *gin.Context) {
 // @Accept  json
 // @Product json
 // @Param Keywords query string false "图表名称关键词"
+// @Param ClassifyId query string false "图表分类ID"
 // @Param Page query int false "当前页页码，从1开始"
 // @Param Limit query int false "每页数据量"
 // @Success 200 {object} []my_chart.MyChartList
@@ -64,34 +64,44 @@ func GetMyChartChassify(c *gin.Context) {
 func GetMyChartList(c *gin.Context) {
 	userInfo := user.GetInfoByClaims(c)
 
-	// 获取图表分类IDs
-	publicCondition := make(map[string]interface{})
-	privateCondition := make(map[string]interface{})
-	publicClassify, privateClassify, err := chart.GetUserChartClassifyListByCondition(userInfo, publicCondition, privateCondition)
-	if err != nil {
-		response.Fail("获取图标信息失败, Err:" + err.Error(), c)
-		return
-	}
-
+	// 筛选
 	var condition string
 	var pars []interface{}
-	// 图表分类
-	classifyIdsSlice := make([]string, 0)
-	for i := 0; i < len(publicClassify); i++ {
-		classifyIdsSlice = append(classifyIdsSlice, strconv.Itoa(publicClassify[i].MyChartClassifyID))
-	}
-	for i := 0; i < len(privateClassify); i++ {
-		classifyIdsSlice = append(classifyIdsSlice, strconv.Itoa(privateClassify[i].MyChartClassifyID))
-	}
-	classifyIdsStr := strings.Join(classifyIdsSlice, ",")
-	condition += " AND d.my_chart_classify_id IN (?)"
-	pars = append(pars, classifyIdsStr)
-	// 关键词
 	reqKeywords := c.DefaultQuery("Keywords", "")
-	if reqKeywords != "" {
+	reqClassifyId := c.DefaultQuery("ClassifyId", "")
+
+	if reqClassifyId == "" && reqKeywords == "" {
+		// 默认展示第一个最小分类下的图表
+		publicCondition := make(map[string]interface{})
+		privateCondition := make(map[string]interface{})
+		publicClassify, privateClassify, err := chart.GetUserChartClassifyListByCondition(userInfo, publicCondition, privateCondition)
+		if err != nil {
+			response.Fail("获取图表分类信息失败, Err:" + err.Error(), c)
+			return
+		}
+		// 内部员工默认取自己的第一个分类
+		classifyId := 0
+		if len(privateClassify) > 0 {
+			classifyId = privateClassify[0].MyChartClassifyID
+		} else {
+			if len(publicClassify) > 0 {
+				classifyId = publicClassify[0].MyChartClassifyID
+			}
+		}
+
+		condition += " AND d.my_chart_classify_id = ?"
+		pars = append(pars, classifyId)
+	} else if reqKeywords != "" {
+		// 关键词
 		condition += " AND b.chart_name LIKE ?"
 		pars = append(pars, "%" + reqKeywords + "%")
+	} else {
+		// 指定分类
+		condition += " AND d.my_chart_classify_id = ?"
+		pars = append(pars, reqClassifyId)
 	}
+
+	// 分页
 	page, _ := strconv.Atoi(c.Query("Page"))
 	limit, _ := strconv.Atoi(c.Query("Limit"))
 	if page == 0 {
@@ -108,10 +118,4 @@ func GetMyChartList(c *gin.Context) {
 	}
 
 	response.OkData("获取成功", list, c)
-}
-
-
-// GetChartInfo 获取图表详情
-func GetChartInfo(c *gin.Context)  {
-
 }

go.mod

@@ -35,4 +35,5 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gorm.io/driver/mysql v1.1.3
 	gorm.io/gorm v1.22.2
+	github.com/nosixtools/solarlunar v0.0.0-20211112060703-1b6dea7b4a19
 )

models/response/chart_info/chart_info.go

@@ -0,0 +1,11 @@
+package chart_info
+
+import (
+	"hongze/hongze_yb/models/tables/chart_edb_mapping"
+	"hongze/hongze_yb/models/tables/chart_info"
+)
+
+type ChartInfoDetailResp struct {
+	ChartInfo   *chart_info.ChartInfoView
+	EdbInfoList []*chart_edb_mapping.ChartEdbInfoMapping
+}

models/tables/chart_classify/chart_classify.go

@@ -0,0 +1,50 @@
+package chart_classify
+
+import "time"
+
+// ChartClassify 图表分类表
+type ChartClassify struct {
+	ChartClassifyID   int       `gorm:"primaryKey;column:chart_classify_id;type:int(11);not null" json:"-"`
+	ChartClassifyName string    `gorm:"column:chart_classify_name;type:varchar(255);not null;default:''" json:"chartClassifyName"` // 分类名称
+	ParentID          int       `gorm:"column:parent_id;type:int(11);not null;default:0" json:"parentId"`                          // 父级id
+	HasData           int8      `gorm:"column:has_data;type:tinyint(4);default:0" json:"hasData"`                                  // 是否存在指标数据:1有，2：无
+	CreateTime        time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                        // 创建时间
+	ModifyTime        time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                        // 修改时间
+	SysUserID         int       `gorm:"column:sys_user_id;type:int(11)" json:"sysUserId"`                                          // 创建人id
+	SysUserRealName   string    `gorm:"column:sys_user_real_name;type:varchar(50)" json:"sysUserRealName"`                         // 创建人姓名
+	Level             int       `gorm:"column:level;type:int(11);default:0" json:"level"`                                          // 层级
+	UniqueCode        string    `gorm:"unique;column:unique_code;type:varchar(50);default:''" json:"uniqueCode"`
+	Sort              uint32    `gorm:"column:sort;type:int(9) unsigned;default:10" json:"sort"` // 排序字段，越小越靠前，默认值：10
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *ChartClassify) TableName() string {
+	return "chart_classify"
+}
+
+// ChartClassifyColumns get sql column name.获取数据库列名
+var ChartClassifyColumns = struct {
+	ChartClassifyID   string
+	ChartClassifyName string
+	ParentID          string
+	HasData           string
+	CreateTime        string
+	ModifyTime        string
+	SysUserID         string
+	SysUserRealName   string
+	Level             string
+	UniqueCode        string
+	Sort              string
+}{
+	ChartClassifyID:   "chart_classify_id",
+	ChartClassifyName: "chart_classify_name",
+	ParentID:          "parent_id",
+	HasData:           "has_data",
+	CreateTime:        "create_time",
+	ModifyTime:        "modify_time",
+	SysUserID:         "sys_user_id",
+	SysUserRealName:   "sys_user_real_name",
+	Level:             "level",
+	UniqueCode:        "unique_code",
+	Sort:              "sort",
+}

models/tables/chart_classify/query.go

@@ -0,0 +1,7 @@
+package chart_classify
+
+type ChartClassifyView struct {
+	ChartClassifyId   int       `orm:"column(chart_classify_id);pk"`
+	ChartClassifyName string    `description:"分类名称"`
+	ParentId          int       `description:"父级id"`
+}

models/tables/chart_edb_mapping/chart_edb_mapping.go

@@ -0,0 +1,65 @@
+package chart_edb_mapping
+
+import "time"
+
+// ChartEdbMapping 图表指标映射表
+type ChartEdbMapping struct {
+	ChartEdbMappingID int       `gorm:"primaryKey;column:chart_edb_mapping_id;type:int(11);not null" json:"-"`
+	ChartInfoID       int       `gorm:"uniqueIndex:idx_chart_edb;column:chart_info_id;type:int(11);default:0" json:"chartInfoId"` // 图表id
+	EdbInfoID         int       `gorm:"uniqueIndex:idx_chart_edb;column:edb_info_id;type:int(11);default:0" json:"edbInfoId"`     // 指标id
+	CreateTime        time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                       // 创建时间
+	ModifyTime        time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                       // 修改时间
+	UniqueCode        string    `gorm:"unique;column:unique_code;type:varchar(50);default:''" json:"uniqueCode"`                  // 唯一编码
+	MaxData           float64   `gorm:"column:max_data;type:double;default:0" json:"maxData"`                                     // 上限
+	MinData           float64   `gorm:"column:min_data;type:double;default:0" json:"minData"`                                     // 下限
+	IsOrder           int8      `gorm:"column:is_order;type:tinyint(4);default:1" json:"isOrder"`                                 // 1:正序,0:逆序
+	IsAxis            int8      `gorm:"column:is_axis;type:tinyint(4);default:1" json:"isAxis"`                                   // 1:左轴,0:右轴
+	EdbInfoType       int8      `gorm:"column:edb_info_type;type:tinyint(4);default:1" json:"edbInfoType"`                        // 1:标准指标,0:领先指标
+	LeadValue         int       `gorm:"column:lead_value;type:int(11);default:0" json:"leadValue"`                                // 领先值
+	LeadUnit          string    `gorm:"column:lead_unit;type:varchar(10);default:''" json:"leadUnit"`                             // 领先单位
+	ChartStyle        string    `gorm:"column:chart_style;type:varchar(20);default:''" json:"chartStyle"`                         // 图表类型
+	ChartColor        string    `gorm:"column:chart_color;type:varchar(20);default:''" json:"chartColor"`                         // 颜色
+	ChartWidth        float64   `gorm:"column:chart_width;type:double;default:0" json:"chartWidth"`                               // 线条大小
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *ChartEdbMapping) TableName() string {
+	return "chart_edb_mapping"
+}
+
+// ChartEdbMappingColumns get sql column name.获取数据库列名
+var ChartEdbMappingColumns = struct {
+	ChartEdbMappingID string
+	ChartInfoID       string
+	EdbInfoID         string
+	CreateTime        string
+	ModifyTime        string
+	UniqueCode        string
+	MaxData           string
+	MinData           string
+	IsOrder           string
+	IsAxis            string
+	EdbInfoType       string
+	LeadValue         string
+	LeadUnit          string
+	ChartStyle        string
+	ChartColor        string
+	ChartWidth        string
+}{
+	ChartEdbMappingID: "chart_edb_mapping_id",
+	ChartInfoID:       "chart_info_id",
+	EdbInfoID:         "edb_info_id",
+	CreateTime:        "create_time",
+	ModifyTime:        "modify_time",
+	UniqueCode:        "unique_code",
+	MaxData:           "max_data",
+	MinData:           "min_data",
+	IsOrder:           "is_order",
+	IsAxis:            "is_axis",
+	EdbInfoType:       "edb_info_type",
+	LeadValue:         "lead_value",
+	LeadUnit:          "lead_unit",
+	ChartStyle:        "chart_style",
+	ChartColor:        "chart_color",
+	ChartWidth:        "chart_width",
+}

models/tables/chart_edb_mapping/query.go

@@ -0,0 +1,54 @@
+package chart_edb_mapping
+
+import "hongze/hongze_yb/global"
+
+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:"最大值"`
+	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
+             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=? 
+             ORDER BY chart_edb_mapping_id ASC `
+	err = global.MYSQL["data"].Raw(sql, chartInfoId).Scan(&list).Error
+
+	return
+}
+
+// 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 + `) `
+	err = global.MYSQL["data"].Raw(sql).Scan(&list).Error
+	return
+}

models/tables/chart_info/chart_info.go

@@ -0,0 +1,91 @@
+package chart_info
+
+import (
+	"time"
+)
+
+// ChartInfo 图表信息表
+type ChartInfo struct {
+	ChartInfoID     int       `gorm:"primaryKey;column:chart_info_id;type:int(11);not null" json:"-"`
+	ChartName       string    `gorm:"uniqueIndex:idx_chart_name;column:chart_name;type:varchar(500);default:''" json:"chartName"`        // 图表名称
+	UniqueCode      string    `gorm:"unique;column:unique_code;type:varchar(50);default:''" json:"uniqueCode"`                           // 唯一编码
+	ChartClassifyID int       `gorm:"uniqueIndex:idx_chart_name;column:chart_classify_id;type:int(11);default:0" json:"chartClassifyId"` // 分类id
+	SysUserID       int       `gorm:"column:sys_user_id;type:int(11);default:0" json:"sysUserId"`                                        // 创建人id
+	SysUserRealName string    `gorm:"column:sys_user_real_name;type:varchar(100);default:''" json:"sysUserRealName"`                     // 创建人姓名
+	CreateTime      time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	ModifyTime      time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`
+	DateType        int       `gorm:"column:date_type;type:int(11);default:0" json:"dateType"`                     // 日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间,6:起始日期至今
+	StartDate       string    `gorm:"column:start_date;type:varchar(30);default:''" json:"startDate"`              // 自定义开始日期
+	EndDate         string    `gorm:"column:end_date;type:varchar(30);default:''" json:"endDate"`                  // 自定义结束日期
+	IsSetName       int8      `gorm:"column:is_set_name;type:tinyint(4);default:0" json:"isSetName"`               // 0:未修改，1:已修改
+	EdbInfoIDs      string    `gorm:"column:edb_info_ids;type:varchar(100);default:''" json:"edbInfoIds"`          // 指标id
+	ChartType       int8      `gorm:"column:chart_type;type:tinyint(4);default:1" json:"chartType"`                // 生成样式:1:曲线图,2:季节性图
+	Calendar        string    `gorm:"column:calendar;type:varchar(10);default:''" json:"calendar"`                 // 公历/农历
+	SeasonStartDate string    `gorm:"column:season_start_date;type:varchar(30);default:''" json:"seasonStartDate"` // 季节开始日期
+	SeasonEndDate   string    `gorm:"column:season_end_date;type:varchar(30);default:''" json:"seasonEndDate"`     // 季节结束日期
+	ChartImage      string    `gorm:"column:chart_image;type:varchar(255);default:''" json:"chartImage"`           // 图表图片
+	Sort            int       `gorm:"column:sort;type:int(9);default:0" json:"sort"`                               // 排序字段，数字越小越排前面
+	EdbEndDate      time.Time `gorm:"column:edb_end_date;type:date" json:"edbEndDate"`                             // 指标最后更新日期
+	LeftMin         string    `gorm:"column:left_min;type:varchar(30);default:''" json:"leftMin"`                  // 图表左侧最小值
+	LeftMax         string    `gorm:"column:left_max;type:varchar(30);default:''" json:"leftMax"`                  // 图表左侧最大值
+	RightMin        string    `gorm:"column:right_min;type:varchar(30);default:''" json:"rightMin"`                // 图表右侧最小值
+	RightMax        string    `gorm:"column:right_max;type:varchar(30);default:''" json:"rightMax"`                // 图表右侧最大值
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *ChartInfo) TableName() string {
+	return "chart_info"
+}
+
+// ChartInfoColumns get sql column name.获取数据库列名
+var ChartInfoColumns = struct {
+	ChartInfoID     string
+	ChartName       string
+	UniqueCode      string
+	ChartClassifyID string
+	SysUserID       string
+	SysUserRealName string
+	CreateTime      string
+	ModifyTime      string
+	DateType        string
+	StartDate       string
+	EndDate         string
+	IsSetName       string
+	EdbInfoIDs      string
+	ChartType       string
+	Calendar        string
+	SeasonStartDate string
+	SeasonEndDate   string
+	ChartImage      string
+	Sort            string
+	EdbEndDate      string
+	LeftMin         string
+	LeftMax         string
+	RightMin        string
+	RightMax        string
+}{
+	ChartInfoID:     "chart_info_id",
+	ChartName:       "chart_name",
+	UniqueCode:      "unique_code",
+	ChartClassifyID: "chart_classify_id",
+	SysUserID:       "sys_user_id",
+	SysUserRealName: "sys_user_real_name",
+	CreateTime:      "create_time",
+	ModifyTime:      "modify_time",
+	DateType:        "date_type",
+	StartDate:       "start_date",
+	EndDate:         "end_date",
+	IsSetName:       "is_set_name",
+	EdbInfoIDs:      "edb_info_ids",
+	ChartType:       "chart_type",
+	Calendar:        "calendar",
+	SeasonStartDate: "season_start_date",
+	SeasonEndDate:   "season_end_date",
+	ChartImage:      "chart_image",
+	Sort:            "sort",
+	EdbEndDate:      "edb_end_date",
+	LeftMin:         "left_min",
+	LeftMax:         "left_max",
+	RightMin:        "right_min",
+	RightMax:        "right_max",
+}

models/tables/chart_info/query.go

@@ -0,0 +1,45 @@
+package chart_info
+
+import (
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/models/tables/chart_classify"
+	"time"
+)
+
+type ChartInfoView struct {
+	ChartInfoId       int    `orm:"column(chart_info_id);pk"`
+	ChartName         string `description:"来源名称"`
+	ChartClassifyId   int    `description:"图表分类id"`
+	ChartClassifyName string `description:"图表名称"`
+	SysUserId         int
+	SysUserRealName   string
+	UniqueCode        string `description:"图表唯一编码"`
+	CreateTime        time.Time
+	ModifyTime        time.Time
+	DateType          int    `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
+	StartDate         string `description:"自定义开始日期"`
+	EndDate           string `description:"自定义结束日期"`
+	IsSetName         int    `description:"设置名称"`
+	EdbInfoIds        string `description:"指标id"`
+	ChartType         int    `description:"生成样式:1:曲线图,2:季节性图"`
+	Calendar          string `description:"公历/农历"`
+	SeasonStartDate   string `description:"季节性图开始日期"`
+	SeasonEndDate     string `description:"季节性图开始日期"`
+	ChartImage        string `description:"图表图片"`
+	Sort              int    `description:"排序字段，数字越小越排前面"`
+	IsAdd             bool   `description:"true:已加入我的图库,false:未加入我的图库"`
+	MyChartId         int
+	MyChartClassifyId string `description:"我的图表分类，多个用逗号隔开"`
+	EdbEndDate        string `description:"指标最新更新日期"`
+	LeftMin           string `description:"图表左侧最小值"`
+	LeftMax           string `description:"图表左侧最大值"`
+	RightMin          string `description:"图表右侧最小值"`
+	RightMax          string `description:"图表右侧最大值"`
+	ChartClassify     []*chart_classify.ChartClassifyView
+}
+
+// 通过Id获取图表信息
+func GetChartInfoViewById(chartInfoId int) (item *ChartInfoView, err error) {
+	err = global.MYSQL["data"].Where("chart_info_id = ?", chartInfoId).First(&item).Error
+	return
+}

models/tables/chart_info_log/chart_info_log.go

@@ -0,0 +1,50 @@
+package chart_info_log
+
+import "time"
+
+// ChartInfoLog 图表操作日志表
+type ChartInfoLog struct {
+	ChartInfoLogID  int       `gorm:"primaryKey;column:chart_info_log_id;type:int(11);not null" json:"-"`
+	ChartInfoID     int       `gorm:"index:idx_chart_info_id;column:chart_info_id;type:int(11);default:0" json:"chartInfoId"`
+	ChartName       string    `gorm:"column:chart_name;type:varchar(500);default:''" json:"chartName"`               // 图表名称
+	UniqueCode      string    `gorm:"column:unique_code;type:varchar(50);default:''" json:"uniqueCode"`              // 唯一编码
+	ChartClassifyID int       `gorm:"column:chart_classify_id;type:int(11);default:0" json:"chartClassifyId"`        // 分类id
+	SysUserID       int       `gorm:"column:sys_user_id;type:int(11);default:0" json:"sysUserId"`                    // 创建人id
+	SysUserRealName string    `gorm:"column:sys_user_real_name;type:varchar(100);default:''" json:"sysUserRealName"` // 创建人姓名
+	CreateTime      time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	Content         string    `gorm:"column:content;type:text" json:"content"`
+	Status          string    `gorm:"column:status;type:varchar(50);default:''" json:"status"`
+	Method          string    `gorm:"column:method;type:varchar(255);default:''" json:"method"`
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *ChartInfoLog) TableName() string {
+	return "chart_info_log"
+}
+
+// ChartInfoLogColumns get sql column name.获取数据库列名
+var ChartInfoLogColumns = struct {
+	ChartInfoLogID  string
+	ChartInfoID     string
+	ChartName       string
+	UniqueCode      string
+	ChartClassifyID string
+	SysUserID       string
+	SysUserRealName string
+	CreateTime      string
+	Content         string
+	Status          string
+	Method          string
+}{
+	ChartInfoLogID:  "chart_info_log_id",
+	ChartInfoID:     "chart_info_id",
+	ChartName:       "chart_name",
+	UniqueCode:      "unique_code",
+	ChartClassifyID: "chart_classify_id",
+	SysUserID:       "sys_user_id",
+	SysUserRealName: "sys_user_real_name",
+	CreateTime:      "create_time",
+	Content:         "content",
+	Status:          "status",
+	Method:          "method",
+}

models/tables/edb_data/query.go

@@ -0,0 +1,115 @@
+package edb_data
+
+import (
+	"errors"
+	"fmt"
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/utils"
+	"strconv"
+)
+
+// 指标数据->存储表
+func GetEdbDataTableName(source int) (tableName string) {
+	switch source {
+	case utils.DATA_SOURCE_THS:
+		tableName = "edb_data_ths"
+	case utils.DATA_SOURCE_WIND:
+		tableName = "edb_data_wind"
+	case utils.DATA_SOURCE_PB:
+		tableName = "edb_data_pb"
+	case utils.DATA_SOURCE_CALCULATE:
+		tableName = "edb_data_calculate"
+	case utils.DATA_SOURCE_CALCULATE_LJZZY:
+		tableName = "edb_data_calculate_ljzzy"
+	case utils.DATA_SOURCE_CALCULATE_TBZ:
+		tableName = "edb_data_calculate_tbz"
+	case utils.DATA_SOURCE_CALCULATE_TCZ:
+		tableName = "edb_data_calculate_tcz"
+	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS:
+		tableName = "edb_data_calculate_nszydpjjs"
+	case utils.DATA_SOURCE_MANUAL:
+		tableName = "edb_data_manual"
+	case utils.DATA_SOURCE_LZ:
+		tableName = "edb_data_lz"
+	case utils.DATA_SOURCE_YS:
+		tableName = "edb_data_ys"
+	case utils.DATA_SOURCE_CALCULATE_HBZ:
+		tableName = "edb_data_calculate_hbz"
+	case utils.DATA_SOURCE_CALCULATE_HCZ:
+		tableName = "edb_data_calculate_hcz"
+	case utils.DATA_SOURCE_CALCULATE_BP:
+		tableName = "edb_data_calculate_bp"
+	case utils.DATA_SOURCE_GL:
+		tableName = "edb_data_gl"
+	case utils.DATA_SOURCE_ZZ:
+		tableName = "edb_data_zz"
+	case utils.DATA_SOURCE_DL:
+		tableName = "edb_data_dl"
+	case utils.DATA_SOURCE_SH:
+		tableName = "edb_data_sh"
+	case utils.DATA_SOURCE_CFFEX:
+		tableName = "edb_data_cffex"
+	case utils.DATA_SOURCE_SHFE:
+		tableName = "edb_data_ine"
+	case utils.DATA_SOURCE_GIE:
+		tableName = "edb_data_gie"
+	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
+		tableName = "edb_data_calculate_zjpj"
+	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT:
+		tableName = "edb_data_calculate_time_shift"
+	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ:
+		tableName = "edb_data_calculate_ljztbpj"
+	case utils.DATA_SOURCE_LT:
+		tableName = "edb_data_lt"
+	default:
+		tableName = ""
+	}
+	return
+}
+
+type EdbDataList struct {
+	EdbDataId     int     `description:" 指标数据ID"`
+	EdbInfoId     int     `description:"指标ID"`
+	DataTime      string  //`json:"-" description:"数据日期"`
+	DataTimestamp int64   `description:"数据日期"`
+	Value         float64 `description:"数据值"`
+}
+
+type EdbDataItems struct {
+	Items []*EdbDataList
+	Year  int
+}
+
+type EdbDataResult struct {
+	List []*EdbDataItems
+}
+
+type QuarterData struct {
+	Year     int
+	DataList []*EdbDataList
+}
+
+// GetEdbDataList 获取指标数据
+func GetEdbDataList(source, endInfoId int, startDate, endDate string) (list []*EdbDataList, err error) {
+	tableName := GetEdbDataTableName(source)
+	if tableName == "" {
+		err = errors.New("无效的渠道：" + strconv.Itoa(source))
+		list = make([]*EdbDataList, 0)
+		return list, err
+	}
+	var pars []interface{}
+	sql := `SELECT edb_data_id,edb_info_id,data_time,value,data_timestamp FROM %s WHERE edb_info_id = ? `
+	if startDate != "" {
+		sql += ` AND data_time >= ? `
+		pars = append(pars, startDate)
+	}
+	if endDate != "" {
+		sql += ` AND data_time <= ? `
+		pars = append(pars, endDate)
+	}
+	sql += ` ORDER BY data_time ASC `
+	sql = fmt.Sprintf(sql, tableName)
+	err = global.MYSQL["data"].Raw(sql, endInfoId, pars).Scan(&list).Error
+
+	return
+}

models/tables/my_chart/query.go

@@ -32,7 +32,16 @@ type MyChartList struct {
 	EdbEndDate          string	`description:"指标最新更新日期"`
 }
 
-// GetMyChartListByCondition 条件获取图库列表
+type MyChartView struct {
+	MyChartId         int       `orm:"column(my_chart_id);pk"`
+	ChartInfoId       int       `description:"图表id"`
+	AdminId           int       `description:"用户id"`
+	CreateTime        time.Time `description:"创建时间"`
+	ModifyTime        time.Time `description:"修改时间"`
+	MyChartClassifyId string
+}
+
+// GetMyChartListByCondition 条件获取我的图表列表
 func GetMyChartListByCondition(condition string, pars []interface{}, page, limit int) (list []*MyChartList, err error) {
 	sql := ` SELECT a.my_chart_id,c.sort,b.* FROM my_chart AS a
 			INNER JOIN chart_info AS b ON a.chart_info_id=b.chart_info_id
@@ -47,5 +56,20 @@ func GetMyChartListByCondition(condition string, pars []interface{}, page, limit
 	pars = append(pars, offset, limit)
 	err = global.MYSQL["data"].Raw(sql, pars).Scan(&list).Error
 
+	return
+}
+
+// GetMyChartByCondition 条件获取我的图表
+func GetMyChartByCondition(condition string, pars []interface{}) (list []*MyChartView, err error) {
+	sql := ` SELECT a.*,GROUP_CONCAT(c.my_chart_classify_id SEPARATOR ',') AS my_chart_classify_id FROM my_chart AS a
+			LEFT JOIN  my_chart_classify_mapping AS b ON a.my_chart_id=b.my_chart_id AND a.admin_id=b.admin_id
+			LEFT JOIN my_chart_classify AS c ON b.my_chart_classify_id=c.my_chart_classify_id AND b.admin_id=c.admin_id
+			WHERE 1=1 `
+	if condition != "" {
+		sql += condition
+	}
+	sql += ` GROUP BY a.chart_info_id  `
+	err = global.MYSQL["data"].Raw(sql, pars).Scan(&list).Error
+
 	return
 }

routers/chart.go

@@ -11,5 +11,6 @@ func InitChart(r *gin.Engine) {
 	{
 		rGroup.GET("/getChartChassify", chart.GetMyChartChassify)
 		rGroup.GET("/getChartList", chart.GetMyChartList)
+		rGroup.GET("/getChartDetail", chart.GetChartInfoDetail)
 	}
 }

services/edb_data/edb_data.go

@@ -0,0 +1,185 @@
+package edb_data
+
+import (
+	"fmt"
+	"github.com/nosixtools/solarlunar"
+	"hongze/hongze_yb/models/tables/edb_data"
+	"hongze/hongze_yb/utils"
+	"strconv"
+	"time"
+)
+
+// AddCalculateQuarter 指标季度数据计算(公历转农历)
+func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.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(edb_data.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)
+
+			items := new(edb_data.EdbDataItems)
+			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(edb_data.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(edb_data.EdbDataItems)
+			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(edb_data.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(edb_data.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
+}

utils/constants.go

@@ -40,3 +40,33 @@ var (
 const (
 	key = "zDeESsxsXuionhqSLZYHWcDJ" //全局加密KEY
 )
+
+//数据来源渠道
+const (
+	DATA_SOURCE_THS                  = iota + 1 //同花顺
+	DATA_SOURCE_WIND                            //wind
+	DATA_SOURCE_PB                              //彭博
+	DATA_SOURCE_CALCULATE                       //指标运算
+	DATA_SOURCE_CALCULATE_LJZZY                 //累计值转月
+	DATA_SOURCE_CALCULATE_TBZ                   //同比值
+	DATA_SOURCE_CALCULATE_TCZ                   //同差值
+	DATA_SOURCE_CALCULATE_NSZYDPJJS             //N数值移动平均计算
+	DATA_SOURCE_MANUAL                          //手工指标
+	DATA_SOURCE_LZ                              //隆众
+	DATA_SOURCE_YS                              //有色
+	DATA_SOURCE_CALCULATE_HBZ                   //环比值->12
+	DATA_SOURCE_CALCULATE_HCZ                   //环差值->13
+	DATA_SOURCE_CALCULATE_BP                    //变频->14
+	DATA_SOURCE_GL                              //钢联->15
+	DATA_SOURCE_ZZ                              //郑商所->16
+	DATA_SOURCE_DL                              //大商所->17
+	DATA_SOURCE_SH                              //上期所->18
+	DATA_SOURCE_CFFEX                           //中金所->19
+	DATA_SOURCE_SHFE                            //上期能源->20
+	DATA_SOURCE_GIE                             //欧洲天然气->21
+	DATA_SOURCE_CALCULATE_TIME_SHIFT            //时间移位->22
+	DATA_SOURCE_CALCULATE_ZJPJ                  //直接拼接->23
+	DATA_SOURCE_CALCULATE_LJZTBPJ               //累计值同比拼接->24
+	DATA_SOURCE_LT                              //路透->25
+
+)