package data import ( "encoding/json" "errors" "fmt" "github.com/shopspring/decimal" "github.com/yidane/formula" "hongze/hz_crm_api/models/data_manage" "hongze/hz_crm_api/models/data_manage/request" "hongze/hz_crm_api/models/system" "hongze/hz_crm_api/utils" "strconv" "strings" "time" ) // AddPredictEdbInfo 新增预测指标 func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList []request.RuleConfig, sysUserId int, sysUserName, requestBody, requestUrl string) (edbInfo *data_manage.EdbInfo, err error, errMsg string) { var sourceEdbInfo *data_manage.EdbInfo // 来源指标信息校验 { sourceEdbInfo, err = data_manage.GetEdbInfoById(sourceEdbInfoId) if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "新增失败" err = errors.New("获取来源指标失败，Err:" + err.Error()) return } if sourceEdbInfo == nil { errMsg = "找不到该来源指标" err = nil return } //必须是普通的指标 if sourceEdbInfo.EdbInfoType != 0 { errMsg = "来源指标异常，不是普通的指标" return } if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, sourceEdbInfo.Frequency) { errMsg = "预测指标只支持选择日度、周度、月度的指标" return } } var classifyInfo *data_manage.EdbClassify // 来源分类信息校验 { classifyInfo, err = data_manage.GetEdbClassifyById(classifyId) if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "新增失败" err = errors.New("获取预测指标分类失败，Err:" + err.Error()) return } if classifyInfo == nil { errMsg = "找不到该预测指标分类" err = nil return } //必须是预测指标分类 if classifyInfo.ClassifyType != 1 { errMsg = "预测指标分类异常，不是预测指标分类" return } } edbName = strings.Trim(edbName, " ") edbCode := sourceEdbInfo.EdbCode + "_" + time.Now().Format(utils.FormatShortDateTimeUnSpace) // 判断该来源指标是否已经被引用了 { //predictEdbConf, tmpErr := data_manage.GetPredictEdbConfBySourceEdbInfoId(sourceEdbInfoId) //if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { // errMsg = "新增失败" // err = tmpErr // return //} // 如果该来源指标已经被引用了，那么不允许再次使用 //if predictEdbConf != nil { // //获取预测指标详情 // predictEdbInfo, tmpErr := data_manage.GetEdbInfoById(predictEdbConf.PredictEdbInfoId) // if tmpErr != nil { // errMsg = "新增失败" // err = tmpErr // return // } // //获取预测指标的分类 // edbClassifyInfo, tmpErr := data_manage.GetEdbClassifyById(predictEdbInfo.ClassifyId) // if tmpErr != nil { // errMsg = "新增失败" // err = tmpErr // return // } // errMsg = "该指标已存在数据库，目录为：" + edbClassifyInfo.ClassifyName + "，请重新选择指标" // err = errors.New(errMsg) // return //} } //判断指标名称是否存在 var condition string var pars []interface{} condition += " AND edb_info_type=? " pars = append(pars, 1) condition += " AND edb_name=? " pars = append(pars, edbName) count, err := data_manage.GetEdbInfoCountByCondition(condition, pars) if err != nil { errMsg = "判断指标名称是否存在失败" err = errors.New("判断指标名称是否存在失败,Err:" + err.Error()) return } if count > 0 { errMsg = "指标名称已存在，请重新填写" return } timestamp := strconv.FormatInt(time.Now().UnixNano(), 10) edbInfo = &data_manage.EdbInfo{ //EdbInfoId: 0, EdbInfoType: 1, SourceName: "预测指标", Source: utils.DATA_SOURCE_PREDICT, EdbCode: edbCode, EdbName: edbName, EdbNameSource: edbName, Frequency: sourceEdbInfo.Frequency, Unit: sourceEdbInfo.Unit, StartDate: sourceEdbInfo.StartDate, ClassifyId: classifyId, SysUserId: sysUserId, SysUserRealName: sysUserName, UniqueCode: utils.MD5(utils.DATA_PREFIX + "_" + timestamp), CreateTime: time.Now(), ModifyTime: time.Now(), MinValue: sourceEdbInfo.MinValue, MaxValue: sourceEdbInfo.MaxValue, CalculateFormula: sourceEdbInfo.CalculateFormula, EdbType: 1, //Sort: sourceEdbInfo., LatestDate: sourceEdbInfo.LatestDate, LatestValue: sourceEdbInfo.LatestValue, MoveType: sourceEdbInfo.MoveType, MoveFrequency: sourceEdbInfo.MoveFrequency, NoUpdate: sourceEdbInfo.NoUpdate, ServerUrl: "", } // 关联关系表 calculateMappingList := make([]*data_manage.EdbInfoCalculateMapping, 0) fromEdbMap := make(map[int]int) // 源指标关联关系表 calculateMappingItem := &data_manage.EdbInfoCalculateMapping{ //EdbInfoCalculateMappingId: 0, //EdbInfoId: 0, Source: edbInfo.Source, SourceName: edbInfo.SourceName, EdbCode: edbInfo.EdbCode, FromEdbInfoId: sourceEdbInfo.EdbInfoId, FromEdbCode: sourceEdbInfo.EdbCode, FromEdbName: sourceEdbInfo.EdbName, FromSource: sourceEdbInfo.Source, FromSourceName: sourceEdbInfo.SourceName, //FromTag: "", Sort: 1, CreateTime: time.Now(), ModifyTime: time.Now(), } fromEdbMap[sourceEdbInfoId] = sourceEdbInfoId calculateMappingList = append(calculateMappingList, calculateMappingItem) // 预测指标配置 predictEdbConfList := make([]*data_manage.PredictEdbConf, 0) for _, v := range ruleList { // 预测指标配置 ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local) if tmpErr != nil { errMsg = "规则配置的截止日期异常，请重新填写" return } // 没有数据，自己瞎测试 //switch v.RuleType { //case 3: //3：同比 // v.Value = "0.1" //case 4: //4：同差 // v.Value = "10" //case 5: //5：环比 // v.Value = "0.1" //case 6: //6：环差 // v.Value = "0.1" //case 7: //7：N期移动均值 // v.Value = "5" //case 8: //8：N期段线性外推值 // v.Value = "5" //} switch v.RuleType { case 8: //N期段线性外推值 valInt, tmpErr := strconv.Atoi(v.Value) if tmpErr != nil { errMsg = "N期段线性外推值的N值异常" return } if valInt <= 1 { errMsg = "N期段线性外推值的N值必须大于1" return } case 9: //9：动态环差 for _, v := range v.EdbInfoIdArr { fromEdbMap[v.EdbInfoId] = v.EdbInfoId } } tmpPredictEdbConf := &data_manage.PredictEdbConf{ PredictEdbInfoId: 0, SourceEdbInfoId: sourceEdbInfoId, RuleType: v.RuleType, //FixedValue: v.Value, Value: v.Value, EndDate: ruleEndDate, ModifyTime: time.Now(), CreateTime: time.Now(), } edbInfo.EndDate = v.EndDate predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf) } err = data_manage.AddPredictEdb(edbInfo, calculateMappingItem, predictEdbConfList) if err != nil { errMsg = "保存失败" err = errors.New("保存失败，Err:" + err.Error()) return } //新增操作日志 { edbLog := new(data_manage.EdbInfoLog) edbLog.EdbInfoId = edbInfo.EdbInfoId edbLog.SourceName = edbInfo.SourceName edbLog.Source = edbInfo.Source edbLog.EdbCode = edbInfo.EdbCode edbLog.EdbName = edbInfo.EdbName edbLog.ClassifyId = edbInfo.ClassifyId edbLog.SysUserId = sysUserId edbLog.SysUserRealName = sysUserName edbLog.CreateTime = time.Now() edbLog.Content = requestBody edbLog.Status = "新增指标" edbLog.Method = requestUrl go data_manage.AddEdbInfoLog(edbLog) } //添加es AddOrEditEdbInfoToEs(edbInfo.EdbInfoId) return } // EditPredictEdbInfo 编辑预测指标 func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []request.RuleConfig, sysUserId int, sysUserName, requestBody, requestUrl string) (edbInfo *data_manage.EdbInfo, err error, errMsg string) { // 指标信息校验 { edbInfo, err = data_manage.GetEdbInfoById(edbInfoId) if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "修改失败" err = errors.New("获取预测指标失败，Err:" + err.Error()) return } if edbInfo == nil { errMsg = "找不到该预测指标" err = nil return } //必须是普通的指标 if edbInfo.EdbInfoType != 1 { errMsg = "指标异常，不是预测指标" return } } var predictEdbConf *data_manage.PredictEdbConf // 指标配置信息校验 { // 查找该预测指标配置 predictEdbConfList, tmpErr := data_manage.GetPredictEdbConfListById(edbInfo.EdbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "修改失败" err = errors.New("获取预测指标配置信息失败，Err:" + tmpErr.Error()) return } if len(predictEdbConfList) == 0 { errMsg = "找不到该预测指标配置" err = nil return } predictEdbConf = predictEdbConfList[0] } //判断指标名称是否存在 var condition string var pars []interface{} condition += " AND edb_info_id<>? " pars = append(pars, edbInfoId) condition += " AND edb_info_type=? " pars = append(pars, 1) condition += " AND edb_name=? " pars = append(pars, edbName) count, err := data_manage.GetEdbInfoCountByCondition(condition, pars) if err != nil { errMsg = "判断指标名称是否存在失败" err = errors.New("判断指标名称是否存在失败,Err:" + err.Error()) return } if count > 0 { errMsg = "指标名称已存在，请重新填写" return } edbInfo.EdbName = edbName edbInfo.EdbNameSource = edbName edbInfo.ClassifyId = classifyId edbInfo.ModifyTime = time.Now() updateEdbInfoCol := []string{"EdbName", "EdbNameSource", "ClassifyId", "EndDate", "ModifyTime"} // 预测指标配置 predictEdbConfList := make([]*data_manage.PredictEdbConf, 0) for _, v := range ruleList { // 预测指标配置 ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local) if tmpErr != nil { errMsg = "规则配置的截止日期异常，请重新填写" return } switch v.RuleType { case 8: //N期段线性外推值 valInt, tmpErr := strconv.Atoi(v.Value) if tmpErr != nil { errMsg = "N期段线性外推值的N值异常" return } if valInt <= 1 { errMsg = "N期段线性外推值的N值必须大于1" return } case 9: //9：动态环差 } tmpPredictEdbConf := &data_manage.PredictEdbConf{ PredictEdbInfoId: edbInfoId, SourceEdbInfoId: predictEdbConf.SourceEdbInfoId, RuleType: v.RuleType, //FixedValue: v.Value, Value: v.Value, EndDate: ruleEndDate, ModifyTime: time.Now(), CreateTime: time.Now(), } predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf) edbInfo.EndDate = v.EndDate } err = data_manage.EditPredictEdb(edbInfo, predictEdbConfList, updateEdbInfoCol) if err != nil { errMsg = "保存失败" err = errors.New("保存失败，Err:" + err.Error()) return } //新增操作日志 { edbLog := new(data_manage.EdbInfoLog) edbLog.EdbInfoId = edbInfo.EdbInfoId edbLog.SourceName = edbInfo.SourceName edbLog.Source = edbInfo.Source edbLog.EdbCode = edbInfo.EdbCode edbLog.EdbName = edbInfo.EdbName edbLog.ClassifyId = edbInfo.ClassifyId edbLog.SysUserId = sysUserId edbLog.SysUserRealName = sysUserName edbLog.CreateTime = time.Now() edbLog.Content = requestBody edbLog.Status = "编辑指标" edbLog.Method = requestUrl go data_manage.AddEdbInfoLog(edbLog) } //添加es AddOrEditEdbInfoToEs(edbInfoId) // 刷新关联指标 go EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, true) return } // RefreshPredictEdbInfo 刷新预测指标 func RefreshPredictEdbInfo(edbInfoId int, refreshAll bool) (edbInfo *data_manage.EdbInfo, err error, errMsg string) { // 指标信息校验 { edbInfo, err = data_manage.GetEdbInfoById(edbInfoId) if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "刷新失败" err = errors.New("获取预测指标失败，Err:" + err.Error()) return } if edbInfo == nil { errMsg = "找不到该预测指标" err = nil return } //必须是预测的指标 if edbInfo.EdbInfoType != 1 { errMsg = "指标异常，不是预测指标" return } } err = EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, refreshAll) return } // MovePredictEdbInfo 移动预测指标 func MovePredictEdbInfo(edbInfoId, classifyId, prevEdbInfoId, nextEdbInfoId int, sysUser *system.Admin, requestBody, requestUrl string) (err error, errMsg string) { //判断分类是否存在 count, _ := data_manage.GetEdbClassifyCountById(classifyId) if count <= 0 { errMsg = "分类已被删除，不可移动，请刷新页面" return } edbInfo, err := data_manage.GetEdbInfoById(edbInfoId) if err != nil { if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取预测指标失败，Err:" + err.Error()) return } if edbInfo == nil { errMsg = "找不到该预测指标" err = nil return } return } // 移动权限校验 button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType) if !button.MoveButton { errMsg = "无权限操作" err = nil return return } //如果改变了分类，那么移动该指标数据 if edbInfo.ClassifyId != classifyId { err = data_manage.MoveEdbInfo(edbInfoId, classifyId) if err != nil { errMsg = "移动失败" err = errors.New("移动预测指标失败,Err:" + err.Error()) return } } updateCol := make([]string, 0) //如果有传入 上一个兄弟节点分类id if prevEdbInfoId > 0 { prevEdbInfo, tmpErr := data_manage.GetEdbInfoById(prevEdbInfoId) if tmpErr != nil { errMsg = "移动失败" err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + tmpErr.Error()) return } //如果是移动在两个兄弟节点之间 if nextEdbInfoId > 0 { //下一个兄弟节点 nextEdbInfo, tmpErr := data_manage.GetEdbInfoById(nextEdbInfoId) if tmpErr != nil { errMsg = "移动失败" err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + tmpErr.Error()) return } //如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1 if prevEdbInfo.Sort == nextEdbInfo.Sort || prevEdbInfo.Sort == edbInfo.Sort { //变更兄弟节点的排序 updateSortStr := `sort + 2` _ = data_manage.UpdateEdbInfoSortByClassifyId(prevEdbInfo.ClassifyId, prevEdbInfo.Sort, prevEdbInfo.EdbInfoId, updateSortStr) } else { //如果下一个兄弟的排序权重正好是上个兄弟节点 的下一层，那么需要再加一层了 if nextEdbInfo.Sort-prevEdbInfo.Sort == 1 { //变更兄弟节点的排序 updateSortStr := `sort + 1` _ = data_manage.UpdateEdbInfoSortByClassifyId(prevEdbInfo.ClassifyId, prevEdbInfo.Sort, prevEdbInfo.EdbInfoId, updateSortStr) } } } edbInfo.Sort = prevEdbInfo.Sort + 1 edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } else { firstClassify, tmpErr := data_manage.GetFirstEdbInfoByClassifyId(classifyId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstClassify != nil && firstClassify.Sort == 0 { updateSortStr := ` sort + 1 ` _ = data_manage.UpdateEdbInfoSortByClassifyId(firstClassify.ClassifyId, 0, firstClassify.EdbInfoId-1, updateSortStr) } edbInfo.Sort = 0 //那就是排在第一位 edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } //更新 if len(updateCol) > 0 { err = edbInfo.Update(updateCol) } if err != nil { errMsg = "移动失败" err = errors.New("修改失败,Err:" + err.Error()) return } //新增操作日志 { edbLog := new(data_manage.EdbInfoLog) edbLog.EdbInfoId = edbInfo.EdbInfoId edbLog.SourceName = edbInfo.SourceName edbLog.Source = edbInfo.Source edbLog.EdbCode = edbInfo.EdbCode edbLog.EdbName = edbInfo.EdbName edbLog.ClassifyId = edbInfo.ClassifyId edbLog.SysUserId = sysUser.AdminId edbLog.SysUserRealName = sysUser.RealName edbLog.CreateTime = time.Now() edbLog.Content = requestBody edbLog.Status = "移动指标" edbLog.Method = requestUrl go data_manage.AddEdbInfoLog(edbLog) } return } // GetPredictEdbInfoDataList 获取预测指标的未来数据 func GetPredictEdbInfoDataList(predictEdbConf data_manage.PredictEdbConf, latestDateStr string, lastDataValue float64, endDateStr, frequency string) (predictEdbInfoData []*data_manage.EdbData, err error) { endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local) if err != nil { return } latestDate, err := time.ParseInLocation(utils.FormatDate, latestDateStr, time.Local) if err != nil { return } dataValue := lastDataValue if predictEdbConf.RuleType == 2 { dataValue = predictEdbConf.FixedValue } //获取后面的预测数据 dayList := getPredictEdbDayList(latestDate, endDate, frequency) predictEdbInfoData = make([]*data_manage.EdbData, 0) lenDayList := len(dayList) if lenDayList > 0 { for i := lenDayList - 1; i >= 0; i-- { v := dayList[i] predictEdbInfoData = append(predictEdbInfoData, &data_manage.EdbData{ EdbDataId: predictEdbConf.PredictEdbInfoId + 100000 + i, EdbInfoId: predictEdbConf.PredictEdbInfoId, DataTime: v.Format(utils.FormatDate), Value: dataValue, }) } } return } // GetChartPredictEdbInfoDataList 获取图表的预测指标的未来数据 func GetChartPredictEdbInfoDataList(predictEdbConf data_manage.PredictEdbConf, filtrateStartDateStr, latestDateStr string, lastDataValue float64, endDateStr, frequency string) (predictEdbInfoData []*data_manage.EdbDataList, err error) { endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local) if err != nil { return } latestDate, err := time.ParseInLocation(utils.FormatDate, latestDateStr, time.Local) if err != nil { return } // 开始预测数据的时间 startDate := latestDate // 如果有筛选时间的话 if filtrateStartDateStr != `` { filtrateStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, filtrateStartDateStr, time.Local) if tmpErr != nil { err = tmpErr return } //如果筛选时间晚于实际数据时间，那么就以筛选时间作为获取预测数据的时间 if filtrateStartDate.After(latestDate) { startDate = filtrateStartDate.AddDate(0, 0, -1) } } dataValue := lastDataValue if predictEdbConf.RuleType == 2 { dataValue = predictEdbConf.FixedValue } //获取后面的预测数据 dayList := getPredictEdbDayList(startDate, endDate, frequency) predictEdbInfoData = make([]*data_manage.EdbDataList, 0) for k, v := range dayList { predictEdbInfoData = append(predictEdbInfoData, &data_manage.EdbDataList{ EdbDataId: predictEdbConf.PredictEdbInfoId + 100000 + k, EdbInfoId: predictEdbConf.PredictEdbInfoId, DataTime: v.Format(utils.FormatDate), Value: dataValue, DataTimestamp: v.UnixNano() / 1e6, }) } return } // GetChartPredictEdbInfoDataListByConfList 获取图表的预测指标的未来数据 func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []data_manage.PredictEdbConfAndData, filtrateStartDateStr, latestDateStr, endDateStr, frequency string, realPredictEdbInfoData []*data_manage.EdbDataList) (predictEdbInfoData []*data_manage.EdbDataList, minValue, maxValue float64, err error, errMsg string) { endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local) if err != nil { return } latestDate, err := time.ParseInLocation(utils.FormatDate, latestDateStr, time.Local) if err != nil { return } // 开始预测数据的时间 startDate := latestDate // 如果有筛选时间的话 if filtrateStartDateStr != `` { filtrateStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, filtrateStartDateStr, time.Local) if tmpErr != nil { err = tmpErr return } //如果筛选时间晚于实际数据时间，那么就以筛选时间作为获取预测数据的时间 if filtrateStartDate.After(latestDate) { startDate = filtrateStartDate.AddDate(0, 0, -1) } } //var dateArr []string // 对应日期的值 existMap := make(map[string]float64) for _, v := range realPredictEdbInfoData { //dateArr = append(dateArr, v.DataTime) existMap[v.DataTime] = v.Value } predictEdbInfoData = make([]*data_manage.EdbDataList, 0) //dataValue := lastDataValue //预测规则，1：最新，2：固定值，3：同比，4：同差，5：环比，6：环差，7：N期移动均值，8：N期段线性外推值 for _, predictEdbConf := range predictEdbConfList { dataEndTime := endDate if predictEdbConf.EndDate.Before(dataEndTime) { dataEndTime = predictEdbConf.EndDate } var tmpMinValue, tmpMaxValue float64 // 当前预测结果中的最大/最小值 dayList := getPredictEdbDayList(startDate, dataEndTime, frequency) if len(dayList) <= 0 { // 如果未来没有日期的话，那么就退出当前循环，进入下一个循环 continue } switch predictEdbConf.RuleType { case 1: //1：最新 var lastDataValue float64 //最新值 tmpAllData := make([]*data_manage.EdbDataList, 0) tmpAllData = append(tmpAllData, realPredictEdbInfoData...) tmpAllData = append(tmpAllData, predictEdbInfoData...) lenTmpAllData := len(tmpAllData) if lenTmpAllData > 0 { lastDataValue = tmpAllData[lenTmpAllData-1].Value } predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, lastDataValue, dayList, predictEdbInfoData, existMap) tmpMaxValue = lastDataValue tmpMinValue = lastDataValue case 2: //2：固定值 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } dataValue, _ := tmpValDecimal.Float64() predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, dataValue, dayList, predictEdbInfoData, existMap) tmpMaxValue = dataValue tmpMinValue = dataValue case 3: //3：同比 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } tbValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTb(predictEdbConf.PredictEdbInfoId, tbValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap) case 4: //4：同差 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } tcValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTc(predictEdbConf.PredictEdbInfoId, tcValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap) case 5: //5：环比 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } hbValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHb(predictEdbConf.PredictEdbInfoId, hbValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) case 6: //6：环差 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } hcValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHc(predictEdbConf.PredictEdbInfoId, hcValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) case 7: //7：N期移动均值 nValue, tmpErr := strconv.Atoi(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(predictEdbConf.PredictEdbInfoId, nValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) case 8: //8：N期段线性外推值 nValue, tmpErr := strconv.Atoi(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } if nValue <= 1 { errMsg = `N期段线性外推值的N值必须大于1` err = errors.New(errMsg) return } predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleNLinearRegression(predictEdbConf.PredictEdbInfoId, nValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) if err != nil { return } case 9: //9：动态环差”预测规则； //规则计算的环差值map hcDataMap := make(map[string]float64) if predictEdbConf.PredictEdbInfoId > 0 { //已经生成的动态数据 tmpPredictEdbRuleDataList, tmpErr := data_manage.GetPredictEdbRuleDataList(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate)) if tmpErr != nil { err = tmpErr return } for _, v := range tmpPredictEdbRuleDataList { hcDataMap[v.DataTime] = v.Value } } else { //未生成的动态数据，需要使用外部传入的数据进行计算 if len(predictEdbConf.DataList) <= 0 { return } for _, v := range predictEdbConf.DataList { currentDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local) if tmpErr != nil { continue } // 只处理时间段内的数据 if currentDate.Before(startDate) || currentDate.After(endDate) { continue } hcDataMap[v.DataTime] = v.Value } } predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTrendsHC(predictEdbConf.PredictEdbInfoId, dayList, realPredictEdbInfoData, predictEdbInfoData, hcDataMap, existMap) case 10: //10：根据 给定终值后插值 规则获取预测数据 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } finalValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleFinalValueHc(predictEdbConf.PredictEdbInfoId, finalValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) case 11: //11：根据 季节性 规则获取预测数据 predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleSeason(predictEdbConf.PredictEdbInfoId, predictEdbConf.Value, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) if err != nil { return } case 12: //12：根据 移动平均同比 规则获取预测数据 var moveAverageConf MoveAverageConf tmpErr := json.Unmarshal([]byte(predictEdbConf.Value), &moveAverageConf) if tmpErr != nil { err = errors.New("季节性配置信息异常:" + tmpErr.Error()) return } predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleMoveAverageTb(predictEdbConf.PredictEdbInfoId, moveAverageConf.NValue, moveAverageConf.Year, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) if err != nil { return } case 13: //13：根据 同比增速差值 规则获取预测数据 tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value) if tmpErr != nil { err = tmpErr return } tbEndValue, _ := tmpValDecimal.Float64() predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTbzscz(predictEdbConf.PredictEdbInfoId, tbEndValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap) case 14: //14：根据 一元线性拟合 规则获取预测数据 var ruleConf RuleLineNhConf err = json.Unmarshal([]byte(predictEdbConf.Value), &ruleConf) if err != nil { err = errors.New("一元线性拟合配置信息异常:" + err.Error()) return } // 规则计算的拟合残差值map newNhccDataMap := make(map[string]float64) if predictEdbConf.PredictEdbInfoId > 0 { //已经生成的动态数据 tmpPredictEdbRuleDataList, tmpErr := data_manage.GetPredictEdbRuleDataList(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, "", "") if tmpErr != nil { err = tmpErr return } for _, v := range tmpPredictEdbRuleDataList { newNhccDataMap[v.DataTime] = v.Value } } else { //未生成的动态数据，需要使用外部传入的数据进行计算 newNhccDataMap, err = getCalculateNhccData(append(realPredictEdbInfoData, predictEdbInfoData...), ruleConf) if err != nil { return } } predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleLineNh(predictEdbConf.PredictEdbInfoId, dayList, realPredictEdbInfoData, predictEdbInfoData, newNhccDataMap, existMap) if err != nil { return } case 15: //15：N年均值：过去N年同期均值。过去N年可以连续或者不连续，指标数据均用线性插值补全为日度数据后计算； predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleNAnnualAverage(predictEdbConf.PredictEdbInfoId, predictEdbConf.Value, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap) if err != nil { return } case 16: //16：年度值倒推 predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleAnnualValueInversion(predictEdbConf.PredictEdbInfoId, predictEdbConf.Value, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap) if err != nil { return } } // 下一个规则的开始日期 { lenPredictEdbInfoData := len(predictEdbInfoData) if lenPredictEdbInfoData > 0 { tmpDataEndTime, _ := time.ParseInLocation(utils.FormatDate, predictEdbInfoData[lenPredictEdbInfoData-1].DataTime, time.Local) if startDate.Before(tmpDataEndTime) { startDate = tmpDataEndTime } } } if tmpMinValue < minValue { minValue = tmpMinValue } if tmpMaxValue > maxValue { maxValue = tmpMaxValue } } return } // GetPredictEdbDayList 获取预测指标日期列表 func getPredictEdbDayList(startDate, endDate time.Time, frequency string) (dayList []time.Time) { //if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, frequency) switch frequency { case "日度": for currDate := startDate.AddDate(0, 0, 1); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 1) { //周六、日排除 if currDate.Weekday() == time.Sunday || currDate.Weekday() == time.Saturday { continue } dayList = append(dayList, currDate) } case "周度": //nextDate := startDate.AddDate(0, 0, 7) for currDate := startDate.AddDate(0, 0, 7); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 7) { dayList = append(dayList, currDate) } case "旬度": for currDate := startDate.AddDate(0, 0, 1); currDate.Before(endDate) || currDate.Equal(endDate); { nextDate := currDate.AddDate(0, 0, 1) //每个月的10号、20号、最后一天，那么就写入 if nextDate.Day() == 11 || nextDate.Day() == 21 || nextDate.Day() == 1 { dayList = append(dayList, currDate) } currDate = nextDate } case "月度": for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); { currDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 1, -1) if !currDate.After(endDate) && !currDate.Equal(startDate) { dayList = append(dayList, currDate) } currDate = currDate.AddDate(0, 0, 1) } case "季度": for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); { // 每月的最后一天 currDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 1, -1) if !currDate.After(endDate) && !currDate.Equal(startDate) { // 季度日期就写入，否则不写入 if currDate.Month() == 3 || currDate.Month() == 6 || currDate.Month() == 9 || currDate.Month() == 12 { dayList = append(dayList, currDate) } } currDate = currDate.AddDate(0, 0, 1) } case "半年度": for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); { // 每月的最后一天 currDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 1, -1) if !currDate.After(endDate) && !currDate.Equal(startDate) { // 半年度日期就写入，否则不写入 if currDate.Month() == 6 || currDate.Month() == 12 { dayList = append(dayList, currDate) } } currDate = currDate.AddDate(0, 0, 1) } case "年度": for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); { currDate = time.Date(currDate.Year()+1, 12, 31, 0, 0, 0, 0, time.Now().Location()) if !currDate.After(endDate) && !currDate.Equal(startDate) { dayList = append(dayList, currDate) } } } return } // GetPredictDataListByPredictEdbInfoId 根据预测指标id获取预测指标的数据 func GetPredictDataListByPredictEdbInfoId(edbInfoId int, startDate, endDate string, isTimeBetween bool) (edbInfo *data_manage.EdbInfo, dataList []*data_manage.EdbDataList, sourceEdbInfoItem *data_manage.EdbInfo, predictEdbConf *data_manage.PredictEdbConf, err error, errMsg string) { edbInfo, err = data_manage.GetEdbInfoById(edbInfoId) if err != nil { errMsg = `获取预测指标信息失败` return } dataList, sourceEdbInfoItem, predictEdbConf, err, errMsg = GetPredictDataListByPredictEdbInfo(edbInfo, startDate, endDate, isTimeBetween) return } // GetPredictDataListByPredictEdbInfo 根据预测指标信息获取预测指标的数据 func GetPredictDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, startDate, endDate string, isTimeBetween bool) (dataList []*data_manage.EdbDataList, sourceEdbInfoItem *data_manage.EdbInfo, predictEdbConf *data_manage.PredictEdbConf, err error, errMsg string) { // 非计算指标，直接从表里获取数据 if edbInfo.EdbType != 1 { if !isTimeBetween { //如果不是区间数据，那么就结束日期为空 endDate = `` } return GetPredictCalculateDataListByPredictEdbInfo(edbInfo, startDate, endDate) } // 查找该预测指标配置 predictEdbConfList, err := data_manage.GetPredictEdbConfListById(edbInfo.EdbInfoId) if err != nil && err.Error() != utils.ErrNoRow() { errMsg = "获取预测指标配置信息失败" return } if len(predictEdbConfList) == 0 { errMsg = "获取预测指标配置信息失败" err = errors.New(errMsg) return } predictEdbConf = predictEdbConfList[0] // 来源指标 sourceEdbInfoItem, err = data_manage.GetEdbInfoById(predictEdbConf.SourceEdbInfoId) if err != nil { if err.Error() == utils.ErrNoRow() { errMsg = "找不到来源指标信息" err = errors.New(errMsg) } return } allDataList := make([]*data_manage.EdbDataList, 0) //获取指标数据（实际已生成） dataList, err = data_manage.GetEdbDataList(sourceEdbInfoItem.Source, sourceEdbInfoItem.EdbInfoId, startDate, endDate) if err != nil { return } // 如果选择了日期，那么需要筛选所有的数据，用于未来指标的生成 if startDate != `` { allDataList, err = data_manage.GetEdbDataList(sourceEdbInfoItem.Source, sourceEdbInfoItem.EdbInfoId, "", "") if err != nil { return } } else { allDataList = dataList } // 获取预测指标未来的数据 predictDataList := make([]*data_manage.EdbDataList, 0) endDateStr := edbInfo.EndDate //预测指标的结束日期 if isTimeBetween { //如果是时间区间，那么 reqEndDateTime, _ := time.ParseInLocation(utils.FormatDate, endDate, time.Local) endDateTime, _ := time.ParseInLocation(utils.FormatDate, edbInfo.EndDate, time.Local) // 如果选择的时间区间结束日期 晚于 当天，那么预测数据截止到当天 if reqEndDateTime.Before(endDateTime) { endDateStr = endDate } } //predictDataList, err = GetChartPredictEdbInfoDataList(*predictEdbConf, startDate, sourceEdbInfoItem.LatestDate, sourceEdbInfoItem.LatestValue, endDateStr, edbInfo.Frequency) predictEdbConfDataList := make([]data_manage.PredictEdbConfAndData, 0) for _, v := range predictEdbConfList { predictEdbConfDataList = append(predictEdbConfDataList, data_manage.PredictEdbConfAndData{ ConfigId: v.ConfigId, PredictEdbInfoId: v.PredictEdbInfoId, SourceEdbInfoId: v.SourceEdbInfoId, RuleType: v.RuleType, FixedValue: v.FixedValue, Value: v.Value, EndDate: v.EndDate, ModifyTime: v.ModifyTime, CreateTime: v.CreateTime, DataList: make([]*data_manage.EdbDataList, 0), }) } //var predictMinValue, predictMaxValue float64 predictDataList, _, _, err, _ = GetChartPredictEdbInfoDataListByConfList(predictEdbConfDataList, startDate, sourceEdbInfoItem.LatestDate, endDateStr, edbInfo.Frequency, allDataList) if err != nil { return } dataList = append(dataList, predictDataList...) //if len(predictDataList) > 0 { // // 如果最小值 大于 预测值，那么将预测值作为最小值数据返回 // if edbInfo.MinValue > predictMinValue { // edbInfo.MinValue = predictMinValue // } // // // 如果最大值 小于 预测值，那么将预测值作为最大值数据返回 // if edbInfo.MaxValue < predictMaxValue { // edbInfo.MaxValue = predictMaxValue // } //} return } // GetChartDataList 通过完整的预测数据 进行 季节性图、公历、农历处理 func GetChartDataList(dataList []*data_manage.EdbDataList, chartType int, calendar, latestDateStr, startDate string) (resultDataList interface{}, err error) { startDateReal := startDate calendarPreYear := 0 if calendar == "农历" { newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal) if err != nil { fmt.Println("time.Parse:" + err.Error()) } calendarPreYear = newStartDateReal.Year() - 1 newStartDateReal = newStartDateReal.AddDate(-1, 0, 0) startDateReal = newStartDateReal.Format(utils.FormatDate) } // 曲线图 if chartType == 1 { resultDataList = dataList return } //实际数据的截止日期 latestDate, tmpErr := time.Parse(utils.FormatDate, latestDateStr) if tmpErr != nil { err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + latestDateStr)) return } latestDateYear := latestDate.Year() //实际数据截止年份 if calendar == "农历" { if len(dataList) <= 0 { resultDataList = data_manage.EdbDataResult{} } else { result, tmpErr := data_manage.AddCalculateQuarterV4(dataList) if tmpErr != nil { err = errors.New("获取农历数据失败,Err:" + tmpErr.Error()) return } // 处理季节图的截止日期 for k, edbDataItems := range result.List { var cuttingDataTimestamp int64 // 切割的日期时间字符串 cuttingDataTimeStr := latestDate.AddDate(0, 0, edbDataItems.BetweenDay).Format(utils.FormatDate) //如果等于最后的实际日期，那么遍历找到该日期对应的时间戳，并将其赋值为 切割时间戳 if edbDataItems.Year >= latestDateYear { for _, tmpData := range edbDataItems.Items { if tmpData.DataTime == cuttingDataTimeStr { cuttingDataTimestamp = tmpData.DataTimestamp break } } } edbDataItems.CuttingDataTimestamp = cuttingDataTimestamp result.List[k] = edbDataItems } if result.List[0].Year != calendarPreYear { itemList := make([]*data_manage.EdbDataList, 0) items := new(data_manage.EdbDataItems) //items.Year = calendarPreYear items.Items = itemList newResult := new(data_manage.EdbDataResult) newResult.List = append(newResult.List, items) newResult.List = append(newResult.List, result.List...) resultDataList = newResult } else { resultDataList = result } } } else { currentYear := time.Now().Year() quarterDataList := make([]*data_manage.QuarterData, 0) quarterMap := make(map[int][]*data_manage.EdbDataList) var quarterArr []int for _, v := range dataList { itemDate, tmpErr := time.Parse(utils.FormatDate, v.DataTime) if tmpErr != nil { err = errors.New("季度指标日期转换,Err:" + tmpErr.Error() + ";DataTime:" + v.DataTime) return } year := itemDate.Year() newItemDate := itemDate.AddDate(currentYear-year, 0, 0) timestamp := newItemDate.UnixNano() / 1e6 v.DataTimestamp = timestamp if findVal, ok := quarterMap[year]; !ok { quarterArr = append(quarterArr, year) findVal = append(findVal, v) quarterMap[year] = findVal } else { findVal = append(findVal, v) quarterMap[year] = findVal } } for _, v := range quarterArr { itemList := quarterMap[v] quarterItem := new(data_manage.QuarterData) quarterItem.Year = v quarterItem.DataList = itemList //如果等于最后的实际日期，那么将切割时间戳记录 if v == latestDateYear { var cuttingDataTimestamp int64 for _, tmpData := range itemList { if tmpData.DataTime == latestDateStr { cuttingDataTimestamp = tmpData.DataTimestamp break } } quarterItem.CuttingDataTimestamp = cuttingDataTimestamp } else if v > latestDateYear { //如果大于最后的实际日期，那么第一个点就是切割的时间戳 if len(itemList) > 0 { quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100 } } quarterDataList = append(quarterDataList, quarterItem) } resultDataList = quarterDataList } return } // GetPredictCalculateDataListByPredictEdbInfo 根据预测运算指标信息获取预测指标的数据 func GetPredictCalculateDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, startDate, endDate string) (dataList []*data_manage.EdbDataList, sourceEdbInfoItem *data_manage.EdbInfo, predictEdbConf *data_manage.PredictEdbConf, err error, errMsg string) { dataList, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.EdbInfoId, startDate, endDate) return } // GetCalculateByRuleByNineParams 获取预测规则9的计算参数 func GetCalculateByRuleByNineParams(req request.RuleConfig) (formula string, edbInfoList []*data_manage.EdbInfo, edbInfoIdBytes []string, err error, errMsg string) { formula = req.Value formula = strings.Replace(formula, "（", "(", -1) formula = strings.Replace(formula, "）", ")", -1) formula = strings.Replace(formula, "，", ",", -1) formula = strings.Replace(formula, "。", ".", -1) formula = strings.Replace(formula, "%", "*0.01", -1) //检验公式 var checkFormulaStr string for _, tmpEdbInfoId := range req.EdbInfoIdArr { checkFormulaStr += tmpEdbInfoId.FromTag + "," edbInfoIdBytes = append(edbInfoIdBytes, tmpEdbInfoId.FromTag) } formulaMap := CheckFormula(formula) for _, tmpFormula := range formulaMap { if !strings.Contains(checkFormulaStr, tmpFormula) { errMsg = "公式错误，请重新填写" return } } //关联的指标信息 edbInfoList = make([]*data_manage.EdbInfo, 0) for _, tmpEdbInfoId := range req.EdbInfoIdArr { fromEdbInfo, tmpErr := data_manage.GetEdbInfoById(tmpEdbInfoId.EdbInfoId) if tmpErr != nil { if tmpErr.Error() == utils.ErrNoRow() { err = errors.New("指标 " + strconv.Itoa(tmpEdbInfoId.EdbInfoId) + " 不存在") } else { err = errors.New("获取指标失败:Err:" + tmpErr.Error()) } errMsg = "数据计算失败" return } edbInfoList = append(edbInfoList, fromEdbInfo) } ok, _ := CheckFormula2(edbInfoList, formulaMap, formula, edbInfoIdBytes) if !ok { errMsg = "生成计算指标失败，请使用正确的计算公式" err = errors.New(errMsg) } return } // CalculateByRuleByNine 动态环差规则计算入库 func CalculateByRuleByNine(formulaStr string, edbInfoList []*data_manage.EdbInfo, edbInfoIdBytes []string) (dataList []*data_manage.EdbDataList, err error) { realSaveDataMap := make(map[string]map[int]float64) saveDataMap := make(map[string]map[int]float64) dateList := make([]string, 0) //日期 formulaStr = strings.ToUpper(formulaStr) // 获取关联指标数据 for edbInfoIndex, v := range edbInfoList { sourceDataList, _, _, tmpErr, _ := GetPredictDataListByPredictEdbInfo(v, "", "", false) if tmpErr != nil { err = tmpErr return } dataMap := make(map[string]float64) for _, dv := range sourceDataList { // 实际数据 if val, ok := realSaveDataMap[dv.DataTime]; ok { if _, ok := val[v.EdbInfoId]; !ok { val[v.EdbInfoId] = dv.Value } } else { temp := make(map[int]float64) temp[v.EdbInfoId] = dv.Value realSaveDataMap[dv.DataTime] = temp } // saveDataMap 待计算的数据 if val, ok := saveDataMap[dv.DataTime]; ok { if _, ok := val[v.EdbInfoId]; !ok { val[v.EdbInfoId] = dv.Value } } else { temp2 := make(map[int]float64) temp2[v.EdbInfoId] = dv.Value saveDataMap[dv.DataTime] = temp2 } // 以第一个指标的日期作为基准日期 if edbInfoIndex == 0 { dateList = append(dateList, dv.DataTime) } } item := new(CalculateItems) item.EdbInfoId = v.EdbInfoId item.DataMap = dataMap } //数据处理，将日期内不全的数据做补全 handleDateSaveDataMap(dateList, realSaveDataMap, saveDataMap, edbInfoList) // 添加数据 dataList = make([]*data_manage.EdbDataList, 0) // 计算规则 formulaMap := CheckFormula(formulaStr) existDataMap := make(map[string]string) for k, date := range dateList { sv := saveDataMap[date] //fmt.Println(date, sv) formulaFormStr := ReplaceFormula(edbInfoList, sv, formulaMap, formulaStr, edbInfoIdBytes) if formulaFormStr == `` { //计算公式异常，那么就移除该指标 continue } //fmt.Println(fmt.Sprintf("formulaFormStr:%s", formulaFormStr)) expression := formula.NewExpression(formulaFormStr) calResult, tmpErr := expression.Evaluate() if tmpErr != nil { // 分母为0的报错 if strings.Contains(tmpErr.Error(), "divide by zero") { continue } err = errors.New("计算失败：Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr) return } calVal, tmpErr := calResult.Float64() if tmpErr != nil { err = errors.New("计算失败：获取计算值失败 Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr) fmt.Println(err) return } saveValue, _ := decimal.NewFromFloat(calVal).RoundCeil(4).Float64() //utils.SubFloatToString(calVal, 4) dataTime, _ := time.Parse(utils.FormatDate, date) timestamp := dataTime.UnixNano() / 1e6 if _, existOk := existDataMap[date]; !existOk { tmpPredictEdbRuleData := &data_manage.EdbDataList{ EdbDataId: k, EdbInfoId: 0, DataTime: date, DataTimestamp: timestamp, Value: saveValue, } dataList = append(dataList, tmpPredictEdbRuleData) } existDataMap[date] = date } return }