fix

models/data_manage/edb_data_calculate_time_shift.go

@@ -1,13 +1,6 @@
 package data_manage
 
 import (
-	"errors"
-	"fmt"
-	"github.com/beego/beego/v2/client/orm"
-	"github.com/shopspring/decimal"
-	"hongze/hongze_chart_lib/utils"
-	"strconv"
-	"strings"
 	"time"
 )
 
@@ -28,363 +21,6 @@ type EdbInfoCalculateMove struct {
 	ModifyTime           time.Time `description:"修改时间"`
 }
 
-//时间移位
-func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
-	fmt.Println("AddCalculateTimeShift")
-	o := orm.NewOrmUsingDB("data")
-	o.Begin()
-	defer func() {
-		if err != nil {
-			fmt.Println("AddCalculateTimeShift,Err:" + err.Error())
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
-		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TIME_SHIFT
-		edbInfo.SourceName = "时间移位"
-		edbInfo.EdbCode = edbCode
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
-		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
-		edbInfo.ClassifyId = req.ClassifyId
-		edbInfo.SysUserId = sysUserId
-		edbInfo.SysUserRealName = sysUserRealName
-		edbInfo.CreateTime = time.Now()
-		edbInfo.ModifyTime = time.Now()
-		edbInfo.UniqueCode = uniqueCode
-		edbInfo.CalculateFormula = req.Formula
-		edbInfo.EdbType = 2
-		edbInfo.MoveType = req.MoveType
-		edbInfo.MoveFrequency = req.MoveFrequency
-		newEdbInfoId, err := o.Insert(edbInfo)
-		if err != nil {
-			return edbInfoId, err
-		}
-		edbInfoId = int(newEdbInfoId)
-		//关联关系
-		{
-			calculateMappingItem := new(EdbInfoCalculateMapping)
-			calculateMappingItem.CreateTime = time.Now()
-			calculateMappingItem.ModifyTime = time.Now()
-			calculateMappingItem.Sort = 1
-			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
-			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
-			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
-			calculateMappingItem.FromSource = fromEdbInfo.Source
-			calculateMappingItem.FromSourceName = fromEdbInfo.SourceName
-			calculateMappingItem.FromTag = ""
-			calculateMappingItem.Source = edbInfo.Source
-			calculateMappingItem.SourceName = edbInfo.SourceName
-			o.Insert(calculateMappingItem)
-		}
-	} else {
-		edbInfoId = req.EdbInfoId
-		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TIME_SHIFT)
-		fmt.Println("dataTableName:" + dataTableName)
-		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
-		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = o.Raw(deleteSql, req.EdbInfoId).Exec()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	var shiftDay int
-	formulaInt, _ := strconv.Atoi(req.Formula)
-	switch req.MoveFrequency {
-	case "天":
-		shiftDay = formulaInt
-	case "周":
-		shiftDay = formulaInt * 7
-	case "月":
-		shiftDay = formulaInt * 30
-	case "季":
-		shiftDay = formulaInt * 90
-	case "年":
-		shiftDay = formulaInt * 365
-	default:
-		shiftDay = formulaInt
-	}
-
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	if req.MoveType == 2 {
-		shiftDay = -shiftDay
-	}
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			newDate := currentDate.AddDate(0, 0, shiftDay)
-			timestamp := newDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, newDate.Format(utils.FormatDate), timestampStr, valStr)
-			isAdd = true
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
-	return
-}
-
-//环比值
-func EditCalculateTimeShift(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, oldEdbInfo *EdbInfo) (edbInfoId int, err error) {
-	edbInfoId = req.EdbInfoId
-	o := orm.NewOrmUsingDB("data")
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-
-	//修改指标信息
-	sql := ` UPDATE  edb_info
-			SET
-			  edb_name =?,
-			  edb_name_source=?,
-			  frequency = ?,
-			  unit = ?,
-			  classify_id = ?,
-			  move_type=?,
-			  move_frequency=?,
-			  calculate_formula=?,
-			  modify_time = NOW()
-			WHERE edb_info_id = ? `
-	_, err = o.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, req.MoveType, req.MoveFrequency, req.Formula, edbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	var existCondition string
-	var existPars []interface{}
-	existCondition += " AND edb_info_id=? "
-	existPars = append(existPars, edbInfoId)
-
-	existCondition += " AND from_edb_info_id=? "
-	existPars = append(existPars, req.FromEdbInfoId)
-
-	//判断计算指标是否被更换
-	count, err := GetEdbInfoCalculateCountByCondition(req.Source, existCondition, existPars)
-	if err != nil {
-		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
-		return
-	}
-	if count <= 0 || req.MoveType != oldEdbInfo.MoveType || req.MoveFrequency != oldEdbInfo.MoveFrequency || req.Formula != oldEdbInfo.CalculateFormula {
-		if count <= 0 {
-			//删除，计算指标关联的，基础指标的关联关系
-			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-			_, err = o.Raw(sql, edbInfoId).Exec()
-			if err != nil {
-				err = errors.New("删除计算指标关联关系失败,Err:" + err.Error())
-				return
-			}
-			//关联关系
-			{
-				calculateMappingItem := new(EdbInfoCalculateMapping)
-				calculateMappingItem.CreateTime = time.Now()
-				calculateMappingItem.ModifyTime = time.Now()
-				calculateMappingItem.Sort = 1
-				calculateMappingItem.EdbCode = edbCode
-				calculateMappingItem.EdbInfoId = edbInfoId
-				calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
-				calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
-				calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
-				calculateMappingItem.FromSource = fromEdbInfo.Source
-				calculateMappingItem.FromSourceName = fromEdbInfo.SourceName
-				calculateMappingItem.FromTag = ""
-				calculateMappingItem.Source = utils.DATA_SOURCE_CALCULATE_TIME_SHIFT
-				calculateMappingItem.SourceName = "时间移位"
-				o.Insert(calculateMappingItem)
-			}
-		}
-		//清空原有数据
-		sql = ` DELETE FROM edb_data_calculate_time_shift WHERE edb_info_id = ? `
-		_, err = o.Raw(sql, edbInfoId).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		edbInfoIdStr := strconv.Itoa(edbInfoId)
-
-		var shiftDay int
-		formulaInt, _ := strconv.Atoi(req.Formula)
-		switch req.MoveFrequency {
-		case "天":
-			shiftDay = formulaInt
-		case "周":
-			shiftDay = formulaInt * 7
-		case "月":
-			shiftDay = formulaInt * 30
-		case "季":
-			shiftDay = formulaInt * 90
-		case "年":
-			shiftDay = formulaInt * 365
-		default:
-			shiftDay = formulaInt
-		}
-
-		//计算数据
-		var condition string
-		var pars []interface{}
-		condition += " AND edb_info_id=? "
-		pars = append(pars, req.FromEdbInfoId)
-		fmt.Println("EdbInfoId:", req.FromEdbInfoId)
-		dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-		if err != nil {
-			return edbInfoId, err
-		}
-		addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-		var isAdd bool
-		existMap := make(map[string]string)
-		dataLen := len(dataList)
-		if req.MoveType == 2 {
-			shiftDay = -shiftDay
-		}
-		for i := 0; i < dataLen; i++ {
-			//当期
-			currentItem := dataList[i]
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			newDate := currentDate.AddDate(0, 0, shiftDay)
-			existKey := edbCode + newDate.Format(utils.FormatDate)
-			if _, ok := existMap[existKey]; !ok {
-				timestamp := newDate.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				addSql += GetAddSql(edbInfoIdStr, edbCode, newDate.Format(utils.FormatDate), timestampStr, valStr)
-				isAdd = true
-			}
-			existMap[existKey] = currentItem.DataTime
-		}
-		if isAdd {
-			addSql = strings.TrimRight(addSql, ",")
-			_, err = o.Raw(addSql).Exec()
-			if err != nil {
-				return edbInfoId, err
-			}
-		}
-	}
-	return
-}
-
-//变频
-func RefreshCalculateTimeShift(edbInfoId, formulaInt, moveType int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate, moveFrequency string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-
-	if err != nil {
-		return
-	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	//计算数据
-
-	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	pars = append(pars, fromEdbInfo.EdbInfoId)
-
-	if startDate != "" {
-		condition += " AND data_time>=? "
-		pars = append(pars, startDate)
-	}
-	if endDate != "" {
-		condition += " AND data_time<=? "
-		pars = append(pars, endDate)
-	}
-
-	var shiftDay int
-	switch moveFrequency {
-	case "天":
-		shiftDay = formulaInt
-	case "周":
-		shiftDay = formulaInt * 7
-	case "月":
-		shiftDay = formulaInt * 30
-	case "季":
-		shiftDay = formulaInt * 90
-	case "年":
-		shiftDay = formulaInt * 365
-	default:
-		shiftDay = formulaInt
-	}
-	if moveType == 2 {
-		shiftDay = -shiftDay
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return err
-	}
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			newDate := currentDate.AddDate(0, 0, -shiftDay)
-			timestamp := newDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, newDate.Format(utils.FormatDate), timestampStr, valStr)
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}
-
 type EdbInfoCalculateTimeShiftDetail struct {
 	EdbInfoCalculateBpId int       `orm:"column(edb_info_calculate_bp_id);pk"`
 	EdbInfoId            int       `description:"指标id"`
@@ -401,134 +37,3 @@ type EdbInfoCalculateTimeShiftDetail struct {
 	StartDate            string    `description:"开始日期"`
 	EndDate              string    `description:"结束日期"`
 }
-
-func GetEdbInfoCalculateTimeShiftDetail(edbInfoId int) (item *EdbInfoCalculateTbzDetail, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT a.*,b.start_date,b.end_date FROM edb_info_calculate_mapping AS a
-			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
-			WHERE a.edb_info_id=? `
-	err = o.Raw(sql, edbInfoId).QueryRow(&item)
-	return
-}
-
-//刷新所有变频数据
-func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate, moveFrequency string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-
-	if err != nil {
-		return
-	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	//计算数据
-
-	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	pars = append(pars, fromEdbInfo.EdbInfoId)
-
-	if startDate != "" {
-		condition += " AND data_time>=? "
-		pars = append(pars, startDate)
-	}
-	if endDate != "" {
-		condition += " AND data_time<=? "
-		pars = append(pars, endDate)
-	}
-
-	var shiftDay int
-	switch moveFrequency {
-	case "天":
-		shiftDay = formulaInt
-	case "周":
-		shiftDay = formulaInt * 7
-	case "月":
-		shiftDay = formulaInt * 30
-	case "季":
-		shiftDay = formulaInt * 90
-	case "年":
-		shiftDay = formulaInt * 365
-	default:
-		shiftDay = formulaInt
-	}
-
-	if moveType == 2 {
-		shiftDay = -shiftDay
-	}
-
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-	fmt.Println("source:", source)
-	//获取指标所有数据
-	existDataList := make([]*EdbDataBase, 0)
-	dataTableName := GetEdbDataTableName(source)
-	fmt.Println("dataTableName:", dataTableName)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
-	}
-	existDataMap := make(map[string]string)
-	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-	}
-	fmt.Println("existDataMap:", existDataMap)
-	addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
-	var isAdd bool
-
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			newDate := currentDate.AddDate(0, 0, shiftDay)
-
-			timestamp := newDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			if existVal, ok := existDataMap[newDate.Format(utils.FormatDate)]; !ok {
-				isAdd = true
-				addSql += GetAddSql(edbInfoIdStr, edbCode, newDate.Format(utils.FormatDate), timestampStr, valStr)
-			} else {
-				if existVal != valStr {
-					sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-					sql = fmt.Sprintf(sql, dataTableName)
-					_, err = o.Raw(sql, valStr, edbInfoId, newDate.Format(utils.FormatDate)).Exec()
-					if err != nil {
-						return err
-					}
-				}
-			}
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

models/target.go

@@ -540,10 +540,10 @@ func TargetDelete(tradeCode string) (err error) {
 	}()
 
 	sql := " DELETE FROM edbinfo WHERE TRADE_CODE = ? "
-	_, err = o.Raw(sql, tradeCode).Exec()
+	_, err = tx.Raw(sql, tradeCode).Exec()
 
 	sql = " DELETE FROM edbdata WHERE TRADE_CODE = ? "
-	_, err = o.Raw(sql, tradeCode).Exec()
+	_, err = tx.Raw(sql, tradeCode).Exec()
 
 	return
 }

services/data/chart_info.go

@@ -9,307 +9,6 @@ import (
 	"time"
 )
 
-func ChartInfoRefresh(chartInfoId int) (err error) {
-	var errmsg string
-	defer func() {
-		if err != nil {
-			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
-			fmt.Println("ChartInfoRefresh Err:" + errmsg)
-		}
-	}()
-	baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshData(chartInfoId)
-	if err != nil {
-		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
-		return
-	}
-	var startDate string
-
-	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
-	baseMap := make(map[int]*data_manage.EdbInfo)
-	for _, bv := range baseEdbInfoArr {
-		if _, ok := baseMap[bv.EdbInfoId]; !ok {
-			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
-		}
-		baseMap[bv.EdbInfoId] = bv
-	}
-
-	fmt.Println("calculateInfoArr:", len(calculateInfoArr))
-
-	newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
-	calculateMap := make(map[int]*data_manage.EdbInfo)
-	var calculateArr []int
-	for _, bv := range calculateInfoArr {
-		if _, ok := calculateMap[bv.EdbInfoId]; !ok {
-			newCalculateInfoArr = append(newCalculateInfoArr, bv)
-			calculateArr = append(calculateArr, bv.EdbInfoId)
-		}
-		calculateMap[bv.EdbInfoId] = bv
-	}
-	sort.Ints(calculateArr)
-	for _, bv := range newBaseEdbInfoArr {
-		source := bv.Source
-		edbInfoId := bv.EdbInfoId
-		edbCode := bv.EdbCode
-		startDate = bv.StartDate
-		sTime, err := time.Parse(utils.FormatDate, bv.EndDate)
-		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 = RefreshEdbDataByThs(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByThs Err:" + err.Error()
-			}
-		} else if source == utils.DATA_SOURCE_WIND {
-			endDate := time.Now().Format(utils.FormatDate)
-			err = RefreshEdbDataByWind(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByWind 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 = RefreshEdbDataByPb(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByPb 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.RefreshEdbDataByManual(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByManual 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.RefreshEdbDataByLz(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByLz 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 = "RefreshEdbDataByYs 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.RefreshEdbDataByGl(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByGl Err:" + err.Error()
-			}
-		}else if source == utils.DATA_SOURCE_LT {
-			endDate := time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshAllEdbDataByLt(edbInfoId, source, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshAllEdbDataByLT Err:" + err.Error()
-			}
-		}else if source == utils.DATA_SOURCE_COAL {
-			endDate := time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshEdbDataByCoal(edbInfoId, edbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshEdbDataByGl 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
-			}
-		}
-	}
-
-	for _, v := range calculateArr {
-		edbInfo := calculateMap[v]
-		if edbInfo == nil {
-			return err
-		}
-		edbInfoId := edbInfo.EdbInfoId
-		source := edbInfo.Source
-		edbCode := edbInfo.EdbCode
-
-		fmt.Println("source:", source)
-		fmt.Println("edbInfoId:", edbInfoId)
-
-		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)
-			}
-			fmt.Println("start RefreshCalculate")
-			endDate := ""
-			err = RefreshCalculate(edbInfoList, int(edbInfoId), 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
-			}
-			year := time.Now().Year()
-			startDate = strconv.Itoa(year) + "-01" + "-01"
-			endDate := ""
-			err = data_manage.RefreshCalculateLjzzy(edbInfoId, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateLjzzy 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 = time.Now().AddDate(-1, -2, 0).Format(utils.FormatDate)
-			endDate := "" // time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshCalculateTbz(edbInfoId, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateTbz 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 = time.Now().AddDate(-1, -2, 0).Format(utils.FormatDate)
-			endDate := "" //time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshCalculateTcz(edbInfoId, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateTcz Err:" + err.Error()
-				return err
-			}
-		} else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS { //N数值移动平均计算
-			fmt.Println("刷新计算指标:", edbInfoId)
-			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)
-			err = data_manage.RefreshCalculateNszydpjjs(edbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode)
-			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 = time.Now().AddDate(-1, -2, 0).Format(utils.FormatDate)
-			endDate := "" //time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshCalculateHbz(edbInfoId, edbInfo.Source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateHbz 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 = time.Now().AddDate(-1, -2, 0).Format(utils.FormatDate)
-			endDate := "" //time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshCalculateHcz(edbInfoId, edbInfo.Source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateHcz Err:" + err.Error()
-				return err
-			}
-		} else if source == utils.DATA_SOURCE_CALCULATE_BP { //刷新变频
-			calculateTbz, err := data_manage.GetEdbInfoCalculateBpDetail(edbInfoId)
-			if err != nil {
-				errmsg = "GetEdbInfoCalculateBpDetail Err:" + err.Error()
-				return err
-			}
-			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
-			if err != nil {
-				errmsg = "GetEdbInfoById Err:" + err.Error()
-				return err
-			}
-			startDate = time.Now().AddDate(-1, -2, 0).Format(utils.FormatDate)
-			endDate := "" //time.Now().Format(utils.FormatDate)
-			err = data_manage.RefreshCalculateBp(edbInfoId, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-			if err != nil {
-				errmsg = "RefreshCalculateBp Err:" + err.Error()
-				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
-			}
-		}
-	}
-	return err
-}
-
 func ChartInfoRefreshV1(chartInfoId int) (err error) {
 	var errmsg string
 	defer func() {
@@ -378,7 +77,7 @@ func ChartInfoRefreshV1(chartInfoId int) (err error) {
 				errmsg = "RefreshEdbDataByPb Err:" + err.Error()
 			}
 		} else if source == utils.DATA_SOURCE_MANUAL {
-			err = data_manage.RefreshAllEdbDataByManual(edbInfoId,bv.Source, edbCode)
+			err = data_manage.RefreshAllEdbDataByManual(edbInfoId, bv.Source, edbCode)
 			if err != nil {
 				errmsg = "RefreshEdbDataByManual Err:" + err.Error()
 			}
@@ -400,13 +99,13 @@ func ChartInfoRefreshV1(chartInfoId int) (err error) {
 			if err != nil {
 				errmsg = "RefreshEdbDataByGl Err:" + err.Error()
 			}
-		}else if source == utils.DATA_SOURCE_LT {
+		} else if source == utils.DATA_SOURCE_LT {
 			endDate := time.Now().Format(utils.FormatDate)
 			err = data_manage.RefreshAllEdbDataByLt(edbInfoId, source, edbCode, startDate, endDate)
 			if err != nil {
 				errmsg = "RefreshAllEdbDataByLT Err:" + err.Error()
 			}
-		}else if source == utils.DATA_SOURCE_COAL {
+		} else if source == utils.DATA_SOURCE_COAL {
 			endDate := time.Now().Format(utils.FormatDate)
 			err = data_manage.RefreshAllEdbDataByCoal(edbInfoId, source, edbCode, startDate, endDate)
 			if err != nil {