Merge branch 'pool/787' into debug

models/base_from_calculate.go

@@ -363,7 +363,11 @@ func RefreshAllCalculate(edbInfoIdArr []*EdbInfo, edbInfoId, source int, edbCode
 func refreshAllCalculate(to orm.TxOrmer, edbInfoIdArr []*EdbInfo, edbInfoId, source int, edbCode, formulaStr, startDate, endDate string, edbInfoIdBytes []string) (err error) {
 	realSaveDataMap := make(map[string]map[int]float64)
 	saveDataMap := make(map[string]map[int]float64)
-	dateList := make([]string, 0)
+
+	// 最小的结束日期 , 最晚的数据开始日期
+	var minLatestDate, maxStartDate time.Time
+	dateList := make([]string, 0) // 第一个指标的日期数据
+
 	for edbInfoIndex, v := range edbInfoIdArr {
 		var condition string
 		var pars []interface{}
@@ -382,6 +386,9 @@ func refreshAllCalculate(to orm.TxOrmer, edbInfoIdArr []*EdbInfo, edbInfoId, sou
 		if err != nil {
 			return err
 		}
+
+		lenData := len(dataList)
+
 		for _, dv := range dataList {
 			if val, ok := realSaveDataMap[dv.DataTime]; ok {
 				if _, ok := val[v.EdbInfoId]; !ok {
@@ -409,10 +416,22 @@ func refreshAllCalculate(to orm.TxOrmer, edbInfoIdArr []*EdbInfo, edbInfoId, sou
 				dateList = append(dateList, dv.DataTime)
 			}
 		}
+
+		if lenData > 0 {
+			tmpLatestDate, _ := time.ParseInLocation(utils.FormatDate, dataList[lenData-1].DataTime, time.Local)
+			if minLatestDate.IsZero() || minLatestDate.After(tmpLatestDate) {
+				minLatestDate = tmpLatestDate
+			}
+
+			tmpStartDate, _ := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
+			if maxStartDate.IsZero() || maxStartDate.Before(tmpStartDate) {
+				maxStartDate = tmpStartDate
+			}
+		}
 	}
 
 	//数据处理，将日期内不全的数据做补全
-	handleDateSaveDataMap(dateList, realSaveDataMap, saveDataMap, edbInfoIdArr)
+	handleDateSaveDataMap(dateList, maxStartDate, minLatestDate, realSaveDataMap, saveDataMap, edbInfoIdArr)
 
 	formulaMap := utils.CheckFormula(formulaStr)
 	addSql := ` INSERT INTO edb_data_calculate(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
@@ -743,8 +762,18 @@ func CheckFormula2(edbInfoArr []*EdbInfo, formulaMap map[string]string, formulaS
 }
 
 // 处理整个数据
-func handleDateSaveDataMap(dateList []string, realSaveDataMap, saveDataMap map[string]map[int]float64, edbInfoIdArr []*EdbInfo) {
+func handleDateSaveDataMap(dateList []string, maxStartDate, minLatestDate time.Time, realSaveDataMap, saveDataMap map[string]map[int]float64, edbInfoIdArr []*EdbInfo) {
 	for _, date := range dateList {
+		dateTime, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
+		// 如果当前日期早于数据的最大开始日期，那么不处理，进入下一个循环
+		if dateTime.Before(maxStartDate) {
+			continue
+		}
+		// 如果当前日期晚于数据的最小结束日期，那么不处理，直接返回了
+		if dateTime.After(minLatestDate) {
+			return
+		}
+
 		tmpDataMap := realSaveDataMap[date]
 		for _, edbInfo := range edbInfoIdArr {
 			tmpEdbInfoId := edbInfo.EdbInfoId // 当前指标id

models/base_predict_from_calculate.go

@@ -90,132 +90,6 @@ func EditPredictCalculate(edbInfo *EdbInfo, calculateMappingList []*EdbInfoCalcu
 }
 
 // AddPredictCalculateData 新增预测计算（运算）指标的数据
-func AddPredictCalculateDataBak(edbInfoIdList []*EdbInfo, edbInfoId int, edbCode, formulaStr string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
-	o := orm.NewOrm()
-	defer func() {
-		if err != nil {
-			utils.FileLog.Info(fmt.Sprintf("Calculate Err:%s" + err.Error()))
-		}
-	}()
-
-	var minLatestDate time.Time
-	oldSaveDataMap := make(map[string]map[int]float64)
-	saveDataMap := make(map[string]map[int]float64)
-	dateList := make([]string, 0)
-
-	for edbInfoIndex, v := range edbInfoIdList {
-		tmpLatestDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.LatestDate, time.Local)
-		if tmpErr != nil {
-			err = errors.New(`最近的日期格式化失败;日期：` + v.LatestDate + `;err:` + tmpErr.Error())
-			return
-		}
-		// 如果不存在最小的真实数据日期，那么将当前指标的真实数据日期给赋值；
-		// 如果存在最小的真实数据日期，同时当前指标的真实数据日期 早于 最小的真实数据日期， 那么将当前指标的真实数据日期给赋值；
-		if minLatestDate.IsZero() || tmpLatestDate.Before(minLatestDate) {
-			minLatestDate = tmpLatestDate
-		}
-
-		dataList, tmpErr := GetPredictEdbDataListAll(v, 1)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-		dataMap := make(map[string]float64)
-		for _, dv := range dataList {
-			// 现有实际数据
-			if val, ok := oldSaveDataMap[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
-				oldSaveDataMap[dv.DataTime] = temp
-			}
-
-			// 待处理的数据
-			if val, ok := saveDataMap[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
-				saveDataMap[dv.DataTime] = temp
-			}
-
-			// 以第一个指标的日期作为基准日期
-			if edbInfoIndex == 0 {
-				dateList = append(dateList, dv.DataTime)
-			}
-		}
-		item := new(PredictCalculateItems)
-		item.EdbInfoId = v.EdbInfoId
-		item.DataMap = dataMap
-	}
-
-	//数据处理，将日期内不全的数据做补全
-	handleDateSaveDataMap(dateList, oldSaveDataMap, saveDataMap, edbInfoIdList)
-
-	formulaMap := utils.CheckFormula(formulaStr)
-	addSql := ` INSERT INTO edb_data_predict_calculate (edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	nowStr := time.Now().Format(utils.FormatDateTime)
-	var isAdd bool
-
-	if !minLatestDate.IsZero() {
-		latestDateStr = minLatestDate.Format(utils.FormatDate)
-	}
-	for sk, sv := range saveDataMap {
-		formulaStr = strings.ToUpper(formulaStr)
-		formulaFormStr := ReplaceFormula(edbInfoIdList, sv, formulaMap, formulaStr, edbInfoIdBytes)
-		if formulaStr == "" {
-			return
-		}
-		if formulaFormStr != "" {
-			expression := formula.NewExpression(formulaFormStr)
-			calResult, tmpErr := expression.Evaluate()
-			if tmpErr != nil {
-				err = errors.New("计算失败：Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr)
-				fmt.Println(err)
-				return
-			}
-			calVal, tmpErr := calResult.Float64()
-			if tmpErr != nil {
-				err = errors.New("计算失败：获取计算值失败 Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr)
-				fmt.Println(err)
-				return
-			}
-
-			//需要存入的数据
-			{
-				if latestDateStr == sk {
-					latestValue, _ = decimal.NewFromFloat(calVal).Truncate(4).Float64() //保留4位小数
-				}
-				dataTime, _ := time.ParseInLocation(utils.FormatDate, sk, time.Local)
-				timestamp := dataTime.UnixNano() / 1e6
-				timeStr := fmt.Sprintf("%d", timestamp)
-				addSql += "("
-				addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + sk + "'" + "," + utils.SubFloatToString(calVal, 4) + "," + "'" + nowStr + "'" +
-					"," + "'" + nowStr + "'" + "," + "'" + timeStr + "'"
-				addSql += "),"
-				isAdd = true
-			}
-		} else {
-			fmt.Println("formulaFormStr is empty")
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
-		if err != nil {
-			fmt.Println("AddPredictCalculate Err:" + err.Error())
-			//errMsg = " tx.Exec Err :" + err.Error()
-			return
-		}
-	}
-	return
-}
-
 func AddPredictCalculateData(edbInfoIdList []*EdbInfo, edbInfo *EdbInfo, edbCode, formulaStr string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
@@ -260,20 +134,30 @@ func RefreshAllPredictCalculate(edbInfoIdList []*EdbInfo, edbInfoId, source int,
 func refreshAllPredictCalculate(to orm.TxOrmer, edbInfoIdList []*EdbInfo, edbInfoId, source int, edbCode, formulaStr, startDate string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
 	fmt.Println("startDate:", startDate)
 
-	var minLatestDate time.Time
+	// 最小的结束日期 , 最晚的数据开始日期
+	var minLatestDate, maxStartDate time.Time
+	dateList := make([]string, 0) // 第一个指标的日期数据
+
 	realSaveDataMap := make(map[string]map[int]float64)
 	saveDataMap := make(map[string]map[int]float64)
-	dateList := make([]string, 0)
 
 	for edbInfoIndex, v := range edbInfoIdList {
-		tmpLatestDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.LatestDate, time.Local)
+		tmpLatestDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
 		if tmpErr != nil {
-			err = errors.New(`最近的日期格式化失败;日期：` + v.LatestDate + `;err:` + tmpErr.Error())
+			err = errors.New(`最近的日期格式化失败;日期：` + v.EndDate + `;err:` + tmpErr.Error())
 			return
 		}
 		if minLatestDate.IsZero() || tmpLatestDate.Before(minLatestDate) {
 			minLatestDate = tmpLatestDate
 		}
+		tmpStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.StartDate, time.Local)
+		if tmpErr != nil {
+			err = errors.New(`最近的日期格式化失败;日期：` + v.StartDate + `;err:` + tmpErr.Error())
+			return
+		}
+		if maxStartDate.IsZero() || maxStartDate.Before(tmpStartDate) {
+			maxStartDate = tmpStartDate
+		}
 
 		// 获取关联指标数据
 		dataList, tmpErr := GetPredictEdbDataListAllByStartDate(v, 1, startDate)
@@ -281,7 +165,7 @@ func refreshAllPredictCalculate(to orm.TxOrmer, edbInfoIdList []*EdbInfo, edbInf
 			err = tmpErr
 			return
 		}
-		dataMap := make(map[string]float64)
+
 		for _, dv := range dataList { // 现有实际数据
 			if val, ok := realSaveDataMap[dv.DataTime]; ok {
 				if _, ok := val[v.EdbInfoId]; !ok {
@@ -303,19 +187,14 @@ func refreshAllPredictCalculate(to orm.TxOrmer, edbInfoIdList []*EdbInfo, edbInf
 				temp[v.EdbInfoId] = dv.Value
 				saveDataMap[dv.DataTime] = temp
 			}
-
-			// 以第一个指标的日期作为基准日期
 			if edbInfoIndex == 0 {
 				dateList = append(dateList, dv.DataTime)
 			}
 		}
-		item := new(CalculateItems)
-		item.EdbInfoId = v.EdbInfoId
-		item.DataMap = dataMap
 	}
 
-	//数据处理，将日期内不全的数据做补全
-	handleDateSaveDataMap(dateList, realSaveDataMap, saveDataMap, edbInfoIdList)
+	//数据处理，将日期内不全的数据做填补
+	handleDateSaveDataMap(dateList, maxStartDate, minLatestDate, realSaveDataMap, saveDataMap, edbInfoIdList)
 
 	formulaMap := utils.CheckFormula(formulaStr)
 	addSql := ` INSERT INTO edb_data_predict_calculate (edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `

models/predict_edb.go

@@ -49,18 +49,22 @@ func RefreshCalculateByRuleBy9(rule CalculateRule) (resultDataList []*EdbInfoSea
 func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (resultDataList []*EdbInfoSearchData, err error) {
 	realSaveDataMap := make(map[string]map[int]float64)
 	saveDataMap := make(map[string]map[int]float64)
-	dateList := make([]string, 0)
+
+	// 最小的结束日期 , 最晚的数据开始日期
+	var minLatestDate, maxStartDate time.Time
+	dateList := make([]string, 0) // 第一个指标的日期数据
 
 	formulaStr := strings.ToUpper(rule.Formula)
 	// 获取关联指标数据
-	for edbInfoIndex, v := range rule.EdbInfoList {
+	for _, v := range rule.EdbInfoList {
 		dataList, tmpErr := GetPredictEdbDataListAll(v, 1)
 		if tmpErr != nil {
 			err = tmpErr
 			return
 		}
-		dataMap := make(map[string]float64)
-		for _, dv := range dataList {
+
+		lenData := len(dataList)
+		for edbInfoIndex, dv := range dataList {
 			// 现有实际数据
 			if val, ok := realSaveDataMap[dv.DataTime]; ok {
 				if _, ok := val[v.EdbInfoId]; !ok {
@@ -88,13 +92,22 @@ func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (resultDataList []*E
 				dateList = append(dateList, dv.DataTime)
 			}
 		}
-		item := new(CalculateItems)
-		item.EdbInfoId = v.EdbInfoId
-		item.DataMap = dataMap
+
+		if lenData > 0 {
+			tmpLatestDate, _ := time.ParseInLocation(utils.FormatDate, dataList[lenData-1].DataTime, time.Local)
+			if minLatestDate.IsZero() || minLatestDate.After(tmpLatestDate) {
+				minLatestDate = tmpLatestDate
+			}
+
+			tmpStartDate, _ := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
+			if maxStartDate.IsZero() || maxStartDate.Before(tmpStartDate) {
+				maxStartDate = tmpStartDate
+			}
+		}
 	}
 
-	//数据处理，将日期内不全的数据做补全
-	handleDateSaveDataMap(dateList, realSaveDataMap, saveDataMap, rule.EdbInfoList)
+	//数据处理，将日期内不全的数据做填补
+	handleDateSaveDataMap(dateList, maxStartDate, minLatestDate, realSaveDataMap, saveDataMap, rule.EdbInfoList)
 
 	// 添加数据
 	addDataList := make([]*PredictEdbRuleData, 0)