package controllers

import (
	"encoding/json"
	"fmt"
	"hongze/hongze_edb_lib/models"
	"hongze/hongze_edb_lib/services"
	"hongze/hongze_edb_lib/utils"
	"strconv"
	"strings"
	"time"
)

// PredictCalculateController 预测计算指标
type PredictCalculateController struct {
	BaseAuthController
}

// Save
// @Title 新增/编辑预测指标运算接口
// @Description 新增预测指标运算接口
// @Success 200 {object} models.EdbInfoCalculateSaveReq
// @router /save [post]
func (this *PredictCalculateController) Save() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.EdbInfoCalculateSaveReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.EdbInfoId <= 0 {
		addPredictCalculate(br, req)
	} else {
		editPredictCalculate(br, req)
	}
}

// AddPredictCalculate 添加预测指标运算
func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {

	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if len(req.EdbInfoIdArr) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	if req.CalculateFormula == "" {
		br.Msg = "请填写指标"
		return
	}

	//加入缓存机制，避免创建同一个名称的指标 start
	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT_CALCULATE, ":", req.EdbName)
	isExist := utils.Rc.IsExist(redisKey)
	if isExist {
		br.Msg = "指标正在处理,请勿重复提交"
		return
	} else {
		//设置3分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Second*300)
		defer func() {
			utils.Rc.Delete(redisKey)
		}()
	}

	calculateFormula := req.CalculateFormula
	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
	if strings.Contains(req.CalculateFormula, "%") {
		calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
	}
	req.CalculateFormula = calculateFormula

	//检验公式
	var formulaStr string
	var edbInfoIdBytes []string
	for _, v := range req.EdbInfoIdArr {
		formulaStr += v.FromTag + ","
		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
	}
	formulaMap := services.CheckFormula(req.CalculateFormula)
	for _, v := range formulaMap {
		if !strings.Contains(formulaStr, v) {
			br.Msg = "公式错误，请重新填写"
			return
		}
	}

	// 判断指标名称是否存在
	{
		var condition string
		var pars []interface{}
		// 指标类型，0：普通指标，1：预测指标
		condition += " AND edb_info_type=?  AND edb_name=? "
		pars = append(pars, 1, req.EdbName)

		count, err := models.GetEdbInfoCountByCondition(condition, pars)
		if err != nil {
			br.Msg = "判断指标名称是否存在失败"
			br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
			return
		}
		if count > 0 {
			br.Msg = "指标名称已存在，请重新填写"
			br.ErrMsg = "指标名称已存在，请重新填写"
			return
		}
	}

	// 关联指标信息
	edbInfoList := make([]*models.EdbInfo, 0)
	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
	for k, v := range req.EdbInfoIdArr {
		fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "生成计算指标失败"
				br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
				return
			}
			br.Msg = "生成计算指标失败"
			br.Msg = "获取指标失败:Err:" + err.Error()
			return
		}
		edbInfoList = append(edbInfoList, fromEdbInfo)

		//关联关系表
		{
			calculateMappingItem := &models.EdbInfoCalculateMapping{
				CreateTime: time.Now(),
				ModifyTime: time.Now(),
				Sort:       k + 1,
				//EdbCode:        edbCode,
				//EdbInfoId:      int(edbInfoId),
				FromEdbInfoId:  fromEdbInfo.EdbInfoId,
				FromEdbCode:    fromEdbInfo.EdbCode,
				FromEdbName:    fromEdbInfo.EdbName,
				FromSource:     fromEdbInfo.Source,
				FromSourceName: fromEdbInfo.SourceName,
				FromTag:        v.FromTag,
				Source:         utils.DATA_SOURCE_PREDICT_CALCULATE,
				SourceName:     "预测指标运算",
			}
			calculateMappingList = append(calculateMappingList, calculateMappingItem)
		}
	}

	// 指标入库
	randStr := utils.GetRandDigit(4)
	edbCode := `C2` + time.Now().Format("060102") + randStr
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
	edbInfo := &models.EdbInfo{
		EdbInfoType:      1,
		Source:           utils.DATA_SOURCE_PREDICT_CALCULATE,
		SourceName:       "预测指标运算",
		EdbCode:          edbCode,
		EdbName:          req.EdbName,
		EdbNameSource:    req.EdbName,
		Frequency:        req.Frequency,
		Unit:             req.Unit,
		ClassifyId:       req.ClassifyId,
		SysUserId:        req.AdminId,
		SysUserRealName:  req.AdminName,
		CreateTime:       time.Now(),
		ModifyTime:       time.Now(),
		UniqueCode:       uniqueCode,
		CalculateFormula: req.CalculateFormula,
		EdbType:          2,
	}
	edbInfoId, err := models.AddEdbInfo(edbInfo)
	if err != nil {
		br.Msg = "生成计算指标失败"
		br.Msg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
		return
	}
	edbInfo.EdbInfoId = int(edbInfoId)

	//处理同名指标
	{
		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
					return
				}
			}
		}
	}

	//关联关系表入库
	{
		if len(calculateMappingList) > 0 {
			for k, v := range calculateMappingList {
				v.EdbCode = edbInfo.EdbCode
				v.EdbInfoId = edbInfo.EdbInfoId
				calculateMappingList[k] = v
			}
			go models.AddEdbInfoCalculateMappingMulti(calculateMappingList)
		}
	}

	// 开始添加预测指标
	latestDateStr, latestValue, err := models.AddPredictCalculateData(edbInfoList, int(edbInfoId), edbCode, req.CalculateFormula, edbInfoIdBytes)
	if err != nil {
		br.Msg = "生成计算指标失败"
		br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
		return
	}

	// 更新指标最大最小值
	err, errMsg := models.UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	resp := models.AddEdbInfoResp{
		EdbInfoId:  int(edbInfoId),
		UniqueCode: uniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// editPredictCalculate 编辑预测指标运算
func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {
	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if len(req.EdbInfoIdArr) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	if req.CalculateFormula == "" {
		br.Msg = "请填写指标"
		return
	}

	//加入缓存机制，避免创建同一个名称的指标 start
	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT_CALCULATE, ":", req.EdbName)
	isExist := utils.Rc.IsExist(redisKey)
	if isExist {
		br.Msg = "指标正在处理,请勿重复提交"
		return
	} else {
		//设置3分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Second*300)
		defer func() {
			utils.Rc.Delete(redisKey)
		}()
	}

	calculateFormula := req.CalculateFormula
	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
	if strings.Contains(req.CalculateFormula, "%") {
		calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
	}
	req.CalculateFormula = calculateFormula

	//检验公式
	var formulaStr string
	var edbInfoIdBytes []string
	for _, v := range req.EdbInfoIdArr {
		formulaStr += v.FromTag + ","
		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
	}
	formulaMap := services.CheckFormula(req.CalculateFormula)
	for _, v := range formulaMap {
		if !strings.Contains(formulaStr, v) {
			br.Msg = "公式错误，请重新填写"
			return
		}
	}

	// 获取计算指标信息
	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}
	// 判断指标名称是否存在
	{
		var condition string
		var pars []interface{}
		// 指标类型，0：普通指标，1：预测指标
		condition += " AND edb_info_id !=?  AND edb_info_type=?  AND edb_name=? "
		pars = append(pars, edbInfo.EdbInfoId, edbInfo.EdbInfoType, req.EdbName)

		count, err := models.GetEdbInfoCountByCondition(condition, pars)
		if err != nil {
			br.Msg = "判断指标名称是否存在失败"
			br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
			return
		}
		if count > 0 {
			br.Msg = "指标名称已存在，请重新填写"
			br.ErrMsg = "指标名称已存在，请重新填写"
			return
		}
	}

	// 关联指标信息
	edbInfoList := make([]*models.EdbInfo, 0)
	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
	for k, v := range req.EdbInfoIdArr {
		fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "生成计算指标失败"
				br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
				return
			}
			br.Msg = "生成计算指标失败"
			br.Msg = "获取指标失败:Err:" + err.Error()
			return
		}
		edbInfoList = append(edbInfoList, fromEdbInfo)

		//关联关系表
		{
			calculateMappingItem := &models.EdbInfoCalculateMapping{
				CreateTime:     time.Now(),
				ModifyTime:     time.Now(),
				Sort:           k + 1,
				EdbCode:        edbInfo.EdbCode,
				EdbInfoId:      edbInfo.EdbInfoId,
				FromEdbInfoId:  fromEdbInfo.EdbInfoId,
				FromEdbCode:    fromEdbInfo.EdbCode,
				FromEdbName:    fromEdbInfo.EdbName,
				FromSource:     fromEdbInfo.Source,
				FromSourceName: fromEdbInfo.SourceName,
				FromTag:        v.FromTag,
				Source:         utils.DATA_SOURCE_PREDICT_CALCULATE,
				SourceName:     "预测指标运算",
			}
			calculateMappingList = append(calculateMappingList, calculateMappingItem)
		}
	}

	//处理同名指标
	{
		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
					return
				}
			}
		}
	}

	edbInfo.EdbName = req.EdbName
	edbInfo.Frequency = req.Frequency
	edbInfo.Unit = req.Unit
	edbInfo.ClassifyId = req.ClassifyId
	edbInfo.CalculateFormula = req.CalculateFormula
	err = models.EditPredictCalculate(edbInfo, calculateMappingList)
	if err != nil {
		br.Msg = "修改计算指标失败"
		br.Msg = "修改计算指标失败,Calculate Err:" + err.Error()
		return
	}

	// 开始添加预测指标
	latestDateStr, latestValue, err := models.AddPredictCalculateData(edbInfoList, edbInfo.EdbInfoId, edbInfo.EdbCode, req.CalculateFormula, edbInfoIdBytes)
	if err != nil {
		br.Msg = "生成计算指标失败"
		br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
		return
	}

	// 更新指标最大最小值
	err, errMsg := models.UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: edbInfo.UniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Refresh
