package data
import (
"encoding/json"
"errors"
"eta/eta_api/models"
"eta/eta_api/models/company"
"eta/eta_api/models/data_manage"
"eta/eta_api/models/system"
"eta/eta_api/services/alarm_msg"
"eta/eta_api/services/data/data_manage_permission"
"eta/eta_api/utils"
"fmt"
"github.com/shopspring/decimal"
"math"
"sort"
"strconv"
"strings"
"time"
)
func ChartInfoRefreshV1(chartInfoId int) (err error) {
var errmsg string
defer func() {
if err != nil {
go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
fmt.Println("ChartInfoRefresh Err:" + errmsg)
}
}()
baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshData(chartInfoId)
if err != nil {
errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
return
}
newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
baseMap := make(map[int]*data_manage.EdbInfo)
for _, bv := range baseEdbInfoArr {
// 如果不是普通指标，那么过滤
if bv.EdbInfoType != 0 {
continue
}
if _, ok := baseMap[bv.EdbInfoId]; !ok {
newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
}
baseMap[bv.EdbInfoId] = bv
}
fmt.Println("calculateInfoArr:", len(calculateInfoArr))
newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
calculateMap := make(map[int]*data_manage.EdbInfo)
var calculateArr []int
for _, bv := range calculateInfoArr {
if _, ok := calculateMap[bv.EdbInfoId]; !ok {
newCalculateInfoArr = append(newCalculateInfoArr, bv)
calculateArr = append(calculateArr, bv.EdbInfoId)
}
calculateMap[bv.EdbInfoId] = bv
}
sort.Ints(calculateArr)
// 刷新相关基础指标
for _, bv := range newBaseEdbInfoArr {
err, errmsg = refreshBaseEdbInfo(bv)
if err != nil {
return
}
}
// 刷新相关计算指标
for _, v := range calculateArr {
edbInfo := calculateMap[v]
if edbInfo == nil {
return err
}
err, errmsg = refreshCalculateEdbInfo(edbInfo)
if err != nil {
return
}
}
return err
}
// BatchChartInfoRefresh 图表批量刷新
func BatchChartInfoRefresh(chartInfoList []*data_manage.ChartInfo) (err error) {
if len(chartInfoList) <= 0 {
return
}
chartInfoIdSlice := make([]string, 0)
for _, chartInfo := range chartInfoList {
chartInfoIdSlice = append(chartInfoIdSlice, strconv.Itoa(chartInfo.ChartInfoId))
}
var errmsg string
defer func() {
if err != nil {
go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
fmt.Println("ChartInfoRefresh Err:" + errmsg)
}
}()
baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshDataByChartInfoIdSlice(chartInfoIdSlice)
if err != nil {
errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
return
}
//基础指标去重
newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
baseMap := make(map[int]*data_manage.EdbInfo)
for _, bv := range baseEdbInfoArr {
fmt.Println(bv.UniqueCode)
if _, ok := baseMap[bv.EdbInfoId]; !ok {
newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
}
baseMap[bv.EdbInfoId] = bv
}
fmt.Println("calculateInfoArr:", len(calculateInfoArr))
//计算指标去重
newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
calculateMap := make(map[int]*data_manage.EdbInfo)
var calculateArr []int
for _, bv := range calculateInfoArr {
if _, ok := calculateMap[bv.EdbInfoId]; !ok {
newCalculateInfoArr = append(newCalculateInfoArr, bv)
calculateArr = append(calculateArr, bv.EdbInfoId)
}
calculateMap[bv.EdbInfoId] = bv
}
sort.Ints(calculateArr)
// 刷新相关基础指标
for _, bv := range newBaseEdbInfoArr {
err, errmsg = refreshBaseEdbInfo(bv)
if err != nil {
return
}
}
// 刷新相关计算指标
for _, v := range calculateArr {
edbInfo := calculateMap[v]
if edbInfo == nil {
return err
}
err, errmsg = refreshCalculateEdbInfo(edbInfo)
if err != nil {
return
}
}
return err
}
// refreshBaseEdbInfo 刷新基础指标
func refreshBaseEdbInfo(bv *data_manage.EdbInfo) (err error, errMsg string) {
source := bv.Source
subSource := bv.SubSource
edbInfoId := bv.EdbInfoId
edbCode := bv.EdbCode
//startDate := bv.StartDate
frequency := bv.Frequency
if bv.StartDate == "0000-00-00" {
return
}
sTime, err := time.Parse(utils.FormatDate, bv.EndDate)
if err != nil {
return
}
var limitDay int
startDate := ""
switch frequency {
case "日度":
limitDay = utils.DATA_START_REFRESH_LIMIT
case "周度":
limitDay = utils.DATA_START_REFRESH_LIMIT * 7
case "月度":
limitDay = utils.DATA_START_REFRESH_LIMIT * 30
case "季度":
limitDay = utils.DATA_START_REFRESH_LIMIT * 90
case "年度":
limitDay = utils.DATA_START_REFRESH_LIMIT * 365
default:
limitDay = utils.DATA_START_REFRESH_LIMIT
}
startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
fmt.Println("source:", source)
respItem, err := RefreshEdbData(edbInfoId, source, subSource, edbCode, startDate)
if err != nil {
errMsg = errors.New("RefreshEdbData Err:" + err.Error()).Error()
return
}
if respItem.Ret != 200 {
errMsg = errors.New(respItem.ErrMsg + ";EdbCode:" + edbCode).Error()
return
}
maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
if err != nil {
return
}
if maxAndMinItem != nil {
err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
if err != nil {
return
}
}
return
}
// refreshCalculateEdbInfo 刷新计算指标
func refreshCalculateEdbInfo(edbInfo *data_manage.EdbInfo) (err error, errMsg string) {
startDate := edbInfo.StartDate
source := edbInfo.Source
if source == utils.DATA_SOURCE_CALCULATE {
startDate = edbInfo.StartDate
sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
if tmpErr != nil {
err = tmpErr
return
}
startDate = sTime.Format(utils.FormatDate)
}
result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
if err != nil {
fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
errMsg = "RefreshEdbCalculateData Err:" + err.Error()
return
}
if result.Ret != 200 {
fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
errMsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
err = errors.New("刷新失败")
return
}
return
}
type ChartInfoReq struct {
ChartInfoId int `description:"图表id,新增时传0"`
}
// DeleteChartInfoDataRedis 清除图表缓存
func DeleteChartInfoDataRedis(bodyByte []byte) (err error) {
var req ChartInfoReq
err = json.Unmarshal(bodyByte, &req)
if err != nil {
return
}
if req.ChartInfoId > 0 {
err = utils.Rc.Delete(GetChartInfoDataKey(req.ChartInfoId))
}
return
}
// DeleteChartClassifyRedis 清除图表分类缓存
func DeleteChartClassifyRedis(bodyByte []byte) (err error) {
err = utils.Rc.Delete(utils.CACHE_CHART_CLASSIFY)
return
}
// GetChartInfoDataKey 获取图表缓存的key
func GetChartInfoDataKey(chartInfoId int) string {
key := fmt.Sprint(utils.CACHE_CHART_INFO_DATA, chartInfoId)
return key
}
// CheckOpChartPermission 判断图表操作权限
func CheckOpChartPermission(sysUser *system.Admin, createUserId int, haveOperaAuth bool) (ok bool) {
// 没有数据权限，那么直接返回
if !haveOperaAuth {
return
}
if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN {
ok = true
}
// 如果图表创建人与当前操作人相同的话，那么就是允许操作
if ok == false && createUserId == sysUser.AdminId {
ok = true
}
// 如果图表权限id 是 1 ，那么允许编辑
if ok == false && sysUser.ChartPermission == 1 {
ok = true
}
return
}
// GetChartEdbData 获取图表的指标数据
func GetChartEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string) (edbList []*data_manage.ChartEdbInfoMapping, xEdbIdValue []int, yDataList []data_manage.YData, dataResp interface{}, err error, errMsg string) {
edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
xEdbIdValue = make([]int, 0)
yDataList = make([]data_manage.YData, 0)
var extraConfig interface{}
switch chartType {
case 7: // 柱形图
var barConfig data_manage.BarChartInfoReq
if extraConfigStr == `` {
errMsg = "柱方图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
if err != nil {
errMsg = "柱方图配置异常"
err = errors.New(errMsg)
return
}
extraConfig = barConfig
case 10: // 截面散点图
var tmpExtraConfig data_manage.SectionScatterReq
if extraConfigStr == `` {
errMsg = "截面散点图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
if err != nil {
errMsg = "截面散点配置异常"
err = errors.New(errMsg)
return
}
extraConfig = tmpExtraConfig
case utils.CHART_TYPE_RADAR:
var barConfig data_manage.RadarChartInfoReq
if extraConfigStr == `` {
errMsg = "雷达图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
if err != nil {
errMsg = "雷达图配置异常"
err = errors.New(errMsg)
return
}
extraConfig = barConfig
default:
xEdbIdValue = make([]int, 0)
yDataList = make([]data_manage.YData, 0)
}
// 指标对应的所有数据
edbDataListMap, edbList, err := getEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig)
if err != nil {
return
}
// 特殊图形数据处理
switch chartType {
case 7: // 柱形图
barChartConf := extraConfig.(data_manage.BarChartInfoReq)
xEdbIdValue, yDataList, err = BarChartData(mappingList, edbDataListMap, barChartConf.DateList, barChartConf.Sort)
for k := range yDataList {
yDataList[k].Unit = barChartConf.Unit
yDataList[k].UnitEn = barChartConf.UnitEn
}
for _, v := range edbList {
// 指标别名
if barChartConf.EdbInfoIdList != nil && len(barChartConf.EdbInfoIdList) > 0 {
for _, reqEdb := range barChartConf.EdbInfoIdList {
if v.EdbInfoId == reqEdb.EdbInfoId {
v.EdbAliasName = reqEdb.Name
}
}
}
}
case 10: // 截面散点图
sectionScatterConf := extraConfig.(data_manage.SectionScatterReq)
xEdbIdValue, dataResp, err = GetSectionScatterChartData(chartInfoId, mappingList, edbDataListMap, sectionScatterConf)
var tmpExtraConfig data_manage.SectionScatterReq
if extraConfigStr == `` {
errMsg = "截面散点图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
if err != nil {
errMsg = "截面散点配置异常"
err = errors.New(errMsg)
return
}
// 这个数据没有必要返回给前端
for _, v := range edbList {
v.DataList = nil
}
case utils.CHART_TYPE_RADAR: //雷达图
radarConf := extraConfig.(data_manage.RadarChartInfoReq)
xEdbIdValue, dataResp, err = RadarChartData(mappingList, edbDataListMap, radarConf)
}
return
}
// GetEdbDataMapList 获取指标最后的基础数据
func GetEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtra string) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
edbDataListMap, edbList, err = getEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtra)
return
}
// getEdbDataMapList 获取指标最后的基础数据
func getEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
// 指标对应的所有数据
edbDataListMap = make(map[int][]*data_manage.EdbDataList)
for _, v := range mappingList {
//fmt.Println("v:", v.EdbInfoId)
item := new(data_manage.ChartEdbInfoMapping)
item.EdbInfoId = v.EdbInfoId
item.SourceName = v.SourceName
item.Source = v.Source
item.EdbCode = v.EdbCode
item.EdbName = v.EdbName
item.EdbNameEn = v.EdbNameEn
item.Frequency = v.Frequency
item.EdbType = v.EdbType
item.FrequencyEn = GetFrequencyEn(v.Frequency)
if v.Unit != `无` {
item.Unit = v.Unit
}
item.UnitEn = v.UnitEn
item.StartDate = v.StartDate
item.EndDate = v.EndDate
item.ModifyTime = v.ModifyTime
item.EdbInfoCategoryType = v.EdbInfoCategoryType
item.PredictChartColor = v.PredictChartColor
item.ClassifyId = v.ClassifyId
if chartInfoId <= 0 {
item.IsAxis = 1
item.LeadValue = 0
item.LeadUnit = ""
item.ChartEdbMappingId = 0
item.ChartInfoId = 0
item.IsOrder = false
item.EdbInfoType = 1
item.ChartStyle = ""
item.ChartColor = ""
item.ChartWidth = 0
item.MaxData = v.MaxValue
item.MinData = v.MinValue
} else {
item.IsAxis = v.IsAxis
item.EdbInfoType = v.EdbInfoType
item.LeadValue = v.LeadValue
item.LeadUnit = v.LeadUnit
item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
item.ChartEdbMappingId = v.ChartEdbMappingId
item.ChartInfoId = v.ChartInfoId
item.ChartStyle = v.ChartStyle
item.ChartColor = v.ChartColor
item.ChartWidth = v.ChartWidth
item.IsOrder = v.IsOrder
item.MaxData = v.MaxData
item.MinData = v.MinData
}
item.LatestValue = v.LatestValue
item.LatestDate = v.LatestDate
item.UniqueCode = v.UniqueCode
item.MoveLatestDate = v.LatestDate
item.EdbAliasName = v.EdbAliasName
item.IsConvert = v.IsConvert
item.ConvertType = v.ConvertType
item.ConvertValue = v.ConvertValue
item.ConvertUnit = v.ConvertUnit
item.ConvertEnUnit = v.ConvertEnUnit
item.IsJoinPermission = v.IsJoinPermission
var startDateReal string
var diffSeconds int64
if chartType == 2 { //季节性图
startDateReal = startDate
} else {
if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
var startTimeRealTemp time.Time
startDateParse, _ := time.Parse(utils.FormatDate, startDate)
switch v.LeadUnit {
case "天":
startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
case "月":
startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
case "季":
startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
case "周":
startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
case "年":
startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
}
if startTimeRealTemp.Before(startDateParse) {
startDateReal = startTimeRealTemp.Format(utils.FormatDate)
diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
} else {
startDateReal = startDate
diffSeconds = 0
}
// 预测指标的开始日期也要偏移
{
day, tmpErr := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
if tmpErr != nil {
err = tmpErr
return
}
moveLatestDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, item.MoveLatestDate, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
item.MoveLatestDate = moveLatestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
}
} else {
startDateReal = startDate
}
}
//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
calendarPreYear := 0
if calendar == "农历" {
newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
if err != nil {
fmt.Println("time.Parse:" + err.Error())
}
calendarPreYear = newStartDateReal.Year() - 1
newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
startDateReal = newStartDateReal.Format(utils.FormatDate)
}
dataList := make([]*data_manage.EdbDataList, 0)
//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
//fmt.Println("calendarPreYear:", calendarPreYear)
//var newEdbInfo *data_manage.EdbInfo
switch v.EdbInfoCategoryType {
case 0:
dataList, err = data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, startDateReal, endDate)
case 1:
_, dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, true)
default:
err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
}
if err != nil {
return
}
if v.IsConvert == 1 {
switch v.ConvertType {
case 1:
for i, data := range dataList {
dataList[i].Value = data.Value * v.ConvertValue
}
//item.MaxData = item.MaxData * v.ConvertValue
//item.MinData = item.MinData * v.ConvertValue
case 2:
for i, data := range dataList {
dataList[i].Value = data.Value / v.ConvertValue
}
//item.MaxData = item.MaxData / v.ConvertValue
//item.MinData = item.MinData / v.ConvertValue
case 3:
for i, data := range dataList {
if data.Value <= 0 {
err = errors.New("数据中含有负数或0，无法对数运算")
return
}
dataList[i].Value = math.Log(data.Value) / math.Log(v.ConvertValue)
}
//item.MaxData = math.Log(item.MaxData) / math.Log(v.ConvertValue)
//item.MinData = math.Log(item.MinData) / math.Log(v.ConvertValue)
}
}
edbDataListMap[v.EdbInfoId] = dataList
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 {
latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
if tmpErr != nil {
//item.DataList = dataList
item.IsNullData = true
edbList = append(edbList, item)
continue
err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
return
}
if calendar == "农历" {
if len(dataList) <= 0 {
result := new(data_manage.EdbDataResult)
item.DataList = result
} else {
result, tmpErr := data_manage.AddCalculateQuarterV6(dataList)
if tmpErr != nil {
err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
return
}
quarterDataList, tErr := GetSeasonEdbInfoDataListByXDateNong(result, latestDate, seasonExtraConfig, calendarPreYear)
if tErr != nil {
err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
return
}
item.DataList = quarterDataList
}
} else {
quarterDataList, tErr := GetSeasonEdbInfoDataListByXDate(dataList, latestDate, seasonExtraConfig)
if tErr != nil {
err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
return
}
item.DataList = quarterDataList
}
} else if chartType == 7 || chartType == utils.CHART_TYPE_RADAR { //柱方图
//item.DataList = dataList
} else {
item.DataList = dataList
}
edbList = append(edbList, item)
}
return
}
// GetSeasonEdbInfoDataListByXDate 季节性图的指标数据根据横轴展示
func GetSeasonEdbInfoDataListByXDate(dataList []*data_manage.EdbDataList, latestDate time.Time, seasonExtraConfig string) (quarterDataListSort data_manage.QuarterDataList, err error) {
xStartDate := "01-01"
xEndDate := "12-31"
jumpYear := 0
legends := make([]data_manage.SeasonChartLegend, 0)
var seasonExtra data_manage.SeasonExtraItem
if seasonExtraConfig != "" {
err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra)
if err != nil {
return
}
}
if seasonExtra.XStartDate != "" {
xStartDate = seasonExtra.XStartDate
xEndDate = seasonExtra.XEndDate
jumpYear = seasonExtra.JumpYear
legends = seasonExtra.ChartLegend
}
length := len(dataList)
if length == 0 {
return
}
legendMap := make(map[string]string, 0)
if len(legends) > 0 {
for _, v := range legends {
legendMap[v.Name] = v.Value
}
}
latestDateStr := latestDate.Format(utils.FormatDate)
//判断横轴的两个时间之间是不是跨年了，如果跨年了，则横轴截止年份比起始年份+1，如果不跨年，截止年份等于起始年份
//根据数据确定最早的年份，和最近年份
//根据横轴的日期，汇总所有的年份
startDate := dataList[0].DataTime
startDateT, tmpErr := time.Parse(utils.FormatDate, startDate)
if tmpErr != nil {
err = tmpErr
return
}
startYear := startDateT.Year()
//获取数据的最新日期
lastDate := dataList[length-1].DataTime
lastDateT, tmpErr := time.Parse(utils.FormatDate, lastDate)
if tmpErr != nil {
err = tmpErr
return
}
endYear := lastDateT.Year()
nowYear := time.Now().Year()
dataMap := make(map[string]data_manage.QuarterXDateItem, 0)
quarterDataList := make([]*data_manage.QuarterData, 0)
quarterMap := make(map[string][]*data_manage.EdbDataList, 0)
//整理出日期
idx := 1
chartLegendMap := make(map[string]int, 0)
for currentStartYear := startYear; currentStartYear <= endYear; currentStartYear++ {
startStr := fmt.Sprintf("%d-%s", currentStartYear, xStartDate)
currentEndYear := currentStartYear
if jumpYear == 1 {
currentEndYear = currentStartYear + 1
}
endStr := fmt.Sprintf("%d-%s", currentEndYear, xEndDate)
name := fmt.Sprintf("%s_%s", startStr, endStr)
showName := fmt.Sprintf("%d_%d", currentStartYear, currentEndYear)
startT, tEr := time.Parse(utils.FormatDate, startStr)
if tEr != nil {
err = tEr
return
}
endT, tEr := time.Parse(utils.FormatDate, endStr)
if tEr != nil {
err = tEr
return
}
if lastDateT.Before(startT) {
//如果最新的日期在起始日之前，则跳出循环
break
}
if endT.Year() > nowYear {
//如果最新的日期比真实年份要大，则数据全部按照最大的年份补齐
nowYear = endT.Year()
}
item := data_manage.QuarterXDateItem{
StartDate: startT,
EndDate: endT,
ShowName: showName,
}
dataMap[name] = item
chartLegendMap[name] = idx
idx++
fmt.Println("年份" + showName + "日期" + startStr + " " + endStr)
if lastDateT.Before(endT) {
//如果最新的日期在起始日之前，则跳出循环
break
}
}
lenYear := len(dataMap)
for k, v := range dataMap {
if i, ok := chartLegendMap[k]; ok {
v.ChartLegend = strconv.Itoa(endYear - lenYear + i)
}
dataMap[k] = v
}
for _, v := range dataList {
dataTimeT, _ := time.Parse(utils.FormatDate, v.DataTime)
year := dataTimeT.Year()
newItemDate := dataTimeT.AddDate(nowYear-year, 0, 0)
for k, dateItem := range dataMap {
tmpVal := data_manage.EdbDataList{
EdbDataId: v.EdbDataId,
EdbInfoId: v.EdbInfoId,
DataTime: v.DataTime,
DataTimestamp: v.DataTimestamp,
Value: v.Value,
}
if (dateItem.StartDate.Before(dataTimeT) && dateItem.EndDate.After(dataTimeT)) || dateItem.StartDate == dataTimeT || dateItem.EndDate == dataTimeT {
if jumpYear == 1 {
//计算前一年最大的日期, 只补齐数据到去年
beforeYearMaxDate := fmt.Sprintf("%d-12-31", dateItem.StartDate.Year())
beforeYearMaxDateT, _ := time.Parse(utils.FormatDate, beforeYearMaxDate)
if dataTimeT.Before(beforeYearMaxDateT) || dataTimeT == beforeYearMaxDateT {
newItemDate = dataTimeT.AddDate(nowYear-year-1, 0, 0)
} else {
newItemDate = dataTimeT.AddDate(nowYear-year, 0, 0)
}
} else {
newItemDate = dataTimeT.AddDate(nowYear-year, 0, 0)
}
timestamp := newItemDate.UnixNano() / 1e6
tmpVal.DataTimestamp = timestamp
tmpV := &tmpVal
if findVal, ok := quarterMap[k]; !ok {
findVal = append(findVal, tmpV)
quarterMap[k] = findVal
} else {
findVal = append(findVal, tmpV)
quarterMap[k] = findVal
}
if v.DataTime == latestDateStr {
dateItem.CuttingDataTimestamp = timestamp
dataMap[k] = dateItem
}
//break
}
}
}
for k, v := range dataMap {
itemList := quarterMap[k]
quarterItem := new(data_manage.QuarterData)
quarterItem.Years = v.ShowName
quarterItem.ChartLegend = v.ChartLegend
if le, ok := legendMap[v.ShowName]; ok {
if le != strconv.Itoa(v.StartDate.Year()) && le != strconv.Itoa(v.EndDate.Year()) {
quarterItem.ChartLegend = le
}
}
quarterItem.DataList = itemList
quarterItem.CuttingDataTimestamp = v.CuttingDataTimestamp
//如果等于最后的实际日期，那么将切割时间戳记录
if quarterItem.CuttingDataTimestamp == 0 {
//如果大于最后的实际日期，那么第一个点就是切割的时间戳
if latestDate.Before(v.StartDate) && len(itemList) > 0 {
quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
}
}
quarterDataList = append(quarterDataList, quarterItem)
}
if len(quarterDataList) > 0 {
quarterDataListSort = quarterDataList
sort.Sort(quarterDataListSort)
}
return
}
// GetSeasonEdbInfoDataListByXDateNong 季节性图的指标数据根据横轴选择农历时展示
func GetSeasonEdbInfoDataListByXDateNong(result *data_manage.EdbDataResult, latestDate time.Time, seasonExtraConfig string, calendarPreYear int) (quarterDataListSort data_manage.QuarterDataList, err error) {
xStartDate := "01-01"
xEndDate := "12-31"
jumpYear := 0
legends := make([]data_manage.SeasonChartLegend, 0)
var seasonExtra data_manage.SeasonExtraItem
if seasonExtraConfig != "" {
err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra)
if err != nil {
return
}
}
if seasonExtra.XStartDate != "" {
xStartDate = seasonExtra.XStartDate
xEndDate = seasonExtra.XEndDate
jumpYear = seasonExtra.JumpYear
legends = seasonExtra.ChartLegend
}
length := len(result.List)
if length == 0 {
return
}
legendMap := make(map[string]string, 0)
if len(legends) > 0 {
for _, v := range legends {
legendMap[v.Name] = v.Value
}
}
latestDateYear := latestDate.Year()
//判断横轴的两个时间之间是不是跨年了，如果跨年了，则横轴截止年份比起始年份+1，如果不跨年，截止年份等于起始年份
//根据数据确定最早的年份，和最近年份
//根据横轴的日期，汇总所有的年份
startYear := result.List[0].Year
/*if jumpYear == 1 {
if startYear != calendarPreYear {
startYear = startYear - 1
}
}*/
itemLength := len(result.List[length-1].Items)
//获取数据的最新日期
lastDate := result.List[length-1].Items[itemLength-1].DataTime
maxY := result.List[length-1].Year
lastDateT, tmpErr := time.Parse(utils.FormatDate, lastDate)
if tmpErr != nil {
err = tmpErr
return
}
endYear := lastDateT.Year()
nowYear := time.Now().Year()
dataMap := make(map[string]data_manage.QuarterXDateItem, 0)
quarterDataList := make([]*data_manage.QuarterData, 0)
resultData := make([]*data_manage.QuarterData, 0)
quarterMap := make(map[string][]*data_manage.EdbDataList, 0)
//整理出日期
var startTmpT, endTmpT time.Time
idx := 1
chartLegendMap := make(map[string]int, 0)
for currentStartYear := startYear; currentStartYear <= endYear; currentStartYear++ {
startStr := fmt.Sprintf("%d-%s", currentStartYear, xStartDate)
currentEndYear := currentStartYear
if jumpYear == 1 {
currentEndYear = currentStartYear + 1
}
endStr := fmt.Sprintf("%d-%s", currentEndYear, xEndDate)
showName := fmt.Sprintf("%d_%d", currentStartYear, currentEndYear)
startT, tEr := time.Parse(utils.FormatDate, startStr)
if tEr != nil {
err = tEr
return
}
endT, tEr := time.Parse(utils.FormatDate, endStr)
if tEr != nil {
err = tEr
return
}
if lastDateT.Before(startT) {
//如果最新的日期在起始日之前，则跳出循环
break
}
if endT.Year() > nowYear {
//如果最新的日期比真实年份要大，则数据全部按照最大的年份补齐
nowYear = endT.Year()
}
item := data_manage.QuarterXDateItem{
StartDate: startT,
EndDate: endT,
ShowName: showName,
}
dataMap[showName] = item
fmt.Println("年份" + showName + "日期" + startStr + " " + endStr)
startTmpT = startT
endTmpT = endT
chartLegendMap[showName] = idx
idx++
if lastDateT.Before(endT) {
//如果最新的日期在起始日之前，则跳出循环
break
}
}
lenYear := len(dataMap)
for k, v := range dataMap {
if i, ok := chartLegendMap[k]; ok {
v.ChartLegend = strconv.Itoa(endYear - lenYear + i)
}
dataMap[k] = v
}
yearDataListMap := make(map[int]*data_manage.EdbDataItems, 0)
for _, lv := range result.List {
yearDataListMap[lv.Year] = lv
}
//判断哪些点应该落在同一条时间线上
/*maxY := lastDateT.Year()
changeFlag := false
if lastDateT.Month() >= 11 {
maxY = maxY + 1
}
if maxY < nowYear {
changeFlag = true
maxY = nowYear
}*/
/*endTmp := fmt.Sprintf("%d-%s", maxY, xEndDate)
endTmpT, _ := time.Parse(utils.FormatDate, endTmp)
minY := maxY
if jumpYear == 1 {
minY = maxY - 1
}
startTmp := fmt.Sprintf("%d-%s", minY, xStartDate)
startTmpT, _ := time.Parse(utils.FormatDate, startTmp)*/
fmt.Println("横轴截取日" + startTmpT.Format(utils.FormatDate) + " " + endTmpT.Format(utils.FormatDate))
fmt.Printf("lastDateT.Year() 为%d \n", lastDateT.Year())
fmt.Printf("maxY 为%d \n", maxY)
for name, dateItem := range dataMap {
tY := dateItem.EndDate.Year()
if lastDateT.Month() >= 11 {
if maxY > endTmpT.Year() {
tY = tY + 1
}
}
lv, ok1 := yearDataListMap[tY]
fmt.Printf("name %s yearDataListMap[%d]\n", name, tY)
if !ok1 {
continue
}
for _, item := range lv.Items {
tmpVal := data_manage.EdbDataList{
EdbDataId: item.EdbDataId,
EdbInfoId: item.EdbInfoId,
DataTime: item.DataTime,
DataTimestamp: item.DataTimestamp,
Value: item.Value,
}
dataTimeT, _ := time.Parse(utils.FormatDate, item.DataTime)
if (startTmpT.Before(dataTimeT) && endTmpT.After(dataTimeT)) || startTmpT == dataTimeT || endTmpT == dataTimeT {
tmpV := &tmpVal
if findVal, ok := quarterMap[name]; !ok {
findVal = append(findVal, tmpV)
quarterMap[name] = findVal
} else {
findVal = append(findVal, tmpV)
quarterMap[name] = findVal
}
if lv.Year >= latestDateYear {
// 切割的日期时间字符串
cuttingDataTimeStr := latestDate.AddDate(0, 0, lv.BetweenDay).Format(utils.FormatDate)
if item.DataTime == cuttingDataTimeStr {
dateItem.CuttingDataTimestamp = tmpVal.DataTimestamp
dataMap[name] = dateItem
}
}
}
}
}
for k, v := range dataMap {
itemList := quarterMap[k]
quarterItem := new(data_manage.QuarterData)
quarterItem.Years = v.ShowName
quarterItem.ChartLegend = v.ChartLegend
if le, ok := legendMap[v.ShowName]; ok {
if le != strconv.Itoa(v.StartDate.Year()) && le != strconv.Itoa(v.EndDate.Year()) {
quarterItem.ChartLegend = le
}
}
quarterItem.DataList = itemList
quarterItem.CuttingDataTimestamp = v.CuttingDataTimestamp
//如果等于最后的实际日期，那么将切割时间戳记录
if quarterItem.CuttingDataTimestamp == 0 {
//如果大于最后的实际日期，那么第一个点就是切割的时间戳
if latestDate.Before(v.StartDate) && len(itemList) > 0 {
quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
}
}
quarterDataList = append(quarterDataList, quarterItem)
}
if result.List[0].Year != calendarPreYear {
itemList := make([]*data_manage.EdbDataList, 0)
items := new(data_manage.QuarterData)
//items.Year = calendarPreYear
items.DataList = itemList
newResult := make([]*data_manage.QuarterData, 0)
newResult = append(newResult, items)
newResult = append(newResult, quarterDataList...)
resultData = newResult
} else {
resultData = quarterDataList
}
if len(quarterDataList) > 0 {
quarterDataListSort = resultData
sort.Sort(quarterDataListSort)
}
return
}
// BarChartData 柱方图的数据处理
func BarChartData(mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, barChartInfoDateList []data_manage.BarChartInfoDateReq, barChartInfoSort data_manage.BarChartInfoSortReq) (edbIdList []int, yDataList []data_manage.YData, err error) {
// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
edbDataMap := make(map[int]map[string]float64)
for edbInfoId, edbDataList := range edbDataListMap {
edbDateData := make(map[string]float64)
for _, edbData := range edbDataList {
edbDateData[edbData.DataTime] = edbData.Value
}
edbDataMap[edbInfoId] = edbDateData
}
// edbIdList 指标展示顺序；x轴的指标顺序
edbIdList = make([]int, 0)
//Sort int `description:"排序类型，0：默认，1：升序，2：降序"`
dateData := make(map[int]float64)
if barChartInfoSort.Sort == 0 {
for _, v := range mappingList {
edbIdList = append(edbIdList, v.EdbInfoId)
}
} else {
lenBarChartInfoDateList := len(barChartInfoDateList)
if barChartInfoSort.DateIndex >= lenBarChartInfoDateList {
err = errors.New("排序日期异常")
return
}
notDataEdbIdList := make([]int, 0) //没有数据的指标id
// 日期配置
barChartInfoDate := barChartInfoDateList[barChartInfoSort.DateIndex]
for edbInfoId, dataList := range edbDataListMap {
if len(dataList) <= 0 {
// 没有数据的指标id
notDataEdbIdList = append(notDataEdbIdList, edbInfoId)
continue
}
findDate := barChartInfoDate.Date
switch barChartInfoDate.Type {
case 1: //最新值
findDate = dataList[len(dataList)-1].DataTime
case 2: //近期几天
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
findDateTime = findDateTime.AddDate(0, 0, -barChartInfoDate.Value)
lenData := len(dataList) - 1
for i := lenData; i >= 0; i-- {
currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
findDate = dataList[i].DataTime
break
}
}
case 3: // 固定日期
//最早的日期
minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
//寻找固定日期的数据
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, barChartInfoDate.Date, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
tmpDate := tmpDateTime.Format(utils.FormatDate)
if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
findDate = tmpDate
break
}
}
default:
err = errors.New(fmt.Sprint("日期类型异常,Type:", barChartInfoDate.Type))
return
}
if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
dateData[edbInfoId] = tmpValue
} else {
// 没有数据的指标id
notDataEdbIdList = append(notDataEdbIdList, edbInfoId)
}
}
//Sort int `description:"排序类型，0：默认，1：升序，2：降序"`
// 排序
dateDataSort := utils.NewMapSorter(dateData)
sort.Sort(dateDataSort)
if barChartInfoSort.Sort == 1 {
// 先将没有数据的指标id放在最前面
if len(notDataEdbIdList) > 0 {
edbIdList = append(edbIdList, notDataEdbIdList...)
}
for _, v := range dateDataSort {
edbIdList = append(edbIdList, v.Key)
}
} else {
for i := len(dateDataSort) - 1; i >= 0; i-- {
edbIdList = append(edbIdList, dateDataSort[i].Key)
}
// 再将没有数据的指标id放在最后面
if len(notDataEdbIdList) > 0 {
edbIdList = append(edbIdList, notDataEdbIdList...)
}
}
}
yDataList = make([]data_manage.YData, 0) //y轴的数据列表
for _, barChartInfoDate := range barChartInfoDateList {
var maxDate time.Time
findDataList := make([]float64, 0) // 当前日期的数据值
for _, edbInfoId := range edbIdList {
findDate := barChartInfoDate.Date //需要的日期值
dataList := edbDataListMap[edbInfoId] //指标的所有数据值
if len(dataList) <= 0 {
// 没有数据的指标id
findDataList = append(findDataList, 0)
continue
}
switch barChartInfoDate.Type {
case 1: //最新值
dataList := edbDataListMap[edbInfoId]
findDate = dataList[len(dataList)-1].DataTime
case 2: //近期几天
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
findDateTime = findDateTime.AddDate(0, 0, -barChartInfoDate.Value)
lenData := len(dataList) - 1
for i := lenData; i >= 0; i-- {
currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
findDate = dataList[i].DataTime
break
}
}
case 3: // 固定日期
//最早的日期
minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
//寻找固定日期的数据
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, barChartInfoDate.Date, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
tmpDate := tmpDateTime.Format(utils.FormatDate)
if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
findDate = tmpDate
break
}
}
default:
err = errors.New(fmt.Sprint("日期类型异常,Type:", barChartInfoDate.Type))
return
}
findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
if maxDate.IsZero() {
maxDate = findDateTime
} else {
if findDateTime.After(maxDate) {
maxDate = findDateTime
}
}
if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
tmpValue, _ = decimal.NewFromFloat(tmpValue).Round(4).Float64()
findDataList = append(findDataList, tmpValue)
} else {
findDataList = append(findDataList, 0)
}
}
yDate := "0000-00-00"
if !maxDate.IsZero() {
yDate = maxDate.Format(utils.FormatDate)
}
yDataList = append(yDataList, data_manage.YData{
Date: yDate,
Value: findDataList,
Color: barChartInfoDate.Color,
Name: barChartInfoDate.Name,
})
}
return
}
// ChartInfoRefreshV2 图表刷新
// @author Roc
// @datetime 2022-09-16 10:15:38
// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成 只获取使用的指标id，然后遍历去调用“指标刷新服务”
func ChartInfoRefreshV2(chartInfoId int) (err error, isAsync bool) {
var errmsg string
defer func() {
if err != nil {
go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
fmt.Println("ChartInfoRefresh Err:" + errmsg)
}
}()
edbMappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
if err != nil {
errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
return
}
edbIdList := make([]int, 0)
for _, v := range edbMappingList {
edbIdList = append(edbIdList, v.EdbInfoId)
}
// 批量刷新
err, isAsync = EdbInfoRefreshAllFromBaseV3(edbIdList, false, false, false)
if err != nil {
return
}
return
}
// BatchChartInfoRefreshV2 图表批量刷新
// @author Roc
// @datetime 2022-09-16 10:15:38
// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成 只获取使用的指标id，然后遍历去调用“指标刷新服务”
func BatchChartInfoRefreshV2(chartInfoList []*data_manage.ChartInfo, redisKey string) (err error, isAsync bool) {
if len(chartInfoList) <= 0 {
return
}
chartInfoIdSlice := make([]int, 0)
for _, chartInfo := range chartInfoList {
chartInfoIdSlice = append(chartInfoIdSlice, chartInfo.ChartInfoId)
}
var errMsg string
defer func() {
if err != nil {
go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errMsg, 3)
//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
fmt.Println("ChartInfoRefresh Err:" + errMsg)
}
}()
// 是否删除缓存
isDeleteCache := true
if redisKey != `` {
//设置最多10分钟缓存
utils.Rc.SetNX(redisKey, 1, time.Minute*10)
defer func() {
if isDeleteCache {
utils.Rc.Delete(redisKey)
}
}()
}
// 获取需要刷新的指标信息
edbIdList := make([]int, 0)
edbInfoIdMap := make(map[int]int)
edbMappingList, err := data_manage.GetChartEdbMappingListByIdList(chartInfoIdSlice)
for _, v := range edbMappingList {
if _, ok := edbInfoIdMap[v.EdbInfoId]; !ok {
edbIdList = append(edbIdList, v.EdbInfoId)
edbInfoIdMap[v.EdbInfoId] = v.EdbInfoId
}
}
// 获取需要刷新的指标列表
newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr := getEdbInfoIdList(edbIdList)
// 需要刷新的指标数量
totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)
if totalEdbInfo > 20 { // 关联指标过多的时候，异步刷新
isAsync = true
isDeleteCache = false // 不删除缓存
go refreshChartEdbInfo(chartInfoList, redisKey, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
} else {
err = edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
//清除图表缓存
for _, v := range chartInfoList {
key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
_ = utils.Rc.Delete(key)
}
}
return
}
// refreshChartEdbInfo
// @Description: 刷新图表中的质保列表
// @author: Roc
// @datetime 2023-12-01 16:05:39
// @param chartInfoList []*data_manage.ChartInfo
// @param redisKey string
// @param newBaseEdbInfoArr []*data_manage.EdbInfo
// @param newBasePredictEdbInfoArr []*data_manage.EdbInfo
// @param newCalculateMap map[int]*data_manage.EdbInfo
// @param newPredictCalculateMap map[int]*data_manage.EdbInfo
// @param calculateArr []int
// @param predictCalculateArr []int
func refreshChartEdbInfo(chartInfoList []*data_manage.ChartInfo, redisKey string, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
//清除图表缓存
for _, v := range chartInfoList {
key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
_ = utils.Rc.Delete(key)
}
// 如果是有插入redisKey，那么刷新结束后就清除缓存
if redisKey != `` {
utils.Rc.Delete(redisKey)
}
}
// GetBatchChartRefreshKey
// @Description: 获取批量刷新key
// @author: Roc
// @datetime 2023-11-30 13:30:26
// @param source string
// @param reportId int
// @param reportChapterId int
// @return string
func GetBatchChartRefreshKey(source string, reportId, reportChapterId int) string {
if source == `` {
return ``
}
return fmt.Sprint("batch_chart_refresh:", source, ":", reportId, ":", reportChapterId)
}
// CheckBatchChartRefreshResult
// @Description: 判断报告中的图表是否刷新完成
// @author: Roc
// @datetime 2023-11-30 13:30:26
// @param source string
// @param reportId int
// @param reportChapterId int
// @return string
func CheckBatchChartRefreshResult(source string, reportId, reportChapterId int) (refreshResult bool) {
refreshResult = true
redisKey := GetBatchChartRefreshKey(source, reportId, reportChapterId)
if redisKey != `` {
// 如果找到了key，那么就是还在更新中
isOk := utils.Rc.IsExist(redisKey)
if isOk {
refreshResult = false
}
}
return
}
func CheckIsEnChart(chartNameEn string, edbList []*data_manage.ChartEdbInfoMapping, source, chartType int) bool {
// 相关性图表不判断指标
if utils.InArrayByInt([]int{utils.CHART_SOURCE_CORRELATION, utils.CHART_SOURCE_ROLLING_CORRELATION, utils.CHART_SOURCE_LINE_EQUATION}, source) && chartNameEn != "" {
return true
}
if chartNameEn != "" && len(edbList) <= 0 {
return true
}
if chartNameEn == "" {
return false
}
// 截面散点图的话，肯定是有英文配置的
if chartType == utils.CHART_TYPE_SECTION_SCATTER {
return true
}
for _, v := range edbList {
if v.EdbNameEn == "" {
return false
}
if v.Unit != "无" && v.Unit != "" && v.UnitEn == "" {
return false
}
}
return true
}
func CheckIsEnEdb(edbNameEn, unit, unitEn string) bool {
if edbNameEn == "" {
return false
}
if unit != "无" && unit != "" && unitEn == "" {
return false
}
return true
}
// CheckIsDisableChart 根据指标Id判断是否是禁用图表
// return int 0:启用，1：禁用
func CheckIsDisableChart(edbInfoIdArr []int) (isDisable int) {
crmConfig, err := company.GetConfigDetailByCode("chart_disabled_edb")
if err != nil {
return
}
//没有配置，立马返回
if crmConfig.ConfigValue == `` {
return
}
confEdbInfoIdList := strings.Split(crmConfig.ConfigValue, ",")
for _, edbInfoId := range edbInfoIdArr {
for _, confEdbInfoId := range confEdbInfoIdList {
if strconv.Itoa(edbInfoId) == confEdbInfoId {
isDisable = 1
return
}
}
}
return
}
// CheckChartExtraConfig 校验图表额外配置的信息,并且获取相关联的指标id
func CheckChartExtraConfig(chartType int, extraConfigStr string) (edbIdList []int, err error, errMsg string) {
switch chartType {
case 10: //截面散点
var extraConfig data_manage.SectionScatterReq
err = json.Unmarshal([]byte(extraConfigStr), &extraConfig)
if err != nil {
return
}
// 判断是否有配置日期序列
if len(extraConfig.SeriesList) <= 0 {
errMsg = `请配置序列`
err = errors.New(errMsg)
return
}
// 判断是否有填写指标
if len(extraConfig.SeriesList[0].EdbInfoList) <= 0 {
errMsg = `请选择指标`
err = errors.New(errMsg)
return
}
// 遍历指标列表获取指标id
edbIdMap := make(map[int]int)
for _, v := range extraConfig.SeriesList[0].EdbInfoList {
// X 轴的指标id
if _, ok := edbIdMap[v.XEdbInfoId]; !ok {
edbIdMap[v.XEdbInfoId] = v.XEdbInfoId
edbIdList = append(edbIdList, v.XEdbInfoId)
}
// Y 轴的指标id
if _, ok := edbIdMap[v.YEdbInfoId]; !ok {
edbIdMap[v.YEdbInfoId] = v.YEdbInfoId
edbIdList = append(edbIdList, v.YEdbInfoId)
}
}
case utils.CHART_TYPE_RADAR:
var extraConfig data_manage.RadarChartInfoReq
if extraConfigStr == `` {
errMsg = "雷达图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &extraConfig)
if err != nil {
errMsg = "雷达图配置异常"
err = errors.New(errMsg)
return
}
}
return
}
// GetSectionScatterChartData 截面散点图的数据处理
func GetSectionScatterChartData(chartInfoId int, mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, extraConfig data_manage.SectionScatterReq) (edbIdList []int, chartDataResp data_manage.SectionScatterInfoResp, err error) {
// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
edbDataMap := make(map[int]map[string]float64)
for edbInfoId, edbDataList := range edbDataListMap {
edbDateData := make(map[string]float64)
for _, edbData := range edbDataList {
edbDateData[edbData.DataTime] = edbData.Value
}
edbDataMap[edbInfoId] = edbDateData
}
// edbIdList 指标展示顺序；x轴的指标顺序
edbIdList = make([]int, 0)
edbMappingMap := make(map[int]*data_manage.ChartEdbInfoMapping)
for _, v := range mappingList {
edbIdList = append(edbIdList, v.EdbInfoId)
edbMappingMap[v.EdbInfoId] = v
}
//SectionScatterSeriesInfoResp
dataListResp := make([]data_manage.SectionScatterSeriesItemResp, 0) //y轴的数据列表
for _, seriesItem := range extraConfig.SeriesList {
var maxDate time.Time
// 系列中的指标数据
tmpSeriesEdbInfoList := make([]data_manage.SectionScatterEdbItemResp, 0)
var minXVal, maxXVal, minYVal, maxYVal float64
for _, edbConf := range seriesItem.EdbInfoList {
tmpItem := data_manage.SectionScatterEdbItemResp{
IsShow: edbConf.IsShow,
Name: edbConf.Name,
NameEn: edbConf.NameEn,
} //单个坐标点的数据
//X轴的数据
{
edbInfoId := edbConf.XEdbInfoId //X轴的指标
edbMappingInfo, ok := edbMappingMap[edbInfoId]
if !ok {
continue
}
findDate := edbConf.XDate //需要的日期值
dataList := edbDataListMap[edbInfoId] //指标的所有数据值
if len(dataList) <= 0 {
// 没有数据的指标id
//findDataList = append(findDataList, 0)
continue
}
tmpItem.XEdbInfoId = edbInfoId
tmpItem.XName = edbMappingInfo.EdbName
tmpItem.XNameEn = edbMappingInfo.EdbNameEn
switch edbConf.XDateType {
case 1: //最新值
findDate = dataList[len(dataList)-1].DataTime
case 2: //近期几天
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
findDateTime = findDateTime.AddDate(0, 0, -edbConf.XDateValue)
lenData := len(dataList) - 1
for i := lenData; i >= 0; i-- {
currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
findDate = dataList[i].DataTime
break
}
}
case 3: // 固定日期
//最早的日期
minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
//寻找固定日期的数据
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, edbConf.XDate, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
tmpDate := tmpDateTime.Format(utils.FormatDate)
if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
findDate = tmpDate
break
}
}
default:
err = errors.New(fmt.Sprint("日期类型异常,Type:", edbConf.XDate))
return
}
findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
if maxDate.IsZero() {
maxDate = findDateTime
} else {
if findDateTime.After(maxDate) {
maxDate = findDateTime
}
}
if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
tmpItem.XDate = findDate
tmpItem.XValue = tmpValue
} else {
continue
}
}
//Y轴的数据
{
edbInfoId := edbConf.YEdbInfoId //Y轴的指标
edbMappingInfo, ok := edbMappingMap[edbInfoId]
if !ok {
continue
}
findDate := edbConf.YDate //需要的日期值
dataList := edbDataListMap[edbInfoId] //指标的所有数据值
if len(dataList) <= 0 {
// 没有数据的指标id
//findDataList = append(findDataList, 0)
continue
}
tmpItem.YEdbInfoId = edbInfoId
tmpItem.YName = edbMappingInfo.EdbName
tmpItem.YNameEn = edbMappingInfo.EdbNameEn
switch edbConf.YDateType {
case 1: //最新值
findDate = dataList[len(dataList)-1].DataTime
case 2: //近期几天
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
findDateTime = findDateTime.AddDate(0, 0, -edbConf.YDateValue)
lenData := len(dataList) - 1
for i := lenData; i >= 0; i-- {
currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
findDate = dataList[i].DataTime
break
}
}
case 3: // 固定日期
//最早的日期
minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
//寻找固定日期的数据
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, edbConf.YDate, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
tmpDate := tmpDateTime.Format(utils.FormatDate)
if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
findDate = tmpDate
break
}
}
default:
err = errors.New(fmt.Sprint("日期类型异常,Type:", edbConf.YDate))
return
}
findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
if maxDate.IsZero() {
maxDate = findDateTime
} else {
if findDateTime.After(maxDate) {
maxDate = findDateTime
}
}
if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
tmpItem.YDate = findDate
tmpItem.YValue = tmpValue
} else {
continue
}
}
// 获取当前系列的X轴的最大最小值
{
if tmpItem.XValue < minXVal {
minXVal = tmpItem.XValue
}
if tmpItem.XValue > maxXVal {
maxXVal = tmpItem.XValue
}
if tmpItem.YValue < minYVal {
minYVal = tmpItem.YValue
}
if tmpItem.YValue > maxYVal {
maxYVal = tmpItem.YValue
}
}
tmpSeriesEdbInfoList = append(tmpSeriesEdbInfoList, tmpItem)
}
trendLimitData := make([]data_manage.CoordinatePoint, 0) //趋势线的前后坐标点
var trendLine, rSquare string
// 生成线性方程式
var a, b float64
{
coordinateData := make([]utils.Coordinate, 0)
for _, tmpSeriesEdbInfo := range tmpSeriesEdbInfoList {
tmpCoordinate1 := utils.Coordinate{
X: tmpSeriesEdbInfo.XValue,
Y: tmpSeriesEdbInfo.YValue,
}
coordinateData = append(coordinateData, tmpCoordinate1)
}
// 只有存在两个坐标点的时候,才能去计算线性方程和R平方
if len(coordinateData) >= 2 {
a, b = utils.GetLinearResult(coordinateData)
if !math.IsNaN(a) && !math.IsNaN(b) {
if b > 0 {
trendLine = fmt.Sprintf("y=%sx+%s", utils.SubFloatToString(a, 4), utils.SubFloatToString(b, 4))
} else {
trendLine = fmt.Sprintf("y=%sx%s", utils.SubFloatToString(a, 4), utils.SubFloatToString(b, 4))
}
minYVal, _ = decimal.NewFromFloat(a).Mul(decimal.NewFromFloat(minXVal)).Add(decimal.NewFromFloat(b)).Round(4).Float64()
maxYVal, _ = decimal.NewFromFloat(a).Mul(decimal.NewFromFloat(maxXVal)).Add(decimal.NewFromFloat(b)).Round(4).Float64()
}
// 计算R平方
rSquare = fmt.Sprint(utils.CalculationDecisive(coordinateData))
}
trendLimitData = append(trendLimitData, data_manage.CoordinatePoint{
X: minXVal,
Y: minYVal,
}, data_manage.CoordinatePoint{
X: maxXVal,
Y: maxYVal,
})
}
dataListResp = append(dataListResp, data_manage.SectionScatterSeriesItemResp{
Name: seriesItem.Name,
NameEn: seriesItem.NameEn,
IsNameDefault: seriesItem.IsNameDefault,
Color: seriesItem.Color,
EdbInfoList: tmpSeriesEdbInfoList,
ShowTrendLine: seriesItem.ShowTrendLine,
ShowFitEquation: seriesItem.ShowFitEquation,
ShowRSquare: seriesItem.ShowRSquare,
TrendLine: trendLine,
RSquare: rSquare,
TrendLimitData: trendLimitData,
})
}
// 截面散点图点击详情时自动更新系列名
if len(extraConfig.SeriesList) > 0 {
// 默认名字的时候才自动更新
if extraConfig.SeriesList[0].IsNameDefault {
firstXEdbInfoId := extraConfig.SeriesList[0].EdbInfoList[0].XEdbInfoId
needUpdate := false
if v, ok := edbMappingMap[firstXEdbInfoId]; ok {
extraConfig.SeriesList[0].Name = v.LatestDate
extraConfig.SeriesList[0].NameEn = v.LatestDate
dataListResp[0].Name = v.LatestDate
dataListResp[0].NameEn = v.LatestDate
needUpdate = true
}
extraConfigByte, e := json.Marshal(extraConfig)
if e != nil {
errMsg := "截面散点系列更新异常"
err = errors.New(errMsg)
return
}
extraConfigStr := string(extraConfigByte)
if needUpdate {
err = data_manage.EditChartInfoExtraConfig(chartInfoId, extraConfigStr)
if err != nil {
errMsg := "截面散点系列更新异常"
err = errors.New(errMsg)
return
}
}
}
}
chartDataResp = data_manage.SectionScatterInfoResp{
XName: extraConfig.XName,
XNameEn: extraConfig.XNameEn,
XUnitName: extraConfig.XUnitName,
XUnitNameEn: extraConfig.XUnitNameEn,
YName: extraConfig.YName,
YNameEn: extraConfig.YNameEn,
YUnitName: extraConfig.YUnitName,
YUnitNameEn: extraConfig.YUnitNameEn,
XMinValue: extraConfig.XMinValue,
XMaxValue: extraConfig.XMaxValue,
YMinValue: extraConfig.YMinValue,
YMaxValue: extraConfig.YMaxValue,
DataList: dataListResp,
}
return
}
// AddChartInfo 添加图表
func AddChartInfo(req data_manage.AddChartInfoReq, sysUserId int, sysUserRealName, lang string) (chartInfo *data_manage.ChartInfo, err error, errMsg string, isSendEmail bool) {
isSendEmail = true // 默认错误的时候要发送邮件
req.ChartName = strings.Trim(req.ChartName, " ")
if req.ChartName == "" {
errMsg = "请填写图表名称！"
err = errors.New(errMsg)
isSendEmail = false
return
}
if req.ChartClassifyId <= 0 {
errMsg = "分类参数错误！"
err = errors.New(errMsg)
isSendEmail = false
return
}
//if req.ChartThemeId <= 0 {
// errMsg = "请选择主题"
// err = errors.New(errMsg)
// isSendEmail = false
// return
//}
//
//// 判断主题是否存在
//_, err = chart_theme.GetChartThemeId(req.ChartThemeId)
//if err != nil {
// if err.Error() == utils.ErrNoRow() {
// errMsg = "主题不存在"
// err = errors.New(errMsg)
// return
// }
// errMsg = "获取主题信息失败"
// return
//}
chartClassify, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
if err != nil {
if err.Error() == utils.ErrNoRow() {
errMsg = "分类不存在"
err = errors.New(errMsg)
return
}
errMsg = "获取分类信息失败"
return
}
if chartClassify == nil {
errMsg = "分类不存在"
err = errors.New(errMsg)
return
}
chartType := req.ChartType
extraConfig := req.ExtraConfig
var extraConfigEdbInfoIdArr []int
extraConfigEdbInfoIdArr, err, errMsg = CheckChartExtraConfig(chartType, extraConfig)
if err != nil {
err = errors.New("添加失败:" + err.Error())
return
}
// 季节性图表额外配置信息
var seasonExtraConfig string
// 关联指标
var edbInfoIdArr []int
chartEdbInfoList := req.ChartEdbInfoList
if len(chartEdbInfoList) > 0 {
for _, v := range chartEdbInfoList {
edbInfoId := v.EdbInfoId
edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
if tmpErr != nil {
if tmpErr.Error() == utils.ErrNoRow() {
errMsg = "指标不存在！"
err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
return
} else {
errMsg = "获取指标信息失败！"
err = errors.New("获取图表的指标信息失败，Err:" + tmpErr.Error())
return
}
}
if edbInfo == nil {
errMsg = "指标已被删除，请重新选择！"
err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
return
} else {
if edbInfo.EdbInfoId <= 0 {
errMsg = "指标已被删除，请重新选择！"
err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
return
}
}
edbInfoIdArr = append(edbInfoIdArr, edbInfoId)
edbInfo.EdbNameSource = edbInfo.EdbName
//edbList = append(edbList, edbInfo)
//新增季节性图表数据计算
if chartType == 2 {
existCount, tmpErr := data_manage.GetEdbDataQuarterCount(edbInfoId)
if tmpErr != nil {
errMsg = "保存失败"
err = errors.New("判断季节性图表，指标数据是否存在失败，Err:" + tmpErr.Error())
return
}
if existCount <= 0 {
go data_manage.AddCalculateQuarter(edbInfoId, edbInfo.Source, edbInfo.EdbCode)
}
// 处理季节性图表横轴配置
{
if req.SeasonExtraConfig.XEndDate != "" {
if req.SeasonExtraConfig.XStartDate > req.SeasonExtraConfig.XEndDate && req.SeasonExtraConfig.JumpYear != 1 {
errMsg = "季节性图表配置信息异常：横坐标日期配置错误"
err = errors.New("季节性图表配置信息异常： 横坐标日期配置错误")
return
}
seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
if tErr != nil {
errMsg = "季节性图表配置信息异常"
err = errors.New("季节性图表配置信息异常,Err:" + tErr.Error())
return
}
seasonExtraConfig = string(seasonExtra)
}
}
}
}
} else {
if extraConfig == `` {
errMsg = "请选择指标！"
err = errors.New(errMsg)
return
}
edbInfoIdArr = extraConfigEdbInfoIdArr
lenEdbInfoIdArr := len(edbInfoIdArr)
if lenEdbInfoIdArr > 0 {
tmpEdbList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdArr)
if tmpErr != nil {
errMsg = "指标异常！"
err = errors.New("指标异常！Err:" + tmpErr.Error())
return
}
if len(tmpEdbList) != lenEdbInfoIdArr {
errMsg = "指标异常！"
err = errors.New(fmt.Sprint("查找出来的指标数量与选择的指标数量不符！查找出来的指标数量:", len(tmpEdbList), ";用户选择的指标数量:", lenEdbInfoIdArr))
return
}
for _, v := range tmpEdbList {
chartEdbInfoList = append(chartEdbInfoList, &data_manage.ChartSaveItem{
EdbInfoId: v.EdbInfoId,
MaxData: 0,
MinData: 0,
IsOrder: false,
IsAxis: 1,
EdbInfoType: 1,
LeadValue: 0,
LeadUnit: "",
ChartStyle: "",
ChartColor: "",
PredictChartColor: "",
ChartWidth: 0,
Source: utils.CHART_SOURCE_DEFAULT,
})
}
}
}
if len(edbInfoIdArr) <= 0 {
errMsg = "请选择指标！"
err = errors.New(errMsg)
return
}
// 图表额外配置
extraConfig, err, errMsg = HandleExtraConfig(chartType, extraConfig)
if err != nil {
if errMsg == `` {
errMsg = "指标异常！"
}
err = errors.New("指标异常！Err:" + err.Error())
return
}
sort.Ints(edbInfoIdArr)
var edbInfoIdArrStr []string
for _, v := range edbInfoIdArr {
edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
}
edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
//count, err := data_manage.ChartInfoExist("", edbInfoIdStr)
//if err != nil && err.Error() != utils.ErrNoRow() {
// br.Msg = "保存失败"
// br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
// return
//}
//if count > 0 {
// br.Msg = "所选指标已存在相同指标"
// return
//}
{
var count int // 同名指标数量
//判断图表是否存在
var condition string
var pars []interface{}
// 图表名称在不同图分类下不允许重复 需求调整时间：2022年11月07日09:47:07
//condition += " AND chart_classify_id=? "
//pars = append(pars, req.ChartClassifyId)
switch lang {
case utils.EnLangVersion:
condition += " AND chart_name_en = ? AND source = ? "
default:
condition += " AND chart_name = ? AND source = ? "
}
pars = append(pars, req.ChartName, utils.CHART_SOURCE_DEFAULT)
count, err = data_manage.GetChartInfoCountByCondition(condition, pars)
if err != nil {
errMsg = "判断图表名称是否存在失败"
err = errors.New("判断图表名称是否存在失败,Err:" + err.Error())
return
}
if count > 0 {
errMsg = "图表已存在，请重新填写"
err = errors.New(errMsg)
isSendEmail = false
return
}
}
barChartConf := `` //柱方图的配置信息
if chartType == 7 {
barChartConfReq := req.BarChartInfo
if len(barChartConfReq.EdbInfoIdList) <= 0 {
errMsg = "请选择指标"
err = errors.New(errMsg)
isSendEmail = false
return
}
if len(barChartConfReq.DateList) <= 0 {
errMsg = "请选择日期"
err = errors.New(errMsg)
isSendEmail = false
return
}
barChartConfByte, tmpErr := json.Marshal(barChartConfReq)
if tmpErr != nil {
errMsg = "柱方图信息异常"
err = errors.New("柱方图信息异常,Err:" + tmpErr.Error())
return
}
barChartConf = string(barChartConfByte)
}
disableVal := CheckIsDisableChart(edbInfoIdArr)
chartInfo = new(data_manage.ChartInfo)
chartInfo.ChartName = req.ChartName
chartInfo.ChartNameEn = req.ChartName
chartInfo.EdbInfoIds = edbInfoIdStr
chartInfo.ChartClassifyId = req.ChartClassifyId
chartInfo.SysUserId = sysUserId
chartInfo.SysUserRealName = sysUserRealName
chartInfo.CreateTime = time.Now()
chartInfo.ModifyTime = time.Now()
chartInfo.IsSetName = 0
timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
chartInfo.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + timestamp)
// todo 判断是否需要重新计算用户的start_date
if req.DateType > 0 {
chartInfo.DateType = req.DateType
} else {
chartInfo.DateType = 3
}
if chartType == 0 {
chartType = 1
}
chartInfo.ChartType = chartType
calendar := req.Calendar
if calendar == "" {
calendar = "公历"
}
chartInfo.Calendar = calendar
chartInfo.StartDate = req.StartDate
chartInfo.EndDate = req.EndDate
chartInfo.SeasonStartDate = req.StartDate
chartInfo.SeasonEndDate = req.EndDate
chartInfo.LeftMin = req.LeftMin
chartInfo.LeftMax = req.LeftMax
chartInfo.RightMin = req.RightMin
chartInfo.RightMax = req.RightMax
chartInfo.Right2Min = req.Right2Min
chartInfo.Right2Max = req.Right2Max
chartInfo.MinMaxSave = req.MinMaxSave
chartInfo.Disabled = disableVal
chartInfo.BarConfig = barChartConf
chartInfo.ExtraConfig = extraConfig
chartInfo.SeasonExtraConfig = seasonExtraConfig
chartInfo.StartYear = req.StartYear
chartInfo.Source = utils.CHART_SOURCE_DEFAULT
chartInfo.ChartThemeId = req.ChartThemeId
chartInfo.SourcesFrom = req.SourcesFrom
chartInfo.Instructions = req.Instructions
chartInfo.MarkersLines = req.MarkersLines
chartInfo.MarkersAreas = req.MarkersAreas
chartInfo.Unit = req.Unit
chartInfo.UnitEn = req.UnitEn
newId, err := data_manage.AddChartInfo(chartInfo)
if err != nil {
errMsg = `保存失败`
err = errors.New("保存失败，Err:" + err.Error())
return
}
chartInfo.ChartInfoId = int(newId)
mapList := make([]*data_manage.ChartEdbMapping, 0)
for _, v := range chartEdbInfoList {
mapItem := new(data_manage.ChartEdbMapping)
mapItem.ChartInfoId = int(newId)
mapItem.EdbInfoId = v.EdbInfoId
mapItem.CreateTime = time.Now()
mapItem.ModifyTime = time.Now()
edbTimestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
mapItem.UniqueCode = utils.MD5(fmt.Sprint(utils.CHART_PREFIX, "_", v.EdbInfoId, "_", edbTimestamp))
mapItem.MaxData = v.MaxData
mapItem.MinData = v.MinData
mapItem.IsOrder = v.IsOrder
mapItem.IsAxis = v.IsAxis
mapItem.EdbInfoType = v.EdbInfoType
mapItem.LeadValue = v.LeadValue
mapItem.LeadUnit = v.LeadUnit
mapItem.ChartStyle = v.ChartStyle
mapItem.ChartColor = v.ChartColor
mapItem.PredictChartColor = v.PredictChartColor
mapItem.ChartWidth = v.ChartWidth
mapItem.Source = utils.CHART_SOURCE_DEFAULT
mapItem.EdbAliasName = v.EdbAliasName
mapItem.IsConvert = v.IsConvert
mapItem.ConvertType = v.ConvertType
mapItem.ConvertValue = v.ConvertValue
mapItem.ConvertUnit = v.ConvertUnit
mapItem.ConvertEnUnit = v.ConvertEnUnit
mapList = append(mapList, mapItem)
}
err = data_manage.AddChartEdbMapping(mapList)
if err != nil {
errMsg = `保存失败`
err = errors.New("保存失败，Err:" + err.Error())
return
}
//添加es数据
go EsAddOrEditChartInfo(chartInfo.ChartInfoId)
return
}
// EditChartInfo 编辑图表
func EditChartInfo(req data_manage.EditChartInfoReq, sysUser *system.Admin, lang string) (chartItem *data_manage.ChartInfo, err error, errMsg string, isSendEmail bool) {
isSendEmail = true // 默认错误的时候要发送邮件
req.ChartName = strings.Trim(req.ChartName, " ")
if req.ChartName == "" {
errMsg = "请填写图表名称！"
err = errors.New(errMsg)
isSendEmail = false
return
}
if req.ChartClassifyId <= 0 {
errMsg = "分类参数错误！"
err = errors.New(errMsg)
isSendEmail = false
return
}
//if req.ChartThemeId <= 0 {
// errMsg = "请选择主题！"
// err = errors.New(errMsg)
// isSendEmail = false
// return
//}
//
//// 判断主题是否存在
//_, err = chart_theme.GetChartThemeId(req.ChartThemeId)
//if err != nil {
// if err.Error() == utils.ErrNoRow() {
// errMsg = "主题不存在"
// err = errors.New(errMsg)
// return
// }
// errMsg = "获取主题信息失败"
// return
//}
chartClassify, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
if err != nil {
if err.Error() == utils.ErrNoRow() {
errMsg = "分类不存在"
err = errors.New(errMsg)
return
}
errMsg = "获取分类信息失败"
return
}
if chartClassify == nil {
errMsg = "分类不存在"
err = errors.New(errMsg)
return
}
chartItem, err = data_manage.GetChartInfoById(req.ChartInfoId)
if err != nil {
if err.Error() == utils.ErrNoRow() {
errMsg = "图表已被删除，请刷新页面"
err = errors.New(errMsg)
isSendEmail = false
return
}
errMsg = "获取图表信息失败"
err = errors.New("获取图表信息失败,Err:" + err.Error())
return
}
var extraConfigEdbInfoIdArr []int
extraConfigEdbInfoIdArr, err, errMsg = CheckChartExtraConfig(req.ChartType, req.ExtraConfig)
if err != nil {
err = errors.New("添加失败:" + err.Error())
return
}
// 季节性图表额外配置信息
var seasonExtraConfig string
// 图表关联指标id
chartEdbInfoList := make([]*data_manage.ChartSaveItem, 0)
// 关联指标
var edbInfoIdArr []int
// 非散点截面图的直接通过前端获取,散点截面图需要额外从配置中获取
if chartItem.ChartType != 10 {
//edbList := make([]*data_manage.EdbInfo, 0)
for _, v := range req.ChartEdbInfoList {
edbInfoId := v.EdbInfoId
edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
if tmpErr != nil {
if tmpErr.Error() == utils.ErrNoRow() {
errMsg = "指标不存在！"
err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
return
} else {
errMsg = "获取指标信息失败！"
err = errors.New("获取图表的指标信息失败，Err:" + tmpErr.Error())
return
}
}
if edbInfo == nil {
errMsg = "指标已被删除，请重新选择！"
err = errors.New("指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId))
return
} else {
if edbInfo.EdbInfoId <= 0 {
errMsg = "指标已被删除，请重新选择！"
err = errors.New("指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId))
return
}
}
edbInfoIdArr = append(edbInfoIdArr, edbInfoId)
edbInfo.EdbNameSource = edbInfo.EdbName
//edbList = append(edbList, edbInfo)
//新增季节性图表数据计算
if req.ChartType == 2 {
existCount, tmpErr := data_manage.GetEdbDataQuarterCount(edbInfoId)
if tmpErr != nil {
errMsg = "保存失败"
err = errors.New("判断季节性图表，指标数据是否存在失败，Err:" + tmpErr.Error())
return
}
if existCount <= 0 {
go data_manage.AddCalculateQuarter(edbInfoId, edbInfo.Source, edbInfo.EdbCode)
}
// 处理季节性图表横轴配置
{
if req.SeasonExtraConfig.XEndDate != "" {
if req.SeasonExtraConfig.XStartDate > req.SeasonExtraConfig.XEndDate && req.SeasonExtraConfig.JumpYear != 1 {
errMsg = "季节性图表配置信息异常：横坐标日期配置错误"
err = errors.New("季节性图表配置信息异常： 横坐标日期配置错误")
return
}
seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
if tErr != nil {
errMsg = "季节性图表配置信息异常"
err = errors.New("季节性图表配置信息异常,Err:" + tErr.Error())
return
}
seasonExtraConfig = string(seasonExtra)
}
}
}
}
chartEdbInfoList = req.ChartEdbInfoList
} else {
if req.ExtraConfig == `` {
errMsg = "请选择指标！"
err = errors.New(errMsg)
isSendEmail = false
return
}
edbInfoIdArr = extraConfigEdbInfoIdArr
lenEdbInfoIdArr := len(edbInfoIdArr)
if lenEdbInfoIdArr > 0 {
tmpEdbList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdArr)
if tmpErr != nil {
errMsg = "指标异常！"
err = errors.New("指标异常！Err:" + tmpErr.Error())
return
}
if len(tmpEdbList) != lenEdbInfoIdArr {
errMsg = "指标异常！"
err = errors.New(fmt.Sprint("查找出来的指标数量与选择的指标数量不符！查找出来的指标数量:", len(tmpEdbList), ";用户选择的指标数量:", lenEdbInfoIdArr))
return
}
for _, v := range tmpEdbList {
chartEdbInfoList = append(chartEdbInfoList, &data_manage.ChartSaveItem{
EdbInfoId: v.EdbInfoId,
MaxData: 0,
MinData: 0,
IsOrder: false,
IsAxis: 1,
EdbInfoType: 1,
LeadValue: 0,
LeadUnit: "",
ChartStyle: "",
ChartColor: "",
PredictChartColor: "",
ChartWidth: 0,
Source: utils.CHART_SOURCE_DEFAULT,
})
}
}
}
if len(edbInfoIdArr) <= 0 {
errMsg = "请选择指标！"
err = errors.New(errMsg)
isSendEmail = false
return
}
// 图表额外配置
extraConfig, err, errMsg := HandleExtraConfig(req.ChartType, req.ExtraConfig)
if err != nil {
if errMsg == `` {
errMsg = "指标异常！"
}
err = errors.New("指标异常！Err:" + err.Error())
return
}
req.ExtraConfig = extraConfig
// 权限
var haveOperaAuth bool
{
// 已授权分类id
permissionChartIdList, permissionClassifyIdList, tmpErr := data_manage_permission.GetUserChartAndClassifyPermissionList(sysUser.AdminId, chartItem.ChartInfoId, chartItem.ChartClassifyId)
if tmpErr != nil {
if errMsg == `` {
errMsg = "获取失败！"
}
err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error())
return
}
haveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartItem.IsJoinPermission, chartClassify.IsJoinPermission, chartItem.ChartInfoId, chartItem.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
}
//图表操作权限
ok := CheckOpChartPermission(sysUser, chartItem.SysUserId, haveOperaAuth)
if !ok {
errMsg = "没有该图表的操作权限"
err = errors.New(errMsg)
isSendEmail = false
return
}
var calendar string
var dateType int
dateType = req.DateType
if req.ChartType != chartItem.ChartType {
if chartItem.ChartType != 2 && chartItem.Calendar == "" { //非季节性图
calendar = "公历"
}
if chartItem.ChartType == 2 && chartItem.DateType <= 0 {
dateType = 3
}
}
sort.Ints(edbInfoIdArr)
var edbInfoIdArrStr []string
for _, v := range edbInfoIdArr {
edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
}
edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
//mappingCondition := ` AND chart_info_id<> ` + strconv.Itoa(req.ChartInfoId)
//count, err := data_manage.ChartInfoExist(mappingCondition, edbInfoIdStr)
//if err != nil && err.Error() != utils.ErrNoRow() {
// br.Msg = "保存失败"
// br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
// return
//}
//if count > 0 {
// br.Msg = "所选指标已存在相同指标"
// return
//}
// 判断图表是否存在
{
var count int
var condition string
var pars []interface{}
condition += " AND chart_info_id<>? "
pars = append(pars, req.ChartInfoId)
// 图表名称在不同图分类下不允许重复 需求调整时间：2022年11月07日09:47:07
//condition += " AND chart_classify_id=? "
//pars = append(pars, req.ChartClassifyId)
switch lang {
case utils.EnLangVersion:
condition += " AND chart_name_en = ? AND source = ? "
default:
condition += " AND chart_name = ? AND source = ? "
}
pars = append(pars, req.ChartName, utils.CHART_SOURCE_DEFAULT)
count, err = data_manage.GetChartInfoCountByCondition(condition, pars)
if err != nil {
errMsg = "判断图表名称是否存在失败"
err = errors.New("判断图表名称是否存在失败,Err:" + err.Error())
return
}
if count > 0 {
errMsg = "图表已存在，请重新填写"
err = errors.New(errMsg)
isSendEmail = false
return
}
}
barChartConf := `` //柱方图的配置信息
if req.ChartType == 7 {
barChartConfReq := req.BarChartInfo
if len(barChartConfReq.EdbInfoIdList) <= 0 {
errMsg = "请选择指标"
err = errors.New(errMsg)
isSendEmail = false
return
}
if len(barChartConfReq.DateList) <= 0 {
errMsg = "请选择日期"
err = errors.New(errMsg)
isSendEmail = false
return
}
barChartConfByte, tmpErr := json.Marshal(barChartConfReq)
if tmpErr != nil {
errMsg = "柱方图信息异常"
err = errors.New("柱方图信息异常,Err:" + tmpErr.Error())
return
}
barChartConf = string(barChartConfByte)
}
// 图表启用与否
disableVal := CheckIsDisableChart(edbInfoIdArr)
switch lang {
case utils.EnLangVersion:
req.ChartNameEn = req.ChartName
req.ChartName = chartItem.ChartName
if req.UnitEn == `` {
req.UnitEn = req.Unit
}
req.Unit = chartItem.Unit
default:
req.ChartNameEn = chartItem.ChartNameEn
req.UnitEn = chartItem.UnitEn
}
err = data_manage.EditChartInfoAndMapping(&req, edbInfoIdStr, calendar, dateType, disableVal, barChartConf, chartEdbInfoList, seasonExtraConfig)
if err != nil {
errMsg = "保存失败"
err = errors.New("保存失败,Err:" + err.Error())
return
}
resp := new(data_manage.AddChartInfoResp)
resp.ChartInfoId = chartItem.ChartInfoId
resp.UniqueCode = chartItem.UniqueCode
resp.ChartType = req.ChartType
//添加es数据
go EsAddOrEditChartInfo(chartItem.ChartInfoId)
//修改my eta es数据
go EsAddOrEditMyChartInfoByChartInfoId(chartItem.ChartInfoId)
return
}
// GetEdbSourceByEdbInfoIdList 获取关联指标的来源
func GetEdbSourceByEdbInfoIdList(chartEdbInfoMappingList []*data_manage.ChartEdbInfoMapping) (sourceNameList, sourceNameEnList []string) {
sourceNameList = make([]string, 0)
sourceNameEnList = make([]string, 0)
sourceMap := make(map[int]string)
for _, v := range chartEdbInfoMappingList {
// 指标类型:1:基础指标,2:计算指标
if v.EdbType == 2 || v.EdbInfoCategoryType == 1 {
//sourceMap[0] = "弘则研究"
baseEdbInfoArr, _, _ := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
for _, baseEdbInfo := range baseEdbInfoArr {
if baseEdbInfo.EdbInfoType == 0 { //普通指标才参与，预测指标不参与
sourceMap[baseEdbInfo.Source] = baseEdbInfo.SourceName
}
}
} else {
sourceMap[v.Source] = v.SourceName
}
}
for source, sourceName := range sourceMap {
if utils.InArrayByInt([]int{utils.DATA_SOURCE_MANUAL, utils.DATA_SOURCE_MYSTEEL_CHEMICAL}, source) {
continue
}
sourceNameList = append(sourceNameList, sourceName)
sourceNameEn, ok := utils.DataSourceEnMap[source]
if !ok {
sourceNameEn = sourceName
}
sourceNameEnList = append(sourceNameEnList, sourceNameEn)
}
//sourceNameList = append(sourceNameList, utils.ChartDefaultNameCn)
//sourceNameEnList = append(sourceNameEnList, utils.ChartDefaultNameEn)
// 图表来源
conf, e := models.GetBusinessConf()
if e != nil {
return
}
if conf[models.BusinessConfCompanyName] != "" {
sourceNameList = append(sourceNameList, conf[models.BusinessConfCompanyName])
sourceNameEnList = append(sourceNameEnList, conf[models.BusinessConfCompanyName])
}
return
}
// RadarChartData 雷达图的数据处理
func RadarChartData(mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, extraConfig data_manage.RadarChartInfoReq) (edbIdList []int, chartDataResp data_manage.RadarChartInfoResp, err error) {
// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
edbDataMap := make(map[int]map[string]float64)
for edbInfoId, edbDataList := range edbDataListMap {
edbDateData := make(map[string]float64)
for _, edbData := range edbDataList {
edbDateData[edbData.DataTime] = edbData.Value
}
edbDataMap[edbInfoId] = edbDateData
}
// edbIdList 指标展示顺序；x轴的指标顺序
edbIdList = make([]int, 0)
for _, v := range mappingList {
edbIdList = append(edbIdList, v.EdbInfoId)
}
chartDateList := extraConfig.DateList
yDataList := make([]data_manage.RadarYData, 0) //y轴的数据列表
for _, chartDate := range chartDateList {
var maxDate time.Time
findDataList := make([]float64, 0) // 当前日期的数据值
for _, edbInfoId := range edbIdList {
findDate := chartDate.Date //需要的日期值
dataList := edbDataListMap[edbInfoId] //指标的所有数据值
if len(dataList) <= 0 {
// 没有数据的指标id
findDataList = append(findDataList, 0)
continue
}
switch chartDate.Type {
case 1: //最新值
findDate = dataList[len(dataList)-1].DataTime
case 2: //近期几天
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
findDateTime = findDateTime.AddDate(0, 0, -chartDate.Value)
lenData := len(dataList) - 1
for i := lenData; i >= 0; i-- {
currDateTime, e := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
if e != nil {
err = e
return
}
if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
findDate = dataList[i].DataTime
break
}
}
case 3: // 固定日期
//最早的日期
minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
//寻找固定日期的数据
findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, chartDate.Date, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
tmpDate := tmpDateTime.Format(utils.FormatDate)
if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
findDate = tmpDate
break
}
}
default:
err = errors.New(fmt.Sprint("日期类型异常,Type:", chartDate.Type))
return
}
findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
if maxDate.IsZero() {
maxDate = findDateTime
} else {
if findDateTime.After(maxDate) {
maxDate = findDateTime
}
}
if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
tmpValue, _ = decimal.NewFromFloat(tmpValue).Round(4).Float64()
findDataList = append(findDataList, tmpValue)
} else {
findDataList = append(findDataList, 0)
}
}
yDate := "0000-00-00"
if !maxDate.IsZero() {
yDate = maxDate.Format(utils.FormatDate)
}
yDataList = append(yDataList, data_manage.RadarYData{
Date: yDate,
Value: findDataList,
Color: chartDate.Color,
Name: chartDate.Name,
})
}
chartDataResp = data_manage.RadarChartInfoResp{
YDataList: yDataList,
XEdbIdValue: edbIdList,
}
return
}
// GetChartConvertEdbData 获取图表数据转换的指标数据
func GetChartConvertEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string) (edbList []*data_manage.ChartEdbInfoMapping, xEdbIdValue []int, yDataList []data_manage.YData, dataResp interface{}, err error, errMsg string) {
edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
xEdbIdValue = make([]int, 0)
yDataList = make([]data_manage.YData, 0)
var extraConfig interface{}
switch chartType {
case 7: // 柱形图
var barConfig data_manage.BarChartInfoReq
if extraConfigStr == `` {
errMsg = "柱方图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
if err != nil {
errMsg = "柱方图配置异常"
err = errors.New(errMsg)
return
}
extraConfig = barConfig
case 10: // 截面散点图
var tmpExtraConfig data_manage.SectionScatterReq
if extraConfigStr == `` {
errMsg = "截面散点图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
if err != nil {
errMsg = "截面散点配置异常"
err = errors.New(errMsg)
return
}
extraConfig = tmpExtraConfig
case utils.CHART_TYPE_RADAR:
var barConfig data_manage.RadarChartInfoReq
if extraConfigStr == `` {
errMsg = "雷达图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
if err != nil {
errMsg = "雷达图配置异常"
err = errors.New(errMsg)
return
}
extraConfig = barConfig
default:
xEdbIdValue = make([]int, 0)
yDataList = make([]data_manage.YData, 0)
}
// 指标对应的所有数据
edbDataListMap, edbList, err := getEdbConvertDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig)
if err != nil {
return
}
// 特殊图形数据处理
switch chartType {
case 7: // 柱形图
barChartConf := extraConfig.(data_manage.BarChartInfoReq)
xEdbIdValue, yDataList, err = BarChartData(mappingList, edbDataListMap, barChartConf.DateList, barChartConf.Sort)
for k := range yDataList {
yDataList[k].Unit = barChartConf.Unit
yDataList[k].UnitEn = barChartConf.UnitEn
}
for _, v := range edbList {
// 指标别名
if barChartConf.EdbInfoIdList != nil && len(barChartConf.EdbInfoIdList) > 0 {
for _, reqEdb := range barChartConf.EdbInfoIdList {
if v.EdbInfoId == reqEdb.EdbInfoId {
v.EdbAliasName = reqEdb.Name
}
}
}
}
case 10: // 截面散点图
sectionScatterConf := extraConfig.(data_manage.SectionScatterReq)
xEdbIdValue, dataResp, err = GetSectionScatterChartData(chartInfoId, mappingList, edbDataListMap, sectionScatterConf)
var tmpExtraConfig data_manage.SectionScatterReq
if extraConfigStr == `` {
errMsg = "截面散点图未配置"
err = errors.New(errMsg)
return
}
err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
if err != nil {
errMsg = "截面散点配置异常"
err = errors.New(errMsg)
return
}
// 这个数据没有必要返回给前端
for _, v := range edbList {
v.DataList = nil
}
case utils.CHART_TYPE_RADAR: //雷达图
radarConf := extraConfig.(data_manage.RadarChartInfoReq)
xEdbIdValue, dataResp, err = RadarChartData(mappingList, edbDataListMap, radarConf)
}
return
}
func getEdbConvertDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
// 指标对应的所有数据
edbDataListMap = make(map[int][]*data_manage.EdbDataList)
for _, v := range mappingList {
//fmt.Println("v:", v.EdbInfoId)
item := new(data_manage.ChartEdbInfoMapping)
item.EdbInfoId = v.EdbInfoId
item.SourceName = v.SourceName
item.Source = v.Source
item.EdbCode = v.EdbCode
item.EdbName = v.EdbName
item.EdbNameEn = v.EdbNameEn
item.Frequency = v.Frequency
item.EdbType = v.EdbType
item.FrequencyEn = GetFrequencyEn(v.Frequency)
if v.Unit != `无` {
item.Unit = v.Unit
}
item.UnitEn = v.UnitEn
item.StartDate = v.StartDate
item.EndDate = v.EndDate
item.ModifyTime = v.ModifyTime
item.EdbInfoCategoryType = v.EdbInfoCategoryType
item.PredictChartColor = v.PredictChartColor
item.ClassifyId = v.ClassifyId
if chartInfoId <= 0 {
item.IsAxis = 1
item.LeadValue = 0
item.LeadUnit = ""
item.ChartEdbMappingId = 0
item.ChartInfoId = 0
item.IsOrder = false
item.EdbInfoType = 1
item.ChartStyle = ""
item.ChartColor = ""
item.ChartWidth = 0
item.MaxData = v.MaxValue
item.MinData = v.MinValue
} else {
item.IsAxis = v.IsAxis
item.EdbInfoType = v.EdbInfoType
item.LeadValue = v.LeadValue
item.LeadUnit = v.LeadUnit
item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
item.ChartEdbMappingId = v.ChartEdbMappingId
item.ChartInfoId = v.ChartInfoId
item.ChartStyle = v.ChartStyle
item.ChartColor = v.ChartColor
item.ChartWidth = v.ChartWidth
item.IsOrder = v.IsOrder
item.MaxData = v.MaxData
item.MinData = v.MinData
}
item.LatestValue = v.LatestValue
item.LatestDate = v.LatestDate
item.UniqueCode = v.UniqueCode
item.MoveLatestDate = v.LatestDate
item.EdbAliasName = v.EdbAliasName
item.IsConvert = v.IsConvert
item.ConvertType = v.ConvertType
item.ConvertValue = v.ConvertValue
item.ConvertUnit = v.ConvertUnit
item.ConvertEnUnit = v.ConvertEnUnit
var startDateReal string
var diffSeconds int64
if chartType == 2 { //季节性图
startDateReal = startDate
} else {
if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
var startTimeRealTemp time.Time
startDateParse, _ := time.Parse(utils.FormatDate, startDate)
switch v.LeadUnit {
case "天":
startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
case "月":
startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
case "季":
startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
case "周":
startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
case "年":
startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
}
if startTimeRealTemp.Before(startDateParse) {
startDateReal = startTimeRealTemp.Format(utils.FormatDate)
diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
} else {
startDateReal = startDate
diffSeconds = 0
}
// 预测指标的开始日期也要偏移
{
day, tmpErr := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
if tmpErr != nil {
err = tmpErr
return
}
moveLatestDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, item.MoveLatestDate, time.Local)
if tmpErr != nil {
err = tmpErr
return
}
item.MoveLatestDate = moveLatestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
}
} else {
startDateReal = startDate
}
}
//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
calendarPreYear := 0
if calendar == "农历" {
newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
if err != nil {
fmt.Println("time.Parse:" + err.Error())
}
calendarPreYear = newStartDateReal.Year() - 1
newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
startDateReal = newStartDateReal.Format(utils.FormatDate)
}
dataList := make([]*data_manage.EdbDataList, 0)
//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
//fmt.Println("calendarPreYear:", calendarPreYear)
//var newEdbInfo *data_manage.EdbInfo
switch v.EdbInfoCategoryType {
case 0:
dataList, err = data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, startDateReal, endDate)
case 1:
_, dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, true)
default:
err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
}
if err != nil {
return
}
if v.IsConvert == 1 {
switch v.ConvertType {
case 1:
for i, data := range dataList {
dataList[i].Value = data.Value * v.ConvertValue
}
item.MaxData = item.MaxData * v.ConvertValue
item.MinData = item.MinData * v.ConvertValue
case 2:
for i, data := range dataList {
dataList[i].Value = data.Value / v.ConvertValue
}
item.MaxData = item.MaxData / v.ConvertValue
item.MinData = item.MinData / v.ConvertValue
case 3:
for i, data := range dataList {
dataList[i].Value = math.Log(data.Value) / math.Log(v.ConvertValue)
}
item.MaxData = math.Log(item.MaxData) / math.Log(v.ConvertValue)
item.MinData = math.Log(item.MinData) / math.Log(v.ConvertValue)
}
}
edbDataListMap[v.EdbInfoId] = dataList
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 {
latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
if tmpErr != nil {
//item.DataList = dataList
item.IsNullData = true
edbList = append(edbList, item)
continue
err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
return
}
if calendar == "农历" {
if len(dataList) <= 0 {
result := new(data_manage.EdbDataResult)
item.DataList = result
} else {
result, tmpErr := data_manage.AddCalculateQuarterV6(dataList)
if tmpErr != nil {
err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
return
}
quarterDataList, tErr := GetSeasonEdbInfoDataListByXDateNong(result, latestDate, seasonExtraConfig, calendarPreYear)
if tErr != nil {
err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
return
}
item.DataList = quarterDataList
}
} else {
quarterDataList, tErr := GetSeasonEdbInfoDataListByXDate(dataList, latestDate, seasonExtraConfig)
if tErr != nil {
err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
return
}
item.DataList = quarterDataList
}
} else if chartType == 7 || chartType == utils.CHART_TYPE_RADAR { //柱方图
//item.DataList = dataList
} else {
item.DataList = dataList
}
edbList = append(edbList, item)
}
return
}