package data import ( "encoding/json" "errors" "eta/eta_mobile/models" "eta/eta_mobile/models/company" "eta/eta_mobile/models/data_manage" "eta/eta_mobile/models/system" "eta/eta_mobile/services/alarm_msg" "eta/eta_mobile/services/data/data_manage_permission" "eta/eta_mobile/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 6: var tmpConfig data_manage.ChartTimeCombineExtraConf if extraConfigStr != `` { err = json.Unmarshal([]byte(extraConfigStr), &tmpConfig) if err != nil { errMsg = "雷达图配置异常" err = errors.New(errMsg) return } } extraConfig = tmpConfig 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 case utils.CHART_TYPE_SECTION_COMBINE: // 预览和详情都走这个接口 var sectionExtraConfig data_manage.ChartSectionAllExtraConf if extraConfigStr == `` { errMsg = "截面组合图未配置" err = errors.New(errMsg) return } if chartInfoId > 0 { var sectionExtraConfigTmp data_manage.ChartSectionExtraConf err = json.Unmarshal([]byte(extraConfigStr), §ionExtraConfigTmp) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg) return } sectionExtraConfig.XDataList = sectionExtraConfigTmp.XDataList sectionExtraConfig.BaseChartSeriesName = sectionExtraConfigTmp.BaseChartSeriesName sectionExtraConfig.UnitList = sectionExtraConfigTmp.UnitList sectionExtraConfig.DateConfList = sectionExtraConfigTmp.DateConfList sectionExtraConfig.IsHeap = sectionExtraConfigTmp.IsHeap sectionExtraConfig.SortType = sectionExtraConfigTmp.SortType // 查询所有的seriesEdb seriesEdbList, e := data_manage.GetChartSeriesEdbByChartInfoId(chartInfoId) if e != nil { errMsg = "查询seriesEdb失败" err = errors.New(errMsg + e.Error()) return } // todo 是否有必要返回单位信息 // 组装成map seriesEdbMap := make(map[int][]*data_manage.ChartSectionSeriesEdbConf) for _, v := range seriesEdbList { var dateConf *data_manage.ChartSectionSeriesDateConfItem if v.DateConf != "" { err = json.Unmarshal([]byte(v.DateConf), &dateConf) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg + err.Error()) return } } tmp := &data_manage.ChartSectionSeriesEdbConf{ ChartSeriesEdbMappingId: v.ChartSeriesEdbMappingId, ChartSeriesId: v.ChartSeriesId, //ChartInfoId: v.ChartInfoId, EdbInfoId: v.EdbInfoId, DateConf: dateConf, EdbName: "", EdbNameEn: "", Unit: "", UnitEn: "", DateConfName: v.DateConfName, DateConfType: v.DateConfType, } seriesEdbMap[v.ChartSeriesId] = append(seriesEdbMap[v.ChartSeriesId], tmp) } //查询series seriesListTmp, e := data_manage.GetChartSeriesByChartInfoId(chartInfoId) if e != nil { errMsg = "查询series失败" err = errors.New(errMsg + e.Error()) return } seriesList := make([]*data_manage.ChartSectionSeriesItem, 0) for _, v := range seriesListTmp { tmpSeries := &data_manage.ChartSectionSeriesItem{ ChartSeriesId: v.ChartSeriesId, SeriesName: v.SeriesName, SeriesNameEn: v.SeriesNameEn, ChartStyle: v.ChartStyle, ChartColor: v.ChartColor, ChartWidth: v.ChartWidth, IsPoint: v.IsPoint, IsNumber: v.IsNumber, IsAxis: v.IsAxis, MaxData: v.MaxData, MinData: v.MinData, //IsOrder: false, EdbInfoList: nil, DataList: nil, } edbInfoList, ok := seriesEdbMap[v.ChartSeriesId] if ok { tmpSeries.EdbInfoList = edbInfoList } seriesList = append(seriesList, tmpSeries) } sectionExtraConfig.SeriesList = seriesList } else { err = json.Unmarshal([]byte(extraConfigStr), §ionExtraConfig) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg) return } } //校验引用日期名称是否重复 dateNameMap := make(map[string]int) dateNameEnMap := make(map[string]int) for _, v := range sectionExtraConfig.DateConfList { if _, ok := dateNameMap[v.DateConfName]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfName) return } if _, ok := dateNameEnMap[v.DateConfNameEn]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfNameEn) return } if v.DateConfName != "" { dateNameMap[v.DateConfName] = 1 } if v.DateConfNameEn != "" { dateNameEnMap[v.DateConfNameEn] = 1 } } //检查系列名称是否重复 seriesNameMap := make(map[string]int) seriesNameEnMap := make(map[string]int) for _, v := range sectionExtraConfig.SeriesList { if _, ok := seriesNameMap[v.SeriesName]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesName) return } if _, ok := seriesNameEnMap[v.SeriesNameEn]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesNameEn) return } if v.SeriesName != "" { seriesNameMap[v.SeriesName] = 1 } if v.SeriesNameEn != "" { seriesNameEnMap[v.SeriesNameEn] = 1 } } // 检查基准系列是否设置 if sectionExtraConfig.BaseChartSeriesName == "" { errMsg = "截面组合图基准系列名称未设置" err = errors.New(errMsg) return } //todo 如果是详情接口，应该要从其他表里查询配置 extraConfig = sectionExtraConfig 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 6: //时序组合图 //判断是否堆积 timeConf := extraConfig.(data_manage.ChartTimeCombineExtraConf) if extraConfigStr == "" { //历史数据，默认开启堆积 timeConf = data_manage.ChartTimeCombineExtraConf{ IsHeap: 1, } } dataResp = data_manage.ChartTimeCombineDataResp{IsHeap: timeConf.IsHeap} case 2: // 季节性图 if seasonExtraConfig != "" { // 季节性图计算不管图上数据时间，拿所有数据 _, tempEdbList, e := getEdbDataMapList(chartInfoId, chartType, calendar, "1990-01-01", "", mappingList, seasonExtraConfig) if e != nil { err = e return } dataResp, err = SeasonChartData(tempEdbList, seasonExtraConfig) } else { // 兼容无配置的老图 dataResp = new(data_manage.SeasonChartResp) } 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_SECTION_COMBINE: // 截面组合图 sectionConf := extraConfig.(data_manage.ChartSectionAllExtraConf) var chartInfo *data_manage.ChartInfo if chartInfoId > 0 { chartInfo, err = data_manage.GetChartInfoById(chartInfoId) if err != nil { errMsg = "获取图表信息失败" return } } xEdbIdValue, dataResp, err = GetChartSectionCombineData(chartInfo, mappingList, edbDataListMap, sectionConf) // 这个数据没有必要返回给前端 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 if len(mappingList) > 1 { item.IsAxis = v.IsAxis } } 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 && item.IsAxis == 1 { 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 == 2 && item.IsAxis == 0 { // 右轴数据处理 xStartDate := "01-01" jumpYear := 0 var seasonExtra data_manage.SeasonExtraItem if seasonExtraConfig != "" { err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra) if err != nil { return } } if seasonExtra.XStartDate != "" { xStartDate = seasonExtra.XStartDate jumpYear = seasonExtra.JumpYear } length := len(dataList) if length == 0 { return } 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 } var rightAxisDate time.Time if jumpYear == 1 { latestDate = latestDate.AddDate(-1, 0, 0) } latestDateStr := fmt.Sprintf("%d-%s", latestDate.Year(), xStartDate) rightAxisDate, err = time.Parse(utils.FormatDate, latestDateStr) if err != nil { return } newDataList := make([]*data_manage.EdbDataList, 0) for _, v := range dataList { dataTime, e := time.Parse(utils.FormatDate, v.DataTime) if e != nil { err = errors.New("季节性图处理右轴指标数据转换日期失败,Err:" + e.Error()) return } if dataTime.Equal(rightAxisDate) || dataTime.After(rightAxisDate) { newDataList = append(newDataList, v) } } item.DataList = newDataList } 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() chartLegendMaxYear := 0 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, } chartLegendMaxYear = endT.Year() dataMap[name] = item chartLegendMap[name] = idx idx++ fmt.Println("年份" + showName + "日期" + startStr + " " + endStr) if lastDateT.Before(endT) { //如果最新的日期在起始日之前，则跳出循环 break } } lenYear := len(dataMap) if chartLegendMaxYear > endYear { chartLegendMaxYear = endYear } for k, v := range dataMap { if i, ok := chartLegendMap[k]; ok { //v.ChartLegend = strconv.Itoa(endYear - lenYear + i) v.ChartLegend = strconv.Itoa(chartLegendMaxYear - 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] /*if len(itemList) == 0 { continue }*/ 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() chartLegendMaxYear := 0 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, } chartLegendMaxYear = endT.Year() dataMap[showName] = item fmt.Println("年份" + showName + "日期" + startStr + " " + endStr) startTmpT = startT endTmpT = endT chartLegendMap[showName] = idx idx++ if lastDateT.Before(endT) { //如果最新的日期在起始日之前，则跳出循环 break } } lenYear := len(dataMap) if chartLegendMaxYear > endYear { chartLegendMaxYear = endYear } for k, v := range dataMap { if i, ok := chartLegendMap[k]; ok { //v.ChartLegend = strconv.Itoa(endYear - lenYear + i) v.ChartLegend = strconv.Itoa(chartLegendMaxYear - 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] /*if len(itemList) == 0 { continue }*/ 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 } case utils.CHART_TYPE_SECTION_COMBINE: var extraConfig data_manage.ChartSectionAllExtraConf if extraConfigStr == `` { errMsg = "截面组合图未配置" err = errors.New(errMsg) return } err = json.Unmarshal([]byte(extraConfigStr), &extraConfig) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg + err.Error()) return } //校验引用日期名称是否重复 dateNameMap := make(map[string]int) dateNameEnMap := make(map[string]int) for _, v := range extraConfig.DateConfList { if _, ok := dateNameMap[v.DateConfName]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfName) return } if _, ok := dateNameEnMap[v.DateConfNameEn]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfNameEn) return } if v.DateConfName != "" { dateNameMap[v.DateConfName] = 1 } if v.DateConfNameEn != "" { dateNameEnMap[v.DateConfNameEn] = 1 } } //检查系列名称是否重复 seriesNameMap := make(map[string]int) seriesNameEnMap := make(map[string]int) for _, v := range extraConfig.SeriesList { if _, ok := seriesNameMap[v.SeriesName]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesName) return } if _, ok := seriesNameEnMap[v.SeriesNameEn]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesNameEn) return } if v.SeriesName != "" { seriesNameMap[v.SeriesName] = 1 } if v.SeriesNameEn != "" { seriesNameEnMap[v.SeriesNameEn] = 1 } } // 检查基准系列是否设置 if extraConfig.BaseChartSeriesName == "" { errMsg = "截面组合图基准系列名称未设置" err = errors.New(errMsg) return } //todo 如果是详情接口，应该要从其他表里查询配置 // 遍历指标列表获取指标id edbIdMap := make(map[int]int) hasUsed := make(map[string]struct{}) for _, v := range extraConfig.SeriesList { for _, item := range v.EdbInfoList { if item.DateConfName != "" && item.DateConfType == 1 { hasUsed[item.DateConfName] = struct{}{} } if _, ok := edbIdMap[item.EdbInfoId]; !ok { edbIdMap[item.EdbInfoId] = item.EdbInfoId edbIdList = append(edbIdList, item.EdbInfoId) } } } // todo 遍历引用日期获取引用日期里的指标ID, 如果引用日期里的指标没有被引用，是否加入映射 for _, v := range extraConfig.DateConfList { if _, ok := hasUsed[v.DateConfName]; !ok { continue } if _, ok := edbIdMap[v.EdbInfoId]; !ok && v.EdbInfoId > 0 { edbIdMap[v.EdbInfoId] = v.EdbInfoId edbIdList = append(edbIdList, v.EdbInfoId) } } } 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 } // 图表额外配置 // 图表额外配置 var allExtraConfig string extraConfig, allExtraConfig, err, errMsg = HandleExtraConfig(0, 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 } if chartType == utils.CHART_TYPE_SECTION_COMBINE { err = data_manage.AddChartSeriesAndEdbMapping(allExtraConfig, int(newId)) 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, allExtraConfig, err, errMsg := HandleExtraConfig(req.ChartInfoId, 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 if chartItem.ChartType == utils.CHART_TYPE_SECTION_COMBINE { err = data_manage.EditChartSeriesAndEdbMapping(allExtraConfig, chartItem.ChartInfoId) if err != nil { errMsg = "保存失败" err = errors.New("保存失败,Err:" + err.Error()) return } } //添加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}, 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, isAxis int) (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, isAxis) if err != nil { return } // 特殊图形数据处理 switch chartType { case 2: // 季节性图 if seasonExtraConfig != "" { // 季节性图计算不管图上数据时间，拿所有数据 _, tempEdbList, e := getEdbDataMapList(chartInfoId, chartType, calendar, "1990-01-01", "", mappingList, seasonExtraConfig) if e != nil { err = e return } dataResp, err = SeasonChartData(tempEdbList, seasonExtraConfig) } else { // 兼容无配置的老图 dataResp = new(data_manage.SeasonChartResp) } 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, isAxis int) (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 if len(mappingList) > 1 { item.IsAxis = v.IsAxis } } 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 && isAxis == 1 { 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 == 2 && isAxis == 0 { // 右轴数据处理，只要最新一年 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 } newDataList := make([]*data_manage.EdbDataList, 0) for _, v := range dataList { dataTime, e := time.Parse(utils.FormatDate, v.DataTime) if e != nil { err = errors.New("季节性图处理右轴指标数据转换日期失败,Err:" + e.Error()) return } if dataTime.Year() == latestDate.Year() { newDataList = append(newDataList, v) } } item.DataList = newDataList } else if chartType == 7 || chartType == utils.CHART_TYPE_RADAR { //柱方图 //item.DataList = dataList } else { item.DataList = dataList } edbList = append(edbList, item) } return } // GetChartEdbDataV2 获取图表的指标数据 func GetChartEdbDataV2(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string, chartInfoData ChartInfoDataShow) (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 6: var tmpConfig data_manage.ChartTimeCombineExtraConf if extraConfigStr != `` { err = json.Unmarshal([]byte(extraConfigStr), &tmpConfig) if err != nil { errMsg = "雷达图配置异常" err = errors.New(errMsg) return } } extraConfig = tmpConfig 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 case utils.CHART_TYPE_SECTION_COMBINE: // 预览和详情都走这个接口 var sectionExtraConfig data_manage.ChartSectionAllExtraConf if extraConfigStr == `` { errMsg = "截面组合图未配置" err = errors.New(errMsg) return } if chartInfoId > 0 { var sectionExtraConfigTmp data_manage.ChartSectionExtraConf err = json.Unmarshal([]byte(extraConfigStr), §ionExtraConfigTmp) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg) return } sectionExtraConfig.XDataList = sectionExtraConfigTmp.XDataList sectionExtraConfig.BaseChartSeriesName = sectionExtraConfigTmp.BaseChartSeriesName sectionExtraConfig.UnitList = sectionExtraConfigTmp.UnitList sectionExtraConfig.DateConfList = sectionExtraConfigTmp.DateConfList sectionExtraConfig.IsHeap = sectionExtraConfigTmp.IsHeap sectionExtraConfig.SortType = sectionExtraConfigTmp.SortType // 查询所有的seriesEdb seriesEdbList, e := data_manage.GetChartSeriesEdbByChartInfoId(chartInfoId) if e != nil { errMsg = "查询seriesEdb失败" err = errors.New(errMsg + e.Error()) return } // todo 是否有必要返回单位信息 // 组装成map seriesEdbMap := make(map[int][]*data_manage.ChartSectionSeriesEdbConf) for _, v := range seriesEdbList { var dateConf *data_manage.ChartSectionSeriesDateConfItem if v.DateConf != "" { err = json.Unmarshal([]byte(v.DateConf), &dateConf) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg + err.Error()) return } } tmp := &data_manage.ChartSectionSeriesEdbConf{ ChartSeriesEdbMappingId: v.ChartSeriesEdbMappingId, ChartSeriesId: v.ChartSeriesId, //ChartInfoId: v.ChartInfoId, EdbInfoId: v.EdbInfoId, DateConf: dateConf, EdbName: "", EdbNameEn: "", Unit: "", UnitEn: "", DateConfName: v.DateConfName, DateConfType: v.DateConfType, } seriesEdbMap[v.ChartSeriesId] = append(seriesEdbMap[v.ChartSeriesId], tmp) } //查询series seriesListTmp, e := data_manage.GetChartSeriesByChartInfoId(chartInfoId) if e != nil { errMsg = "查询series失败" err = errors.New(errMsg + e.Error()) return } seriesList := make([]*data_manage.ChartSectionSeriesItem, 0) for _, v := range seriesListTmp { tmpSeries := &data_manage.ChartSectionSeriesItem{ ChartSeriesId: v.ChartSeriesId, SeriesName: v.SeriesName, SeriesNameEn: v.SeriesNameEn, ChartStyle: v.ChartStyle, ChartColor: v.ChartColor, ChartWidth: v.ChartWidth, IsPoint: v.IsPoint, IsNumber: v.IsNumber, IsAxis: v.IsAxis, MaxData: v.MaxData, MinData: v.MinData, //IsOrder: false, EdbInfoList: nil, DataList: nil, } edbInfoList, ok := seriesEdbMap[v.ChartSeriesId] if ok { tmpSeries.EdbInfoList = edbInfoList } seriesList = append(seriesList, tmpSeries) } sectionExtraConfig.SeriesList = seriesList } else { err = json.Unmarshal([]byte(extraConfigStr), §ionExtraConfig) if err != nil { errMsg = "截面组合图配置异常" err = errors.New(errMsg) return } } //校验引用日期名称是否重复 dateNameMap := make(map[string]int) dateNameEnMap := make(map[string]int) for _, v := range sectionExtraConfig.DateConfList { if _, ok := dateNameMap[v.DateConfName]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfName) return } if _, ok := dateNameEnMap[v.DateConfNameEn]; ok { errMsg = "截面组合图引用日期名称设置重复" err = errors.New(errMsg + v.DateConfNameEn) return } if v.DateConfName != "" { dateNameMap[v.DateConfName] = 1 } if v.DateConfNameEn != "" { dateNameEnMap[v.DateConfNameEn] = 1 } } //检查系列名称是否重复 seriesNameMap := make(map[string]int) seriesNameEnMap := make(map[string]int) for _, v := range sectionExtraConfig.SeriesList { if _, ok := seriesNameMap[v.SeriesName]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesName) return } if _, ok := seriesNameEnMap[v.SeriesNameEn]; ok { errMsg = "截面组合图系列名称设置重复" err = errors.New(errMsg + v.SeriesNameEn) return } if v.SeriesName != "" { seriesNameMap[v.SeriesName] = 1 } if v.SeriesNameEn != "" { seriesNameEnMap[v.SeriesNameEn] = 1 } } // 检查基准系列是否设置 if sectionExtraConfig.BaseChartSeriesName == "" { errMsg = "截面组合图基准系列名称未设置" err = errors.New(errMsg) return } //todo 如果是详情接口，应该要从其他表里查询配置 extraConfig = sectionExtraConfig default: xEdbIdValue = make([]int, 0) yDataList = make([]data_manage.YData, 0) } // 指标对应的所有数据 edbDataListMap, edbList, err := chartInfoData.GetEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig) if err != nil { return } // 特殊图形数据处理 switch chartType { case 6: //时序组合图 //判断是否堆积 timeConf := extraConfig.(data_manage.ChartTimeCombineExtraConf) if extraConfigStr == "" { //历史数据，默认开启堆积 timeConf = data_manage.ChartTimeCombineExtraConf{ IsHeap: 1, } } dataResp = data_manage.ChartTimeCombineDataResp{IsHeap: timeConf.IsHeap} case 2: // 季节性图 if seasonExtraConfig != "" { // 季节性图计算不管图上数据时间，拿所有数据 _, tempEdbList, e := getEdbDataMapList(chartInfoId, chartType, calendar, "1990-01-01", "", mappingList, seasonExtraConfig) if e != nil { err = e return } dataResp, err = SeasonChartData(tempEdbList, seasonExtraConfig) } else { // 兼容无配置的老图 dataResp = new(data_manage.SeasonChartResp) } 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) case utils.CHART_TYPE_SECTION_COMBINE: // 截面组合图 sectionConf := extraConfig.(data_manage.ChartSectionAllExtraConf) var chartInfo *data_manage.ChartInfo if chartInfoId > 0 { chartInfo, err = data_manage.GetChartInfoById(chartInfoId) if err != nil { errMsg = "获取图表信息失败" return } } xEdbIdValue, dataResp, err = GetChartSectionCombineData(chartInfo, mappingList, edbDataListMap, sectionConf) // 这个数据没有必要返回给前端 for _, v := range edbList { v.DataList = nil } } return } // SeasonChartData 季节性图的数据处理 func SeasonChartData(dataList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string) (dataResp data_manage.SeasonChartResp, err error) { var seasonConfig data_manage.SeasonExtraItem err = json.Unmarshal([]byte(seasonExtraConfig), &seasonConfig) if err != nil { err = errors.New("季节性图配置异常, Err:" + err.Error()) return } for _, mappingItem := range dataList { if mappingItem.IsAxis == 0 { continue } quarterDataList, ok := mappingItem.DataList.(data_manage.QuarterDataList) if !ok { continue } // 上下限区间 if seasonConfig.MaxMinLimits.Year > 0 { startYear := time.Now().AddDate(-seasonConfig.MaxMinLimits.Year, 0, 0).Year() dataResp.MaxMinLimits.List = make([]*data_manage.MaxMinLimitsData, 0) dataTimeMap := make(map[time.Time]time.Time) dataTimeList := make([]string, 0) maxValueMap := make(map[time.Time]float64) minValueMap := make(map[time.Time]float64) maxMinDataList := make([]*data_manage.MaxMinLimitsData, 0) var startDateStr string var endDateStr string var newDate time.Time startDateStr = fmt.Sprintf("%d-%s", time.Now().Year(), seasonConfig.XStartDate) endDateStr = fmt.Sprintf("%d-%s", time.Now().Year(), seasonConfig.XEndDate) startDate, e := time.Parse(utils.FormatDate, startDateStr) if e != nil { err = e return } endDate, e := time.Parse(utils.FormatDate, endDateStr) if e != nil { err = e return } // 日度 周度插值 for _, v := range quarterDataList { if mappingItem.Frequency == "日度" || mappingItem.Frequency == "周度" { handleDataMap := make(map[string]float64) dataTimeList, _, err = HandleDataByLinearRegressionToList(v.DataList, handleDataMap) if err != nil { err = errors.New("插值处理数据异常, Err:" + err.Error()) return } // 不包含当年 if v.ChartLegend == strconv.Itoa(time.Now().Year()) { continue } for _, date := range dataTimeList { dateTime, e := time.Parse(utils.FormatDate, date) if e != nil { err = errors.New("时间格式化异常, Err:" + e.Error()) return } if dateTime.Year() < startYear { continue } // 不包含2月29号 if dateTime.Month() == 2 && dateTime.Day() == 29 { continue } newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0) if seasonConfig.JumpYear == 1 { if startDate.After(endDate) { // 如果跨年且不到一年 // 全年截取一部分 if newDate.Before(startDate.AddDate(0, 0, 1)) && newDate.After(endDate) { continue } if newDate.After(startDate.AddDate(0, 0, -1)) { // 减一年 newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year()-1, 0, 0) } // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < handleDataMap[date] { maxValueMap[newDate] = handleDataMap[date] } } else { maxValueMap[newDate] = handleDataMap[date] } if value, ok := minValueMap[newDate]; ok { if value > handleDataMap[date] { minValueMap[newDate] = handleDataMap[date] } } else { minValueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate } else { // 如果跨年且大于等于一年 // double后截取 if newDate.After(startDate) { // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < handleDataMap[date] { maxValueMap[newDate] = handleDataMap[date] } } else { maxValueMap[newDate] = handleDataMap[date] } if value, ok := minValueMap[newDate]; ok { if value > handleDataMap[date] { minValueMap[newDate] = handleDataMap[date] } } else { minValueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate } newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year()+1, 0, 0) newEndDate := endDate.AddDate(1, 0, 0) if newDate.Before(newEndDate) { // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < handleDataMap[date] { maxValueMap[newDate] = handleDataMap[date] } } else { maxValueMap[newDate] = handleDataMap[date] } if value, ok := minValueMap[newDate]; ok { if value > handleDataMap[date] { minValueMap[newDate] = handleDataMap[date] } } else { minValueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate } } } else { // 如果不跨年 正常获取 // 获取当前日期所在区间 // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < handleDataMap[date] { maxValueMap[newDate] = handleDataMap[date] } } else { maxValueMap[newDate] = handleDataMap[date] } if value, ok := minValueMap[newDate]; ok { if value > handleDataMap[date] { minValueMap[newDate] = handleDataMap[date] } } else { minValueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate } } } else { // 旬度、月度、季度、半年度 不插值，需要先把日期列表和数据map取出来 for _, vv := range v.DataList { dateTime, e := time.Parse(utils.FormatDate, vv.DataTime) if e != nil { err = errors.New("时间格式化异常, Err:" + e.Error()) return } // 不包含当年 if v.ChartLegend == strconv.Itoa(time.Now().Year()) { continue } if dateTime.Year() < startYear { continue } // 月度的2月29号日期改为2月28日 if dateTime.Month() == 2 && dateTime.Day() == 29 { dateTime = dateTime.AddDate(0, 0, -1) } newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0) if seasonConfig.JumpYear == 1 { if startDate.After(endDate) { // 如果跨年且不到一年 // 全年截取一部分 if newDate.Before(startDate.AddDate(0, 0, 1)) && newDate.After(endDate) { continue } if newDate.After(startDate.AddDate(0, 0, -1)) { // 减一年 newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year()-1, 0, 0) } // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < vv.Value { maxValueMap[newDate] = vv.Value } } else { maxValueMap[newDate] = vv.Value } if value, ok := minValueMap[newDate]; ok { if value > vv.Value { minValueMap[newDate] = vv.Value } } else { minValueMap[newDate] = vv.Value } dataTimeMap[newDate] = newDate } else { // 如果跨年且大于等于一年 // double后截取 if newDate.After(startDate) { // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < vv.Value { maxValueMap[newDate] = vv.Value } } else { maxValueMap[newDate] = vv.Value } if value, ok := minValueMap[newDate]; ok { if value > vv.Value { minValueMap[newDate] = vv.Value } } else { minValueMap[newDate] = vv.Value } dataTimeMap[newDate] = newDate } newDate = dateTime.AddDate(time.Now().Year()-dateTime.Year()+1, 0, 0) newEndDate := endDate.AddDate(1, 0, 0) if newDate.Before(newEndDate) { // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < vv.Value { maxValueMap[newDate] = vv.Value } } else { maxValueMap[newDate] = vv.Value } if value, ok := minValueMap[newDate]; ok { if value > vv.Value { minValueMap[newDate] = vv.Value } } else { minValueMap[newDate] = vv.Value } dataTimeMap[newDate] = newDate } } } else { // 如果不跨年 正常获取 // 获取当前日期所在区间 // 处理上下限列表 if value, ok := maxValueMap[newDate]; ok { if value < vv.Value { maxValueMap[newDate] = vv.Value } } else { maxValueMap[newDate] = vv.Value } if value, ok := minValueMap[newDate]; ok { if value > vv.Value { minValueMap[newDate] = vv.Value } } else { minValueMap[newDate] = vv.Value } dataTimeMap[newDate] = newDate } } } } for _, v := range dataTimeMap { maxMinItem := &data_manage.MaxMinLimitsData{} if maxValue, ok := maxValueMap[v]; ok { maxMinItem.MaxValue = maxValue } else { maxMinItem.MaxValue = minValueMap[v] } if minValue, ok := minValueMap[v]; ok { maxMinItem.MinValue = minValue } else { maxMinItem.MinValue = maxValueMap[v] } maxMinItem.DataTime = v.Format(utils.FormatDate) maxMinItem.DataTimestamp = v.UnixNano() / 1e6 maxMinDataList = append(maxMinDataList, maxMinItem) } // 排序 sort.Slice(maxMinDataList, func(i, j int) bool { return maxMinDataList[i].DataTime < maxMinDataList[j].DataTime }) dataResp.MaxMinLimits.List = maxMinDataList dataResp.MaxMinLimits.Color = seasonConfig.MaxMinLimits.Color dataResp.MaxMinLimits.Legend = seasonConfig.MaxMinLimits.Legend dataResp.MaxMinLimits.IsShow = seasonConfig.MaxMinLimits.IsShow dataResp.MaxMinLimits.IsAdd = seasonConfig.MaxMinLimits.IsAdd dataResp.MaxMinLimits.Year = seasonConfig.MaxMinLimits.Year } // 自定义同期均线 if seasonConfig.SamePeriodAverage.Year > 0 { handleDataMap := make(map[string]float64) dataTimeMap := make(map[time.Time]time.Time) dataTimeList := make([]string, 0) valueMap := make(map[time.Time]float64) averageDataList := make([]*data_manage.SamePeriodAverageData, 0) for i := len(quarterDataList) - 1; i >= 0; i-- { // 插值成日度 dataTimeList, _, err = HandleDataByLinearRegressionToList(quarterDataList[i].DataList, handleDataMap) if err != nil { err = errors.New("插值处理数据异常, Err:" + err.Error()) return } for _, date := range dataTimeList { dateTime, e := time.Parse(utils.FormatDate, date) if e != nil { err = errors.New("时间格式化异常, Err:" + e.Error()) return } startYear := time.Now().AddDate(-seasonConfig.SamePeriodAverage.Year, 0, 0).Year() if dateTime.Year() < startYear { continue } // 不包含2月29号 if dateTime.Month() == 2 && dateTime.Day() == 29 { continue } // 不包含当年 if quarterDataList[i].ChartLegend == strconv.Itoa(time.Now().Year()) { continue } newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0) // 处理均值 if value, ok := valueMap[newDate]; ok { valueMap[newDate] = (handleDataMap[date] + value) / 2 } else { valueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate } } for _, v := range dataTimeMap { averageItem := &data_manage.SamePeriodAverageData{} if value, ok := valueMap[v]; ok { averageItem.Value = value } averageItem.DataTime = v.Format(utils.FormatDate) averageItem.DataTimestamp = v.UnixNano() / 1e6 averageDataList = append(averageDataList, averageItem) } // 排序 sort.Slice(averageDataList, func(i, j int) bool { return averageDataList[i].DataTime < averageDataList[j].DataTime }) dataResp.SamePeriodAverage.List = averageDataList dataResp.SamePeriodAverage.Year = seasonConfig.SamePeriodAverage.Year dataResp.SamePeriodAverage.Color = seasonConfig.SamePeriodAverage.Color dataResp.SamePeriodAverage.Legend = seasonConfig.SamePeriodAverage.Legend dataResp.SamePeriodAverage.IsShow = seasonConfig.SamePeriodAverage.IsShow dataResp.SamePeriodAverage.LineType = seasonConfig.SamePeriodAverage.LineType dataResp.SamePeriodAverage.LineWidth = seasonConfig.SamePeriodAverage.LineWidth dataResp.SamePeriodAverage.IsAdd = seasonConfig.SamePeriodAverage.IsAdd } // 自定义同期标准差 if seasonConfig.SamePeriodStandardDeviation.Year > 1 && seasonConfig.SamePeriodStandardDeviation.Multiple > 0 { startYear := time.Now().AddDate(-seasonConfig.SamePeriodStandardDeviation.Year, 0, 0).Year() // 先算均值，再算标准差 handleDataMap := make(map[string]float64) dataTimeMap := make(map[time.Time]time.Time) dataTimeValueMap := make(map[time.Time][]float64) dataTimeList := make([]string, 0) valueMap := make(map[time.Time]float64) samePeriodStandardDeviationList := make([]*data_manage.MaxMinLimitsData, 0) for i := len(quarterDataList) - 1; i > len(quarterDataList)-seasonConfig.SamePeriodAverage.Year-1 && i > 0; i-- { // 插值成日度 dataTimeList, _, err = HandleDataByLinearRegressionToListV2(quarterDataList[i].DataList, handleDataMap) if err != nil { err = errors.New("插值处理数据异常, Err:" + err.Error()) return } for _, date := range dataTimeList { dateTime, e := time.Parse(utils.FormatDate, date) if e != nil { err = errors.New("时间格式化异常, Err:" + e.Error()) return } if dateTime.Year() < startYear { continue } // 不包含2月29号 if dateTime.Month() == 2 && dateTime.Day() == 29 { continue } newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0) // 处理均值 if value, ok := valueMap[newDate]; ok { valueMap[newDate] = (handleDataMap[date] + value) / 2 } else { valueMap[newDate] = handleDataMap[date] } dataTimeMap[newDate] = newDate valueList := dataTimeValueMap[newDate] valueList = append(valueList, handleDataMap[date]) dataTimeValueMap[newDate] = valueList } } for _, v := range dataTimeMap { valueList := dataTimeValueMap[v] stdev := utils.CalculateStandardDeviation(valueList) stdev, _ = decimal.NewFromFloat(stdev).Round(4).Float64() maxMinItem := &data_manage.MaxMinLimitsData{} if value, ok := valueMap[v]; ok { maxMinItem.MaxValue = value + stdev*seasonConfig.SamePeriodStandardDeviation.Multiple maxMinItem.MinValue = value - stdev*seasonConfig.SamePeriodStandardDeviation.Multiple } maxMinItem.DataTime = v.Format(utils.FormatDate) maxMinItem.DataTimestamp = v.UnixNano() / 1e6 samePeriodStandardDeviationList = append(samePeriodStandardDeviationList, maxMinItem) } // 排序 sort.Slice(samePeriodStandardDeviationList, func(i, j int) bool { return samePeriodStandardDeviationList[i].DataTime < samePeriodStandardDeviationList[j].DataTime }) dataResp.SamePeriodStandardDeviation.List = samePeriodStandardDeviationList dataResp.SamePeriodStandardDeviation.Color = seasonConfig.SamePeriodStandardDeviation.Color dataResp.SamePeriodStandardDeviation.Legend = seasonConfig.SamePeriodStandardDeviation.Legend dataResp.SamePeriodStandardDeviation.IsShow = seasonConfig.SamePeriodStandardDeviation.IsShow dataResp.SamePeriodStandardDeviation.Multiple = seasonConfig.SamePeriodStandardDeviation.Multiple dataResp.SamePeriodStandardDeviation.Year = seasonConfig.SamePeriodStandardDeviation.Year dataResp.SamePeriodStandardDeviation.IsAdd = seasonConfig.SamePeriodStandardDeviation.IsAdd } // 自定义右轴 if seasonConfig.RightAxis.IndicatorType != 0 { if seasonConfig.RightAxis.IndicatorType == 1 { startTime, _ := time.Parse(utils.FormatDate, mappingItem.StartDate) for i := len(quarterDataList) - 1; i > len(quarterDataList)-2 && i > 0; i-- { var rightMappingItem data_manage.ChartEdbInfoMapping rightMappingItem = *mappingItem // 计算同比值 tbzDataList, minValue, maxValue, e := GetEdbDataTbzForSeason(mappingItem.Frequency, quarterDataList[i].DataList, startTime) if e != nil { err = errors.New("计算同比值失败, Err:" + e.Error()) return } rightMappingItem.DataList = tbzDataList rightMappingItem.MaxData = maxValue rightMappingItem.MinData = minValue dataResp.RightAxis.EdbInfoList = append(dataResp.RightAxis.EdbInfoList, &rightMappingItem) } } dataResp.RightAxis.SeasonRightAxis = seasonConfig.RightAxis } } return } // 计算百分位对应的值 func PercentileAlgorithm(x float64, data []float64) float64 { N := float64(len(data)) n := (x / 100) * (N - 1) // 如果n是整数，则直接返回第n个数值 if n == float64(int(n)) { return data[int(n)-1] } // 如果n是小数，执行插值 nInt := int(n) e := n - float64(nInt) // 取出相邻的两个数值 Sn := data[nInt-1] Sn1 := data[nInt] // 计算插值结果 y := Sn + e*(Sn1-Sn) return y } // HandleDateChange 处理日期变换 func HandleDateChange(date string, edbDateConf data_manage.EdbDateChangeConf) (newDate string, err error) { newDate = date if newDate != "" { if len(edbDateConf.DateChange) > 0 { var dateTime time.Time dateTime, err = time.ParseInLocation(utils.FormatDate, newDate, time.Local) if err != nil { err = fmt.Errorf("日期解析失败: %s", err.Error()) return } for _, v := range edbDateConf.DateChange { if v.ChangeType == 1 { dateTime = dateTime.AddDate(v.Year, v.Month, v.Day) newDate = dateTime.Format(utils.FormatDate) } else if v.ChangeType == 2 { newDate, err, _ = handleSystemAppointDateT2(dateTime, v.FrequencyDay, v.Frequency) if err != nil { return } dateTime, err = time.ParseInLocation(utils.FormatDate, newDate, time.Local) if err != nil { err = fmt.Errorf("日期解析失败: %s", err.Error()) return } } } } } return } // handleSystemAppointDateT // @Description: 处理系统日期相关的指定频率（所在周/旬/月/季/半年/年的最后/最早一天） // @author: Roc // @datetime2023-10-27 09:31:35 // @param Frequency string // @param Day string // @return date string // @return err error // @return errMsg string func handleSystemAppointDateT2(currDate time.Time, appointDay, frequency string) (date string, err error, errMsg string) { //currDate := time.Now() switch frequency { case "本周": day := int(currDate.Weekday()) if day == 0 { // 周日 day = 7 } num := 0 switch appointDay { case "周一": num = 1 case "周二": num = 2 case "周三": num = 3 case "周四": num = 4 case "周五": num = 5 case "周六": num = 6 case "周日": num = 7 } day = num - day date = currDate.AddDate(0, 0, day).Format(utils.FormatDate) case "本旬": day := currDate.Day() var tmpDate time.Time switch appointDay { case "第一天": if day <= 10 { tmpDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, currDate.Location()) } else if day <= 20 { tmpDate = time.Date(currDate.Year(), currDate.Month(), 11, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), currDate.Month(), 21, 0, 0, 0, 0, currDate.Location()) } case "最后一天": if day <= 10 { tmpDate = time.Date(currDate.Year(), currDate.Month(), 10, 0, 0, 0, 0, currDate.Location()) } else if day <= 20 { tmpDate = time.Date(currDate.Year(), currDate.Month(), 20, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), currDate.Month()+1, 1, 0, 0, 0, 0, currDate.Location()).AddDate(0, 0, -1) } } date = tmpDate.Format(utils.FormatDate) case "本月": var tmpDate time.Time switch appointDay { case "第一天": tmpDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, currDate.Location()) case "最后一天": tmpDate = time.Date(currDate.Year(), currDate.Month()+1, 1, 0, 0, 0, 0, currDate.Location()).AddDate(0, 0, -1) } date = tmpDate.Format(utils.FormatDate) case "本季": month := currDate.Month() var tmpDate time.Time switch appointDay { case "第一天": if month <= 3 { tmpDate = time.Date(currDate.Year(), 1, 1, 0, 0, 0, 0, currDate.Location()) } else if month <= 6 { tmpDate = time.Date(currDate.Year(), 4, 1, 0, 0, 0, 0, currDate.Location()) } else if month <= 9 { tmpDate = time.Date(currDate.Year(), 7, 1, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), 10, 1, 0, 0, 0, 0, currDate.Location()) } case "最后一天": if month <= 3 { tmpDate = time.Date(currDate.Year(), 3, 31, 0, 0, 0, 0, currDate.Location()) } else if month <= 6 { tmpDate = time.Date(currDate.Year(), 6, 30, 0, 0, 0, 0, currDate.Location()) } else if month <= 9 { tmpDate = time.Date(currDate.Year(), 9, 30, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), 12, 31, 0, 0, 0, 0, currDate.Location()) } } date = tmpDate.Format(utils.FormatDate) case "本半年": month := currDate.Month() var tmpDate time.Time switch appointDay { case "第一天": if month <= 6 { tmpDate = time.Date(currDate.Year(), 1, 1, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), 7, 1, 0, 0, 0, 0, currDate.Location()) } case "最后一天": if month <= 6 { tmpDate = time.Date(currDate.Year(), 6, 30, 0, 0, 0, 0, currDate.Location()) } else { tmpDate = time.Date(currDate.Year(), 12, 31, 0, 0, 0, 0, currDate.Location()) } } date = tmpDate.Format(utils.FormatDate) case "本年": var tmpDate time.Time switch appointDay { case "第一天": tmpDate = time.Date(currDate.Year(), 1, 1, 0, 0, 0, 0, currDate.Location()) case "最后一天": tmpDate = time.Date(currDate.Year(), 12, 31, 0, 0, 0, 0, currDate.Location()) } date = tmpDate.Format(utils.FormatDate) default: errMsg = "错误的日期频度：" + frequency err = errors.New(errMsg) return } return }