eta_api/services/residual_analysis_service/residual_analysis_service.go

package residual_analysis_service

import (
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/residual_analysis_model"
	"eta/eta_api/utils"
	"fmt"
	"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())
	}

	var edbInfoMappingA, edbInfoMappingB *data_manage.ChartEdbInfoMapping
	for _, v := range mappingList {
		if v.EdbInfoId == req.EdbInfoIdA {
			edbInfoMappingA = v
		}
		if v.EdbInfoId == req.EdbInfoIdB {
			edbInfoMappingB = v
		}
	}
	if edbInfoMappingA == nil {
		return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标A不存在", nil)
	}
	if edbInfoMappingB == nil {
		return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("指标B不存在", nil)
	}

	// 时间处理
	var startDate, endDate string
	switch req.DateType {
	case 0:
		startDate = req.StartDate
		endDate = req.EndDate
	case 1:
		startDate = req.StartDate
		endDate = ""
	default:
		startDate = utils.GetPreYear(req.DateType)
		endDate = ""
	}

	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

	// 原始图表信息
	var OriginalEdbList []*residual_analysis_model.ResidualAnalysisChartEdbInfoMapping

	OriginalEdbList, err = fillOriginalChart(req, mappingList, startDate, endDate, edbInfoMappingA, edbInfoMappingB, OriginalEdbList)
	if err != nil {
		return residual_analysis_model.ResidualAnalysisResp{}, err
	}
	baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingB.EdbName

	resp.OriginalChartData = residual_analysis_model.ChartResp{
		ChartInfo:   baseChartInfo,
		EdbInfoList: OriginalEdbList,
	}

	dataAList, ok := edbInfoMappingA.DataList.([]data_manage.EdbDataList)
	if !ok {
		return residual_analysis_model.ResidualAnalysisResp{}, fmt.Errorf("数据类型转换失败", nil)
	}
	indexADataMap := map[string]data_manage.EdbDataList{}
	for _, indexData := range dataAList {
		indexADataMap[indexData.DataTime] = indexData
	}

	// 映射图表信息
	mappingEdbList, err := fillMappingChartInfo(req, edbInfoMappingA, edbInfoMappingB, OriginalEdbList, indexADataMap)
	if err != nil {
		return residual_analysis_model.ResidualAnalysisResp{}, err
	}
	baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingB.EdbName + "映射" + edbInfoMappingA.EdbName

	resp.MappingChartData = residual_analysis_model.ChartResp{
		ChartInfo:   baseChartInfo,
		EdbInfoList: mappingEdbList,
	}

	// 残差图表信息
	ResidualEdbList, err := fillResidualChartInfo(edbInfoMappingA, edbInfoMappingB, mappingEdbList)
	if err != nil {
		return residual_analysis_model.ResidualAnalysisResp{}, err
	}

	baseChartInfo.ChartName = edbInfoMappingA.EdbName + "与" + edbInfoMappingA.EdbName + "映射残差/" + edbInfoMappingB.EdbName

	resp.MappingChartData = residual_analysis_model.ChartResp{
		ChartInfo:   baseChartInfo,
		EdbInfoList: ResidualEdbList,
	}

	return resp, nil
}

