eta_chart_lib/models/chart.go

package models

import (
	"errors"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/orm"
	"hongze/hongze_chart_lib/utils"
	"strconv"
	"time"

	"github.com/nosixtools/solarlunar"
)

type ChartInfo struct {
	ChartInfoId     int       `json:"-" orm:"column(chart_info_id);pk"`
	ChartName       string    `description:"来源名称"`
	ChartClassifyId int       `json:"-" description:"图表分类id"`
	SysUserId       int       `json:"-"`
	SysUserRealName string    `json:"-"`
	UniqueCode      string    `description:"图表唯一编码"`
	CreateTime      time.Time `json:"-"`
	ModifyTime      time.Time `json:"-"`
	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:"图表图片"`
}

func GetChartInfoByUniqueCode(uniqueCode string) (item *ChartInfo, err error) {
	o := orm.NewOrm()
	o.Using("data")
	sql := ` SELECT * FROM chart_info WHERE unique_code=? `
	err = o.Raw(sql, uniqueCode).QueryRow(&item)
	return
}

type ChartEdbInfoMapping struct {
	EdbInfoId  int    `description:"指标id"`
	SourceName string `description:"来源名称"`
	Source     int    `description:"来源id"`
	EdbCode    string `description:"指标编码"`
	EdbName    string `description:"指标名称"`
	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:领先指标"`
	EdbType int     `description:"指标类型:1:基础指标,2:计算指标"`
	LeadValue   int     `description:"领先值"`
	LeadUnit    string  `description:"领先单位"`
	ChartStyle  string  `description:"图表类型"`
	ChartColor  string  `description:"颜色"`
	ChartWidth  float64 `description:"线条大小"`
	DataList    interface{}
}

func GetChartEdbMappingList(chartInfoId int) (list []*ChartEdbInfoMapping, err error) {
	o := orm.NewOrm()
	o.Using("data")
	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.edb_type
             FROM chart_edb_mapping AS a
			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
			 WHERE chart_info_id=? 
             ORDER BY chart_edb_mapping_id ASC `
	_, err = o.Raw(sql, chartInfoId).QueryRows(&list)
	return
}

type EdbDataList struct {
	EdbDataId     int     `json:"-" description:" 指标数据ID"`
	EdbInfoId     int     `json:"-" description:"指标ID"`
	DataTime      string  `json:"-" description:"数据日期"`
	DataTimestamp int64   `description:"数据日期"`
	Value         float64 `description:"数据值"`
}

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{}
	var condition string
	if startDate != "" {
		condition += ` AND data_time>=? `
		pars = append(pars, startDate)
	}
	if endDate != "" {
		condition += ` AND data_time<=? `
		pars = append(pars, endDate)
	}
	sql := `SELECT edb_data_id,edb_info_id,data_time,TRUNCATE(value,4) AS value,data_timestamp FROM %s WHERE edb_info_id=? `
	if condition != "" {
		sql += condition
	}
	sql += ` ORDER BY data_time ASC  `
	sql = fmt.Sprintf(sql, tableName)
	o := orm.NewOrm()
	o.Using("data")
	_, err = o.Raw(sql, endInfoId, pars).QueryRows(&list)
	return
}

//指标季度数据计算(公历转农历)
func AddCalculateQuarterV4(dataList []*EdbDataList) (result *EdbDataResult, err error) {
	var errMsg string
	defer func() {
		if errMsg != "" {
			fmt.Println("errMsg:", errMsg)
		}
	}()
	result = new(EdbDataResult)
	var yearArr []int
	yearMap := make(map[int]int)
	var cureentDate time.Time
	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
	}
	//排序
	fmt.Println(yearArr)
	thisYear := cureentDate.Year()
	thisMonth := int(cureentDate.Month())

	fmt.Println("thisMonth:", thisMonth)
	//sort.Ints(yearArr)
	fmt.Println("yearArr:", yearArr)
	fmt.Println("thisYear:", thisYear)

	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
			}

			fmt.Println(ky, vy)
			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)
			fmt.Println("currentYearCjgl:", currentYearCjgl, "preYearCjgl:", preYearCjgl)

			items := new(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)
				fmt.Println("line 467:", newDate, selectDate)
				if newDate.Before(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 {
			fmt.Println(ky, vy)
			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)
			items := new(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(nextYear) + "-05" + "-31"
				selectDate, _ := time.Parse(utils.FormatDate, selectDateStr)

				if newDate.Before(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)
		}
	}
	return
}

type EdbDataItems struct {
	Items []*EdbDataList
	Year  int
}

type EdbDataResult struct {
	List []*EdbDataItems
}

type QuarterData struct {
	Year     int
	DataList []*EdbDataList
}

type ChartInfoDetailResp struct {
	ChartInfo   *ChartInfo
	EdbInfoList []*ChartEdbInfoMapping
}

//指标季度数据计算(公历转农历)
func AddCalculateQuarterV5(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)

			items := new(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(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.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
}