|
|
@@ -7,15 +7,13 @@ import (
|
|
|
"eta/eta_api/models/system"
|
|
|
"eta/eta_api/utils"
|
|
|
"fmt"
|
|
|
+ "math"
|
|
|
+ "strconv"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
func ResidualAnalysisPreview(req residual_analysis_model.ResidualAnalysisReq) (residual_analysis_model.ResidualAnalysisResp, error) {
|
|
|
|
|
|
- if req.DateType < 0 {
|
|
|
- return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("时间类型错误", nil)
|
|
|
- }
|
|
|
-
|
|
|
mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList([]int{req.EdbInfoIdA, req.EdbInfoIdB})
|
|
|
if err != nil {
|
|
|
return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("获取图表，指标信息失败，Err:%s", err.Error())
|
|
|
@@ -31,10 +29,10 @@ func ResidualAnalysisPreview(req residual_analysis_model.ResidualAnalysisReq) (r
|
|
|
}
|
|
|
}
|
|
|
if edbInfoMappingA == nil {
|
|
|
- return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标A不存在", nil)
|
|
|
+ return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标A不存在")
|
|
|
}
|
|
|
if edbInfoMappingB == nil {
|
|
|
- return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标B不存在", nil)
|
|
|
+ return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标B不存在")
|
|
|
}
|
|
|
|
|
|
// 时间处理
|
|
|
@@ -53,15 +51,6 @@ func ResidualAnalysisPreview(req residual_analysis_model.ResidualAnalysisReq) (r
|
|
|
|
|
|
resp := residual_analysis_model.ResidualAnalysisResp{}
|
|
|
|
|
|
- // 图表基础信息
|
|
|
- baseChartInfo := new(residual_analysis_model.ResidualAnalysisChartInfo)
|
|
|
- baseChartInfo.Calendar = `公历`
|
|
|
- baseChartInfo.Source = utils.CHART_SOURCE_DEFAULT
|
|
|
- baseChartInfo.DateType = req.DateType
|
|
|
- baseChartInfo.StartDate = startDate
|
|
|
- baseChartInfo.EndDate = endDate
|
|
|
- baseChartInfo.ChartType = utils.CHART_TYPE_CURVE
|
|
|
-
|
|
|
// 原始图表信息
|
|
|
originalEdbList := make([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, 0)
|
|
|
|
|
|
@@ -69,16 +58,21 @@ func ResidualAnalysisPreview(req residual_analysis_model.ResidualAnalysisReq) (r
|
|
|
if err != nil {
|
|
|
return residual_analysis_model.ResidualAnalysisResp{}, err
|
|
|
}
|
|
|
- baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingB.EdbName
|
|
|
+
|
|
|
+ originalChartInfo := createChartInfoResp(req, startDate, endDate, edbInfoMappingA.EdbName+"与"+edbInfoMappingB.EdbName)
|
|
|
|
|
|
resp.OriginalChartData = residual_analysis_model.ChartResp{
|
|
|
- ChartInfo: baseChartInfo,
|
|
|
+ ChartInfo: originalChartInfo,
|
|
|
EdbInfoList: originalEdbList,
|
|
|
}
|
|
|
+ // 如果只需要第一张图表的数据 直接返回，避免继续处理
|
|
|
+ if req.QueryType == 1 {
|
|
|
+ return resp, nil
|
|
|
+ }
|
|
|
|
|
|
dataAList, ok := edbInfoMappingA.DataList.([]*data_manage.EdbDataList)
|
|
|
if !ok {
|
|
|
- return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("数据类型转换失败", nil)
|
|
|
+ return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("数据类型转换失败")
|
|
|
}
|
|
|
indexADataMap := map[string]*data_manage.EdbDataList{}
|
|
|
for _, indexData := range dataAList {
|
|
|
@@ -86,34 +80,54 @@ func ResidualAnalysisPreview(req residual_analysis_model.ResidualAnalysisReq) (r
|
|
|
}
|
|
|
|
|
|
// 映射图表信息
|
|
|
- mappingEdbList, err := fillMappingChartInfo(req, edbInfoMappingA, edbInfoMappingB, originalEdbList, indexADataMap)
|
|
|
+ mappingEdbList, a, b, r, err := fillMappingChartInfo(req, edbInfoMappingA, edbInfoMappingB, originalEdbList, indexADataMap)
|
|
|
if err != nil {
|
|
|
return residual_analysis_model.ResidualAnalysisResp{}, err
|
|
|
}
|
|
|
- baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingB.EdbName + "映射" + edbInfoMappingA.EdbName
|
|
|
+
|
|
|
+ mappingChartInfo := createChartInfoResp(req, startDate, endDate, edbInfoMappingA.EdbName+"与"+edbInfoMappingB.EdbName+"映射"+edbInfoMappingA.EdbName)
|
|
|
|
|
|
resp.MappingChartData = residual_analysis_model.ChartResp{
|
|
|
- ChartInfo: baseChartInfo,
|
|
|
+ ChartInfo: mappingChartInfo,
|
|
|
EdbInfoList: mappingEdbList,
|
|
|
}
|
|
|
|
|
|
// 残差图表信息
|
|
|
- ResidualEdbList, err := fillResidualChartInfo(edbInfoMappingA, edbInfoMappingB, mappingEdbList)
|
|
|
+ residualEdbList, R2, err := fillResidualChartInfo(edbInfoMappingA, edbInfoMappingB, mappingEdbList)
|
|
|
if err != nil {
|
|
|
return residual_analysis_model.ResidualAnalysisResp{}, err
|
|
|
}
|
|
|
|
|
|
- baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingA.EdbName + "映射残差/" + edbInfoMappingB.EdbName
|
|
|
+ residualChartInfo := createChartInfoResp(req, startDate, endDate, edbInfoMappingA.EdbName+"与"+edbInfoMappingA.EdbName+"映射残差/"+edbInfoMappingB.EdbName)
|
|
|
|
|
|
- resp.MappingChartData = residual_analysis_model.ChartResp{
|
|
|
- ChartInfo: baseChartInfo,
|
|
|
- EdbInfoList: ResidualEdbList,
|
|
|
+ resp.ResidualChartData = residual_analysis_model.ChartResp{
|
|
|
+ ChartInfo: residualChartInfo,
|
|
|
+ EdbInfoList: residualEdbList,
|
|
|
+ }
|
|
|
+
|
|
|
+ if req.ResidualType == 2 {
|
|
|
+ resp.A = a
|
|
|
+ resp.B = b
|
|
|
+ resp.R = r
|
|
|
+ resp.R2 = R2
|
|
|
}
|
|
|
|
|
|
return resp, nil
|
|
|
}
|
|
|
|
|
|
-func fillResidualChartInfo(edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, mappingEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
|
|
|
+func createChartInfoResp(req residual_analysis_model.ResidualAnalysisReq, startDate, endDate, chartName string) residual_analysis_model.ResidualAnalysisChartInfo {
|
|
|
+ return residual_analysis_model.ResidualAnalysisChartInfo{
|
|
|
+ Calendar: `公历`,
|
|
|
+ Source: utils.CHART_SOURCE_DEFAULT,
|
|
|
+ DateType: req.DateType,
|
|
|
+ StartDate: startDate,
|
|
|
+ EndDate: endDate,
|
|
|
+ ChartType: utils.CHART_TYPE_CURVE,
|
|
|
+ ChartName: chartName,
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func fillResidualChartInfo(edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, mappingEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, float64, error) {
|
|
|
// 计算公式 映射残差 = 因变量指标 - 映射指标
|
|
|
var edbInfoA, edbInfoB residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
|
|
|
if mappingEdbList[0].EdbInfoId == edbInfoMappingA.EdbInfoId {
|
|
|
@@ -125,59 +139,98 @@ func fillResidualChartInfo(edbInfoMappingA *data_manage.ChartEdbInfoMapping, edb
|
|
|
}
|
|
|
dataAList, ok := edbInfoA.DataList.([]*data_manage.EdbDataList)
|
|
|
if !ok {
|
|
|
- return nil, fmt.Errorf("数据类型转换失败", nil)
|
|
|
+ return nil, 0, fmt.Errorf("数据类型转换失败")
|
|
|
}
|
|
|
- edbData := dataAList
|
|
|
+ edbData := make([]*data_manage.EdbDataList, len(dataAList))
|
|
|
+ for i, data := range dataAList {
|
|
|
+ edbData[i] = &data_manage.EdbDataList{
|
|
|
+ Value: data.Value, // 确保为每个元素创建一个新的对象
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
dataBList, ok := edbInfoB.DataList.([]*data_manage.EdbDataList)
|
|
|
if !ok {
|
|
|
- return nil, fmt.Errorf("数据类型转换失败", nil)
|
|
|
+ return nil, 0, fmt.Errorf("数据类型转换失败")
|
|
|
}
|
|
|
var indexDataBMap = make(map[string]*data_manage.EdbDataList)
|
|
|
for _, data := range dataBList {
|
|
|
indexDataBMap[data.DataTime] = data
|
|
|
}
|
|
|
- var valueB float64
|
|
|
+ // 求R2
|
|
|
+ var valueB, sumValueA, averageValueA, residualQuadraticSum, totalQuadraticSum, R2 float64
|
|
|
+
|
|
|
+ for _, indexData := range edbData {
|
|
|
+ // 因变量的值总和
|
|
|
+ sumValueA += indexData.Value
|
|
|
+ }
|
|
|
+ // 因变量平均值
|
|
|
+ averageValueA = sumValueA / float64(len(edbData))
|
|
|
+
|
|
|
for _, indexData := range edbData {
|
|
|
if dataB, ok := indexDataBMap[indexData.DataTime]; ok {
|
|
|
valueB = dataB.Value
|
|
|
} else {
|
|
|
valueB = 0
|
|
|
}
|
|
|
+
|
|
|
+ // 总因变量平方和
|
|
|
+ totalQuadraticSum += math.Pow(indexData.Value-averageValueA, 2)
|
|
|
+
|
|
|
+ // 补全残差值
|
|
|
indexData.Value = indexData.Value - valueB
|
|
|
+
|
|
|
+ // 残差平方和
|
|
|
+ residualQuadraticSum += math.Pow(indexData.Value, 2)
|
|
|
}
|
|
|
- for _, mapping := range mappingEdbList {
|
|
|
+ // 计算R2 公式：R2=1-SSE/SST R2越大，越符合线性 R2 = 1 - 残差平方和/总平方和
|
|
|
+ R2 = 1 - residualQuadraticSum/totalQuadraticSum
|
|
|
+
|
|
|
+ mappingEdb := make([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, len(mappingEdbList))
|
|
|
+ copy(mappingEdb, mappingEdbList)
|
|
|
+
|
|
|
+ for i, mapping := range mappingEdb {
|
|
|
if mapping.EdbInfoId != edbInfoMappingA.EdbInfoId {
|
|
|
- mapping.DataList = edbData
|
|
|
- mapping.EdbName = edbInfoMappingA.EdbName + "映射残差/" + edbInfoMappingB.EdbName
|
|
|
+ mappingEdb[i].DataList = edbData
|
|
|
+ mappingEdb[i].EdbName = edbInfoMappingA.EdbName + "映射残差/" + edbInfoMappingB.EdbName
|
|
|
+ mappingEdb[i].IsAxis = 1
|
|
|
+ mappingEdb[i].ChartColor = `#00F`
|
|
|
+ mappingEdb[i].IsOrder = false
|
|
|
+ } else {
|
|
|
+ mappingEdb[i].IsAxis = 0
|
|
|
+ mappingEdb[i].ChartColor = `#F00`
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- return mappingEdbList, nil
|
|
|
+ return mappingEdb, R2, nil
|
|
|
}
|
|
|
|
|
|
-func fillMappingChartInfo(req residual_analysis_model.ResidualAnalysisReq, edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, originalEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, indexADataMap map[string]*data_manage.EdbDataList) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
|
|
|
+func fillMappingChartInfo(req residual_analysis_model.ResidualAnalysisReq, edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, originalEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, indexADataMap map[string]*data_manage.EdbDataList) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, float64, float64, float64, error) {
|
|
|
// 计算公式：Y=aX+b，Y为映射后的指标，X为自变量指标
|
|
|
// 正序：a=(L2-L1)/(R2-R1) b=L2-R2*a
|
|
|
// 逆序：a=(L2-L1)/(R1-R2) b=L2-R1*a
|
|
|
// L2：左轴下限 R2：右轴上限 L1：左轴上限 R1：右轴下限
|
|
|
- var a, b float64
|
|
|
- if req.IsOrder {
|
|
|
- a = (req.LeftIndexMax - req.LeftIndexMin) / (req.RightIndexMax - req.RightIndexMin)
|
|
|
- b = req.LeftIndexMax - req.RightIndexMax*a
|
|
|
- } else {
|
|
|
- a = (req.LeftIndexMax - req.LeftIndexMin) / (req.RightIndexMin - req.RightIndexMax)
|
|
|
- b = req.LeftIndexMax - req.RightIndexMin*a
|
|
|
+ var a, b, r float64
|
|
|
+
|
|
|
+ // 映射残差 计算a,b
|
|
|
+ if req.ResidualType == 1 {
|
|
|
+ if req.IsOrder {
|
|
|
+ a = (req.LeftIndexMax - req.LeftIndexMin) / (req.RightIndexMin - req.RightIndexMax)
|
|
|
+ b = req.LeftIndexMax - req.RightIndexMin*a
|
|
|
+ } else {
|
|
|
+ a = (req.LeftIndexMax - req.LeftIndexMin) / (req.RightIndexMax - req.RightIndexMin)
|
|
|
+ b = req.LeftIndexMax - req.RightIndexMax*a
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
dataList, ok := edbInfoMappingB.DataList.([]*data_manage.EdbDataList)
|
|
|
if !ok {
|
|
|
- return nil, fmt.Errorf("数据类型转换失败", nil)
|
|
|
+ return nil, a, b, r, fmt.Errorf("数据类型转换失败")
|
|
|
}
|
|
|
|
|
|
// 领先指标 dataList进行数据处理
|
|
|
if req.IndexType == 2 {
|
|
|
if req.LeadValue < 0 {
|
|
|
- return nil, fmt.Errorf("领先值不能小于0", nil)
|
|
|
+ return nil, a, b, r, fmt.Errorf("领先值不能小于0")
|
|
|
} else if req.LeadValue > 0 {
|
|
|
for _, indexData := range dataList {
|
|
|
switch req.LeadFrequency {
|
|
|
@@ -196,14 +249,12 @@ func fillMappingChartInfo(req residual_analysis_model.ResidualAnalysisReq, edbIn
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+ // 指标B数据补充
|
|
|
for index := 0; index < len(dataList)-1; index++ {
|
|
|
// 获取当前数据和下一个数据
|
|
|
beforeIndexData := dataList[index]
|
|
|
afterIndexData := dataList[index+1]
|
|
|
|
|
|
- // 计算映射值
|
|
|
- beforeIndexData.Value = a*beforeIndexData.Value + b
|
|
|
-
|
|
|
// 从最早时间开始，补充时间为自然日
|
|
|
if utils.IsMoreThanOneDay(beforeIndexData.DataTime, afterIndexData.DataTime) {
|
|
|
// 创建补充数据
|
|
|
@@ -217,27 +268,55 @@ func fillMappingChartInfo(req residual_analysis_model.ResidualAnalysisReq, edbIn
|
|
|
dataList = append(dataList, &replenishIndexData)
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ // 拟合残差 计算a,b
|
|
|
+ var coordinateList []utils.Coordinate
|
|
|
+ if req.ResidualType == 2 {
|
|
|
+ for _, indexData := range dataList {
|
|
|
+ if _, ok := indexADataMap[indexData.DataTime]; ok {
|
|
|
+
|
|
|
+ coordinate := utils.Coordinate{
|
|
|
+ X: indexData.Value,
|
|
|
+ Y: indexADataMap[indexData.DataTime].Value,
|
|
|
+ }
|
|
|
+ coordinateList = append(coordinateList, coordinate)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ a, b = utils.GetLinearResult(coordinateList)
|
|
|
+ r = utils.CalculationDecisive(coordinateList)
|
|
|
+ }
|
|
|
+
|
|
|
// 根据指标A的时间key，在B的映射指标中筛选出对应的值
|
|
|
var dataBList []*data_manage.EdbDataList
|
|
|
+
|
|
|
for _, indexData := range dataList {
|
|
|
if _, ok := indexADataMap[indexData.DataTime]; ok {
|
|
|
- dataBList = append(dataBList, indexData)
|
|
|
+ indexDataCopy := *indexData
|
|
|
+
|
|
|
+ // 计算指标B映射值
|
|
|
+ indexDataCopy.Value = math.Round((a*indexData.Value+b)*10000) / 10000
|
|
|
+
|
|
|
+ // 将副本添加到 dataBList
|
|
|
+ dataBList = append(dataBList, &indexDataCopy)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- mappingEdbList := originalEdbList
|
|
|
- for _, mapping := range mappingEdbList {
|
|
|
- if mapping.EdbInfoId == req.EdbInfoIdB {
|
|
|
- mapping.EdbInfoId = 0
|
|
|
- mapping.EdbCode = ""
|
|
|
- mapping.EdbName = edbInfoMappingB.EdbName + "映射" + edbInfoMappingA.EdbName
|
|
|
- mapping.DataList = dataList
|
|
|
+ mappingEdbList := make([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, len(originalEdbList))
|
|
|
+ copy(mappingEdbList, originalEdbList)
|
|
|
+
|
|
|
+ for i, mapping := range mappingEdbList {
|
|
|
+ if mapping.EdbInfoId != req.EdbInfoIdA {
|
|
|
+ mappingEdbList[i].EdbInfoId = 0
|
|
|
+ mappingEdbList[i].EdbCode = ""
|
|
|
+ mappingEdbList[i].IsAxis = 1
|
|
|
+ mappingEdbList[i].EdbName = edbInfoMappingB.EdbName + "映射" + edbInfoMappingA.EdbName
|
|
|
+ mappingEdbList[i].DataList = dataBList
|
|
|
}
|
|
|
}
|
|
|
- return mappingEdbList, nil
|
|
|
+ return mappingEdbList, a, b, r, nil
|
|
|
}
|
|
|
|
|
|
-func fillOriginalChart(req residual_analysis_model.ResidualAnalysisReq, mappingList []*data_manage.ChartEdbInfoMapping, startDate string, endDate string, edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, OriginalEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
|
|
|
+func fillOriginalChart(req residual_analysis_model.ResidualAnalysisReq, mappingList []*data_manage.ChartEdbInfoMapping, startDate string, endDate string, edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, originalEdbList []residual_analysis_model.ResidualAnalysisChartEdbInfoMapping) ([]residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
|
|
|
for _, v := range mappingList {
|
|
|
var edbInfoMapping residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
|
|
|
edbInfoMapping.EdbInfoType = 1
|
|
|
@@ -272,11 +351,15 @@ func fillOriginalChart(req residual_analysis_model.ResidualAnalysisReq, mappingL
|
|
|
edbInfoMapping.Frequency = v.Frequency
|
|
|
edbInfoMapping.Source = v.Source
|
|
|
edbInfoMapping.SourceName = v.SourceName
|
|
|
+ edbInfoMapping.MinValue = v.MinValue
|
|
|
+ edbInfoMapping.MaxValue = v.MaxValue
|
|
|
+ edbInfoMapping.LatestDate = v.LatestDate
|
|
|
+ edbInfoMapping.LatestValue = v.LatestValue
|
|
|
|
|
|
edbInfoMapping.DataList = dataList
|
|
|
- OriginalEdbList = append(OriginalEdbList, edbInfoMapping)
|
|
|
+ originalEdbList = append(originalEdbList, edbInfoMapping)
|
|
|
}
|
|
|
- return OriginalEdbList, nil
|
|
|
+ return originalEdbList, nil
|
|
|
}
|
|
|
|
|
|
func ContrastPreview(indexCode string) (residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
|
|
|
@@ -300,10 +383,14 @@ func ContrastPreview(indexCode string) (residual_analysis_model.ResidualAnalysis
|
|
|
|
|
|
var resp residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
|
|
|
resp.EdbInfoId = edbInfo.EdbInfoId
|
|
|
+ resp.EdbCode = edbInfo.EdbCode
|
|
|
+ resp.ChartColor = "#F00"
|
|
|
resp.SourceName = edbInfo.SourceName
|
|
|
resp.EdbName = edbInfo.EdbName
|
|
|
resp.Unit = edbInfo.Unit
|
|
|
resp.Frequency = edbInfo.Frequency
|
|
|
+ resp.MinValue = edbInfo.MinValue
|
|
|
+ resp.MaxValue = edbInfo.MaxValue
|
|
|
resp.DataList = dataList
|
|
|
return resp, nil
|
|
|
}
|
|
|
@@ -316,75 +403,196 @@ func SaveResidualAnalysis(req residual_analysis_model.ResidualAnalysisIndexSaveR
|
|
|
return err
|
|
|
}
|
|
|
if classifyCount <= 0 {
|
|
|
- return fmt.Errorf("分类不存在", nil)
|
|
|
+ return fmt.Errorf("分类不存在")
|
|
|
+ }
|
|
|
+
|
|
|
+ // 校验名称是否重复
|
|
|
+ var condition string
|
|
|
+ var pars []interface{}
|
|
|
+
|
|
|
+ condition += " and source = ? AND edb_name=?"
|
|
|
+ pars = append(pars, req.Source, req.EdbName)
|
|
|
+
|
|
|
+ edbInfoByCondition, err := data_manage.GetEdbInfoByCondition(condition, pars)
|
|
|
+ if err != nil && err.Error() != utils.ErrNoRow() {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ // 获取指标数据最大值 最小值 最后更新时间 最后更新时间对应的值
|
|
|
+ var indexMax, indexMin, indexLatestValue float64
|
|
|
+ var indexLatestDate string
|
|
|
+ if len(req.DataList) > 0 {
|
|
|
+ latestTime, _ := time.Parse(utils.YearMonthDay, req.DataList[0].DataTime)
|
|
|
+ for _, data := range req.DataList {
|
|
|
+ // 比较最大值
|
|
|
+ if data.Value > indexMax {
|
|
|
+ indexMax = data.Value
|
|
|
+ }
|
|
|
+
|
|
|
+ // 比较最小值
|
|
|
+ if data.Value < indexMin {
|
|
|
+ indexMin = data.Value
|
|
|
+ }
|
|
|
+
|
|
|
+ // 比较最新时间和对应值
|
|
|
+ currentTime, err := time.Parse(utils.YearMonthDay, data.DataTime)
|
|
|
+ if err != nil {
|
|
|
+ // 时间解析失败，跳过此项
|
|
|
+ continue
|
|
|
+ }
|
|
|
+
|
|
|
+ // 如果当前时间更晚
|
|
|
+ if currentTime.After(latestTime) {
|
|
|
+ latestTime = currentTime
|
|
|
+ indexLatestDate = data.DataTime
|
|
|
+ indexLatestValue = data.Value
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
+ // 更新保存指标和配置的映射关系
|
|
|
+ mappingList, err := residual_analysis_model.GetConfigMappingListByConfigId(req.ConfigId)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ // 判断是更新还是修改 看指标配置映射中，是否存在对应指标 存在 则更新 不存在 则新增
|
|
|
+ var edbInfoMapping residual_analysis_model.CalculateResidualAnalysisConfigMapping
|
|
|
+ for _, mapping := range mappingList {
|
|
|
+ if req.IndexType == mapping.IndexType && req.IndexType != 0 {
|
|
|
+ edbInfoMapping = mapping
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var edbInfoId int64
|
|
|
+ var edbCode string
|
|
|
// 更新or新增
|
|
|
- if req.EdbCode != "" {
|
|
|
+ if edbInfoMapping.EdbInfoId > 0 {
|
|
|
// 查询指标库指标
|
|
|
- edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_RESIDUAL_ANALYSIS, req.EdbCode)
|
|
|
+ edbInfo, err := data_manage.GetEdbInfoById(int(edbInfoMapping.EdbInfoId))
|
|
|
if err != nil {
|
|
|
return err
|
|
|
}
|
|
|
if edbInfo == nil {
|
|
|
- return fmt.Errorf("指标不存在", nil)
|
|
|
+ return fmt.Errorf("指标不存在")
|
|
|
}
|
|
|
- // todo 须补充更新指标最大值，最小值，数据最新时间，
|
|
|
- err = edbInfo.Update([]string{"min_value", "max_value", "latest_date", "latest_value"})
|
|
|
+ edbInfoId = int64(edbInfo.EdbInfoId)
|
|
|
+ edbCode = edbInfo.EdbCode
|
|
|
+
|
|
|
+ if edbInfoByCondition != nil && edbInfoByCondition.EdbInfoId != edbInfo.EdbInfoId {
|
|
|
+ return fmt.Errorf("指标名称重复")
|
|
|
+ }
|
|
|
+
|
|
|
+ // 须补充更新指标最大值，最小值，数据最新时间，数据最新值
|
|
|
+ edbInfo.MaxValue = indexMax
|
|
|
+ edbInfo.MinValue = indexMin
|
|
|
+ edbInfo.LatestDate = indexLatestDate
|
|
|
+ edbInfo.LatestValue = indexLatestValue
|
|
|
+ edbInfo.Unit = req.Unit
|
|
|
+ edbInfo.Frequency = req.Frequency
|
|
|
+ edbInfo.ClassifyId = req.ClassifyId
|
|
|
+ edbInfo.EdbName = req.EdbName
|
|
|
+ err = edbInfo.Update([]string{"min_value", "max_value", "latest_date", "latest_value", "unit", "frequency", "classify_id", "edb_name"})
|
|
|
if err != nil {
|
|
|
return err
|
|
|
}
|
|
|
|
|
|
// 删除对应得指标数据
|
|
|
- err = residual_analysis_model.DeleteResidualAnalysisDataByEdbCode(req.EdbCode)
|
|
|
+ err = residual_analysis_model.DeleteResidualAnalysisDataByEdbCode(edbInfo.EdbCode)
|
|
|
if err != nil {
|
|
|
- return fmt.Errorf("删除指标数据失败", nil)
|
|
|
+ return fmt.Errorf("删除指标数据失败")
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if edbInfoByCondition != nil {
|
|
|
+ return fmt.Errorf("指标名称重复")
|
|
|
}
|
|
|
- }
|
|
|
- // 新增指标
|
|
|
- edbCode, err := utils.GenerateEdbCode(1, "")
|
|
|
- if err != nil {
|
|
|
- return err
|
|
|
- }
|
|
|
|
|
|
- _, err = data_manage.AddEdbInfo(&data_manage.EdbInfo{
|
|
|
- EdbCode: edbCode,
|
|
|
- EdbName: req.EdbName,
|
|
|
- EdbNameEn: req.EdbNameEn,
|
|
|
- EdbType: req.EdbType,
|
|
|
- Unit: req.Unit,
|
|
|
- UnitEn: req.UnitEn,
|
|
|
- Frequency: req.Frequency,
|
|
|
- Source: utils.DATA_SOURCE_RESIDUAL_ANALYSIS,
|
|
|
- SourceName: "残差分析",
|
|
|
- })
|
|
|
- if err != nil {
|
|
|
- return err
|
|
|
+ // 新增指标
|
|
|
+ edbCode, err = utils.GenerateEdbCode(1, "")
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
|
|
|
+
|
|
|
+ edbInfoId, err = data_manage.AddEdbInfo(&data_manage.EdbInfo{
|
|
|
+ EdbCode: edbCode,
|
|
|
+ UniqueCode: utils.MD5(utils.CHART_PREFIX + "_" + timestamp),
|
|
|
+ EdbName: req.EdbName,
|
|
|
+ EdbNameEn: req.EdbNameEn,
|
|
|
+ ClassifyId: req.ClassifyId,
|
|
|
+ EdbType: req.EdbType,
|
|
|
+ Unit: req.Unit,
|
|
|
+ UnitEn: req.UnitEn,
|
|
|
+ Frequency: req.Frequency,
|
|
|
+ Source: req.Source,
|
|
|
+ SourceName: "残差分析",
|
|
|
+ Calendar: req.Calendar,
|
|
|
+ SysUserRealName: sysUser.RealName,
|
|
|
+ SysUserId: sysUser.AdminId,
|
|
|
+ LatestDate: indexLatestDate,
|
|
|
+ LatestValue: indexLatestValue,
|
|
|
+ MinValue: indexMin,
|
|
|
+ MaxValue: indexMax,
|
|
|
+ CreateTime: time.Now(),
|
|
|
+ ModifyTime: time.Now(),
|
|
|
+ })
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ // 新增指标配置关系
|
|
|
+ _, err = residual_analysis_model.SaveConfigMapping(residual_analysis_model.CalculateResidualAnalysisConfigMapping{
|
|
|
+ CalculateResidualAnalysisConfigId: req.ConfigId,
|
|
|
+ EdbInfoId: edbInfoId,
|
|
|
+ ResidualType: req.ResidualType,
|
|
|
+ IndexType: req.IndexType,
|
|
|
+ CreateTime: time.Now(),
|
|
|
+ ModifyTime: time.Now(),
|
|
|
+ })
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// 新增数据
|
|
|
- edbInfoId, err := residual_analysis_model.AddResidualAnalysisData(req.DataList)
|
|
|
- if err != nil {
|
|
|
- return err
|
|
|
+ for i := range req.DataList {
|
|
|
+ req.DataList[i].EdbDataId = 0
|
|
|
+ req.DataList[i].EdbInfoId = int(edbInfoId)
|
|
|
+ req.DataList[i].EdbCode = edbCode
|
|
|
}
|
|
|
-
|
|
|
- // 更新保存指标和配置的映射关系
|
|
|
- mappingList, err := residual_analysis_model.GetConfigMappingListByConfigId(req.ConfigId)
|
|
|
+ _, err = residual_analysis_model.AddResidualAnalysisData(req.DataList)
|
|
|
if err != nil {
|
|
|
return err
|
|
|
}
|
|
|
- flag := true
|
|
|
+
|
|
|
+ // 新增自变量 因变量与配置得关系 配置中不存在该指标，则新增
|
|
|
+ var indexMap = make(map[int64]residual_analysis_model.CalculateResidualAnalysisConfigMapping)
|
|
|
for _, mapping := range mappingList {
|
|
|
- if mapping.CalculateResidualAnalysisConfigId == req.ConfigId {
|
|
|
- flag = false
|
|
|
- }
|
|
|
+ indexMap[mapping.EdbInfoId] = mapping
|
|
|
}
|
|
|
|
|
|
- if flag {
|
|
|
+ if _, ok := indexMap[int64(req.EdbInfoIdA)]; !ok {
|
|
|
_, err = residual_analysis_model.SaveConfigMapping(residual_analysis_model.CalculateResidualAnalysisConfigMapping{
|
|
|
CalculateResidualAnalysisConfigId: req.ConfigId,
|
|
|
- EdbInfoId: edbInfoId,
|
|
|
+ EdbInfoId: int64(req.EdbInfoIdA),
|
|
|
ResidualType: req.ResidualType,
|
|
|
+ IndexType: 3,
|
|
|
+ CreateTime: time.Now(),
|
|
|
+ ModifyTime: time.Now(),
|
|
|
+ })
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if _, ok := indexMap[int64(req.EdbInfoIdB)]; !ok {
|
|
|
+ _, err = residual_analysis_model.SaveConfigMapping(residual_analysis_model.CalculateResidualAnalysisConfigMapping{
|
|
|
+ CalculateResidualAnalysisConfigId: req.ConfigId,
|
|
|
+ EdbInfoId: int64(req.EdbInfoIdB),
|
|
|
+ ResidualType: req.ResidualType,
|
|
|
+ IndexType: 4,
|
|
|
+ CreateTime: time.Now(),
|
|
|
+ ModifyTime: time.Now(),
|
|
|
})
|
|
|
if err != nil {
|
|
|
return err
|
|
|
@@ -408,7 +616,7 @@ func ResidualAnalysisDetail(edbInfoId int) (residual_analysis_model.ResidualAnal
|
|
|
}
|
|
|
|
|
|
if len(mappingList) <= 0 {
|
|
|
- return residual_analysis_model.ResidualAnalysisDetailResp{}, fmt.Errorf("指标不存在", nil)
|
|
|
+ return residual_analysis_model.ResidualAnalysisDetailResp{}, fmt.Errorf("指标不存在")
|
|
|
}
|
|
|
|
|
|
mapping := mappingList[0]
|
|
|
@@ -419,8 +627,19 @@ func ResidualAnalysisDetail(edbInfoId int) (residual_analysis_model.ResidualAnal
|
|
|
}
|
|
|
|
|
|
var edbInfoIdList []int64
|
|
|
+ var edbInfoMap = make(map[int64]residual_analysis_model.CalculateResidualAnalysisConfigMapping)
|
|
|
+ var mappgingFlag = false
|
|
|
+ var residualFlag = false
|
|
|
for _, v := range configMappingList {
|
|
|
edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
|
|
|
+
|
|
|
+ edbInfoMap[v.EdbInfoId] = v
|
|
|
+
|
|
|
+ if v.IndexType == 1 {
|
|
|
+ mappgingFlag = true
|
|
|
+ } else if v.IndexType == 2 {
|
|
|
+ residualFlag = true
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
condition = ""
|
|
|
@@ -442,15 +661,76 @@ func ResidualAnalysisDetail(edbInfoId int) (residual_analysis_model.ResidualAnal
|
|
|
return residual_analysis_model.ResidualAnalysisDetailResp{}, err
|
|
|
}
|
|
|
|
|
|
+ var edbInfoListResp []*residual_analysis_model.DetailEdbInfoList
|
|
|
+ var dependentEdbInfo residual_analysis_model.DetailEdbInfoList
|
|
|
+ var independentEdbInfo residual_analysis_model.DetailEdbInfoList
|
|
|
+ for _, edbInfo := range edbInfoList {
|
|
|
+ var indexType int
|
|
|
+ if _, ok := edbInfoMap[int64(edbInfo.EdbInfoId)]; ok {
|
|
|
+ indexType = edbInfoMap[int64(edbInfo.EdbInfoId)].IndexType
|
|
|
+ }
|
|
|
+
|
|
|
+ info := residual_analysis_model.DetailEdbInfoList{
|
|
|
+ EdbInfoId: edbInfo.EdbInfoId,
|
|
|
+ EdbInfoType: edbInfo.EdbInfoType,
|
|
|
+ IndexType: indexType,
|
|
|
+ SourceName: edbInfo.SourceName,
|
|
|
+ Source: edbInfo.Source,
|
|
|
+ EdbCode: edbInfo.EdbCode,
|
|
|
+ EdbName: edbInfo.EdbName,
|
|
|
+ EdbNameEn: edbInfo.EdbNameEn,
|
|
|
+ Unit: edbInfo.Unit,
|
|
|
+ UnitEn: edbInfo.UnitEn,
|
|
|
+ Frequency: edbInfo.Frequency,
|
|
|
+ FrequencyEn: edbInfo.FrequencyEn,
|
|
|
+ ClassifyId: edbInfo.ClassifyId,
|
|
|
+ }
|
|
|
+ edbInfoListResp = append(edbInfoListResp, &info)
|
|
|
+
|
|
|
+ if indexType == 3 {
|
|
|
+ dependentEdbInfo = info
|
|
|
+ } else if indexType == 4 {
|
|
|
+ independentEdbInfo = info
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 补充表格中 映射指标或者残差指标
|
|
|
+ if mappgingFlag && !residualFlag {
|
|
|
+ info := residual_analysis_model.DetailEdbInfoList{
|
|
|
+ IndexType: 2,
|
|
|
+ EdbName: independentEdbInfo.EdbName + "映射残差/" + dependentEdbInfo.EdbName,
|
|
|
+ EdbNameEn: dependentEdbInfo.EdbNameEn,
|
|
|
+ Unit: dependentEdbInfo.Unit,
|
|
|
+ UnitEn: dependentEdbInfo.UnitEn,
|
|
|
+ Frequency: dependentEdbInfo.Frequency,
|
|
|
+ FrequencyEn: dependentEdbInfo.FrequencyEn,
|
|
|
+ ClassifyId: dependentEdbInfo.ClassifyId,
|
|
|
+ }
|
|
|
+ edbInfoListResp = append(edbInfoListResp, &info)
|
|
|
+ } else if !mappgingFlag && residualFlag {
|
|
|
+ info := residual_analysis_model.DetailEdbInfoList{
|
|
|
+ IndexType: 1,
|
|
|
+ EdbName: dependentEdbInfo.EdbName + "映射" + independentEdbInfo.EdbName,
|
|
|
+ EdbNameEn: dependentEdbInfo.EdbNameEn,
|
|
|
+ Unit: dependentEdbInfo.Unit,
|
|
|
+ UnitEn: dependentEdbInfo.UnitEn,
|
|
|
+ Frequency: dependentEdbInfo.Frequency,
|
|
|
+ FrequencyEn: dependentEdbInfo.FrequencyEn,
|
|
|
+ ClassifyId: dependentEdbInfo.ClassifyId,
|
|
|
+ }
|
|
|
+ edbInfoListResp = append(edbInfoListResp, &info)
|
|
|
+ }
|
|
|
+
|
|
|
resp := residual_analysis_model.ResidualAnalysisDetailResp{
|
|
|
- ConfigInfo: &configInfo,
|
|
|
- EdbInfoList: edbInfoList,
|
|
|
+ ConfigInfo: &configInfo,
|
|
|
+ EdbInfoList: edbInfoListResp,
|
|
|
+ ResidualType: mapping.ResidualType,
|
|
|
}
|
|
|
|
|
|
return resp, nil
|
|
|
}
|
|
|
|
|
|
-func SaveResidualAnalysisConfig(req residual_analysis_model.ResidualAnalysisReq, sysUser *system.Admin) error {
|
|
|
+func SaveResidualAnalysisConfig(req residual_analysis_model.ResidualAnalysisReq, sysUser *system.Admin) (int64, error) {
|
|
|
|
|
|
config := residual_analysis_model.ResidualAnalysisConfigVo{
|
|
|
DateType: req.DateType,
|
|
|
@@ -473,42 +753,80 @@ func SaveResidualAnalysisConfig(req residual_analysis_model.ResidualAnalysisReq,
|
|
|
// 转换为json格式
|
|
|
configJson, err := json.Marshal(config)
|
|
|
if err != nil {
|
|
|
- return err
|
|
|
+ return 0, err
|
|
|
}
|
|
|
|
|
|
- var condition string
|
|
|
- var pars []interface{}
|
|
|
// 新增or更新
|
|
|
- if req.EdbInfoId > 0 {
|
|
|
- condition += " and edb_info_id=?"
|
|
|
- pars = append(pars, req.EdbInfoId)
|
|
|
- configMappings, err := residual_analysis_model.GetConfigMappingListByCondition(condition, pars)
|
|
|
- if err != nil {
|
|
|
- return err
|
|
|
- }
|
|
|
- if len(configMappings) > 0 {
|
|
|
- mapping := configMappings[0]
|
|
|
- configInfo, err := residual_analysis_model.GetResidualAnalysisConfigById(mapping.CalculateResidualAnalysisConfigId)
|
|
|
+ /*
|
|
|
+ var condition string
|
|
|
+ var pars []interface{}
|
|
|
+ if req.EdbInfoId > 0 {
|
|
|
+ condition += " and edb_info_id=?"
|
|
|
+ pars = append(pars, req.EdbInfoId)
|
|
|
+ configMappings, err := residual_analysis_model.GetConfigMappingListByCondition(condition, pars)
|
|
|
if err != nil {
|
|
|
- return err
|
|
|
+ return 0, err
|
|
|
}
|
|
|
- configInfo.Config = string(configJson)
|
|
|
- err = residual_analysis_model.UpdateResidualAnalysisConfig(configInfo)
|
|
|
- if err != nil {
|
|
|
- return err
|
|
|
+ if len(configMappings) > 0 {
|
|
|
+ mapping := configMappings[0]
|
|
|
+ configInfo, err := residual_analysis_model.GetResidualAnalysisConfigById(mapping.CalculateResidualAnalysisConfigId)
|
|
|
+ if err != nil {
|
|
|
+ return 0, err
|
|
|
+ }
|
|
|
+ configInfo.Config = string(configJson)
|
|
|
+ err = residual_analysis_model.UpdateResidualAnalysisConfig(configInfo)
|
|
|
+ if err != nil {
|
|
|
+ return 0, err
|
|
|
+ }
|
|
|
}
|
|
|
+ }*/
|
|
|
+ var configId int64
|
|
|
+ if req.ConfigId > 0 {
|
|
|
+ configInfo, err := residual_analysis_model.GetResidualAnalysisConfigById(req.ConfigId)
|
|
|
+ if err != nil {
|
|
|
+ return 0, err
|
|
|
+ }
|
|
|
+ if configInfo.CalculateResidualAnalysisConfigId == 0 {
|
|
|
+ return 0, fmt.Errorf("未找到配置信息")
|
|
|
+ }
|
|
|
+
|
|
|
+ configId = int64(configInfo.CalculateResidualAnalysisConfigId)
|
|
|
+ configInfo.Config = string(configJson)
|
|
|
+
|
|
|
+ err = residual_analysis_model.UpdateResidualAnalysisConfig(configInfo)
|
|
|
+ if err != nil {
|
|
|
+ return 0, err
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ analysisConfig := residual_analysis_model.CalculateResidualAnalysisConfig{
|
|
|
+ Config: string(configJson),
|
|
|
+ SysUserId: sysUser.AdminId,
|
|
|
+ CreateTime: time.Now(),
|
|
|
+ ModifyTime: time.Now(),
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- analysisConfig := residual_analysis_model.CalculateResidualAnalysisConfig{
|
|
|
- Config: string(configJson),
|
|
|
- SysUserId: sysUser.AdminId,
|
|
|
+ configId, err = residual_analysis_model.SaveResidualAnalysisConfig(analysisConfig)
|
|
|
+ if err != nil {
|
|
|
+ return 0, err
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- _, err = residual_analysis_model.SaveResidualAnalysisConfig(analysisConfig)
|
|
|
+ return configId, nil
|
|
|
+}
|
|
|
+
|
|
|
+func CheckResidualAnalysisExist(configId int) (int64, error) {
|
|
|
+
|
|
|
+ configMappingList, err := residual_analysis_model.GetConfigMappingListByConfigId(configId)
|
|
|
if err != nil {
|
|
|
- return err
|
|
|
+ return 0, err
|
|
|
}
|
|
|
|
|
|
- return nil
|
|
|
+ var configMapping residual_analysis_model.CalculateResidualAnalysisConfigMapping
|
|
|
+ for _, mapping := range configMappingList {
|
|
|
+ if mapping.IndexType == 2 {
|
|
|
+ configMapping = mapping
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return configMapping.EdbInfoId, nil
|
|
|
}
|
xiziwen