package data import ( "encoding/json" "errors" "eta/eta_api/models" "eta/eta_api/models/data_manage" "eta/eta_api/models/system" "eta/eta_api/services/alarm_msg" "eta/eta_api/services/elastic" "eta/eta_api/utils" "fmt" "sort" "strconv" "strings" "time" ) // EdbInfoRefreshAllFromBaseV2 全部刷新指标（切换到edb_lib服务） func EdbInfoRefreshAllFromBaseV2(edbInfoId int, refreshAll bool) (err error, isAsync bool) { var errmsg string defer func() { if err != nil { fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg) go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers) } }() err, isAsync = EdbInfoRefreshAllFromBaseV3([]int{edbInfoId}, refreshAll, false) return //// 获取关联的基础指标 //newBaseEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoList(edbInfoId) //if err != nil { // return //} // //var startDate string //for _, bv := range newBaseEdbInfoArr { // //source := bv.Source // //edbInfoId := bv.EdbInfoId // //edbCode := bv.EdbCode // if bv.StartDate == "0000-00-00" { // continue // } // //开始时间 // startDate = `` // if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 // sTime, err := time.Parse(utils.FormatDate, bv.StartDate) // if err != nil { // return err // } // startDate = sTime.Format(utils.FormatDate) // } else { // sTime, err := time.Parse(utils.FormatDate, bv.EndDate) // if err != nil { // return err // } // frequency := bv.Frequency // var limitDay int // 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) // } // result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate) // if err != nil { // fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now()) // errmsg = "RefreshBaseEdbData Err:" + err.Error() // return err // } // if result.Ret != 200 { // fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // return fmt.Errorf("刷新失败, err:", errmsg) // } // // //maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) // //if err != nil { // // if err.Error() == utils.ErrNoRow() { //找不到数据，那么就进入到下一条数据做处理 // // continue // // } // // return err // //} // //if maxAndMinItem != nil { // // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem) // // if err != nil { // // return err // // } // //} // fmt.Println("end newBaseEdbInfoArr:", bv, time.Now()) //} // ////刷新相关普通计算指标 //for _, v := range calculateArr { // edbInfo := newCalculateMap[v] // if edbInfo == nil { // return err // } // startDate = edbInfo.StartDate // source := edbInfo.Source // if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） // startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) // } else { // if source == utils.DATA_SOURCE_CALCULATE { // startDate = `` // if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 // startDate = edbInfo.StartDate // } else { // sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) // if err != nil { // return err // } // frequency := edbInfo.Frequency // var limitDay int // 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) // } // } // } // // result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) // if err != nil { // fmt.Println(v, "RefreshEdbCalculateData err", time.Now()) // errmsg = "RefreshEdbCalculateData Err:" + err.Error() // return err // } // if result.Ret != 200 { // fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // return fmt.Errorf("刷新失败") // } //} // ////刷新相关预测计算指标 //for _, v := range predictCalculateArr { // edbInfo := newPredictCalculateMap[v] // if edbInfo == nil { // return err // } // startDate = edbInfo.StartDate // source := edbInfo.Source // if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） // startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) // } else { // if source == utils.DATA_SOURCE_PREDICT_CALCULATE { // startDate = `` // if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 // startDate = edbInfo.StartDate // } else { // sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) // if err != nil { // return err // } // frequency := edbInfo.Frequency // var limitDay int // 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) // } // } // } // // result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) // if err != nil { // fmt.Println(v, "RefreshEdbCalculateData err", time.Now()) // errmsg = "RefreshEdbCalculateData Err:" + err.Error() // return err // } // if result.Ret != 200 { // fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) // return fmt.Errorf("刷新失败") // } //} //return err } // EdbInfoRefreshAllFromBaseV3 全部刷新指标（切换到edb_lib服务） // @author Roc // @datetime 2022-09-16 11:04:44 // @description 将原有的单个指标刷新，调整为批量多个指标刷新 func EdbInfoRefreshAllFromBaseV3(edbInfoIdList []int, refreshAll, isSync bool) (err error, isAsync bool) { var errmsg string defer func() { if err != nil { fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg) go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers) } }() // 获取关联的基础指标 newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList) if err != nil { return } // 需要刷新的指标数量 totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr) if totalEdbInfo <= 20 || isSync { err = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr) } else { isAsync = true go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr) } return } func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) (err error) { var errmsg string defer func() { if err != nil { fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg) go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers) } }() var startDate string for _, bv := range newBaseEdbInfoArr { //source := bv.Source //edbInfoId := bv.EdbInfoId //edbCode := bv.EdbCode if bv.StartDate == "0000-00-00" { continue } //开始时间 startDate = `` if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 sTime, err := time.Parse(utils.FormatDate, bv.StartDate) if err != nil { return err } startDate = sTime.Format(utils.FormatDate) } else { sTime, err := time.Parse(utils.FormatDate, bv.EndDate) if err != nil { return err } frequency := bv.Frequency var limitDay int 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) } result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate) if err != nil { fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now()) errmsg = "RefreshBaseEdbData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败, err:", errmsg) } //maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) //if err != nil { // if err.Error() == utils.ErrNoRow() { //找不到数据，那么就进入到下一条数据做处理 // continue // } // return err //} //if maxAndMinItem != nil { // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem) // if err != nil { // return err // } //} fmt.Println("end newBaseEdbInfoArr:", bv, time.Now()) } //刷新相关普通计算指标 for _, v := range calculateArr { edbInfo := newCalculateMap[v] if edbInfo == nil { return err } //计算指标就不用开始时间了吧，因为存在说开始时间变更的情况 startDate = `` if !refreshAll { //如果不是全部更新，那么以指标的开始时间作为刷新 startDate = edbInfo.StartDate source := edbInfo.Source if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) } else { if source == utils.DATA_SOURCE_CALCULATE { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } } } result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) if err != nil { fmt.Println(v, "RefreshEdbCalculateData err", time.Now()) errmsg = "RefreshEdbCalculateData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败") } } //刷新相关预测计算指标 for _, v := range predictCalculateArr { edbInfo := newPredictCalculateMap[v] if edbInfo == nil { return err } startDate = edbInfo.StartDate source := edbInfo.Source if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) } else { if source == utils.DATA_SOURCE_PREDICT_CALCULATE { startDate = `` if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 startDate = edbInfo.StartDate } else { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } } } result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) if err != nil { fmt.Println(v, "RefreshEdbCalculateData err", time.Now()) errmsg = "RefreshEdbCalculateData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败") } } // 4、更新动态环差值 { predictEdbInfoIdList := make([]int, 0) for _, v := range newBasePredictEdbInfoArr { predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId) } fmt.Println("predictEdbConfCalculateMappingDetailList:", predictEdbInfoIdList) predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(predictEdbInfoIdList) if err != nil { errmsg = fmt.Sprint("更新动态环差值时，获取数据失败:" + err.Error()) return fmt.Errorf("刷新失败, err:", errmsg) } for _, bv := range predictEdbConfCalculateMappingDetailList { result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, bv.EdbCode, "") if err != nil { fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now()) errmsg = "RefreshBasePredictEdbData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败, err:%s", errmsg) } fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now()) } } //5、再次刷新相关预测计算指标 for _, v := range predictCalculateArr { edbInfo := newPredictCalculateMap[v] if edbInfo == nil { return err } startDate = edbInfo.StartDate source := edbInfo.Source if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) } else { if source == utils.DATA_SOURCE_PREDICT_CALCULATE { startDate = `` if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 startDate = edbInfo.StartDate } else { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } } } result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) if err != nil { fmt.Println(v, "RefreshEdbCalculateData err", time.Now()) errmsg = "RefreshEdbCalculateData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败") } } return err } // EdbInfoRefresh 刷新单个指标,不会刷新关联指标 func EdbInfoRefresh(edbInfo *data_manage.EdbInfoView, refreshAll bool) (err error) { var errmsg string defer func() { if err != nil { fmt.Println("EdbInfoRefresh Err:" + err.Error() + ";errmsg:" + errmsg) go alarm_msg.SendAlarmMsg("EdbInfoRefresh,Err"+err.Error()+";errMsg:"+errmsg, 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers) } }() switch edbInfo.EdbInfoType { //指标类型，0：普通指标，1：预测指标 case 0: if edbInfo.StartDate == "0000-00-00" { return } //开始时间 startDate := `` if edbInfo.EdbType == 1 { // 基础指标 if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 sTime, err := time.Parse(utils.FormatDate, edbInfo.StartDate) if err != nil { return err } startDate = sTime.Format(utils.FormatDate) } else { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } result, err := RefreshEdbData(edbInfo.EdbInfoId, edbInfo.Source, edbInfo.EdbCode, startDate) if err != nil { fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err", time.Now()) errmsg = "RefreshBaseEdbData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败, err:", errmsg) } } else { //计算指标 //计算指标就不用开始时间了吧，因为存在说开始时间变更的情况 if !refreshAll { //如果不是全部更新，那么以指标的开始时间作为刷新 startDate = edbInfo.StartDate source := edbInfo.Source if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) } else { if source == utils.DATA_SOURCE_CALCULATE { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } } } 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 err } 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) return fmt.Errorf("刷新失败") } } case 1: startDate := edbInfo.StartDate var result *models.BaseResponse if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了） startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate) } else { startDate = `` if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新 startDate = edbInfo.StartDate } else { sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) if err != nil { return err } frequency := edbInfo.Frequency var limitDay int 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) } } if edbInfo.EdbType == 1 { //基础指标 result, err = RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate) } else { // 预测计算指标 // 4、更新动态环差值 { predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId([]int{edbInfo.EdbInfoId}) if err != nil { errmsg = fmt.Sprint("更新动态环差值时，获取数据失败:" + err.Error()) return fmt.Errorf("刷新失败, err:", errmsg) } for _, bv := range predictEdbConfCalculateMappingDetailList { result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, bv.EdbCode, "") if err != nil { fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now()) errmsg = "RefreshBasePredictEdbData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败, err:%s", errmsg) } fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now()) } } } if err != nil { fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now()) errmsg = "RefreshEdbCalculateData Err:" + err.Error() return err } if result.Ret != 200 { fmt.Println(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg) return fmt.Errorf("刷新失败") } } return err } // AddEdbInfo 新增手工指标数据 func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int) (err error) { tradeCode, err := models.GetMaxTradeCode() if err != nil { return } if tradeCode == "" { err = errors.New("最大编码为空") return } maxTradeCode, err := utils.GetMaxTradeCode(tradeCode) if err != nil { err = errors.New("获取编码信息失败,Err:" + err.Error()) return } if maxTradeCode == "" { err = errors.New("编码为空，请联系技术") return } //判断指标名称是否为空 if secName == "" { err = errors.New("指标名称不能为空") return } item, err := models.GetEdbinfoBySecName(secName) if err != nil && err.Error() != utils.ErrNoRow() { err = errors.New("获取信息失败，Err:" + err.Error()) return } if item != nil { err = errors.New("指标名称已存在") return } // 先删除该指标编码的历史数据（避免上海删除指标时，没有删除该指标数据） _ = models.DeleteAllEdbData(maxTradeCode) // 再次新增指标 err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId) if err != nil { err = errors.New("新增失败，Err:" + err.Error()) return } err = models.AddEdbinfoUser(maxTradeCode, mobile) return } //全部刷新指标 //func EdbInfoRefreshAllFromBase(edbInfoId int) (err error) { // var errmsg string // defer func() { // if err != nil { // fmt.Println("EdbInfoRefreshAllFromBase Err:" + err.Error() + ";errmsg:" + errmsg) // go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers) // } // }() // // calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId) // if err != nil && err.Error() != utils.ErrNoRow() { // return errors.New("GetEdbInfoAllCalculate Err:" + err.Error()) // } // baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // calculateInfoArr := make([]*data_manage.EdbInfo, 0) // baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId) // if err != nil { // return errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error()) // } // baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo) // // for _, v := range calculateList { // getBaseEdbInfoArr, getCalculateInfoArr, err := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) // if err != nil { // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) // errmsg = "获取需要刷新的指标失败:Err:" + err.Error() // return err // } // baseEdbInfoArr = append(baseEdbInfoArr, getBaseEdbInfoArr...) // calculateInfoArr = append(calculateInfoArr, getCalculateInfoArr...) // calculateInfoArr = append(calculateInfoArr, v) // } // //取重 // newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // baseMap := make(map[int]int) // for _, v := range baseEdbInfoArr { // if _, ok := baseMap[v.EdbInfoId]; !ok { // newBaseEdbInfoArr = append(newBaseEdbInfoArr, v) // } // baseMap[v.EdbInfoId] = v.EdbInfoId // } // // var calculateArr []int // newCalculateMap := make(map[int]*data_manage.EdbInfo) // for _, v := range calculateInfoArr { // if _, ok := newCalculateMap[v.EdbInfoId]; !ok { // calculateArr = append(calculateArr, v.EdbInfoId) // } // newCalculateMap[v.EdbInfoId] = v // } // sort.Ints(calculateArr) // var startDate string // for _, bv := range newBaseEdbInfoArr { // source := bv.Source // edbInfoId := bv.EdbInfoId // edbCode := bv.EdbCode // // sTime, err := time.Parse(utils.FormatDate, bv.StartDate) // if err != nil { // return err // } // startDate = sTime.Format(utils.FormatDate) // // if source == utils.DATA_SOURCE_THS { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByThs(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByThs Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_WIND { // endDate := time.Now().Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByWind(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByWind Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_PB { // startDate := sTime.Format(utils.FormatDateUnSpace) // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace) // err = data_manage.RefreshAllEdbDataByPb(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByPb Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_MANUAL { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByManual(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByManual Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_LZ { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByLz(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByLz Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_YS { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByYs(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByYs Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_GL { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByGl(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByGl Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_ZZ { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByZz(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByZz Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_DL { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByDl(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByDl Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_SH { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataBySh(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataBySh Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_CFFEX { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByCffex(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByCffex Err:" + err.Error() // } // } else if source == utils.DATA_SOURCE_SHFE { // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate) // err = data_manage.RefreshAllEdbDataByShfe(edbInfoId, source, edbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllEdbDataByShfe Err:" + err.Error() // } // } // // maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) // if err != nil { // return err // } // if maxAndMinItem != nil { // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem) // if err != nil { // return err // } // } // fmt.Println("end newBaseEdbInfoArr:", bv, time.Now()) // } // // endDate := "" //计算指标不限制日期 // //刷新相关计算指标 // for _, v := range calculateArr { // edbInfo := newCalculateMap[v] // if edbInfo == nil { // return err // } // edbInfoId := edbInfo.EdbInfoId // source := edbInfo.Source // edbCode := edbInfo.EdbCode // // if source == utils.DATA_SOURCE_CALCULATE { // startDate = edbInfo.StartDate // sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate) // if err != nil { // return err // } // startDate = sTime.Format(utils.FormatDate) // // var edbInfoIdBytes []string // calculateMap, err := data_manage.GetEdbInfoCalculateDetail(edbInfoId, edbInfo.Source) // if err != nil { // errmsg = "GetEdbInfoCalculateDetail Err:" + err.Error() // return err // } // var formulaStr string // edbInfoList := make([]*data_manage.EdbInfo, 0) // // for _, v := range calculateMap { // formulaStr += v.FromTag + "," // edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag) // edbInfo, _ := data_manage.GetEdbInfoById(v.FromEdbInfoId) // edbInfoList = append(edbInfoList, edbInfo) // } // err = data_manage.RefreshAllCalculate(edbInfoList, int(edbInfoId), source, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes) // if err != nil { // errmsg = "RefreshCalculate Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_LJZZY { //刷新累计值转月值 // calculateLjzzy, err := data_manage.GetEdbInfoCalculateLjzzyDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateLjzzy.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // err = data_manage.RefreshAllCalculateLjzzy(edbInfoId, source, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllCalculateLjzzy Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_TBZ { //刷新同比值 // calculateTbz, err := data_manage.GetEdbInfoCalculateTbzDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // err = data_manage.RefreshAllCalculateTbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllCalculateTbz Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_TCZ { //同差值 // calculateTcz, err := data_manage.GetEdbInfoCalculateTczDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateTczDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTcz.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // err = data_manage.RefreshAllCalculateTcz(edbInfoId, source, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshCalculateTcz Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS { //N数值移动平均计算 // calculateNszydpjjs, err := data_manage.GetEdbInfoCalculateNszydpjjsDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula) // startDate = edbInfo.StartDate // err = data_manage.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode, startDate) // if err != nil { // errmsg = "RefreshCalculateNszydpjjs Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_HBZ { //刷新环比值 // calculateTbz, err := data_manage.GetEdbInfoCalculateHbzDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateHbzDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula) // err = data_manage.RefreshAllCalculateHbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt) // if err != nil { // errmsg = "RefreshAllCalculateHbz Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_HCZ { //刷新环差值 // calculateTbz, err := data_manage.GetEdbInfoCalculateHczDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateHczDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula) // err = data_manage.RefreshAllCalculateHcz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt) // if err != nil { // errmsg = "RefreshAllCalculateHcz Err:" + err.Error() // return err // } // } else if source == utils.DATA_SOURCE_CALCULATE_BP { //刷新变频 // calculateTbz, err := data_manage.GetEdbInfoCalculateBpDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // err = data_manage.RefreshAllCalculateBp(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate) // if err != nil { // errmsg = "RefreshAllCalculateBp Err:" + err.Error() // return err // } //<<<<<<< HEAD // } else if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT { // calculate, err := data_manage.GetEdbInfoCalculateMappingDetail(edbInfoId) // if err != nil { // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error() // return err // } // fromEdbInfo, err := data_manage.GetEdbInfoById(calculate.FromEdbInfoId) // if err != nil { // errmsg = "GetEdbInfoById Err:" + err.Error() // return err // } // startDate = edbInfo.StartDate // endDate = time.Now().Format(utils.FormatDate) // formulaInt, _ := strconv.Atoi(calculate.CalculateFormula) // err = data_manage.RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency) // if err != nil { // errmsg = "RefreshAllCalculateTimeShift Err:" + err.Error() //======= // } else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //刷新直接拼接 // err = data_manage.RefreshAllCalculateZjpj(edbInfo) // if err != nil { // errmsg = "RefreshAllCalculateBp Err:" + err.Error() //>>>>>>> 884fd669cc9e91923781680e1890a519c012d38e // return err // } // } // // maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) // if err != nil { // return err // } // // if maxAndMinItem != nil { // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem) // if err != nil { // return err // } // } // fmt.Println("end calculateArr:", v, time.Now()) // } // return err //} // //// AddEdbInfo 新增手工指标数据 //func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int) (err error) { // tradeCode, err := models.GetMaxTradeCode() // if err != nil { // return // } // // if tradeCode == "" { // err = errors.New("最大编码为空") // return // } // maxTradeCode, err := utils.GetMaxTradeCode(tradeCode) // if err != nil { // err = errors.New("获取编码信息失败,Err:" + err.Error()) // return // } // if maxTradeCode == "" { // err = errors.New("编码为空，请联系技术") // return // } // //判断指标名称是否为空 // if secName == "" { // err = errors.New("指标名称不能为空") // return // } // item, err := models.GetEdbinfoBySecName(secName) // if err != nil && err.Error() != utils.ErrNoRow() { // err = errors.New("获取信息失败，Err:" + err.Error()) // return // } // if item != nil { // err = errors.New("指标名称已存在") // return // } // err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId) // if err != nil { // err = errors.New("新增失败，Err:" + err.Error()) // return // } // err = models.AddEdbinfoUser(maxTradeCode, mobile) // return //} // // // // // AddOrEditAllEdbInfoToEs 修复ES中的指标 func AddOrEditAllEdbInfoToEs() { //添加es total, itemInfoList, _ := data_manage.GetEdbInfoFilterList("", []interface{}{}, 0, 100000) for k, itemInfo := range itemInfoList { elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo) fmt.Println("剩余", int(total)-k-1, "条数据") } } // AddOrEditEdbInfoToEs 添加/修改ES中的指标 func AddOrEditEdbInfoToEs(edbInfoId int) { //添加es itemInfo, _ := data_manage.GetEdbInfoByCondition("AND edb_info_id=?", []interface{}{edbInfoId}) go elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo) } // DeleteEdbInfoToEs 删除ES中的指标 func DeleteEdbInfoToEs(edbInfoId int) { //添加es go elastic.EsDeleteEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(edbInfoId)) } // RefreshManualData 根据手工指标code刷新手工指标数据 func RefreshManualData(edbCode string) { var err error defer func() { if err != nil { go alarm_msg.SendAlarmMsg("导入手工数据后，根据手工指标code刷新手工指标数据失败提醒,Err"+err.Error(), 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"导入手工数据后，根据手工指标code刷新手工指标数据失败提醒", "errmsg:"+err.Error(), utils.EmailSendToUsers) } }() edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_MANUAL, edbCode) if err != nil { if err.Error() == utils.ErrNoRow() { err = nil } return } // 刷新指标库 err, _ = EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, true) return } // EdbInfoReplace 替换指标v2版本（更换时间：2022年01月05日15:33:42） func EdbInfoReplace(oldEdbInfo, newEdbInfo *data_manage.EdbInfo, sysAdminId int, sysAdminRealName string) (replaceChartTotal, replaceCalculateTotal int, err error) { defer func() { if err != nil { fmt.Println("ERR:", err.Error()) } }() mappingList, replaceChartTotal, replaceCalculateTotal, err := data_manage.ReplaceChartEdb(oldEdbInfo, newEdbInfo) if err != nil { return } //更新指标 err = replaceRelationEdbInfo(mappingList, oldEdbInfo, newEdbInfo, sysAdminId, sysAdminRealName) return } // replaceRelationEdbInfo 刷新指标 func replaceRelationEdbInfo(mappingList []*data_manage.EdbInfoCalculateMapping, oldEdbInfo, newEdbInfo *data_manage.EdbInfo, sysAdminId int, sysAdminRealName string) (err error) { errmsg := `` defer func() { if errmsg != "" { fmt.Println("errmsg:" + errmsg) } if err != nil && errmsg != "" { go alarm_msg.SendAlarmMsg("替换关联指标失败提醒,errmsg："+errmsg, 3) //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"替换指标失败提醒", "errmsg:"+errmsg, utils.EmailSendToUsers) } }() //获取计算指标关联指标 allMappingList := make([]*data_manage.EdbInfoCalculateMapping, 0) allMapping := make(map[int]int) tmpMapping := make(map[int]int) for _, v := range mappingList { if _, ok := allMapping[v.EdbInfoId]; !ok { allMappingList = append(allMappingList, v) } newList, _ := data_manage.GetAllCalculateV2(v.EdbInfoId, newEdbInfo.EdbInfoId, tmpMapping) for _, nv := range newList { if _, ok := allMapping[v.EdbInfoId]; !ok { allMappingList = append(allMappingList, nv) } allMapping[v.EdbInfoId] = v.EdbInfoId } allMapping[v.EdbInfoId] = v.EdbInfoId } for mk, mv := range allMappingList { //原指标关联的所有计算指标 fmt.Println("mk/mv", mk, mv) //重新计算计算指标 { edbInfo, tmpErr := data_manage.GetEdbInfoById(mv.EdbInfoId) //计算指标 err = tmpErr if err != nil { if err.Error() == utils.ErrNoRow() { errmsg = "计算指标已被删除" } else { errmsg = "获取计算指标失败:err:" + err.Error() } return } fromEdbInfoList, tmpErr := data_manage.GetEdbInfoCalculateDetail(mv.EdbInfoId, edbInfo.Source) err = tmpErr if err != nil { errmsg = "获取计算指标失败:err:" + err.Error() return } if len(fromEdbInfoList) <= 0 { errmsg = "计算指标所依赖指标不存在" err = fmt.Errorf("计算指标所依赖指标不存在") return } fromEdbInfoItem := fromEdbInfoList[0] if fromEdbInfoItem == nil { return } fromEdbInfo, tmpErr := data_manage.GetEdbInfoById(fromEdbInfoItem.FromEdbInfoId) err = tmpErr if err != nil { errmsg = "获取计算指标 来源指标失败:err:" + err.Error() return } edbCode := edbInfo.EdbCode //uniqueCode := edbInfo.UniqueCode sourName := edbInfo.SourceName source := edbInfo.Source edbInfoId := edbInfo.EdbInfoId req := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{ AdminId: sysAdminId, AdminName: sysAdminRealName, EdbInfoId: edbInfoId, EdbName: edbInfo.EdbName, Frequency: edbInfo.Frequency, Unit: edbInfo.Unit, ClassifyId: edbInfo.ClassifyId, Formula: edbInfo.CalculateFormula, //N数值移动平均计算、环比值、环差值 FromEdbInfoId: fromEdbInfoList[0].FromEdbInfoId, Source: edbInfo.Source, MoveType: edbInfo.MoveType, MoveFrequency: edbInfo.MoveFrequency, CalculateFormula: edbInfo.CalculateFormula, EdbInfoIdArr: nil, } if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { edbInfoIdArr := make([]data_manage.EdbInfoFromTag, 0) //A指标 aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId //找出需要替换的指标 { for _, v := range fromEdbInfoList { if v.FromTag == "A" { if v.FromEdbInfoId == oldEdbInfo.EdbInfoId { aFromEdbInfoId = newEdbInfo.EdbInfoId } else { aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId } } if v.FromTag == "B" { if v.FromEdbInfoId == oldEdbInfo.EdbInfoId { edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{ EdbInfoId: newEdbInfo.EdbInfoId, FromTag: v.FromTag, }) } else { edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{ EdbInfoId: v.FromEdbInfoId, FromTag: v.FromTag, }) } } } } req.FromEdbInfoId = aFromEdbInfoId req.EdbInfoIdArr = edbInfoIdArr sourName = "直接拼接" if len(req.EdbInfoIdArr) != 1 { errmsg = "请传入拼接日期之后的指标" err = fmt.Errorf("请传入拼接日期之后的指标") return } secondEdbInfoReq := req.EdbInfoIdArr[0] secondEdbInfo, tmpErr := data_manage.GetEdbInfoById(secondEdbInfoReq.EdbInfoId) err = tmpErr if err != nil { errmsg = "获取拼接日期之后的指标信息失败:Err:" + err.Error() err = fmt.Errorf("获取拼接日期之后的指标信息失败:Err:" + err.Error()) return } if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId { errmsg = "两个指标不允许为同一个" err = fmt.Errorf("两个指标不允许为同一个") return } } else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接 edbInfoIdArr := make([]data_manage.EdbInfoFromTag, 0) //A指标 aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId // 找出需要替换的指标 { for _, v := range fromEdbInfoList { if v.FromTag == "A" { if v.FromEdbInfoId == oldEdbInfo.EdbInfoId { aFromEdbInfoId = newEdbInfo.EdbInfoId } else { aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId } } if v.FromTag == "B" { if v.FromEdbInfoId == oldEdbInfo.EdbInfoId { edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{ EdbInfoId: newEdbInfo.EdbInfoId, FromTag: v.FromTag, }) } else { edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{ EdbInfoId: v.FromEdbInfoId, FromTag: v.FromTag, }) } } } } req.FromEdbInfoId = aFromEdbInfoId req.EdbInfoIdArr = edbInfoIdArr sourName = "累计值同比拼接" if fromEdbInfo.Frequency != "月度" { errmsg = "累计值同比拼接,待拼接指标只能筛选月度指标" err = fmt.Errorf("累计值同比拼接,待拼接指标只能筛选月度指标") return } if len(req.EdbInfoIdArr) != 1 { errmsg = "请传入同比值指标" err = fmt.Errorf("请传入同比值指标") return } secondEdbInfoReq := req.EdbInfoIdArr[0] tbzEdbInfo, tmpErr := data_manage.GetEdbInfoById(secondEdbInfoReq.EdbInfoId) err = tmpErr if err != nil { errmsg = "获取同比值指标信息失败:Err:" + err.Error() err = fmt.Errorf("获取同比值指标信息失败:Err:" + err.Error()) return } if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ { errmsg = "指标必须是传入同比值指标类型" err = fmt.Errorf("指标必须是传入同比值指标类型") return } if tbzEdbInfo.Frequency != "月度" { errmsg = "同比值指标只能筛选月度指标" err = fmt.Errorf("同比值指标只能筛选月度指标") return } if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId { errmsg = "两个指标不允许为同一个" err = fmt.Errorf("两个指标不允许为同一个") return } } else { errmsg = "无效计算方式,source:" + strconv.Itoa(source) err = fmt.Errorf("无效计算方式,source:" + strconv.Itoa(source)) return } // 调用指标库去更新 reqJson, tmpErr := json.Marshal(req) if tmpErr == nil { respItem, tmpErr := EditEdbCalculateData(string(reqJson)) if err != nil { err = tmpErr return } if respItem.Ret != 200 { err = errors.New("修改失败") return } } else { err = tmpErr } maxAndMinItem, tmpErr := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) err = tmpErr if err != nil && err.Error() != utils.ErrNoRow() { errmsg = "生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error() err = fmt.Errorf("生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error()) return } if maxAndMinItem != nil { err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem) } } } return } // 获取频度的英文版 func GetFrequencyEn(frequency string) (frequencyEn string) { switch frequency { case "日度": frequencyEn = "day" return case "周度": frequencyEn = "week" return case "旬度": frequencyEn = "ten days" return case "月度": frequencyEn = "month" return case "季度": frequencyEn = "quarter" return case "年度": frequencyEn = "year" return } return } func GetLeadUnitEn(unit string) (unitEn string) { switch unit { case "天": unitEn = "day" return case "周": unitEn = "week" return case "月": unitEn = "month" return case "季": unitEn = "quarter" return case "年": unitEn = "year" return } return } // getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标） //func getRefreshEdbInfoList(edbInfoId int) (newBaseEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) { // calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId) // if err != nil && err.Error() != utils.ErrNoRow() { // err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error()) // return // } // // 获取指标信息 // baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId) // if err != nil { // err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error()) // return // } // // baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 基础普通指标 // calculateInfoArr := make([]*data_manage.EdbInfo, 0) //基础运算指标 // basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 预测普通指标 // predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标 // // if baseEdbInfo.EdbInfoType == 0 { //普通指标 // switch baseEdbInfo.EdbType { // case 1: //基础指标 // baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo) // case 2: //计算指标 // calculateList = append(calculateList, baseEdbInfo) // } // } else { //预测指标 // switch baseEdbInfo.EdbType { // case 1: //基础指标 // basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo) // case 2: //计算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo) // } // } // // // 计算指标 // for _, v := range calculateList { // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) // if tmpErr != nil { // err = tmpErr // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) // errMsg = "获取需要刷新的指标失败:Err:" + err.Error() // return // } // for _, tmpEdbInfo := range getBaseEdbInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通基础指标 // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) // case 1: //预测基础指标 // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) // } // } // // for _, tmpEdbInfo := range getCalculateInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) // } // } // switch v.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, v) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, v) // } // } // // // 预测计算指标 // for _, v := range predictCalculateInfoArr { // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) // if tmpErr != nil { // err = tmpErr // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) // errMsg = "获取需要刷新的指标失败:Err:" + err.Error() // return // } // for _, tmpEdbInfo := range getBaseEdbInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通基础指标 // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) // case 1: //预测基础指标 // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) // } // } // // for _, tmpEdbInfo := range getCalculateInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) // } // } // switch v.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, v) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, v) // } // } // // // 第一次的计算指标map // newCalculateMap = make(map[int]*data_manage.EdbInfo) // for _, v := range calculateInfoArr { // if _, ok := newCalculateMap[v.EdbInfoId]; !ok { // calculateArr = append(calculateArr, v.EdbInfoId) // } // newCalculateMap[v.EdbInfoId] = v // } // // // 基础预测指标 // if len(basePredictEdbInfoArr) > 0 { // basePredictEdbInfoIdList := make([]int, 0) // for _, v := range basePredictEdbInfoArr { // basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId) // } // baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList) // if tmpErr != nil { // err = tmpErr // return // } // // tmpCalculateList := make([]*data_manage.EdbInfo, 0) // for _, v := range baseEdbInfoList { // switch v.EdbType { // case 1: // baseEdbInfoArr = append(baseEdbInfoArr, v) // case 2: // // 如果不在第一次里面，那么在第二次 刷新预测指标的时候 需要加进去 // if _, ok := newCalculateMap[v.EdbInfoId]; !ok { // tmpCalculateList = append(tmpCalculateList, v) // } // } // } // // // 这里是查询预测指标用到的 普通计算指标 // for _, v := range tmpCalculateList { // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) // if tmpErr != nil { // err = tmpErr // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) // errMsg = "获取需要刷新的指标失败:Err:" + err.Error() // return // } // // // 基础指标 // for _, tmpEdbInfo := range getBaseEdbInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通基础指标 // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) // case 1: //预测基础指标 // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) // } // } // // // 计算指标 // for _, tmpEdbInfo := range getCalculateInfoArr { // switch tmpEdbInfo.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) // } // } // switch v.EdbInfoType { // case 0: //普通运算指标 // calculateInfoArr = append(calculateInfoArr, v) // case 1: //预测运算指标 // predictCalculateInfoArr = append(predictCalculateInfoArr, v) // } // } // // // 第二次计算指标的map // for _, v := range calculateInfoArr { // if _, ok := newCalculateMap[v.EdbInfoId]; !ok { // calculateArr = append(calculateArr, v.EdbInfoId) // } // newCalculateMap[v.EdbInfoId] = v // } // } // // // 普通基础指标去重 // newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0) // baseMap := make(map[int]int) // for _, v := range baseEdbInfoArr { // if _, ok := baseMap[v.EdbInfoId]; !ok { // newBaseEdbInfoArr = append(newBaseEdbInfoArr, v) // } // baseMap[v.EdbInfoId] = v.EdbInfoId // } // // // 普通计算指标的id // sort.Ints(calculateArr) // // // 预测计算指标去重 // newPredictCalculateMap = make(map[int]*data_manage.EdbInfo) // for _, v := range predictCalculateInfoArr { // if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok { // predictCalculateArr = append(predictCalculateArr, v.EdbInfoId) // } // newPredictCalculateMap[v.EdbInfoId] = v // } // // 预测计算指标的id // sort.Ints(predictCalculateArr) // // return //} // getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标） func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) { calculateList, err := data_manage.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList) if err != nil && err.Error() != utils.ErrNoRow() { err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error()) return } // 获取指标信息 edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList) if err != nil { err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error()) return } baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 基础普通指标 calculateInfoArr := make([]*data_manage.EdbInfo, 0) //基础运算指标 basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 预测普通指标 predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标 for _, baseEdbInfo := range edbInfoList { // 指标若停更, 则忽略掉 if baseEdbInfo.NoUpdate == 1 { continue } if baseEdbInfo.EdbInfoType == 0 { //普通指标 switch baseEdbInfo.EdbType { case 1: //基础指标 baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo) case 2: //计算指标 calculateList = append(calculateList, baseEdbInfo) } } else { //预测指标 switch baseEdbInfo.EdbType { case 1: //基础指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo) case 2: //计算指标 predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo) } } } // 计算指标 for _, v := range calculateList { getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) if tmpErr != nil { err = tmpErr fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) errMsg = "获取需要刷新的指标失败:Err:" + err.Error() return } for _, tmpEdbInfo := range getBaseEdbInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通基础指标 baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) case 1: //预测基础指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } } for _, tmpEdbInfo := range getCalculateInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) case 1: //预测运算指标 //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) if tmpEdbInfo.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) } } } switch v.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, v) case 1: //预测指标 if v.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, v) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, v) } } } // 预测计算指标 for _, v := range predictCalculateInfoArr { getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) if tmpErr != nil { err = tmpErr fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) errMsg = "获取需要刷新的指标失败:Err:" + err.Error() return } for _, tmpEdbInfo := range getBaseEdbInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通基础指标 baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) case 1: //预测基础指标 if tmpEdbInfo.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) } //basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } } for _, tmpEdbInfo := range getCalculateInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) case 1: //预测运算指标 if tmpEdbInfo.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) } //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) } } switch v.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, v) case 1: //预测指标 if v.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, v) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, v) } } } // 第一次的计算指标map newCalculateMap = make(map[int]*data_manage.EdbInfo) for _, v := range calculateInfoArr { if _, ok := newCalculateMap[v.EdbInfoId]; !ok { calculateArr = append(calculateArr, v.EdbInfoId) } newCalculateMap[v.EdbInfoId] = v } // 基础预测指标 if len(basePredictEdbInfoArr) > 0 { basePredictEdbInfoIdList := make([]int, 0) for _, v := range basePredictEdbInfoArr { basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId) } baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList) if tmpErr != nil { err = tmpErr return } tmpCalculateList := make([]*data_manage.EdbInfo, 0) for _, v := range baseEdbInfoList { switch v.EdbType { case 1: baseEdbInfoArr = append(baseEdbInfoArr, v) case 2: // 如果不在第一次里面，那么在第二次 刷新预测指标的时候 需要加进去 if _, ok := newCalculateMap[v.EdbInfoId]; !ok { tmpCalculateList = append(tmpCalculateList, v) } } } // 这里是查询预测指标用到的 普通计算指标 for _, v := range tmpCalculateList { getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source) if tmpErr != nil { err = tmpErr fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error()) errMsg = "获取需要刷新的指标失败:Err:" + err.Error() return } // 基础指标 for _, tmpEdbInfo := range getBaseEdbInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通基础指标 baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo) case 1: //预测基础指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } } // 计算指标 for _, tmpEdbInfo := range getCalculateInfoArr { switch tmpEdbInfo.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, tmpEdbInfo) case 1: //预测运算指标 if v.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo) } else { predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo) } } } switch v.EdbInfoType { case 0: //普通运算指标 calculateInfoArr = append(calculateInfoArr, v) case 1: //预测指标 if v.EdbType == 1 { //预测普通指标 basePredictEdbInfoArr = append(basePredictEdbInfoArr, v) } else { //预测运算指标 predictCalculateInfoArr = append(predictCalculateInfoArr, v) } } } // 第二次计算指标的map for _, v := range calculateInfoArr { if _, ok := newCalculateMap[v.EdbInfoId]; !ok { calculateArr = append(calculateArr, v.EdbInfoId) } newCalculateMap[v.EdbInfoId] = v } } // 普通基础指标去重 newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0) baseMap := make(map[int]int) for _, v := range baseEdbInfoArr { if _, ok := baseMap[v.EdbInfoId]; !ok { newBaseEdbInfoArr = append(newBaseEdbInfoArr, v) } baseMap[v.EdbInfoId] = v.EdbInfoId } // 普通计算指标的id sort.Ints(calculateArr) // 普通预测指标去重 newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0) basePredictMap := make(map[int]int) for _, v := range basePredictEdbInfoArr { if _, ok := basePredictMap[v.EdbInfoId]; !ok { newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, v) } basePredictMap[v.EdbInfoId] = v.EdbInfoId } // 预测计算指标去重 newPredictCalculateMap = make(map[int]*data_manage.EdbInfo) for _, v := range predictCalculateInfoArr { if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok { predictCalculateArr = append(predictCalculateArr, v.EdbInfoId) } newPredictCalculateMap[v.EdbInfoId] = v } // 预测计算指标的id sort.Ints(predictCalculateArr) return } // GetMoveEdbChartList 获取待转移的指标/图表列表 // @param source 来源 ：1：手工数据指标 2：钢联化工数据库 3：ETA指标库 4：ETA预测指标 5：图库 func GetMoveEdbChartList(source, userId int, keyword, classify string, startSize, pageSize int) (list []data_manage.MoveEdbChartList, total int, err error) { var condition string var pars []interface{} switch source { case 1: //手工数据指标 if keyword != "" { condition += ` AND (a.SEC_NAME LIKE ? OR a.TRADE_CODE like ? ) ` pars = append(pars, `%`+keyword+`%`, `%`+keyword+`%`) } if userId > 0 { condition += ` AND a.user_id = ? ` pars = append(pars, userId) } if classify != "" { condition += ` AND a.classify_id IN (` + classify + `) ` } total, err = models.GetEdbinfoListCount(condition, pars, "", 0) if err != nil { return } tmpList, tmpErr := models.GetEdbinfoList(condition, pars, startSize, pageSize, "", 0) if tmpErr != nil { err = tmpErr return } if len(tmpList) > 0 { adminIdList := make([]int, 0) for _, v := range tmpList { adminIdList = append(adminIdList, v.UserId) } adminList, tmpErr := system.GetAdminListByIdListWithoutEnable(adminIdList) if tmpErr != nil { err = tmpErr return } adminMap := make(map[int]string) for _, adminInfo := range adminList { adminMap[adminInfo.AdminId] = adminInfo.RealName } for _, v := range tmpList { list = append(list, data_manage.MoveEdbChartList{ DataId: v.TradeCode, Code: v.TradeCode, Name: v.SecName, ClassifyName: v.ClassifyName, CreateUserId: v.UserId, CreateUserName: adminMap[v.UserId], }) } } case 2: //钢联化工数据库 if keyword != `` { condition += " AND (index_name like ? OR index_code like ? OR sys_user_real_name like ? ) " pars = append(pars, "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%") } if userId > 0 { condition += ` AND sys_user_id = ? ` pars = append(pars, userId) } if classify != "" { condition += ` AND base_from_mysteel_chemical_classify_id IN (` + classify + `) ` } total, err = data_manage.GetMysteelChemicalIndexCount(condition, pars) if err != nil { return } tmpList, tmpErr := data_manage.GetMysteelChemicalIndexList(condition, pars, startSize, pageSize) if tmpErr != nil { err = tmpErr return } for _, v := range tmpList { list = append(list, data_manage.MoveEdbChartList{ DataId: strconv.Itoa(v.BaseFromMysteelChemicalIndexId), Code: v.IndexCode, Name: v.IndexName, //ClassifyName: v., CreateUserId: v.SysUserId, CreateUserName: v.SysUserRealName, }) } case 3, 4: //ETA指标库、ETA预测指标 if keyword != `` { condition += " AND (edb_code like ? OR edb_name like ? OR sys_user_real_name like ? ) " pars = append(pars, "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%") } if userId > 0 { condition += ` AND sys_user_id = ? ` pars = append(pars, userId) } if classify != "" { condition += ` AND classify_id IN (` + classify + `) ` } edbInfoType := 0 //ETA指标库 if source == 4 { //ETA预测指标 edbInfoType = 1 } condition += ` AND edb_info_type = ? ` pars = append(pars, edbInfoType) total, err = data_manage.GetEdbInfoByConditionCount(condition, pars) if err != nil { return } tmpList, tmpErr := data_manage.GetEdbInfoListByCondition(condition, pars, startSize, pageSize) if tmpErr != nil { err = tmpErr return } for _, v := range tmpList { list = append(list, data_manage.MoveEdbChartList{ DataId: strconv.Itoa(v.EdbInfoId), Code: v.EdbCode, Name: v.EdbName, //ClassifyName: v., CreateUserId: v.SysUserId, CreateUserName: v.SysUserRealName, }) } case 5: //图库 if keyword != `` { condition += " AND (chart_name like ? OR sys_user_real_name like ? ) " pars = append(pars, "%"+keyword+"%", "%"+keyword+"%") } if userId > 0 { condition += ` AND sys_user_id = ? ` pars = append(pars, userId) } if classify != "" { condition += ` AND chart_classify_id IN (` + classify + `) ` } total, err = data_manage.GetChartInfoCountByCondition(condition, pars) if err != nil { return } tmpList, tmpErr := data_manage.GetChartInfoListByCondition(condition, pars, startSize, pageSize) if tmpErr != nil { err = tmpErr return } // 获取所有的图表分类 firstClassifyList, tmpErr := data_manage.GetChartClassifyByParentId(0, 1) if tmpErr != nil { err = tmpErr return } firstClassifyNameMap := make(map[int]string) for _, v := range firstClassifyList { firstClassifyNameMap[v.ChartClassifyId] = v.ChartClassifyName } secondClassList, tmpErr := data_manage.GetChartClassifyAll(1) if tmpErr != nil { err = tmpErr return } secondClassifyNameMap := make(map[int]string) for _, v := range secondClassList { firstName := firstClassifyNameMap[v.ParentId] if firstName != `` { firstName = firstName + " / " } secondClassifyNameMap[v.ChartClassifyId] = firstName + v.ChartClassifyName } for _, v := range tmpList { list = append(list, data_manage.MoveEdbChartList{ DataId: strconv.Itoa(v.ChartInfoId), Name: v.ChartName, ClassifyName: secondClassifyNameMap[v.ChartClassifyId], CreateUserId: v.SysUserId, CreateUserName: v.SysUserRealName, }) } default: return } return } // MoveEdbChart 转移指标/图表创建人 // @param source 来源 ：1：手工数据指标 2：钢联化工数据库 3：ETA指标库 4：ETA预测指标 5：图库 func MoveEdbChart(source, userId int, dataId []string) (err error, errMsg string) { adminInfo, err := system.GetSysAdminById(userId) if err != nil { return } switch source { case 1: //手工数据指标 tmpList, tmpErr := models.GetEdbinfoListByCodeListGroupByUserId(dataId) if tmpErr != nil { err = tmpErr return } if len(tmpList) > 0 { for _, v := range tmpList { if v.UserId == userId { errMsg = "新创建人不可和原创建人一致" err = errors.New(errMsg) return } } // 修改创建人 err = models.ModifyEdbinfoUserIdByCodeList(dataId, userId) } case 2: //钢联化工数据库 tmpList, tmpErr := data_manage.GetMysteelChemicalIndexListGroupByUserId(dataId) if tmpErr != nil { err = tmpErr return } if len(tmpList) > 0 { for _, v := range tmpList { if v.SysUserId == userId { errMsg = "新创建人不可和原创建人一致" err = errors.New(errMsg) return } } // 修改创建人 err = data_manage.ModifyMysteelChemicalIndexUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName) } case 3, 4: //ETA指标库、ETA预测指标 tmpList, tmpErr := data_manage.GetEdbInfoListGroupByUserId(dataId) if tmpErr != nil { err = tmpErr return } if len(tmpList) > 0 { for _, v := range tmpList { if v.SysUserId == userId { errMsg = "新创建人不可和原创建人一致" err = errors.New(errMsg) return } } // 修改创建人 err = data_manage.ModifyEdbInfoUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName) // 移除当前用户的不可操作权限 { obj := data_manage.EdbInfoNoPermissionAdmin{} for _, v := range dataId { edbInfoId, _ := strconv.Atoi(v) go obj.DeleteByEdbInfoIdAndAdminId(edbInfoId, adminInfo.AdminId) } } } case 5: //图库 tmpList, tmpErr := data_manage.GetChartInfoListGroupByUserId(dataId) if tmpErr != nil { err = tmpErr return } if len(tmpList) > 0 { for _, v := range tmpList { if v.SysUserId == userId { errMsg = "新创建人不可和原创建人一致" err = errors.New(errMsg) return } } // 修改创建人 err = data_manage.ModifyChartInfoUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName) } default: return } return } func GetEdbChartClassifyList(source int) (resp data_manage.EdbChartClassifyResp, err error) { switch source { case 1: //手工数据指标 list, e := models.GetEdbdataClassify(0) if e != nil { err = e return } for _, v := range list { item := data_manage.EdbChartClassify{ ClassifyId: v.ClassifyId, ClassifyName: v.ClassifyName, ParentId: v.ParentId, } for _, v2 := range v.Child { child := data_manage.EdbChartClassify{ ClassifyId: v2.ClassifyId, ClassifyName: v2.ClassifyName, ParentId: v2.ParentId, } item.Child = append(item.Child, &child) } resp.List = append(resp.List, &item) } case 2: //钢联化工数据库 rootList, e := data_manage.GetBaseFromMysteelChemicalClassifyByParentId(0) if e != nil && e.Error() != utils.ErrNoRow() { err = e return } classifyAll, e := data_manage.GetAllBaseFromMysteelChemicalClassify() if e != nil && e.Error() != utils.ErrNoRow() { err = e return } rootChildMap := make(map[int][]*data_manage.BaseFromMysteelChemicalClassifyItems) for _, v := range classifyAll { rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v) } nodeAll := make([]*data_manage.BaseFromMysteelChemicalClassifyItems, 0) for _, v := range rootList { if existItems, ok := rootChildMap[v.BaseFromMysteelChemicalClassifyId]; ok { v.Children = existItems } else { items := make([]*data_manage.BaseFromMysteelChemicalClassifyItems, 0) v.Children = items } nodeAll = append(nodeAll, v) } for _, v := range nodeAll { item := data_manage.EdbChartClassify{ ClassifyId: v.BaseFromMysteelChemicalClassifyId, ClassifyName: v.ClassifyName, ParentId: v.ParentId, } for _, v2 := range v.Children { child := data_manage.EdbChartClassify{ ClassifyId: v2.BaseFromMysteelChemicalClassifyId, ClassifyName: v2.ClassifyName, ParentId: v2.ParentId, } item.Child = append(item.Child, &child) } resp.List = append(resp.List, &item) } case 3: //ETA指标库 //rootList, e := data_manage.GetEdbClassifyByParentId(0, 0) //if e != nil && e.Error() != utils.ErrNoRow() { // err = e // return //} // 考虑到后面可以会迭代到10层, 这里直接用递归处理 classifyAll, e := data_manage.GetAllEdbClassifyByType(0) if e != nil && e.Error() != utils.ErrNoRow() { err = e return } resp.List = GetEdbMenuTreeRecursive(classifyAll, 0) //rootChildMap := make(map[int][]*data_manage.EdbClassifyItems) //for _, v := range classifyAll { // rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v) //} //nodeAll := make([]*data_manage.EdbClassifyItems, 0) //for _, v := range rootList { // if existItems, ok := rootChildMap[v.ClassifyId]; ok { // v.Children = existItems // } else { // items := make([]*data_manage.EdbClassifyItems, 0) // v.Children = items // } // nodeAll = append(nodeAll, v) //} // //for _, v := range nodeAll { // item := data_manage.EdbChartClassify{ // ClassifyId: v.ClassifyId, // ClassifyName: v.ClassifyName, // ParentId: v.ParentId, // } // for _, v2 := range v.Children { // child := data_manage.EdbChartClassify{ // ClassifyId: v2.ClassifyId, // ClassifyName: v2.ClassifyName, // ParentId: v2.ParentId, // } // item.Child = append(item.Child, &child) // } // resp.List = append(resp.List, &item) //} case 4: //ETA预测指标 // 考虑到后面可以会迭代到10层, 这里直接用递归 classifyAll, e := data_manage.GetAllEdbClassifyByType(1) if e != nil && e.Error() != utils.ErrNoRow() { err = e return } resp.List = GetEdbMenuTreeRecursive(classifyAll, 0) //rootList, e := data_manage.GetEdbClassifyByParentId(0, 1) //if e != nil && e.Error() != utils.ErrNoRow() { // err = e // return //} //nodeAll := make([]*data_manage.EdbClassifyItems, 0) //for _, v := range rootList { // nodeAll = append(nodeAll, v) //} // //for _, v := range nodeAll { // item := data_manage.EdbChartClassify{ // ClassifyId: v.ClassifyId, // ClassifyName: v.ClassifyName, // ParentId: v.ParentId, // } // for _, v2 := range v.Children { // child := data_manage.EdbChartClassify{ // ClassifyId: v2.ClassifyId, // ClassifyName: v2.ClassifyName, // ParentId: v2.ParentId, // } // item.Child = append(item.Child, &child) // } // resp.List = append(resp.List, &item) //} case 5: //图库 //判断是否存在缓存，如果存在缓存，那么直接从缓存中获取 //key := utils.CACHE_CHART_CLASSIFY //if utils.Re == nil { // if utils.Re == nil && utils.Rc.IsExist(key) { // rep := new(data_manage.ChartClassifyListResp) // if data, err1 := utils.Rc.RedisBytes(key); err1 == nil { // e := json.Unmarshal(data, &rep) // if e == nil && rep != nil { // for _, v := range rep.AllNodes { // item := data_manage.EdbChartClassify{ // ClassifyId: v.ChartClassifyId, // ClassifyName: v.ChartClassifyName, // ParentId: v.ParentId, // } // for _, v2 := range v.Children { // child := data_manage.EdbChartClassify{ // ClassifyId: v2.ChartClassifyId, // ClassifyName: v2.ChartClassifyName, // ParentId: v2.ParentId, // } // item.Child = append(item.Child, &child) // } // resp.List = append(resp.List, &item) // } // fmt.Println("source redis") // return // } // } // } //} // 考虑到后面可以会迭代到10层, 这里直接用递归处理 classifyAll, e := data_manage.GetAllChartClassifyItemsBySource(1) if e != nil && e.Error() != utils.ErrNoRow() { err = e return } resp.List = GetChartMenuTreeRecursive(classifyAll, 0) //rootList, e := data_manage.GetChartClassifyByParentIdFromETA(0) //if e != nil && e.Error() != utils.ErrNoRow() { // err = e // return //} // //classifyAll, e := data_manage.GetChartClassifyAllFromETA() //if e != nil && e.Error() != utils.ErrNoRow() { // err = e // return //} // //rootChildMap := make(map[int][]*data_manage.ChartClassifyItems) //for _, v := range classifyAll { // rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v) //} //nodeAll := make([]*data_manage.ChartClassifyItems, 0) //for _, v := range rootList { // if existItems, ok := rootChildMap[v.ChartClassifyId]; ok { // v.Children = existItems // } else { // items := make([]*data_manage.ChartClassifyItems, 0) // v.Children = items // } // nodeAll = append(nodeAll, v) //} // //for _, v := range nodeAll { // item := data_manage.EdbChartClassify{ // ClassifyId: v.ChartClassifyId, // ClassifyName: v.ChartClassifyName, // ParentId: v.ParentId, // } // for _, v2 := range v.Children { // child := data_manage.EdbChartClassify{ // ClassifyId: v2.ChartClassifyId, // ClassifyName: v2.ChartClassifyName, // ParentId: v2.ParentId, // } // item.Child = append(item.Child, &child) // } // resp.List = append(resp.List, &item) //} // 将数据加入缓存 //if utils.Re == nil { // utils.Rc.Delete(key) //} default: return } return } // EdbInfoAdd 添加指标到指标库 func EdbInfoAdd(source, classifyId int, edbCode, edbName, frequency, unit, startDate, endDate string, sysUserId int, sysUserRealName string) (edbInfo *data_manage.EdbInfo, err error, errMsg string, isSendEmail bool) { isSendEmail = true //判断指标名称是否存在 var condition string var pars []interface{} //condition += " AND source=? " //pars = append(pars, source) 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 = "指标名称已存在，请重新填写" err = errors.New(errMsg) isSendEmail = false return } edbInfo = new(data_manage.EdbInfo) edbInfo.Source = source sourceNameMap := map[int]string{ utils.DATA_SOURCE_THS: "同花顺", utils.DATA_SOURCE_WIND: "wind", utils.DATA_SOURCE_PB: "彭博", utils.DATA_SOURCE_PB_FINANCE: "彭博财务", utils.DATA_SOURCE_MANUAL: "手工数据", utils.DATA_SOURCE_LZ: "隆众", utils.DATA_SOURCE_YS: "SMM", utils.DATA_SOURCE_GL: "钢联", utils.DATA_SOURCE_ZZ: "郑商所", utils.DATA_SOURCE_DL: "大商所", utils.DATA_SOURCE_SH: "上期所", utils.DATA_SOURCE_CFFEX: "中金所", utils.DATA_SOURCE_SHFE: "上期能源", utils.DATA_SOURCE_GIE: "欧洲天然气", utils.DATA_SOURCE_LT: "路透", utils.DATA_SOURCE_COAL: "中国煤炭网", utils.DATA_SOURCE_GOOGLE_TRAVEL: "our world in data", utils.DATA_SOURCE_MYSTEEL_CHEMICAL: "钢联化工", utils.DATA_SOURCE_EIA_STEO: "EIA STEO报告", utils.DATA_SOURCE_COM_TRADE: "UN", utils.DATA_SOURCE_SCI: "SCI", utils.DATA_SOURCE_BAIINFO: "BAIINFO", utils.DATA_SOURCE_STOCK_PLANT: "存量装置", utils.DATA_SOURCE_NATIONAL_STATISTICS: "国家统计局", utils.DATA_SOURCE_FUBAO: "富宝数据", } sourceName, ok := sourceNameMap[source] if !ok { edbSource := data_manage.EdbSourceIdMap[source] if edbSource != nil { sourceName = edbSource.SourceName } if sourceName == "" { errMsg = "指标来源异常" err = errors.New(errMsg) return } } edbInfo.SourceName = sourceName edbType := 1 //基础指标 if source == utils.DATA_SOURCE_STOCK_PLANT { edbType = 2 //计算指标 } //从缓存中获取 serverUrl := `` if edbInfo.Source == utils.DATA_SOURCE_WIND { windCacheKey := utils.CACHE_WIND_URL + ":" + edbCode serverUrl, _ = utils.Rc.RedisString(windCacheKey) if serverUrl == `` { if len(utils.Hz_Data_WIND_Url_List) >= 1 { serverUrl = utils.Hz_Data_WIND_Url_List[len(utils.Hz_Data_WIND_Url_List)-1] //默认是最后一个服务器地址 } } } //获取该层级下最大的排序数 maxSort, err := GetEdbClassifyMaxSort(classifyId, 0) if err != nil { errMsg = "获取失败" err = errors.New("查询排序信息失败，Err:" + err.Error()) return } edbInfo.EdbCode = edbCode edbInfo.EdbName = edbName edbInfo.EdbNameSource = edbName edbInfo.Frequency = frequency edbInfo.Unit = unit edbInfo.StartDate = startDate edbInfo.EndDate = endDate edbInfo.ClassifyId = classifyId edbInfo.SysUserId = sysUserId edbInfo.SysUserRealName = sysUserRealName edbInfo.CreateTime = time.Now() edbInfo.ModifyTime = time.Now() edbInfo.ServerUrl = serverUrl edbInfo.Sort = maxSort + 1 edbInfo.DataDateType = `交易日` timestamp := strconv.FormatInt(time.Now().UnixNano(), 10) edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp) itemVal, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) if itemVal != nil && err == nil { edbInfo.MaxValue = itemVal.MaxValue edbInfo.MinValue = itemVal.MinValue } edbInfo.EdbType = edbType edbInfoId, err := data_manage.AddEdbInfo(edbInfo) if err != nil { errMsg = "保存失败" err = errors.New("保存失败，Err:" + err.Error()) return } edbInfo.EdbInfoId = int(edbInfoId) //保存数据 data_manage.ModifyEdbInfoDataStatus(edbInfoId, source, edbCode) //处理同名指标 //{ // edbNameList, tmpErr := data_manage.GetEdbInfoByName(edbName) // if tmpErr != nil { // errMsg = "保存失败" // err = errors.New("获取指标信息失败，Err:" + tmpErr.Error()) // return // } // if len(edbNameList) >= 2 { // for _, v := range edbNameList { // edbName := v.EdbName + "(" + v.SourceName + ")" // err = data_manage.ModifyEdbInfoNameSource(edbName, v.EdbInfoId) // if err != nil { // errMsg = "保存失败" // err = errors.New("修改指标名称失败，Err:" + err.Error()) // return // } // } // } //} //上传到ES //indexName := utils.DATA_INDEX_NAME //docId := strconv.Itoa(int(edbInfoId)) // //go data.EsAddOrEditEdbInfo(indexName, docId, edbInfo) maxAndMinItem, _ := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode) if maxAndMinItem != nil { err = data_manage.ModifyEdbInfoMaxAndMinInfo(int(edbInfoId), maxAndMinItem) } //添加es AddOrEditEdbInfoToEs(int(edbInfoId)) return } // TraceEdbInfoByEdbInfoId 指标追溯 func TraceEdbInfoByEdbInfoId(edbInfoId int) (traceEdbInfo data_manage.TraceEdbInfoResp, err error) { edbInfo, err := data_manage.GetEdbInfoById(edbInfoId) if err != nil { return } edbInfoRuleMap := make(map[int]string, 0) edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo) //edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo) traceEdbInfo = data_manage.TraceEdbInfoResp{ //EdbInfoId: edbInfo.EdbInfoId, EdbInfoId: edbInfoId, EdbInfoType: edbInfo.EdbInfoType, EdbName: edbInfo.EdbName, EdbType: edbInfo.EdbType, //Source: edbInfo.Source, UniqueCode: edbInfo.UniqueCode, ClassifyId: edbInfo.ClassifyId, } findIdMap := make(map[int]int) findIdMap[edbInfoId] = edbInfoId existMap := make(map[int]data_manage.TraceEdbInfoResp) traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap) edbInfoIdList := make([]int, 0) for _, v := range findIdMap { edbInfoIdList = append(edbInfoIdList, v) } edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList) if err != nil { return } edbInfoMap := make(map[int]*data_manage.EdbInfo) for _, tmpEdbInfo := range edbInfoList { edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo } traceEdbInfo, err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap) return } // traceEdbInfoByEdbInfoId 指标追溯 func traceEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo data_manage.TraceEdbInfoResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]data_manage.TraceEdbInfoResp, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (child []data_manage.TraceEdbInfoResp, err error) { traceEdbInfo, ok := existMap[edbInfoId] if ok { return } child = make([]data_manage.TraceEdbInfoResp, 0) edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId) if e != nil { err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error()) return } edbMappingMap[edbInfoId] = edbInfoMappingList for _, v := range edbInfoMappingList { tmpEdbInfoId := v.FromEdbInfoId tmpTraceEdbInfo := data_manage.TraceEdbInfoResp{ EdbInfoId: tmpEdbInfoId, EdbInfoType: v.FromEdbInfoType, EdbType: v.FromEdbType, UniqueCode: v.FromUniqueCode, ClassifyId: v.FromClassifyId, } // 计算指标/预测指标继续溯源 if v.FromEdbType == 2 || v.FromEdbInfoType == 1 { // 查过了就不查了 if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 { tmpTraceEdbInfo.Child, e = traceEdbInfoByEdbInfoId(tmpEdbInfoId, tmpTraceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap) if e != nil { err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error()) return } } } child = append(child, tmpTraceEdbInfo) findIdMap[tmpEdbInfoId] = tmpEdbInfoId } existMap[edbInfoId] = traceEdbInfo return } func handleTraceEdbInfo(traceEdbInfoResp data_manage.TraceEdbInfoResp, parentEdbInfoId int, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (newTraceEdbInfoResp data_manage.TraceEdbInfoResp, err error) { edbInfo, ok := edbInfoMap[traceEdbInfoResp.EdbInfoId] if !ok { err = errors.New("指标异常") return } var parentEdbInfo *data_manage.EdbInfo if parentEdbInfoId > 0 { parentEdbInfo, ok = edbInfoMap[parentEdbInfoId] if !ok { err = errors.New("指标异常") return } } //traceEdbInfoResp.EdbName = edbInfo.EdbName traceEdbInfoResp.EdbName, traceEdbInfoResp.RuleTitle = getEdbRuleTitle(edbInfo, parentEdbInfo, traceEdbInfoResp.Child, edbInfoMap, edbMappingMap) if traceEdbInfoResp.Child != nil && len(traceEdbInfoResp.Child) > 0 { for k, v := range traceEdbInfoResp.Child { traceEdbInfoResp.Child[k], err = handleTraceEdbInfo(v, traceEdbInfoResp.EdbInfoId, edbInfoMap, edbMappingMap) if err != nil { return } } } newTraceEdbInfoResp = traceEdbInfoResp return } // getEdbRule 获取规则名称 func getEdbRuleTitle(edbInfo, parentEdbInfo *data_manage.EdbInfo, childList []data_manage.TraceEdbInfoResp, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (edbName, ruleTitle string) { edbName = edbInfo.EdbName ruleTitle = `来源于` + edbInfo.SourceName if parentEdbInfo != nil { edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId] if !ok { edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{} } // 指标名称 switch parentEdbInfo.Source { case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE: for _, v := range edbMappingList { if v.FromEdbInfoId == edbInfo.EdbInfoId { edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag) } } case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ, utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 直接拼接 ,累计值同比拼接 for _, v := range edbMappingList { if v.FromEdbInfoId == edbInfo.EdbInfoId { tmpName := `` if v.FromTag == `A` { tmpName = `拼接日期前` } else if v.FromTag == `B` { tmpName = `拼接日期后` } edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName) } } case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差） for _, v := range edbMappingList { //（需对上游指标+自变量，领先10天/因变量） if v.FromEdbInfoId == edbInfo.EdbInfoId { tmpName := `` if v.FromTag == `A` { tmpName = fmt.Sprintf(`自变量，领先%d天`, v.MoveValue) } else if v.FromTag == `B` { tmpName = `因变量` } edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName) } } case utils.DATA_SOURCE_CALCULATE_CORRELATION: // 滚动相关性 for _, v := range edbMappingList { if v.FromEdbInfoId == edbInfo.EdbInfoId { edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag) } } } } if edbInfo.EdbType == 1 { // 基础指标的话，直接返回来源名称 //ruleTitle = `来源于`+edbInfo.SourceName return } // 规则 switch edbInfo.Source { case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE: ruleTitle = "=" + edbInfo.CalculateFormula case utils.DATA_SOURCE_CALCULATE_LJZZY, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZZY: ruleTitle = `累计转月值计算` case utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ: ruleTitle = `同比值计算` case utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ: ruleTitle = `同差值计算` case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS: ruleTitle = fmt.Sprintf("N数值移动均值计算（N=%s）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ: ruleTitle = fmt.Sprintf("N数值环比值计算（N=%s）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ: ruleTitle = fmt.Sprintf("N数值环差值计算（N=%s）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT: moveType := `领先` if edbInfo.MoveType == 2 { moveType = "滞后" } ruleTitle = fmt.Sprintf("时间移位计算（%s%s%s）", moveType, edbInfo.CalculateFormula, edbInfo.MoveFrequency) case utils.DATA_SOURCE_CALCULATE_BP, utils.DATA_SOURCE_PREDICT_CALCULATE_BP: // 变频 childFrequency := `` if len(childList) > 0 { if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok { childFrequency = childEdbInfo.Frequency } } ruleTitle = fmt.Sprintf("升频计算（%s转%s）", childFrequency, edbInfo.Frequency) case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ: // 直接拼接 ruleTitle = fmt.Sprintf("直接拼接计算（%s）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 累计值同比拼 ruleTitle = fmt.Sprintf("累计值同比值拼接计算（%s）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_PYTHON: ruleTitle = `代码运算` case utils.DATA_SOURCE_CALCULATE_CJJX, utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX: ruleTitle = fmt.Sprintf("超季节性计算（N=%s，%s）", edbInfo.CalculateFormula, edbInfo.Calendar) case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差） var startDate, endDate string dateList := strings.Split(edbInfo.CalculateFormula, ",") if len(dateList) == 2 { startDate = dateList[0] endDate = dateList[1] } ruleTitle = fmt.Sprintf("拟合残差计算（%s至%s）", startDate, endDate) case utils.DATA_SOURCE_CALCULATE_ADJUST: ruleTitle = `数据调整` case utils.DATA_SOURCE_CALCULATE_NH, utils.DATA_SOURCE_PREDICT_CALCULATE_NH: ruleTitle = `年化计算` case utils.DATA_SOURCE_CALCULATE_KSZS, utils.DATA_SOURCE_PREDICT_CALCULATE_KSZS: // 扩散指数->53 type KszsConfig struct { DateType int `description:"扩散指标日期；1：全部指标日期并集;2:部分指标日期并集"` CheckList []string `description:"选中的数据,A,B,C"` } var config KszsConfig err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &config) if err != nil { return } var startDate, endDate time.Time childEdbInfoIdList := make([]int, 0) if config.DateType == 1 { for _, v := range childList { childEdbInfoIdList = append(childEdbInfoIdList, v.EdbInfoId) } } else { if parentEdbInfo != nil { edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId] if !ok { edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{} } tagMap := make(map[string]int) for _, v := range edbMappingList { tagMap[v.FromTag] = v.FromEdbInfoId } for _, v := range config.CheckList { if tmpEdbInfoId, ok := tagMap[v]; ok { childEdbInfoIdList = append(childEdbInfoIdList, tmpEdbInfoId) } } } } for _, v := range childEdbInfoIdList { if childEdbInfo, ok := edbInfoMap[v]; ok { tmpStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.StartDate, time.Local) if tmpErr != nil { return } if startDate.IsZero() || startDate.After(tmpStartDate) { startDate = tmpStartDate } tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.EndDate, time.Local) if tmpErr != nil { return } if endDate.IsZero() || endDate.Before(tmpEndDate) { endDate = tmpEndDate } } } ruleTitle = fmt.Sprintf("扩散指数计算（%s至%s）", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate)) case utils.DATA_SOURCE_STOCK_PLANT: ruleTitle = `来源于装置分析` case utils.DATA_SOURCE_CALCULATE_CORRELATION: type EdbCalculateFormula struct { BaseCalculateValue int `description:"基础计算窗口"` BaseCalculateUnit string `description:"基础计算频度"` LeadValue int `description:"领先期数"` LeadUnit string `description:"频度"` CalculateValue int `description:"计算窗口"` CalculateUnit string `description:"计算频度"` } var correlationConf EdbCalculateFormula err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &correlationConf) if err != nil { return } ruleTitle = fmt.Sprintf("滚动相关性（计算窗口%d%s，B领先A%d%s）", correlationConf.CalculateValue, correlationConf.CalculateUnit, correlationConf.LeadValue, correlationConf.LeadUnit) case utils.DATA_SOURCE_CALCULATE_JP, utils.DATA_SOURCE_PREDICT_CALCULATE_JP: childFrequency := `` if len(childList) > 0 { if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok { childFrequency = childEdbInfo.Frequency } } ruleTitle = fmt.Sprintf("降频计算（%s转%s，%s）", childFrequency, edbInfo.Frequency, edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_STANDARD_DEVIATION: ruleTitle = fmt.Sprintf("标准差（滚动%s期）", edbInfo.CalculateFormula) case utils.DATA_SOURCE_CALCULATE_PERCENTILE, utils.DATA_SOURCE_PREDICT_CALCULATE_PERCENTILE: type TempCalculate struct { CalculateValue int `description:"计算窗口"` CalculateUnit string `description:"计算频度"` } cf := TempCalculate{} if e := json.Unmarshal([]byte(edbInfo.CalculateFormula), &cf); e != nil { return } ruleTitle = fmt.Sprintf("百分位（时间长度%d%s）", cf.CalculateValue, cf.CalculateUnit) case utils.DATA_SOURCE_CALCULATE_ZSXY, utils.DATA_SOURCE_PREDICT_CALCULATE_ZSXY: ruleTitle = `指数修匀计算` } return } // GetEdbChartAdminList // @param source 来源 ：1：手工数据指标 2：钢联化工数据库 3：ETA指标库 4：ETA预测指标 5：图库 func GetEdbChartAdminList(source int) (list []int, err error) { switch source { case 1: //手工数据指标 list, err = models.GetEdbInfoAdminList() if err != nil { return } case 2: //钢联化工数据库 list, err = data_manage.GetMysteelChemicalIndexAdminList() if err != nil { return } case 3: //ETA指标库 list, err = data_manage.GetEdbInfoAdminList(0) if err != nil { return } case 4: //ETA预测指标 list, err = data_manage.GetEdbInfoAdminList(1) if err != nil { return } case 5: //图库 list, err = data_manage.GetChartInfoAdminList() if err != nil { return } default: return } return } // GetEdbMenuTreeRecursive 递归指标库菜单树 func GetEdbMenuTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int) []*data_manage.EdbChartClassify { res := make([]*data_manage.EdbChartClassify, 0) for _, v := range list { t := new(data_manage.EdbChartClassify) t.ClassifyId = v.ClassifyId t.ClassifyName = v.ClassifyName t.ParentId = v.ParentId if v.ParentId == parentId { t.Child = GetEdbMenuTreeRecursive(list, v.ClassifyId) res = append(res, t) } } return res } // GetChartMenuTreeRecursive 递归指标库菜单树 func GetChartMenuTreeRecursive(list []*data_manage.ChartClassifyItems, parentId int) []*data_manage.EdbChartClassify { res := make([]*data_manage.EdbChartClassify, 0) for _, v := range list { t := new(data_manage.EdbChartClassify) t.ClassifyId = v.ChartClassifyId t.ClassifyName = v.ChartClassifyName t.ParentId = v.ParentId if v.ParentId == parentId { t.Child = GetChartMenuTreeRecursive(list, v.ChartClassifyId) res = append(res, t) } } return res }