func fillResidualChartInfo(edbInfoMappingA *data_manage.ChartEdbInfoMapping, edbInfoMappingB *data_manage.ChartEdbInfoMapping, mappingEdbList []*residual_analysis_model.ResidualAnalysisChartEdbInfoMapping) ([]*residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
	// 计算公式 映射残差 = 因变量指标 - 映射指标
	var edbInfoA, edbInfoB *residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
	if mappingEdbList[0].EdbInfoId == edbInfoMappingA.EdbInfoId {
		edbInfoA = mappingEdbList[0]
		edbInfoB = mappingEdbList[1]
	} else {
		edbInfoA = mappingEdbList[1]
		edbInfoB = mappingEdbList[0]
	}
	dataAList, ok := edbInfoA.DataList.([]data_manage.EdbDataList)
	if !ok {
		return nil, fmt.Errorf("数据类型转换失败", nil)
	}
	edbData := dataAList
	dataBList, ok := edbInfoB.DataList.([]data_manage.EdbDataList)
	if !ok {
		return nil, fmt.Errorf("数据类型转换失败", nil)
	}
	var indexDataBMap map[string]data_manage.EdbDataList
	for _, data := range dataBList {
		indexDataBMap[data.DataTime] = data
	}
	var valueB float64
	for _, indexData := range edbData {
		if dataB, ok := indexDataBMap[indexData.DataTime]; ok {
			valueB = dataB.Value
		} else {
			valueB = 0
		}
		indexData.Value = indexData.Value - valueB
	}
	for _, mapping := range mappingEdbList {
		if mapping.EdbInfoId != edbInfoMappingA.EdbInfoId {
			mapping.DataList = edbData
			mapping.EdbName = edbInfoMappingA.EdbName + "映射残差/" + edbInfoMappingB.EdbName
		}
	}

	return mappingEdbList, 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) {
	// 计算公式：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
	}

	dataList, ok := edbInfoMappingB.DataList.([]data_manage.EdbDataList)
	if !ok {
		return nil, fmt.Errorf("数据类型转换失败", nil)
	}

	// 领先指标 dataList进行数据处理
	if req.IndexType == 2 {
		if req.LeadValue < 0 {
			return nil, fmt.Errorf("领先值不能小于0", nil)
		} else if req.LeadValue > 0 {
			for _, indexData := range dataList {
				switch req.LeadFrequency {
				case "天":
					indexData.DataTime = utils.GetNextDayN(indexData.DataTime, req.LeadValue)
				case "周":
					indexData.DataTime = utils.GetNextDayN(indexData.DataTime, req.LeadValue*7)
				case "月":
					indexData.DataTime = utils.TimeToString(utils.AddDate(utils.StringToTime(indexData.DataTime), 0, req.LeadValue), utils.YearMonthDay)
				case "季":
					indexData.DataTime = utils.TimeToString(utils.AddDate(utils.StringToTime(indexData.DataTime), 0, req.LeadValue*3), utils.YearMonthDay)
				case "年":
					indexData.DataTime = utils.TimeToString(utils.AddDate(utils.StringToTime(indexData.DataTime), req.LeadValue, 0), utils.YearMonthDay)
				}
			}
		}
	}

	for index, indexData := range dataList {
		// 计算映射值
		indexData.Value = a*indexData.Value + b

		// 从最早时间开始 补充时间为自然日
		beforeIndexData := dataList[index]
		afterIndexData := dataList[index+1]
		if utils.IsMoreThanOneDay(beforeIndexData.DataTime, afterIndexData.DataTime) {
			replenishIndexData := data_manage.EdbDataList{
				DataTime:      utils.GetNextDay(beforeIndexData.DataTime),
				DataTimestamp: time.Now().UnixMilli(),
				Value:         beforeIndexData.Value,
			}
			dataList = append(dataList, replenishIndexData)
		}
	}
	// 根据指标A的时间key，在B的映射指标中筛选出对应的值
	var dataBList []data_manage.EdbDataList
	for _, indexData := range dataList {
		if _, ok := indexADataMap[indexData.DataTime]; ok {
			dataBList = append(dataBList, indexData)
		}
	}

	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
		}
	}
	return mappingEdbList, 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) {
	for _, v := range mappingList {
		var edbInfoMapping *residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
		edbInfoMapping.EdbInfoType = 1
		edbInfoMapping.IsOrder = false
		edbInfoMapping.IsAxis = 1
		edbInfoMapping.ChartColor = `#00F`
		edbInfoMapping.ChartWidth = 3

		// 获取图表中的指标数据
		dataList, err := data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, startDate, endDate)
		if err != nil {
			return nil, fmt.Errorf("获取指标数据失败，Err:%s", err.Error())
		}

		if v.EdbInfoId == req.EdbInfoIdB {
			edbInfoMapping.LeadValue = req.LeadValue
			edbInfoMapping.LeadUnit = req.LeadFrequency
			edbInfoMapping.EdbInfoType = req.IndexType
			edbInfoMapping.IsOrder = req.IsOrder
			edbInfoMapping.IsAxis = 0
			edbInfoMapping.ChartColor = `#F00`
			edbInfoMapping.ChartWidth = 1

			edbInfoMappingB.DataList = dataList
		} else {
			edbInfoMappingA.DataList = dataList
		}
		edbInfoMapping.EdbInfoId = v.EdbInfoId
		edbInfoMapping.EdbName = v.EdbName
		edbInfoMapping.EdbCode = v.EdbCode
		edbInfoMapping.Unit = v.Unit
		edbInfoMapping.Frequency = v.Frequency
		edbInfoMapping.Source = v.Source
		edbInfoMapping.SourceName = v.SourceName

		edbInfoMapping.DataList = dataList
		OriginalEdbList = append(OriginalEdbList, edbInfoMapping)
	}
	return OriginalEdbList, nil
}

func ContrastPreview(indexCode string) (residual_analysis_model.ResidualAnalysisChartEdbInfoMapping, error) {
	var condition string
	var pars []interface{}

	if indexCode != "" {
		condition += " and edb_code=?"
		pars = append(pars, indexCode)
	}

	edbInfo, err := data_manage.GetEdbInfoByCondition(condition, pars)
	if err != nil {
		return residual_analysis_model.ResidualAnalysisChartEdbInfoMapping{}, err
	}
	if edbInfo == nil {
		return residual_analysis_model.ResidualAnalysisChartEdbInfoMapping{}, fmt.Errorf("指标不存在")
	}

	dataList, err := data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, "", "")

	var resp residual_analysis_model.ResidualAnalysisChartEdbInfoMapping
	resp.EdbInfoId = edbInfo.EdbInfoId
	resp.SourceName = edbInfo.SourceName
	resp.EdbName = edbInfo.EdbName
	resp.Unit = edbInfo.Unit
	resp.Frequency = edbInfo.Frequency
	resp.DataList = dataList
	return resp, nil
}