// @Title 刷新计算指标接口
// @Description 刷新计算指标接口
// @Success 200 {object} models.RefreshEdbInfoReq
// @router /refresh [post]
func (this *PredictCalculateController) Refresh() {
	br := new(models.BaseResponse).Init()
	var cacheKey string
	defer func() {
		utils.Rc.Delete(cacheKey)
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.RefreshEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.EdbCode == "" {
		br.Msg = "请输入指标编码！"
		br.ErrMsg = "请输入指标编码，指标编码为空"
		return
	}
	if req.EdbInfoId <= 0 {
		br.Msg = "请输入指标ID！"
		br.ErrMsg = "请输入指标ID"
		return
	}
	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "指标不存在！"
		br.ErrMsg = "指标不存在"
		return
	}

	cacheKey = utils.CACHE_EDB_DATA_REFRESH + strconv.Itoa(edbInfo.Source) + "_" + req.EdbCode
	if !utils.Rc.IsExist(cacheKey) {
		utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)

		startDate := req.StartDate
		var errMsg string
		endDate := time.Now().Format(utils.FormatDate)
		edbInfoId := edbInfo.EdbInfoId
		source := edbInfo.Source

		switch source {
		case utils.DATA_SOURCE_CALCULATE:
			//startDate = edbInfo.StartDate
			//sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
			//if err != nil {
			//	return
			//}
			//startDate = sTime.Format(utils.FormatDate)
			startDate = ""
			var edbInfoIdBytes []string
			calculateMap, err := models.GetEdbInfoCalculateDetailList(edbInfo.EdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateDetail Err:" + err.Error()
				break
			}
			var formulaStr string
			edbInfoList := make([]*models.EdbInfo, 0)

			for _, v := range calculateMap {
				formulaStr += v.FromTag + ","
				edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
				edbInfo, _ := models.GetEdbInfoById(v.FromEdbInfoId)
				edbInfoList = append(edbInfoList, edbInfo)
			}
			err = models.RefreshAllCalculate(edbInfoList, edbInfo.EdbInfoId, source, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshCalculate Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_LJZZY: //刷新累计值转月值
			calculateLjzzy, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			err = models.RefreshAllCalculateLjzzy(edbInfoId, source, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateLjzzy Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_TBZ: //刷新同比值
			calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			err = models.RefreshAllCalculateTbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateTbz Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_TCZ: //同差值
			calculateTcz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateTczDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateTcz.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			err = models.RefreshAllCalculateTcz(edbInfoId, source, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshCalculateTcz Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS: //N数值移动平均计算
			calculateNszydpjjs, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
			startDate = edbInfo.StartDate
			err = models.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode, startDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshCalculateNszydpjjs Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_HBZ: //刷新环比值
			calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateHbzDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
			err = models.RefreshAllCalculateHbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateHbz Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_HCZ: //刷新环差值
			calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateHczDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
			err = models.RefreshAllCalculateHcz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateHcz Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_BP: //刷新变频
			calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			err = models.RefreshAllCalculateBp(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateBp Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT:
			calculate, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
				break
			}
			fromEdbInfo, err := models.GetEdbInfoById(calculate.FromEdbInfoId)
			if err != nil {
				errMsg = "GetEdbInfoById Err:" + err.Error()
				break
			}
			startDate = edbInfo.StartDate
			endDate = time.Now().Format(utils.FormatDate)
			formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
			err = models.RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateTimeShift Err:" + err.Error()
			}
		case utils.DATA_SOURCE_CALCULATE_ZJPJ: //刷新直接拼接
			err = models.RefreshAllCalculateZjpj(edbInfo)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateZjpj Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_CALCULATE_LJZTBPJ: //刷新累计值同比拼接
			err = models.RefreshAllCalculateLjztbpj(edbInfo)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllCalculateLjztbpj Err:" + err.Error()
				break
			}
		case utils.DATA_SOURCE_PYTHON: //python代码运算
			edbPythonCode, err := models.GetEdbPythonCodeById(edbInfo.EdbInfoId)
			if err != nil {
				errMsg = "获取python代码失败 Err:" + err.Error()
				break
			}
			edbData, err, errMsg := services.ExecPythonCode(edbInfo.EdbCode, edbPythonCode.PythonCode)
			if err != nil {
				br.Msg = "获取数据失败"
				br.ErrMsg = "python代码获取数据失败，err:" + err.Error()
				if errMsg != "" {
					br.ErrMsg = errMsg
				}
				return
			}
			err = models.RefreshAllPythonEdb(edbInfo, edbData)
			if err != nil && err.Error() != utils.ErrNoRow() {
				errMsg = "RefreshAllPythonEdb Err:" + err.Error()
				break
			}

		default:
			br.Msg = "来源异常，请联系相关开发！"
			br.ErrMsg = "来源异常，请联系相关开发"
			return
		}
		if errMsg != `` {
			br.Msg = "刷新指标失败！"
			br.ErrMsg = "刷新指标失败，err:" + errMsg
			return
		}

		// 更新指标最大最小值
		err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
		if err != nil {
			br.Msg = errMsg
			br.ErrMsg = err.Error()
			return
		}
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
	} else {
		br.Ret = 501
		br.Success = true
		br.Msg = "系统处理中，请稍后重试"
	}
}